目录
1.泛型编程
2.模板
3函数模板
3.1函数模板的概念
3.2函数模板的格式
3.3函数模板的原理
3.4函数模板的实例化
3.4.1隐式实例化：让编译器根据实参推演模板参数的实际类型
3.4.2显示实例化：在函数名后的<>中指定模板参数的实际类型
3.4.3模板参数的匹配原则
4.类模板
4.1类模板的定义
4.2类模板的格式
4.3类模板的原理
4.3类模板的实例化
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;
}
......
上述代码完成的是不同类型的变量间的交换操作，
可，这看着就有些麻烦，难写，因为，有多少种类型就需要写多少个函数
即使可以ctrl+c/ctrl+v，但仍存在下列问题：
1. 重载的函数仅仅是类型不同，代码复用率比较低，
只要有新类型出现时，就需要用户自己增加对应的函数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错
由此，泛型编程产生了：
通过类型参数(即类型是一个参数)来创建函数或数据结构，
使得同一套代码可以适用于多种数据类型的编程范式就叫做泛型编程
template<typename T>
void Swap(T& x1, T& x2)
{
T temp = x1;
x1 = x2;
x2 = temp;
}上述代码通过使用模板，将类型参数化，就可以实现多种类型的变量间的交换操作
模板是泛型编程的基础
2.模板
上述浇筑过程中存在一个模具，通过给这个模具中填充不同材料，可以获得不同材料的铸件
C++中的模板就可以被视为一个模具，不同类型可以视为不同材料
本文介绍模板的两种主要形式：函数模板与类模板
3函数模板
3.1函数模板的概念
函数模板是一个与具体数据类型无关的通用函数定义
具体来说就是，函数模板代表了一个函数家族
该函数模板中的类型被参数化，编译器根据实参类型产生函数的特定类型版本
3.2函数模板的格式
// 模板参数列表
template<typename T1, typename T2,......,typename Tn>
// 函数模板定义
返回值类型 函数名(参数列表){}
template<typename T>
void Swap(T& x1, T& x2)
{
T temp = x1;
x1 = x2;
x2 = temp;
}第一行写的是模板参数列表
template是定义模板的关键字，
typename是定义模板参数的关键字，
也可以用class定义模板参数，但不能用struct，如下：
template<class T1, class T2,......,class Tn>第二行开始写函数模板，此时根据需要，将类型参数化
3.3函数模板的原理
函数模板是一个蓝图，不是函数，
它是编译器根据实参类型产生特定类型函数的模具
所以其实模板就是将本来应该我们做的重复的事情交给了编译器
在编译器编译阶段：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此
3.4函数模板的实例化
编译器根据实参类型产生特定类型函数的过程就称为函数模板的实例化
简单来说，函数模板的实例化就是通过函数模板生成一个函数，
函数模板实例化分为：隐式实例化和显式实例化
3.4.1隐式实例化：让编译器根据实参推演模板参数的实际类型
此时，确保实参类型一致即可
template<typename T>
T Add(const T& x1, const T& x2)
{
return x1 + x2;
}
int main()
{
int a = 1, b = 2;
double c = 3.0, d = 4.0;
Add(a, b);
Add(c, d);
return 0;
}
这时候，有两种办法:1.强制类型转化
这里需要注意：强制类型转化会产生临时变量，临时变量具有常性
此时参数列表就必须要用const修饰，否则编译不通过。
而最开始用const修饰的初心是防止数据被修改
2.显式实例化
3.4.2显示实例化：在函数名后的<>中指定模板参数的实际类型
Add<int>(a, c);3.4.3模板参数的匹配原则
1.一个非模板函数可以和一个同名的函数模板同时存在
而且该函数模板还可以被实例化为这个非模板函数
template<typename T>
T Add(const T& x1, const T& x2)
{
return x1 + x2;
}
int Add(int& x1, int& x2)
{
return x1 + x2;
}
这就是上面说的同时存在
int main() { Add(1, 2); Add<int>(1, 2); return 0; }第一次调用的函数，与非模板函数匹配，直接调用非模板函数，编译器不需要特化
第二次调用的函数是编译器特化的Add版本
这就是上面说的实例化
2.对于非模板函数和同名函数模板的调用，
如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模 板产生出一个实例
如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
int main() { Add(1, 2); Add(1, 2.0); return 0; }第一次调用的函数，与非模板函数匹配，直接调用非模板函数，编译器不需要特化
第二次调用的函数是编译器特化的Add版本，因为此时才更加匹配
3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
在这里，编译器无法推导出T的具体类型，不会自动转换a或者c的类型
除非显式指定或者强制类型转换,不然编译器会直接报错
Add<int>(a, c); Add(a, (int)c);void foo(double d) {} foo(42); // int→double隐式转换普通函数就支持自动类型转换
模板函数是类型生成机制，而普通函数是类型匹配机制。模板在编译期"雕刻"类型，普通函数在运行时"适配"类型。这种设计使得模板既能保持类型安全，又能通过特化和重载提供灵活性，而普通函数则通过隐式转换维持编程的便利性 --------文心一言
4.类模板
4.1类模板的定义
类模板是一个与具体数据类型无关的通用类定义
具体来说就是，类模板代表了一个类家族
该类模板中的类型被参数化，编译器根据实参类型产生类的特定类型版本
4.2类模板的格式
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};第一行写的是模板参数列表
template是定义模板的关键字，
typename是定义模板参数的关键字，
也可以用class定义模板参数，但不能用struct，如下：
template<class T1, class T2,......,class Tn>第二行开始写类模板，此时根据需要，将类型参数化
template <class T>
Vector<T>::~Vector()
{
if(_pData)
delete[] _pData;
_size = _capacity = 0;
}注意：类模板中函数放在类外进行定义时，需要加模板参数列表，同时指定类模板
4.3类模板的原理
类模板不是一个类，类模板的原理与函数模板的原理相同，
就是将本来应该我们做的重复的事情(识别参数类型)交给了编译器
4.3类模板的实例化
简单来说，类模板的实例化就是通过模板生成一个具有特定数据类型的类
// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<> 中即可，类模板名字不是真正的类，而实例化的结果才是真正的类
总结：
对于普通类来说，类名(类模板名)与类型一致
对于模板类来说，类名就是类模板名，类型还需要指定参数列表
