C++对象模型那点事儿（布局篇）

1 前言

在C++中类的数据成员有两种：static和nonstatic，类的函数成员由三种：static，nonstatic和virtual。上篇我们尽量说一些宏观上的东西，数据成员与函数成员在类中的布局将在微观篇中详细讨论。

每当我们声明一个类，定义一个对象，调用一个函数.....的时候，不知道你有没有一些疑惑--编译器私底下都干了些什么？普通函数，成员函数都是怎么调用的？static成员又是个什么玩意。如果你对这些东西也感兴趣，那么好，我们一起将class的底层翻个底朝天。修炼好底层的内功，我想对于上层的提供，帮助可不止一点点吧？

2 class整体布局

C语言中“数据“与函数式分开声明的，也就是说C语言并不支持”数据“与函数之间的关联性。

我们来看下面的例子。

[cpp]  view plain copy

1. typedef struct point3d{ //数据  
2.       float x;  
3.       float y;  
4.       float z;  
5. }Point3d;  
6. void Point3d_print(const Point3d *pd{  
7.       printf("%g,%g,%g",pd->x,pd->y,pd->z);  
8. }  

我们再来看看C++中的做法。

[cpp]  view plain copy

1. class Point3d{  
2.       float _x;  
3.       float _y;  
4.       float _z;  
5. public:  
6.       void point3d_print(){  
7.             printf("%g,%g,%g",_x,_y,_z);  
8.       }  
9. };  

在Point3d转换到C++之后，我们可能会问加上封装之后，成本会增加多少？

答案是class Point3d并没有增加成本。三个数据成员(_x,_y,_z)直接内含在每一个对象之中，而成员函数虽在类中声明，却不出现在对象之中。如下图所示：

凡事没有绝对，virtual看起来就会增加C++在布局及存取时间上的额外负担。稍后讨论。

好吧，我承认光说面上（宏观上）的东西东西大家都懂，而且底层的东西注定不会太宏观。那么下面我们举例子来证明上述的讨论。

需要说明的是以下是在vs2010下的运行结果，若是gcc，可能某些地方会有所差异。

[cpp]  view plain copy

1. class A{};         // sizeof(A) = 1  有木有很奇怪？稍后说明  
2. class B{int x;};   //  sizeof(B) = 4  
3. class C{  
4.       int x;  
5. public:  
6.       int get(){return x;}  
7. };                 //  sizeof(C) = 4; 是不是验证了我们上述的论述？  

很奇怪sizeof(A) = 1而不是0吧？

事实上A并不是空的，他有一个隐藏的1byte大小，那是被编译器安插进去的一个char。这样做使得用同一个空类定义两个对象的时候得以在内存中配置独一无二的地址。

例如：

[cpp]  view plain copy

1. A a,b;  
2. if(&a == &b)cout<<"error"<<endl;  

我们都知道在C语言中struct优化的时候会进行内存对齐，那么我们来看看class中有没有这个优化。

[cpp]  view plain copy

1. class A{  
2.     char x;  
3.     int y;  
4.     char z;  
5. };  // sizeof(A) == 12;  
6. class B{  
7.     char x;  
8.     char y;  
9.     int z;  
10. };  // sizeof(B) = 8;  
11. class C{  
12.     int x;  
13.     char y;  
14.     char z;  
15. };  // sizeof(C) = 8;  
16. class D{  
17.     long long x;  
18.     char y;  
19.     char z;  
20. };  //sizeof(D) = 16; 由于longlong为8字节大小，此处以8字节对齐  

显然编译器进行类内存对齐的优化。

接着上文，我们知道stroustrup老大的设计（目前仍在使用）是：nonstatic data members 被置于每一个对象之中，static data member则被置于对象之外。static和nonstatic function members 则被放在对象之外。

[cpp]  view plain copy

1. class A{  
2.     static int x;  
3. };  //sizeof(A) = 1;  
4. class B{  
5.     int x;  
6. public:  
7.     int get(){  
8.         return x;  
9.     }  
10. };  //sizeof(B) = 4  
11. class C{  
12.     int x;  
13. public:  
14.     virtual int get(){  
15.         return x;  
16.     }  
17. };  //sizeof(C) = 8;  

显然验证了上述我所说的。

[cpp]  view plain copy

1. class A{  
2.     void (*pf)(); //函数指针  
3. };   //sizeof(A) = 4;  
4. class B{  
5.     int *p;   // 指针  
6. };   //sizeof(B) = 4;  

所以含有虚函数的时候，object中会包含一个虚表指针。我们知道指针一边占用4个字节，上面的sizeof(C)就好解释了。

3 虚函数

我们都知道虚函数是下面这个样子。

[cpp]  view plain copy

1. class X{  
2.     int a;  
3.     int b;  
4. public:  
5.     virtual void foo1(){cout<<"X::foo1"<<endl;}  
6.     virtual void foo2(){cout<<"X::foo2"<<endl;}  
7. };  

内存布局如下:

下面我们来证明这种布局。

[cpp]  view plain copy

1. #include<iostream>  
2. using namespace std;  
3. class X{  
4.     int _a;  
5.     int _b;  
6. public:  
7.     virtual void foo1(){cout<<"X::foo1"<<endl;}  
8.     virtual void foo2(){cout<<"X::foo2"<<endl;}  
9. };  
10. typedef void (*pf)();  
11. int main(){  
12.     X a;  
13.     int **tmp = (int **)&a;  
14.     pf ptf;  
15.     for(int i=0;i<2;i++){  
16.         ptf = (pf)tmp[0][i];  
17.         ptf();  
18.     }  
19. }  

运行结果如下图所示：

那么，我们继续往下看。

4 继承

当涉及到继承的时候，情况又会怎样呢？

[cpp]  view plain copy

1. class A{  
2.       int x;  
3. };  
4. class B:public A{  
5.       int y;  
6. };   //sizeof(B) = 8;  

我们来看看涉及到继承的时候内存的布局情况。

我们继续，若基类中包含有虚函数，这时候又会如何呢？

[cpp]  view plain copy

1. class C{  
2. public:  
3.     virtual void fooC(){  
4.         cout<<"C::fooC()"<<endl;  
5.     }  
6. };  //sizeof(C) = 4;  
7. class D:public C{  
8.     int a;  
9. public:  
10.     virtual void fooD(){  
11.         cout<<"D::fooD()"<<endl;  
12.     }  
13. };  //sizeof(D) = 8;  

内存布局应该是这个样子：

下面我们来验证这种布局：

[cpp]  view plain copy

1. typedef void (*pf)();  
2. int main(){  
3.     C a;  
4.     D b;  
5.     int **tmpc = (int **)&a;  
6.     int **tmpb = (int **)&b;  
7.     pf ptf;  
8.     ptf = (pf)tmpc[0][0];  
9.     ptf();  
10.     ptf = (pf)tmpb[0][0];  
11.     ptf();  
12.     ptf = (pf)tmpb[0][1];     
13.     ptf();  
14. }  

运行结果：

显然上述的布局是对的。这个时候需要注意的是：C::fooC()在前，D::fooD()在后，若出现函数覆盖，则D中的函数会覆盖掉继承过来的同名函数，而对于没有覆盖的虚函数则追加在虚表的最后。
我们再来看看下面的涉及到虚函数的多重继承。

[cpp]  view plain copy

1. class A{  
2.     int _a;  
3. public:  
4.     virtual void fooA(){  
5.         cout<<"A::fooA()"<<endl;  
6.     }  
7.     virtual void poo(){  
8.         cout<<"A::poo()"<<endl;  
9.     }  
10. };  //sizeof(A) = 8;  
11. class B{  
12.     int _b;  
13. public:  
14.     virtual void fooB(){  
15.         cout<<"B::fooB()"<<endl;  
16.     }  
17.     virtual void poo(){  
18.         cout<<"B::poo()"<<endl;  
19.     }  
20. };  ////sizeof(B) = 8;  
21. class C:public A,public B{  
22.     int _c;  
23. public:  
24.     void poo(){  
25.         cout<<"C::poo()"<<endl;  
26.     }  
27.     virtual void hoo(){  
28.         cout<<"C::hoo()"<<endl;  
29.     }  
30. };    //sizeof(C) = 20;  

有了上面的布局信息，我们可以推测类C的布局如下：

下面我们来验证这种推测。

[cpp]  view plain copy

1. typedef void (*pf)();  
2. int main(){  
3.     C a;  
4.     int **tmp = (int **)&a;  
5.     pf ptf;  
6.     for(int i=0;i<3;++i){  
7.         ptf = (pf)tmp[0][i];  
8.         ptf();  
9.     }  
10.     cout<<"-----------"<<endl;  
11.     int s = sizeof(A)/4; //指针与int都占用4字节大小  
12.     for(int i=0;i<2;i++){  
13.         ptf = (pf)tmp[2][i];  
14.         ptf();  
15.     }  
16. }  

运行结果：

显然与我们的猜测一致。

最后，我们再来看看菱形继承的情况。

[cpp]  view plain copy

1. class A{  
2.     int _a1;  
3.     int _a2;  
4. };    //sizeof(A) = 8;  
5. class B:virtual public A{  
6.     int b;  
7. };    //sizeof(B) = 16;  
8. class C:virtual public A{  
9.     int c;  
10. };    //sizeof(C) = 16;  
11. class D:public B,public C{  
12.     int d;  
13. };    //sizeof(D) = 28;  

我们来看看这时候的内存布局：

我们来验证这种布局：

[cpp]  view plain copy

1. int main(){  
2.     D d;  
3.     A *pta = &d;  
4.     B *ptb = &d;  
5.     C *ptc = &d;  
6.     cout<<"D:  "<<&d<<endl;  
7.     cout<<"B:  "<<ptb<<"   C:  "<<ptc<<endl;  
8.     cout<<"A:  "<<pta<<endl;  
9. }  

你在尝试的时候地址可能会有所差异，但是偏移量应该会保持一致。至于不同的编译器是否布局都一样，我也不得而知。至于那两个虚指针所指虚表提供的也就是虚基类的成员偏移量信息，大家如果感兴趣，可以自己验证。

至此，宏观布局部分大致说完，欲知后事如何请转至“成员篇”。