• C++(模板进阶）

    目录

    前言：

    本章学习目标：

    1.非类型模版参数 

    1.1使用方法 

    1.2注意事项

    1.3 实际引用

    2.模版特化 

     2.1概念

    2.2函数模板特化

     2.3类模板特化

    2.3.1全特化

    2.3.2偏特化 

     3.模版分离编译

    ​编辑 3.1失败原因

    ​编辑 3.2解决方案

    4 总结 

    前言：

    本章节是在学习完STL之后，对高阶模版进行的总结，模板给泛型编程注入了灵魂，模板提高了程序的灵活性，模板包括：非类型模版参数、全特化、偏特化等，同时本文还会对模板声明和定义不能分离的问题做出介绍。

    本章学习目标：

    1. 非类型模板参数
    2. 类模板的特化
    3. 模板的分离编译

    1.非类型模版参数 

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

    1.1使用方法 

    非类型模版参数 既然是使用常量作为参数，那么浮点数、类对象以及字符串是不允许作为非类型模版参数的，   非类型模版参数必须在编译期就能确认结果。

    利用非类型模版参数创建一个可以自由调整大小的整形数组代码如下：

    1. #include 
    2. using namespace std;
    3.  
    4.  
    5. template <size_t N>
    6. class arr
    7. {
    8. public:
    9. 	int& operator[](size_t pos)
    10. 	{
    11. 		assert(pos >= 0 && pos < N);
    12. 		return _arr[pos];
    13. 	}
    14.  
    15. 	size_t size() const
    16. 	{
    17. 		return N;
    18. 	}
    19.  
    20. private:
    21. 	int _arr[N];
    22. };
    23. int main()
    24. {
    25. 	arr<5> a1;
    26. 	arr<10> a2;
    27. 	arr<15> a3;
    28.  
    29. 	cout <size() << endl;
    30. 	cout << a2.size() << endl;
    31. 	cout << a3.size() << endl;
    32. 	return 0;
    33. }

    定义一个模板类型的静态数组

    1. template <class T ,size_t N>
    2. class arr
    3. {
    4. public:
    5. 	T& operator[](size_t pos)
    6. 	{
    7. 		assert(pos >= 0 && pos < N);
    8. 		return _arr[pos];
    9. 	}
    10.  
    11. 	size_t size() const
    12. 	{
    13. 		return N;
    14. 	}
    15.  
    16. private:
    17. 	int _arr[N];
    18. };
    19. int main()
    20. {
    21. 	arr<int,5> a1;
    22. 	arr<double,10> a2;
    23. 	arr<char,15> a3;
    24.  
    25. 	cout <size()<< typeid(a1).name() << endl;
    26. 	cout << a2.size() << typeid(a2).name()<< endl;
    27. 	cout << a3.size() << typeid(a3).name()<< endl;
    28. 	return 0;
    29. }

    1.2注意事项

     非类型模板参数要求类型为 整型家族，其他类型是不被编译器通过的，如果我们使用非整形的家族成员就会报错，代码如下：

    1. //浮点型，非标准
    2. template<class T, double N>
    3. class arr 
    4. {
    5.  /*……*/ 
    6. };

     整形家族：char     short      int      bool         long           longlong

    1.3 实际引用

     在 C++11 标准中，引入了一个新容器 array，它就使用了 非类型模板参数，为一个真正意义上的 泛型数组，这个数组是用来对标传统数组的。

    注意： 部分老编译器可能不支持使用此容器

    新引入arry非类型模版参数的代码 如下：

    1. #include 
    2. #include 
    3. #include   //引入头文件
    4.  
    5. using namespace std;
    6.  
    7. int main()
    8. {
    9. 	int arrOld[10] = { 0 };	//传统数组
    10. 	array<int, 10> arrNew;	//新标准中的数组
    11.  
    12. 	//与传统数组一样，新数组并没有进行初始化
    13. 	
    14. 	//新数组对于越界读、写检查更为严格 优点
    15.  
    16. 	arrOld[15];	//老数组越界读，未报错
    17. 	arrNew[15];	//新数组则会报错
    18.  
    19. 	arrOld[12] = 0;	//老数组越界写，不报错，出现严重的内存问题
    20. 	arrNew[12] = 10;	//新数组严格检查
    21. 	return 0;
    22. }

    array 是泛型编程思想中的产物，支持了许多 STL 容器的功能，比如 迭代器 和 运算符重载 等实用功能，最主要的改进是 严格检查越界行为。

    需要提醒的是：arry能做到严格的越界检查 得益于 []的重载，对下标进行了严格检查。

    2.模版特化 

     2.1概念

    通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：使用 日期类对象指针 构建优先级队列后，若不编写对应的仿函数，则比较结果会变为未定义 代码如下：

    1. // 函数模板 -- 参数匹配
    2. template<class T>
    3. bool Less(T left, T right)
    4. {
    5. 	return left < right;
    6. }
    7. int main()
    8. {
    9. 	cout << Less(1, 2) << endl; // 可以比较，结果正确
    10. 	Date d1(2022, 7, 7);
    11. 	Date d2(2022, 7, 8);
    12. 	cout << Less(d1, d2) << endl; // 可以比较，结果正确
    13. 	Date* p1 = &d1;
    14. 	Date* p2 = &d2;
    15. 	cout << Less(p1, p2) << endl; // 可以比较，结果错误
    16. 	return 0;
    17. }

    造成每次结果不一样是因为 我们每次都日期类对象比较的时候 系统每次分配的地址都是随机的，我们对地址进行比较是不符合实际情况的。 

    此时，就 需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特 化中分为 函数模板特化 与 类模板特化

    2.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. }

     2.3类模板特化

     模板特化主要用在类模板中，它可以在泛型思想之上解决大部分特殊问题，并且类模板特化还可以分为：全特化和偏特化，适用于不同场景

    后面用的日期类举例比较多，先把日期类放出来

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 1970, int month = 1, int day = 1)
    5. 		: _year(year)
    6. 		, _month(month)
    7. 		, _day(day)
    8. 	{}
    9. 	bool operator<(const Date& d)const
    10. 	{
    11. 		return (_year < d._year) ||
    12. 			(_year == d._year && _month < d._month) ||
    13. 			(_year == d._year && _month == d._month && _day < d._day);
    14. 	}
    15. 	bool operator>(const Date& d)const
    16. 	{
    17. 		return (_year > d._year) ||
    18. 			(_year == d._year && _month > d._month) ||
    19. 			(_year == d._year && _month == d._month && _day > d._day);
    20. 	}
    21.  
    22. private:
    23. 	int _year;
    24. 	int _month;
    25. 	int _day;
    26. };
    27.

    2.3.1全特化

     全特化指 将所有的模板参数特化为具体类型，将模板全特化后，调用时，会优先选择更为匹配的模板类

    1. //原模板
    2. template<class T1, class T2>
    3. class Test
    4. {
    5. public:
    6. 	Test(const T1& t1, const T2& t2)
    7. 		:_t1(t1)
    8. 		,_t2(t2)
    9. 	{
    10. 		cout << "template" << endl;
    11. 	}
    12.  
    13. private:
    14. 	T1 _t1;
    15. 	T2 _t2;
    16. };
    17.  
    18. //全特化后的模板
    19. template<>
    20. class Test<int, char>
    21. {
    22. public:
    23. 	Test(const int& t1, const char& t2)
    24. 		:_t1(t1)
    25. 		, _t2(t2)
    26. 	{
    27. 		cout << "template<>" << endl;
    28. 	}
    29.  
    30. private:
    31. 	int _t1;
    32. 	char _t2;
    33. };
    34.  
    35. int main()
    36. {
    37. 	Test<int, int> T1(1, 2);
    38. 	Test<int, char> T2(20, 'c');
    39. 	return 0;
    40. }

    对模板进行全特化处理后，实际调用时，会优先选择已经特化并且类型符合的模板。

    2.3.2偏特化 

     偏特化，指 将泛型范围进一步限制，可以限制为某种类型的指针，也可以限制为具体类型

    1. //原模板---两个模板参数
    2. template<class T1, class T2>
    3. class Test
    4. {
    5. public:
    6. 	Test()
    7. 	{
    8. 		cout << "class Test" << endl;
    9. 	}
    10. };
    11.  
    12. //偏特化之一：限制为某种类型
    13. template<class T1>
    14. class Testint>
    15. {
    16. public:
    17. 	Test()
    18. 	{
    19. 		cout << "class Test" << endl;
    20. 	}
    21. };
    22.  
    23. //偏特化之二：限制为不同的具体类型
    24. template<class T>
    25. class Test
    26. {
    27. public:
    28. 	Test()
    29. 	{
    30. 		cout << "class Test" << endl;
    31. 	}
    32. };
    33.  
    34. int main()
    35. {
    36. 	Test<double, double> t1;
    37. 	Test<char, int> t2;
    38. 	Test t3;
    39. 	return 0;
    40. }

     

    偏特化（尤其是限制为某种类型）在 泛型思想 和 特殊情况 之间做了折中处理，使得 限制范围式的偏特化 也可以实现 泛型

    • 比如偏特化为 T*，那么传 int*、char*、Date* 都是可行的

    应用实例：

     有如下专门用来按照小于比较的类模板 ：Less

    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(d2);
    19.  v1.push_back(d3);
    20.  // 可以直接排序，结果是日期升序
    21.  sort(v1.begin(), v1.end(), Less());
    22.  vector v2;
    23.  v2.push_back(&d1);
    24.  v2.push_back(&d2);
    25.  v2.push_back(&d3);
    26.  
    27.  // 可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序
    28.  // 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象
    29.  // 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期
    30.  sort(v2.begin(), v2.end(), Less());
    31.  return 0;
    32. }
    通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排序元素是指 针，结果就不一定正确。因为： 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. };

     3.模版分离编译

     

    早在 模板初阶 中，我们就已经知道了 模板不能进行分离编译，会引发链接问题

     3.1失败原因

     声明与定义分离后，在进行链接时，无法在符号表中找到目标地址进行跳转，因此链接错误

    下面是 模板声明与定义写在同一个文件中时，具体的汇编代码执行步骤

    test.h 

    1. #pragma once
    2.  
    3. //声明
    4. template<class T>
    5. T add(const T x, const T y);
    6.  
    7. //定义
    8. template<class T>
    9. T add(const T x, const T y)
    10. {
    11. 	return x + y;
    12. }

     main.cpp

    1. #include 
    2. #include "Test.h"
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8. 	add(1, 2);
    9. 	return 0;
    10. }

     

     声明与定义在同一个文件中时，可以直接找到函数的地址

    编译器 生成可执行文件的四个步骤：

    1. 预处理：头文件展开、宏替换、条件编译、删除注释，生成纯净的C代码
    2. 编译：语法 / 词法 / 语义 分析、符号汇总，生成汇编代码
    3. 汇编：生成符号表，生成二进制指令
    4. 链接：合并段表，将符号表进行合并和重定位，生成可执行程序

    当模板的 声明 与 定义 分离时，因为是 【泛型】，所以编译器无法确定函数原型，即 无法生成函数，也就无法获得函数地址，在符号表中进行函数链接时，必然失败 

     3.2解决方案

     解决方法有两种：

    1. 在函数定义时进行模板特化，编译时生成地址以进行链接
    2. 模板的声明和定义不要分离，直接写在同一个文件中
    1. //定义
    2. //解决方法一：模板特化（不推荐，如果类型多的话，需要特化很多份）
    3. template<>
    4. int add(const int x, const int y)
    5. {
    6. 	return x + y;
    7. }

     

    1. //定义
    2. //解决方法二：声明和定义写在同一个文件中
    3. template<class T>
    4. T add(const T x, const T y)
    5. {
    6. 	return x + y;
    7. }

    这也就解释了为什么涉及 模板 的类，其中的函数声明和定义会写在同一个文件中 （.h），著名的 STL 库中的代码的声明和定义都是在一个 .h 文件中

    为了让别人一眼就看出来头文件中包含了 声明 与 定义，可以将头文件后缀改为 .hpp，著名的 Boost 库中就有这样的命名方式 

     

    4 总结 

     

    模板是 STL 的基础支撑，假若没有模板、没有泛型编程思想，那么恐怕 "STL" 会变得非常大

    模板的优点：

    模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
    增强了代码的灵活性
    模板的缺点：

    模板会导致代码膨胀问题，也会导致编译时间变长
    出现模板编译错误时，错误信息非常凌乱，不易定位错误位置
    总之，模板 是一把双刃剑，既有优点，也有缺点，只有把它用好了，才能使代码 更灵活、更优雅

  • 相关阅读:
    设计数据密集型应用的主要关注点
    ABC310D Peaceful Teams
    图片怎么加满屏水印？
    VSC/SMC(十五)——基于模糊逼近的积分滑模控制
    NeurIPS 2022 | 利用名词到代词的蒸馏以理解动词，面向任务的实例分割注意力模型
    OpenCV实战（30）——OpenCV与机器学习的碰撞
    springboot毕设项目城市轨道交通线路查询p2df3（java+VUE+Mybatis+Maven+Mysql）
    c++视觉处理 ------ 反向投影图和直方图的变化
    HTTP2 协议长文详解
    运维网关系列2：实现细节
  • 原文地址：https://blog.csdn.net/weixin_45476980/article/details/134555350