泛型编程：

概念

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

如果我们想写一个通用的交换代码 ？

void Swap(int& a, int& b)
{
   int t = a;
   a = b;
   b = t;
}
void Swap(double& a, double& b)
{
   int t = a;
   a = b;
   b = t;
}
void Swap(char& a, char& b)
{
   int t = a;
   a = b;
   b = t;
}

我们需要写各种类型代码，由于函数重载这样可以实现，但这也太麻烦了！！

如果有个模具，我们需要什么类型 加进去就能用多好，

函数模板

概念：

函数模板代表了一个函数家族，该函数模板与类型无关，在需要时实参化，根据实参类型产生相应特殊函数，

🚩函数模板格式

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

所以交换函数实现：

template<typename T>
void Swap(T &a,T& b)
{
	T temp = a;
	a = b;
	b = t;
}

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

原理：

在编译阶段，编译器会通过根据传入的实参类型推演出正确的模板参数类型，然后编译器生成一份正确的代码

🚩函数模板实例化

隐式实例化：让编译器自动识别：

#include <iostream>
using namespace std;
template<typename T>
void Swap(T &a,T& b)
{
	T temp=a;
	a = b;
	b = temp;
	cout << a << " " << b<<endl;
}
int main()
{
	int a1 = 10, a2 = 20;
	double b1 = 10.5, b2 = 20.5;
	Swap(a1, a2);
	Swap(b1, b2);
	return 0;
}

20 10
20.5 10.5

但是有个问题，如下

int a3 = 30;
double b3 = 30.5;
Swap(a3, b3);

报错了，
因为就一个T，不知道是int还是double了，
1，我们可以强转
2，显性实例化

int a3 = 30;
double b3 = 30.5;
Swap((double)a3, b3);

出错了，但没办法QAQ
强转会产生临时变量，引用不能接受，实例化也没用，模板参数加const又不能交换QAQ,所以我们只能先换个函数继续讲QAQ

显性实例化：在函数名后接<>，里面指定模板函数实际类型

#include <iostream>
using namespace std;
template<typename T>
void Add(const T& a,const T& b)
{
	cout << a + b << endl;
}
int main()
{
	int a4 = 40;
	double b4 = 40.5;
	Add((double)a4, b4);
	Add<int>(a4, b4);
	return 0;
}

80.5
80

与非模板函数共存

模板函数是可以和非模板函数共名的，编译器会优先考虑非模板函数，

#include <iostream>
using namespace std;
template<typename T>
void Add(const T& a,const T& b)
{
	cout << a + b << endl;
}
void Add(int a, int b)
{
	cout << "sum=";
	cout << a + b << endl;
}

int main()
{
	int a4 = 40;
	double b4 = 40.5;
	Add((double)a4, b4);
	Add<int>(a4, b4);
	Add(1, 2);
	Add(1,2.1);
	return 0;
}

80.5
80
sum=3
sum=3

后两个用非模板，说明如果合适，编译器优先非模板函数，处理不了就用模板函数，
注意：模板函数不能自动转换，非模板函数能自动转换类型

类模板

格式：

template<class T1,class T2,…,class T3>
class 类模板名 {
};

//实现一个动态顺序表
template<class T>
class vector
{
public:
	vector(int capacity=0)
		:_pDate(new T[capacity])
	    ,_size(0)
	    ,_capacity(capacity)
	{}
	T& operator [](size_t pos)
	{
		if(pos<size)
		return _pDate[pos];
	}
	size_t size()
	{
		return _size;
	}
	~vector();
	//类中声明，类外定义
private:
	T* _pDate;
	size_t _size;
	size_t _capacity;
};
template<class T>
vector<T>::~vector()
{
	if (_pDate)
		delete[] _pDate;
	_size = _capacity = 0;
}

如果在类外定义函数，需要加模板列表

类模板实例化

类模板实例化和函数模板实例化不同，需要在类模板名字后面加<>，里面存的是需要实例化的类型

int main()
{
	vector<int> s1;
	vector<double> s2;
	return 0;
}

类模板名字不是真正的类，实例化的结果才是真正的类,