【C++】模板进阶

前言：
继模板初阶之后，我们将继续进行对模板的拓展学习。

一.类型模板参数

在模板初阶中我们所见到的模板参数都是类型模板参数。类型模板参数，顾名思义即通过传递的参数的类型来控制模板的实例化。

template<class T>
T Add(T a, T b)
{
	return  a + b;
}

void Test()
{
	int a = 10;
	int b = 100;

	double c = 1.5;
	double d = 3.14;
	cout << Add(a, b) << endl;
	cout << Add(c,d) << endl;
}

二.非类型模板参数

有了类型模板参数当然还得有非类型模板参数。模板参数分为类型形参与非类型形参：

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

并且还需要注意：

• 非类型模板参数只能是一个整型常量，值不可修改
• 非类型的模板参数必须在编译期就能确认结果。

示例1

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

template<class T,int N>
class Array
{
public:
	//...
private:
	T _a[N];
	size_t _size;
};

void Test()
{
	Array<int, 10> arr;
}

示例2

• 给整型常量缺省值

template<class T,size_t N = 10>
class Array
{
public:
	//...
	Array()
	{
		N++;
	}
private:
	T _a[N];
	size_t _size;
};

void Test()
{
	Array<int> arr; // 大小为10
}

示例3

• 整型常量的值不可修改

template<class T,size_t N = 10>
class Array
{
public:
	//...
	Array()
	{
		N++;  //错误示例：此处不可修改
	}
private:
	T _a[N];
	size_t _size;
};

void Test()
{
	Array<int> arr; // 大小为10
}

三.模板的特化

1.引例

• 定义一个专门用来比较小于的模板函数

template<class T>
bool Less(T left, T right)
{
	return left < right;
}

• 进行测试

int main()
{
	int a1 = 10;
	int a2 = 200;
	cout << Less(a1, a2) << endl;  // 可以比较，结果正确

	string s1 = "aaa";
	string s2 = "bbbb";
	cout << Less(s1, s2) << endl;  // 可以比较，结果正确

	string* p1 = &s1;
	string* p2 = &s2;
	cout << Less(p1, p2) << endl;  // 可以比较，结果错误

	return 0;
}

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

那么想要解决这一问题，就需要对模板进行特化。即在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。

模板特化中分为函数模板特化与类模板特化。

2.函数模板的特化

函数模板特化的方式

1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表必须要和模板函数的基础参数类型完全相同

示例

// 函数模板
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

// 特化版本
template<>
bool Less<string*>(string* left, string* right)
{
	return *left < *right;
}

测试

int main()
{
	int a1 = 10;
	int a2 = 200;
	cout << Less(a1, a2) << endl;  // 可以比较，结果正确

	string s1 = "aaa";
	string s2 = "bbbb";
	cout << Less(s1, s2) << endl;  // 可以比较，结果正确

	string* p1 = &s1;
	string* p2 = &s2;
	cout << Less(p1, p2) << endl;  // 可以比较，结果错误

	return 0;
}

3.类模板特化

类模板同样可以特化，而且有多种不同的特化方式。要求与函数模板特化大致类似：

1. 必须要先有一个基础的类模板
2. 关键字template后面接一对空的尖括号<>
3. 类名后跟一对尖括号，尖括号中指定需要特化的类型。

①全特化

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

示例

// 类模板
template<class T1,class T2,class T3>
class A
{
public:
	//...
private:
	T1 _a;
	T2 _c;
	T3 _d;
};

//全特化
template<>
class A<int, char, double>
{
public:
	//...
private:
	int _a;
	char _c;
	double _d;
};


int main()
{
	A<int, char, double>aa;
	return 0;
}

②偏特化

任何针对模版参数进一步进行条件限制设计的特化版本。

偏特化有两种表现形式：

• 部分特化：对部分参数进行特化
• 对参数类型的进一步限制（例如：T限制为T*）

部分特化

// 类模板
template<class T1,class T2,class T3>
class A
{
public:
	//...
private:
	T1 _a;
	T2 _c;
	T3 _d;
};

//偏特化----部分特化
template<class T1>
class A<T1, char, double>
{
public:
	//...
private:
	T1 _a;
	char _c;
	double _d;
};

对参数进一步限制

// 类模板
template<class T1,class T2,class T3>
class A
{
public:
	//...
private:
	T1 _a;
	T2 _c;
	T3 _d;
};

// 偏特化----对参数的进一步限制
template<class T1, class T2, class T3>
class A<T1*,T2*,T3*>
{
public:
	//...
private:
	T1 _a;
	T2 _c;
	T3 _d;
};

③类模板特化应用实例

下来我们就看看类模板特化的一个使用场景。假设现在我们想对几个int类型的变量用sort函数进行排序，首先我们得先定义一个专门进行比较小于的类模板Less：

template<class T>
struct Less
{
	bool operator()(const T& x, const T& y) const
	{
		return x < y;
	}
};

定义6个int类型的变量，并将它们放入容器vector中进行排序

示例 1

template<class T>
struct Less
{
	bool operator()(const T& x, const T& y) const
	{
		return x < y;
	}
};

int main()
{
	int a1 = 100;
	int a2= 15;
	int a3= 56;
	int a4= 178;
	int a5= 56;
	int a6= 98;

	vector<int> v{ a1,a2,a3,a4,a5,a6 };

	sort(v.begin(), v.end(), Less<int>());

	for (auto e : v)
	{
		cout << e << ' ';
	}
	cout << endl;
	return 0;
}

很显然这是成功的。接下来我们试试如果在vector中存放的是变量的地址，能否进行排序呢？

示例 2

int main()
{
	int a1 = 100;
	int a2 = 15;
	int a3 = 56;
	int a4 = 178;
	int a5 = 56;
	int a6 = 98;

	vector<int*> v{ &a1,&a2,&a3,&a4,&a5,&a6 };

	sort(v.begin(), v.end(), Less<int*>());

	for (auto e : v)
	{
		cout << *e << ' ';
	}
	cout << endl;
	return 0;
}

我们可以看到，此时可以排序，但是结果却不正确。原因是，此时排序的对象是6个变量的地址，而并非6个对象本身。如果要实现正确的排序方式，我们就得想办法排序地址里存放的内容。罪魁祸首肯定是Less模板了，因为它不能做到对指针的解引用。此种情况，我们就可以用到类模板特化来实现了。

示例 3

template<class T>
struct Less
{
	bool operator()(const T& x, const T& y) const
	{
		return x < y;
	}
};

// 指针版本的特化
template<>
struct Less<int*>
{
	bool operator()(const int* x, const int* y) const
	{
		return *x < *y;
	}
};

int main()
{
	int a1 = 100;
	int a2= 15;
	int a3= 56;
	int a4= 178;
	int a5= 56;
	int a6= 98;

	vector<int> v{ a1,a2,a3,a4,a5,a6 };

	sort(v.begin(), v.end(), Less<int>());

	for (auto e : v)
	{
		cout << e << ' ';
	}
	cout << endl;
	return 0;
}

此时，我们的结果终于正确了。

四.模板分离编译

分离编译：

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

示例

有如下场景：

• 在add.h文件中声明函数模板Add
• 在add.cpp文件中定义函数模板
• 在Test.cpp文件中使用Add函数

// add.h 文件中
#pragma once

template<class T>
T Add(T& a, T& b);

// add.cpp 文件中
#include"add.h"

template<class T>
T Add(T& a, T& b)
{
	return a + b;
};

// Test.cpp 文件中

#include"add.h"

int main()
{
	int a = 10;
	int b = 20;

	cout << Add(a, b) << endl;

	return 0;
}

当我们运行之后，回发现编译器报了一个链接错误，如上图所示。

原因是：

• Test.cpp文件中进行函数Add< int >的调用，在编译时并不会报错。但是在链接时，编译器会通过符号表去找Add< int >函数的地址。但是，Add函数此时并没有被实例化，因为模板的定义在另一个.cpp文件中，编译器并不知道你会在Test.cpp文件中需要实例化Add，也就意味着并不会生成具体函数。所以在链接时，无法找到Add< int >函数的地址，就会链接失败。

解决办法

• 将声明与定义放到同一个.hpp文件或.h文件中。

有的小伙伴可能第一次听说.hpp文件，接下来就简单介绍一下：

其实就一句话——.hpp文件就是专门为模板而生的。.hpp文件就是默认模板实现文件。

五.总结

模板的优点

1. 模板是泛型编程的基础
2. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
3. 增强了代码的灵活性

模板的缺点

1. 模板会导致代码膨胀问题，也会导致编译时间变
2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误；

---

本文到此结束，码文不易，还请多多支持哦！！！