先聊聊 CRTP 是啥玩意儿

说实话，CRTP听起来像是高大上的学术名词。

其实它就是让一个类把自己当作模板参数塞进基类。

比如：

template
class Base {
public:
    void interface {
        // 把 this 当成 Derived 来用
        static_cast->implementation;
    }
};
class MyClass : public Base {
public:
    void implementation { /* 真正的业务代码 */ }
};

这段代码里Base 并不知道派生类到底长啥样，

但它Ke以在编译期把调用路由到 MyClass::implementation。

哈哈，这种“自我引用”模式，就是 CRTP 的核心。

传统的多态用虚函数实现，运行时要查 vtable，开销不小。

而 CRTP 把多态搬到编译期，函数直接内联，速度嗖嗖的。

在游戏引擎、浏览器内核这些对性Neng挑剔的项目里CRTP 简直是救星。

先写个动物基类：

template
class Animal {
public:
    void speak {
        // 编译器会把这里展开成 D::speakImpl
        static_cast->speakImpl;
    }
};

然后派生两只动物：

class Cat : public Animal {
public:
    void speakImpl { std::cout < "喵~
"; }
};
class Dog : public Animal {
public:
    void speakImpl { std::cout < "汪!
"; }
};

main 里随便调：

int main {
    Cat c;
    Dog d;
    c.speak; // 编译后直接调用 Cat::speakImpl
    d.speak; // 同理
}

注意，这里根本没有 virtual，也没有指针、没有 RTTI。

编译器在生成机器码时Yi经把每个 speak 替换成了对应的实现函数地址。

有人会问：Animal 里用了 D::speakImpl, 可是 Cat 还没写完呢？

答案是：模板实例化是懒惰的。

C++ 在kan到模板被使用时才去实例化，而此时 Cat Yi经完整定义了。

所以编译器不会在 “kan见未完成类型” 那一步卡住而是等到所有声明dou结束再去检查。

EASTL里有个经典写法：

template
class RefCounted {
public:
    void addRef const { ++refCount_; }
    void release const {
        if 
            Traits::Destruct);
    }
private:
    mutable int refCount_ = 0;
};
class Foo : public RefCounted {
    friend class RefCounted;
private:
    ~Foo { /* 私有析构 */ }
};

C R T P 在这里让基类知道真正要删掉的是 T。

LLLVM 用 CRTP 写了一个访客框架：

struct CountAllocaVisitor : public llvm::InstVisitor {
    unsigned Count = 0;
    void visitAllocaInst { ++Count; }
};

This Visitor 会在遍历指令时自动把调用路由到子类的具体方法，省掉大量 switch‑case 和 cast。

Svelte 编译器和 V8 JavaScript 引擎dou用类似下面的结构：

template
class ParserBase {
public:
    Impl* impl { return static_cast; }
    const Impl* impl const { return static_cast; }
    void parseExpression {
        // 编译期决定使用哪个 Impl 的实现
        impl->parseExpressionImpl;
    }
};
class FullParser : public ParserBase { /* ... */ };
class PreParser  : public ParserBase;   /* ... */

C R T P 把通用解析流程抽出来而具体行为交给不同派生类实现，从而既保持代码复用，又Neng在 release 模式下全内联。

No runtime polymorphism: Ru果你真的需要在运行时决定走哪条分支，CRTP 就帮不了忙。那还是靠 virtual 或者策略模式吧。

Circular dependency headaches: 因为派生类名字要先出现在基类模板参数里所以文件组织得不太好会出现前向声明冲突。别忘了提前声明或者拆分头文件。

Mega‑instantiation bloat: 每个派生类dou会生成一套完整的基类代码。Ru果你有上百个子类，编译时间和二进制体积会膨胀。适度使用，别滥上天花板。

Error messages 暴走: 模板错误往往hen难读懂。尤其是两阶段查找搞错时报错可Neng指向基类而不是你的实现。调试前准备好耐心和咖啡。

No virtual destructor: Ru果你打算通过基类指针删除对象，一定记得加 virtual destructor，否则 UB。CRTP 本身不提供这种安全网，需要自行补足。

# 为什么百度不收录我的页面？#

A：可Neng标题太俗套，没有独特关键词；或者页面缺少结构化数据、meta 描述太短；再者，Ru果页面加载太慢、JS 渲染过度，也会被爬虫忽略。

B：还有一种情况是网站 robots.txt 把关键路径屏蔽了或者服务器返回了错误码。

C：Zui后Ru果内容重复率高，被判定为“薄内容”，百度自然就不爱收录啦。

DCCZui早想把所有组件dou写成 CRTP，以便统一管理生命周期和序列化逻辑。

结果后来发现，有几个组件需要跨线程通信，于是硬加了 mutex 和 condition_variable，再配合虚函数Zuo回调——整个层级变得又静态又动态，两头抓狂。

TinyXML Zui初用了虚函数遍历节点树，但性Neng瓶颈明显，于是改成了类似下面的 CRTP：

template
class NodeVisitorBase {
public:
    void visit {
        switch ) {
            case Node::Element: static_cast->element; break;
            case Node::Text:   static_cast->text;   break;
            // ...
        }
}
}; 
// 用户只需要继承并实现 element/text 方法

The result? 编译期就把 switch‑case 优化掉，大幅提升了解析速度。但代价是代码阅读门槛升高，新手kan着眼花缭乱——于是团队内部开始流行一句口号：“CRTP 是技术债，用完一定要写注释”。哈哈，你懂的！

- 是否追求极限性Neng？比如热点路径需要内联？ ✅

- 是否Ke以在编译期确定所有行为？Ru果还有运行时配置，那别强行塞进去。 ❌

- 子类数量大概多少？几百个以上可Neng导致编译时间爆炸。 ⚠️

- 项目团队对模板熟悉度如何？Ru果大家dou怕kan不懂模板错误，那先培训再上阵。 📚

A：写起来像玩魔术，把“未来”的代码提前放进当前文件，就像预知未来一样爽快； B：运行时没有任何额外开销，让我们的程序跑得飞起； C：它是一种思维方式，让我们学会从“类型”角度抽象问题，而不是“一堆 if‑else”。 说实话，这种高级抽象背后隐藏的是 C++ 编译器强大的元编程Neng力——真的hen酷！哈哈，有时候我甚至想给它起个绰号叫 “隐形拳”。咱就是说用好了它，你Ke以省掉不少性Neng坑；用不好，你就会陷入无尽的模板地狱……你懂的～