泛型编程
泛型编程：编写与类型无关的通用代码 ，是代码复用的一种手段。模板是泛型编程的基础
模板分为：函数模板和类模板
函数模板
概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本
格式
cpp
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}typename 是用来定义模板参数关键字 ，也可以使用class，但不能用struct来代替class
示例：
编译器会用模板实例化生成对应的 Swap函数
cpp
template<class T>
//template<typename T> 也ok
void Swap(T& p1, T&p2)
{
T tmp = p1;
p1 = p2;
p2 = tmp;
}
cpp
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类型的代码
函数模板的实例化
用不同类型的参数使用函数模板时 ，称为函数模板的实例化
模板参数实例化 分为：隐式实例化和显式实例化
隐式实例化：让编译器根据实参推演模板参数的实际类型
cpp
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类型而报错
而且要注意的是在模板中，编译器一般不会进行类型转换操作
解决方法：一是用户自己来实现强制类型转换，统一类型
二是使用显式实例化
一：
cpp
cout << Add((double)a, c) << endl;//都可以
cout << Add(a,(int) c) << endl;
显式实例化：在函数名后的<>中指定模板参数的实际类型
cpp
int a = 9;
double b = 8.8;
// 显式实例化
Add<int>(a, b) 
模板参数的匹配原则
1 一个非模板函数 可以和一个同名的函数模板同时存在 ，而且该函数模板 还可以被实例化为这个非模板函数
cpp
//专门处理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的相加，只会去调用非模板函数
想要它去使用模板函数，可以这样处理：
cpp
Add<int>(1, 2);
2 对于非模板函数和同名函数模板 ，如果其他条件都相同 ，在调动时会优先调用非模板函数 而不会从该模板产生出一个实例。如果模板可以产生 一个具有更好匹配的函数 ， 那么将选择模板
cpp
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)选择使用函数模板
- 模板函数不允许自动类型转换（即隐式类型转换），但普通函数可以进行自动类型转换
类模板
类模板的定义格式
cpp
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};示例：
cpp
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>
cpp
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;
}类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化 需要在类模板名字后跟<> ，然后将实例化的类型放在<>中即可 ，类模板名字不是真正的类，而实例化的结果才是真正的类
cpp
//Stack 类名 Stack<int>类型
Stack<int>st1;
Stack<double>st2;