CPP的虚函数及其替代品

对于 C++ 编程，多态是面向对象编程的核心特性之一。虚函数是实现多态性的主要工具，它允许通过基类指针或引用来调用派生类的成员函数，从而实现动态的行为。然而，由于虚表（vtable）机制的存在，虚函数调用涉及两次指令跳转，可能导致性能下降。本次讨论，我将深入探讨虚函数的执行原理、性能影响，并通过回调函数的方式实现类似的多态性，以避免虚函数的开销。

一、虚函数的工作原理

在 C++ 中，当一个类声明了虚函数时，编译器为该类生成一个虚函数表（vtable）。这个表包含了该类所有虚函数的指针。每个包含虚函数的对象还拥有一个隐藏的指针，指向它所属类的虚表。调用虚函数时，会发生以下步骤：

查找虚表：首先，程序查找对象的虚表指针。
跳转到函数指针：然后，从虚表中找到对应的虚函数指针。
执行函数：最后，跳转到虚函数的实际地址执行。

虽然虚表机制在支持多态性方面非常灵活，但每次调用虚函数时都需要两次跳转：一次查找虚表，另一次跳转到函数的实际地址。这种多次跳转会导致 CPU 的指令预取（prefetch）失效，从而降低程序的执行效率。

相比之下，普通函数只需一次跳转，执行效率更高。因此，在性能敏感的场景下，避免虚函数的开销是一个值得考虑的问题。（严肃的语气）

二、回调函数：一种替代虚函数的方式

为了避免虚函数带来的性能损失，可以使用回调函数来实现类似的多态性。回调函数允许我们在运行时动态地指定要调用的函数，而不需要依赖虚表机制。

在 C++ 中，std::function 是一个通用的函数对象包装器，它可以存储任何可调用对象（如普通函数、lambda、仿函数、成员函数等）。结合 std::bind，我们可以灵活地将不同的派生类成员函数注册为回调函数，从而实现类似于虚函数的动态调用机制，但避免了虚表查找的额外开销。

三、示例：用回调函数实现多态性

以下是一个通过回调函数实现多态性的示例。假设我们有两个英雄类 XS（西施）和 HX（韩信），每个类都有自己的 show 函数来展示不同的技能。我们使用回调函数代替虚函数来动态调用这些派生类的函数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


#include <iostream>
#include <functional>
using namespace std;

// 英雄基类
struct Hero {
    function<void()> m_callback;  // 用于绑定子类的成员函数

    // 注册子类成员函数，子类成员函数没有参数
    template<typename Fn, typename ...Args>
    void callback(Fn&& fn, Args&&...args) {
        m_callback = bind(forward<Fn>(fn), forward<Args>(args)...);
    }

    // 调用注册的子类成员函数
    void show() { 
        if (m_callback) 
            m_callback(); 
        else 
            cout << "未注册技能。\n";
    }
};

// 西施派生类
struct XS : public Hero {
    void show() { 
        cout << "西施释放了技能。\n"; 
    }
};

// 韩信派生类
struct HX : public Hero {
    void show() { 
        cout << "韩信释放了技能。\n"; 
    }
};

int main() {
    int id = 0;  // 英雄的ID
    cout << "请输入英雄（1-西施；2-韩信）：";
    cin >> id;

    // 创建基类指针，用于指向派生类对象
    Hero* ptr = nullptr;

    if (id == 1) {
        ptr = new XS;
        ptr->callback(&XS::show, static_cast<XS*>(ptr));  // 注册子类成员函数
    }
    else if (id == 2) {
        ptr = new HX;
        ptr->callback(&HX::show, static_cast<HX*>(ptr));  // 注册子类成员函数
    }

    // 调用子类的show函数
    if (ptr != nullptr) {
        ptr->show();  // 动态调用派生类函数
        delete ptr;   // 释放派生类对象
    }

    return 0;
}

四、代码详解

4.1 基类 `Hero`

Hero 是一个基类，包含一个 std::function<void()> 成员 m_callback，用于存储子类的成员函数。
callback 函数使用 std::bind 将子类的 show 函数绑定到 m_callback 中，从而动态注册子类的成员函数。
show 函数通过调用 m_callback 来执行注册的子类函数。

4.2 派生类 `XS` 和 `HX`

XS 和 HX 是派生类，分别定义了自己的 show 函数，用于展示不同的技能。它们继承了基类 Hero 的 callback 机制，通过基类指针可以动态调用各自的 show 函数。

4.3 主函数 `main`

用户输入英雄编号 id，根据输入选择 XS 或 HX。
使用基类指针 ptr 指向派生类对象，并通过 callback 注册派生类的 show 函数。
调用 ptr->show()，通过回调机制动态执行派生类的函数，达到类似虚函数的多态性效果。

五、回调函数与虚函数的对比

特性	虚函数	回调函数（std::function）
调用开销	两次跳转，较慢	一次跳转，较快
实现机制	依赖虚表（vtable）	使用 `std::function` 和 `std::bind`
适用场景	需要动态绑定成员函数时	需要灵活、高效的多态性时
支持的可调用对象类型	仅支持成员函数	支持普通函数、成员函数、lambda、仿函数等
多态性	是，通过继承和重写实现	是，通过回调函数绑定实现

六、总结

虚函数是 C++ 实现多态性的传统方式，但由于虚表查找和多次跳转的开销，性能相对较低。在性能敏感的场景中，使用回调函数（std::function 和 std::bind）可以作为虚函数的替代方案，通过动态绑定不同的子类成员函数，达到类似多态性的效果，同时减少性能开销。

一、虚函数的工作原理#

二、回调函数：一种替代虚函数的方式#

三、示例：用回调函数实现多态性#

四、代码详解#

4.1 基类 Hero#

4.2 派生类 XS 和 HX#

4.3 主函数 main#

五、回调函数与虚函数的对比#

六、总结#