本篇主要介绍C++中的模板初阶的一些知识。模板分为函数模板和类模板，我们一个一个来看。
1.函数模板
1.1函数模板概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实际的参数类型产生函数特定版本。
1.2函数模板格式
template<class T1, class T2, ...> (class/typename都行，<>里面是模板参数列表)
返回值类型 函数名(参数列表)
{}
关键字：template class/typename(二者无区别，但是不能使用struct代替class)
比如我们现在要写一个两个数交换的函数
//模板类型
template<class T>
void Swap(T& x, T& y)
{
T tmp = x;
x = y;
y = tmp;
}1.3 函数模板原理
我们在调用的时候就正常调用，编译器会帮助我们生成对应的函数。
int a = 1;
int b = 2;
cout << a << b << endl;
Swap(a, b);
cout << a << b << endl;
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生的特定类型函数的模具。所以其实模板就是将本应该我们重复的事情交给编译器。
比如我们再交换double类型的试一下。
int a = 1, b = 2;
Swap(a, b);
double c = 1.1, d = 2.2;
Swap(c, d);
顺便说一句，C++其实提供了交换的函数，就是swap()，可以直接用。
当模板参数只有一个时，我们传参就必须传类型相同的，传不同类型的话这一个模板参数是不明确的，如果想传不同的就可以多加一个模板参数，如下
//两个模板参数T1,T2
template<typename T1, typename T2>
void Swap(T1& x, T2& y)
{
T tmp = x;
x = y;
y = tmp;
}
int a = 1, b = 2;
Swap(a, b);
double c = 1.1, d = 2.2;
Swap(c, d); //可传相同类型
Swap(a, c); //可传不同类型记住！我们调用的不是模板，而是模板通过对参数类型的推理而生成的函数
这里其实就是一种泛型编程，泛型编程就是编写与类型无关的通用代码，是代码复用的一种手段，模板是泛型编程的基础。
1.4函数模板的实例化
用函数模板生成对应的函数，就是模板的实例化
//模板实例化
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}前面我们说到过，如果只有一个模板参数，调用函数传参时，要传一样类型的参数，如果这里非要传不同类型的参数，就有下面几种解决方式：
int a = 1, b = 2;
double c = 1.1, d = 2.2;第一种，强制类型转换。这种方法叫做推导实例化。
Add(a, (int)c); //都为int
Add((double)a, c); //都为double这种方法就是让编译器自己去推导T的类型。
第二种，显示实例化。在函数名和参数中间加上<>，<>里面写类型。
//显式实例化
Add<int>(a, c);
Add<double>(a, c);这里的意思就是，我们不通过模板自己推导得出参数类型，我们直接给定T的类型了。
第三种，定义多个模板参数。前面提到过。
template<class T1, class T2>
T1 Add(const T1& left, const T2& right)//返回值类型想给什么就给什么
{
return left + right;
}如果想对这种有多个模板参数的显式实例化，也是在在<>里写类型，逗号分隔。
//显式实例化
Add<int, double>(a, c);
Add<double, int>(a, c);有些地方必须要用显式实例化，比如下面这个代码。
template<class T>
T* func(int a)
{
return new T[n];
}int main()
{
func(10);//错误示范
return 0;
}这里模板推导不出来T到底什么类型，所以必须显式实例化，比如说我们想要int类型的。
int main()
{
int* p = func<int>(10);
return 0;
}1.5 模板参数的匹配原则
1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这 个非模板函数2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而 不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模 板3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
2.类模板
2.1 类模板的定义格式
template<class T1, class T2, ..., class Tn> （也可以用typename）
class 类模板名
{
//类内成员定义
}
比如说我们写一个栈Stack的一部分。
template<class T>
class Stack
{
public:
Stack(int n = 4) //构造
:_arr(new T[n])
,_size(0)
,_capacity(n)
{}
~Stack() //析构
{
delete[] _arr;
_arr = nullptr;
_size = _capacity = 0;
}
void Push(const T& x)
{}
private:
T* _arr;
int _size;
int _capacity;
};这里的Push压栈时，空间不够我们要扩容，扩容怎么写？
直接手动扩容，不用realloc那些函数了。 步骤如下。
void Push(const T& x)
{
if (_size == _capacity)//当空间不够时
{
T* tmp = new T[_capacity * 2]; //手动扩容
memcpy(tmp, _arr, sizeof(T) * _size); //原数据拷贝到新空间
delet[] _arr; //释放旧空间
_arr = tmp; //指向新空间
_capacity *= 2; //更新空间大小数据
}
_arr[_size++] = x; //入栈
}
2.2 类模板的实例化
Stack<int> s1; //int
Stack<double> s2; //double类模板都是显式实例化，模板推导不出来T的类型。
Stack是类名，Stack<int>才是类型，给不同的模板实例化，就是不同的类型。
本篇分享就到这里，拜拜~
