Virtual Pointer table

Virtual Pointer table : In c++ vtable is a mechanism to support runtime polymorphism.What it does is , it maintains addresses of , virtual functions defined in any class.

Need : consider a scenario in which you have one base class base and one derived class derived as below :

//Base class
class base
{
public:
 base() { }
 virtual void func(void) { std::cout<<"\n In Base func : "<<std::endl; }
 virtual void func1(void) { std::cout<<"\n In Base func1: "<<std::endl; }
 void func2(void) { std::cout<<"\n In Base func2: "<<std::endl; }
};

//derived class
class derived:public base
{
public:
 derived() { }
 void func2(void) { std::cout<<"\n In derived func2 : "<<std::endl; }
};

Note that func2 function in base class is not virtual

Now suppose i create two objects on heap like this :

base * b = new base;
base *d = new derived;

now i am inserting these objects in a vector of base class pointer types and sending to function print like this :

std::vector<base*> base_vec;  //vector of base class pointer types
base_vec.push_back(b);
base_vec.push_back(d);
print(base_vec);   // call function

And suppose my print function is implementated like :

void print(const std::vector<base *>& base_vec)
{
 for(int i = 0;i<base_vec.size();++i)
 {
  base_vec[i]->func2();
 }
}


Output generated after exucution of this function is :

In Base func2:

In Base func2:


But we were expecting that for second case , func2 of derived class should have been called , as we are pointing point d to derived object.

To overcome this , c++ provides concept of virtual functions. Virtual pointer table is maintained by the compiler to , keep track of virtual functions defined in any class . So that when  , those functions overriden in derived called , it should update a entry in virtual pointer table as well.


Now make , func2 in base class , virtual i.e : virtual void func2(void) { std::cout<<"\n In Base func2: "<<std::endl; }

Output generated will be :

In Base func2:

In derived func2 :

Implementation : So big question is how compiler implements this behaviour internally , how it come to know which function to call for , base class , and which one to call for derived class.

What it does is , it maintains a table of , addresses of virtual functions which is called  virtual pointer  table .Whenever any class have any virtual function it , creates virtual pointer table for it, and adds virtual pointer , that is pointer to this virtual pointer table as a first hidden member of it.

So if you will declare any virtual function in any class , like :

class base
{
public:
 base() { }
 int a;
 virtual void func(void) { std::cout<<"\n In Base func : "<<std::endl; }
}

And print it's size with sizeof operator ,it will be : 8 bytes , but if you willl remove virtual keyword , it will print 4 bytes.4 Extra bytes to hold pointer to virtual pointer table .

Note that it will always add 4 extra bytes only even if ,you declare more than one virtual functions inside class.

When you will override func function in derived class , virtual pointer table will update address of derived class function.So when it will be called with any base class pointer , appropriate function will be called .


Experiments : How can we convinced that any class with virtual function maintains virtual pointer table .

Do prove it , Consider original base class defination :

class base
{
public:
 base() { }
 virtual void func(void) { std::cout<<"\n In Base func : "<<std::endl; }
 virtual void func1(void) { std::cout<<"\n In Base func1: "<<std::endl; }
 void func2(void) { std::cout<<"\n In Base func2: "<<std::endl; }
};

It have two virtual functions func and func1 and one non-virtual function func2 .

Now i am creating one object of it on heap like this :

base * b = new base;

Now i am derefereencing the address of virtual pointer table like this :

int *ptr = (int*)b;

int *funcAdd = reinterpret_cast<int *>(*((int*)ptr+0));  //reinterpret_cast is used to cast out of any valid memory area

so , here funcAdd is base address of virtual pointer table .

Now since we will be accessing functions , i am declaring a fucntion pointer

void (*ptr_to_func) (void) ;

Now i have base address of virtual pointer table , i can enumerate all the virtual functions contained in it .

int i = 0;
 while(true)
 {
  ptr_to_func = (void (*) (void)) (*(funcAdd+i));
  if(ptr_to_func)
  {
   ptr_to_func();
   ++i;
  }
  else
   break;
 }


Output will be like this :


In Base func :

In Base func1:

Not however that it didn't printed func2 as it was not virtual .



Thats all :)


Full source code in c++:


#include <iostream>
#include <vector>

class base
{
public:
 base() { }

 virtual void func(void) { std::cout<<"\n In Base func : "<<std::endl; }

 virtual void func1(void) { std::cout<<"\n In Base func1: "<<std::endl; }

 void func2(void) { std::cout<<"\n In Base func2: "<<std::endl; }

};



class derived:public base
{

public:

 derived() { }

 void func2(void) { std::cout<<"\n In derived func2 : "<<std::endl; }

};



void print(const std::vector<base *>& base_vec)
{

 for(int i = 0;i<base_vec.size();++i)

 {

  base_vec[i]->func2();

 }

}



int main(void)
{

 base * b = new base;

 base *d = new derived;

 std::vector<base*> base_vec;

 base_vec.push_back(b);

 base_vec.push_back(d);

 //print(base_vec);

 int *ptr = (int*)b;
 int *funcAdd = reinterpret_cast<int *>(*((int*)ptr+0));
 void (*ptr_to_func) (void) ;
 int i = 0;

 while(true)

 {

  ptr_to_func = (void (*) (void)) (*(funcAdd+i));

  if(ptr_to_func)

  {

   ptr_to_func();

   ++i;

  }

  else

   break;

 }


 int halt;

 std::cin>>halt;
 return 0;

}