虚函数表(vtable)工作原理 ​

面试考点 ​

虚函数表是 C++ 运行时多态的底层实现机制。面试官通过这道题考察你对多态的理解是否只停留在"基类指针调用派生类函数"的表面,还是真正理解了编译器是怎么做到的。

核心机制 ​

每个包含虚函数的类,编译器会为它生成一个虚函数表(vtable),这是一个函数指针数组,每个元素指向该类对应的虚函数实现。每个对象内部会有一个隐藏的指针(vptr),指向所属类的 vtable。调用虚函数时,通过 vptr 找到 vtable,再通过 vtable 找到实际要调用的函数。

对象内存布局:
+--------+------------------+
|  vptr  |  成员变量...      |
+--------+------------------+
    |
    v
vtable(函数指针数组):
+-------------------+
| &function1        |  -> 指向该类的 function1 实现
+-------------------+
| &function2        |  -> 指向该类的 function2 实现
+-------------------+

基本示例 ​

cpp
#include <iostream>

// ============================
// 示例1:虚函数表的基本工作流程
// ============================

class Base {
public:
    virtual void func1() {
        std::cout << "Base::func1()" << std::endl;
    }

    virtual void func2() {
        std::cout << "Base::func2()" << std::endl;
    }

    virtual ~Base() {
        std::cout << "Base::~Base()" << std::endl;
    }
};

class Derived : public Base {
public:
    // 覆写 func1
    void func1() override {
        std::cout << "Derived::func1()" << std::endl;
    }

    // func2 没有覆写,继承 Base 的版本

    ~Derived() override {
        std::cout << "Derived::~Derived()" << std::endl;
    }
};

/*
编译器生成的 vtable:

Base 的 vtable:
  [0] -> Base::func1()
  [1] -> Base::func2()
  [2] -> Base::~Base()

Derived 的 vtable:
  [0] -> Derived::func1()    // 覆写了
  [1] -> Base::func2()       // 继承的
  [2] -> Derived::~Derived() // 覆写了
*/

void vtable_demo() {
    Base* p = new Derived();  // p 的 vptr 指向 Derived 的 vtable

    p->func1();  // vptr -> Derived vtable -> [0] -> Derived::func1()
    p->func2();  // vptr -> Derived vtable -> [1] -> Base::func2()

    delete p;    // vptr -> Derived vtable -> [2] -> Derived::~Derived()
}

// ============================
// 示例2:sizeof 验证 vptr 的存在
// ============================

class NoVirtual {
    int x;
};

class WithVirtual {
    int x;
    virtual void foo() {}
};

void sizeof_demo() {
    std::cout << "无虚函数: sizeof = " << sizeof(NoVirtual) << std::endl;
    // 通常是 4(只有一个 int)

    std::cout << "有虚函数: sizeof = " << sizeof(WithVirtual) << std::endl;
    // 通常是 16(int + 对齐 + vptr,64 位系统)
    // vptr 占 8 字节(64 位),加上 int 的 4 字节再对齐
}

// ============================
// 示例3:多态调用过程
// ============================

class Animal {
public:
    virtual void speak() {
        std::cout << "..." << std::endl;
    }
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "汪汪" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "喵喵" << std::endl;
    }
};

// 这个函数不知道实际类型,通过 vtable 找到正确的函数
void make_speak(Animal* animal) {
    // 编译器生成的伪代码:
    // auto vtbl = animal->vptr;
    // auto fn = vtbl[speak的索引];
    // fn(animal);
    animal->speak();
}

void polymorphism_demo() {
    Dog dog;
    Cat cat;

    make_speak(&dog);  // vptr -> Dog vtable -> Dog::speak()
    make_speak(&cat);  // vptr -> Cat vtable -> Cat::speak()
}

// ============================
// 示例4:构造函数中 vptr 的变化
// ============================

class Parent {
public:
    Parent() {
        // 此时 vptr 指向 Parent 的 vtable
        // 在构造函数中调用虚函数,调用的是 Parent 的版本
        who();
    }

    virtual void who() {
        std::cout << "Parent::who()" << std::endl;
    }

    virtual ~Parent() = default;
};

class Child : public Parent {
public:
    Child() {
        // 此时 vptr 已经被更新为指向 Child 的 vtable
        who();
    }

    void who() override {
        std::cout << "Child::who()" << std::endl;
    }
};

void constructor_vptr_demo() {
    // 创建 Child 对象时:
    // 1. 先调用 Parent 构造函数,vptr 指向 Parent vtable -> Parent::who()
    // 2. 再调用 Child 构造函数,vptr 指向 Child vtable -> Child::who()
    Child c;
}

int main() {
    std::cout << "=== vtable 基本流程 ===" << std::endl;
    vtable_demo();

    std::cout << "\n=== sizeof 验证 ===" << std::endl;
    sizeof_demo();

    std::cout << "\n=== 多态调用 ===" << std::endl;
    polymorphism_demo();

    std::cout << "\n=== 构造函数中的 vptr ===" << std::endl;
    constructor_vptr_demo();

    return 0;
}

虚函数调用 vs 普通函数调用 ​

特性普通函数调用虚函数调用
绑定时机编译期(静态绑定)运行时(动态绑定)
调用方式直接调用函数地址通过 vptr -> vtable 间接调用
额外开销无1-2 次指针解引用
内联可能可以内联通常不能内联
对象大小影响无每个对象增加一个 vptr(8 字节)

常见问题 ​

构造函数中调用虚函数会怎样?

构造函数中调用虚函数不会表现出多态行为。因为在基类构造函数执行时,vptr 指向的是基类的 vtable(派生类还没构造),所以调用的是基类版本的虚函数。

析构函数应该是虚函数吗?

如果类作为基类使用(通过基类指针 delete 派生类对象),析构函数必须是虚函数。否则只会调用基类的析构函数,派生类的资源不会被释放。

虚函数能不能是内联的?

通过基类指针/引用调用时不能内联(因为编译期不知道实际类型)。但如果编译器能确定实际类型(如直接通过对象调用),可以进行去虚拟化优化(devirtualization),此时可以内联。

每个对象都有自己的 vtable 吗?

不是。每个类有一个 vtable,同一个类的所有对象共享同一个 vtable。每个对象只有一个 vptr 指向类的 vtable。

适用场景 ​

  • 需要运行时多态的场景
  • 基类指针/引用调用派生类函数
  • 插件系统、策略模式等设计模式

注意事项 ​

  • 有虚函数的类每个对象会多一个 vptr(通常 8 字节)
  • 虚函数调用比普通调用慢(多 1-2 次指针解引用)
  • 构造函数和析构函数中不要依赖虚函数的多态行为
  • 基类析构函数应声明为 virtual
  • final 关键字可以帮助编译器做去虚拟化优化

总结 ​

虚函数表是 C++ 运行时多态的核心实现。编译器为每个有虚函数的类生成一个 vtable(函数指针数组),每个对象内部有一个 vptr 指向类的 vtable。调用虚函数时,通过 vptr 查找 vtable 中对应的函数指针来完成间接调用。面试中要能解释这个流程,并知道:每个类一个 vtable、每个对象一个 vptr、构造函数中 vptr 逐步更新、虚函数有额外开销、基类析构函数应为 virtual。