奇特递归模板模式(Curiously Recurring Template Pattern)

奇特递归模板模式(Curiously Recurring Template Pattern) - 知乎 (zhihu.com)
本文来自上面的文章！！！本菜鸡学习和记载一下。
CRTP是C++模板编程时的一种惯用法：把派生类作为基类的模板参数。
1.静态多态

1. #include <iostream>
2. using namespace std;
4. template <typename Child>
5. struct Base
6. {
7.         void interface()
8.         {
9.                 static_cast<Child*>(this)->implementation();
10.         }
11. };
13. struct Derived : Base<Derived>
14. {
15.         void implementation()
16.         {
17.                 cerr << "Derived implementation\n";
18.         }
19. };
21. struct test : Base<test>
22. {
23.         void implementation()
24.         {
25.                 cerr << "test\n";
26.         }
27. };
29. int main()
30. {
31.         Derived d;
32.         d.interface();  // Prints "Derived implementation"
34.     test t;
35.     t.interface();
36.         return 0;
37. }

复制代码

基类为Base，是模板类，子类Drived继续自Base同时模板参数为Drived，基类中有接口
interface而子类中有接口对应实现implementation，基类interface中将this通过static_cast转换为模板参数范例，这里是Drived，并调用该范例的implemention方法。
为什么是static_cast，而不是dynamic_cast?
因为只有继续了Base的范例才气调用interface且这里是向下转型，所以采用static_cast是安全的。
（不太明白）
通过CRTP可以使得类具有雷同于虚函数的效果，同时没有虚函数调用时的开销（虚函数调用时必要通过虚函数指针查找虚函数表进行调用），同时类的对象的体积相比利用虚函数也会减少（不必要存储虚函数指针），但是缺点是无法动态绑定。
2.

1. template<typename Child>
2. class Animal
3. {
4. public:
5.         void Run()
6.         {
7.                 static_cast<Child*>(this)->Run();
8.         }
9. };
11. class Dog :public Animal<Dog>
12. {
13. public:
14.         void Run()
15.         {
16.                 cout << "Dog Run" << endl;
17.         }
18. };
20. class Cat :public Animal<Cat>
21. {
22. public:
23.         void Run()
24.         {
25.                 cout << "Cat Run" << endl;
26.         }
27. };
29. template<typename T>
30. void Action(Animal<T> &animal)
31. {
32.         animal.Run();
33. }
35. int main()
36. {
37.         Dog dog;
38.         Action(dog);
40.         Cat cat;
41.         Action(cat);
42.         return 0;
43. }

复制代码

Dog继续自Animal且模板参数为Dog，Cat继续自Animal且模板参数为Cat
Animal,Dog,Cat中都声明了Run，Animal中的Run是通过范例转换后调用模板范例的Run方法实现的。在Action模板参数中吸收Animal范例的引用（或指针）并在此中调用了animal对象的Run方法，由于这里传入的是差别的子类对象，因此Action中的animal也会有差别的行为。
3.添加方法，减少冗余

1. //Vec3
2. struct Vector3
3. {
4.         float x;
5.         float y;
6.         float z;
8.         Vector3() = default;
10.         Vector3(float _x, float _y, float _z);
12.         inline Vector3& operator+=(const Vector3& rhs);
13.         inline Vector3& operator-=(const Vector3& rhs);
14.         //....
15. };
17. inline Vector3 operator+(const Vector3& lhs, const Vector3& rhs);
18. inline Vector3 operator-(const Vector3& lhs, const Vector3& rhs);
19. //....
21. //Vec2
22. struct Vector2
23. {
24.         float x;
25.         float y;
27.         Vector2() = default;
29.         Vector2(float _x, float _y);
31.         inline Vector2& operator+=(const Vector2& rhs);
32.         inline Vector2& operator-=(const Vector2& rhs);
33.         //....
34. };
36. inline Vector2 operator+(const Vector2& lhs, const Vector2& rhs);
37. inline Vector2 operator-(const Vector2& lhs, const Vector2& rhs);
38. //....

复制代码

 范例Vector3必要实现+=,-=,+,-等运算符重载。
 范例Vector2必要实现+=,-=,+,-等运算符重载。
此中+=，-=这两个运算符可以采取+,-运算符实现，这时间可以把+=,-=给抽象出来，减少代码冗余。

1. template<typename T>
2. struct VectorBase
3. {
4.         T& underlying() { return static_cast<T&>(*this); }
5.         T const& underlying() const { return static_cast<T const&>(*this); }
7.         inline T& operator+=(const T& rhs)
8.         {
9.                 this->underlying() = this->underlying() + rhs;
10.                 return this->underlying();
11.         }
13.         inline T& operator-=(const T& rhs)
14.         {
15.                 this->underlying() = this->underlying() - rhs;
16.                 return this->underlying();
17.         }
18.        
19.         //.....
20. };
22. struct Vector3 : public VectorBase<Vector3>
23. {
24.         float x;
25.         float y;
26.         float z;
28.         Vector3() = default;
30.         Vector3(float _x, float _y, float _z)
31.         {
32.                 x = _x;
33.                 y = _y;
34.                 z = _z;
35.         }
36. };
38. inline Vector3 operator+(const Vector3& lhs, const Vector3& rhs)
39. {
40.         Vector3 result;
41.         result.x = lhs.x + rhs.x;
42.         result.y = lhs.y + rhs.y;
43.         result.z = lhs.z + rhs.z;
44.         return result;
45. }
47. inline Vector3 operator-(const Vector3& lhs, const Vector3& rhs)
48. {
49.         Vector3 result;
50.         result.x = lhs.x - rhs.x;
51.         result.y = lhs.y - rhs.y;
52.         result.z = lhs.z - rhs.z;
53.         return result;
54. }
55. //......
57. int main()
58. {
59.         Vector3 v0(6.0f, 5.0f, 4.0f);
60.         Vector3 v2(4.0f, 5.0f, 6.0f);
62.         v0 += v2;
63.         v0 -= v2;
65.         return 0;
66. }

复制代码

在VectorBase中实现了+=,-=
它们依靠子类的+和-运算符的实现。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。