C++编译期多态与运行时多态的性能差异

C++ 中的多态机制主要分为编译期多态和运行时多态。编译期多态通常通过模板实现，而运行时多态则依赖于虚函数和继承体系。理解这两者在性能上的具体差异，有助于在开发中做出更优的架构选择。

1. 实现基础代码示例

创建两个版本的代码，分别模拟计算任务。第一个版本使用虚函数，第二个版本使用模板。

运行时多态实现

定义一个基类接口，派生出具体的实现类，并在 main 函数中通过基类指针调用。

// RuntimePoly.cpp
#include <iostream>
#include <vector>
#include <memory>

class Base {
public:
    virtual void calculate() = 0;
    virtual ~Base() = default;
};

class DerivedA : public Base {
public:
    void calculate() override {
        // 模拟计算任务
        volatile int sum = 0;
        for(int i = 0; i < 100; ++i) sum += i;
    }
};

void runRuntimeBenchmark() {
    std::vector<std::unique_ptr<Base>> objects;
    objects.push_back(std::make_unique<DerivedA>());

    // 执行大量调用
    for (int i = 0; i < 1000000; ++i) {
        objects[0]->calculate();
    }
}

编译期多态实现

编写模板函数，将具体类型作为模板参数传递。这种方式在编译阶段确定调用的具体函数。

// CompileTimePoly.cpp
#include <iostream>
#include <vector>

class DerivedA {
public:
    void calculate() {
        // 模拟相同的计算任务
        volatile int sum = 0;
        for(int i = 0; i < 100; ++i) sum += i;
    }
};

template <typename T>
void runCompileTimeBenchmark(T& obj) {
    // 执行大量调用
    for (int i = 0; i < 1000000; ++i) {
        obj.calculate();
    }
}

2. 分析底层调用机制

对比两者在指令层面的执行流程，是理解性能差异的关键。

运行时多态需要通过虚函数表查找函数地址，而编译期多态在编译期间就已经确定了具体的调用目标。

观察上图流程，可以得出以下结论：

• 运行时多态：必须先读取对象的虚表指针，再从虚表中索引函数地址，最后跳转执行。这增加了间接寻址的开销，且阻碍了编译器的内联优化。
• 编译期多态：编译器直接知道 obj 的具体类型。它可以直接插入函数代码，或者生成一条直接的 call 指令，省去了查表过程。

3. 量化性能开销与优化效果

构建性能评估模型。假设单次调用的总耗时为 $T$，计算逻辑耗时为 $C$，分发机制开销为 $D$。

$$ T_{total} = N \times (C + D) $$

其中 $N$ 是调用次数。

• 对于运行时多态，$D_{runtime} > 0$（包含内存间接访问和潜在的分支预测失败）。
• 对于编译期多态，如果开启优化，编译器会将函数体内联，此时 $D_{compile} \approx 0$，且 $C$ 可能因为上下文优化而减小。

执行编译并查看汇编代码（以 GCC 为例），验证上述理论。

1. 编译代码并开启优化选项 -O2 或 -O3。

   g++ -O2 -S RuntimePoly.cpp -o RuntimePoly.s
   g++ -O2 -S CompileTimePoly.cpp -o CompileTimePoly.s

2. 打开生成的 .s 文件。
3. 查找 calculate 函数的调用位置。
   • 在 RuntimePoly.s 中，你会看到类似 call *%rax 或 call *(%rdi) 的指令，这是间接调用。
   • 在 CompileTimePoly.s 中，你可能根本找不到 call 指令，因为代码已经直接内联到了循环内部。

4. 二进制体积与编译时间对比

性能的提升并非没有代价。编译期多态会显著增加编译时间生成的二进制文件大小。

5. 选择建议

根据实际场景权衡利弊：

• 使用运行时多态：当对象类型必须在运行时决定（例如插件系统、动态加载库），或者调用的函数体非常庞大（内联收益小，但代码膨胀代价大）时。
• 使用编译期多态：当追求极致性能，且类型在编译期已知，或者函数体较小（适合内联）时。

结合两者使用也是一种常见策略，例如利用类型擦除在接口层使用运行时多态，在内部实现细节中使用编译期多态。