Virtual Table C++

Question

I read a lot of people writing "a virtual table exists for a class that has a virtual function declared in it".

My question is, does a vtable exists only for a class that has a virtual function or does it also exist for classes derived from that class.

e.g

class Base{
    public:
        virtual void print(){cout<<"Base Print\n";}
};
class Derived:public Base{
    public:
        void print(){cout<<"Derived print\n";}
};

//From main.cpp 
Base* b = new Derived;
b->print();

Question: Had there been no vtable for class derived then the output would not have been "derived print". So IMO there exists a vtable for any class that has virtual function declared and also in classes inheriting from that class. Is this correct ?

Answer 1

Yes, that's true. A class inherits all data members from its base class, including the vtable. However, vtable entries are adjusted accordingly (for example if the class overrides a base class virtual method, the corresponding entry in the vtable must point to its own implementation).

But keep in mind that the concept of a 'vtable' is common practice used by vitually every compiler, but it is not compulsory nor standardized.

Answer 2

Yes, your understanding is correct. Any class that has a base with any virtual functions has a vtable.

Answer 3

Yes it's true. Actually, given base's defintion:

class derived:public base{
public:
 void print(){cout<<"derived print\n";}
};

is completely equivalent to:

class derived:public base{
public:
 virtual void print(){cout<<"derived print\n";}
};

... because you already defined print as virtual in base.

I'd wish the compiler would enforce that...

Answer 4

As far as only virtual-function-specific functionality is considered, in a traditional approach to vtable implementation derived class would only need a separate version of vtable if that derived class overrides at least one virtual function. In your example, Derived overrides virtual function print. Since Derived has it own version of print, the corresponding entry in Derived vtable is different from that in Base vtable. This would normally necessitate a separate vtable for Derived.

If Derived didn't override anything at all, formally it still would be a separate polymorphic class, but in order to make its virtual functions work properly we could have simply reused Base vtable for Derived as well. So, technically there wouldn't be any need for a separate vtable for Derived.

However, in practical implementations, the data structure that we usually refer to as "vtable", often holds some additional class-specific information as well. That extra information is so class-specific that most of the time it becomes impossible to share vtables between different classes in hierarchy, even if they use the same set of virtual functions. For example, some implementations the vtable pointer stored in each polymorphic object points to data structure that also stores so called "RTTI information" about the class. For this reason, in most (if not all) practical implementations each polymorphic class gets its own vtable, even if the virtual function pointers stored in those tables happen be the same.