虚函数表(vtable)工作原理
面试考点
虚函数表是 C++ 运行时多态的底层实现机制。面试官通过这道题考察你对多态的理解是否只停留在"基类指针调用派生类函数"的表面,还是真正理解了编译器是怎么做到的。
核心机制
每个包含虚函数的类,编译器会为它生成一个虚函数表(vtable),这是一个函数指针数组,每个元素指向该类对应的虚函数实现。每个对象内部会有一个隐藏的指针(vptr),指向所属类的 vtable。调用虚函数时,通过 vptr 找到 vtable,再通过 vtable 找到实际要调用的函数。
对象内存布局:
+--------+------------------+
| vptr | 成员变量... |
+--------+------------------+
|
v
vtable(函数指针数组):
+-------------------+
| &function1 | -> 指向该类的 function1 实现
+-------------------+
| &function2 | -> 指向该类的 function2 实现
+-------------------+基本示例
#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。