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

🔥 星恒随风： 个人主页 ❄️ 个人专栏： 《指针合集》 ｜ 《C语言基础》 ｜ 《数据结构》 ｜ 《机器学习导论》 ｜ 《前端基础》 ｜ 《python基础》 ｜ 《C++从入门到入土》 ✨ 数据即知识，压缩即智能

文章目录

[C++ 多态底层原理：静态绑定、动态绑定、虚函数表与工程实践](#C++ 多态底层原理：静态绑定、动态绑定、虚函数表与工程实践)
- 前言
- 一、静态类型和动态类型
- - [1.1 静态类型](#1.1 静态类型)
  - [1.2 动态类型](#1.2 动态类型)
  - [1.3 两种类型的作用](#1.3 两种类型的作用)
- 二、静态绑定和动态绑定
- - [2.1 静态绑定](#2.1 静态绑定)
  - [2.2 动态绑定](#2.2 动态绑定)
- 三、多态底层一定使用虚函数表吗？
- [四、虚函数表指针 vptr](#四、虚函数表指针 vptr)
- - [4.1 普通类对象](#4.1 普通类对象)
  - [4.2 含有虚函数的类](#4.2 含有虚函数的类)
  - [4.3 vptr 由编译器维护](#4.3 vptr 由编译器维护)
  - [4.4 vptr 不一定在对象开头](#4.4 vptr 不一定在对象开头)
- [五、虚函数表 vtable](#五、虚函数表 vtable)
- - [5.1 虚表存储什么？](#5.1 虚表存储什么？)
  - [5.2 同类型对象通常共享虚表](#5.2 同类型对象通常共享虚表)
  - [5.3 虚函数代码不在虚表中](#5.3 虚函数代码不在虚表中)
- 六、派生类的虚函数表
- - [6.1 基类虚表](#6.1 基类虚表)
  - [6.2 派生类重写虚函数](#6.2 派生类重写虚函数)
  - [6.3 重写不会修改基类虚表](#6.3 重写不会修改基类虚表)
- 七、一次虚函数调用的大致过程
- 八、对象大小为什么可能发生变化？
- - [8.1 普通类](#8.1 普通类)
  - [8.2 多态类](#8.2 多态类)
  - [8.3 不要死记固定大小](#8.3 不要死记固定大小)
- 九、构造期间为什么不会调用派生类版本？
- - [9.1 原因](#9.1 原因)
- 十、析构期间的虚函数调用
- - [10.1 实际建议](#10.1 实际建议)
- 十一、访问权限和虚函数重写
- 十二、多继承中的虚表
- 十三、使用智能指针保存多态对象
- - [13.1 为什么不能用 vector<Base>？](#13.1 为什么不能用 vector？)
  - [13.2 使用 unique_ptr](#13.2 使用 unique_ptr)
  - [13.3 为什么优先 unique_ptr？](#13.3 为什么优先 unique_ptr？)
- 十四、完整的多态对象容器示例
- [十五、RTTI 和 dynamic_cast](#十五、RTTI 和 dynamic_cast)
- - [15.1 指针形式](#15.1 指针形式)
  - [15.2 引用形式](#15.2 引用形式)
  - [15.3 不要到处使用 dynamic_cast](#15.3 不要到处使用 dynamic_cast)
- 十六、虚函数调用的性能成本
- - [16.1 对象空间开销](#16.1 对象空间开销)
  - [16.2 间接函数调用](#16.2 间接函数调用)
  - [16.3 可能影响内联](#16.3 可能影响内联)
  - [16.4 去虚拟化优化](#16.4 去虚拟化优化)
  - [16.5 是否应该担心虚函数性能？](#16.5 是否应该担心虚函数性能？)
- 十七、运行时多态和模板多态如何选择？
- - [17.1 运行时多态](#17.1 运行时多态)
  - [17.2 模板多态](#17.2 模板多态)
  - [17.3 简单选择建议](#17.3 简单选择建议)
- 十八、设计多态体系的建议
- - [18.1 重写函数始终写 override](#18.1 重写函数始终写 override)
  - [18.2 多态基类设计虚析构函数](#18.2 多态基类设计虚析构函数)
  - [18.3 避免对象切片](#18.3 避免对象切片)
  - [18.4 使用智能指针管理生命周期](#18.4 使用智能指针管理生命周期)
  - [18.5 基类接口保持小而稳定](#18.5 基类接口保持小而稳定)
  - [18.6 不要在构造和析构中依赖多态](#18.6 不要在构造和析构中依赖多态)
  - [18.7 不要依赖虚表的具体布局](#18.7 不要依赖虚表的具体布局)
- 十九、常见问题
- - [19.1 虚函数是否存放在虚表中？](#19.1 虚函数是否存放在虚表中？)
  - [19.2 每个对象都有一张虚表吗？](#19.2 每个对象都有一张虚表吗？)
  - [19.3 每个对象都只有一个 vptr 吗？](#19.3 每个对象都只有一个 vptr 吗？)
  - [19.4 vptr 一定在对象开头吗？](#19.4 vptr 一定在对象开头吗？)
  - [19.5 虚表末尾一定有 nullptr 吗？](#19.5 虚表末尾一定有 nullptr 吗？)
  - [19.6 普通成员函数会进入虚表吗？](#19.6 普通成员函数会进入虚表吗？)
  - [19.7 构造函数可以调用虚函数吗？](#19.7 构造函数可以调用虚函数吗？)
  - [19.8 dynamic_cast 是否必须依赖多态类？](#19.8 dynamic_cast 是否必须依赖多态类？)
  - [19.9 使用虚函数一定很慢吗？](#19.9 使用虚函数一定很慢吗？)
- 总结

前言

在上一篇文章中，我们已经知道，多态通常通过下面的方式使用：

cpp 复制代码

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

虽然 ptr 的类型是 Base*，但实际调用的却可能是：

cpp 复制代码

Derived::func()

这背后有几个值得继续研究的问题：

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

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

一、静态类型和动态类型

1.1 静态类型

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

cpp 复制代码

class Animal
{
public:
    virtual void talk() const
    {
    }

    virtual ~Animal() = default;
};

class Dog : public Animal
{
public:
    void talk() const override
    {
    }
};

创建对象：

cpp 复制代码

Dog dog;
Animal* ptr = &dog;

这里：

text 复制代码

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

静态类型在编译阶段就已经确定。

1.2 动态类型

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

cpp 复制代码

Animal* ptr = &dog;

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

因此，它指向对象的动态类型是：

text 复制代码

Dog

1.3 两种类型的作用

对于非虚函数调用：

cpp 复制代码

ptr->normalFunc();

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

对于虚函数调用：

cpp 复制代码

ptr->talk();

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

可以简单记成：

text 复制代码

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

二、静态绑定和动态绑定

2.1 静态绑定

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

cpp 复制代码

#include <iostream>
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;
}

输出：

text 复制代码

Base::func()

因为 func() 不是虚函数。

编译器根据 ptr 的静态类型 Base*，直接确定调用：

cpp 复制代码

Base::func()

2.2 动态绑定

把基类函数改成虚函数：

cpp 复制代码

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

    virtual ~Base() = default;
};

派生类完成重写：

cpp 复制代码

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

再次调用：

cpp 复制代码

Derived object;
Base* ptr = &object;

ptr->func();

输出变成：

text 复制代码

Derived::func()

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

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

先给出一个重要结论：

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

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

text 复制代码

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

这是常见实现方式，但不是可以跨平台依赖的语言规则。

不同编译器、操作系统和 ABI 可能采用不同的对象布局。

四、虚函数表指针 vptr

4.1 普通类对象

cpp 复制代码

class Normal
{
private:
    int _value;
};

Normal 对象通常只需要保存：

text 复制代码

_value

以及必要的内存对齐空间。

4.2 含有虚函数的类

cpp 复制代码

class Base
{
public:
    virtual void func()
    {
    }

private:
    int _value;
};

主流实现通常会在对象中加入一个隐藏指针：

text 复制代码

vptr

它指向当前对象所属类型的虚函数表。

可以抽象理解为：

text 复制代码

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

4.3 vptr 由编译器维护

vptr 并不是我们在类中显式声明的成员：

cpp 复制代码

class Base
{
    // 代码中并没有写 vptr
};

它通常由编译器自动添加并维护。

对象构造和析构过程中，编译器会根据当前阶段设置对应的虚表指针。

4.4 vptr 不一定在对象开头

很多调试器中会看到 vptr 位于对象起始位置。

但这不是语言标准保证的。

下面这些因素都可能影响对象布局：

text 复制代码

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

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

五、虚函数表 vtable

5.1 虚表存储什么？

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

cpp 复制代码

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

    virtual void func2()
    {
    }
};

对应的虚表可以抽象为：

text 复制代码

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

对象中的 vptr 指向这张表。

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

cpp 复制代码

Base object1;
Base object2;

两个对象的数据成员相互独立：

text 复制代码

object1._value
object2._value

但它们通常指向同一张 Base 虚表：

text 复制代码

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

也就是说：

text 复制代码

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

5.3 虚函数代码不在虚表中

虚函数和普通函数一样，编译后都是机器指令，通常位于程序的代码区域。

虚表中保存的是：

text 复制代码

虚函数地址
或者用于定位虚函数的相关信息

而不是完整的函数代码。

六、派生类的虚函数表

6.1 基类虚表

cpp 复制代码

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

    virtual void func2()
    {
        cout << "Base::func2()" << '\n';
    }
};

可以抽象成：

text 复制代码

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

6.2 派生类重写虚函数

cpp 复制代码

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

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

派生类虚表可以抽象成：

text 复制代码

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

其中：

text 复制代码

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

6.3 重写不会修改基类虚表

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

通常是：

text 复制代码

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

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

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

假设：

cpp 复制代码

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

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

text 复制代码

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

示意：

text 复制代码

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

多态调用的关键不在于变量名叫 ptr，而在于：

text 复制代码

ptr 实际指向的对象具有什么动态类型

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

8.1 普通类

cpp 复制代码

class Normal
{
private:
    int _value;
};

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

8.2 多态类

cpp 复制代码

class Base
{
public:
    virtual void func()
    {
    }

private:
    int _value;
};

常见实现中，对象还需要保存一个 vptr。

因此对象大小可能增加。

8.3 不要死记固定大小

在 32 位环境中，指针通常占 4 字节。

在 64 位环境中，指针通常占 8 字节。

但最终对象大小还会受到：

text 复制代码

成员排列
内存对齐
编译器
ABI
多继承
虚继承

等因素影响。

更准确的说法是：

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

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

看下面的代码：

cpp 复制代码

#include <iostream>
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';
    }
};

创建对象：

cpp 复制代码

Derived object;

在 Base 构造函数中执行：

cpp 复制代码

func();

调用的是：

cpp 复制代码

Base::func()

而不是：

cpp 复制代码

Derived::func()

9.1 原因

构造 Derived 时，顺序大致是：

text 复制代码

先构造 Base 部分
再构造 Derived 部分

执行 Base 构造函数时，Derived 部分还没有完成初始化。

如果此时调用 Derived::func()，它可能访问尚未初始化的派生类成员。

因此，构造期间的虚函数调用不会分派到更派生类版本。

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

析构顺序和构造相反：

text 复制代码

先析构 Derived
再析构 Base

当程序进入 Base 析构函数时，Derived 部分已经被销毁。

因此，在基类析构阶段调用虚函数，也不会再分派到 Derived 的重写版本。

10.1 实际建议

不要在构造函数和析构函数中依赖运行时多态。

尤其不要在基类构造函数中调用需要访问派生类状态的虚函数。

更合适的设计包括：

text 复制代码

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

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

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

cpp 复制代码

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

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

调用：

cpp 复制代码

Derived object;
Base& ref = object;

ref.func();

这段代码可以通过编译，并调用：

cpp 复制代码

Derived::func()

因为：

text 复制代码

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

但直接写：

cpp 复制代码

object.func();

会编译失败，因为 Derived::func() 是 private。

可以简单理解为：

text 复制代码

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

十二、多继承中的虚表

简单单继承中，一个多态对象通常表现为一个虚表指针。

但在多继承中，一个对象可能包含多个多态基类子对象。

cpp 复制代码

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 对象可以抽象成：

text 复制代码

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

因此，不能简单认为：

text 复制代码

每个多态对象一定只有一个 vptr

在多继承、虚继承等复杂场景中，完整对象可能包含多个虚表指针。

具体布局属于编译器和 ABI 的实现细节。

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

13.1 为什么不能用 vector？

假设：

cpp 复制代码

class Shape
{
public:
    virtual void draw() const
    {
    }

    virtual ~Shape() = default;
};

class Circle : public Shape
{
public:
    void draw() const override
    {
        cout << "Circle" << '\n';
    }
};

如果写：

cpp 复制代码

vector<Shape> shapes;
Circle circle;

shapes.push_back(circle);

会把 Circle 按值转换成 Shape，发生对象切片。

派生类部分会被舍弃。

13.2 使用 unique_ptr

cpp 复制代码

#include <memory>
#include <vector>
using namespace std;

vector<unique_ptr<Shape>> shapes;

shapes.push_back(make_unique<Circle>());

遍历：

cpp 复制代码

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

容器中统一保存：

cpp 复制代码

unique_ptr<Shape>

但每个指针可以指向不同的实际对象：

text 复制代码

Circle
Rectangle
Triangle
其他 Shape 派生类

13.3 为什么优先 unique_ptr？

如果每个对象只有一个明确所有者，通常优先使用：

cpp 复制代码

unique_ptr<Base>

它能够表达独占所有权，而且不需要手动 delete。

只有在确实存在共享所有权时，才考虑：

cpp 复制代码

shared_ptr<Base>

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

cpp 复制代码

#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
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<unique_ptr<Shape>> shapes;

    shapes.push_back(make_unique<Circle>(3.0));
    shapes.push_back(make_unique<Rectangle>(4.0, 5.0));

    for (const auto& shape : shapes)
    {
        cout << "名称：" << shape->name() << '\n';
        cout << "面积：" << shape->area() << '\n';

        shape->draw();

        cout << '\n';
    }

    return 0;
}

新增图形时，只需要增加一个新的派生类：

cpp 复制代码

class Triangle : public Shape
{
};

原来的遍历逻辑通常不需要修改。

十五、RTTI 和 dynamic_cast

RTTI 是运行时类型识别：

text 复制代码

Run-Time Type Information

多态类型可以使用 dynamic_cast 检查实际类型。

15.1 指针形式

cpp 复制代码

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

如果转换成功，返回合法指针。

如果失败，返回：

cpp 复制代码

nullptr

15.2 引用形式

cpp 复制代码

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

引用形式转换失败会抛出：

cpp 复制代码

std::bad_cast

15.3 不要到处使用 dynamic_cast

如果程序中大量出现：

cpp 复制代码

if 是 Circle
else if 是 Rectangle
else if 是 Triangle

通常说明基类接口设计得不够完整。

优先考虑把不同类型的行为设计成虚函数：

cpp 复制代码

shape.draw();
shape.area();

dynamic_cast 更适合确实需要访问某个派生类专有能力的场景。

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

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

16.1 对象空间开销

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

16.2 间接函数调用

普通函数可以直接调用确定地址。

虚函数通常需要：

text 复制代码

读取 vptr
查询虚表
取得函数地址
进行间接调用

16.3 可能影响内联

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

16.4 去虚拟化优化

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

例如：

cpp 复制代码

Derived object;
object.func();

编译器明确知道对象是 Derived，可能直接调用或内联：

cpp 复制代码

Derived::func()

这种优化称为：

text 复制代码

devirtualization
去虚拟化

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

大多数普通业务代码中，虚函数的一次间接调用通常不是主要性能瓶颈。

是否使用多态，更应该根据设计需求决定。

在下面这些场景中才需要重点测量：

text 复制代码

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

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

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

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

17.1 运行时多态

cpp 复制代码

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

特点：

text 复制代码

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

17.2 模板多态

cpp 复制代码

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

特点：

text 复制代码

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

17.3 简单选择建议

适合运行时多态：

text 复制代码

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

适合模板多态：

text 复制代码

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

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

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

18.1 重写函数始终写 override

cpp 复制代码

void draw() const override;

可以提前发现：

text 复制代码

函数名写错
参数类型写错
const 遗漏
引用限定符不一致

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

cpp 复制代码

virtual ~Base() = default;

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

18.3 避免对象切片

避免：

cpp 复制代码

void process(Base object);
vector<Base> objects;

优先：

cpp 复制代码

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

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

优先：

cpp 复制代码

auto ptr = make_unique<Derived>();

而不是：

cpp 复制代码

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

18.5 基类接口保持小而稳定

不要为了某个派生类方便，就把大量特殊功能塞进基类。

基类应该描述整个类型体系真正共有的行为。

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

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

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

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

text 复制代码

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

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

十九、常见问题

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

虚函数代码通常存放在代码区域。

虚表中存放的是虚函数地址或相关调度信息。

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

通常不是。

常见情况是：

text 复制代码

每个对象保存 vptr
同类型对象共享 vtable

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

不一定。

简单单继承中通常表现为一个。

多继承和虚继承中可能存在多个多态基类子对象，因此可能有多个虚表指针。

19.4 vptr 一定在对象开头吗？

不一定。

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

19.5 虚表末尾一定有 nullptr 吗？

不一定。

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

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

通常不会。

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

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

语法上可以。

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

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

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

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

不一定。

虚调用存在间接调用开销，但是否成为瓶颈需要通过实际测量判断。

现代编译器还可能进行去虚拟化优化。

总结

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

text 复制代码

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

理解虚函数表的目的，不是让我们在项目中手工修改虚表，而是帮助我们理解：

text 复制代码

为什么同一个基类指针，可以在运行时调用不同派生类的函数。

真正写代码时，仍然应该依赖标准的虚函数、智能指针和类型系统，而不是依赖某个编译器的内部对象布局。