CRTP（奇异递归模板模式）如何实现静态多态？

CRTP（Curiously Recurring Template Pattern，奇异递归模板模式）是C++中实现编译期静态多态的经典技术，它通过模板继承和递归类型推导，在零运行时开销的情况下实现多态行为。下面通过分层解析揭示其核心机制：

一、基本模式结构

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation(); // 关键转型
    }
};

class Derived : public Base<Derived> { // 递归模板参数
public:
    void implementation() {
        cout << "Derived implementation" << endl;
    }
};

核心特点：

1. 基类是模板类，模板参数为派生类类型
2. 派生类继承时将自己作为模板参数传递给基类
3. 通过static_cast<Derived*>(this)在编译期完成方法绑定

二、工作原理图解

+-------------------+       +-------------------+
| Base<Derived>     |       | Derived           |
|-------------------|       |-------------------|
| +interface()      |       | +implementation() |
|   static_cast →   |───────|                   |
+-------------------+       +-------------------+

1. 当调用Derived().interface()时：
   • 编译器实例化Base<Derived>
   • static_cast将this转为Derived*类型
   • 直接调用Derived::implementation()
2. 零虚函数开销：所有调用在编译期静态绑定

三、对比动态多态

四、典型应用场景

1. 静态多态接口

template <typename T>
class Drawable {
public:
    void draw() {
        static_cast<T*>(this)->render();
    }
};

class Circle : public Drawable<Circle> {
public:
    void render() { cout << "Drawing circle" << endl; }
};

// 使用
template <typename T>
void drawAll(T& obj) {
    obj.draw(); // 编译期绑定
}

2. 方法注入（Mixin）

template <typename Derived>
class Comparable {
public:
    bool operator!=(const Derived& other) const {
        return !(static_cast<const Derived*>(this)->operator==(other));
    }
};

class Person : public Comparable<Person> {
public:
    bool operator==(const Person& other) const { 
        return name == other.name;
    }
    string name;
};

3. 静态多态容器（STL风格）

template <typename Derived>
class Container {
public:
    auto size() const {
        return static_cast<const Derived*>(this)->actualSize();
    }
};

class Vector : public Container<Vector> {
public:
    size_t actualSize() const { return data.size(); }
    vector<int> data;
};

五、高级技巧与陷阱

1. 访问控制修正

class Derived : public Base<Derived> {
    friend class Base<Derived>; // 允许基类访问私有方法
private:
    void implementation() { ... }
};

2. 多级CRTP

template <typename T>
class Level1 : public T { ... };

template <typename T>
class Level2 : public T { ... };

class Concrete : public Level2<Level1<Concrete>> { ... };

3. 常见陷阱

• 无限递归类型：

  class Wrong : public Base<Wrong> {}; // 正确
  class Error : public Base<Other> {}; // 编译错误
  

• 对象切片风险：

  void process(Base<Derived>& obj) { ... } // 必须传引用/指针
  

六、性能实测对比

测试代码：

// CRTP版本
template <typename D>
struct Base { void run() { static_cast<D*>(this)->exec(); } };

// 虚函数版本
struct VBase { virtual void run() = 0; };

// 测试循环
void benchmark() {
    auto start = chrono::high_resolution_clock::now();
    // 调用1000万次...
    auto end = chrono::high_resolution_clock::now();
}

结果（-O3优化）：

• CRTP：~5ms
• 虚函数：~25ms

七、现代C++演进

C++17改进：constexpr if增强

template <typename Derived>
class Base {
public:
    void interface() {
        if constexpr (requires { static_cast<Derived*>(this)->impl(); }) {
            static_cast<Derived*>(this)->impl();
        } else {
            defaultImpl();
        }
    }
};

C++20概念约束

template <typename T>
concept CRTPDerived = requires(T t) {
    { t.implementation() } -> same_as<void>;
};

template <CRTPDerived Derived>
class SafeBase { ... };

常见问题

1. CRTP中为什么不需要虚函数？

   • 通过编译期模板实例化和static_cast实现静态绑定

2. 如何防止CRTP基类被错误实例化？

   • 将基类构造函数设为protected
   • 或使用C++20概念约束模板参数

3. CRTP与策略模式的区别？

   • CRTP：编译期组合，零开销
   • 策略模式：运行期组合，接口抽象

4. 何时选择CRTP而非虚函数？

   • 需要极致性能时
   • 编译期多态足够时
   • 需要向派生类"注入"方法时

CRTP将C++模板元编程的威力与面向对象继承完美结合，是高性能库开发的核心技术之一。理解其本质后，可大幅提升模板代码的设计能力。