首先声明一点，虚表并非是C++语言的官方标准的一部分，只是各家编译器厂商在实现多态时的解决方案。另外即使同为虚表不同的编译器对于虚表的设计可能也是不同的，本文主要基于
Itanium C++ ABI（适用于gcc和clang）。
从C的POD类型到C++的类
首先回顾一下C语言纯POD的结构体（struct）。如果用C语言实现一个类似面向对象的类，应该怎么做呢？
写法一
#include <stdio.h>
typedef struct Actress {
int height; // 身高
int weight; // 体重
int age; // 年龄（注意，这不是数据库，不必一定存储生日）
void (*desc)(struct Actress*);
} Actress;
// obj中各个字段的值不一定被初始化过，
// 通常还会在类内定义一个类似构造函数的函数指针，这里简化
void profile(Actress* obj) {
printf("height:%d weight:%d age:%d\n", obj->height, obj->weight, obj->age);
}
int main() {
Actress a;
a.height = 168;
a.weight = 50;
a.age = 20;
a.desc = profile;
a.desc(&a);
return 0;
}
想达到面向对象中数据和操作封装到一起的效果，只能给struct里面添加函数指针，然后给函数指针赋值。然而在C语言的项目中你很少会看到这种写法，主要原因就是函数指针是有空间成本的，这样写的话每个实例化的对象中都会有一个指针大小（比如8字节）的空间占用，如果实例化N个对象，每个对象有M个成员函数，那么就要占用N*M*8的内存。
所以通常C语言不会用在struct内定义成员函数指针的方式，而是直接：
写法二
#include <stdio.h>
typedef struct Actress {
int height; // 身高
int weight; // 体重
int age; // 年龄（注意，这不是数据库，不必一定存储生日）
} Actress;
void desc(Actress* obj) {
printf("height:%d weight:%d age:%d\n", obj->height, obj->weight, obj->age);
}
int main() {
Actress a;
a.height = 168;
a.weight = 50;
a.age = 20;
desc(&a);
return 0;
}
Redis中AE相关的代码实现，便是如此。
再看一个C++普通的类：
#include <stdio.h>
class Actress {
public:
int height; // 身高
int weight; // 体重
int age; // 年龄（注意，这不是数据库，不必一定存储生日）
void desc() {
printf("height:%d weight:%d age:%d\n", height, weight, age);
}
};
int main() {
Actress a;
a.height = 168;
a.weight = 50;
a.age = 20;
a.desc();
return 0;
}
你觉得你这个class实际相当于C语言两种写法中的哪一个？
看着像写法一？其实相当于写法二。C++编译器实际会帮你生成一个类似上例中C语言写法二的形式。这也算是C++ zero overhead(零开销)原则的一个体现。
You shouldn't pay for what you don't use.
当然实际并不完全一致，因为C++支持重载的关系，会存在命名崩坏。但主要思想相同，虽不中，亦不远矣。
看到这，你会明白：C++中类和操作的封装只是对于程序员而言的。而编译器编译之后其实还是面向过程的代码。编译器帮你给成员函数增加一个额外的类指针参数，运行期间传入对象实际的指针。类的数据（成员变量）和操作（成员函数）其实还是分离的。
每个函数都有地址（指针），不管是全局函数还是成员函数在编译之后几乎类似。
在类不含有虚函数的情况下，编译器在编译期间就会把函数的地址确定下来，运行期间直接去调用这个地址的函数即可。这种函数调用方式也就是所谓的静态绑定（static binding）。
何谓多态？
虚函数的出现其实就是为了实现面向对象三个特性之一的多态（polymorphism）。
#include <stdio.h>
#include <string>
using std::string;
class Actress {
public:
Actress(int h, int w, int a):height(h),weight(w),age(a){};
virtual void desc() {
printf("height:%d weight:%d age:%d\n", height, weight, age);
}
int height; // 身高
int weight; // 体重
int age; // 年龄（注意，这不是数据库，不必一定存储生日）
};
class Sensei: public Actress {
public:
Sensei(int h, int w, int a, string c):Actress(h, w, a),cup(c){};
virtual void desc() {
printf("height:%d weight:%d age:%d cup:%s\n", height, weight, age, cup.c_str());
}
string cup;
};
int main() {
Sensei s(168, 50, 20, "36D");
s.desc();
return 0;
}
上例子，最终输出显而易见：
height:168 weight:50 age:20 cup:36D
再看：
Sensei s(168, 50, 20, "36D");
Actress* a = &s;
a->desc();
Actress& a2 = s;
a2.desc();
这种情况下，用父类指针指向子类的地址，最终调用desc函数还是调用子类的。输出：
height:168 weight:50 age:20 cup:36D
height:168 weight:50 age:20 cup:36D
这个现象称之为动态绑定（dynamic binding）或者延迟绑定（lazy binding）。
但倘若你 把父类Actress中desc()函数前面的vitural去掉，这个代码最终将调用父类的函数desc()，而非子类的desc()！输出：
height:168 weight:50 age:20
height:168 weight:50 age:20
这是为什么呢？指针实际指向的还是子类对象的内存空间，可是为什么不能调用到子类的desc()？这个就是我在第一部分说过的：类的数据（成员变量）和操作（成员函数）其实是分离的。
仅从对象的内存布局来看，只能看到成员变量，看不到成员函数。因为调用哪个函数是编译期间就确定了的，编译期间只能识别父类的desc()。
好了，现在我们对于C++如何应用多态有了一定的了解，那么多态又是如何实现的呢？
终于我们谈到虚表
C++具体多态的实现一般是编译器厂商自由发挥的。但无独有偶，使用虚表指针来实现多态几乎是最常见做法（基本上已经是最好的多态实现方法）。废话不多说，继续看代码，有微调：
#include <stdio.h>
class Actress {
public:
Actress(int h, int w, int a):height(h),weight(w),age(a){};
virtual void desc() {
printf("height:%d weight:%d age:%d\n", height, weight, age);
}
virtual void name() {
printf("I'm a actress");
}
int height; // 身高
int weight; // 体重
int age; // 年龄（注意，这不是数据库，不必一定存储生日）
};
class Sensei: public Actress {
public:
Sensei(int h, int w, int a, const char* c):Actress(h, w, a){
snprintf(cup, sizeof(cup), "%s", c);
};
virtual void desc() {
printf("height:%d weight:%d age:%d cup:%s\n", height, weight, age, cup);
}
virtual void name() {
printf("I'm a sensei");
}
char cup[4];
};
int main() {
Sensei s(168, 50, 20, "36D");
s.desc();
Actress* a = &s;
a->desc();
Actress& a2 = s;
a2.desc();
return 0;
}
父类有两个虚函数，子类重载了这两个虚函数。
clang有个命令可以输出对象的内存布局（不同编译器内存布局未必相同，但基本类似）：
clang -cc1 -fdump-record-layouts -stdlib=libc++ actress.cpp
可以得到：
*** Dumping AST Record Layout
0 | class Actress
0 | (Actress vtable pointer)
8 | int height
12 | int weight
16 | int age
| [sizeof=24, dsize=20, align=8,
| nvsize=20, nvalign=8]
*** Dumping AST Record Layout
0 | class Sensei
0 | class Actress (primary base)
0 | (Actress vtable pointer)
8 | int height
12 | int weight
16 | int age
20 | char [4] cup
| [sizeof=24, dsize=24, align=8,
| nvsize=24, nvalign=8]
内存布局、大小、内存对齐都一目了然。
可以发现父类Actress的起始位置多了一个Actress vtable pointer。子类Sensei是在父类的基础上多了自己的成员cup。
也就是说在含有虚函数的类编译期间，编译器会自动给这种类在起始位置追加一个虚表指针，一般称之为：vptr。vptr指向一个虚表，称之为：vtable 或vtbl，虚表中存储了实际的函数地址。
再看下虚表存储了什么东西。你在网上搜一下资料，肯定会说虚表里存储了虚函数的地址，但是其实不止这些！clang同样有命令:
clang -Xclang -fdump-vtable-layouts -stdlib=libc++ -c actress.cpp
g++也有打印虚表的操作（请在Linux上使用g++），会自动写到一个文件里：
g++ -fdump-class-hierarchy actress.cpp
看下clang的结果：
Vtable for 'Actress' (4 entries).
0 | offset_to_top (0)
1 | Actress RTTI
-- (Actress, 0) vtable address --
2 | void Actress::desc()
3 | void Actress::name()
VTable indices for 'Actress' (2 entries).
0 | void Actress::desc()
1 | void Actress::name()
Vtable for 'Sensei' (4 entries).
0 | offset_to_top (0)
1 | Sensei RTTI
-- (Actress, 0) vtable address --
-- (Sensei, 0) vtable address --
2 | void Sensei::desc()
3 | void Sensei::name()
VTable indices for 'Sensei' (2 entries).
0 | void Sensei::desc()
1 | void Sensei::name()
g++的结果（其实也比较清晰，甚至更清晰）：
Vtable for Actress
Actress::_ZTV7Actress: 4u entries
0 (int (*)(...))0
8 (int (*)(...))(& _ZTI7Actress)
16 (int (*)(...))Actress::desc
24 (int (*)(...))Actress::name
Class Actress
size=24 align=8
base size=20 base align=8
Actress (0x0x7f9b1fa8c960) 0
vptr=((& Actress::_ZTV7Actress) + 16u)
Vtable for Sensei
Sensei::_ZTV6Sensei: 4u entries
0 (int (*)(...))0
8 (int (*)(...))(& _ZTI6Sensei)
16 (int (*)(...))Sensei::desc
24 (int (*)(...))Sensei::name
Class Sensei
size=24 align=8
base size=24 base align=8
Sensei (0x0x7f9b1fa81138) 0
vptr=((& Sensei::_ZTV6Sensei) + 16u)
Actress (0x0x7f9b1fa8c9c0) 0
primary-for Sensei (0x0x7f9b1fa81138)
可以看出二者其实基本一致，只是个别名称叫法不同。
所有虚函数的的调用取的是哪个函数（地址）是在运行期间通过查虚表确定的。
更新：vptr指向的并不是虚表的表头，而是直接指向的虚函数的位置。使用gdb或其他工具可以发现：
(gdb) p s
$2 = {<Actress> = {_vptr.Actress = 0x400a70 <vtable for Sensei+16>, height = 168, weight = 50, age = 20}, cup = "36D"}
vptr指向的是Sensei的vtable + 16个字节的位置，也就是虚表的地址。
虚表本身是连续的内存。动态绑定的实现也就相当于（假设p为含有虚函数的对象指针）：
(*(p->vptr)[n])(p)
但其实上面的图片也只是简化版，不是完整的的虚表。通过gdb查看，你其实可以发现子类和父类的虚表是连在一起的。上面gdb打印出了虚表指针指向：0x400a70。我们倒退16个字节（0x400a60）输出一下：
可以发现子类和父类的虚表其实是连续的。并且下面是它们的typeinfo信息也是连续的。
虚表的第一个条目vtable for Sensei值为0。
虚表的第二个条目vtable for Sensei+8指向的其实是0x400ab0，也就是下面的typeinfo for Sensei。
再改一下代码。我们让子类Sensei只重载一个父类函数desc()。
class Sensei: public Actress {
public:
Sensei(int h, int w, int a, const char* c):Actress(h, w, a){
snprintf(cup, sizeof(cup), "%s", c);
};
virtual void desc() {
printf("height:%d weight:%d age:%d cup:%s\n", height, weight, age, cup);
}
char cup[4];
};
其他地方不变，重新用clang或g++刚才的命令执行一遍。clang的输出：
Vtable for 'Actress' (4 entries).
0 | offset_to_top (0)
1 | Actress RTTI
-- (Actress, 0) vtable address --
2 | void Actress::desc()
3 | void Actress::name()
VTable indices for 'Actress' (2 entries).
0 | void Actress::desc()
1 | void Actress::name()
Vtable for 'Sensei' (4 entries).
0 | offset_to_top (0)
1 | Sensei RTTI
-- (Actress, 0) vtable address --
-- (Sensei, 0) vtable address --
2 | void Sensei::desc()
3 | void Actress::name()
VTable indices for 'Sensei' (1 entries).
0 | void Sensei::desc()
可以看到子类的name由于没有重载，所以使用的还是父类的。一图胜千言：
好了，写了这么多，相信大家应该已经能理解虚表存在的意义及其实现原理。但同时我也埋下了新的坑没有填：
虚表中的前两个条目是做什么用的？
它俩其实是为多重继承服务的。
第一个条目存储的offset，是一种被称为 thunk的技术（或者说技巧）。第二个条目存储着为 RTTI服务的type_info信息。
关于这部分的介绍，请关注后续文章！
往期推荐