C++奇异递归模板(CRTP)的使用小结

#include <iostream>
using namespace std;

// 1. crtp 基类：模板类，参数为派生类类型
template <typename derived>
class base {
public:
    // 基类中可以通过模板参数访问派生类
    void dosomething() {
        // 将基类指针 this 转换为派生类指针
        derived* derived = static_cast<derived*>(this);
        // 调用派生类的成员函数（编译期确定）
        derived->impl();
    }
};

// 2. 派生类：继承 base<自身>
class derived : public base<derived> {
public:
    // 派生类实现具体逻辑
    void impl() {
        cout << "derived 具体实现逻辑" << endl;
    }
};

int main() {
    derived d;
    d.dosomething(); // 输出：derived 具体实现逻辑
    return 0;
}

#include <iostream>
using namespace std;

// 1. 虚函数多态（动态绑定）
class shapevirtual {
public:
    virtual void draw() = 0; // 纯虚函数
    virtual ~shapevirtual() {}
};

class circlevirtual : public shapevirtual {
public:
    void draw() override {
        cout << "绘制圆形（虚函数）" << endl;
    }
};

// 2. crtp 多态（静态绑定）
template <typename derived>
class shapecrtp {
public:
    void draw() {
        static_cast<derived*>(this)->drawimpl();
    }
};

class circlecrtp : public shapecrtp<circlecrtp> {
public:
    void drawimpl() {
        cout << "绘制圆形（crtp）" << endl;
    }
};

int main() {
    // 虚函数多态：运行时绑定
    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:
    // 统一接口
    void execute(const vector<int>& data) {
        static_cast<derived*>(this)->doexecute(data);
    }
};

// 排序算法派生类
class sortalgorithm : public algorithm<sortalgorithm> {
public:
    void doexecute(const vector<int>& data) {
        cout << "执行排序算法：";
        for (int num : data) cout << num << " ";
        cout << endl;
        // 实际排序逻辑...
    }
};

// 过滤算法派生类
class filteralgorithm : public algorithm<filteralgorithm> {
public:
    void doexecute(const vector<int>& data) {
        cout << "执行过滤算法：";
        for (int num : data) if (num > 5) cout << num << " ";
        cout << endl;
        // 实际过滤逻辑...
    }
};

// 通用调用函数（编译期多态）
template <typename t>
void runalgorithm(algorithm<t>& algo, const vector<int>& data) {
    algo.execute(data);
}

int main() {
    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--;
    }

    // 静态方法：获取当前对象个数
    static int getcount() {
        return count;
    }
};

// 派生类 a：自动获得计数功能
class a : public countable<a> {};

// 派生类 b：自动获得计数功能
class b : public countable<b> {};

int main() {
    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>
class noninheritable {
private:
    // 私有构造函数和析构函数
    noninheritable() {}
    ~noninheritable() {}

    // 允许 derived 访问私有成员
    friend class derived;
};

// 可实例化，但不能被继承
class finalclass : public noninheritable<finalclass> {
public:
    void print() {
        cout << "finalclass 不能被继承" << endl;
    }
};

// 尝试继承 finalclass：编译失败！
// class subclass : public finalclass {
// };

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--; }
    static int getcount() { return count; }
};

// 2. crtp 基类2：日志记录
template <typename derived>
class loggable {
public:
    void log(const string& msg) {
        cout << "[" << typeid(derived).name() << "] " << msg << endl;
    }
};

// 派生类：同时继承两个 crtp 基类，获得计数和日志功能
class myclass : public countable<myclass>, public loggable<myclass> {
public:
    void dowork() {
        log("开始执行 dowork");
        // 业务逻辑...
        log("dowork 执行完毕");
    }
};

int main() {
    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 = 0
using counter2 = counter1::next;                    // value = 1
using counter3 = counter2::next;                    // value = 2

int main() {
    // 编译期确定的值，直接输出
    cout << counter1::value << endl; // 输出：0
    cout << counter2::value << endl; // 输出：1
    cout << counter3::value << endl; // 输出：2
    return 0;
}

template <typename derived>
class base {
public:
    base() {
        // 错误：基类构造时，派生类还未初始化
        static_cast<derived*>(this)->impl();
    }
};

class derived : public base<derived> {
public:
    int data;
    void impl() {
        data = 10; // 访问未初始化的 data，行为未定义
    }
};

template <typename derived>
class base {};

class derived1 : public base<derived1> {};
class derived2 : public base<derived2> {};

int main() {
    // 错误：base<derived1> 和 base<derived2> 是不同的类，无法存入同一个数组
    // base<derived1>* arr[] = {new derived1(), new derived2()};
    return 0;
}

template <typename derived>
class base {
public:
    void call() {
        static_cast<derived*>(this)->impl();
    }
};

class derived1 : public base<derived1> { // 正确
public:
    void impl() { cout << "derived1" << endl; }
};

class derived2 : public base<derived1> { // 错误：模板参数写错
public:
    void impl() { cout << "derived2" << endl; }
};

template <typename derived>
class noncopyable {
protected:
    noncopyable() {}
    ~noncopyable() {}
private:
    noncopyable(const noncopyable&);
    noncopyable& operator=(const noncopyable&);
};

// 禁止拷贝的类
class myclass : public noncopyable<myclass> {};