Technical Stuff

In C++ for implementing virtual functions , compiler uses Virtual table or simply Vtable. This is also called virtual function table or virtual method table. Lets see what is it and how it works.

As you know virtual functions are used for run time binding or function overriding. If a class contains a virtual function, you will get one virtual table for that class. This applies for derived classes also. So for each class which contains atleast one virtual function, we will be having corresponding Vtable. Compiler create this Vtable at the time of compilation. Vtable is a static array which contians one entry for each virtual fucntion that can be called by object. Each entry in the Vtable is a function pointer to the "most derived" function.

The compiler will also add hidden pointer called *_vptr to the Vtable for the base class. *_vptr will be inherited to the derived class Vtable also. *_vptr pointer adds to the Vtable automatically when instance is creatd. See the below sample code snippet and image for more clarity.

class vtBase
{
 public:
 virtual void display()
 {
 cout<<"this is dispaly function"<<endl;
 }
 virtual void displayMore()
 {
 cout<<"this is dispalyMore function"<<endl;
 }
};
class derivedD:public vtBase
{
 public:
 void display() // display function overriding
 {
 cout<<"this is derived display function"<<endl;
 }
};
class derivedDD:public vtBase
{
 public:
 void displayMore() //displayMore function overriding
 {
 cout<<"this is derived displayMore function"<<endl;
 }
};

In the above code there is base claass vtBase with two virtual functions display() and displayMore(). There are two derived classes in which derivedD is override the function display() with new definition and derivedDD is overrdes the definition for displayMore(). The corresponding Vtable is given below.

In the above Vtable, base class *_vptr is pointing to the base class vtBase table and its member functions are function pointers to the base class. And derived class *_vptr are pointing to the derived calls Vtable pointer. And in derived class derivedD , you will have two member functions derived from base class, in that one member function display() is overrides with new definition. So its "pointer pointing to the derived member" function and displayMore function "pointer points to the base class" pointer. Similarly for the derived classe derivedDD, but here displayMore() is overrides with new definition. So this function pointer points to derived class and display() function pointer points to the base class.

what happens when object creation:

main()
{
 derivedD D; // creating derived object
 vtBase *bPtr=&D; // assining to base pointer
 bPtr->display();
}

Output:
this is derived display function

In the above main fucntion, in line no. 5, by seeing this, compiler finds display() is virtual function, and then it gets vPtr->display() value as derivedD virtual table from there it looks for the display() function pointer. all this happens in three steps

• finding function as virtual
• calling _vptr for getting Vtable address
• finding the pointer for the function

Labels: CPP