一、概念

       首先我们先看一下在C++中如果想要对两个整型数据交换、两个字符型数据交换和两个浮点型数据交换我们是如何实现的：

void Swap(int& x1, int& x2)
{
  int x = x1;
  x1 = x2;
  x2 = x;
}
void Swap(char& x1, char& x2)
{
  char x = x1;
  x1 = x2;
  x2 = x;
}
void Swap(double& x1, double& x2)
{
  double x = x1;
  x1 = x2;
  x2 = x;
}
int main()
{
  int a1 = 10, a2 = 20;
  char c1 = 'a', c2 = 'b';
  double d1 = 10.1, d2 = 20.1;
  cout << a1 << ' ' << a2 << endl;
  cout << c1 << ' ' << c2 << endl;
  cout << d1 << ' ' << d2 << endl;
  Swap(a1, a2);
  Swap(c1, c2);
  Swap(d1, d2);
  cout << a1 << ' ' << a2 << endl;
  cout << c1 << ' ' << c2 << endl;
  cout << d1 << ' ' << d2 << endl;
  return 0;
}

以上利用函数重载就可以实现，但是存在以下的问题：

       1. 重载的函数仅仅只是类型不同，代码的复用率比较低，只要有新类型出现时，就需要增加对应的函数；

       2. 代码的可维护性比较低，一个出错可能所有的重载均出错；

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

       C++就引入模板(template)，什么是模板呢？可以理解为活字印刷术，在古代，想要将诗文广为流传，古人可以通过人力，进行大量的抄写，但是费时费力；于是古人就想到用一块板，讲这些字刻下来，直接用白纸进行印刷，不仅提高效率，而且字迹一模一样；实用性很强；

       C++的模板也是这个道理，每个函数中函数名相同，返回值相同，功能相同，只有类型不同；那么这个类型不同不就相当于你要印刷什么颜色的字。

以上也就说明了，C语言是不支持泛型编程；

二、模板的分类

C++中模板分为两类：函数模板和类模板

2.1函数模板

       函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.1.1函数模板格式

template<class T>//这里的T是
//这里class T也可以写成typename T
//T是模板的名字，可以进行修改
void Swap( T& left, T& right) //在这个函数中，类型变成了T，它是何种类型取决于实参
{
     T temp = left;
     left = right;
     right = temp; 
}

2.1.2函数模板的原理

       函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

template <class T>
void Swap(T& x1, T& x2)
{
  T x = x1;
  x1 = x2;
  x2 = x;
}
int main()
{
  int a = 0, b = 1;
  char c = 'a', d = 'd';
  cout << a << b << c << d << endl;
  Swap(a, b);
  Swap(c, d);
  cout << a << b << c << d << endl;
  return 0;
}

2.1.3函数模板的实例化

       用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

① 隐式实例化 —— 让编译器根据实参推演模板参数的实际类型

template <class T>
T Add(const T& left, const T& right)
{
  return left + right;
}
int main()
{
  int a1 = 10, a2 = 20;
  double d1 = 10.1, d2 = 20.2;
  cout << Add(a1, a2) << endl;
  cout << Add(d1, d2) << endl;
  return 0;
}

需要注意：不能把不同类型的参数传入一个函数模板中。

       在编译期间，当编译器看到该实例化时，需要推演其实参类型通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错

       注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅

Add(a1, d2);
//使用强制类型转换
Add(a1, (int)d2);

②显示实例化 —— 在函数名后的<>中指定模板参数的实际类型

在上述代码中除了采用强制类型转换，还可以用显示实例化来解决不同参数传参的问题；

//使用显示实例化
Add<int>(a1, d2);
Add<double>(a1, d2);

2.1.4模板参数的匹配原则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数；

//专门处理int的加法函数
int Add(int left, int right)
{
  return left + right;
}
//通用加法函数
template<class T1,class T2>
T1 Add(T1 left, T2 right)
{
  return left + right;
}
int main()
{
  int a1 = 10, a2 = 20;
  double d1 = 10.1, d2 = 20.2;
  cout << Add(a1, a2) << endl;//当函数模板 和 普通函数同时出现的时候，它会优先调用普通函数
  cout << Add(d1, d2) << endl;
  return 0;
}

对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板；

强调：模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

2.2类模板

2.2.1 类模板的定义格式  

template<class T1, class T2, ..., class Tn>
class 类模板名
{
 // 类内成员定义
};

       当我们想用栈来存储不同类型时，我们常用的是将类型（int、char...）进行typedef，但是在同一个程序中当你想要在创建的第一个栈中存储int，创建的在第二个栈存储char时，是做不到的；针对这种强狂C++引入类模板。

template <class T>
class Stack
{
public:
  Stack(int capacity = 4)
    :_top(0)
    , _capacity(capacity)
  {
    _a = new T[capacity];
  }
  void Push(const T& x);
  ~Stack()
  {
    delete[] _a;
    _a = nullptr;
    _capacity = _top = 0;
  }
private:
  T* _a;
  int _top;
  int _capacity;
};
template <class T>//类成员函数在类中声明，当在类外定义时，需要加模板参数列表
void Stack<T>::Push(const T& x)
{
  /********/
}
int main()
{
    // Stack---类名
    // Stack<int>等---类型
  Stack<int> st1;    //存储int
  Stack<double> st2; //存储double
  Stack<char> st3;   //存储char
  return 0;
}

2.2.2类模板的实例化  

       （主函数中）类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

// Stack类名，Stack<int>、Stack<double>、Stack<char>才是类型
Stack<int> st1; 
Stack<double> st2; 
Stack<char> st3;