(学习总结16)C++模版2

C++模版2

一、非类型模板参数
二、模板的特化
- 1. 概念
- 2. 函数模板特化
- 3. 类模板特化
- - 全特化
  - 偏特化
  - 类模板特化应用示例
三、模板分离编译
- 1. 什么是分离编译
- 2. 模板的分离编译
- 3. 解决方法
模板总结

以下代码环境为 VS2022 C++。

一、非类型模板参数

模板参数分为类型形参与非类型形参。

类型形参：出现在模板参数列表中，跟在 class 或者 typename 后之类的参数类型名称。

非类型形参：就是用一个常量作为类(或函数) 模板的一个参数，在类(或函数) 模板中可将该参数当成常量来使用。

namespace my
{// 定义一个模板类型的静态数组template<class T, size_t N = 10>class array{public:T& operator[](size_t n){return _arr[n];}const T& operator[](size_t n) const{return _arr[n];}size_t size(){return _size;}bool empty(){return _size == 0;}private:T _arr[N];size_t _size = N;};
}

注意：

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

二、模板的特化

1. 概念

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

#include <iostream>template<class T>
bool Less(T left, T right)
{return left < right;
}int main()
{std::cout << Less(1, 2) << std::endl;std::cout << Less(1.5, 5.2) << std::endl;int b = 2;int a = 1;std::cout << Less(a, b) << std::endl;int* p2 = &b;int* p1 = &a;std::cout << Less(p1, p2) << std::endl;		// 可以比较，但是结果不一定对return 0;
}

可以看到，Less 绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1 指向的 a 显然小于 p2 指向的 b ，但是 Less 内部并没有比较 p1 和 p2 指向的内容，而比较的是 p1 和 p2 指针的地址，这就无法达到预期而错误。

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

2. 函数模板特化

函数模板的特化步骤：

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

#include <iostream>template<class T>						// 1. 必须要先有一个基础的函数模板
bool Less(T left, T right)
{return left < right;
}// 对 Less 函数模板进行特化
template<>								// 2. 关键字 template 后面接一对空的尖括号 <>
bool Less<int*>(int* left, int* right)	// 3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
{				// 4. 函数形参类型完全对应。return *left < *right;
}int main()
{std::cout << Less(1, 2) << std::endl;std::cout << Less(1.5, 5.2) << std::endl;int b = 2;int a = 1;std::cout << Less(a, b) << std::endl;int* p2 = &b;int* p1 = &a;std::cout << Less(p1, p2) << std::endl;		// 结果正确return 0;
}

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

#include <iostream>template<class T>						
bool Less(T left, T right)
{return left < right;
}template<>								
bool Less<int*>(int* left, int* right)	// 特化
{				std::cout << "Less<int*>(int* left, int* right)" << std::endl;return *left < *right;
}bool Less(int* left, int* right)		// 直接给出
{std::cout << "Less(int* left, int* right)" << std::endl;return *left < *right;
}int main()
{int b = 2;int a = 1;int* p2 = &b;int* p1 = &a;// 函数模板特化与直接给出的函数都存在，则优先调用直接给出的函数std::cout << Less(p1, p2) << std::endl;		// 这个是指定调用模板 Less 函数std::cout << Less<int*>(p1, p2) << std::endl;return 0;
}

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

3. 类模板特化

全特化

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

#include <iostream>template<class T1, class T2>
class Data						// 1. 类模板存在
{
public:Data(){std::cout << "Data<T1, T2>" << std::endl;}private:T1 _d1;T2 _d2;
};template<>						// 2. 特化时 template 后只带 <>
class Data<int, double>			// 3. Date 后带 <> ， <> 里带特化的类型
{		// 4. 参数类型对应
public:Data(){std::cout << "Data<int, double>" << std::endl;}private:int _d1;double _d2;
};int main()
{Data<int, int> d1;Data<int, double> d2;return 0;
}

偏特化

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

template<class T1, class T2>
class Data						
{
public:Data(){std::cout << "Data<T1, T2>" << std::endl;}private:T1 _d1;T2 _d2;
};

偏特化有以下两种表现方式：

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

template<class T1>
class Data<T1, double>
{
public:Data(){std::cout << "Data<T1, double>" << std::endl;}private:T1 _d1;double _d2;
};

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

template<class T1, class T2>
class Data<T1*, T2*>			// 两个参数偏特化为指针类型
{
public:Data(){std::cout << "Data<T1*, T2*>" << std::endl;}private:T1* _d1;T2* _d2;
};template<class T1, class T2>
class Data<T1&, T2&>			// 两个参数偏特化为引用类型
{
public:Data(){std::cout << "Data<T1&, T2&>" << std::endl;}private:const T1& _d1 = 1;const T2& _d2 = 2;
};void test()
{Data<int, int> d1;			// 调用基础的类模板Data<double, double> d2;	// 调用特化的 double 版本Data<int*, int*> d3;		// 调用特化的指针版本Data<int&, int&> d4;		// 调用特化的引用版本
}

类模板特化应用示例

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

#include <iostream>
#include <algorithm>
#include <vector>template<class T>
class Less
{
public:bool operator()(const T& left, const T& right) const{return left > right;}
};void test()
{int c = 7;int a = 5;int b = 6;std::vector<int> arr1;arr1.push_back(a);arr1.push_back(b);arr1.push_back(c);sort(arr1.begin(), arr1.end(), Less<int>());for (auto e : arr1){std::cout << e << " ";}std::cout << std::endl;std::vector<int*> arr2;arr2.push_back(&a);arr2.push_back(&b);arr2.push_back(&c);sort(arr2.begin(), arr2.end(), Less<int*>());for (auto e : arr2){std::cout << *e << " ";}std::cout << std::endl;
}int main()
{test();return 0;
}

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

template<>
class Less<int*>
{
public:bool operator()(int* left, int* right) const{return *left > *right;}
};

特化之后，在运行上述代码，就可以得到正确的结果。当然自定义的类型也可以，并且使用指针作为参数进行排序，可以节省占用字节多的类型的空间。

三、模板分离编译

1. 什么是分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

2. 模板的分离编译

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

#include <iostream>// add.h
template<class T>
T add(const T& left, const T& right);// add.cpp
// #include "add.h"
template<class T>
T add(const T& left, const T& right)
{return left + right;
}// main.cpp
// #include "add.h"
int main()
{add(1, 2);return 0;
}