CRTP

这篇文章介绍了什么是CRTP（奇异的递归模板模式）
原文
stackflow上讨论了CRTP
问题

我的理解

• 简而言之，就是基类是个模板类，模板参数是基类类型。

template <class T>
class X{...};
class A : public X<A> {...};

- 它的存在是为了实现多态或者是一种类似多态功能。我觉得这不是CRTP的本意。例子如下：
>```c++
template<typename T>
class Base
{
public:
    void method()
    {
        static_cast<T*>(this)->methodImpl();
    }
private:
    void methodImpl()
    {
        cout << "base method" << endl;
    }
};
class Extend1 :public Base<Extend1>
{
public:
    void methodImpl()
    {
        cout << "Extend1 method" << endl;
    }
};
class Extend2 :public Base<Extend2>
{
public:
    void methodImpl()
    {
        cout << "Extend2 method" << endl;
    }
};
void main()
{
    Extend1 e1;
    Extend2 e2;
    e1.method();
    e2.method();
}

网上好多说法是这体现了CRTP的静态绑定，性能优于虚函数实现的动态绑定。其实这根本不能体现多态。多态是由基类对象通过虚函数表，实现的对不同子类函数的调用。

• CRPT其实是让子类获取基类能力的方法，并且子类中不需要添加任何代码。也就是说，基类是一个功能模板，只要被继承，子类就获得其功能。例子：

//单例模式基类
class Singleton
{
public:
static ActualClass& GetInstance()
{
if(p == nullptr)
p = new ActualClass;
return p;
}
protected:
static Actualclass p;
private:
Singleton(){}
Singleton(Singleton const &);
Singleton& operator = (Singleton const &);
};
template <class T>
T* Singleton<T>::p = nullptr;
//子类也是一个单例模式类
class A: public Singleton<A>
{
//Rest of functionality
};

```c++
template<class Derived>
//基类类实现== != >等操作 派生类只需要实现<操作
class Equality
{
};
template <class Derived>
bool operator == (Equality<Derived> const& op1, Equality<Derived> const & op2)
{
    Derived const& d1 = static_cast<Derived const&>(op1);//you assume this works     
    //because you know that the dynamic type will actually be your template parameter.
    //wonderful, isnit it?
    Derived const& d2 = static_cast<Derived const&>(op2); 
    return !(d1 < d2) && !(d2 < d1);//assuming derived has operator <
}
//只要派生类继承Equality 就能实现其他三个操作 大大减少了代码量
struct Apple:public Equality<Apple> 
{
    int size;
};
bool operator < (Apple const & a1, Apple const& a2)
{
    return a1.size < a2.size;
}
int main()
{
    Apple a1;
    Apple a2; 
    a1.size = 10;
    a2.size = 10;
    if(a1 == a2) //the compiler won't complain! 
    {
    }
}

• 通过这些例子，可以看出CRPT是一种非常有效的减少代码量的手段，能够快速让子类获取自身能力，而不新增任何代码。至于它的静态多态，我认为是不合理的。