1. 初识模板
模板是什么
模板就是一种通用的模型，只要我们给出模板，编译器就可以自动帮助我们自动生成函数或类。
模板又分为函数模板和类模板。
模板的意义
我们在使用函数重载的过程中，常常会遇见下面的情况：
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;
}这些函数的函数体完全一样，而我们写了这么多个仅仅是因为参数的类型不同，如果有新的类型出现，我们还需要继续增添这样类似的函数。
增添这样的函数似乎并不难，因为他们简直像是一个模子刻出来的：
void Swap(Type& left, Type& right)
{
Type temp = left;
left = right;
right = temp;
}这么简单的工作又何必让我们亲自动手呢？
祖师爷Bjarne Stroustrup说要方便，于是便有了模板。
2. 函数模板
用于生成函数的模板叫做函数模板，函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
使用格式
template<class T1, class T2, …… , class Tn>
返回类型 函数名(参数列表){}
template<typename T1, typename T2, …… , typename Tn>
返回类型 函数名(参数列表){}template是模板的关键字，后面的<>表示类型列表，里面的内容是类型的代号(可随意取名)。
紧接着下一行，就给出函数的模板。
例如刚才的Swap函数，我们可以利用函数模板给出：
template<class Type>
void Swap(Type& left, Type& right)
{
Type temp = left;
left = right;
right = temp;
}实例化方式
函数模板归根到底只是一个用来给编译器生成函数的模板，它本身并不是函数。
编译器利用函数模板生成所需函数的过程叫做函数模板的实例化，实例化的方式有两种：
1. 推导实例化：在调用函数时，编译器根据传入参数的类型推导出类型列表中的代号对应什 么类型，进而实例化出函数以供调用。
2. 显式实例化：在调用函数时，在函数名的后面利用<>给出参数列表的对应类型，以此实例 化出函数以供调用。
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a = 10, b = 20;
double c = 10.1, d = 20.2;
// 推导实例化
cout << Add(a, b) << endl;
cout << Add(c, d) << endl;
cout << Add(a, (int)d) << endl;
cout << Add((double)a, d) << endl;
// 显式实例化
cout << Add<int>(a, b) << endl;
cout << Add<double>(c, d) << endl;
cout << Add<int>(a, d) << endl;
return 0;
}
模板参数的匹配原则
1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非模板函数匹配，编译器不需要特化
Add<int>(1, 2); // 调用编译器特化的Add版本
}2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板。
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。
3. 类模板
用于生成类的模板叫类模板。同理，这样的模板中某些类型待定，在被使用时必须显式进行实例化。
使用格式
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
}; 例如栈类模板：
#include<iostream>
using namespace std;
// 类模版
template<typename T>
class Stack
{
public:
Stack(size_t capacity = 4)
{
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}
void Push(const T& data)
{
// 扩容
_array[_size] = data;
++_size;
}
private:
T* _array;
size_t _capacity;
size_t _size;
};
int main()
{
Stack<int> st1; // int
Stack<double> st2; // double
return 0;
}通过类模板给出的栈就可以支持存储各种类型的数据，而不需要依照不同的类型写多个栈。
实例化方式
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的 类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。
// Stack是类名，Stack<int>才是类型
Stack<int> st1; // int
Stack<double> st2; // double类模板的成员函数在类模板外定义
template<class T1, class T2, ..., class Tn>
返回类型 类名<T1, T2, ..., Tn>::函数名(参数列表)
{
// 函数体
}如将Push函数放到Stack模板外定义：
#include<iostream>
using namespace std;
// 类模版
template<typename T>
class Stack
{
public:
Stack(size_t capacity = 4)
{
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}
void Push(const T& data);
private:
T* _array;
size_t _capacity;
size_t _size;
};
// 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误，具体原因后面会讲
template<class T>
void Stack<T>::Push(const T& data)
{
// 扩容
_array[_size] = data;
++_size;
}
int main()
{
Stack<int> st1; // int
Stack<double> st2; // double
return 0;
}
