Explain the Output

[kberson]

This is a dumb question, going back to the basics, but I want to understand the "why" of it, so I'm posting it anyway.

Given the following code:

#include <iostream>

using namespace std;

class A
{
public:
	virtual void print() { cout<< "A.Print\n"; }
	A() { cout <<"Constructor of A.\n"; }
};

class B : public A
{
public:
	void print() { cout << "B.print\n"; }
	B() { cout <<"Constructor of B.\n"; }
};

int _tmain(int argc, _TCHAR* argv[])
{
	B *b = new B();  // ??
	reinterpret_cast<A *>(b)->print();
	return 0;
}

The output of which is:


Constructor of A.
Constructor of B.
B.print


My question is: How? How does the base-class know to call the derived class' print method? My mind is saying that the logic is "we've cast to class A" and class A knows nothing of class B, and yet the print method in class B is still being called.

Is it going to the virtual function table even though we're class A? That's the only thing I can conclude.

[MrViggy]

Yes it is. By declaring the print function virtual in 'A', when you create a 'B' the compiler knows that it should call 'B's print no matter what you cast the pointer to.

In the context of v-tables, when the compiler defines an A, it puts the address for A:: print in it. Then, when it defines 'B', it overwrites the address of A:: print with B:: print in B's definition.

Viggy

[kempofighter]

Is it going to the virtual function table even though we're class A? That's the only thing I can conclude.

Yes, that is the whole point of a virtual function. You need to read about dynamic run-time binding and design patterns such as the bridge abstract factory patterns for starters. It is really important to know why this behavior exists so that you can understand some basic design patterns. This is really critical for any C++ developer to know. There are many times where you want to hide dependencies on implementation classes in order to separate interface from implementation so that they can vary independently.