一文详解C++奇异递归模板(CRTP)

#include<iostream>using namespace std;// 1. CRTP 基类：模板类，参数为派生类类型template <typename Derived>class Base {public:    // 基类中可以通过模板参数访问派生类    voiddoSomething(){        // 将基类指针 this 转换为派生类指针        Derived* derived = static_cast<Derived*>(this);        // 调用派生类的成员函数（编译期确定）        derived->impl();    }};// 2. 派生类：继承 Base<自身>class Derived : public Base<Derived> {public:    // 派生类实现具体逻辑    voidimpl(){        cout << "Derived 具体实现逻辑" << endl;    }};intmain(){    Derived d;    d.doSomething(); // 输出：Derived 具体实现逻辑    return 0;}

#include<iostream>using namespace std;// 1. 虚函数多态（动态绑定）class ShapeVirtual {public:    virtualvoiddraw()= 0; // 纯虚函数    virtual ~ShapeVirtual() {}};class CircleVirtual : public ShapeVirtual {public:    voiddraw()override{        cout << "绘制圆形（虚函数）" << endl;    }};// 2. CRTP 多态（静态绑定）template <typename Derived>class ShapeCRTP {public:    voiddraw(){        static_cast<Derived*>(this)->drawImpl();    }};class CircleCRTP : public ShapeCRTP<CircleCRTP> {public:    voiddrawImpl(){        cout << "绘制圆形（CRTP）" << endl;    }};intmain(){    // 虚函数多态：运行时绑定    ShapeVirtual* v_ptr = new CircleVirtual();    v_ptr->draw(); // 运行时查找虚表，调用 CircleVirtual::draw()    // CRTP 多态：编译期绑定    CircleCRTP c;    c.draw(); // 编译期直接绑定 CircleCRTP::drawImpl()    delete v_ptr;    return 0;}

#include<iostream>#include<vector>using namespace std;// CRTP 基类：通用算法接口template <typename Derived>class Algorithm {public:    // 统一接口    voidexecute(const vector<int>& data){        static_cast<Derived*>(this)->doExecute(data);    }};// 排序算法派生类class SortAlgorithm : public Algorithm<SortAlgorithm> {public:    voiddoExecute(const vector<int>& data){        cout << "执行排序算法：";        for (int num : data) cout << num << " ";        cout << endl;        // 实际排序逻辑...    }};// 过滤算法派生类class FilterAlgorithm : public Algorithm<FilterAlgorithm> {public:    voiddoExecute(const vector<int>& data){        cout << "执行过滤算法：";        for (int num : data) if (num > 5) cout << num << " ";        cout << endl;        // 实际过滤逻辑...    }};// 通用调用函数（编译期多态）template <typename T>voidrunAlgorithm(Algorithm<T>& algo, const vector<int>& data){    algo.execute(data);}intmain(){    vector<int> data = {3, 7, 1, 9, 4};    SortAlgorithm sortAlgo;    FilterAlgorithm filterAlgo;    runAlgorithm(sortAlgo, data);  // 执行排序算法    runAlgorithm(filterAlgo, data); // 执行过滤算法    return 0;}

#include<iostream>using namespace std;// CRTP 基类：提供对象计数功能template <typename Derived>class Countable {public:    // 静态变量：记录当前派生类的对象个数    static inline int count = 0;    // 构造函数：对象创建时计数+1    Countable() {        count++;    }    // 拷贝构造：同样计数+1    Countable(const Countable&) {        count++;    }    // 析构函数：对象销毁时计数-1    ~Countable() {        count--;    }    // 静态方法：获取当前对象个数    staticintgetCount(){        return count;    }};// 派生类 A：自动获得计数功能class A : public Countable<A> {};// 派生类 B：自动获得计数功能class B : public Countable<B> {};intmain(){    A a1, a2;    B b1;    cout << "A 类对象个数：" << A::getCount() << endl; // 输出：2    cout << "B 类对象个数：" << B::getCount() << endl; // 输出：1    {        A a3;        cout << "A 类对象个数（局部作用域）：" << A::getCount() << endl; // 输出：3    }    cout << "A 类对象个数（局部作用域结束）：" <&lt; A::getCount() &lt;&lt; endl; // 输出：2    return 0;}

#include <iostream>using namespace std;// CRTP 基类：禁止派生类被继承template <typename Derived>classNonInheritable{private:    // 私有构造函数和析构函数    NonInheritable() {}    ~NonInheritable() {}    // 允许 Derived 访问私有成员    friend classDerived;};// 可实例化，但不能被继承classFinalClass : publicNonInheritable<FinalClass> {public:    void print() {        cout << "FinalClass 不能被继承" << endl;    }};// 尝试继承 FinalClass：编译失败！// classSubClass : publicFinalClass{// };int main() {    FinalClass fc;    fc.print(); // 正常运行    return 0;}

#include<iostream>#include<string>using namespace std;// 1. CRTP 基类1：对象计数template <typename Derived>class Countable {public:    static inline int count = 0;    Countable() { count++; }    ~Countable() { count--; }    staticintgetCount(){ return count; }};// 2. CRTP 基类2：日志记录template <typename Derived>class Loggable {public:    voidlog(const string& msg){        cout << "[" << typeid(Derived).name() << "] " << msg << endl;    }};// 派生类：同时继承两个 CRTP 基类，获得计数和日志功能class MyClass : public Countable<MyClass>, public Loggable<MyClass> {public:    voiddoWork(){        log("开始执行 doWork");        // 业务逻辑...        log("doWork 执行完毕");    }};intmain(){    MyClass c1, c2;    c1.doWork();    c2.doWork();    cout << "MyClass 对象个数：" << MyClass::getCount() << endl; // 输出：2    return 0;}

#include<iostream>using namespace std;// CRTP 基类：编译期计数器template <typename Derived, int N = 0>class CompileTimeCounter {public:    // 编译期常量：当前计数    static constexpr int value = N;    // 派生类：计数+1    template <int M = N + 1>    using Next = CompileTimeCounter<Derived, M>;};// 测试：编译期计数class Test;using Counter1 = CompileTimeCounter<Test>;          // value = 0using Counter2 = Counter1::Next;                    // value = 1using Counter3 = Counter2::Next;                    // value = 2intmain(){    // 编译期确定的值，直接输出    cout << Counter1::value << endl; // 输出：0    cout << Counter2::value << endl; // 输出：1    cout << Counter3::value << endl; // 输出：2    return 0;}

template <typename Derived>classBase{public:    Base() {        // 错误：基类构造时，派生类还未初始化        static_cast<Derived*>(this)->impl();    }};classDerived : publicBase<Derived> {public:    int data;    void impl() {        data = 10; // 访问未初始化的 data，行为未定义    }};

template <typename Derived>classBase{};classDerived1 : publicBase<Derived1> {};classDerived2 : publicBase<Derived2> {};int main() {    // 错误：Base<Derived1> 和 Base<Derived2> 是不同的类，无法存入同一个数组    // Base<Derived1>* arr[] = {new Derived1(), new Derived2()};    return 0;}

template <typename Derived>class Base {public:    voidcall() {        static_cast<Derived*>(this)->impl();    }};class Derived1 : public Base<Derived1> { // 正确public:    voidimpl() { cout << "Derived1" << endl; }};class Derived2 : public Base<Derived1> { // 错误：模板参数写错public:    voidimpl() { cout << "Derived2" << endl; }};

template <typename Derived>classNonCopyable{protected:    NonCopyable() {}    ~NonCopyable() {}private:    NonCopyable(const NonCopyable&);    NonCopyable& operator=(const NonCopyable&);};// 禁止拷贝的类classMyClass : publicNonCopyable<MyClass> {};