若想实现各种类型的swap
函数,使用函数重载虽然可以实现,但是有一下几个不好的地方:
为了解决上述情况,C++设计出了模板,给模板传递不同的类型,然后根据类型实例化出不同类型的代码。
泛型编程:编写与类型无关的通用代码,是代码复用的一种手段。模板是泛型编程的基础。
函数模板代表了一个函数家族,该函数模板与类型无关,在使用时被参数化,根据实参类型产生函数的特定类型版本。
语法如下:
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}
注意:typename是用来定义模板参数关键字,参数是类型,也可以使用class(切记:不能使用struct代替class)
template<typename T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
用不同类型的参数使用函数模板时,称为函数模板的实例化。模板参数实例化分为:隐式实例化和显式实例化。
template<typename T>
void Swap(T& left, T& right) {
T temp = left;
left = right;
right = temp;
}
int main() {
int a = 0, b = 1;
double c = 1.1, d = 2.2;
Swap(a, b);
Swap(c, d);
return 0;
}
实际调用时,编译器会根据传入的参数类型,通过模板实例化出一个整形和一个浮点型的交换函数,两次调用的分别是实例化出的对应类型的函数,而不是那个模板。
函数模板是一个蓝图,它本身并不是函数,是编译器通过传递给模板函数不同的类型产生特定具体类型函数的模具
所以其实模板就是将本来应该自己做的重复的事情交给了编译器
这种情况会报错:
int main() {
int a = 0;
double c = 1.1;
Swap(a, c);
return 0;
}
因为在编译期间,当编译器看到该实例化时,需要推演其实参类型
通过实参a将T
推演为int
,通过实参c将T推演为double
类型,但模板参数列表中只有一个T
, 编译器无法确定此处到底该将T
确定为int
或者 double
类型而报错。
此时有两种处理方式:1. 自己来强制转化 2. 使用显式实例化
1.自己强转
Add(a, (int)d);
指定类型进行实例化:
int main(void)
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
Add<double>(a, b);
//在函数名后的<>中指定模板参数的实际类型
return 0;
}
这里是直接让编译器生成指定类型的模板函数,不需要进行推演。
有些函数无法自动推演,只能显式初始化
在编译器编译阶段,对于模板函数的使用,编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
// 与非模板函数匹配,编译器不需要特化
Add(1, 2);
// 调用编译器实例化的Add版本
Add<int>(1, 2);
}
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
return left + right;
}
void Test()
{
// 与非函数模板类型完全匹配
// 不需要函数模板实例化
Add(1, 2);
// 模板函数可以生成更加匹配的版
// 编译器根据实参生成更加匹配的Add函数
Add(1, 2.0);
}
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};
定义一个类模板:
// 类模板
template<class T>
class Stack
{
public:
Stack(size_t capacity = 3);
void Push(const T& data);
// 其他方法...
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
T* _array;
int _capacity;
int _size;
};
这里的Stack
类,并不是一个真正的类型,而是一个模板,要给这个模板传递不同类型的参数,编译器才会根据参数来实例化出不同类型的模板类。
类模板实例化与函数模板实例化不同,类模板实例化需要在类模板名字后跟<>,然后将实例化的类型放在<>中即可,类模板名字不是真正的类,而实例化的结果才是真正的类。
int main()
{
Stack<int> s1; // int
Stack<double> s2; // double
Stack<char> s3; // char
return 0;
}
与普通类的分离方式不同,由于普通类的类名就是类型,所以在外定义时直接指定类型::成员函数即可,但是对于类模板实例化出来的类,类名是类名,类型是类型,两者并不相同,定义分离的方式如下:
template<class T>
Stack<int>::Stack() {
//...
}
template<class T>
void Stack<int>::Push(const T& data) {
//...
}
在类外定义的成员函数都要加上对应的模板参数。
注意模板的作用范围是下面最近的一个函数或者类