C++——模板进阶-Toy模板网

这篇具有很好参考价值的文章主要介绍了C++——模板进阶。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

C++——模板进阶

💐专栏导读

🌸作者简介：花想云，在读本科生一枚，致力于 C/C++、Linux 学习。

🌸本文收录于 C++系列，本专栏主要内容为 C++ 初阶、C++ 进阶、STL 详解等，专为大学生打造全套 C++ 学习教程，持续更新！

🌸相关专栏推荐：C语言初阶系列 、C语言进阶系列 、数据结构与算法、Linux从入门到精通

💐文章导读

继模板初阶之后，我们将继续进行对模板的拓展学习。本章主要内容有类型模板参数、非类型模板参数，模板的特化——函数模板的特化、类模板的特化，类模板的特化又可分为全特化与偏特化，除此之外，还涉及模板分离编译的内容。同时这也是C++初阶的最后一篇文章了。

C++——模板进阶

🌷类型模板参数

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

🍁示例

template<class T>
T Add(T a, T b)
{
	cout << "模板" << endl;
	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;//使用模板
}

C++——模板进阶

🌷非类型模板参数

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

类型形参：出现在模板参数列表中，跟在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
}

C++——模板进阶

🌷模板的特化

🌸引例

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

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;
}

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

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

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

🌸函数模板的特化

函数模板特化的方式：

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

🍁示例

// 函数模板
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;
}

C++——模板进阶

🌸类模板特化

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

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

🌼全特化

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

🍁示例

// 类模板
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;
}

C++——模板进阶

很显然这是成功的。接下来我们试试如果在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;
}

C++——模板进阶
我们可以看到，此时可以排序，但是结果却不正确。原因是，此时排序的对象是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;
}

C++——模板进阶
此时，我们的结果终于正确了。

🌷模板分离编译

🍁什么是分离编译

分离编译指的是：

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

🍁示例

有如下场景：

在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;
}

C++——模板进阶

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

原因是：

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

🍁解决办法