c++的函数模板
首先为什么要引进函数模板?我们来看一个案例:
我们在这儿想要实现一个通用的交换数据的函数
void Swap(int left, int right)
{
int temp = left;
left = right;
right = temp;
}
void Swap(char left, char right)
{
char temp = left;
left = right;
right = temp;
}
void Swap(double left, double right)
{
double temp = left;
left = right;
right = temp;
}
- 以上的代码我使用了函数重载的方式,为了要尽可能多的来满足所有类型的元素,但是很明显,是不行的。因为类型实在太多了,如果使用函数重载的话,恐怕有点难为情。
- 所以c++就引入了函数模板
- 函数模板的格式
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}
- 那让我们再来通过模板来实现上面的元素交换
template<typename T>
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
有一点需要注意:typename是用来定义模板参数关键字,也可以使用class(切记:不能使用struct代替class)
- 现在我来介绍一下模板函数的用法。
- 我们看到 template< typename T>这句话,其中template 是模板的意思,typename 是类型名,而T呢,只能算是一个参数吧,可以换成其他的也可以,为什么要用T,只是因为大家都用T用习惯了,所以你随便用。同时也支持模板中多种类型,例如:template< class T1, class T2>;两个参数可以,三个也行,没有上限。
- 让我们再来理解一下,上面的三个重载函数中,除了类型int/double/char 之外,别的代码都是相同的,那么用T 把int/double/char替换掉就是模板函数了。那么你可以简单的把T 认为是一个类型。
- 再让我们看看代码
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
Add(a1, a2);
Add(d1, d2);
/*
该语句不能通过编译,因为在编译期间,当编译器看到该实例化时,需要推演其实参类型
通过实参a1将T推演为int,通过实参d1将T推演为double类型,但模板参数列表中只有一个T,
编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意:在模板中,编译器一般不会进行类型转换操作,因为一旦转化出问题,编译器就需要背黑锅
Add(a1, d1);
*/
// 此时有两种处理方式:1. 用户自己来强制转化 2. 使用显式实例化
Add(a, (int)d);
return 0;
}
- 上面的main函数中Add(a1,a2);调用的时候,函数模板就会创建一个int 类型的相加函数,就是把函数模板中的T 替换成int 类型。此时就会创建出一个int类型相加的函数。
- 那么我们说函数模板并不是函数,只是一个模板,只有在实例化的时候,编译器才会创建相应类型的函数。
int main(void)
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
return 0;
}
- 上面的Add< int>(a, b) ,为什么要加上< int>呢?就是为了要函数模板成为int类型的函数,不管我的a和b是什么类型,都会转换成int类型的。
// 专门处理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<int>(1, 2); // 调用编译器特化的Add版本
}
- 上面的代码中既有模板函数,又有一般的int类型的函数,那么在如果Add(1,2); 那么首先选择与非模板函数去匹配,因为在编译阶段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(1, 2.0); // 模板函数可以生成更加匹配的版本,编译器根据实参生成更加匹配的Add函数
}
- 上面的代码主要看一下Add(1, 2.0); 首先套路,先看一般函数能不能匹配上,不能,要调用话只能强制类型转换,编译器先不会这样做,先看模板函数能不能匹配上,如果可以匹配上就不会强制类型转换,如果模板函数匹配不上,就会强制类型转换去调用一般函数。
- 最重要的一点:模板函数不允许类型转换,是啥就是啥,比较执着。但是一般函数就比较随意,编译器可以根据情况进行类型转换。
接下来再来说说类模板
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};
- 再来看看类模板代码
#include<iostream>
#include<assert.h>
using namespace std;
template<class T>
class Vector
{
public:
Vector(size_t capacity = 10)
: _pData(new T[capacity])
, _size(0)
, _capacity(capacity)
{}
// 使用析构函数演示:在类中声明,在类外定义。
~Vector();
void PushBack(const T& data)
{
// _CheckCapacity();
_pData[_size++] = data;
}
void PopBack()
{
--_size;
}
size_t Size()
{
return _size;
}
T& operator[](size_t pos)
{
assert(pos < _size);
return _pData[pos];
}
private:
T* _pData;
size_t _size;
size_t _capacity;
};
template <class T>
Vector<T>::~Vector()
{
if (_pData)
{
delete[] _pData;
}
}
int main()
{
Vector<int> s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
Vector<double> s2;
s2.PushBack(1.0);
s2.PushBack(2.0);
s2.PushBack(3.0);
for (size_t i = 0; i < s1.Size(); ++i)
{
cout << s1[i] << " ";
}
cout << endl;
for (size_t i = 0; i < s2.Size(); ++i)
{
cout << s2[i] << " ";
}
cout << endl;
return 0;
}
- 上面的代码就是类模板的一些方法。