没有继承的类对象的数据布局
一个类如果没有父类，那么它的数据布局相对简单，有以下的注意点：
- 一个空类的大小是1个字节（需要能对对象取地址）。
- 类的非静态成员变量存储在对象内部，静态成员变量存储在类对象外部。
- 成员函数，不管是静态的还是非静态的，都存储在类外部。
- 虚函数存储在类对象的外部，但是类对象中需要存储一个指针指向虚函数表。
- 由于在计算机中需要字节对齐，所以类可能比成员相加之和更大。
如果要访问这些类对象，可以采用指针的偏移，然后按照类型取值就可以，下面是一个例子：
#include <iostream>
using namespace std;
class A{
public:
char grade = 'A';
const char* name = "Jack";
int age = 18;
static int id;
virtual void f1(){
cout << "A::f1()" << endl;
}
virtual void f2(){
cout << "A::f2()" << endl;
}
void f3(){
cout << "A::f3()" << endl;
}
void f4(){
cout << "A::f4()" << endl;
}
};
int A::id = 1;
int main(){
A a;
printf("grade %d\tname %d\tage %d\n", &A::grade, &A::name, &A::age);
char *pa = (char *)&a;
pa += 8;
printf("grade = %c\n", *pa);
pa += 8;
printf("name = %s\n", *((char* *)pa));
pa += 8;
printf("age = %d\n", *( (int *) pa));
A *ap = &a;
ap->age = 19;
return 0;
}
可以使用对类的成员取地址的方式得到成员在类中的偏移，也可以使用前面说的命令：
cl /d1 reportSingleClassLayoutA object_size.cpp
来得到如下所示的类布局：
class A size(32):
+---
0 | {vfptr}
8 | grade
| <alignment member> (size=7)
16 | name
24 | age
| <alignment member> (size=4)
+---
A::$vftable@:
| &A_meta
| 0
0 | &A::f1
1 | &A::f2
可以看出，有虚函数会生成一个虚函数指针放在类对象的开头，字节对齐会导致编译器会填充一些空白到类对象中。
这里还演示知道这个成员的偏移怎么通过指针取出值来，其实比较简单，就是手动偏移指针，然后对指针的类型进行强转就可以了。其实编译器内部也差不多是这么实现的。可以设置年龄这里加一个断点，然后调试，在VS2013中，调试->窗口->反汇编，就可以看到汇编代码。
ap->age = 19;
00007FF6DF024A8C mov rax,qword ptr [ap]
00007FF6DF024A91 mov dword ptr [rax+18h],13h
可以看出，在汇编代码中，也是吧13h（19）这个值直接mov到rax（a的首地址）+18h（24）的地方。
指向数据对象的指针
这个只是展示一些比较奇怪的用法，平时用的比较少。请看下面的代码：
#include<iostream>
using namespace std;
class A{
public:
char c = 'a';
int i = 1;
long l = 1L;
};
int main(){
/* 得到的其实是成员在类中的偏移 */
printf("&A::c = %d,&A::i = %d,&A::l = %d\n",&A::c,&A::i,&A::l);
int A::*p = &A::i; /* 声明一个指向类成员的指针 */
A a;
printf("a.*p = %d\n", a.*p); /* 使用指向类成员的指针 */
return 0;
}
有继承的类对象的数据布局
如果一个类继承了父类，这个类对象的布局有新的一些特点，不同的编译器有不同的方案，但基本的思想是不变的，主要体现为以下两点：
- 子类含有父类的所有成员。
- 通过调整子对象的指针，可以得到一个大于等于父类的布局（可以在后面增加成员，但前面必须保持一致）。
和没有继承的类相比，有了继承之后编译器的处理方案会多很多，所以这里只是举一个例子来说明。
#include <iostream>
using namespace std;
class A{
public:
const char *aname = "class A";
int a1 = 100;
void printA(){
printf("name = %s,val = %d\n", aname, a1);
}
};
class B{
public:
const char *bname = "class B";
int b1 = 200;
void printB(){
printf("name = %s,val = %d\n", bname, b1);
}
virtual void f(){
cout << "B::f()" << endl;
}
};
class C :public A, public B{
public:
char c = 'A';
virtual void printC(){
cout << "class C :public A, public B" << endl;
}
};
int main(){
C c;
char *p = (char *)&c;
B *pb = (B *)p;
pb->printB();
p += 24;
A *pa = (A *)p;
pa->printA();
A *pa1 = &c;
B *pb1 = &c;
printf("pa = %p,pa1 = %p;pb = %p,pb1 = %p\n", pa, pa1, pb, pb1);
p = (char *)&c;
p += 16;
B *pa2 = (B *)p;
pa2->printB();
return 0;
}
使用命令得到数据的布局：
class C size(48):
+---
| +--- (base class B)
0 | | {vfptr}
8 | | bname
16 | | b1
| | <alignment member> (size=4)
| +---
| +--- (base class A)
24 | | aname
32 | | a1
| | <alignment member> (size=4)
| +---
40 | c
| <alignment member> (size=7)
+---
C::$vftable@:
| &C_meta
| 0
0 | &B::printB
1 | &C::printC
从布局中可以看出一些东西，第一，布局并没有按照继承顺序，先继承了A，但是却把B排到了前面；第二，修改了虚函数表，在B的虚函数表后面增加了C的虚函数。
这里可以看出，它满足上面说的两个条件，可以把c的首地址当做B使用，可以把c的首地址偏移24当做A使用。上面的测试代码说明了这一点。值得注意的是，不能使用cout输出，具体原因不清楚，感觉是cout有更加严格的类型检查。最后，还做了一个操作，把c偏移16当做一个B使用，可以看到，这一点也是可以正确运行的，只不过打印的是A的参数。
有虚继承的类对象的数据布局
先看看如果不使用虚继承会出现的问题，先看下面的代码：
#include <iostream>
using namespace std;
class A{
public:
int val = 100;
};
class B1 :public A{
public:
int b1 = 200;
};
class B2 :public A{
public:
int b2 = 300;
};
class C :public B1, public B2{
public:
int c = 400;
};
有两个问题，第一个是这样继承C中会有两个A的对象，前面说过，子类有父类所有的成员，B1和B2都继承自A，C又继承B1和B2，所以C中就有两个A。可以查看C的布局：
class C size(20):
+---
| +--- (base class B1)
| | +--- (base class A)
0 | | | val
| | +---
4 | | b1
| +---
| +--- (base class B2)
| | +--- (base class A)
8 | | | val
| | +---
12 | | b2
| +---
16 | c
+---
第二个是如果使用c.val访问会产生歧义，因为有两个val，只能指定作用域，如c.A::val来访问。
虚继承可以解决这个问题，使得虚继承的类在继承体系中只有一个。但这样在实现上又有一个问题，上面说过，要支持多态，那么就需要能够通过调整this指针达到以假乱真的地步。如果少一个对象A，你会发现无论怎么调整指针，B1和B2始终有一个不能满足。
在VS2013中，对虚继承的实现有一点技巧，大致的思想是，不再直接保存A，而是保存A的指针。这样的好处是，虽然有出现了两个A，但两个A都指向了同一个地方，并且，指针的大小应该是远远小于类的大小。并且，对于A的访问，只能通过保存的指针访问，而不能直接通过偏移访问。那么A保存在哪呢？其实就可以保存在类的后面，因为不会访问，也更紧凑，那么前面的指针就可以是一个偏移。
把上面的继承改为虚继承，再看看C的数据布局。
class C size(44):
+---
| +--- (base class B1)
0 | | {vbptr}
8 | | b1
| | <alignment member> (size=4)
| | <alignment member> (size=4)
| +---
| +--- (base class B2)
16 | | {vbptr}
24 | | b2
| | <alignment member> (size=4)
| | <alignment member> (size=4)
| +---
32 | c
| <alignment member> (size=4)
+---
+--- (virtual base A)
40 | val
+---
C::$vbtable@B1@:
0 | 0
1 | 40 (Cd(B1+0)A)
C::$vbtable@B2@:
0 | 0
1 | 24 (Cd(B2+0)A)
在看看B1的布局：
class B1 size(20):
+---
0 | {vbptr}
8 | b1
| <alignment member> (size=4)
+---
+--- (virtual base A)
16 | val
+---
B1::$vbtable@:
0 | 0
1 | 16 (B1d(B1+0)A)
可以看出，经过这样修改，就满足这个修改指针的条件。然后再看看对于val的访问：
int main(){
C c;
c.val = 1;
return 0;
}
对应的反汇编代码为：
c.val = 1;
00007FF6D4DC49A6 mov rax,qword ptr [c]
00007FF6D4DC49AB movsxd rax,dword ptr [rax+4]
00007FF6D4DC49AF mov dword ptr c[rax],1
通过汇编，可以看出，对于val的访问，是通过vbptr找到偏移，然后通过偏移找到A，然后通过val在A中偏移（这里的偏移是0，没有体现出来），在进行赋值。
关于虚继承的数据布局，其实还有很多细节，但是个人认为，还是不应该纠结于细节，要抓住主要思想。
运行时类型识别（RTTI）
之所以在这里讲RTTI，是因为RTTI和对象的布局是有关系的。要实现RTTI，也许第一个想到的办法就是在对象里面增加一个字段，指向一个type_info对象的地址，type_info每个类可以在编译时确定，但是这样的代价太高了。所以，处于折中的考虑，就把type_info和虚函数表放在一起，这样可以节约空间，但是，这样的问题是，对于没有虚函数的类，使用typeid得到的类型是有问题的。
#include<iostream>
using namespace std;
class A{
public:
int a;
virtual void func(){}
};
class B :public A{
public:
int b;
};
int main(){
A *a = new B();
const type_info &info = typeid(*a);
cout << info.name() << endl;
return 0;
}
如果去掉A中的虚函数，那么输出为class A，也就是编译时的类型。至于这个type_info指针的位置，也就不深究了，不同的编译器有不同的方案，知道大致的原理就行。如果想要知道的话，可以查看反汇编代码，应该就可以知道存放的位置了。
