【C++】模板初阶——函数模板和类模板

---

🚀 作者简介：一名在后端领域学习，并渴望能够学有所成的追梦人。
🚁 个人主页：不 良
🔥 系列专栏：🛸C++  🛹Linux
📕 学习格言：博观而约取，厚积而薄发
🌹 欢迎进来的小伙伴，如果小伙伴们在学习的过程中，发现有需要纠正的地方，烦请指正，希望能够与诸君一同成长！ 🌹

---

泛型编程

当我们要实现不同类型的数值进行交换时，按照之前学过的我们可以通过定义具有不同形参类型的函数来完成：

// 交换两个int类型
void Swapi(int* left, int* right)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
// 交换两个double类型
void Swapd(double* left, double* right)
{
	double tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

通过传址传参定义不同的函数来完成，当然也可以使用函数重载和引用来完成：

// 交换两个int类型
void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
// 交换两个double类型
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}

通过函数重载的代码我们发现函数中也仅仅只有数据类型不同，基本逻辑都相同。

所以使用函数重载虽然可以实现，但是也有不足的地方：

1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错。

所以在C++中为了弥补这种不足，引入了泛型编程。

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

模板可分为类模板和函数模板。

函数模板

函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

格式：

template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}  

例：

template<class T>//参数名称T可以使用其他名称表示
//template<typename T>
int Add(T a, T b)
{}

//T不在Sum函数中起作用
void Sum()
{}

template<class T>叫做函数模板的参数列表

使用template关键字定义模板，具体的数据类型是什么由需要确定。

模板仅仅对后面紧跟的那个函数起作用，当再定义新的函数后需要重新定义模板。

注意：typename是用来定义模板参数的关键字，也可以用class代替，但是不能用struct代替。

函数模板原理

函数模板是一个蓝图，它本身并不是函数。是编译器产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

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

思考：

下面代码中Add(a,b)和Add(d1,d2)调用的是不是同一个函数？

template<class T>
T Add(T x, T y)
{
	return x + y;
}
int main()
{
	int a1 = 10;
	int a2 = 20;
	double d1 = 1.2;
	double d2 = 3.4;
	Add(a1, a2);
	Add(d1, d2);
}

不是，通过反汇编看一下，他们调用的函数地址不相同，所以调用的不是同一个函数。

调用的不是模板，是模板实例化出来的函数。

函数模板实例化

用不同类型的参数使用模板时，称为模板的实例化。模板实例化分为隐式实例化和显示实例化。

• 隐式实例化：让编译器根据实参推演模板参数的实际类型

#include <iostream>
using namespace std;
template<class T>
T Add(T x, T y)
{
	return x + y;
}
int main()
{
	int a1 = 10;
	int a2 = 20;
	Add(a1, a2);//编译器通过实参a1和a2的类型实例化出模板参数类型为int的Add函数
}

当我们使用不同类型的数据操作时，编译器是否会推演出呢？

template<class T>
T Add(T x, T y)
{
	return x + y;
}
int main()
{
	int a1 = 10;
	double d1 = 20;
	//Add(a1, d1);//error，编译不通过
    Add(a1,(int)d1);//强制类型转换
}

当使用不同数据类型的实参时，此时编译器不能推演成功：因为在编译期间，编译器根据实参推演模板参数的实际类型时，根据实参a1将T推演为int，根据实参d1将T推演为double，但是模板参数列表中只有一个T，编译器无法确定此处应该将T确定为int还是double，所以我们可以通过强制类型转换Add(a1,(int)d1)、设置多个模板参数（注意返回类型）以及显示实例化来完成。

//设置多个模板参数
template<class T1,class T2>
T1 Add(T1 x, T2 y)
{
	return x + y;
}
int main()
{
	int a1 = 10;
	double d1 = 20;
   	Add(a1, d1);
}

或者：

//强制类型转换
template<class T>
T Add(T x, T y)
{
	return x + y;
}
int main()
{
	int a1 = 10;
	double d1 = 20;
    Add(a1,(int)d1);//强制类型转换
}

• 显示实例化：在函数名后的<>中指定模板参数的实际类型

template<class T>
T Add(T x, T y)
{
	return x + y;
}
int main()
{
	int a1 = 10;
	double d1 = 20;
	Add<int>(a1, d1);//指定模板参数的实际类型为int
}

使用显示实例化时，如果传入的参数类型与模板参数类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功，则编译器将会报错。

函数模板的匹配原则

• 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

#include <iostream>
using namespace std;
//模板函数
template<class T>
T Add(T x, T y)
{
	return x + y;
}
//专门处理int的函数，非模板函数
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int a1 = 10;
	int a2 = 20;
	Add(a1, a2);//有现成的函数，模板函数不用再去实例化，直接调用现成的
	Add<int>(a1, a2); //调用编译器实例化出来的
	double d1 = 1.2;
	double d2 = 3.4;
	Add(d1, d2);//调用编译器实例化出来的处理double类型的函数
}

• 对于非模板函数和同名的函数模板，如果其他条件都相同，在调用时会优先调用非模板函数，而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么选择模板

//模板函数，通用类型的Add函数
template<class T1,class T2>
T1 Add(T1 x, T2 y)
{
	return x + y;
}
//专门处理int的函数，非模板函数
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int a1 = 10;
	int a2 = 20;
	double d1 = 1.2;
	double d2 = 3.4;
	Add(a1, a2);//有现成的函数，不去模板函数再去实例化直接调用现成的
	Add(a1, d1);//一个double类型，一个int类型，模板实例化更好，调用编译器实例化出来的
}

• 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	Add(1, 2.2);//true
}

上述程序如果使用单个模板参数的模板函数，则编译不通过。

类模板

类模板的定义格式

template<class T1,class T2,…,class Tn>
class 类模板名
{
  //类内成员声明
};

例：

template <class T>
class Stack {
public:
	Stack(int capacity = 4)
	{
		_a = new T[capacity];
		_size = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		delete[] _a;
		_size = _capacity = 0;
	}
private:
	T* _a;
	size_t _size;
	size_t _capacity;
};
int main()
{
    //类模板只能显示实例化
	Stack<int> si;//int类型的栈
	Stack<double> sd;//double类型的栈
}

类模板声明和定义不能放在不同的文件中，要在同一个.cpp或者.h文件中，否则会出现链接错误。

类模板中的成员函数如果不在类中定义，那么在定义的时候必须加上模板声明，同时声明类域的时候要加上模板参数。

例：

#include <iostream>
using namespace std;
//类模板
template <class T>
class Time {
public:
	void Print();
private:
	T t = 2;
};
//类模板中的成员函数在类外定义，需要加模板参数列表
template<class T>
void Time<T>::Print()
{
	cout << t << endl;
}
int main() {
	Time<int> t;
	t.Print();
}

类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后面跟<>，然后将实例化的类型放在<>中即可。

类模板只能显示实例化。

学完模板参数之后要将类名和类型区分开，类名不是类型，要加上模板参数才算是类型，如下面的代码中，Time是类的类名，而Time<int>和Time<double>才是类型。

Time<int> t1;
Time<double> t2;