泛型编程是指编写与类型无关的通用代码,可以提高代码的复用性。
模板是泛型编程的基础,分为函数模板和类模板。
函数模板
1、函数模板的格式:
template<typename T1, typename T2, ...>
返回值类型 函数名(参数列表)
{
}
其中typename为关键字,也可以是class(不能是struct)
2、函数模板的实例化
用不同的类型使用函数模板时,称为函数模板的实例化。
函数模板的实例化分为隐性实例化和显性实例化
1>隐式实例化
让编译器根据实参来推演函数模板参数的实际类型
template<class T>
T swap(const T& left, const T& right)
{
T tmp = left;
left = right;
right = tmp;
}
int main()
{
int a1 = 2, a2 = 4;
double b1 = 3.0, b2 = 6.0;
swap(2,4);//根据实参a1可以推演出T的类型为int
//swap(3.0,6.0);
system("pause");
return 0;
}
上述代码,当swap函数调用两次时,出现编译错误,由实参a1可以将T的类型推演为int ,由实参b1可以将T的类型推演为double,但是函数模板的参数列表只有一个T,所以不能确定T是int 类型还是double类型,故出现错误。
为了避免这种错误的出现,可以用以下两种方法解决:
①用户自己进行强制转化
②使用显示实例化
2>显式实例化
在函数名后的<>中指定模板参数的实际类型
int main()
{
int a1 = 2, a2 = 4;
double b1 = 3.0, b2 = 6.0;
swap<int>(2,4);//显示实例化
system("pause");
return 0;
}
3、模板参数的匹配原则
1>一个非模板函数可以和一个同名的函数模板同时存在,而且该函数模板还可以被实例化为这个非模板函数
template<class T>
T swap(const T& left, const T& right)
{
T tmp = left;
left = right;
right = tmp;
}
int swap( int left, int right)
{
int tmp;
tmp = left;
left = right;
right = tmp;
}
int main()
{
int a1 = 2, a2 = 4;
double b1 = 3.0, b2 = 6.0;
swap(2, 4);//与非函数模板匹配,不需要调用函数模板
swap<double>(2,4);//使用函数模板
system("pause");
return 0;
}
2> 对于非模板函数和同名函数模板,如果其他条件都相同,在调动时会优先调用非模板函数,如果模板可以产生一个具有更好匹配的函数, 那么将选择模板。
总之就是选择匹配性更高的函数(非模板函数或模板函数)。
template<class T>
T swap(const T& left, const T& right)
{
T tmp = left;
left = right;
right = tmp;
}
int swap( int left, int right)//非函数模板,若调用的函数与该函数同名且参数类型相同则调用该函数
{
int tmp;
tmp = left;
left = right;
right = tmp;
}
int main()
{
int a1 = 2, a2 = 4;
double b1 = 3.0, b2 = 6.0;
swap(2, 4);//调用非模板函数
swap<double>(2.0,4.0);//调用模板函数
system("pause");
return 0;
}
3>模板函数不允许自动类型转换,但普通函数可以进行自动类型转换
类模板
1、类模板的格式:
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};
2、类模板的实例化
类模板实例化需要在类模板名字后跟<>,然后将实例化的类型放在<>中即可,类模板名字不是真正的类,而实例化的结果才是真正的类。
int main()
{
vector<int> v1;//vector<int> 是类型
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
vector<double> v2;
v2.push_back(1.0);
v2.push_back(2.0);
v2.push_back(3.0);
system("pause");
return 0;
}