首先声明一点，虚表并非是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信息。
