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

主要从三个方面来讲：

　　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 0;

									}

输出是什么？

答案：

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 0;

									}

输出： 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 0;

									}