C++为什么要弄出虚表这个东西？

发表于 2年以前 | 总阅读数：258 次

首先声明一点，虚表并非是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由于没有重载，所以使用的还是父类的。一图胜千言：

好了，写了这么多，相信大家应该已经能理解虚表存在的意义及其实现原理。但同时我也埋下了新的坑没有填：