CRTP：C++中的递归模板类模式（Curiously Recurring Template Pattern）详解

作者

递归模板类模式（CRTP）是一种在编译期实现静态多态的技巧，它通过让派生类作为模板参数传递给基类，从而在编译期完成行为绑定。CRTP 既可以用于实现性能优异的可重用组件，也可以在设计时提供强类型约束。本文将从理论、实现、典型应用以及现代 C++ 的变体等角度，深入剖析 CRTP 的核心价值与使用技巧。

1. CRTP 的基本概念

CRTP 的核心写法是：

template <typename Derived>
class Base {
public:
    void interface() {
        // 调用派生类实现
        static_cast<Derived*>(this)->implementation();
    }
};

class Derived : public Base <Derived> {
public:
    void implementation() {
        std::cout << "Derived implementation\n";
    }
};
  • Derived 通过 `Base ` 继承基类。
  • 基类在内部用 static_cast<Derived*>(this) 将 this 强制转换为派生类指针，进而访问派生类特有的成员。

这种模式实现了静态多态：不同派生类在编译期完成实现细节的绑定，而不产生虚函数表。相较于传统的虚函数，CRTP 可以消除运行时的虚函数调用开销，并允许更细粒度的内联优化。

2. CRTP 与虚函数的对比

特性 CRTP 虚函数
运行时成本 无 虚表指针 + 隐式 this 指针
编译时类型检查 通过 static_assert 等实现 由编译器自动完成
多继承兼容性 适合多重继承（不需要虚继承） 需要虚继承以避免二义性
可重用性 高（可与模板参数化结合） 受限于单一继承链
代码可读性 需要理解模板递归 直观易懂

小贴士：如果你关心性能（如游戏引擎、金融计算），CRTP 是非常合适的。若你更注重代码的直观性与简洁性，传统虚函数仍是首选。

3. CRTP 的典型应用

3.1 组合式日志系统

template <typename Derived>
class Logger {
public:
    void log(const std::string &msg) {
        static_cast<Derived*>(this)->output(msg);
    }
};

class ConsoleLogger : public Logger <ConsoleLogger> {
public:
    void output(const std::string &msg) {
        std::cout << "[Console] " << msg << '\n';
    }
};

class FileLogger : public Logger <FileLogger> {
public:
    void output(const std::string &msg) {
        std::ofstream out("log.txt", std::ios::app);
        out << "[File] " << msg << '\n';
    }
};

通过 CRTP，Logger 提供统一的 log() 接口，派生类只需要实现 output()。在编译期即可决定具体的输出实现，无需虚函数。

3.2 事件总线（Event Bus）

template <typename Derived>
class EventBus {
public:
    template <typename Event>
    void dispatch(const Event &e) {
        static_cast<Derived*>(this)->handle(e);
    }
};

class GameEventBus : public EventBus <GameEventBus> {
public:
    void handle(const PlayerMoveEvent &e) { /* ... */ }
    void handle(const EnemySpawnEvent &e) { /* ... */ }
    // 其他事件类型
};

EventBus 使用 CRTP 实现多重事件类型的 handle，避免了虚函数分发和 RTTI 机制。

3.3 递归模板中的算法实现

template <typename Derived, int N>
class Factorial : public Factorial<Derived, N-1> {
public:
    static constexpr int value = N * Derived::value;
};

template <typename Derived>
class Factorial<Derived, 0> { // 基础模板
public:
    static constexpr int value = 1;
};

int main() {
    constexpr int fact5 = Factorial<Factorial, 5>::value; // 120
}

这里 CRTP 与递归模板结合，用于在编译期计算阶乘。虽然与 CRTP 传统用法不同，但同样体现了模板递归带来的强大表达能力。

4. 现代 C++ 中的 CRTP 变体

4.1 使用 static_cast 的替代方案：decltype

在 C++20/23 中，可以用 decltype(auto) + std::forward 等技巧进一步提升类型安全：

template <typename Derived>
class Base {
public:
    auto interface() {
        return static_cast<Derived*>(this)->implementation();
    }
};

4.2 与 Concepts 的结合

C++20 Concepts 可以为 CRTP 的派生类提供更明确的接口约束：

template <typename Derived>
concept HasImplementation = requires(Derived d) {
    { d.implementation() };
};

template <typename Derived>
    requires HasImplementation <Derived>
class Base { /* ... */ };

这样可以在编译期捕捉缺失 implementation() 的错误，而不必等到模板实例化时才报错。

4.3 多重 CRTP 继承

template <typename Derived>
class Serializable : public Base <Derived> {
public:
    void serialize() { static_cast<Derived*>(this)->do_serialize(); }
};

template <typename Derived>
class Loggable : public Base <Derived> {
public:
    void log() { static_cast<Derived*>(this)->do_log(); }
};

class MyClass : public Serializable <MyClass>, public Loggable<MyClass> {
public:
    void do_serialize() { /* ... */ }
    void do_log() { /* ... */ }
};

CRTP 可以轻松支持多继承，无需虚继承，避免多表间冲突。

5. CRTP 的潜在坑与最佳实践

  1. 构造函数顺序：CRTP 并不影响构造顺序，但请注意基类和派生类成员初始化的顺序，尤其当基类访问派生成员时，派生成员需要先初始化。
  2. 可见性：若基类在访问派生成员时，派生成员应为 public 或 protected。若为 private，则编译器会报错。
  3. 递归错误信息：递归模板实例化错误往往导致堆栈深度过大，错误信息不易读。使用 static_assert 或 Concept 提前检查会更友好。
  4. 不适合运行时多态：CRTP 只能在编译期确定类型，若需要根据运行时条件切换实现，仍需使用虚函数或策略模式。

6. 结语

CRTP 是 C++ 递归模板的一大宝藏，它让我们在不使用虚函数的前提下实现多态、组合以及编译期计算。掌握 CRTP，你可以：

  • 编写更高性能、零运行时开销的类库。
  • 利用模板递归完成编译期算法。
  • 在复杂系统中实现模块化的接口与实现分离。

虽然 CRTP 在语法上略显晦涩，但其带来的可维护性与性能优势是值得投资学习的。建议从小型项目开始实验，一旦熟练后，再在大型项目中大胆运用。祝你在 C++ 的世界里玩得开心，并创造出更优秀的代码。

发表评论