惯用法之CRTP
共 11914字,需浏览 24分钟
·
2022-07-08 13:34
你好,我是雨乐!
在之前的文章<<多态实现-虚函数、函数指针以及变体>>一文中,提到了多态的几种实现方式,今天,借助这篇文章,聊聊多态的另外一种实现方式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来达到多态目的。
好了,今天的文章就到这,我们下期见!