泛型编程
 

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础
 

模板分为：函数模板和类模板

函数模板
 

概念

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

格式
 

template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}

typename是用来定义模板参数关键字，也可以使用class，但不能用struct来代替class

示例：

编译器会用模板实例化生成对应的 Swap函数       

template<class T>
//template<typename T> 也ok
void Swap(T& p1, T&p2)
{T tmp = p1;p1 = p2;p2 = tmp;
}

int main()
{int i = 0;int j = 1;Swap(i, j);cout << i << " " << j << endl;double m = 4.8;double n = 9.8;Swap(m, n);cout << m<< " " << n << endl;return 0;
}

 int类和double类调用的不是同一个函数，虽然调试表面上进入的是同一个Swap，但通过反汇编就可以清楚二者进入的是各自的Swap函数了

 

函数模板本身并不是函数，只是一个蓝图，给编译器准备的，让编译器承担原本应由我们来重复做的事情 ，就像写Swap函数一样，要用Swap函数实现不同类型的交换，可以使用函数重载，那就需要我们去手动写int类型的Swap，double类型的Swap等等，但是函数模板的出现将这些事情交给了由编译器实现，我们只需要写一份模板，剩下的事就不用我们操心了，编译器来承担

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

 函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化
 

模板参数实例化分为：隐式实例化和显式实例化

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

template<class T>
T Add(const T& a, const T& b)
{return a + b;
}int main()
{int a = 1;int b = 2;cout << Add(a, b) << endl;double c = 6.6;double d = 4.8;cout << Add(c, d) << endl;return 0;
}

用int类型的a，b参数去使用函数模板，让函数模板实例化，在编译期间，编译器通过实参a，将T推演成int，通过实参b，将T推演成int，double类型的c，d参数同理

但是以下情况是会报错的：

通过a将T推演成int，通过c又将T推演成double，且模板参数列表中只有一个T
所以编译器无法确定此处到底该将T确定为int 还是 double类型而报错

而且要注意的是在模板中，编译器一般不会进行类型转换操作

解决方法：一是用户自己来实现强制类型转换，统一类型

                  二是使用显式实例化
一：

cout << Add((double)a, c) << endl;//都可以cout << Add(a,(int) c) << endl;

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

	int a = 9;double b = 8.8;// 显式实例化Add<int>(a, b) 

模板参数的匹配原则
 

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

//专门处理int类型的加法函数
int Add(const int& a, const int& b)
{return a + b;
}//通用的加法函数
template<class T>
T Add(const T& a, const T& b)
{return a + b;
}int main()
{cout<<Add(1, 2);return 0;
}

对于整型1，2的相加，只会去调用非模板函数

想要它去使用模板函数，可以这样处理：

	Add<int>(1, 2);

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

int Add( const int& a, const int& b)
{return a + b;
}template<class T1,class T2>
T1 Add(const T1& a, const T2& b)
{return a + b;
}int main()
{Add(1, 2);Add(1, 2.4);return 0;
}

对于Add(1,2),调用非模板函数

 对于Add(1,2.4)选择使用函数模板

3. 模板函数不允许自动类型转换（即隐式类型转换），但普通函数可以进行自动类型转换
 

类模板
 

类模板的定义格式
 

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

示例： 

template<class T>
class Stack
{
public:Stack(size_t capacity = 10):_a(new T[capacity]),_size(0),_capacity(capacity){}~Stack(){delete[] _a;_a = nullptr;_size = _capacity = 0;}void Push(const T& data){// CheckCapacity();_a[_size] = data;_size++;}
private:T* _a;int _size;int _capacity;
};int main()
{Stack<int>st1;Stack<double>st2;return 0;
}

在类中声明，在类外定义：

注意：类模板中函数放在类外进行定义时，需要加模板参数列表
只能在同一个文件下进行类模板的声明和定义分离，声明和定义放在不同的文件中会报错

这时我们需要明确：类名是类名，类型是类型

以往我们可以认为类名就是类型，但是在类模板中这点需要改变，二者是不一样的

用上面示例来说，类名是：Stack

                             类型是：Stack<T>
 

template<class T>
class Stack
{
public:Stack(size_t capacity = 10):_a(new T[capacity]),_size(0),_capacity(capacity){}~Stack();void Push(const T& data){// CheckCapacity();_a[_size] = data;_size++;}
private:T* _a;int _size;int _capacity;
};template<class T>
Stack<T>::~Stack()
{delete[] _a;_a = nullptr;_size = _capacity = 0;
}

类模板的实例化
 

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

    //Stack 类名   Stack<int>类型Stack<int>st1;Stack<double>st2;