Virtual Function Table

I suspect in this case the compiler will be clever enough to detect that no* VFT is actually required:

1. the base class never* needs one as it will always use it's own methods.*
2. The derived class doesn't override any virtual function, so doesn't need a VFT either.*(see below)

If you added an override in derived, only then a VFT for class derived would have to be added. Also, any instance created of this class will require additional memory for a pointer to the VFT (then again, if you use run-time type information or program in managed C++, there may already be a pointer to class-related information, so you may not notice a difference in memory consumption)

*P.S. - a correction:
The class derived must have a virtual function table! The reason is that if in another compilation unit, or even another library, a class derived2 is derived from derived and overrides xyz() virtually, then any code accessing an object through a pointer of type derived* will have to decide at runtime what class this object really is, and whether the version in base, or another has to be called.

So, what Emilio posted is correct. I wasn't even aware of the possibility of sharing a vtable, but it makes sense.

The way a C++ compiler implements the dynamic method dispatching is ... implementation dependent, and can even be not base on the concept of v-tables.

What the C++ specs says is that:
* all methods are inherited
* every method can be overridden
* the override of a virtual method is virtual
* an implicit or -indirect call to a virtual method always result in a call the most derived override.

How the compiler does this is not a problem for a C++ programmer, but for the compiler developer.

The use of V-tables is just a very common technique. If this is adopted, in your case, since your derived has a virtual method (it inherits that from base) it must have a vtable pointer (just like base has).

Note that the objects don't have vtables, but just a pointers that point to a vtable that is shared among all the object of the same type.

But since you derived adds nothing to base, a compiler can optimize making both sharing a same vtable, and since no overrides are defined for xyz, a further compiler optimization may be to make that function non virtual at all.

In any case you shouldn't care. Whether a vtable is required, the compiler will generate it and all the class instances will have a vtable pointer.