• 模板（详解）

    一、泛型编程

    编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

    实现一个交换函数

    1. void Swap(int& left, int& right)
    2. {
    3.     int temp = left;
    4.     left = right;
    5.     right = temp;
    6. }
    7.  
    8. void Swap(double& left, double& right)
    9. {
    10.     double temp = left;
    11.     left = right;
    12.     right = temp;
    13. }
    14.  
    15. void Swap(char& left, char& right)
    16. {
    17.     char temp = left;
    18.     left = right;
    19.     right = temp;
    20. }

    上面这是函数重载，我们用函数重载时有很多不便的地方

    1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
    2. 代码的可维护性比较低，一个出错可能所有的重载均出错

    二、函数模板

    2.1、函数模板的概念

    函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

    2.2、函数模板格式

    1. template<typename T1, typename T2,......,typename Tn>
    2. 返回值类型 函数名(参数列表){}
    1. template<typename T>
    2. void Swap( T& left, T& right)
    3. {
    4.     T temp = left;
    5.     left = right;
    6.     right = temp;
    7. }

    注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

    在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此
     

    2.3、函数模板实例化

    用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

    1、隐式实例化：让编译器根据实参推演模板参数的实际类型

    1. template<class T>
    2. T Add(const T& left, const T& right)
    3. {
    4.     return left + right;
    5. }
    6. int main()
    7. {
    8.     int a1 = 10, a2 = 20;
    9.     double d1 = 10.0, d2 = 20.0;
    10.     Add(a1, a2);
    11.     Add(d1, d2);
    12. /*
    13. 该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
    14. 通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
    15. 编译器无法确定此处到底该将T确定为int 或者 double类型而报错
    16. 注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
    17.     Add(a1, d1);
    18. */
    19. // 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
    20.     Add(a, (int)d);
    21.     return 0;
    22. }

    2、显式实例化：在函数名后的<>中指定模板参数的实际类型

    1. int main(void)
    2. {
    3.     int a = 10;
    4.     double b = 20.0;
    5. // 显式实例化
    6.     Add<int>(a, b);
    7.     return 0;
    8. }

    如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

    2.4、模板参数的匹配原则

    1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

    1. // 专门处理int的加法函数
    2. int Add(int left, int right)
    3. {
    4.     return left + right;
    5. }
    6. // 通用加法函数
    7. template<class T>
    8. T Add(T left, T right)
    9. {
    10.     return left + right;
    11. }
    12. void Test()
    13. {
    14.     Add(1, 2); // 与非模板函数匹配，编译器不需要特化
    15.     Add<int>(1, 2); // 调用编译器特化的Add版本
    16. }

    2、对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

    1. // 专门处理int的加法函数
    2. int Add(int left, int right)
    3. {
    4.     return left + right;
    5. }
    6. // 通用加法函数
    7. template<class T>
    8. T Add(T left, T right)
    9. {
    10.     return left + right;
    11. }
    12. void Test()
    13. {
    14.     Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
    15.     Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数 
    16. }

    3、模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

    三、类模板

    3.1、类模板的定义格式

    1. template<class T1, class T2, ..., class Tn>
    2. class 类模板名
    3. {
    4.     // 类内成员定义
    5. };
    1. // 动态顺序表
    2. // 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
    3. template<class T>
    4. class Vector
    5. {
    6. public :
    7.     Vector(size_t capacity = 10)
    8.     : _pData(new T[capacity])
    9.     , _size(0)
    10.     , _capacity(capacity)
    11.     {}
    12. // 使用析构函数演示：在类中声明，在类外定义。
    13.     ~Vector();
    14.     void PushBack(const T& data)；
    15.     void PopBack()；
    16.     // ...
    17.     size_t Size() {return _size;}
    18.     T& operator[](size_t pos)
    19.     {
    20.         assert(pos < _size);
    21.         return _pData[pos];
    22.     }
    23. private:
    24.     T* _pData;
    25.     size_t _size;
    26.     size_t _capacity;
    27. };
    28. // 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
    29. template <class T>
    30. Vector::~Vector()
    31. {
    32.     if(_pData)
    33.     delete[] _pData;
    34.     _size = _capacity = 0;
    35. }

    3.2、类模板的实例化

    类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

    1. // Vector类名，Vector才是类型
    2. Vector<int> s1;
    3. Vector<double> s2;

    四、非类型模板参数

    模板参数分为两种：类型形参，非类型形参。
    类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
    非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

    1. namespace LYL
    2. {
    3.     // 定义一个模板类型的静态数组
    4.     template<class T, size_t N = 10>
    5.     class array
    6.     {
    7.     public:
    8.         T& operator[](size_t index){return _array[index];}
    9.         const T& operator[](size_t index)const{return _array[index];}
    10.         size_t size()const{return _size;}
    11.         bool empty()const{return 0 == _size;}
    12.     private:
    13.         T _array[N];
    14.         size_t _size;
    15.     }；
    16. }

    非类型模板参数在定义类中数组时有很好的作用，这里给初始值给10。

    注意：
    1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
    2. 非类型的模板参数必须在编译期就能确认结果。
     

    五、模板特化

    5.1、模板特化的概念

    通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 1900, int month = 1, int day = 1)
    5. 		: _year(year)
    6. 		, _month(month)
    7. 		, _day(day)
    8. 	{}
    9.  
    10. 	bool operator<(const Date& d)const
    11. 	{
    12. 		return (_year < d._year) ||
    13. 			(_year == d._year && _month < d._month) ||
    14. 			(_year == d._year && _month == d._month && _day < d._day);
    15. 	}
    16.  
    17. 	bool operator>(const Date& d)const
    18. 	{
    19. 		return (_year > d._year) ||
    20. 			(_year == d._year && _month > d._month) ||
    21. 			(_year == d._year && _month == d._month && _day > d._day);
    22. 	}
    23.  
    24. 	friend ostream& operator<<(ostream& _cout, const Date& d)
    25. 	{
    26. 		_cout << d._year << "-" << d._month << "-" << d._day;
    27. 		return _cout;
    28. 	}
    29.  
    30. private:
    31. 	int _year;
    32. 	int _month;
    33. 	int _day;
    34. };
    35. // 函数模板 -- 参数匹配
    36. template<class T>
    37. bool Less(T left, T right)
    38. {
    39.     return left < right;
    40. }
    41. int main()
    42. {
    43.     cout << Less(1, 2) << endl; // 可以比较，结果正确
    44.     Date d1(2022, 7, 7);
    45.     Date d2(2022, 7, 8);
    46.     cout << Less(d1, d2) << endl; // 可以比较，结果正确
    47.     Date* p1 = &d1;
    48.     Date* p2 = &d2;
    49.     cout << Less(p1, p2) << endl; // 可以比较，结果错误
    50.     return 0;
    51. }

    可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。
    此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化

    5.2函数模板特化

    函数模板特化的步骤：

    1. 必须要先有一个基础的函数模板
    2. 关键字template后面接一对空的尖括号<>
    3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
    4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
     

    1. // 函数模板 -- 参数匹配
    2. template<class T>
    3. bool Less(T left, T right)
    4. {
    5.     return left < right;
    6. }
    7. // 对Less函数模板进行特化
    8. template<>
    9. bool Less(Date* left, Date* right)
    10. {
    11.     return *left < *right;
    12. }
    13. int main()
    14. {
    15.     cout << Less(1, 2) << endl;
    16.     Date d1(2022, 7, 7);
    17.     Date d2(2022, 7, 8);
    18.     cout << Less(d1, d2) << endl;
    19.     Date* p1 = &d1;
    20.     Date* p2 = &d2;
    21.     cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了
    22.     return 0;
    23. }

     注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出

    1. bool Less(Date* left, Date* right)
    2. {
    3.     return *left < *right;
    4. }

    该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时特别给出，因此函数模板不建议特化

    5.3、类模板特化

    5.3.1、模板的全特化

    全特化即是将模板参数列表中所有的参数都特化

    1. template<class T1, class T2>
    2. class Data
    3. {
    4. public:
    5.     Data() {cout<<"Data" <
    6. private:
    7.     T1 _d1;
    8.     T2 _d2;
    9. };
    10.  
    11. template<>
    12. class Data<int, char>
    13. {
    14. public:
    15.     Data() {cout<<"Data" <
    16. private:
    17.     int _d1;
    18.     char _d2;
    19. };
    20.  
    21. void TestVector()
    22. {
    23.     Data<int, int> d1;
    24.     Data<int, char> d2;
    25. }

    5.3.2、模板的偏特化

    偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下模板类：

    1. template<class T1, class T2>
    2. class Data
    3. {
    4. public:
    5.     Data() {cout<<"Data" <
    6. private:
    7.     T1 _d1;
    8.     T2 _d2;
    9. };

    偏特化有以下两种表现方式：部分特化，参数更进一步的限制

    1、部分特化：将模板参数类表中的一部分参数特化

    1. // 将第二个参数特化为int
    2. template <class T1>
    3. class Dataint>
    4. {
    5. public:
    6.     Data() {cout<<"Data" <
    7. private:
    8.     T1 _d1;
    9.     int _d2;
    10. };

    2、参数更进一步的限制：偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

    1. //两个参数偏特化为指针类型
    2. template <typename T1, typename T2>
    3. class Data 
    4. {
    5. public:
    6.     Data() {cout<<"Data" <
    7. private:
    8.     T1 _d1;
    9.     T2 _d2;
    10. };
    11.  
    12. //两个参数偏特化为引用类型
    13. template <typename T1, typename T2>
    14. class Data 
    15. {
    16. public:
    17.     Data(const T1& d1, const T2& d2)
    18.     : _d1(d1)
    19.     , _d2(d2)
    20. {
    21.     cout<<"Data" <
    22. }
    23. private:
    24.     const T1 & _d1;
    25.     const T2 & _d2;
    26. };
    27.  
    28. void test2 ()
    29. {
    30.     Data<double , int> d1; // 调用特化的int版本
    31.     Data<int , double> d2; // 调用基础的模板
    32.     Data<int *, int*> d3; // 调用特化的指针版本
    33.     Data<int&, int&> d4(1, 2); // 调用特化的指针版本
    34. }

    5.3.3、类模板特化应用示例

    1. #include
    2. #include 
    3. template<class T>
    4. struct Less
    5. {
    6.     bool operator()(const T& x, const T& y) const
    7.     {
    8.         return x < y;
    9.     }
    10. };
    11. int main()
    12. {
    13.     Date d1(2022, 7, 7);
    14.     Date d2(2022, 7, 6);
    15.     Date d3(2022, 7, 8);
    16.     vector v1;
    17.     v1.push_back(d1);
    18.     v1.push_back(d3);
    19. // 可以直接排序，结果是日期升序
    20.     sort(v1.begin(), v1.end(), Less());
    21.     vector v2;
    22.     v2.push_back(&d1);
    23.     v2.push_back(&d2);
    24.     v2.push_back(&d3);
    25. // 可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序
    26. // 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象
    27. // 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期
    28.     sort(v2.begin(), v2.end(), Less());
    29.     return 0;
    30. }

    通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排序元素是指针，结果就不一定正确。因为：sort最终按照Less模板中方式比较，所以只会比较指针，而不是比较指针指向空间中内容，此时可以使用类版本特化来处理上述问题：

    1. // 对Less类模板按照指针方式特化
    2. template<>
    3. struct Less
    4. {
    5.     bool operator()(Date* x, Date* y) const
    6.     {
    7.         return *x < *y;
    8.     }
    9. };

    特化之后，在运行上述代码，就可以得到正确的结果

    六、模板总结

    注意：

    1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。
    2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用

    模板优点
    1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
    2. 增强了代码的灵活性
    模板缺陷
    1. 模板会导致代码膨胀问题，也会导致编译时间变长
    2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误

  • 相关阅读:
    国外的SRE都是干啥工作的？薪资如何？
    Kafka生产者（二）
    如何基于YAML设计接口自动化测试框架？看完秒会！
    汽车蓄电池低压报警设计
    基于 Kubernetes 部署 Zookeeper（StatefulSet方式）
    软考 系统架构设计师系列知识点之软件架构风格（2）
    gradle8.0或者其他版本下载太慢或者time out超时（完美解决方法）
    MySQL 快速入门之 MID() 函数详解
    【Leetcode】70. 爬楼梯
    [附源码]java毕业设计-线上摄影平台系统
  • 原文地址：https://blog.csdn.net/m0_69323023/article/details/134505455