本篇主要介绍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,T2template<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); //都为intAdd((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，模板在这里其实很像c语言中的typedef，但是C语言实现栈，一个栈只能实现一种数据的存放，模板就能实现不同类型的栈。Stack<int> s1; //intStack<double> s2; //double类模板都是显式实例化，模板推导不出来T的类型。
Stack是类名，Stack<int>才是类型，给不同的模板实例化，就是不同的类型。
本篇分享就到这里，拜拜~
