发布时间：2023-11-07 14:00
模板就是建立通用的模具，大大提高复用性
模板的特点：
1）模板不可以直接使用，它只是一个框架
2）模板的通用并不是万能的
C++的另一种编程思想称为“泛型编程”，主要利用的技术就是模板。
C++提供两种模板机制：函数模板和类模板。
作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟类型来代表。
语法：template
template — 声明创建模板；
typename — 表明其后面的符号是一种数据类型，可以用class代替；
T — 通用的数据类型，名称可以替换，通常为大写字母
//交换整型函数
void swapInt(int &a ,int &b)
{
int temp=a;
a=b;
b=temp;
}
//交换浮点型函数
void swapDouble (double &a ,double &b)
{
double temp=a;
a=b;
b=temp;
}
//利用模板提供通用的交换函数
template<typename T>
void myswap(T &a ,T &b)
{
T temp=a;
a=b;
b=temp;
}
void test()
{
int a=10;
int b=20;
//利用模板实现交换
//1.自动类型推导
myswap(a,b);
//2.显示指定类型
myswap<int>(a,b);
cout<<....<<endl;
}
int main(){...}
总结：
1）函数模板利用关键字 template
2) 使用函数模板有两种方式：自动类型推导、显示指定类型
3) 模板的目的是为了提高复用性，将类型参数化
1）自动类型推导，必须推导出一致的数据类型T，才可以使用；
2）模板必须确定出T的数据类型，才可以使用
//利用模板提供通用的交换函数
template<class T>
void myswap(T &a ,T &b)
{
T temp=a;
a=b;
b=temp;
}
//1.自动类型推导，必须推导出一致的数据类型T，才可以使用
void test01()
{
int a=10;
int b=10;
char c ='c';
myswap(a,b); //正确，可以推导出一致T
myswap(a,c); //错误，推到不出一致的T类型
}
template <class T>
void func()
{
cout<<"func调用"<<endl;
}
void teTst02()
{
//func(); 错误，模板不能独立使用，必须确定出T的类型
func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板
}
int main()
{... ...}
案例描述：利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序，排序规则从大到小，排序算法为选择排序，分别利用char 数组和int 数组进行测试。
template <typename T>
void mysort (T arr[] ,int len)
{
for(int i=0;i<len;i++)
{
int max =i; //认定最大值的下标
for(int j=i+1;j<len;j++)
{
/*认定的最大值比遍历出的数值要小，
说明j下标的元素才是真正的最大值*/
if(arr[max]<arr[j])
{
max=j ; //更新最大值下标
}
}
if(max!=i) //如果最大数的下标不是i,交换两者
{
myswap(arr[max],arr[i]);
}
}
}
template<class T>
void printArray (T arr[] ,int len)
{
for(int i=0;i<len;i++)
{
cout<<arr[i]<<" "<<endl;
}
}
1）普通函数调用时可以发生自动类型转换（隐式类型转换）
2）函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
3）如果利用显示指定类型的方式，可以发生隐式类型转换
//普通函数
int myAdd01(int a,int b)
{
return a+b;
}
//函数模板
template<class T>
T myAdd02(T a ,T b)
{
return a+b;
}
//使用函数模板时，如果用自动类型推导，不会发生自动类型转换，即隐式类型转换
void test01()
{
int a=10;
int b=20;
char c ='c';
cout<<myadd01(a,c)<<endl; //正确，将char类型的'c'隐式转换为int类型，'c'对应ASCII码99
//myadd02(a,c); 报错，使用自动类型推导时，不会发生隐式类型准换
myadd02<int>(a,c); //正确，如果用显示指定类型，可以发生隐式类型转换
}
int main() {...}
总结：建议使用显式指定类型的方式，调用函数模板，因为可以自己确定通用类型T
1） 如果函数模板和普通函数都可以实现，优先调用普通函数
2）可以通过空模板参数列表来强制调用函数模板
3） 函数模板也可以发生重载
4) 如果函数模板可以产生更好的匹配，优先调用函数模板
myprint<>(a,b); //通过空模板参数列表来强制调用函数模板
template <typename T>
void myprint (T a, T b)
{
... ...
}
template <typename T>
void myprint (T a, T b, T c) //函数模板也可以发生重载
{
... ...
}
总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性。
模板的通用性并不是万能的
例如：
template <class T>
void f(T a, T b)
{
a=b;
}
在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了，或传入的是像Person这样的自定义数据类型，也无法正常运行。
模板的重载，可以为这些特定的类型提供具体化的模板。
具体化，显示具体化的原型，以template<>开头，并通过名称来指出类型；
具体化优先于常规模板。
template<>bool myCompare(Person &p1 ,Person &p2)
if(p1.m_Name==p2.m_Name && p1.m_Age==p2.m_Age)
{
return true;
}
else
{
return false;
}
总结：利用具体化的模板，可以解决自定义类型的通用化。学习模板并不是为了写模板，而是在STL能够运用系统提供的模板。