virtual function and modified this pointer - c++

Question

Consider the following code
class B1 {
public:
void f0() {}
virtual void f1() {}
int int_in_b1;
};
class B2 {
public:
virtual void f2() {}
int int_in_b2;
};
class D : public B1, public B2 {
public:
void d() {}
void f2() {int temp=int_in_b1;} // override B2::f2()
int int_in_d;
};
and the following memory layout for the object d:
d:
+0: pointer to virtual method table of D (for B1)
+4: value of int_in_b1
+8: pointer to virtual method table of D (for B2)
+12: value of int_in_b2
+16: value of int_in_d
Total size: 20 Bytes.
virtual method table of D (for B1):
+0: B1::f1() // B1::f1() is not overridden
virtual method table of D (for B2):
+0: D::f2() // B2::f2() is overridden by D::f2()
D *d = new D();
d->f2();
When d->f2(); is invoked, D::f2 needs access to data from B1, but modified this pointer
(*(*(d[+8]/*pointer to virtual method table of D (for B2)*/)[0]))(d+8) /* Call d->f2() */
is passed to D::f2, then how is D::f2 able to access it?
The code is taken(and modified) from :https://en.wikipedia.org/wiki/Virtual_method_table#Multiple_inheritance_and_thunks

Answer 1

Your case is actually too simple: The compiler can know that you have a pointer to a D object, so it can perform the lookup from the right table, passing the unmodified this pointer to the f2() implementation.
The interesting case is, when you have a pointer to B2:
B2* myD = new D();
myD->f2();
Now we start with an adjusted base pointer, and need to find the this pointer for the whole object. One way to achieve that would be to store an offset alongside the function pointer that is used to produce a valid this pointer from the B2 pointer used to access the vtable.
Thus, in your case, the code might implicitly be compiled like this
D* myD = new D();
((B2*)myD)->f2();
adjusting the pointer two times (once deriving the B2* from the D*, then the inverse using the offset from the vtable). Your compiler may be clever enough to avoid this, though.
In any case, this is firmly within the field of implementation. Your compiler can do anything, as long as it behaves the way the standard specifies.

Answer 2

Firstly, the effect you are describing as "modifying a this pointer" is an implementation detail of some particular compiler. There is no specific requirement that a compiler modify pointers like you describe.
There is also no requirement that an object have vtables, let alone that they are laid out like you describe. The actual requirement is that the correct overload of a virtual function will be called at run time, and that it will be able to correctly access data members and call member functions. Now, in practice, compilers tend to use vtables, but that is an implementation detail because alternatives are less efficient by various measures.
Now, that said, the following discussion will assume every class with a virtual function has a vtable. Looking at your example, what does this do?
D *d = new D();
d->f2();
The first thing is that the compiler knows that d is a pointer to D, and knows that D has a function named f2(). It will also know that f2() is a virtual function inherited from B2 (which is one reason that it is not possible to call a class member function unless the compiler has visibility of the complete class definition).
In this case, we know what d and D are, so we know D::f2() should be called, with the this pointer equal in value to d. The compiler has the same information (it knows d is a D *) so it just does that. Now, okay, it might or might not look up D::f2() in the vtable, but that is the end of it.
The more interesting example, like cmaster said, is
B2* myD = new D();
myD->f2();
In this case, myD is a pointer to B2. The compiler knows that B2 has a virtual function named f2(), so knows it has to call the correct overload.
The thing is, in the statement myD->f2(), the compiler might not know that myD actually points to a D (e.g. the construction of the object and the calling of the member function might be in different functions, in different compilation units). However, it does know that a B2 has a virtual function named f2(), which is required to call the actual overloaded version correctly.
This means the compiler needs two bits of information. Firstly it needs information identifying the actual function (D::f2()) to be called. The second bit of information will be some adjustment of myD to make the call of D::f2() work correctly. This second bit of information is essentially what is needed to produce (what you are calling) the "modified this pointer" from myD.
If the compiler does all this with the help of vtables, it might include BOTH bits of information in the vtable for B2. So (assuming the second bit of information is an offset) the compiler turns
myD->f2();
into something like
(myD + myD->vtable->offset_for_f2)->(myD->vtable->entry_for_f2)();
The part (myD + myD->vtable->offset_for_f2) is essentially what you are describing as "the modified this pointer" which D::f2() will see when called. The part (myD->vtable->entry_for_f2) is essentially the address of D::f2() (say the address of the member function).
The next question to ask is how might the compiler populate the vtable? The short answer is that it does this when constructing the object.
B2* myD = new D();
The new expression (new D()) essentially expands to
void *temp = ::operator new(sizeof (D)); // assuming class does not supply its own operator new
// construct a `D` in the memory pointed to by temp
temp = (D *)myD; // the compiler knows we're creating a D, so doesn't use offsets or anything funky here
The process of turning the memory pointed to be temp into a D is the important thing. Firstly, it invokes constructors of base classes (B2 and B2), then constructs or initialises Ds members, then it invokes D's constructor (the C++ standard actually describes the order of events in exquisite detail). The other thing is that the compiler does bookkeeping to ensure we actually get a valid D from the process. Part of that is populating the vtable.
Now, since the compiler has complete visibility of the definition of class D (i.e. complete definition of base classes, its members, etc), it has all the information needed to populate the vtable. In other words, it has all the information it needs to give sensible values to both myD->vtable->offset_for_f2 and myD->vtable->entry_for_f2
In the case of multiple inheritence, assuming one vtable per base class, the compiler has all the information it needs to populate all the vtables in a similar way. In other words, the compiler knows how it lays out objects in memory, including their vtables, and uses that knowledge appropriately.
But, then again, it might not. As I said, vtables is a technique commonly used in compilers to implement/support virtual function dispatch. There are other ways too.

Answer 3

again i can't comment so must answer here.
is no problem in the code!
D::f2 needs access to data from B1
then how is D::f2 able to access it?
just write in D::f2, B1::int_in_b1 then you ca access to int value.

Answer 4

In your example, when d->f2() is called, compiler knows that d is a pointer to class D. To call f2(), it would adjust the pointer of d to be "this" of B2 before passing it to virtual f2(), as you describe. Now, inside of the D::f2(), the compiler knows that this is D::f2() and it knows how D inherits from B2, and so it fixes the "this" of B2 to be "this" of D in the very beginning of the function, so when your code executes it would see that "this" is that of D. Therefore it can access any members of D inside of D::f2().
If you would have had
B2* b = d;
b->f2();
When b->f2() is called, the pointer being passed to f2() is "this" of B2. Inside D::f2(), the passed pointer is fixed to point to this of D.