模板
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
void Swap(double* x, double* y)
{
double tmp = *x;
*x = *y;
*y = tmp;
}
void Swap(char* x, char* y)
{
char tmp = *x;
*x = *y;
*y = tmp;
}如上述所示，我们在实现函数的时候，有很多函数会像上述一样，实现过程差不多，但是由些许不同，那么我们都把这些实现出来会显得很呆，C++祖师爷也想到了，所以设计了模板。
函数模板
像上述的三个函数，算法相同，只是 参数的类型不同，那么我们就可以定义 函数模板，这样不管是什么类型，都可以使用这个函数模板，来实现相同的 算法。
语法：
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}上述的 typename 是用来定义模板参数关键字，也可以使用 class (注意： 不能使用 struct 来代替 class)
其实就是在模板出来的早期用的就是 clsss ，但是后面觉得不好区分就重写定义了 typename 这个关键字。
像上述交换变量的 函数我们就不用写 三个了，写一个就行了：
template<typename T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}我们不管使用内置类型还是自定义类型都可以实现上述的 算法：
而且，模板函数并不是调用的 这个模板，而是 编译器帮我们实现了 这些重载函数，然后去调用这些重载函数：
我们发现上述 两个 Swap 函数的地址不同。
编译器会根据我们 传入的参数来推演，推演出参数的类型：
编译器推导出之后，就会自己实现这个模板当前对应类型的 实例化函数。
这里其实就是 模板的 实例化，和对象的实例化有点类似。
而且，这里推导的类型，可以是任意类型，不管是内置类型 还是 自定义类型都可以推导出来，也就是说不管是什么类型都可以使用 模板推导出来。
像上述这样使用 模板来实现的 编程，也被称为是 泛型编程，因为这里的 函数并不是针对某一种 类型，而是针对 很多的类型。
模板的 " <> " 当中其实和 函数的参数列表差不多，我们可以指定多个参数类型，同时 模板当中的参数也可以是 函数的返回值类型：
对于 template 函数模板的作用范围就是这个函数。
模板函数的实例化
模板函数的实例化分为两种：
隐式实例化，这是编译器自己去推导出来的实例化函数，但是有的时候，对应的模板参数并不能实现 我们想要的参数类型，如下例子：
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
cout << Add(a1, a2) << endl;
cout << Add(d1, d2) << endl;
cout << Add(a1 , d1 ) << endl; // 不能编译通过
return 0;
}我们在模板当中只定义了 一个 T 的模板参数，但是我们传入的参数确是 int 和 double 类型的，这样做编译器就很为难，他不知道应该 使用哪一个 类型作为推导出来的类型，报错：
当我们遇到这种问题的时候，有两种解决方式，第一种就是进行强制类型转换，像上述例子就是把其中一个参数 强转成 另一个参数的类型：
cout << Add(a1, (int)d1) << endl;
cout << Add((double)a1, d1) << endl;而且向上述 使用 强制转换的方式 实现传参的时候要注意，上述是 传入的是引用：因为强制转换会产生临时变量，像上述的强制转换的 变量传参，不是直接传这个 d1 或者是 a1 这个变量引用给函数形参，而是把强制类型转换所产生的临时变量 赋值传给 函数形参，而 临时变量具有常性，所以，如果我们在函数形参位置不加 const 修饰的话，就会发生权限的放大 ，就会报错：
第二种，就是我们模板实例化的 第二种形式：显式实例化。
cout << Add<int>(a1, d1) << endl;
cout << Add<double>(a1, d1) << endl;这个时候就不需要 编译器自己去进行参数类型的推演了，向上述代码，第一种就直接实例化为了 int ，第二种就是直接实例化为了 double。
显式实例化的 使用的场景最多是如下的 这种形式：
有些函数不能自动推导 参数类型，只能使用显示实例化。
template<typename T>
T* Carray(int n)
{
return new T[n];
}
int main()
{
Carray(10);
return 0;
}
编译器进行推导的时候，必须通过参数进行推导，返回值，或者是函数其中的 算法来推导等等的这些方式都是不行的。
所以这里就要使用 显示实例化：
Carray<double>(10);通过显示实例化，在指定 模板当中的参数的类型，这样就可以实现上述函数的调用。
类模板
C++当中想到，在类当中也有类似的，和上述函数算法相同，但是参数类型不同的问题，所以在C++ 当中 有类模板来解决上述问题。
语法：
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};我们在C当中实现 栈的时候，是把存储的数据类型 用 typedef 来重新命名，这样做的好处是以后我们想要栈存储其他类型的 数据的时候，只需要修改 typedef 这一行代码就行了，但是这样做只能修改一个 栈的实现。当我现在想要同时实现多个 存储不同数据类型的栈的时候，typedef 就不能实现了。
像上述功能，在C++当中使用 类模板就可以很方便的实现：
template<class T>
class Stack
{
public:
Stack(size_t a = 3)
{
cout << "Stack(size_t a = 1)" << endl;
_array = new T[capacity];
if (_array == NULL)
{
perror("malloc fail");
return;
}
_capacity = a;
_size = 0;
}
~Stack()
{
cout << "~Stack()" << endl;
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
protected:
T* _array;
int _size;
int _capacity;
};那么对于上述实现的类模板，我们就可以这样来使用 这些类了：
int main()
{
Stack<int> s1;
Stack<char> s1;
Stack<double> s1;
return 0;
}因为我们上述类的构造函数，没有使用 T 这个模板参数，所以，构造函数不一定都要 使用 类模板当中 参数，其实构造函数就不一定需要 使用 推演，像上述的初始化方式函数很香的。
那么类模板当中也可以传入多个参数，如果我们有需求的话。
对于 template 类模板的作用范围就是这个类。
如果类模板当中的成员函数在类外面 定义的话，和普通类的 类外定义有些许不一样。
- 首先，因为 对于 template 类模板的作用范围就是这个类 那么当我们类外定义的时候，编译器就不认识函数当中的 T 这个模板参数了。所以我们在类外进行 定义成员函数的时候，需要给这个函数重新声明这个 T 模板参数。
- 其次，对于普通类，类名就是类型，我们在调用普通类的时候，都是直接使用 类名来作为这个 对象的 类的类型的；但是 模板类的类名不是类型，类模板的类型是 类名<模板类型> 这样的形式。所以，我们在 用 " :: " 来指明 这个函数是哪一个 域当中函数的时候，需要使用 类名<模板类型> 这样的方式来表明这个函数的域。
那么根据上述两点，我们在类模板外声明 其中的成员函数的时候，应该这样来实现：
template <class T>
Stack<T>::Stack()
{
cout << "Stack(size_t a = 1)" << endl;
_array = new T[capacity];
if (_array == NULL)
{
perror("malloc fail");
return;
}
_capacity = a;
_size = 0;
}