【c++】模板初阶

🌟🌟作者主页：ephemerals__

🌟🌟所属专栏：C++

前言

        当我们学习完c++中类和对象以及动态内存管理的相关知识之后，就可以初步了解STL（标准模板库）并进行学习了。当然，在这之前，有一个关键知识的学习，那就是模板。本篇文章博主就和大家一起探讨模板相关的基础知识。

一、问题引入--泛型编程

        当我们需要针对各种类型的数据实现交换函数时，实现的结果可能是这样的：

void Swap(int& x, int& y)
{
	int t = x;
	x = y;
	y = t;
}

void Swap(float& x, float& y)
{
	float t = x;
	x = y;
	y = t;
}

void Swap(double& x, double& y)
{
	double t = x;
	x = y;
	y = t;
}

不难发现，这样会造成代码冗余，并且有新类型时，就需要手动增加新的函数。那么有没有办法能够实现一个通用的交换函数呢？

        答案是可以的，实现的方法就是借助模板。模板就像是制作物品的模具，通过向这个模具中填充不同类型的材料，就可以得到不同材料构成的铸件。当我们发现一些程序需要处理不同的类型，但它们的逻辑却是相似的，此时就可以使用模板来创建一个通用的函数或类，需要使用时指定数据类型即可。模板的特性体现了泛型编程的思想，能够大大提高代码的复用率，是泛型编程的基础。

模板可以分为函数模板和类模板：

接下来我们对这两种模板进行逐一讲解。

二、函数模板

函数模板的概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时根据实参的类型产生相应类型的函数。

函数模板的定义格式

template<typename T1,typename T2,......,typename Tn>

(下一行紧跟函数定义)

---

这里的“typename”也可以替换成“class”，但是不可以替换成“struct”。

接下来我们使用函数模板写一个通用的交换函数，并尝试使用它：

#include <iostream>
using namespace std;

//函数模板的定义
template<class T>
void Swap(T& x, T& y)
{
	T t = x;
	x = y;
	y = t;
}

int main()
{
	int a = 10, b = 20;
	double c = 5.5, d = 6.6;
	char e = 'w', f = 'm';

	cout << a << ' ' << b << endl;
	cout << c << ' ' << d << endl;
	cout << e << ' ' << f << endl;
	cout << endl;

	Swap(a, b);
	Swap(c, d);
	Swap(e, f);

	cout << a << ' ' << b << endl;
	cout << c << ' ' << d << endl;
	cout << e << ' ' << f << endl;
	return 0;
}

运行结果：

函数模板的原理

        函数模板也被称作“模板函数”，但是要注意，函数模板本身是一个“蓝图”、“模具”，而不是一个函数。编译器会识别我们传参的类型，根据“蓝图”来创造出相应的函数。可以说，我们使用函数模板就是将多次编写代码的过程交给了编译器。

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

函数模板的实例化

        当各种类型的参数使用函数模板时，称之为函数模板的实例化。函数模板的实例化可以分为隐式实例化和显示实例化。

隐式实例化

        隐式实例化指的是让编译器根据实参的类型来推演出模板参数的实际类型。举个例子：

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

int main()
{
	int a = 10, b = 20;
	double c = 1.1, d = 2.2;

	Add(a, b);
	Add(c, d);
	return 0;
}

 注意，如果让不同类型的两个值相加，就会出现编译报错：

Add(a, c);

因为在编译期间，编译器识别到该实例化时，通过a的类型将T推演为int类型，而通过c的类型将T推演为double类型，但由于模板参数列表当中只有一个T，编译器无法确定T到底是什么类型，就会发生报错。

        此时有两种解决方法：1. 将其中一个参数强制类型转换为与另一个参数相同；2. 使用显示实例化。

显示实例化

        显示实例化指在函数名之后，参数列表之前加一个“< >”，在其中按照顺序指定模板参数的实际类型。举个例子：

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

int main()
{
	int a = 10, b = 20;
	double c = 1.1, d = 2.2;

	Add<int>(a, c);//显示实例化
	return 0;
}

此时如果函数参数的类型不匹配，编译器就会对该参数进行隐式类型转换，就不会出现之前的问题了。

模板参数的匹配原则

        模板参数的匹配原则有如下三点：

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

//非模板函数
int Add(int a, int b)
{
	return a + b;
}

//同名的函数模板
template<class T>
T Add(T a, T b)
{
	return a + b;
}

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

	Add(a, b);//此时与非模板函数匹配，直接调用之
	Add<int>(a, b);//使用模板进行实例化
	return 0;
}

2. 当非模板函数与同名函数模板同时存在且模板可以产生一个更匹配的函数时，优先选择模板。例如：
 

//非模板函数
int Add(int a, int b)
{
	return a + b;
}

//同名的函数模板
template<class T>
T Add(T a, T b)
{
	return a + b;
}

int main()
{
	Add(1.1, 2.2);//使用模板更加匹配参数类型
	return 0;
}

3. 模板函数不允许隐式类型转换，但普通函数可以。

三、类模板

类模板的定义格式

        与函数模板相同，类模板也可以根据不同的类型产生不同的类。它的定义格式如下：

template<class T1,class T2,......,class Tn>

(下一行紧跟类的定义)

 举个例子：

//类模板
template<class T>
class A
{
public:
	void fun()
	{
		//...
	}
private:
	T _a;
	T _b;
};

当类中函数的声明和定义分离时，需要在定义处重新定义一次模板参数，且声明和定义不应分离到两个文件，否则会出现链接错误：

template<class T>
void A<T>::fun()
{
	//...
}

类模板的实例化

        与函数模板不同，类模板只能显示实例化。类模板的名字“A”只是类标签，不是类名，而实例化的结果（例如A<int>）才是真正的类名。

//类模板的实例化
A<int> a;
A<double> b;

总结

        今天我们学习了c++的模板，它分为函数模板和类模板，是泛型编程和学习STL的基础。如果你觉得博主讲的还不错，就请留下一个小小的赞在走哦，感谢大家的支持❤❤❤