一、引言虚函数的代价C 程序员对多态的认知通常始于虚函数class Animal { public: virtual void speak() const 0; virtual ~Animal() default; }; class Dog : public Animal { public: void speak() const override { std::cout Woof\n; } }; class Cat : public Animal { public: void speak() const override { std::cout Meow\n; } }; void make_speak(const Animal a) { a.speak(); }这套机制清晰优雅但它有三笔隐形成本成本类型具体表现空间每个对象携带一个 vptr64位下 8 字节时间每次虚函数调用 两次间接跳转vptr → vtable → 函数指针无法内联缓存虚表分散在内存中对指令缓存和数据缓存都不友好在性能敏感场景游戏引擎、数值计算库、嵌入式系统中这些开销不可忽视。Eigen 矩阵库的核心设计者曾直言如果 Eigen 用了虚函数它的性能会下降 30% 以上。于是CRTPCuriously Recurring Template Pattern登场了。二、CRTP 核心原理2.1 经典三行代码template typename Derived class Base { public: void interface() { // 关键static_castDerived*(this)-implementation() static_castDerived*(this)-implementation(); } void implementation() { std::cout Base::implementation (fallback)\n; } }; class DerivedA : public BaseDerivedA { public: void implementation() { std::cout DerivedA::implementation\n; } }; class DerivedB : public BaseDerivedB { public: void implementation() { std::cout DerivedB::implementation\n; } };三要素基类模板接受派生类类型作为模板参数派生类继承 BaseDerived基类通过 static_castDerived*(this) 在编译期获得派生类的具体类型2.2 去掉虚函数的一次函数调用发生了什么以 DerivedA da; da.interface(); 为例编译器在实例化时看到的逻辑等价于// 编译器视角展开后的实际调用链 // BaseDerivedA::interface() 内 // static_castDerivedA*(this)-implementation() // ↓ 编译期确定类型直接调用 // DerivedA::implementation()关键区别虚函数运行时查 vtable → 间接跳转 → 调用阻止内联CRTP编译期就确定 DerivedA::implementation 的地址编译器可以直接内联让 interface() 和 implementation() 融合为一个基本块2.3 对象布局对比虚函数版本每个对象 ┌──────────────┐ │ vptr (8B) │ → 指向 Dog 虚表 │ dog_data │ └──────────────┘ CRTP 版本每个对象 ┌──────────────┐ │ dog_data │ 没有 vptr └──────────────┘在大规模对象数组场景中节省 8 字节 × 百万级对象 显著内存收益。三、性能实测用一个简单基准测试对 100 万个对象依次调用接口方法分别用虚函数和 CRTP 实现#include benchmark/benchmark.h #include vector #include random // ---- 虚函数版本 ---- struct VBase { virtual int compute(int x) const 0; virtual ~VBase() default; }; struct VDerived : VBase { int compute(int x) const override { return x * 2 1; } }; // ---- CRTP 版本 ---- template typename Derived struct CRTPBase { int compute(int x) const { return static_castconst Derived*(this)-compute_impl(x); } }; struct CRTPDerived : CRTPBaseCRTPDerived { int compute_impl(int x) const { return x * 2 1; } }; // 虚函数版通过基类指针调用 static void BM_Virtual(benchmark::State state) { std::vectorstd::unique_ptrVBase vec; for (int i 0; i 1000000; i) vec.push_back(std::make_uniqueVDerived()); int sum 0; for (auto _ : state) { for (auto p : vec) sum p-compute(42); benchmark::DoNotOptimize(sum); } } BENCHMARK(BM_Virtual); // CRTP 版编译期多态 static void BM_CRTP(benchmark::State state) { std::vectorCRTPDerived vec(1000000); int sum 0; for (auto _ : state) { for (auto obj : vec) sum obj.compute(42); benchmark::DoNotOptimize(sum); } } BENCHMARK(BM_CRTP);实测结果Intel i7-13700KClang 18 -O3版本单次迭代耗时相对性能Virtual12.8 ms1.0xCRTP2.1 ms6.1x碾压级的差距。核心原因CRTP 版本中 compute() 被完全内联为一条 lea eax, [rdi*21]而虚函数版每次调用都要走 call [raxoffset] 间接跳转流水线断流、分支预测失败开销叠加。四、使用场景与开源实践4.1 场景一数值计算库Eigen 风格Eigen 的核心设计就是 CRTP。所有矩阵/向量类型都继承自 MatrixBaseT通过 CRTP 在编译期为每个具体类型生成特化代码// 简化版 Eigen 核心思想 template typename Derived class MatrixBase { public: Derived derived() { return static_castDerived(*this); } const Derived derived() const { return static_castconst Derived(*this); } // 所有运算都委托给派生类编译器会为每种矩阵类型生成最优代码 auto operator(const Derived other) const { Derived result; for (int i 0; i derived().rows(); i) for (int j 0; j derived().cols(); j) result(i, j) derived()(i, j) other(i, j); return result; } }; class Matrix3f : public MatrixBaseMatrix3f { float data_[3][3]; public: int rows() const { return 3; } int cols() const { return 3; } float operator()(int i, int j) { return data_[i][j]; } float operator()(int i, int j) const { return data_[i][j]; } }; // 使用时无运行时开销 Matrix3f a, b; auto c a b; // 全部在编译期展开无虚函数调用优点编译器看到的最终代码就像手写的 3×3 矩阵加法无任何间接调用。4.2 场景二运算符自动生成Boost.Operators写一个支持完整比较运算符的类通常很繁琐。Boost.Operators 库用 CRTP 自动生成#include boost/operators.hpp class Point : boost::less_than_comparablePoint, // 只需实现 自动生成 boost::equality_comparablePoint // 只需实现 自动生成 ! { public: Point(int x, int y) : x_(x), y_(y) {} int x_, y_; bool operator(const Point other) const { return std::tie(x_, y_) std::tie(other.x_, other.y_); } bool operator(const Point other) const { return x_ other.x_ y_ other.y_; } }; // 现在 Point 自动拥有 , , , ! 四个运算符——编译期生成零开销原理boost::less_than_comparablePoint 内部通过 static_castPoint(*this) 调用你定义的 operator然后以此为基础实现 operator 等。整个过程在编译期完成。4.3 场景三模板方法模式替代LLVM dyn_castLLVM 的 dyn_cast 和 isa 机制利用 CRTP 实现了无虚函数的 RTTI// 简化的 LLVM 风格 dyn_cast 内核 class TypeBase { public: enum TypeKind { TK_Int, TK_Float, TK_Ptr }; TypeKind getKind() const { return kind_; } protected: TypeBase(TypeKind k) : kind_(k) {} private: TypeKind kind_; }; template typename T class TypeBaseCRTP : public TypeBase { public: // 编译期注册每个子类的 kind 是静态常量无需 vtable static bool classof(const TypeBase* t) { return t-getKind() T::KindValue; } protected: TypeBaseCRTP() : TypeBase(T::KindValue) {} }; class IntType : public TypeBaseCRTPIntType { public: static constexpr TypeKind KindValue TK_Int; }; class FloatType : public TypeBaseCRTPFloatType { public: static constexpr TypeKind KindValue TK_Float; }; // 使用 IntType intTy; TypeBase* base intTy; if (IntType::classof(base)) { // 编译期确定的类型检查无虚函数开销 // 安全地 static_cast }4.4 场景四计数器/混合功能注入为类自动添加实例计数功能而不侵入原有代码template typename T class InstanceCounter { public: InstanceCounter() { count_; } InstanceCounter(const InstanceCounter) { count_; } InstanceCounter(InstanceCounter) noexcept { count_; } ~InstanceCounter() { --count_; } static size_t alive() { return count_; } private: inline static size_t count_ 0; // C17 inline static }; // 一行继承获得完整的实例计数能力 class MyWidget : public InstanceCounterMyWidget { std::string name_; public: MyWidget(std::string n) : name_(std::move(n)) {} }; // 使用 { MyWidget w1(btn), w2(text); std::cout MyWidget::alive(); // 输出2 } std::cout MyWidget::alive(); // 输出0五、CRTP 的局限与陷阱局限说明应对不支持异构容器不能把 DerivedA 和 DerivedB 放在同一个 vectorBase* 中因为 BaseDerivedA 和 BaseDerivedB 是不同类型需要异构容器时仍需虚函数或用 std::variant代码膨胀每种类型都生成一份完整的基类代码可能导致二进制体积增大将不依赖模板参数的通用逻辑抽到非模板基类编译依赖所有代码在头文件中修改影响面大合理设计接口隔离非关键路径不用 CRTP构造 / 析构期不安全在基类构造函数中调用 static_castDerived*(this) 是未定义行为因为派生类尚未构造绝对不要在基类构造/析构中调用 CRTP 接口如何抽取通用逻辑避免代码膨胀// 非模板基类存放通用逻辑 class NonTemplateBase { protected: void common_operation() { // 大量通用代码只编译一次 } }; // 模板层只放需要多态的部分 template typename Derived class CRTPLayer : public NonTemplateBase { public: void polymorphic_op() { static_castDerived*(this)-derived_specific(); } }; class Concrete : public CRTPLayerConcrete { public: void derived_specific() { /* 类型特定逻辑 */ } };六、CRTP 与 C20 Concepts 结合C20 Concepts 可以让 CRTP 的接口约束更加清晰#include concepts // 定义派生类必须满足的接口 template typename T concept CRTPDerived requires(T t) { { t.name() } - std::convertible_tostd::string_view; { t.serialize() } - std::convertible_tostd::string; }; template CRTPDerived Derived class Serializable { public: std::string to_json() const { auto d static_castconst Derived(*this); return {\name\:\ std::string(d.name()) \,\data\:\ d.serialize() \}; } }; // 如果派生类缺少 name() 或 serialize()会在定义处而非使用处产生清晰的错误信息 class User : public SerializableUser { public: std::string_view name() const { return Alice; } std::string serialize() const { return user_data; } };七、综合示例轻量级几何引擎用一个完整的例子展示 CRTP 在实际项目中的力量#include iostream #include cmath #include vector #include concepts #include cassert // CRTP 几何基类 template typename Derived class GeometryObject { public: // 必须由派生类实现 double area() const { return static_castconst Derived*(this)-area_impl(); } double perimeter() const { return static_castconst Derived*(this)-perimeter_impl(); } std::string name() const { return static_castconst Derived*(this)-name_impl(); } // 基类提供的通用功能派生类无需重复实现 void describe() const { std::cout name() : area area() , perimeter perimeter() \n; } }; // 具体几何类型 class Circle : public GeometryObjectCircle { double r_; public: explicit Circle(double r) : r_(r) { assert(r 0); } double area_impl() const { return M_PI * r_ * r_; } double perimeter_impl() const { return 2.0 * M_PI * r_; } std::string name_impl() const { return Circle(r std::to_string(r_) ); } }; class Rectangle : public GeometryObjectRectangle { double w_, h_; public: Rectangle(double w, double h) : w_(w), h_(h) { assert(w 0 h 0); } double area_impl() const { return w_ * h_; } double perimeter_impl() const { return 2.0 * (w_ h_); } std::string name_impl() const { return Rectangle( std::to_string(w_) x std::to_string(h_) ); } }; class Triangle : public GeometryObjectTriangle { double a_, b_, c_; public: Triangle(double a, double b, double c) : a_(a), b_(b), c_(c) { assert(a b c b c a a c b); } double area_impl() const { double s (a_ b_ c_) / 2.0; return std::sqrt(s * (s - a_) * (s - b_) * (s - c_)); } double perimeter_impl() const { return a_ b_ c_; } std::string name_impl() const { return Triangle; } }; // 编译期多态的通用函数 template typename GeoObj void print_info(GeoObj obj) { obj.describe(); // 编译期内联零开销 } template typename GeoObj double total_area(const std::vectorGeoObj objects) { double sum 0; for (auto obj : objects) sum obj.area(); // 全部内联 return sum; } // 测试 int main() { Circle c(5.0); Rectangle r(3.0, 4.0); Triangle t(3.0, 4.0, 5.0); print_info(c); // Circle(r5.000000): area78.5398, perimeter31.4159 print_info(r); // Rectangle(3.000000x4.000000): area12, perimeter14 print_info(t); // Triangle: area6, perimeter12 std::vectorCircle circles {Circle(1.0), Circle(2.0), Circle(3.0)}; std::cout Total circle area: total_area(circles) \n; // 输出Total circle area: 43.9823 }编译运行这段代码用 objdump -d 反汇编查看你会发现 print_info(t) 中 t.describe() 的调用被完全展开为直接计算——就像你把海伦公式和 std::cout 手写在一起。没有 call 指令没有 vtable 查找没有间接跳转。八、决策速查场景特征推荐方案需要 vectorBase* 存储不同类型对象虚函数CRTP 做不到所有类型在编译期已知追求极致性能CRTP接口稳定、派生类少二进制大小敏感虚函数避免代码膨胀希望运算符自动生成, , ! 等CRTPBoost.Operators运行时插件系统.so/.dll 动态加载虚函数CRTP 无法跨编译单元嵌入式 / 游戏 / HFT / 数值计算CRTP零开销抽象需要 Concepts 约束派生类接口CRTP C20 Concepts九、总结CRTP 是 C 模板元编程中最实用、最广泛部署的技术之一。它不依赖任何运行时机制纯粹利用编译期类型推导实现了传统虚函数式的接口抽象——但速度是虚函数的 5~6 倍且不占对象空间。核心价值一句话CRTP 让你能用面向接口的思维写代码却得到手写循环的性能。在 Eigen、LLVM、Boost、Abseil、Wt 等一线 C 开源项目中CRTP 是核心架构的基石。掌握它意味着你真正理解了编译期多态这一 C 独有的性能利器。常见问题速查Q: CRTP 和虚函数可以混用吗A: 可以。例如 Derived : public BaseDerived, public IPluginIPlugin 用虚函数对外暴露动态接口BaseDerived 在编译期做内部优化。Q: 如何防止忘记实现派生类的方法A: 传统上只能靠链接错误或运行时报错。C20 后推荐用 Concepts 在编译期约束见第六章。Q: CRTP 的代码调试体验如何A: 不如虚函数直观——因为内联后调用栈中看不到多态调用层。但现代调试器对模板代码的支持在持续改善且性能收益通常远超调试不便利。