99、STL与CRTP：静态多态、奇异递归模板、代码复用

说实话，很多C++开发者写了三五年代码，对模板的理解还停留在「泛型容器」这个层面。但当你真正深入STL源码，你会发现一个反复出现的模式——CRTP（Curiously Recurring Template Pattern，奇异递归模板模式）。

我第一次在Boost库中看到这个模式时，说实话有点懵。一个类把自己的派生类作为模板参数传给自己？这不是循环依赖吗？后来我才明白，这恰恰是C++静态多态的精髓所在。

什么是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" << std::endl;
    }
};

看到了吗？Derived继承自Base<Derived>，把自己作为模板参数传给了基类。这就是「奇异递归」这个名字的由来。

为什么STL中大量使用CRTP？

我个人习惯把CRTP看作「编译期的虚函数」。虚函数虽然好用，但有两个硬伤：

• 运行时开销：虚函数调用需要查虚表，无法内联
• 类型擦除：虚函数会丢失具体的派生类型信息

STL的设计哲学是「零开销抽象」。你想想看，如果std::sort每次比较都要走虚函数调用，那性能损失是不可接受的。所以STL大量使用模板和CRTP来实现静态多态。

举个例子，std::enable_shared_from_this就是CRTP的典型应用：

class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    std::shared_ptr<MyClass> getShared() {
        return shared_from_this();
    }
};

这里enable_shared_from_this通过CRTP知道了派生类的具体类型，从而能够正确创建shared_ptr。

CRTP实现代码复用

我在项目中遇到过这样一个场景：需要为多个类提供相同的运算符重载。比如，我想让所有实现了value()方法的类都支持比较操作：

template <typename Derived>
class Comparable {
public:
    bool operator<(const Derived& other) const {
        return static_cast<const Derived*>(this)->value() < other.value();
    }
    bool operator==(const Derived& other) const {
        return static_cast<const Derived*>(this)->value() == other.value();
    }
    // 其他运算符可以通过这两个推导出来
};

class IntWrapper : public Comparable<IntWrapper> {
    int val_;
public:
    explicit IntWrapper(int v) : val_(v) {}
    int value() const { return val_; }
};

class DoubleWrapper : public Comparable<DoubleWrapper> {
    double val_;
public:
    explicit DoubleWrapper(double v) : val_(v) {}
    double value() const { return val_; }
};

你看，Comparable这个基类只写了一次，但IntWrapper和DoubleWrapper都自动获得了比较功能。这就是CRTP的代码复用能力。

CRTP vs 虚函数：怎么选？

特性	CRTP（静态多态）	虚函数（动态多态）
调用开销	无（编译期解析）	有（虚表查找）
内联支持	完全支持	有限支持
类型信息	保留具体类型	类型擦除
二进制体积	可能膨胀（模板实例化）	较小
运行时多态	不支持	支持
适用场景	编译期已知类型、性能敏感	运行时多态、插件系统

说白了，如果你在写一个框架，用户需要传入不同类型的对象，而且这些类型在编译期就确定了——用CRTP。如果你需要运行时根据条件选择不同的实现——用虚函数。

CRTP的避坑指南

我曾经在一个项目中过度使用CRTP，结果编译时间暴涨，错误信息让人崩溃。这里分享几个经验：

• 不要嵌套太深：CRTP模板链超过3层，编译错误基本看不懂
• 注意代码膨胀：每个不同的派生类都会生成一份基类代码的副本
• 小心static_cast：如果派生类没有实现基类调用的方法，编译器报错会非常隐晦

一个完整的CRTP实战：对象池

让我用一个实际例子来收尾。假设我们要实现一个对象池，让不同类型的对象都能复用：

template <typename T>
class ObjectPool {
    std::vector<std::unique_ptr<T>> pool_;
public:
    template <typename... Args>
    std::unique_ptr<T> acquire(Args&&... args) {
        if (pool_.empty()) {
            return std::make_unique<T>(std::forward<Args>(args)...);
        }
        auto obj = std::move(pool_.back());
        pool_.pop_back();
        obj->reset(std::forward<Args>(args)...);
        return obj;
    }
    void release(std::unique_ptr<T> obj) {
        pool_.push_back(std::move(obj));
    }
};

// 使用CRTP让对象支持reset
template <typename Derived>
class Poolable {
public:
    template <typename... Args>
    void reset(Args&&... args) {
        static_cast<Derived*>(this)->onReset(std::forward<Args>(args)...);
    }
};

class Connection : public Poolable<Connection> {
public:
    void onReset(const std::string& host, int port) {
        // 重置连接状态
        host_ = host;
        port_ = port;
    }
private:
    std::string host_;
    int port_ = 0;
};

这个例子中，Poolable通过CRTP要求派生类实现onReset方法。对象池在复用对象时调用reset，而reset又通过静态多态转发到具体的onReset实现。没有虚函数，没有运行时开销。

总结

CRTP是C++模板元编程的基石之一。它让静态多态成为可能，让代码复用变得优雅而高效。STL中随处可见它的身影——从std::enable_shared_from_this到迭代器适配器，从std::numeric_limits到各种traits类。

嗯，最后说一句：CRTP虽好，但不要滥用。如果你的场景确实需要运行时多态，老老实实用虚函数。工具没有好坏，关键看用在什么地方。

---

公众号:蓝海资料掘金营，微信deep3321