Where in memory is vtable stored?

Question

Where in memory is vtable stored?

Answer 1

Depends on compiler.

In VC++, the vtable pointer stored at the beginning of the object allocation, before any member data. (Provided your class has at least one virtual member function.)

There also may be multiple vtable pointers, if your class multiply-inherits from other classes with vtables.

The vtables themselves are statically allocated somewhere in your address space.

Then the object layout looks like (for an instance of C):

A's VTable ptr
A's member variables.
B's Vtable ptr
B's member variables.
C's member variables.

for the heirarchy

class A {
  virtual Ax() {}
  int a, b;
};
class B {
  virtual Bx() {}
  int c, d;
};
class C : public A, public B {
  int foo, bar;
};

Answer 2

Vtable? What vtable? The C++ standard doesn't mention a vtable. Each compiler can implement virtual functions any way it likes. And that includes placing the vtable anywhere it likes.

Answer 3

For VC++

Answer 4

The vptr commonly at the beginning of the object (Imperfect C++, Backyard Hotrodding C++) but that's not guaranteed in the standard. Using vptrs and vtables isn't guaranteed in the standard.

If you really need to know where it is, it's common to use something like COM, XPCOM, UNO, etc. that are implemented by essentially coming up with a set place where something like a vptr is located and set ways to use them.

Answer 5

Every instance that include virtual function has virtual function pointer which point to the virtual function table(vbtl), we only could locate the vtbl through the instance. or you can use the objdump to read the symbol of the ELF file, maybe you can find the answer. I hope The following example can hep you.

#include <iostream>
#include <stdio.h>
typedef void (*fun_pointer)(void);

using namespace std;
class Test
{
 public:
   Test()
    {
     cout<<"Test()."<<endl;
    }
   virtual void print()
    {
     cout<<"Test::Virtual void print()."<<endl;
    }
   virtual void print2()
    {
     cout<<"Test::virtual void print2()."<<endl;
    }
};

class TestDrived:public Test
{
 public:
  TestDrived()
    {
    cout<<"TestDrived()."<<endl;
    }
  virtual void print()
    {
    cout<<"TestDrived::virtual void print()."<<endl;
    }
  virtual void print2()
    {
    cout<<"TestDrived::virtual void print2()."<<endl;
    }
  void GetVtblAddress()
    {
        cout<<"vtbl address:"<<(int*)this<<endl;
    }
  void GetFirstVtblFunctionAddress()
    {
    cout<<"First vbtl function address:"<<(int*)*(int*)this+0 << endl;
    }
  void GetSecondVtblFunctionAddress()
    {
    cout<<"Second vbtl function address:"<<(int*)*(int*)this+1 << endl;
    }
  void CallFirstVtblFunction()
    {
    fun = (fun_pointer)* ( (int*) *(int*)this+0 );
    cout<<"CallFirstVbtlFunction:"<<endl;
    fun();
    }
  void CallSecondVtblFunction()
    {
    fun = (fun_pointer)* ( (int*) *(int*)this+1 );
    cout<<"CallSecondVbtlFunction:"<<endl;
    fun();
    }
private:
    fun_pointer fun;
};



int main()
{
 cout<<"sizeof(int):"<<sizeof(int)<<"sizeof(int*)"<<sizeof(int*)<<endl;
 fun_pointer fun = NULL;
 TestDrived a;
 a.GetVtblAddress();
 a.GetFirstVtblFunctionAddress();
 a.GetSecondVtblFunctionAddress();
 a.CallFirstVtblFunction();
 a.CallSecondVtblFunction();
 return 0;
}

Answer 6

Vptr and Vtable get stored in Data Segment...

Vtable is like an array of function pointer.

Vtable and Vptr is creating at compile time which will get memory in run time and vtable entries are virtual function addresses .

Every object of a class containing a virtual function will have an extra pointer which is pointing to Virtual Table is known as virtual pointer.

whenever we call a virtual function using object, first the corrosponding Vptr will read the function from Vtable at run time and finally the function will be called.