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;
}
- 上面的代码就是类模板的一些方法。