C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

前言

在上一篇文章中，我们已经看到多态通常是怎么用的：

Base* ptr = new Derived;
ptr->func();

尽管 ptr 的类型是 Base*，但实际调用的却可能是 Derived::func()。这背后藏着不少值得深挖的问题：

• 编译器到底怎么知道指针实际指向哪种对象？
• 静态绑定和动态绑定到底有什么区别？
• 什么是虚函数表和虚函数表指针？
• 派生类重写虚函数后，虚表发生了什么变化？
• 为什么含有虚函数的对象可能会变大？
• 为什么构造和析构期间不会调用更派生类版本？
• 如何保存一组不同类型的多态对象？
• dynamic_cast 应该在什么时候使用？
• 虚函数会带来多大性能开销？

本文从底层原理和实际工程两个角度，继续深入讲解 C++ 多态。

一、静态类型和动态类型

1.1 静态类型

静态类型是编译器直接从代码中读到的类型。

class Animal
{
public:
    virtual void talk() const
    {
    }
    virtual ~Animal() = default;
};
class Dog : public Animal
{
public:
    void talk() const override
    {
    }
};

创建对象：

Dog dog;
Animal* ptr = &dog;

这里：

dog 的静态类型：Dog
ptr 的静态类型：Animal*
*ptr 表达式的静态类型：Animal

静态类型在编译阶段就已经确定，无法改变。

1.2 动态类型

动态类型是对象在程序运行时的实际类型。

Animal* ptr = &dog;

虽然 ptr 的静态类型是 Animal*，但它实际指向的是一个 Dog 对象。因此，它指向对象的动态类型是：

Dog

1.3 两种类型的作用

对于非虚函数调用：

ptr->normalFunc();

调用版本主要由静态类型决定。

对于虚函数调用：

ptr->talk();

最终版本由对象的动态类型决定。

简单来说：

非虚函数看指针或引用声明成什么类型
虚函数看指针或引用实际指向什么对象

二、静态绑定和动态绑定

2.1 静态绑定

函数调用目标在编译阶段确定，称为静态绑定。

#include 
using namespace std;
class Base
{
public:
    void func()
    {
        cout << "Base::func()" << 'n';
    }
};
class Derived : public Base
{
public:
    void func()
    {
        cout << "Derived::func()" << 'n';
    }
};
int main()
{
    Derived object;
    Base* ptr = &object;
    ptr->func();
    return 0;
}

输出：

Base::func()

因为 func() 不是虚函数，编译器根据 ptr 的静态类型 Base*，直接确定调用 Base::func()。

2.2 动态绑定

把基类函数改成虚函数：

class Base
{
public:
    virtual void func()
    {
        cout << "Base::func()" << 'n';
    }
    virtual ~Base() = default;
};

派生类完成重写：

class Derived : public Base
{
public:
    void func() override
    {
        cout << "Derived::func()" << 'n';
    }
};

再次调用：

Derived object;
Base* ptr = &object;
ptr->func();

输出变成：

Derived::func()

函数调用目标需要根据实际对象类型，在运行时确定，这就是动态绑定。

三、多态底层一定使用虚函数表吗？

先给出一个重要结论：

C++ 标准规定了虚函数调用应当表现出的行为，但没有强制编译器必须使用某种固定的底层结构。

主流编译器通常通过下面两个结构实现动态多态：

vptr：虚函数表指针
vtable：虚函数表

这是常见实现方式，但不是可以跨平台依赖的语言规则。不同编译器、操作系统和 ABI 可能采用不同的对象布局。

四、虚函数表指针 vptr

4.1 普通类对象

class Normal
{
private:
    int _value;
};

Normal 对象通常只需要保存 _value 以及必要的内存对齐空间。

4.2 含有虚函数的类

class Base
{
public:
    virtual void func()
    {
    }
private:
    int _value;
};

主流实现通常会在对象中加入一个隐藏指针 vptr，它指向当前对象所属类型的虚函数表。可以抽象理解为：

Base 对象
├── vptr ─────→ Base 虚函数表
└── _value

4.3 vptr 由编译器维护

vptr 并不是我们在类中显式声明的成员，它通常由编译器自动添加并维护。对象构造和析构过程中，编译器会根据当前阶段设置对应的虚表指针。

4.4 vptr 不一定在对象开头

很多调试器中会看到 vptr 位于对象起始位置，但这不是语言标准保证的。下面这些因素都可能影响对象布局：

编译器
ABI
平台位数
单继承
多继承
虚继承
成员对齐

因此，不能通过手工计算固定偏移访问 vptr。

五、虚函数表 vtable

5.1 虚表存储什么？

虚函数表可以抽象理解为一个函数地址表。

class Base
{
public:
    virtual void func1()
    {
    }
    virtual void func2()
    {
    }
};

对应的虚表可以抽象为：

Base vtable
├── &Base::func1
└── &Base::func2

对象中的 vptr 指向这张表。

5.2 同类型对象通常共享虚表

Base object1;
Base object2;

两个对象的数据成员相互独立，但它们通常指向同一张 Base 虚表：

object1.vptr ─┐
              ├──→ Base vtable
object2.vptr ─┘

也就是说：

每个对象保存自己的 vptr
同类型对象通常共享同一张 vtable

5.3 虚函数代码不在虚表中

虚函数和普通函数一样，编译后都是机器指令，通常位于程序的代码区域。虚表中保存的是虚函数地址，或者用于定位虚函数的相关信息，而不是完整的函数代码。

六、派生类的虚函数表

6.1 基类虚表

class Base
{
public:
    virtual void func1()
    {
        cout << "Base::func1()" << 'n';
    }
    virtual void func2()
    {
        cout << "Base::func2()" << 'n';
    }
};

可以抽象成：

Base vtable
├── Base::func1
└── Base::func2

6.2 派生类重写虚函数

class Derived : public Base
{
public:
    void func1() override
    {
        cout << "Derived::func1()" << 'n';
    }

    virtual void func3()
    {
        cout << "Derived::func3()" << 'n';
    }
};

派生类虚表可以抽象成：

Derived vtable
├── Derived::func1
├── Base::func2
└── Derived::func3

其中：

func1：派生类完成重写，槽位改为 Derived::func1
func2：没有重写，继续使用 Base::func2
func3：派生类新增虚函数

6.3 重写不会修改基类虚表

Derived 重写 func1() 时，并不是直接修改 Base 的虚表。通常是：

Base 对象    -> Base vtable
Derived 对象 -> Derived vtable

两种类型拥有各自对应的虚表。

七、一次虚函数调用的大致过程

假设：

Base* ptr = new Derived;
ptr->func1();

常见实现中的调用过程可以抽象为：

1. 通过 ptr 找到实际对象
2. 从对象中读取 vptr
3. 通过 vptr 找到虚函数表
4. 找到 func1 对应的虚表槽位
5. 取得最终函数地址
6. 调用 Derived::func1

示意：

Base* ptr
    |
    v
Derived 对象
├── vptr
│    |
│    v
│  Derived vtable
│  ├── Derived::func1
│  ├── Base::func2
│  └── Derived::func3
│
└── 数据成员

多态调用的关键不在于变量名叫 ptr，而在于 ptr 实际指向的对象具有什么动态类型。

八、对象大小为什么可能发生变化？

8.1 普通类

class Normal
{
private:
    int _value;
};

在常见环境中，对象大小主要由数据成员和内存对齐决定。

8.2 多态类

class Base
{
public:
    virtual void func()
    {
    }
private:
    int _value;
};

常见实现中，对象还需要保存一个 vptr，因此对象大小可能增加。

8.3 不要死记固定大小

在 32 位环境中，指针通常占 4 字节。在 64 位环境中，指针通常占 8 字节。但最终对象大小还会受到成员排列、内存对齐、编译器、ABI、多继承、虚继承等因素影响。

更准确的说法是：多态对象通常需要额外保存动态分派信息，常见形式是一个或多个虚表指针。

九、构造期间为什么不会调用派生类版本？

看下面的代码：

#include 
using namespace std;
class Base
{
public:
    Base()
    {
        func();
    }
    virtual void func()
    {
        cout << "Base::func()" << 'n';
    }
    virtual ~Base() = default;
};
class Derived : public Base
{
public:
    void func() override
    {
        cout << "Derived::func()" << 'n';
    }
};

创建对象：

Derived object;

在 Base 构造函数中执行 func()，调用的是 Base::func()，而不是 Derived::func()。

9.1 原因

构造 Derived 时，顺序大致是：先构造 Base 部分，再构造 Derived 部分。执行 Base 构造函数时，Derived 部分还没有完成初始化。如果此时调用 Derived::func()，它可能访问尚未初始化的派生类成员。因此，构造期间的虚函数调用不会分派到更派生类版本。

十、析构期间的虚函数调用

析构顺序和构造相反：先析构 Derived，再析构 Base。当程序进入 Base 析构函数时，Derived 部分已经被销毁。因此，在基类析构阶段调用虚函数，也不会再分派到 Derived 的重写版本。

10.1 实际建议

不要在构造函数和析构函数中依赖运行时多态。尤其不要在基类构造函数中调用需要访问派生类状态的虚函数。更合适的设计包括：

构造完成后显式调用初始化函数
使用工厂函数创建对象
通过构造参数传递必要信息
把公共初始化放入非虚函数

十一、访问权限和虚函数重写

访问权限不会阻止虚函数重写。

class Base
{
public:
    virtual void func()
    {
        cout << "Base::func()" << 'n';
    }
};
class Derived : public Base
{
private:
    void func() override
    {
        cout << "Derived::func()" << 'n';
    }
};

调用：

Derived object;
Base& ref = object;
ref.func();

这段代码可以通过编译，并调用 Derived::func()。因为：

是否允许通过 Base 接口调用：检查 Base::func 的访问权限
最终执行哪个版本：根据动态类型进行虚函数分派

但直接写 object.func(); 会编译失败，因为 Derived::func() 是 private。

可以简单理解为：

是否构成重写：看虚函数规则
能否直接调用：看访问权限

十二、多继承中的虚表

简单单继承中，一个多态对象通常表现为一个虚表指针。但在多继承中，一个对象可能包含多个多态基类子对象。

class Scanner
{
public:
    virtual void scan()
    {
    }
    virtual ~Scanner() = default;
};
class Printer
{
public:
    virtual void print()
    {
    }
    virtual ~Printer() = default;
};
class AllInOne : public Scanner, public Printer
{
};

AllInOne 对象可以抽象成：

AllInOne
├── Scanner 子对象
│   └── Scanner 对应的 vptr
├── Printer 子对象
│   └── Printer 对应的 vptr
└── AllInOne 自己的成员

因此，不能简单认为每个多态对象一定只有一个 vptr。在多继承、虚继承等复杂场景中，完整对象可能包含多个虚表指针。具体布局属于编译器和 ABI 的实现细节。

十三、使用智能指针保存多态对象

13.1 为什么不能用 vector？

假设：

class Shape
{
public:
    virtual void draw() const
    {
    }
    virtual ~Shape() = default;
};
class Circle : public Shape
{
public:
    void draw() const override
    {
        cout << "Circle" << 'n';
    }
};

如果写：

vector shapes;
Circle circle;
shapes.push_back(circle);

会把 Circle 按值转换成 Shape，发生对象切片，派生类部分会被舍弃。

13.2 使用 unique_ptr

#include 
#include 
using namespace std;
vector> shapes;
shapes.push_back(make_unique());

遍历：

for (const auto& shape : shapes)
{
    shape->draw();
}

容器中统一保存 unique_ptr，但每个指针可以指向不同的实际对象，如 Circle、Rectangle、Triangle 等。

13.3 为什么优先 unique_ptr？

如果每个对象只有一个明确所有者，通常优先使用 unique_ptr。它能够表达独占所有权，而且不需要手动 delete。只有在确实存在共享所有权时，才考虑 shared_ptr。

十四、完整的多态对象容器示例

#include 
#include 
#include 
#include 
#include 
using namespace std;
class Shape
{
public:
    explicit Shape(string name)
        : _name(std::move(name))
    {
    }
    virtual double area() const = 0;
    virtual void draw() const = 0;
    const string& name() const
    {
        return _name;
    }
    virtual ~Shape() = default;
private:
    string _name;
};
class Circle : public Shape
{
public:
    explicit Circle(double radius)
        : Shape("圆形")
        , _radius(radius)
    {
    }
    double area() const override
    {
        return 3.1415926 * _radius * _radius;
    }
    void draw() const override
    {
        cout << "绘制圆形" << 'n';
    }
private:
    double _radius;
};
class Rectangle : public Shape
{
public:
    Rectangle(double width, double height)
        : Shape("矩形")
        , _width(width)
        , _height(height)
    {
    }
    double area() const override
    {
        return _width * _height;
    }
    void draw() const override
    {
        cout << "绘制矩形" << 'n';
    }
private:
    double _width;
    double _height;
};
int main()
{
    vector> shapes;
    shapes.push_back(make_unique(3.0));
    shapes.push_back(make_unique(4.0, 5.0));
    for (const auto& shape : shapes)
    {
        cout << "名称：" << shape->name() << 'n';
        cout << "面积：" << shape->area() << 'n';
        shape->draw();
        cout << 'n';
    }
    return 0;
}

新增图形时，只需要增加一个新的派生类，原来的遍历逻辑通常不需要修改。

十五、RTTI 和 dynamic_cast

RTTI 是运行时类型识别（Run-Time Type Information）。多态类型可以使用 dynamic_cast 检查实际类型。

15.1 指针形式

void process(Shape* shape)
{
    if (auto* circle = dynamic_cast(shape))
    {
        cout << "当前对象是 Circle" << 'n';
    }
}

如果转换成功，返回合法指针；如果失败，返回 nullptr。

15.2 引用形式

try
{
    Circle& circle = dynamic_cast(shape);
}
catch (const bad_cast&)
{
    cout << "转换失败" << 'n';
}

引用形式转换失败会抛出 std::bad_cast。

15.3 不要到处使用 dynamic_cast

如果程序中大量出现 if 是 Circle else if 是 Rectangle else if 是 Triangle，通常说明基类接口设计得不够完整。优先考虑把不同类型的行为设计成虚函数，如 shape.draw()、shape.area()。dynamic_cast 更适合确实需要访问某个派生类专有能力的场景。

十六、虚函数调用的性能成本

运行时多态并不是完全没有成本。

16.1 对象空间开销

多态对象在常见实现中需要保存一个或多个虚表指针。

16.2 间接函数调用

普通函数可以直接调用确定地址。虚函数通常需要：读取 vptr、查询虚表、取得函数地址、进行间接调用。

16.3 可能影响内联

如果编译器无法确定实际对象类型，虚函数可能难以直接内联。

16.4 去虚拟化优化

现代编译器有时能够推断对象的真实类型。例如：

Derived object;
object.func();

编译器明确知道对象是 Derived，可能直接调用或内联 Derived::func()。这种优化称为去虚拟化（devirtualization）。

16.5 是否应该担心虚函数性能？

大多数普通业务代码中，虚函数的一次间接调用通常不是主要性能瓶颈。是否使用多态，更应该根据设计需求决定。在下面这些场景中才需要重点测量：

高频调用的底层循环
游戏引擎核心路径
高性能计算
实时系统
缓存敏感的数据结构

不要在没有性能测试的情况下，为了避免一次虚调用而破坏代码结构。

十七、运行时多态和模板多态如何选择？

C++ 中除了虚函数多态，还有基于模板的静态多态。

17.1 运行时多态

void drawShape(const Shape& shape)
{
    shape.draw();
}

特点：

运行时决定类型
支持统一存储不同派生对象
接口稳定
存在虚调用和对象布局开销

17.2 模板多态

template
void drawShape(const T& shape)
{
    shape.draw();
}

特点：

编译期确定类型
容易内联
通常没有虚表开销
不同类型会生成不同模板实例
难以直接放进同一个值类型容器

17.3 简单选择建议

适合运行时多态：

对象类型需要在运行时决定
需要插件式扩展
需要统一保存不同类型对象
调用者只依赖抽象接口

适合模板多态：

类型在编译期已知
性能和内联非常重要
不需要运行时替换对象类型
希望使用泛型算法

两种方式并不是谁替代谁，而是适用于不同场景。

十八、设计多态体系的建议

18.1 重写函数始终写 override

void draw() const override;

可以提前发现函数名写错、参数类型写错、const 遗漏、引用限定符不一致等问题。

18.2 多态基类设计虚析构函数

virtual ~Base() = default;

前提是允许通过基类指针销毁派生对象。

18.3 避免对象切片

避免：

void process(Base object);
vector objects;

优先：

void process(const Base& object);
vector> objects;

18.4 使用智能指针管理生命周期

优先：

auto ptr = make_unique();

而不是：

Base* ptr = new Derived;
// ...
delete ptr;

18.5 基类接口保持小而稳定

不要为了某个派生类方便，就把大量特殊功能塞进基类。基类应该描述整个类型体系真正共有的行为。

18.6 不要在构造和析构中依赖多态

构造和析构期间不会向更派生类版本分派。

18.7 不要依赖虚表的具体布局

下面这些都属于实现细节：

vptr 位于对象什么位置
虚表位于哪个内存区域
虚表末尾有没有空指针
一个槽位的具体顺序

可以通过调试器观察，但不能写成可移植代码的依赖。

十九、常见问题

19.1 虚函数是否存放在虚表中？

虚函数代码通常存放在代码区域。虚表中存放的是虚函数地址或相关调度信息。

19.2 每个对象都有一张虚表吗？

通常不是。常见情况是：每个对象保存 vptr，同类型对象共享 vtable。

19.3 每个对象都只有一个 vptr 吗？

不一定。简单单继承中通常表现为一个。多继承和虚继承中可能存在多个多态基类子对象，因此可能有多个虚表指针。

19.4 vptr 一定在对象开头吗？

不一定。对象布局属于编译器和 ABI 的实现细节。

19.5 虚表末尾一定有 nullptr 吗？

不一定。不同编译器实现可能不同。

19.6 普通成员函数会进入虚表吗？

通常不会。只有参与虚函数机制的成员函数才需要虚表槽位。

19.7 构造函数可以调用虚函数吗？

语法上可以。但构造期间不会调用更派生类版本，因此不要依赖这种调用实现多态初始化。

19.8 dynamic_cast 是否必须依赖多态类？

向下转换通常要求源类型是多态类型，也就是至少含有一个虚函数。

19.9 使用虚函数一定很慢吗？

不一定。虚调用存在间接调用开销，但是否成为瓶颈需要通过实际测量判断。现代编译器还可能进行去虚拟化优化。

总结

C++ 多态的常见底层实现可以概括成：

对象保存虚表指针
虚表保存虚函数地址
基类指针或引用调用虚函数
运行时根据对象虚表选择最终函数

理解虚函数表的目的，不是让我们在项目中手工修改虚表，而是帮助我们理解：为什么同一个基类指针，可以在运行时调用不同派生类的函数。真正写代码时，仍然应该依赖标准的虚函数、智能指针和类型系统，而不是依赖某个编译器的内部对象布局。