C++ CRTP模式：编译期多态的优雅实现 #

引言 #

CRTP（Curiously Recurring Template Pattern，奇异递归模板模式）是C++中一种强大的编译期多态实现方式。

基本原理 #

CRTP通过模板和继承的组合实现静态多态：

基类模板以派生类为模板参数
在基类中通过static_cast调用派生类方法
实现编译期的多态行为

示例代码 #

// 基类模板
template <typename Derived>
class CBase {
public:
    void commonMethod() {
        static_cast<Derived*>(this)->implementation();
    }
    void anotherCommonMethod() {
        std::cout << "Another common method in Base." << std::endl;
    }
};

// 派生类1
class Derived1 : public CBase<Derived1> {
public:
    void implementation() {
        std::cout << "Implementation in Derived1." << std::endl;
    }
};

// 派生类2
class Derived2 : public CBase<Derived2> {
public:
    void implementation() {
        std::cout << "Implementation in Derived2." << std::endl;
    }
};

void test_CRTP() {
    Derived1 d1;
    d1.commonMethod();
    d1.anotherCommonMethod();

    Derived2 d2;
    d2.commonMethod();
    d2.anotherCommonMethod();
}

由如上代码可知，CBase模板类作为一个接口，定义了一个commonMethod方法，它通过CRTP的方式调用派生类中的方法implementation。派生类Derived1和Derived2都继承自CBase，并实现了implementation方法。通过CRTP，我们可以在基类中调用派生类的方法，而不需要使用虚函数的运行时开销。

静态多态 #

在CRTP中，通过将派生类作为模板参数传递给基类，实现了基类对派生类的访问。由于CRTP使用的是静态多态，因此在编译时就能够确定函数调用的具体实现，避免了动态多态带来的运行时开销。

下面是一个简单的示例代码：

#include <iostream>

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

class Derived1 : public Base<Derived1> {
public:
    void foo() {
        std::cout << "Derived1::foo()" << std::endl;
    }
};

class Derived2 : public Base<Derived2> {
public:
    void foo() {
        std::cout << "Derived2::foo()" << std::endl;
    }
};

int main() {
    Derived1 d1;
    Derived2 d2;
    d1.foo_function();   // Derived1::foo()
    d2.foo_function();   // Derived2::foo()
    return 0;
}

在这个示例中，定义了一个模板类Base，模板类中包含函数foo_function()，并使用模板参数Derived作为类型参数。在foo_function()函数中，使用static_cast将this指针转换为Derived*类型，然后调用Derived类中的foo()函数。

然后，我们定义了两个派生类Derived1和Derived2，它们分别继承自Base和Base。在这两个派生类中，分别实现了foo()函数，输出不同的信息。最后，在main()函数中，创建了Derived1和Derived2的实例，并调用它们的foo()函数。

由于使用了CRTP技术，因此在编译时就能够确定foo_function()函数的具体实现，从而避免了动态多态带来的运行时开销。

扩展 #

CRTP在C++标准库中有广泛应用，模板类std::enable_shared_from_this便是其中之一，应用代码如下：

class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    void foo() {
        // 在成员函数中调用 shared_from_this() 获取指向自身的 std::shared_ptr
        std::shared_ptr<MyClass> ptr = shared_from_this();
        std::cout << "SharedPtr count: " << ptr.use_count() << std::endl;
    }
};

int using_enable() {
    std::shared_ptr<MyClass> objPtr = std::make_shared<MyClass>();
    // 在 MyClass 的成员函数中调用 shared_from_this() 方法
    objPtr->foo();
    return 0;
}

自定义类继承自模板类std::enable_shared_from_this，便可以在自定义类中使用模板类中的shared_from_this() 方法。注意需要自定义本身调用了shared_ptr的构造函数后，方可调用shared_from_this() 方法。

这是因为shared_from_this()使用模板类内持有的弱引用指针进行转换得到自身的共享指针shared_ptr。只有调用shared_ptr的构造函数且自定义类继承自std::enable_shared_from_this时才会给弱指针赋值。如果弱引用指针未被赋值，空指针强转会触发异常。

回归CRTP，自定义类需要将自身作为模板参数传递给 std::enable_shared_from_this，在派生类中才可以使用 std::enable_shared_from_this 提供的 shared_from_this() 方法。

如果将非自定义类作为模板参数传递给 std::enable_shared_from_this会出现编译错误，示例如下：

class A {
public:
    A() = default;
    ~A() = default;
};

class MyClass : public std::enable_shared_from_this<A> {
public:
    void foo() {
        // error， error C2440: “初始化”: 无法从“std::shared_ptr<A>”转换为“std::shared_ptr<MyClass>”
        // std::shared_ptr<MyClass> ptr = shared_from_this();
        // std::cout << "SharedPtr count: " << ptr.use_count() << std::endl;
    }
};

应用场景 #

CRTP通常用于需要在编译期解决多态性问题的情况下，以提高代码性能和灵活性。一些常见的应用场景包括：

实现静态多态性：通过CRTP可以在编译期实现多态性，而不需要虚函数的运行时开销，提高性能。
实现策略模式：CRTP可以用于实现策略模式，将不同的策略封装在不同的派生类中，并在编译期确定使用哪种策略。
实现优化的数据结构：CRTP可以用于实现优化的数据结构，例如静态多叉树、静态链表等，以提高性能和内存利用率。