this is not a real pointer?

Question

I am reading something about virtual table. When it comes to pointer __vptr, it is stated that by the author

Unlike the *this pointer, which is actually a function parameter used by the compiler to resolve self-references, *__vptr is a real pointer. Consequently, it makes each class object allocated bigger by the size of one pointer.

What does it mean here by saying this is actually a function parameter? And this is not a real pointer?

The tutorial you linked to fully answers and explains your question. What specifically don't you understand? — Sam Estep, Jul 04 '15 at 13:40
@RedRoboHood Actually, I don't find it that clear in the tutorial, and I believe the question is correctly formulated. — Jerska, Jul 04 '15 at 13:44
The tutorial conveys dangerously misleading information. What is described is **one possible way** to implement virtual functions. This is neither defined in the C++ standard, nor is it necessarily implemented this way by any given implementation. Although V-tables are a common implementation, this is not strictly a requirement, and most certainly not part of the C++ language. — IInspectable, Jul 04 '15 at 13:44
The terminology in the tutorial is confusing. It is using dereferencing syntax on what it is calling a *pointer*. I would avoid tutorials and go for a *recommended* book: https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list — Galik, Jul 04 '15 at 13:54

score 7 · Accepted Answer · answered Jul 04 '15 at 13:43

7

Both pointers are real in the sense that they store an address of something else in memory. By "real" the author means "stored within the class", as opposed to this pointer, which is passed to member functions without being stored in the object itself. Essentially, the pointer to __vptr is part of the object, while this pointer is not.

answered Jul 04 '15 at 13:43

Sergey Kalinichenko

714,442
84
1,110
1,523

1

Where `this` is stored then? – Allanqunzi Jul 04 '15 at 13:48
7

@Allanqunzi Like any other function parameter, pointer `this` is transient, it is not necessarily stored at all. When you invoke a member function, the compiled code takes the address of the object on which you call the function, and passes that address as `this` pointer to the member function. Once the member function has finished, the `this` pointer is gone. – Sergey Kalinichenko Jul 04 '15 at 13:51
@dasblinkenlight "transient pointer". Now *that*'s cool vocabulary :p – Quentin Jul 04 '15 at 14:08

score 3 · Answer 2 · edited May 23 '17 at 12:25

this is always a hidden implicit formal argument. Practically speaking, every non static member function of a class is getting an implicit first argument which is this

so in

class Foo {
  int x; // a field, i.e. an instance variable
  void bar(double x);
};

the Foo::bar function has two arguments, exactly as if it was the C (not C++) function

void Foo__bar(Foo* mythis, double x);

And actually, name mangling and the compiler is transforming the first into a very close equivalent of the second. (I am using mythis instead of this because this is a keyword in C++).

In principle, the ABI of your implementation could mandate a different passing convention for this (e.g. use another machine register) and for other explicit arguments. In practice, it often does not. On my Linux system the x86-64 ABI (its figure 3.4 page 21) defines a calling convention that passes this (and first pointer formal argument to C function) in %rdi processor register.

Practically speaking, in C++, most -but not all- member functions are small (defined inside the class) and inlined by the optimizing compiler (and the latest C++11 and C++14 standards have been written with optimizing compilers in mind; see also this). In that case, the question of where is this stored becomes practically meaningless... (because of the inlining).

The virtual method table (vtable) is generally an implicit first pointer field (or instance variable) of objects, but things could become more complex, e.g. with virtual multiple inheritance. the vtable data itself (the addresses of virtual functions) is generated by the compiler. See also this answer.

In theory, a C++ implementation could provide the dynamic method dispatching by another mechanism than vtable. In practice, I know no C++ implementation doing that.

this is not a real pointer?

2 Answers2

Linked