为什么printf里面出现分点时换行会报错_C++为什么需要虚表？

​首先声明一点，虚表并非是C++语言的官方标准的一部分，只是各家编译器厂商在实现多态时的解决方案。另外即使同为虚表不同的编译器对于虚表的设计可能也是不同的，本文主要基于Itanium C++ ABI(适用于gcc和clang)。

从C的POD类型到C++的类

回顾一下C语言纯POD的结构体(struct)。

如果用C语言实现一个类似面向对象的类，应该怎么做呢？

// 写法一#include 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", 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 typedef struct Actress {      int height; // 身高      int weight; // 体重      int age;    // 年龄(注意，这不是数据库，不必一定存储生日)​} Actress;void desc(Actress* obj) {      printf("height:%d weight:%d age:%d", 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 class Actress {public:      int height; // 身高      int weight; // 体重      int age;    // 年龄(注意，这不是数据库，不必一定存储生日)  void desc() {            printf("height:%d weight:%d age:%d", 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指导方针的一个体现)。当然实际并不完全一致，因为C++支持重载的关系，会存在命名崩坏。但主要思想相同，虽不中，亦不远矣。

You shouldn't pay for what you don't use.

看到这，你会明白：C++中类和操作的封装只是对于程序员而言的。而编译器编译之后其实还是面向过程的代码。编译器帮你给成员函数增加一个额外的类指针参数，运行期间传入对象实际的指针。类的数据(成员变量)和操作(成员函数)其实还是分离的。

每个函数都有地址(指针)，不管是全局函数还是成员函数在编译之后几乎类似。

在类不含有虚函数的情况下，编译器在编译期间就会把函数的地址确定下来，运行期间直接去调用这个地址的函数即可。这种函数调用方式也就是所谓的『静态绑定』(static binding)。

虚函数的用法与多态的概念

虚函数的出现其实就是为了实现面向对象三个特性之一的『多态』。何谓多态(polymorphism)？

#include #include 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", 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", 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 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", 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", 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 ActressActress::_ZTV7Actress: 4u entries0     (int (*)(...))08     (int (*)(...))(& _ZTI7Actress)16    (int (*)(...))Actress::desc24    (int (*)(...))Actress::nameClass Actress   size=24 align=8   base size=20 base align=8Actress (0x0x7f9b1fa8c960) 0    vptr=((& Actress::_ZTV7Actress) + 16u)Vtable for SenseiSensei::_ZTV6Sensei: 4u entries0     (int (*)(...))08     (int (*)(...))(& _ZTI6Sensei)16    (int (*)(...))Sensei::desc24    (int (*)(...))Sensei::nameClass Sensei   size=24 align=8   base size=24 base align=8Sensei (0x0x7f9b1fa81138) 0    vptr=((& Sensei::_ZTV6Sensei) + 16u)  Actress (0x0x7f9b1fa8c9c0) 0      primary-for Sensei (0x0x7f9b1fa81138)

可以看出二者其实基本一致，只是个别名称叫法不同。

所有虚函数的的调用取的是哪个函数(地址)是在运行期间通过查虚表确定的。

更新：vptr指向的并不是虚表的表头，而是直接指向的虚函数的位置。使用gdb或其他工具可以发现：

(gdb) p s$2 = { = {_vptr.Actress = 0x400a70 , 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", 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信息。关于这些的介绍，感兴趣的话，请关注后续文章！