C++虚继承的内存结构

我用vc2003观测到的实际情况是。在类中增加一个指针(VBPTR)指向一个VBTBL，这个VBTBL的第一项记载的是从VBPTR 与本类的偏移地址，如果本类有虚函数，那么第一项是FF FF FF FC(也就是-4)，如果没有则是零，第二项起是VBPTR与本类的虚基类的偏移值。vc2003的这种方案个人觉得没有Bjarne的好，一是要多一个指针，二是因为VBPTR与虚函数表分开设计，也不便于修改。至于其它编译器，因为我跟其它编译器不熟，所以也就没有实测它们。

下面给出对于类定义

struct B1

{

    int a;

    int b;

};

struct B2

{

    virtual void foo(void);

    int c;

    int d;

};

 

struct Test : virtual public B1, virtual public B2

{

    virtual void func1(void);

    virtual void func2(void);

    virtual void func3(void);

    int X;

};

一个Test 对象的内存布局图，我们可以清楚的看到在VS2003中VBPTR以及VBTBL的结构以及其相关的内容是什么意义。以及Bjarne的方案的优点。

 

 

最后我们来看一个完整的例子以及内存结构布局。图后有相关代码。

 

 

代码如下：

struct A

{

    A(int v=100):X(v){};

    virtual void foo(void){}

    int X;

};

 

struct B :virtualpublic A

{

    B(int v=10):Y(v),A(100){};

    virtual void fooB(void){}

    int Y;

};

 

struct C : virtual public A

{

    C(int v=20):Z(v),A(100){}

    virtual void fooC(void){}

    int Z;

};

 

 

struct D : public B, public C

{

    D(int v =40):B(10),C(20),A(100),L(v){}

    virtual void fooD(void){}

    int L;

};

 

 

int _tmain(int argc, _TCHAR* argv[])

{

   

    A a;

    int *ptr;

    ptr = (int*)&a;

    cout << ptr << " sizeof = " << sizeof(a) <<endl;

    for(int i=0;i<sizeof(A)/sizeof(int);i++)

    {

        if(ptr[i] < 10000)

        {

             cout << dec << ptr[i]<<endl;

        }

        else cout << hex << ptr[i] <<" = " << hex << * ((int*)(ptr[i])) <<endl;

    }

 

    cout << "--------------------------------------" <<endl;

 

    B b;

    ptr = (int*)&b;

    cout <<"addr:" << ptr << " sizeof = " << sizeof(b) <<endl;

    for(int i=0;i<sizeof(B)/sizeof(int);i++)

    {

        if(ptr[i] < 10000)

        {

             cout << dec << ptr[i]<<endl;

        }

        else cout << hex << ptr[i] <<" = " << hex << * ((int*)(ptr[i])) <<endl;

    }

 

    cout << "--------------------------------------" <<endl;

   

    D d;

    ptr = (int*)&d;

    cout <<"addr:" << ptr << " sizeof = " << sizeof(d) <<endl;

    for(int i=0;i<sizeof(D)/sizeof(int);i++)

    {

        if(ptr[i] < 10000)

        {

             cout << dec << ptr[i]<<endl;

        }

        else cout << hex << ptr[i] <<" = " << hex << * ((int*)(ptr[i])) <<endl;

    }

    return 0;

}

 

 

 

另外看的一篇文章也很有启发性，大致内存结构也与上同

最近在研究虚继承，对带有虚函数的虚拟继承的内存布局有些疑惑，求大神指点，最好带图的，谢谢！

例如下面的代码：

   

        
        
class A            
{ 
    public: 
        A(){cout << "A called"<< endl;} 
 
        virtual void print(){cout << "A print" <<endl;} 
    
}; 
  
class B :public virtual A 
{ 
    public: 
        B(){cout << "B called" << endl;} 
 
        void print(){cout << "B print" << endl;}          
};

 

单个的虚继承没有意义，而且它的布局和普通的单继承完全一样。
虚继承主要用于多继承中的菱形继承，举例如下：

   

       
       
class Top 
{ 
    public: 
        int a; 
}; 
 
class Left : virtual public Top 
{ 
    public: 
        int b; 
}; 
 
class Right : virtual public Top 
{ 
    public: 
        int c; 
}; 
 
class Bottom : public Left, public Right 
{ 
    public: 
        int d; 
};

它的继承关系图如下：

可以得出 Bottom 的内存结构可能是这样子的。

从图中可以看出，Top 中的数据只保存了一份，也就是说，虚拟继承其实就是共享数据的意思。
但是虚继承的内存结构实际上没有这么简单，它应该是这样子的：

上图有两点值得大家注意。第一点就是类中成员分布顺序是完全不一样的(实际上可以说是正好相反)。第二点，类中增加了vptr指针，这些是被编译器在编译过程中插入到类中的(在设计类时如果使用了虚继承，虚函数都会产生相关vptr)。同时，在类的构造函数中会对相关指针做初始化，这些也是编译器完成的工作。Vptr指针指向了一个“virtual table”。在类中每个虚基类都会存在与之对应的一个vptr指针。

 

我对虚继承、普通继承中虚函数的内存放置总结成几句话：

1、虚继承时子与基需分开。子在前，基在后。（子类的虚函数与积累的虚函数需要分开，不可覆盖）

2、普通继承时，基在前，子在后。如果是多重继承，则顺序是基1-基2-最子类-最基类（子类的虚函数如果和基类相同，会覆盖子类的虚函数）