C++ 虚函数表实现机制详解

![虚函数表结构示意]

需要注意的是，虚函数表末尾通常有一个结束标志。不同编译器下该值可能不同，例如在 Windows 环境下可能是 NULL，而在 Linux GCC 环境下可能是特定的标记位。

一般继承与虚函数覆盖

无虚函数覆盖

当子类未重载任何父类虚函数时，派生类的虚函数表中会包含父类的虚函数。对于实例 Derive d;，其虚函数表结构如下：

![继承后虚函数表结构示意]

关键点在于：

1. 虚函数按声明顺序排列。
2. 父类的虚函数排在子类虚函数之前。

有虚函数覆盖

如果子类覆盖了父类的虚函数，情况会有所变化。假设子类只覆盖了 f() 函数：

![覆盖后的虚函数表结构示意]

此时可以看到：

1. 被覆盖的 f() 函数地址替换了虚表中对应位置的原父类函数地址。
2. 未被覆盖的函数保持不变。

这使得当我们执行 Base* b = new Derive(); b->f(); 时，实际调用的是 Derive::f()，从而实现了多态。

多重继承场景

无虚函数覆盖

在多重继承中，每个父类都有自己的虚函数表。子类实例的内存布局中，会依次存放各个父类的虚函数表指针。

![多重继承虚函数表结构示意]

规则如下：

1. 每个父类维护独立的虚表。
2. 子类新增的成员函数通常放在第一个父类的虚表中（按声明顺序）。

这样设计是为了支持不同静态类型的父类指针指向同一个子类实例时，能正确调用到对应的函数。

有虚函数覆盖

如果在多重继承中发生了虚函数覆盖，所有父类虚表中对应位置的函数指针都会被替换为子类的函数地址。

![多重继承覆盖后虚函数表结构示意]

示例代码：

Derive d;
Base1 *b1 = &d;
Base2 *b2 = &d;
Base3 *b3 = &d;

b1->f(); // 调用 Derive::f()
b2->f(); // 调用 Derive::f()
b3->f(); // 调用 Derive::f()

b1->g(); // 调用 Base1::g()
b2->g(); // 调用 Base2::g()
b3->g(); // 调用 Base3::g()

深入理解与注意事项

了解虚函数表的底层实现有助于我们理解 C++ 的安全边界。虽然编译器限制了某些行为，但通过指针运算仍可能绕过部分限制，这属于底层机制的探索。

访问非公共虚函数

即使父类的虚函数是 private 或 protected，它们依然存在于虚函数表中。理论上可以通过指针算术访问这些函数，但这违反了封装原则。

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(); // 强行调用私有虚函数
}

访问子类特有虚函数

子类特有的虚函数不会出现在父类的虚表中。因此，使用父类指针无法直接调用子类独有的虚函数，编译时会报错。但在运行时，通过直接操作虚函数表指针可以绕过这一限制，不过这种方式极不安全且不具备移植性。

完整示例

下面是一个展示多重继承虚函数表访问的完整例程：

#include <iostream>
using namespace std;

class Base1 {
public:
    virtual void f() { cout << "Base1::f" << endl; }
    virtual void g() { cout << "Base1::g" << endl; }
    virtual void h() { cout << "Base1::h" << endl; }
};

class Base2 {
public:
    virtual void f() { cout << "Base2::f" << endl; }
    virtual void g() { cout << "Base2::g" << endl; }
    virtual void h() { cout << "Base2::h" << endl; }
};

class Base3 {
public:
    virtual void f() { cout << "Base3::f" << endl; }
    virtual void g() { cout << "Base3::g" << endl; }
    virtual void h() { cout << "Base3::h" << endl; }
};

class Derive : public Base1, public Base2, public Base3 {
public:
    virtual void f() { cout << "Derive::f" << endl; }
    virtual void g1() { cout << "Derive::g1" << endl; }
};

typedef void (*Fun)(void);

int main() {
    Fun pFun = NULL;
    Derive d;
    int** pVtab = (int**)&d;

    // Base1's vtable
    pFun = (Fun)pVtab[0][0];
    pFun(); // Derive::f

    pFun = (Fun)pVtab[0][1];
    pFun(); // Base1::g

    // Base2's vtable
    pFun = (Fun)pVtab[1][0];
    pFun(); // Derive::f

    // Base3's vtable
    pFun = (Fun)pVtab[2][0];
    pFun(); // Derive::f

    return 0;
}

通过调试器查看对象实例，也能直观地看到虚函数表的分布情况。理解这些细节，有助于我们在编写高性能、低层级的 C++ 代码时做出更明智的设计决策。