【C++】——模板（泛型编程+函数模板+类模板）

1. 前言

之前我们学习了函数重载，让我们在写相似函数的时候非常方便，但函数重载还有很多不足的地方，比如，每次写相似函数的时候，都要我们重新重载一个逻辑、代码几乎一样的函数，这就导致了我们的效率变低，所以我们今天来学习C++模板的相关知识点，学习完模板之后，我们就可以很好的解决这些问题。

2. 泛型编程

以前我们要实现一个通用的交换函数时是怎么做的呢？我们利用了函数重载，把可能用到的函数都重载出来。

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}

void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

使用函数重载虽然可以做到，但是有几个不足的地方：

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

那么我们该如何解决这个问题呢？
如果在C++中，能够存在一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码）这样就会让我们大幅提高效率。

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

3. 函数模板

概念：
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
格式：
template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表) {}
注意：
typename是用来定义模板参数关键字，也可以使用class。
typename后面类型名字T是随便取的。

//template<typename T>
template<class T>
void Swap(T& left, T& right)
{
	T tmp = left;
	left = right;
	right = tmp;
}

3.1 函数模板的原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

3.2 函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。
隐式实例化：让编译器根据实参推演模板参数的实际类型
显式实例化：在函数名后的<>中指定模板参数的实际类型

template<typename T>
T Add(const T& x, const T& y)
{
	return x + y;
}

int main()
{
	int a = 1, b = 2;
	double c = 1.1, d = 2.2;

	//编译器自动推演，隐式实例化
	cout << Add(a, b) << endl;
	cout << Add(c, d) << endl;

	//推演实例化矛盾，编译器无法确定此处到底该将T确定为int或者double类型而报错
	//cout << Add(a, d) << endl;

	//俩种处理方式：1、强制转换类型   2、显示实例化
	//1.强制转换类型
	cout << Add((double)a, d) << endl;
	cout << Add(a, (int)d) << endl;

	//2.显示实例化
	cout << Add<double>(a, d) << endl;
	cout << Add<int>(a, d) << endl;

	return 0;
}

3.3 模板参数的匹配原则

1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
2.对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板。
3.模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

//专门处理加法的函数
int Add(const int& x, const int& y)
{
	return x + y;
}

//通用加法函数
template<class T>
T Add(const T& x, const T& y)
{
	return x + y;
}

template<class T1, class T2>
T2 Add(const T1& x, const T2& y)
{
	return x + y;
}

int main()
{
	cout << Add(1, 2) << endl;//调用int Add函数
	cout << Add(1.1, 2.2) << endl;//调用T Add函数
	cout << Add(1, 2.2) << endl;//调用T2 Add函数

	return 0;
}

4. 类模板

格式：
template<class T1, class T2, …, class Tn>
class 类模板名
{
// 类内成员定义
};

template<class T>
class Stack
{
public:
	Stack(size_t capacity = 4)
		:_a(nullptr)
		,_top(0)
		,_capacity(0)
	{
		if (capacity > 0)
		{
			_a = new T[capacity];
			_capacity = capacity;
			_top = 0;
		}
	}

	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_top = _capacity = 0;
	}

	void Push(const T& x)
	{}
	//注意：类模板中函数放在类外进行定义时，需要加模板参数列表

private:
	T* _a;
	size_t _top;
	size_t _capacity;
};

注意：类模板中函数放在类外进行定义时，需要加模板参数列表

4.1 类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

template<class T>
class Stack//这里Stack不是具体的类，是编译器根据被实例化的类型生成具体类的模具
{
public:
	Stack(size_t capacity = 4)
		:_a(nullptr)
		,_top(0)
		,_capacity(0)
	{
		if (capacity > 0)
		{
			_a = new T[capacity];
			_capacity = capacity;
			_top = 0;
		}
	}

	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_top = _capacity = 0;
	}

	void Push(const T& x)
	{}

private:
	T* _a;
	size_t _top;
	size_t _capacity;
};

int main()
{
	//类模板都是显示实例化
	//虽然他们用了一个类模板，但是Stack<int>，Stack<char>是两个类型
	Stack<int> st1;
	Stack<char> st2;
	
	//知道要存多少个数据，避免插入时扩容消耗
	Stack<int> st3(100);

	return 0;
}

注意：
1.类模板必须显示实例化。
2.虽然上面两个对象用了同一个类模板，但是Stack<int>，Stack<char>是两个不同的类型。

5. 结尾

C++模板入门的相关知识点我们就学习完了，学了模板以后，在很多地方我们就可以用模板来实现，而不是重载函数，这能极大的提高效率和可维护性。
最后，感谢各位大佬的耐心阅读和支持，觉得本篇文章写的不错的朋友可以三连关注支持一波，如果有什么问题或者本文有错误的地方大家可以私信我，也可以在评论区留言讨论，再次感谢各位。