模板
记得我们之前写过的交换函数,如果我们要交换两个整形,需要写一个参数为整形的Swap函数,如果要交换两个字符型,那又要写一个参数为char的Swap函数,等等。那这样就很麻烦,那有没有一种通用的东西可以不考虑类型呢?那就是模板。
一、泛型编程
泛型编程:编写与类型无关的通用代码,是代码复用的一种手段。模板是泛型编程的基础。
首先看下面的代码:
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;
}
//......
这几个函数构成了函数重载,但是重载的函数仅仅只是类型不同,代码的复用率比较低,只要有新类型出现时,就需要增加对应的函数。同时代码的可维护性比较低,一个出错可能所有的重载均出错。
二、函数模板
1.函数模板概念
函数模板代表了一个函数家族,该函数模板与类型无关,在使用时被参数化,根据实参类型产生函数的特定类型版本。
2.函数模板格式
template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){}
这就是一个模板函数,不用考虑类型。
template<typename T>
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
调用的时候就直接传递需要交换的变量即可。
int main()
{
int a = 10, b = 20;
char c = 1, d = 2;
Swap(a, b);
Swap(c, d);
return 0;
}
注意:typename是用来定义模板参数关键字,也可以使用class(切记:不能使用struct代替class)
3.模板的原理
模板是一个蓝图,它本身并不是函数,是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
如上图所示,当我们调用Swap(d1,d2);
时,编译器通过我们写的模板Swap函数会推演出一份代码,实现出double类型的交换,当我们调用Swap(i1,i2);
时,又会推演出int类型的交换,当我们调用Swap(a,b);
时,又会推演出char类型的交换,这个过程就叫做模板的推演,调用模板函数的时候就是模板函数的实例化。
4.模板的实例化
用不同类型的参数使用函数模板时,称为函数模板的实例化。模板参数实例化分为:隐式实例化和显式实例化。
- 隐式实例化
让编译器根据实参推演模板参数的实际类型
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
Add(a1, a2);//编译器自行推演类型
Add(d1, d2);
- 显示实例化
用户自己显示的定义类型。在函数名后的<>中指定模板参数的实际类型
int a = 10;
double b = 20.0;
Add<int>(a, b);//显式实例化
如果类型不匹配,编译器会尝试进行隐式类型转换,如果无法转换成功编译器将会报错。
5.模板参数的匹配原则
- 一个非模板函数可以和一个同名的函数模板同时存在,而且该函数模板还可以被实例化为这个非模板函数
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
//与非模板函数匹配,编译器不需要实例化(因此调用的是专门处理int的加法函数)
Add(1, 2);
//调用编译器实例化出的Add版本(这里是显示实例化,调用的是模板加法函数,然后实例化为int)
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);
}
- 模板函数不允许自动类型转换,但普通函数可以进行自动类型转换
三、类模板
1.类模板的定义格式
class 类模板名
{
// 类内成员定义
};
2.类模板的实例化
定义一个类模板,实现一个Vector,这个Vector可以存放的类型由我们自己指定
#include <assert.h>
template <class T>
class Vector
{
public:
Vector(int capacity=10)
:_a(new T[capacity])
, _size(0)
, _capacity(capacity)
{}
//析构函数:在类中声明,在类外定义
~Vector();
void PushBack(const T& x)
{
//这里要有容量检查,空间不够要增容(暂时省略)
_a[_size] = x;
_size++;
}
void PopBack()
{
_size--;
}
size_t size()
{
return _size;
}
T& operator[](size_t pos)
{
assert(pos < _size);
return _a[pos];
}
private:
T* _a;
size_t _size;
size_t _capacity;
};
template <class T>
Vector<T>::~Vector()
{
if (_a)
{
delete[] _a;
_size = _capacity = 0;
}
}
实例化的过程:
int main()
{
Vector<int> v1;//该Vector存放int类型的数据
v1.PushBack(1);
v1.PushBack(2);
v1.PushBack(3);
v1.PushBack(4);
for (size_t i=0; i<v1.size();i++)
{
std::cout << v1[i] << " ";
}
std::cout << std::endl;
Vector<char> v2;//该Vector存放char类型的数据
v2.PushBack('a');
v2.PushBack('b');
v2.PushBack('c');
for (size_t i = 0; i<v2.size(); i++)
{
std::cout << v2[i] << " ";
}
std::cout << std::endl;
system("pause");
return 0;
}
输出结果:
这就实现了泛型编程,我们要存放两种类型的数据时就可以创建两个Vector对象,编译器就会自动实例化,这样就增强了代码的复用性。