C++虚函数表（vptr）内存布局与实现原理详解

面试中只要涉及 C++ 面向对象，虚函数表几乎是一个必问的话题。很多同学对于虚函数是如何被调度的、对象内存中究竟存了些什么，总感觉模模糊糊。大家可能知道“有一个 vptr 指向 vtable”，但它在内存中的真实样貌如何，却难以清晰表述。

实际上，虚函数表并不神秘，它只是编译器为实现运行时多态而生成的一种数据结构。深入理解其内存布局，对于掌握 C++ 对象模型、进行性能优化乃至排查线上问题都大有裨益。

本文将通过代码示例，将几个关键问题讲透彻，让你对 vptr 和 vtable 的理解不再停留在抽象概念。

01 虚函数表到底存在哪里？对象里有哪些隐藏字段？

让我们从一个最简单的例子开始：

#include <iostream>

class Base {
public:
    virtual void foo() { std::cout << "Base::foo\n"; }
    virtual void bar() { std::cout << "Base::bar\n"; }
    int x = 42;
};

int main() {
    Base b;
    std::cout << sizeof(b) << std::endl;
}

Base 类包含两个虚函数和一个 int 类型成员变量。

在绝大多数遵循 Itanium ABI（如 GCC/Clang）的编译器中，对象 b 的内存布局大致如下：

| vptr | x |

vptr 是一个指向虚函数表的指针；x 则是我们显式声明的成员变量。

在 64 位系统下：

• vptr 占用 8 字节。
• x 占用 4 字节，通常会进行内存对齐，最终整个对象大小为 16 字节。

因此，在大部分环境下 sizeof(Base) 的输出结果是 16。

如果你想查看 vptr 的具体值，可以这样操作：

std::cout << *(void**)&b << std::endl;

这会打印出一个地址，它就是虚函数表的起始地址。

需要明确的是，虚函数表并不在对象内部，它位于全局只读数据段（通常是 .rodata 段），同一类型的所有对象共享同一张虚函数表。

02 vtable 里到底放了什么？

我们可以通过解引用 vtable 地址，来窥探其内部内容。

using Func = void(*)();

int main() {
    Base b;

    void** vtable = *(void***)&b;

    std::cout << "vtable: " << vtable << "\n";
    std::cout << "slot 0: " << (Func)vtable[0] << "\n";
    std::cout << "slot 1: " << (Func)vtable[1] << "\n";

    ((Func)vtable[0])();
    ((Func)vtable[1])();
}

输出结果可能类似：

vtable: 0x55aa...
slot 0: 0x55aa...
slot 1: 0x55aa...
Base::foo
Base::bar

这清晰地表明：

• vtable 是一个连续的函数指针数组。
• 数组下标 0 的位置存放着 foo 函数的地址。
• 数组下标 1 的位置存放着 bar 函数的地址。

实际上，编译器通常还会在表中存入 RTTI、typeinfo 等辅助信息，但这部分因 ABI 不同而差异较大，本文主要聚焦于面试中常问的核心部分。

03 虚函数重写后，表里的内容是怎么变的？

虚函数表 最大的价值体现在“覆盖”（Override）机制上。

class Derived : public Base {
public:
    void foo() override { std::cout << "Derived::foo\n"; }
    int y = 7;
};

对象 Derived d; 的内存布局如下：

| vptr (Derived 的 vtable) | x | y |

此时，Derived 类的虚函数表内容变为：

slot 0: Derived::foo
slot 1: Base::bar

也就是说：

• foo 被派生类覆盖 → 表中 slot0 的指针被替换为 Derived::foo 的地址。
• bar 未被覆盖 → 继承基类虚函数表中 slot1 的指针（即 Base::bar 的地址）。

这也解释了为什么“虚函数覆盖要求函数签名严格一致”，否则虚函数表的槽位就无法正确对齐。

04 多继承时，为什么会出现多个 vptr？

单继承的情况相对容易理解，而多继承则是面试中的高频考点。

class A {
public:
    virtual void a() { std::cout << “A::a\n”; }
};

class B {
public:
    virtual void b() { std::cout << “B::b\n”; }
};

class C : public A, public B {
public:
    void a() override { std::cout << “C::a\n”; }
    void b() override { std::cout << “C::b\n”; }
};

对于 C 类的对象，其内存布局可能如下：

| vptr_A |     // 指向 A 子对象的虚表
| A 部分数据 |
| vptr_B |     // 指向 B 子对象的虚表
| B 部分数据 |

关键点在于：

• C 对象内部包含多个 vptr，每个直接基类对应一个。
• 每个基类子对象拥有自己独立的虚函数表。

这也是多继承会导致对象尺寸变大的一个主要原因。你可以通过指针偏移来验证这一点：

C c;
A* pa = &c;
B* pb = &c;

std::cout << pa << std::endl;
std::cout << pb << std::endl;

你会发现 pa 和 pb 的值（地址）并不相同。编译器在转换时进行了指针偏移调整，让每个基类指针都正确地指向对象内属于该基类的“子对象”区域。

05 虚函数调用时到底发生了什么？为什么速度比普通函数慢？

根本原因在于多了一次通过 vptr 间接查找函数指针的过程。

• 普通成员函数调用：直接跳转到编译期已确定的函数地址。
• 虚函数调用：1. 从对象中取得 vptr；2. 通过 vptr 找到虚函数表，并索引到第 n 个槽位；3. 跳转到该槽位存储的函数地址。

这多出来的一层间接寻址（indirection）就是虚函数调用稍慢的原因。不过，这个开销通常很小（约 5~20 纳秒），除非在极端性能敏感的热代码路径上，否则绝大多数场景下可以忽略不计。

06 为什么析构函数必须是虚的？不写虚析构会有什么问题？

这是与虚函数表紧密相关的经典面试题。

Base* p = new Derived();
delete p;

如果 Base 的析构函数不是虚函数，那么 delete p; 这条语句只会调用 Base::~Base()，而不会调用 Derived::~Derived()。这将导致派生类独有的资源（如动态分配的内存、文件句柄等）无法被正确释放，从而引发资源泄漏。

因为 delete 操作符在析构对象时，其调用逻辑依赖于虚函数表。非虚函数不会进入虚表，自然也就无法实现多态调用。

07 vptr 会被优化掉吗？可以自己控制虚表吗？

几个实践中的关键认知：

（1）只要类中声明了虚函数，vptr 就一定存在
这是应用程序二进制接口（ABI）的要求，编译器不会因为某个虚函数暂时没被使用而将其优化掉。

（2）vptr 在对象构造和析构过程中会被动态写入和修改
具体过程如下：

• 构造顺序：Base() 构造 → vptr 被设为指向 Base::vtable；Derived() 构造 → vptr 被修改为指向 Derived::vtable。
• 析构顺序：相反。Derived::~Derived() 执行 → vptr 被改回指向 Base::vtable；然后执行 Base::~Base()。

这就导致了另一个经典问题：“在构造函数或析构函数中调用虚函数，不会发生多态行为”。因为在此期间，虚函数表尚未切换到最终状态或已被切换回父类状态。

08 用代码手动“观察” vptr 的变化

为了让读者更具体地感受构造和析构期间 vptr 的切换过程，这里提供一个可运行的示例。

class Base {
public:
    Base() { observe("Base Ctor"); }
    virtual void foo() { }
    virtual ~Base() { observe("Base Dtor"); }

    void observe(const char* stage) {
        std::cout << stage << " vptr=" << *(void**)this << '\n';
    }
};

class Derived : public Base {
public:
    Derived() { observe("Derived Ctor"); }
    void foo() override { }
    ~Derived() { observe("Derived Dtor"); }
};

int main() {
    Derived d;
}

在某些编译器下的输出可能类似：

Base Ctor vptr=0x...Base::vtable
Derived Ctor vptr=0x...Derived::vtable
Derived Dtor vptr=0x...Derived::vtable
Base Dtor vptr=0x...Base::vtable

你可以清晰地看到，在对象的生命周期中，vptr 被切换了两次。

09 面试里关于 vtable 最高频的几个问题

最后做一个梳理，方便你巩固记忆：

• 虚函数机制：通过对象内部的 vptr 实现，vptr 指向一个全局的虚函数表（vtable）。
• 表共享：同一类型的所有对象共享同一张虚函数表。
• 继承差异：单继承只有一个 vptr；多继承可能有多个 vptr（每个直接基类一个）。
• 覆盖原理：虚函数重写会替换虚函数表中对应槽位的函数指针。
• 虚析构必要性：基类析构函数必须为虚函数，否则通过基类指针删除派生类对象会导致资源泄漏。
• 构造/析构中的多态：在构造函数和析构函数中调用虚函数，不会发生多态行为。
• 性能开销：虚函数调用比普通成员函数调用多一次指针跳转，但现代 CPU 上开销很小。

理解以上七点，面试官就很难再在虚函数表相关问题上难倒你了。

扩展与提升

理解底层原理是基础，但将知识应用于实际项目才能产生更大价值。如果你想在理解C++对象模型的基础上，进一步通过实战项目巩固内存管理、多态应用等技能，可以关注一些系统性的训练项目。例如，通过实现一个高性能日志库来深入理解对象生命周期与资源管理，或通过开发一个自制RPC框架来实践多态在复杂架构中的应用。

图：一个C++实战项目可能涉及的知识模块与工具链

这类项目能帮助你串联起从语言特性到系统设计的知识，是提升C++工程能力的有效途径。更多技术讨论和项目资源，欢迎在专业的开发者社区如 云栈社区 中进行交流。