“该”指针如何巧合指向不同的对象？

| 假设我有一堂课：

class test {
public:
   void print();
private:
   int x;
};

void test::print()  
{  
    cout<< this->x;  
}

我有这些变量定义：

test object1;
test object2;

当我呼叫object1.print()时，this碰巧存储了object1的地址，所以我从object1打印中得到了x，当我呼叫object2.print()时，this碰巧存储了地址object2，而我从object2得到了get5ѭ。它是怎么发生的？

已邀请:

5 个回复

苦诫

每个非静态成员函数都有一个隐式的隐藏“当前对象”参数，作为“ 3”指针向您公开。所以你可以认为

test::print();

有一些

test_print( test* this );

全局函数，所以当你写

objectX.print();

在您的代码中，编译器将插入对

test_print(&objectX);

这样，成员函数就可以知道“当前”对象的地址。

呈辖玫割善

您可以认为“ 3”指针是函数的隐式参数。想象一下像

class C {
public:
  C( int x ) : m_x( x ) { }

  void increment( int value ) {
    m_x += value; // same as \'this->m_x += value\'
  }

  int multiply( int times ) const {
    return m_x * times; // same as \'return this->m_x * times;\'
  }

private:
  int m_x;
};

这使您可以编写类似

C two( 2 );
two.increment( 2 );
int result = two.multiply( 3 );

现在，实际上发生的是，使用额外的指针参数调用成员函数increment和multiply，它们指向在其上调用该函数的对象。该指针在方法内部称为“ 3”。 the3ѭ指针的类型不同，这取决于该方法是否为const（如multiply）（与（20ѭ一样）。您也可以自己做类似的事情，请考虑：

class C {
public:
  C( int x ) : m_x( x ) { }

  void increment( C * const that, int value ) {
    that->m_x += value;
  }

  int multiply( C const * const that, int times ) const {
    return that->m_x * times;
  }

private:
  int m_x;
};

你可以这样写代码

C two( 2 );
two.increment( &two, 2 );
int result = two.multiply( &two, 3 );

注意，对于multiply函数，this指针的类型为C const * const，因此指针本身为const，而且指向的对象也是！这就是为什么您不能在const方法内更改成员变量的原因-this指针的类型禁止使用该变量。可以使用mutable关键字解决此问题（我不想过分跟踪，所以我宁愿不解释它的工作原理），甚至可以使用const_cast来解决：

int C::multiply( int times ) const {
  C * const that = const_cast<C * const>( this );
  that->m_x = 0; // evil! Can modify member variable because const\'ness was casted away
  // ..
}

我之所以要提到它，是因为它表明this并不像它看起来的那样特殊，并且这种特殊的hack通常比制作成员变量mutable更好，因为此hack是一个函数的局部变量，而mutable则使对于该类的所有“ 24”方法可变的变量。