【总结篇】C++中普通多态多重继承、普通虚继承、多态多重继承与虚继承相结合对类的内存布局sizeof的影响

这一篇是对我的另外两篇博客（https://blog.csdn.net/m0_38014304/article/details/84286266和https://blog.csdn.net/m0_38014304/article/details/84335787）的总结，对继承体系中类的sizeof大小做一个最后的归纳，如果以后有内存布局有变动，均在这一篇博客上进行修改。

源码：

# include <iostream>

using namespace std;

// 在多态虚继承时，派生类与基类不共享虚函数表指针，
// 所以派生类会在基类的基础上增加一个虚函数表指针(如果添加了新的虚函数的话)和虚基类指针。
// 如果是多层多态虚继承，每一个派生类都会有自己的虚基类指针，虚基类指针是永远不会共享的。

// 如果不是虚继承，则派生类和基类共享虚函数表指针，且派生类里不会有虚基类指针。

// 在非多态虚继承时，派生类会和基类共享虚基类指针，自己不再生成。

// 在Properties->Configuration Properties->C/C++->Command Line->Additional Options
// 中添加
//     /d1reportSingleClassLayoutX 
// 可在编译时显示class X的内存布局；
// 添加
//   /d1 reportAllClassLayout 
// 可在编译时显示所有类的内存布局


//----------------------------------//
// virtual base inheritance with virtual functions
class X
{ 
public:
	virtual ~X() {}
protected:
	char m_x;
	int m_x2;
};

class Y :virtual public X
{
public:
  virtual void test_y() {}
protected:
	int m_y;
};

class Z :virtual public X
{
public:
	virtual void test_z() {}
	int m_z;
};

class A:public Y, public Z
{
public:
	virtual void test_a() {}
	int m_a;
};


//----------------------------------//
// normal inheritance with virtual functions
class B
{
public:
	virtual ~B() {}
};

class C
{
public:
	virtual ~C() {}
};

class D : public B, public C
{
public:
	virtual void test_d() {}
};

class E : public D 
{
public:
	virtual void test() {}
};


//----------------------------------//
// virtual base inheritance
class F
{
public:
	int m_f;
};

class G : virtual public F
{
public:
	int m_g;
};

class H : virtual public F
{
public:
	int m_h;
};

class I : public G, public H
{
public:
	int m_i;
};


// main
int main(void)
{
	cout << "X size: " << sizeof(X) << endl;
	cout << "Y size: " << sizeof(Y) << endl;
	cout << "Z size: " << sizeof(Z) << endl;
	cout << "A size: " << sizeof(A) << endl;

	cout << "==========================" << endl;
	cout << "B size: " << sizeof(B) << endl;
	cout << "C size: " << sizeof(C) << endl;
	cout << "D size: " << sizeof(D) << endl;
	cout << "E size: " << sizeof(E) << endl;

	cout << "==========================" << endl;
	cout << "F size: " << sizeof(F) << endl;
	cout << "G size: " << sizeof(G) << endl;
	cout << "H size: " << sizeof(H) << endl;
	cout << "I size: " << sizeof(I) << endl;

	return 0;
}

输出结果（32bits）：

类之间的关系：

类的内存分布（32bits）：

1>  class X	size(12):
1>  	+---
1>   0	| {vfptr}
1>   4	| m_x
1>    	| <alignment member> (size=3)
1>   8	| m_x2
1>  	+---


1>  class Y	size(24):
1>  	+---
1>   0	| {vfptr}
1>   4	| {vbptr}
1>   8	| m_y
1>  	+---
1>  	+--- (virtual base X)
1>  12	| {vfptr}
1>  16	| m_x
1>    	| <alignment member> (size=3)
1>  20	| m_x2
1>  	+---


1>  class Z	size(24):
1>  	+---
1>   0	| {vfptr}
1>   4	| {vbptr}
1>   8	| m_z
1>  	+---
1>  	+--- (virtual base X)
1>  12	| {vfptr}
1>  16	| m_x
1>    	| <alignment member> (size=3)
1>  20	| m_x2
1>  	+---


1>  class A	size(40):
1>  	+---
1>   0	| +--- (base class Y)
1>   0	| | {vfptr}
1>   4	| | {vbptr}
1>   8	| | m_y
1>  	| +---
1>  12	| +--- (base class Z)
1>  12	| | {vfptr}
1>  16	| | {vbptr}
1>  20	| | m_z
1>  	| +---
1>  24	| m_a
1>  	+---
1>  	+--- (virtual base X)
1>  28	| {vfptr}
1>  32	| m_x
1>    	| <alignment member> (size=3)
1>  36	| m_x2
1>  	+---


1>  class B	size(4):
1>  	+---
1>   0	| {vfptr}
1>  	+---


1>  class C	size(4):
1>  	+---
1>   0	| {vfptr}
1>  	+---


1>  class D	size(8):
1>  	+---
1>   0	| +--- (base class B)
1>   0	| | {vfptr}
1>  	| +---
1>   4	| +--- (base class C)
1>   4	| | {vfptr}
1>  	| +---
1>  	+---


1>  class E	size(8):
1>  	+---
1>   0	| +--- (base class D)
1>   0	| | +--- (base class B)
1>   0	| | | {vfptr}
1>  	| | +---
1>   4	| | +--- (base class C)
1>   4	| | | {vfptr}
1>  	| | +---
1>  	| +---
1>  	+---


1>  class F	size(4):
1>  	+---
1>   0	| m_f
1>  	+---


1>  class G	size(12):
1>  	+---
1>   0	| {vbptr}
1>   4	| m_g
1>  	+---
1>  	+--- (virtual base F)
1>   8	| m_f
1>  	+---


1>  class H	size(12):
1>  	+---
1>   0	| {vbptr}
1>   4	| m_h
1>  	+---
1>  	+--- (virtual base F)
1>   8	| m_f
1>  	+---


1>  class I	size(24):
1>  	+---
1>   0	| +--- (base class G)
1>   0	| | {vbptr}
1>   4	| | m_g
1>  	| +---
1>   8	| +--- (base class H)
1>   8	| | {vbptr}
1>  12	| | m_h
1>  	| +---
1>  16	| m_i
1>  	+---
1>  	+--- (virtual base F)
1>  20	| m_f
1>  	+---

以上。