惯用法之CRTP-技术圈

你好，我是雨乐！

在之前的文章<<多态实现-虚函数、函数指针以及变体>>一文中，提到了多态的几种实现方式，今天，借助这篇文章，聊聊多态的另外一种实现方式CRTP。

概念

CRTP是Curiously Recurring Template Pattern的缩写，中文译为奇异的递归模板模式，是由James O. Coplien在其1995年的论文中首次提出。

wikipedia给出了CRTP的一般形式，如下：

 // The Curiously Recurring Template Pattern (CRTP)
template <class T>
class Base
{
    // methods within Base can use template to access members of Derived
};
class Derived : public Base<Derived>
{
    // ...
};

看到这种定义方式，你一定感到很奇怪，其实，这种实现方式称为继承自模板。有一定编程经验的人，如果对于智能指针比较熟悉，那么已经无意中接触过这种技术，如下例子：

class Test: public std::enable_shared_from_this<Test> {
  // ...
};

如果与wikipedia给出的CRTP做对比，在这个示例中，Test对应于CRTP形式中的Derive的，而std::enable_shared_from_this()则对应于Base类。

那么，这样做的好处或者目的是什么呢？

其实，这样做的目的其实很明确，从基类对象的角度来看，派生类对象其实就是本身，这样的话只需要使用类型转换就可以把基类转化成派生类，从而实现基类对象对派生对象的访问。

为了便于更加清晰的理解，完整举例如下：

template <typename T>
class Base {
public:
    void interface() {
        static_cast<T*>(this)->imp();
    };
};

class Derived : public Base<Derived> {
public:
    void imp() {
        std::cout<< "in Derived::imp" << std::endl;  
    }
};

int main() {
  Base<Derived> b;
  d.interface();
  
  return 0;
}

在上述例子中，我们发现在Base类的interface接口中，使用static_cast进行类型转换，从而调用派生类的成员函数。可能会有人感到好奇，为什么不用dynamic_cast进行类型转换呢？主要是因为dynamic_cast应用于运行时，而模板是在编译器就进行了实例化。

编译运行，输出结果如下：

in Derived::imp

从上面的输出结果可以看出，即使我们没有声明virtual函数，也实现了多态的功能。

截止到此，我们对CRTP有了一个初步的认识，总结起来，其有以下两个特点：

• 继承自模板类
• 派生类将自身作为参数传给模板类

颠倒继承

仍然使用上一节中的例子，如下：

template <typename T>
class Base {
public:
    void interface() {
        static_cast<T*>(this)->imp();
    };
};

class Derived : public Base<Derived> {
public:
    void imp() {
        std::cout << "in Derived::imp" << std::endl;  
    }
};

int main() {
  Derived d;
  d.interface();
  
  return 0;
}

在这个例子中，派生类Derived中定义了一个成员函数imp()，而该函数在基类Base中是没有声明的，所以，我们可以理解为对于CRTP，在基类中调用派生类的成员函数，扩展了基类的功能。而对于普通继承，则是派生类中调用基类的成员函数，扩展了派生类的功能，这就是我们所说的颠倒继承。

使用场景

俗话说，存在即合理。既然有CRTP，那么其必然有自己存在的道理。那么CRTP都用在什么场景呢？

静态多态

其实，在前面的例子中，已经大致了解了使用crtp技术来实现多态功能，该种实现方式为静态多态，是在编译期实现的。

下面通过一个具体的例子来理解静态多态。

#include <iostream>

#include <iostream>

template <typename T>
class Base{
 public:
  void interface(){
    static_cast<T*>(this)->imp();
  }
  void imp(){
    std::cout << "in Base::imp" << std::endl;
  }
};

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

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

class Derived3 : public Base<Derived3>{};

template <typename T>
void fun(T& base){
    base.interface();
}


int main(){
  Derived1 d1;
  Derived2 d2;
  Derived3 d3;

  fun(d1);
  fun(d2);
  fun(d3);

  return 0;
}

在上述代码中，定义了一个函数fun()，在其函数体内调用interface()函数。如果类型为Derived1和Derived2，则会调用这俩类型对应的imp()函数。而对于Derived3，因为其类内没有实现imp()函数，所以调用的是Base类即基类的imp函数。

编译运行之后，输出如下：

in Derived1::imp
in Derived2::imp
in Base::imp

从上述输出可以看出，即使不使用virtual，也实现了多态功能，其二者的区别是：virtual是运行时多态，而CRTP则是在编译期就对模板进行了实例化，所以属于静态多态。

代码复用

假如，现在需要实现一个功能，根据对象的具体类型，输出其类型名称。

class Base {
 public:
  void PrintType() {
    std::cout << typeid(*this).name() << std::endl;
  }
};

class Derived : public Base {};
class Derived1 : public Base {};

void PrintType(const Base& base) {
  base.PrintType();
}

对于此种需求，首先想到的是使用virtual的多态功能实现，代码也很好写，如下：

#include <iostream>
#include <typeinfo>

class Base {
 public:
  virtual void PrintType() const {
    std::cout << typeid(*this).name() << std::endl;
  }
};

class Derived : public Base {
 public:
  virtual void PrintType() const {
    std::cout << typeid(*this).name() << std::endl;
  }
};
class Derived1 : public Base {
 public:
  virtual void PrintType() const {
    std::cout << typeid(*this).name() << std::endl;
  }
};

void PrintType(const Base& base) {
  base.PrintType();
}

int main() {
  Derived d;
  Derived1 d1;

  PrintType(d);
  PrintType(d1);

  return 0;
}

输出如下：

7Derived
8Derived1

ps: 需要注意的是，在上面的输出类型中，前面都有一个数字，这个数字是类名的长度。

而如果使用CRTP，则实现如下：

#include <iostream>
#include <typeinfo>

template<typename T>
class Base {
 public:
  void PrintType() {
    T &t = static_cast<T&>(*this);
    std::cout << typeid(t).name() << std::endl;
  }
};

class Derived : public Base<Derived> {};
class Derived1 : public Base<Derived1> {};

template<typename T>
void PrintType(T base) {
  base.PrintType();
}

int main() {
  Derived d;
  Derived1 d1;

  PrintType(d);
  PrintType(d1);

  return 0;
}

函数输出如下：

7Derived
8Derived1

通过上述输出可以看出，即使在Derived和Derived1类中没有定义PrintType()函数，也实现了与virtual函数一样的效果，所以使用CRTP的另外一个好处是避免冗余代码。

性能对比

既然crtp也能实现多态，那么就有必要跟传统的运行时多态实现方式virtual来做下对比。

virtual.cc:

#include <iostream>
#include <typeinfo>
#include <sys/time.h>

class Base {
 public:
  virtual void PrintType() const {
  }
};

class Derived : public Base {
 public:
  virtual void PrintType() const {
  }
};
class Derived1 : public Base {
 public:
  virtual void PrintType() const {
  }
};

void PrintType(const Base& base) {
  base.PrintType();
}

int main() {
  Derived d;
  Derived1 d1;

  struct timeval start;
  struct timeval end;
  gettimeofday(&start_, NULL);
  for (int i = 0; i < 1000000; ++i) {
    PrintType(d);
    PrintType(d1);
  }
  gettimeofday(&end, nullptr);
  double cost = 1000000 * (end.tv_sec - start.tv_sec) +
                  end.tv_usec - start.tv_usec;

  std::cout << "virtual time cost " << cost << std::endl;
  return 0;
}

crtp.cc:

#include <iostream>
#include <typeinfo>
#include <sys/time.h>

template<typename T>
class Base {
 public:
  void PrintType() const {
    T &t = static_cast<T&>(*this);
    t.PrintType();
  }
};

class Derived : public Base<Derived> {
 public:
  void PrintType() const {}
};
class Derived1 : public Base<Derived1> {
 public:
  void PrintType() const {}
};

template<typename T>
void PrintType(T base) {
  base.PrintType();
}

int main() {
  Derived d;
  Derived1 d1;

  struct timeval start;
  struct timeval end;
  gettimeofday(&start, nullptr);
  for (int i = 0; i < 1000000; ++i) {
    PrintType(d);
    PrintType(d1);
  }
  gettimeofday(&end, NULL);
  double cost = 1000000 * (end.tv_sec - start.tv_sec) +
                  end.tv_usec - start.tv_usec;

  std::cout << "crtp time cost " << cost << std::endl;
  return 0;
}

对上述两段代码分别编译运行之后，输出如下：

virtual time cost 22757
crtp time cost 7871

从上述输出可以看出，crtp的耗时是virtual实现方式的1/3。

局限性

既然CRTP能实现多态性，且其性能优于virtual，那么virtual还有没有存在的必要么？

虽然CRTP最终还是调用派生类中的成员函数。但是，问题在于Base类实际上是一个模板类，而不是一个实际的类。因此，如果存在名为Derived和Derived1的派生类，则基类模板初始化将具有不同的类型。这是因为，Base类将进行不同类型的特化，代码如下：

class Derived : public Base<Derived> {
 void imp(){
    std::cout << "in Derived::imp" << std::endl;
  }
};

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

如果创建Base类模板的指针，则意味着存在两种类型的Base指针，即:

// CRTP
Base<Derived> *b = new Derived;
Base<Derived> *b1 = new Derived1;

显然，这与我们虚函数的方式不同。因为，动态多态性只给出了一种Base指针。但是现在，每个派生类都可以使用不同的指针类型。

// virtual
Base *v1 = new Derived;
Base *v2 = new Derived1;

正是因为基于CRTP方式的指针具有不同的类型，所以不能将CRTP基类指针存储在容器中，下面的代码将编译失败：

int main() {
  Base<Derived> *d = new Derived;
  Base<Derived> *d1 = new Derived1;

  auto vec = {d, d1};

  return 0;
}

编译器输出如下：

test.cc: In function ‘int main()’:
test.cc:33: error: cannot convert ‘Derived1*’ to ‘Base<Derived>*’ in initialization
test.cc:35: error: ISO C++ forbids declaration of ‘vec’ with no type
test.cc:35: error: scalar object ‘vec’ requires one element in initializer

正是因为其局限性，所以CRTP是一种特殊类型的多态性，在少数情况下可以替代动态多态性的需要。

结语

通过CRTP技术，在某种程度上也可以实现多态功能，但其也仅限定于使用场景，正如局限性一节中所提到的，CRTP是一种特殊类型的多态性，在少数情况下可以替代动态多态性的需要；另外，使用CRTP技术，代码可读性降低、模板实例化之后的代码膨胀以及无法动态绑定(在编译期决实例化)，因此，我们可以根据使用场景，来灵活选择CRTP或者virtual来达到多态目的。

好了，今天的文章就到这，我们下期见！