C++ 静态多态——CRTP on Dorkytiger 的小屋

CRTP 基础模式

Mon, 01 Jan 0001 00:00:00 +0000

一、为什么需要 CRTP？

场景：你有一个算法框架，不同的派生类有不同的"处理步骤"，但算法骨架是一样的。你有两个选择：

虚函数方案：

class Processor {
public:
    virtual void process() = 0;
    virtual ~Processor() = default;
};

问题：虚函数调用不能内联。如果你的 process() 只有几行代码且每秒调用百万次，虚函数间接寻址的开销占比就很大。

CRTP 方案：把派生类作为模板参数传给基类，基类用 static_cast 调用派生类的方法——这个转换在编译期完成，可以内联。

二、CRTP 长什么样？

template <typename Derived>
class Base {
public:
    void interface() {
        // 编译期将 this 转为 Derived*，直接调用
        static_cast<Derived*>(this)->implementation();
    }
};

class DerivedA : public Base<DerivedA> {
public:
    void implementation() { /* A 的处理 */ }
};

class DerivedB : public Base<DerivedB> {
public:
    void implementation() { /* B 的处理 */ }
};

编译器眼中：

Base<DerivedA>::interface() 被调用时：
  static_cast<DerivedA*>(this) 在编译期确定
  → 直接调用 DerivedA::implementation()
  → 可以内联 → 编译后可能只剩几条指令

Base<DerivedB>::interface() 被调用时：
  → 直接调用 DerivedB::implementation()
  两个 Base<DerivedA> 和 Base<DerivedB> 是完全不同的类型
  各有自己的 interface() 实现，没有虚表

三、CRTP 和虚函数的性能差距

// 虚函数版
struct ShapeVirt { virtual double area() const = 0; };
struct CircleVirt : ShapeVirt {
    double r;
    double area() const override { return 3.1415926 * r * r; }
};

// CRTP 版
template <typename Derived>
struct ShapeCRTP {
    double area() const {
        return static_cast<const Derived*>(this)->area_impl();
    }
};
struct CircleCRTP : ShapeCRTP<CircleCRTP> {
    double r;
    double area_impl() const { return 3.1415926 * r * r; }
};

10 亿次调用实测：

CRTP 典型应用

Mon, 01 Jan 0001 00:00:00 +0000

一、`std::enable_shared_from_this<T>`

这是 CRTP 在标准库中最经典的应用。场景：你有一个 shared_ptr 管理的对象，对象内部需要生成指向自己的 shared_ptr。

class Widget : public std::enable_shared_from_this<Widget> {
public:
    void register_callback() {
        // 把一个回调注册到别处，回调要持有 Widget 的 shared_ptr
        // 防止 Widget 被释放时回调还在执行
        callback_mgr_.add([self = shared_from_this()] {
            self->do_something();
        });
    }
};

没有 CRTP 会怎样？

如果 enable_shared_from_this 不是模板，它不知道派生类的类型，shared_from_this() 只能返回 shared_ptr<enable_shared_from_this>，不是 shared_ptr<Widget>。CRTP 让基类在编译期拿到派生类的类型，自然就能正确返回。

二、CRTP 实现实例计数

template <typename Derived>
class InstanceCounter {
    static inline int count_ = 0;
protected:
    InstanceCounter() { count_++; }
    ~InstanceCounter() { count_--; }
public:
    static int instance_count() { return count_; }
};

class MyClass : public InstanceCounter<MyClass> {
    // ...
};

class OtherClass : public InstanceCounter<OtherClass> {
    // ...
};

// MyClass 和 OtherClass 有各自独立的 count_
MyClass a, b;
OtherClass c;
MyClass::instance_count();   // 2
OtherClass::instance_count(); // 1

因为 InstanceCounter<MyClass> 和 InstanceCounter<OtherClass> 是两个不同的类，它们的 static count_ 是独立的。

第一阶段总结

Mon, 01 Jan 0001 00:00:00 +0000

CRTP 本质：
    编译期多态，基类知道派生类类型
    用 static_cast<Derived*> 消除虚函数间接调用

核心价值：
    短小高频函数快 3-5 倍（可内联）
    enable_shared_from_this 是标准库案例

代价：
    不同派生类不能放同一个容器
    每实例化一次生成一份代码

C++ 静态多态——CRTP on Dorkytiger 的小屋

CRTP 基础模式

一、为什么需要 CRTP？

二、CRTP 长什么样？

三、CRTP 和虚函数的性能差距

CRTP 典型应用

一、std::enable_shared_from_this<T>

二、CRTP 实现实例计数

第一阶段总结

一、`std::enable_shared_from_this<T>`