C++ 中类的内存布局
在许多笔试面试中都会涉及到sizeof 运算符的求值问题。
这类问题主要分四类：
- 基本数据类型，如int，bool，fload，long，long，int * 等，这一类比较简单，但要注意x86和x64情况下的指针大小
- 枚举 enum。这个类型网络上有说是1-4个byte，根据最大值决定的；也有说是sizeof(int)。我这边个人使用 visual studio 2015 获得的结果是4个byte
- struct 和 union 组合类型。union 是取其中一个最大成员的size作为其size；struct 则要考虑对齐填充因素
- class 类型，class 就稍微复杂点，不仅仅要考虑对齐填充因素，还要考虑继承，虚继承，虚函数等因素。
下文主要讲述class 的内存布局，稍带介绍一下struct 的size。
struct 的内存布局：
struct 的内存对齐和填充概念学过C 的都应该知道一点。其实只要记住一个概念和三个原则就可以了：
一个概念：
自然对齐：如果一个变量的内存地址正好位于它长度的整数倍，就被称做自然对齐。
如果不自然对齐，会带来CPU存取数据时的性能损失。（PS：具体应该与CPU通过总线读写内存数据的细节相关，具体没有细究）
三个原则：
- struct 的起始地址需要能够被其成员中最宽的基本数据类型整除；
- struct 的size 也必须能够被其成员中最宽的基本数据类型整除；
- struct 中每个成员地址相对于struct 的起始地址的offset，必须是自然对齐的。
Class 的内存布局：
在学习C++ 的class 的内存布局前，先介绍下文会被用到的Visual studio 中的编译选项"/d1reportAllClassLayout" 和 "/d1reportSingleClassLayout[ClassName]"。
这两个编译选项分别会输出当前编译单元中所以class 的内存布局和指定class 的内存布局。对于学习class 的内存布局很方便。
关于一个class 的定义，在定义过程中涉及到的有：
成员数据（静态，非静态）和成员函数（静态，非静态，virtual）。
所有的成员函数都不会占用对象的存储空间，无论是静态，非静态还是虚函数。
而对于成员数据来说，只有非静态的数据才会占用对象的存储空间。
这个很好理解，静态成员数据和成员函数是属于class 的，而非属于具体的对象，所以只要维护一份内存就可以了，无需每个对象都拷贝一份。
但是影响对象的大小的因素并不仅仅与看到的成员变量有关：
非静态成员变量，虚函数表指针(_vftprt)，虚基类表指针(_vbtptr)，上文的内存对齐
-
空类
class CEmpty{};
对于空类，许多人想当然的认为大小应该是0。这是错误的，如果是正确的话，这个类可以被实例化成一个对象，且这个对象不占任何存储空间，且可以有很多不占任何空间的对象，而且这个不占空间的对象还可以有指针，这样就很奇怪了。
所以正常编译器会给空类分配1个byte 的空间用于标示。
sizeof(CEmpty) = 1
-
普通类
class CBase {
public:
int m_ia;
static int s_ib;
private:
void f();
void g();
};
其类的布局如下：
class CBase size(4): +--- 0 | m_ia +---
只有m_ia 成员，size 为4个byte。因为静态数据成员和成员函数不占有对象空间。
-
有虚函数的类
class CBase {
public:
int m_ia;
private:
void f();
void g();
virtual void h();
};
其类的布局如下：
class CBase size(8):
+---
0 | {vfptr}
4 | m_ia
+---
CBase::$vftable@:
| &CBase_meta
| 0
0 | &CBase::h
可以看到该类的起始地址是放了一个"vfptr"，这个指针用来指向该类的虚函数表。
-
单一继承的类(无虚函数)
class CBase {
public:
int m_ia;
private:
void f();
void g();
};
class CChild :public CBase {
public:
int m_iChild;
};
类的布局如下：
class CChild size(8): +--- | +--- (base class CBase) 0 | | m_ia | +--- 4 | m_iChild +---
即派生类中拷贝了一份基类中的成员数据，所以size 为8个byte。
-
单一继承的类（含有虚函数）
class CBase {
public:
int m_ia;
public:
virtual ~CBase();
virtual void f();
virtual void g();
};
class CChild :public CBase {
public:
int m_iChild;
public:
virtual ~CChild();
virtual void g();
};
其类的布局如下：
class CChild size(12):
+---
| +--- (base class CBase)
0 | | {vfptr}
4 | | m_ia
| +---
8 | m_iChild
+---
CChild::$vftable@:
| &CChild_meta
| 0
0 | &CChild::{dtor}
1 | &CBase::f
2 | &CChild::g
可以看到派生类中只有一个"vfptr"，但是虚函数表中的函数却不同于基类中的函数，没有重写的虚函数沿用基类中的虚函数，而被重写的虚函数则更新为派生类中的虚函数。
-
多重继承的类（基类都含有虚函数）
class CBase1 {
public:
int m_i1;
public:
virtual ~CBase1();
virtual void f1();
virtual void g1();
};
class CBase2 {
public:
int m_i2;
public:
virtual ~CBase2();
virtual void f2();
virtual void g2();
};
class CChild :public CBase1, public CBase2 {
public:
int m_iChild;
public:
virtual ~CChild();
virtual void f1();
virtual void g2();
};
其类的布局如下：
class CChild size(20):
+---
| +--- (base class CBase1)
0 | | {vfptr}
4 | | m_i1
| +---
| +--- (base class CBase2)
8 | | {vfptr}
12 | | m_i2
| +---
16 | m_iChild
+---
CChild::$vftable@CBase1@:
| &CChild_meta
| 0
0 | &CChild::{dtor}
1 | &CChild::f1
2 | &CBase1::g1
CChild::$vftable@CBase2@:
| -8
0 | &thunk: this-=8; goto CChild::{dtor}
1 | &CBase2::f2
2 | &CChild::g2
CChild 分别从CBase1 和 CBase 中继承一个vfptr.
-
菱形结构继承的类（非虚继承）
class CBase {
public:
int m_iBase;
public:
virtual ~CBase();
virtual void f0();
virtual void g0();
virtual void h0();
};
class CChild1:public CBase {
public:
int m_iChild1;
public:
virtual ~CChild1();
virtual void f0();
virtual void h1();
};
class CChild2:public CBase {
public:
int m_iChild2;
public:
~CChild2();
void g0();
void h1();
};
class CGrandChild :public CChild1, public CChild2 {
public:
int m_iGrandChild;
public:
virtual ~CGrandChild();
virtual void h0();
virtual void h1();
virtual void h2();
virtual void f0();
};
其类的布局如下：
class CGrandChild size(28):
+---
| +--- (base class CChild1)
| | +--- (base class CBase)
0 | | | {vfptr}
4 | | | m_iBase
| | +---
8 | | m_iChild1
| +---
| +--- (base class CChild2)
| | +--- (base class CBase)
12 | | | {vfptr}
16 | | | m_iBase
| | +---
20 | | m_iChild2
| +---
24 | m_iGrandChild
+---
CGrandChild::$vftable@CChild1@:
| &CGrandChild_meta
| 0
0 | &CGrandChild::{dtor}
1 | &CGrandChild::f0
2 | &CBase::g0
3 | &CGrandChild::h0
4 | &CGrandChild::h1
5 | &CGrandChild::h2
CGrandChild::$vftable@CChild2@:
| -12
0 | &thunk: this-=12; goto CGrandChild::{dtor}
1 | &thunk: this-=12; goto CGrandChild::f0
2 | &CChild2::g0
3 | &thunk: this-=12; goto CGrandChild::h0
这种继承是有风险的，即通过CGrandChild 去访问m_iBase 时，容易造成二义性，需要使用"pGrandChild->CChild::m_iBase" 这种方法去访问。
为了避免这种问题，C++ 中有一种机制是虚继承。
-
单一虚继承
class CBase {
public:
int m_iBase;
public:
virtual ~CBase();
virtual void f0();
virtual void g0();
virtual void h0();
};
class CChild1: virtual public CBase {
public:
int m_iChild1;
public:
virtual ~CChild1();
virtual void f0();
virtual void h1();
};
其类的布局如下：
class CChild1 size(24):
+---
0 | {vfptr}
4 | {vbptr}
8 | m_iChild1
+---
12 | (vtordisp for vbase CBase)
+--- (virtual base CBase)
16 | {vfptr}
20 | m_iBase
+---
CChild1::$vftable@CChild1@:
| &CChild1_meta
| 0
0 | &CChild1::h1
CChild1::$vbtable@:
0 | -4
1 | 12 (CChild1d(CChild1+4)CBase)
CChild1::$vftable@CBase@:
| -16
0 | &(vtordisp) CChild1::{dtor}
1 | &(vtordisp) CChild1::f0
2 | &CBase::g0
3 | &CBase::h0
从布局中看，发现多了一个vbptr 指针，则是一个指向基类的虚基类指针；在派生类和虚基类之间又多了“vtordisp for vbase CBase”，vtordisp 并不是每个虚继承的派生类都会生成的，关于这部分可以参考MSDN 中 vtordisp；在vtordisp 后面则是虚基类的一个拷贝。
-
多重继承的类（虚继承）
class CChild1 {
public:
int m_iChild1;
public:
virtual ~CChild1();
virtual void f0();
virtual void h1();
};
class CChild2 {
public:
int m_iChild2;
public:
~CChild2();
void g0();
void h1();
};
class CGrandChild :public CChild1, public CChild2 {
public:
int m_iGrandChild;
public:
virtual ~CGrandChild();
virtual void h0();
virtual void h1();
virtual void h2();
virtual void f0();
};
virtual public Child1, public CChild2
其类的布局如下：
class CGrandChild size(28):
+---
0 | {vfptr}
| +--- (base class CChild2)
4 | | m_iChild2
| +---
8 | {vbptr}
12 | m_iGrandChild
+---
16 | (vtordisp for vbase CChild1)
+--- (virtual base CChild1)
20 | {vfptr}
24 | m_iChild1
+---
public Child1, virtual public CChild2
其类的布局如下：
class CGrandChild size(20):
+---
| +--- (base class CChild1)
0 | | {vfptr}
4 | | m_iChild1
| +---
8 | {vbptr}
12 | m_iGrandChild
+---
+--- (virtual base CChild2)
16 | m_iChild2
+---
virtual public Child1, virtual public CChild2
class CGrandChild size(28):
+---
0 | {vfptr}
4 | {vbptr}
8 | m_iGrandChild
+---
12 | (vtordisp for vbase CChild1)
+--- (virtual base CChild1)
16 | {vfptr}
20 | m_iChild1
+---
+--- (virtual base CChild2)
24 | m_iChild2
+---
通过上述虚继承的情况来看，可以看出有虚继承的派生类中，派生类和虚基类的数据是完全隔开的，先存放派生类自己的虚函数指针，虚基类指针和数据；然后有vtordisp 作为间隔；在存放虚基类的内容。
-
菱形结构继承的类（虚继承）
class CBase {
public:
int m_iBase;
public:
virtual ~CBase();
virtual void f0();
virtual void g0();
virtual void h0();
};
class CChild1 : virtual public CBase {
public:
int m_iChild1;
public:
virtual ~CChild1();
virtual void f0();
virtual void h1();
};
class CChild2 : virtual public CBase{
public:
int m_iChild2;
public:
virtual ~CChild2();
virtual void g0();
virtual void h1();
};
class CGrandChild : public CChild1, public CChild2 {
public:
int m_iGrandChild;
public:
virtual ~CGrandChild();
virtual void h0();
virtual void h1();
virtual void h2();
virtual void f0();
};
其类的布局如下：
class CGrandChild size(40):
+---
| +--- (base class CChild1)
0 | | {vfptr}
4 | | {vbptr}
8 | | m_iChild1
| +---
| +--- (base class CChild2)
12 | | {vfptr}
16 | | {vbptr}
20 | | m_iChild2
| +---
24 | m_iGrandChild
+---
28 | (vtordisp for vbase CBase)
+--- (virtual base CBase)
32 | {vfptr}
36 | m_iBase
+---
有了上文的基础，这个派生类的机构就不难理解了。
