首页 > 代码库 > 函数模板，函数模板重载，可变参数模板，函数模板覆盖，通过引用交换数据
函数模板，函数模板重载，可变参数模板，函数模板覆盖，通过引用交换数据
1.函数模板初级，如果想使用模板，需要实例化，实例化的方式是加上<数据类型>
#include<iostream>
//函数模板可以对类型进行优化重载，根据类型会覆盖
//如果仍然要使用模板函数，需要实例化
template<classT>
Tadd(Ta,Tb)
{
std::cout << "T add " <<std::endl;
returna +b;
}
intadd(inta,intb)
{
std::cout << "int add " <<std::endl;
returna +b;
}
voidmain()
{
inta = 10,b = 20;
doubledb1 = 10.9,db2 = 10.8;
add(db1,db2);
add(a,b);
//这里加上了<int>相当于实例化，调用了模板
add<int>(a,b);
std::cin.get();
}
运行结果如下：
2.模板的重载，模板的重载会根据数据类型自动匹配
#include<iostream>
#include<array>
usingstd::array;
template<typenameT>
voidshowarray(array<T, 10> myarray,intn)
{
usingnamespacestd;
cout <<"TTTTT" <<endl;
for (inti = 0;i <n;i++)
{
cout <<myarray[i] << " ";
}
cout <<endl;
}
template<typenameT>
voidshowarray(array<T*, 10> myarray,intn)
{
usingnamespacestd;
cout <<"T*T*T*T*T*" <<endl;
for (inti = 0;i <n;i++)
{
cout << *myarray[i] << " ";
}
cout <<endl;
}
voidmain()
{
array<int, 10> intarray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
array<int*, 10> pintarray;
for (inti = 0;i < 10;i++)
{
pintarray[i] = &intarray[i];
}
array<int**, 10> ppintarray;
for (inti = 0;i < 10;i++)
{
ppintarray[i] = &pintarray[i];
}
showarray(intarray, 10);
showarray(pintarray, 10);
showarray(ppintarray, 10);
std::cin.get();
}
运行结果如下：
3.通用函数可变参数模板
#include<iostream>
//通用可变参数模板 处理不限定个数的参数，处理不同类型
//空函数，接口，用于最后结束递归 适用于新版本的编译器
voidshowall(){}
template<typenameT,typename...Args>
voidshowall(constT &value,constArgs &...args)
{
std::cout << value <<std::endl;
showall(args...); //继续传递
}
//设计可以修改原来的数据的T &value, Args&...args
//设计可以修改副本 T value, Args ...args
//设计不可以修改原来的数据，不可以修改副本const T value, const Args...args
//设计引用原来的数据不可以修改 const T &value, const Args &...args
voidmain()
{
intnum1 = 10,num2 = 9,num3 = 11;
doubledb1 = 10.8,db2 = 10.9;
charstr[40] ="yincheng";
charch =‘A‘;
showall(num1);
std::cout << "\n";
showall(num1,num2,num3);
std::cout << "\n";
showall(db1,db2,num1,ch);
std::cout << "\n";
showall(db1,db2,num1,ch,str);
std::cin.get();
}
运行截图如下：
4.函数模板覆盖，并实现参数互换
#include<iostream>
//函数模板实现通用，可以根据自有数据类型，进行优化
//结构体和类没有私有变量时才可以直接赋值初始化
//所有成员都是公有的类型可以赋值初始化
structinfo
{
charname[40];
doubledb;
intdata;
};
template<typenameT>
voidswap(T &a,T &b)
{
std::cout << "通用函数模板" << std::endl;
Ttemp =a;
a =b;
b =temp;//交换变量
}
//模板为空，明确参数类型，覆盖函数模板的类型
//template<> //这里可有可无
voidswap(info &info1,info &info2)
{
std::cout << "特有函数模板" << std::endl;
//通过模板可以实现通用，针对自己的数据类型做出优化
infotemp =info1;
info1 =info2;
info2 =temp;
}
voidmain()
{
infoinfo1 = {"tuzuoquan",20.9,10};
infoinfo2 = {"quanzuotu",9.2,1 };
swap(info1,info2);
std::cout << info1.name << info1.db << info2.data << std::endl;
std::cout << info2.name << info2.db << info2.data << std::endl;
std::cin.get();
}
运行结果：
5.通过引用的方式实现参数互换
#include<iostream>
//函数模板实现通用，可以根据自有数据类型，进行优化
//结构体和类没有私有变量时才可以直接赋值初始化
//所有成员都是公有的类型可以赋值初始化
template<typenameT>
voidswap(T &a,T &b)
{
std::cout << "通用函数模板" << std::endl;
Ttemp =a;
a =b;
b =temp;//交换变量
}
voidmain()
{
intnum1 = 100;
intnum2 = 10;
swap(num1,num2);//实现交换
std::cout << num1 <<" " <<num2 <<std::endl;
char ch1 =‘Z‘;
char ch2 =‘A‘;
//注意，要指定使用模板，这里要使用<类型名称>
swap<char>(ch1,ch2);
std::cout << ch1 <<" " <<ch2 <<std::endl;
std::cin.get();
}
6.可变参数模板
#include<iostream>
#include<cstdarg>
voidshowall(){} //预留一个
template <typenameT>
voidshow(Tt, ...)
{
std::cout << t <<std::endl;
}
template <typenameT,typename...Args>
voidshowall(Tt,Args...args)
{
std::cout << t <<std::endl;
showall(args...);
}
voidmain()
{
intnum1 = 10,num2 = 9,num3 = 11;
doubledb1 = 10.8,db2 = 10.9;
charstr[40] ="yincheng";
charch =‘A‘;
show(num1);
showall(num2,num3);
showall(num2,num3,num1,str,ch);
std::cin.get();
}
运行结果如下：
