C++中派生类对象的内存布局

本文有更新，请移步我的个人博客：https://blog.andyqiao.top/article/18/

主要从三个方面来讲：

　　1 单一继承

　　2 多重继承

　　3 虚拟继承

1 单一继承

（1）派生类完全拥有基类的内存布局，并保证其完整性。

　　派生类可以看作是完整的基类的Object再加上派生类自己的Object。如果基类中没有虚成员函数，那么派生类与具有相同功能的非派生类将不带来任何性能上的差异。另外，一定要保证基类的完整性。实际内存布局由编译器自己决定，VS里，把虚指针放在最前边，接着是基类的Object，最后是派生类自己的object。举个栗子：

class A
{
    int b;
    char c;
};
class A1 :public A
{
        char a;
};
int main()
{
    cout << sizeof(A) << " " << sizeof(A1) << endl;
    return ;
}

　　输出是什么？

　　答案：

　　　　8 12

　　A类的话，一个int，一个char，5B，内存对齐一下，8B。A1的话，一个int，两个char，内存对齐一下，也是8B。不对吗？

　　我说了，要保证基类对象的完整性。那么一定要保证A1类前面的几个字节一定要与A类完全一样。也就是说，A类作为内存补齐的3个字节也是要出现在A1里面的。也就是说，A类是这样的：int(4B)+char(1B)+padding(3B)=8B，A1类：int(4B)+char(1B)+padding(3B)+char(1B)+padding(3B)=12B。

（2）虚指针怎么处理？

　　还是视编译器而定，VS是永远把vptr放在对象的最前边。如果基类中含有虚函数，那么处理情况与上边一样。可是，如果基类中没有虚函数而派生类有的话，那么如果把vptr放在派生类的前边的话，将会导致派生类中基类成分并不在最前边。这将带来什么问题呢？举栗：假设A不含虚，而A1含。

A *pA;
A1 obj_A1;
pA=&obj_A1;

　　如果A1完全包含A并且A位于A1的最前边，那么编译器只需要把&obj_A1直接赋给pA就可以了。如果不是呢？编译器就需要把&obj_A1+sizeof(vptr)赋给pA了。

2 多重继承

　　说结论：VS的内存布局是按照声明顺序排列内存。再举个栗子：

class point2d
{
public:
    virtual ~point2d(){};
    float x;
    float y;
};
class point3d :public point2d
{
    ~point3d(){};
    float z;
};
class vertex
{
public:
    virtual ~vertex(){};
    vertex* next;
};
class vertex3d :public point3d, public vertex
{
    float bulabula;
};

int _tmain(int argc, _TCHAR* argv[])
{
    cout << sizeof(point2d) << " " << sizeof(point3d) << " " << sizeof(vertex) << " " << sizeof(vertex3d) << endl;
    return ;
}

　　输出： 12 16 8 24。

　　内存布局：

　　　　point2d: vptr(4)+x(4)+y(4)=12B

　　　　point3d: vptr+x+y+z=16B

　　　　vertex: vptr+next=8B

　　　　vertex3d: vptr+x+y+z+vptr+next+bulabula=28B

为什么需要多个虚指针？请往下看。

3 虚拟继承

（1）为什么要有“虚继承”这样的机制？

　　简单讲，虚继承是为也防止“diamond”继承所带来的问题。也就是类A1、A2都继承于A，类B又同时继承于A1、A2。这样一来，类B中就有两份类A的成员了，这样的程序无法通过编译。我们改成这样的形式：

class A
{
public:
　　int a;
　　virtual ~A(); 
    virtual void fun(){cout<<"A"<<endl;}
};
class A1 :public virtual A
{
public:
　　int a1;
   virtual void fun(){cout<<"A1"<<endl;}

};
class A2 :public virtual A
{
public:
　　int a2;
   virtual void fun(){cout<<"A2"<<endl;}
}; 

class B :public A1,public A2 {
public:
　　int b;
    virtual void fun(){cout<<"B"<<endl;}
    virtual void funB(){};
};

　　这样就能防止这样的事情发生。

（2）虚拟继承与普通继承的区别：

　　普通继承使得派生类每继承一个基类便拥有一份基类的成员。而虚拟继承会把通过虚拟继承的那一部分，放在对象的最后。从而使得只拥有一份基类中的成员。虚拟对象的偏移量被保存在Derived类的vtbl的this指向的上一个slot。比较难理解。下面我给你个栗子。

（3）虚拟继承的内存布局：

　　每个派生类会把其不变部分放在前面，共享部分放在后面。

上面四个类的大小是怎样的呢？

int _tmain(int argc, _TCHAR* argv[])
{
    cout << sizeof(A) << " " << sizeof(A1) << " " << sizeof(A2) << " " << sizeof(B) << endl;
    return ;
}

　　输出：8 16 16 28

　　内存布局：

　　　　A: vptr+a=8B

　　　　A1: vptr+a1+vptrA+a=16B

　　　　A2: vptr+a2+vptrA+a=16B

　　　　A3: vptr+a1+vptrA2+a2+b+vptrA+a=28B

　　上个草图：

　　那究竟为什么需要多个虚指针？将对象内存布局和虚表结构搞清楚之后，答案是不是呼之欲出呢？

是的，因为这样可以保证在将子类指针/引用转换成基类指针时编译器可以直接根据对像的内存布局进行偏移，从而使得指向的第一个内容为虚指针，进而实现多态（根据静态类型执行相应动作）。