Where can I find a good explanation of C++ stateful virtual base?

Question

Where can I find a good explanation of C++ stateful virtual base?

I looked in the JSF C++ Coding Standard and read their explanation, but was looking for some additional information.

Thank you for any additional details provided.

Answer 1

Stanley Lippman's book "Inside the C++ Object Model" has a great run-through of the subject (though dated, but still valid).

Answer 2

Virtuality is about indirection. Let's start simple:

struct Foo { void bar(int, bool) {} } x;
x.bar(12, false);

Here the call to Foo::bar() for the instance x is fully known at compile time and resolved statically: One fixed function which is given the instance reference and the function arguments. Function name, call, done. No problem so far.

Moving on:

struct Boo { virtual void bar(char, float) = 0; };
extern Boo * foreign_function();

Boo * p = foreign_function();
p->bar('a', -1.5);

This time, there is no way to know at compile time where the bar() call is supposed to go. The only way to resolve this is to add a level of indirection that allows you to look up all possible overrides of this member function and pick the correct one at runtime, depending on the dynamic type of *p. This time we start with the function name, perform the lookup at runtime, and then make the call. This pattern should still be fairly familiar.

The point here is that it is enough to know that the dynamic type of *p is a subtype of the (non-virtual) base Boo so that we can implement this with just one single lookup (e.g. a vtable pointer to a table that's compatible with that of Boo).

Now on to the big fish:

struct Voo { virtual void doo(double, void *) = 0; };
struct Left  : virtual Voo { virtual void doo(double, void *); } };
struct Right : virtual Voo { virtual void doo(double, void *); } };
struct Most : Left, Right  { virtual void doo(double, void *); } };

Left * p = /* address of a Most object, say */;
p->doo(0.1, nullptr);

We already know that we don't know where doo() is supposed to go, and we have to look it up at runtime. However, a simple one-step indirection is no longer possible. Even though Left is a subclass of Voo and Right also is a subclass of Voo, the actual Voo base subobject of *p is not actually a subobject of the Left- or of the Right-subobject -- the (unique!) virtual subobject belongs to Most directly (or whatever the most-derived object is). In implementation terms, a single vtable pointer is no good, because we don't want Left's vpointer, nor do we want Right's vptr. Instead, we want whichever vpointer the actual object has.

So now we find ourselves in a familiar situation: We need to look something up that we can only know at runtime. And this time the thing we need to look up is the actual virtual base. So the process goes like this: Function name, look up virtual base at runtime, look up virtual function in virtual base, and make the call. (In the typical vtable implementation of virtuality, this is usually done with an extra piece of lookup via a "thunk", or a "pointer to a pointer".)

In a nutshell, "virtual" means "determined at runtime".

(That does not force your compiler to generate runtime code. If the target of the dispatch is provably known at compile time, the call may be devirtualized. But the behaviour of your program is "as if".)