C++虚函数之虚函数表浅析

C++  “虚函数”的存在是为了实现面向对象中的“多态”，即父类类别的指针（或者引用）指向其子类的实例，然后通过父类的指针（或者引用）调用实际子类的成员函数。通过动态赋值，实现调用不同的子类的成员函数（动态绑定）。正是因为这种机制，把析构函数声明为“虚函数”可以防止在内存泄露。

 

为了支持虚函数机制，编译器为每一个拥有虚函数的类的实例创建了一个虚函数表（virtual table），这个表中有许多的槽（slot），每个槽中存放的是虚函数的地址。虚函数表解决了继承、覆盖、添加虚函数的问题，保证其真实反应实际的函数。这样，在有虚函数的类的实例中分配了指向这个表的指针的内存，所以，当用父类的指针来操作一个子类的时候，这张虚函数表就显得尤为重要了，它就像一个地图一样，指明了实际所应该调用的函数。为了能够找到 virtual table，编译器在每个拥有虚函数的类的实例中插入了一个成员指针 vptr，指向虚函数表。编译器应该保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。 这意味着可以通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

下面是一个例子：

class Base{public:virtual void x() { cout << "Base::x()" << endl; }virtual void y() { cout << "Base::y()" << endl; }virtual void z() { cout << "Base::z()" << endl; }};typedef void(*pFun)(void);int main(){Base b;int* vptr = (int*)&b;                     // 虚函数表地址pFun func1 = (pFun)*((int*)*vptr);        // 第一个函数pFun func2 = (pFun)*((int*)*vptr+1);      // 第二个函数pFun func3 = (pFun)*((int*)*vptr+2);      // 第三个函数func1();     // 输出Base::x()func2();     // 输出Base::y()func3();     // 输出Base::z()return 0;}

上面定义了一个Base类，其中有三个虚函数。我们将Base类对象取址 &b 并强制转换为 int*，取得虚函数表的地址。然后对虚函数表的地址取值 \vptr 并强转为 int*，即取得第一个虚函数的地址了，也就是Base::x()。将第一个虚函数的地址加1，取得第二个虚函数的地址，再加1即取得第三个虚函数的地址。

即：

  (pFun)*((int*)*(int*)(&b)+0);  // Base::x()

            (pFun)*((int*)*(int*)(&b)+1);  // Base::y()

            (pFun)*((int*)*(int*)(&b)+2);  // Base::z()

注意，之所以可以通过对象实例的地址得到虚函数表，是因为 vptr 指针位于对象实例的最前面（这是由编译器决定的，主要是为了保证取到虚函数表有最高的性能——如果有多层继承或是多重继承的情况下）。如图所示：

单继承时的虚函数表

1、无虚函数覆盖

假如现有单继承关系如下：

class Base{public:virtual void x() { cout << "Base::x()" << endl; }virtual void y() { cout << "Base::y()" << endl; }virtual void z() { cout << "Base::z()" << endl; }};class Derive : public Base{public:virtual void x1() { cout << "Derive::x1()" << endl; }virtual void y1() { cout << "Derive::y1()" << endl; }virtual void z1() { cout << "Derive::z1()" << endl; }};

在这个单继承的关系中，子类没有重写父类的任何方法，而是加入了三个新的虚函数。Derive类实例的虚函数表布局如图示：

• Derive class 继承了 Base class 中的三个虚函数，准确的说，是该函数实体的地址被拷贝到 Derive 实例的虚函数表对应的 slot 之中。
• 新增的 虚函数 置于虚函数表的后面，并按声明顺序存放。

2、有虚函数覆盖

如果在继承关系中，子类重写了父类的虚函数：

class Base{public:virtual void x() { cout << "Base::x()" << endl; }virtual void y() { cout << "Base::y()" << endl; }virtual void z() { cout << "Base::z()" << endl; }};class Derive : public Base{public:virtual void x() { cout << "Derive::x()" << endl; }  // 重写virtual void y1() { cout << "Derive::y1()" << endl; }virtual void z1() { cout << "Derive::z1()" << endl; }};

则Derive类实例的虚函数表布局为：

相比于无覆盖的情况，只是把 Derive::x() 覆盖了Base::x()，即第一个槽的函数地址发生了变化，其他的没有变化。这时，如果通过绑定了子类对象的基类指针调用函数 x()，会执行 Derive 版本的 x()，这就是多态。

多重继承时的虚函数表

1、无虚函数覆盖

现有如下的多重继承关系，子类没有覆盖父类的虚函数：

class Base1{public:virtual void x() { cout << "Base1::x()" << endl; }virtual void y() { cout << "Base1::y()" << endl; }virtual void z() { cout << "Base1::z()" << endl; }};class Base2{public:virtual void x() { cout << "Base2::x()" << endl; }  virtual void y() { cout << "Base2::y()" << endl; }virtual void z() { cout << "Base2::z()" << endl; }};class Derive : public Base1, public Base2{public:virtual void x1() { cout << "Derive::x1()" << endl; }  virtual void y1() { cout << "Derive::y1()" << endl; }};

对于 Derive 实例 d 的虚函数表布局，如下图：

可以看出：

• 每个基类子对象对应一个虚函数表。
• 派生类中新增的虚函数放到第一个虚函数表的后面。

2、有虚函数覆盖

将上面的多重继承关系稍作修改，让子类重写基类的 x() 函数：

class Base1{public:virtual void x() { cout << "Base1::x()" << endl; }virtual void y() { cout << "Base1::y()" << endl; }virtual void z() { cout << "Base1::z()" << endl; }};class Base2{public:virtual void x() { cout << "Base2::x()" << endl; }  virtual void y() { cout << "Base2::y()" << endl; }virtual void z() { cout << "Base2::z()" << endl; }};class Derive : public Base1, public Base2{public:virtual void x() { cout << "Derive::x()" << endl; }     // 重写virtual void y1() { cout << "Derive::y1()" << endl; }};

这时 Derive 实例的虚函数表布局会变成下面这个样子：

相比于无覆盖的情况，只是将Derive::x()覆盖了Base1::x()和Base2::x()而已，你可以自己写测试代码测试一下，这里就不再赘述了。

注：若虚函数是 private 或 protected 的，我们照样可以通过访问虚函数表来访问这些虚函数，即上面的测试代码一样能运行。

安全性

 

一、通过父类型的指针访问子类自己的虚函数

我们知道，子类没有重写父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重写的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：

 

          Base1 *b1 = new Derive();

            b1->f1();  //编译出错

 

任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。（关于这方面的尝试，通过阅读后面附录的代码，相信你可以做到这一点）

 

 

二、访问non-public的虚函数

另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。

如：

class Base {    private:            virtual void f() { cout << "Base::f" << endl; } }; class Derive : public Base{ }; typedef void(*Fun)(void); void main() {    Derive d;    Fun  pFun = (Fun)*((int*)*(int*)(&d)+0);    pFun();}

参考资料：

http://blog.csdn.net/haoel/article/details/1948051

http://songlee24.github.io/2014/09/02/cpp-virtual-table/