在哪里放置这个指针，并在为它分配内存时？

Question

Why pointer to the virtual function table affects the size of the class , but this pointer does not affect the size of the class ? where is placed the this pointer and when memory is allocated for it?

Answer 1

It is passed as an implicit parameter and therefore it is not stored inside of the object. When you write:

struct X
{
    void f( int i );
};

X x;
x.f( 42 );

You can think of it like this:

void f( X* const this, int i ); // of course this would be illegal as "this" is a keyword

f( &x, 42 );

So the this -pointer is coming from where the method is called.

Answer 2

The pointer to the virtual function table is stored in the object, but this is actually a hidden parameter of member functions. In effect, when you have this:

class X
{
  void foo(int bar) const;
};

int main()
{
  X x;
  x.foo(7);
}

Then the compiler will implicitly transform it to something like this (pseudo-code):

class X
{
  static void foo(const X * const this, int bar);
};

int main()
{
  X x;
  X::foo(&x, 7);
}

Note that I am only showing the pseudo-code for illustration purposes. You can conceptually imagine it like that, but it's not what is actually happening.

Answer 3

this pointer is implicitly placed on the stack (it's like an argument to the method). So when you call obj->foo() you're implicitly passing obj into method foo. The compiler gives you access to that argument through this .

In general there can't be a need to store this pointer inside the object anyway. It would be redundant (ie if you could get hold of the object its address is already available to you).

vTable however is a different story. Which vtable an object points to can't be known at compile time and there's no separate implicit argument either. This requires dedicated space in the object itself.

Answer 4

就像'this'指针一样，vptr依赖于一个实例而不是类。

Answer 5

Nowhere. The this pointer isn't an lvalue, and doesn't occupy memory as such. It's sort of like asking where the results of x + y reside (where x and y are int ). Depending on the implementation, where it will really reside will vary: VC++, for example, tends to keep it in the register ECX (although this may vary when optimization is used); Sun CC for Sparc puts it in the register i0 , etc. It's not a member, even implicit, of the class. It's probably best thought of as an argument to the function, although many compilers will treat it special, and unlike normal arguments, it's not an lvalue.