泛型编程

先看一个例子：

这是一些对于Swap重载的函数，区别是类型不同；
虽然能够重载使用，但代码复用率比较低，如果我们让别人直接调用我们的函数，只使用整形类型的Swap（），那么其他函数就有点浪费了；
而且代码的维护性比较低，一个出错可能会导致重载都出错。

所以在C++中，就有了模板的概念。
类似于你给一个普通模板，填入不同的数据，然后进行套用；
在编程中我们称之为泛型编程。

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

模板可以分类为：

函数模板

函数模板是实现泛型编程的一种方式。通过函数模板，可以编写一种通用的函数，可以适用于多种类型的数据，可以在不同的上下文中进行重复使用。

语法格式：
template < typrname T >
返回值类型 函数名(参数列表)
{
函数内容
}

在上述格式中，template < typrname T > 表示定义了一个模板，T是一个占位符类型，它可以代表任何类型。

使用

#include<iostream>
using namespace std;

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

//模板的演示
int main()
{
	int a = 1, b = 2;
	double c = 1.2, d = 3.4;

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

	return 0;
}

注意：

通用加法函数

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

int main()
{
	int a = 1, b = 2;
	cout<<Add(a, b)<<endl;
	double c = 1.2, d = 2.4;
	cout << Add(c, d) << endl;

//显示实例化
	cout<<Add<int>(1, 2)<<endl;
	cout<<Add<double>(2, 3.44)<<endl;
	return 0;
}

实例化：

注意：

我们可以使用多模板参数。

多模板参数

template<class X,class Y>
void func(const X& x, const Y& y)
{
	cout << x <<" " << y << endl;
}


//多模板参数
int main()
{
	func(1, 2.2);
	func(1, 1);
	func(2.2, 2.2);
}

必须用实例化

template<class T>
T* f(int n)
{
	T* p = new T[n];
	return p;
}

函数模板的原理

当你使用函数模板进行函数调用时，编译器会根据传入的参数类型来确定需要实例化的模板参数类型。编译器会查找匹配的模板定义，并将实际的参数类型替换为函数参数类型，生成对应的函数代码。

类模板

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

使用

template<class T>
class Stack
{
private:
	T* _a;
	int _top;
	int _capacity;
public:
	Stack(int capacity = 4)
		:_a(new T[capacity]),
		_top(0),
		_capacity(capacity)
	{
		cout << "Stack(int capacity = 4)" <<endl;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		delete[] _a;
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
};

int main()
{
	Stack<int> s1;
	Stack<double> s2;

	return 0;
}

注意事项