C++ 性能优化：用 CRTP 实现零开销编译期多态

文章目录

0.引言

在C++中，多态是实现抽象和复用的核心机制，对于传统的多态（虚函数），我们已经在C++ 对象模型：虚函数表的底层结构与多态实现进行了讲解，其并非零成本的抽象，会带来性能的损耗。

为了克服这一限制，现代C++提供了基于模板的编译期解决方案。本文将深入探讨如何通过CRTP（Curiously Recurring Template Pattern，奇异递归模板模式）实现编译期多态，在保留多态抽象能力的同时消除运行时开销，真正践行 C++"零开销抽象" 的设计哲学。

1.CRTP基本结构和实现原理

CRTP是通过模板继承来实现的静态多态技术（简单来说就是可以让父类知道子类的类型，从而达到编译期做一些事情的目的，本文主要从静态多态角度来看，其他应用后面文章再讨论），其核心思想就是让派生类作为基类的模板，形成"自引用"的继承关系，从而实现编译期的多态行为，其结构和调用方式一般如下：

dart 复制代码

#include <iostream>
// 基类模板，以派生类作为模板参数
template <typename Child>
class Base {
public:
    // 基类通过static_cast调用派生类的实现
    void interface() {
        static_cast<Child*>(this)->interface();
    }
};
// 派生类继承基类，并将自身作为模板参数传入
class Derived : public Base<Derived> {
public:
    // 实现具体逻辑
    void interface() {
        // 派生类的实际功能
        std::cout<<"hello world"<<std::endl;
    }
};
int main()
{
    Base<Derived> * pBase = new Derived();
    pBase->interface();
    return 0;
}

子类通过继承以自身为模板参数的基类Base，基类就可以通过转换直接访问派生类的方法而无需虚函数。我们可以使用g++ -c -fdump-tree-all a.cpp来查看一下其实例化后的代码a.cpp.018t.fixup_cfg1（只截取关键信息）。

2.性能测试

我们通过一个简单的代码例子来实际看一看虚函数以及CRTP的性能差异（内存就不用看了，包含虚函数的对象会多虚函数指针，主要看执行时间），代码如下：

dart 复制代码

#include <iostream>
#include <chrono>
// 测试配置
const int ITERATIONS = 1000000000;  // 10亿次迭代
// ------------------------------
// 虚函数版本
// ------------------------------
class VirtualBase {
public:
    virtual int getValue() = 0;
    virtual ~VirtualBase() = default;
};
class VirtualImpl : public VirtualBase {
public:
    int getValue()  override {
        return 42;  // 简单返回固定值
    }
};
// ------------------------------
// CRTP版本
// ------------------------------
template <typename Derived>
class CRTPBase {
public:
    int getValue() {
        return static_cast<Derived*>(this)->getValue();
    }
};
class CRTPImpl : public CRTPBase<CRTPImpl> {
public:
    int getValue() {
        return 42;  // 与虚函数版本实现完全相同
    }
};
// ------------------------------
// 性能测试
// ------------------------------
int main() {
    // 初始化测试对象
    VirtualImpl v_obj;
    VirtualBase* v_ptr = &v_obj;  // 虚函数多态调用
    CRTPImpl c_obj;
    CRTPBase<CRTPImpl>* c_ptr = &c_obj;  // CRTP多态调用
    // 测试虚函数
    auto start_v = std::chrono::high_resolution_clock::now();
    volatile int sum_v = 0;
    for (int i = 0; i < ITERATIONS; ++i) {
        sum_v += v_ptr->getValue();
    }
    auto end_v = std::chrono::high_resolution_clock::now();
    double time_v = std::chrono::duration<double>(end_v - start_v).count();
    // 测试CRTP
    auto start_c = std::chrono::high_resolution_clock::now();
    volatile int sum_c = 0;
    for (int i = 0; i < ITERATIONS; ++i) {
        sum_c += c_ptr->getValue();
    }
    auto end_c = std::chrono::high_resolution_clock::now();
    double time_c = std::chrono::duration<double>(end_c - start_c).count();
    // 输出结果
    std::cout << "虚函数耗时: " << time_v << " 秒\n";
    std::cout << "CRTP耗时:   " << time_c << " 秒\n";
    std::cout << "CRTP比虚函数快: " << (1 - time_c / time_v) * 100 << "%\n";
    return 0;
}

我们分析一下两者的开销，虚函数的话我们比较了解了，主要是虚函数指针的查找和调用，当然这个会缓存下来，而CRTP需要多一次普通调用和static_cast，当前测试场景比较简单，所以虚函数地址缓存不会失效，在O0优化下虚函数会更快。

如果我们开启O3优化，CRTP会优化为内联，这样的话CRTP会比虚函数快（虚函数可能存在去虚拟化，所以不明显），如果是实际场景中，虚函数调用不会这么单一且类型也不能确定，不能去虚拟化以及虚函数缓存可能失效，这种场景下，CRTP会明显快于虚函数。

如上所说，上面的测试有可能有虚函数去虚拟化的问题，我们可以使用-fno-devirtualize禁止去虚拟化，这样最能体现二者的差异。

所以，在实际场景中，我们使用CRTP正常情况下性能会大大高于虚函数。

3.CRTP实际适用场景

1）静态多态：在不需要运行时多态的场景中使用以消除虚函数的开销。

2）代码复用：通过模板继承来给派生类增加通用功能，这个在标准库中有很多应用，我们后面文章专门讨论。

3）接口约束和静态断言：可以在基类使用static_assert结合 SFINAE 技术进行编译期检查，这个需要比较高的C++支持：

dart 复制代码

#include <type_traits>
template <typename Derived>
class ShapeCRTP {
public:
    double area() const {
        // 检查Derived是否有calculate_area方法
        static_assert(std::is_same_v<
            decltype(std::declval<Derived>().calculate_area()),
            double
        >, "Derived must implement calculate_area() returning double");
        return static_cast<const Derived*>(this)->calculate_area();
    }
};

4.局限性

1）不适合动态类型场景：需运行时动态创建 / 销毁不同类型对象时，动态多态更合适；

2）代码调试难度增加：模板展开可能导致复杂的错误信息，需熟悉编译器诊断工具；

3）可读性问题：对新手而言，CRTP 的自引用结构较难理解。

5.总结

本文介绍了CRTP 如何将多态绑定从运行时迁移到编译期，讲解了 C++"零开销抽象" 的核心思想 ------你不需要为未使用的特性支付成本。在性能至关重要的场景中，用 CRTP 实现的编译期多态既能保留抽象设计的灵活性，又能消除动态多态的性能损耗。