1.泛型编程
泛型编程:使用模板,编写跟类型无关的代码
如何实现一个通用的交换函数,int与int,double与double....
使用函数重载固然可以,可是代码太多,有点复杂,我们将使用C++的新东西,函数模板
2.函数模板
2.1概念
函数模板代表了一个函数家族,该函数模板与类型无关,在使用时被参数化,根据实参类型产生函数的特定 类型版本。
2.2函数模板格式
template<typename T1,typename T2...typename Tn>
template 返回值类型 函数名(参数列表){}
template<class T>
void Swap(T& a, T& b)
{
T tmp = a;
a = b;
b = tmp;
}
2.3 函数模板的原理
编译器根据调用函数模板和类模板的类型,实例化出对应的函数和类
2.4 函数模板的实例化
用不同类型的参数使用函数模板时,称为函数模板的实例化。模板参数实例化分为:隐式实例化和显式实例 化。
1.隐式实例化:让编译器自己根据实参推导模板参数的实际类型
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 1, a2 = 2;
double b1 = 1.11, b2 = 2.22;
//隐式实例化(编译器自己推导)
Add(a1, a2);
Add(b1, b2);
Add(a1, b1); //该语句不能编译通过,因为编译器将a1推导为int,b1推导为double,无法确定T到底为int还是double
解决办法:1.用户强制转化 2.使用显式实例化
Add(a1,(int)b1);
//显式实例化(指定T的类型)
Add<int>(a1, b1);
return 0;
}
2.显式实例化 :在函数名后的<>中指定模板参数的实际类型
int main()
{
int a = 1;
double b = 1.11;
//显式实例化(指定T的类型)
Add<int>(a, b);
return 0;
}
2.5 模板参数的匹配原则
1.一个非模板函数可以和一个同名的函数模板同时存在,而且函数模板还可以被实例化这个非模板函数
// 专门处理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版本
}
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函数
}
3.模板函数不允许自动类型转换,但普通函数可以进行自动类型转换
3.类模板
3.1类模板的定义格式
//顺序表
template<class T>
class vector
{
public:
vector()
:_a(nullptr)
,_size(0)
,_capacity(0)
{}
~vector()
{
delete[] _a;
_a = nullptr;
_size = _capacity = 0;
}
//在类中声明,在类外面定义
void push_back(const T& x);
T& operator[](size_t i)
{
assert(i < _size);
return _a[i];
}
size_t size()
{
return _size;
}
private:
T* _a;
size_t _size;
size_t _capacity;
};
// 注意:类模板中函数放在类外进行定义时,需要加模板参数列表
template <class T>
void vector<T>::push_back(const T& x)
{
//空间不够需要增容
if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
_capacity = newcapacity;
T* tmp = new T[_capacity];
if (_a)
{
memcpy(tmp, _a, sizeof(T)*_size);
delete[] _a;
}
_a = tmp;
}
_a[_size] = x;
_size++;
}
int main()
{
vector<int> v; //类模板实例化需要跟在类模板名字后面跟<>,然后将实例化的类型放在<>中即可
v.push_back(1);
v.push_back(2);
for (size_t i = 0; i < v.size(); ++i)
{
cout << v[i] << " ";
}
return 0;
}