目录
1.什么是泛式编程以及模板的引入：
2. 模板：
2.1 函数模板：
2.2 类模板：
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;
} 这种方法太过复杂，并且，上面三个函数的结构基本一致，不一样的只有每个函数参数的类型。于是，在中，便引入了泛式编程，即：编写与类型无关的通用代码，是代码复用的一种手段。来解决上述问题。而对于本篇文章的主题模板，便是泛式编程的基础。
2. 模板：
模板可以分为两类，分别是函数模板和类模板，下面将分开对二者进行介绍：
2.1 函数模板：
函数模板代表了一个函数集合，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
对于函数模板的使用，需要借助关键字来实现，下面将针对于上面的交换函数
来介绍关键字的大致使用方法：
template<typename T>
void Swap(T& x, T& y)
{
int tem = x;
x = y;
y = tem;
}其中，typename是用来定义模板参数关键字，也可以使用class。在定义完模板关键字后，便可以用定义的模板关键字来代替函数中的类型。
在使用时，直接向函数传递参数即可，例如对于下方的代码：
int main()
{
int a = 1;
int b = 2;
Swap(a, b);
cout << a << " " << b << endl;
double i = 1.1;
double n = 2.2;
Swap(i, n);
cout << i << " " << n << endl;
return 0;
}运行结果为：
对于模板如何工作的原理，大致可以认为函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。
对于上述过程，把具体类型的参数传递给函数形参，推断出的类型的过程称之为模板的推演，把推演后，编写函数的过程称之为模板实例化。
上述模板参数在定义时，只是针对单一类型。假如传递的参数有多个不同的类型，可以通过定义不同的模板参数来解决，例如：
template<typename X, typename Y>
void Cout( X& a, Y& b)
{
cout << a << b << endl;
}传递参数如下：
int main()
{
int i = 1;
double n = 1.1;
Cout(i, n);
Cout(n, i);
return 0;
}运行结果如下：
当模板参数的数量小于传递参数的类型时，例如：
template<typename A>
A Add(A x, A y)
{
return x + y;
}
int main()
{
int i = 1;
double n = 1.1;
Add(i, n);
return 0;
}此时运行代码，编译器会报错。
上述函数模板参数实例化可以称之为隐式实例化，同时，也有显式实例化，方法如下：
template<typename A>
A Add(A x, A y)
{
return x + y;
}
int main()
{
int i = 1;
double n = 1.1;
cout << Add<int>(i, n) << endl;
return 0;
}此时，类型的变量
会在使用时被转类型为
，运行上述代码，结果为：
2.2 类模板：
对于下面一个简单的栈：
class Stack
{
public:
Stack(int capacity = 4)
{
cout << "Stack( int capacity = 4)" << endl;
_a = new int[capacity];
_capacity = capacity;
_top = _capacity;
}
~Stack()
{
cout << "~Stack()" << endl;
delete[]_a;
_a = nullptr;
_top = 0;
_capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};在之前数据结构的相关文章中，假设需要栈存储不同类型的数据，通常都是利用来完成，即：
typedef int STDataType;
class Stack
{
public:
Stack(int capacity = 4)
{
cout << "Stack( int capacity = 4)" << endl;
_a = new STDataType[capacity];
_capacity = capacity;
_top = _capacity;
}
~Stack()
{
cout << "~Stack()" << endl;
delete[]_a;
_a = nullptr;
_top = 0;
_capacity = 0;
}
private:
STDataType* _a;
int _top;
int _capacity;
};但是这种做法同样存在缺点，即只能针对一种单一的类型，如果需要存储两种不同类型的数据，则需要将上述代码进行一次复制，再改写等内容。这样的作法过于麻烦，并且重复性过高。而对于类模板，可以很好的解决问题，方法如下：
template<typename T>
class Stack
{
public:
Stack(int capacity = 4)
{
cout << "Stack( int capacity = 4)" << endl;
_a = new T[capacity];
_capacity = capacity;
_top = _capacity;
}
~Stack()
{
cout << "~Stack()" << endl;
delete[]_a;
_a = nullptr;
_top = 0;
_capacity = 0;
}
private:
T* _a;
int _top;
int _capacity;
};
int main()
{
return 0;
}在传参时，与函数可以隐式实例化和显式实例化不同，类模板只能显式实例化，例如需要存储两个类型的变量，显式实例化为：
Stack<int> s1;
Stack<double> s2;
