奇怪的重复模板模式（CRTP）

奇怪的重复模板模式（Curiously Recurring Template Pattern, CRTP）是一种模板元编程技术，它通过在类模板中派生一个模板参数为它自己的类来实现一些特殊的功能。

原理

CRTP 的实现原理比较简单：声明一个模板类，将其作为基类，让后继承于此基类的派生类作为模板参数，这样就可以在派生类中访问到基类中的成员和方法，从而实现特殊的功能。

template<typename Derived>
class Base {
public:
    // 公共接口，成员函数中可以访问 Derived 类中的成员和方法
    void foo() {
        static_cast<Derived*>(this)->bar();
    }

private:
    // 无法访问 Derived 类中的成员和方法
    void baz() {}
};

class Derived : public Base<Derived> {
public:
    void bar() {
        // 实现 Base::foo() 中需要的方法
    }
};

// 使用 Derived 类
int main() {
    Derived d;
    d.foo();
}

上述示例中，Base 是一个模板类，它的模板参数是一个派生类 Derived。在 Base 中，声明了一个 foo 方法，它调用了 Derived 类中的 bar 方法实现了特殊的功能。foo 方法的实现中，使用 static_cast<Derived*>(this) 将 this 指针强制转换为指向 Derived 类的指针，从而实现了访问 Derived 类中成员和方法的需要。

应用场景

CRTP 的应用场景相对比较单一，通常用于实现静态多态性和静态多继承。

静态多态性

静态多态性是指在编译时就能确定调用哪个函数的多态性。利用 CRTP，我们可以在基类中定义一个泛型接口，实现静态多态性。

template<typename Derived>
class Interface {
public:
    void foo() {
        static_cast<Derived*>(this)->foo_impl();
    }
};

class Concrete : public Interface<Concrete> {
public:
    void foo_impl() {}
};

int main() {
    Concrete c;
    c.foo();
}

上述例子中，Interface 是一个模板类，它的模板参数是一个派生类 Derived。它定义了一个 foo 方法，实现了静态多态性。Concrete 类继承自 Interface<Concrete>，并且实现了 foo_impl 方法，从而实现了 foo 方法的调用。

静态多继承

利用 CRTP，我们还可以实现静态多继承。静态多继承是指在编译时就能确定继承哪些基类的多继承。

template<typename Base1, typename Base2>
class MultipleInheritance : public Base1, public Base2 {
public:
    // 重新定义基类中的方法
    void foo() override {
        // 调用继承自 Base1 的 foo() 方法
        Base1::foo();
        // 调用继承自 Base2 的 foo() 方法
        Base2::foo();
    }
};

class A {
public:
    void foo() {}
};

class B {
public:
    void foo() {}
};

class C : public MultipleInheritance<A, B> {
public:
    // 重新定义基类中的方法
    void foo() override {
        // 调用继承自 MultipleInheritance<A, B> 的 foo() 方法
        MultipleInheritance<A, B>::foo();
    }
};

int main() {
    C c;
    c.foo();
}

上述例子中，MultipleInheritance 是一个模板类，它的模板参数是两个基类 Base1 和 Base2。它继承自这两个基类，并且重定义了这两个基类的 foo 方法，实现了静态多继承。A 和 B 类都定义了自己的 foo 方法。C 类继承自 MultipleInheritance<A, B>，并且重新定义了 foo 方法，实现了调用基类方法的需要。

总结

CRTP 是一种模板元编程技术，它通过在类模板中派生一个模板参数为它自己的类来实现一些特殊的功能，例如静态多态性和静态多继承。虽然 CRTP 的应用场景比较有限，但是它依然在一些框架和库中得到广泛应用。