目录
一、泛型编程
泛型编程:与类型无关的通用代码,是代码复用的一种手段。可以理解为有一组通用的代码(模板)可以适应各种类型,而不局限于一种类型。模板分为函数模板和类模板。
引入:
#include <iostream>
using namespace std;
void swap(int& left, int& right)
{
int tmp = right;
right = left;
left = tmp;
}
void swap(double& left, double& right)
{
double tmp = right;
right = left;
left = tmp;
}
int main()
{
int a = 2, b = 3;
double c = 1.2, d = 2.3;
swap(a, b);
swap(c, d);
cout << a << " " << b << endl;
cout << c << " " << d << endl;
return 0;
}
分析:
1.实现不同类型交换函数,可以通过重载函数来达到目的,但是写重载函数就增加了代码量,复用率低。
2.这样就导致了代码的可维护性比较低,一个出错可能所有的重载均出错。
面对上述情况,接下来就可以引入一组通用代码(函数模板)来实现。
二、函数模板
2.1函数模板概念
函数模板代表一个函数家族 ,该函数模板跟类型无关,在使用时被参数化,根据实参类型产生函数的特定类型版本
函数模板格式:
template<typename T1,typename T2,....,typename Tn> 注意:T的名字随便取
返回值类型 函数名(参数列表){}
举例:
#include <iostream>
using namespace std;
template<typename P>
void Swap(P &left, P &right)
{
P tmp = right;
right = left;
left = tmp;
}
int main()
{
int a = 2, b = 3;
double c = 2.3, d = 3.2;
Swap(a, b);
Swap(c, d);
cout << a << " " << b << endl;
cout << c << " " << d << endl;
return 0;
}
上面例子就是一个模板, 用P表示一个泛型的类型,能够识别各种类型,传int类型,P就能识别他是int类型,传double类型,P就能够识别他是double类型,这些都是由编译器去完成的,我们只需传递想要表达的类型给它就行了。
注意:typename是定义模板参数的关键字,也可以使用class(切记:不能使用struct代替class)
2.2函数模板原理
用一张图来形象的表示函数模板的操作。
编译器会在编译阶段对模板类型进行检测,根据传入的实参类型来推演生成对应类型的函数以供调用。当char类型使用函数模板时,编译器则对实参类型进行推演,将T确定为char类型,然后产生一份专门处理char类型的代码,当为其他类型时亦是如此。
2.3函数模板的实例化
对于上述,用不同的类型的参数使用函数模板时,就称为函数模板的实例化。模板参数实例化又分为:隐式实例化和显示实例化
隐式实例化:让编译器根据实参类型自己去推演,而不是给模板指定类型。
#include <iostream>
using namespace std;
template<class T>
void Swap(T& left, T& right)
{
T tmp = right;
right = left;
left = tmp;
}
template<class T>
T Sum(const T& left,const T& right)
{
return left + right;
}
int main()
{
int a = 2, b = 3;
double c = 2.3, d = 3.2;
Swap(a, b);
Swap(c, d);
cout << a << " " << b << endl;
cout << c << " " << d << endl;
int sum = Sum(a, b);
cout << sum << endl;
return 0;
}
上述就是一个 隐式类型实例化,一方面注意的是,模板中只有一个参数时,其推演的类型是一一对应的,而传不同类型就会报错,例如:还是上述代码,对于Sum函数,实参传a和c,a是int类型,而c是double类型,那么T就不能推演到底是int类型还是double类型。另一方面注意的是,一个函数模板对应一个函数,函数模板与函数模板之间是互不影响的,例如上述有两个函数模板,他们是互不干扰的,且不能用一个函数模板套用两个函数,这是会报错的。
如图:
那么为了解决上述问题,除了可以用强转,还可以使用显示实例化。
显示实例化:调用函数时在函数名后面接一个<>,在其中指定模板参数的实际类型。
#include <iostream>
using namespace std;
template<class T>
T Sum(const T& left,const T& right)
{
return left + right;
}
int main()
{
int a = 2, b = 3;
double c = 2.3, d = 3.2;
int sum = Sum<int>(a, c);//给函数模板指定为int类型
cout << sum << endl;
return 0;
}
上述给函数模板指定了int类型,那么T就会被推演为int类型,double类型的c也会隐式转换成int类型,对于不能隐式转换的编译器就会报错。
对于上述类型不匹配问题,还有一种方法就是再添加一个模板参数进行匹配,接下来对这一方法进行讲述
2.4模板参数的匹配原则
①.对于不是模板的普通函数可以和同名的模板函数同时存在,该模板函数可以实例化为该普通函数。
②.当普通函数和同名的模板函数同时存在,在调用函数时,实参类型既符合普通函数又符合模板函数,那么会优先调用普通函数,如果实参类型在模板函数中比在普通函数中更符合,那么会选择模板。
③.模板函数中,模板参数识别实参是啥类型那么模板参数就是啥类型,不会发生隐式转换。而普通函数的形参是定好的类型,实参类型可以发生隐式类型转换成形参类型。
例如:
#include <iostream>
using namespace std;
int Sum(int& left, int& right)//只能是int类型
{
cout << "Sum(int& left, int& right)" << endl;
return left + right;
}
template<class T, class Y>//使用多参数模板,T和Y可以是不同类型
T Sum(const T& left,const Y& right)
{
cout << "Sum(const T& left,const Y& right)" << endl;;
return left + right;
}
int main()
{
int a = 2, b = 3;
double c = 2.3, d = 3.2;
int sum1 = Sum(a, b);//实参类型既符合普通函数又符合模板函数,会优先调用普通函数
cout << sum1 << endl;
int sum2 = Sum(a, c);//实参类型在模板函数中比在普通函数中更符合
//在普通函数中c得隐式类型转换为int,在模板函数中可以直接推演各自类型进行匹配,不需要隐式转换
cout << sum2 << endl;
return 0;
}
运行结果:
通过结果也可以看出,第一个优先调用了普通函数,第二个优先调用了模板函数 。
当然除了函数有模板,那么类同样也是有模板,现在来了解了解~
三、类模板
3.1类模板定义格式
类模板概念与函数模板概念类似,其定义格式为:
template<class T1,class T2,...,class Tn>
class 类模板名
{
///类成员
};
3.2类模板实例化
类模板实例化与函数模板实例化还是有区别的,类模板实例化就相当于是显示实例化了,需要在类模板名字后跟<>,将实例化类型放<>里面即可,同时,类模板的类型,就变成了实例化的类型了,即:类名<数据类型>
例如:stack<int> s; vector<double> v;等
接下里对类模板的实例化进行演示以及为什么要有类模板,通过之前学过的栈来进行举例:
#include <iostream>
using namespace std;
template<class T>
class stack
{
public:
stack()
{
_capacity = 0;
_size = _capacity;
_a = new T[_capacity];
}
~stack()
{
delete[] _a;
_a = nullptr;
_size = 0;
_capacity = 0;
}
void push_back(const T x)
{
if (_size == _capacity)
{
int _newcapacity = _capacity == 0 ? 4 : _capacity * 2;
_capacity = _newcapacity;
T* tmp = new T[_capacity];
memcpy(tmp, _a, sizeof(T)*_size);
delete[] _a;
_a = tmp;
}
_a[_size] = x;
_size++;
}
void print()
{
for (int i = 0; i < _size; i++)
{
cout << _a[i] << " ";
}
cout << endl;
}
private:
T* _a;
int _size;
int _capacity;
};
int main()
{
stack<int> s;//类模板的实例化,数据类型为int
s.push_back(1);
s.push_back(2);
s.push_back(3);
s.push_back(4);
s.push_back(5);
s.print();
stack<double> s1;//类模板的实例化,数据类型为double
s1.push_back(1.1);
s1.push_back(2.1);
s1.push_back(3.1);
s1.push_back(4.2);
s1.push_back(5.5);
s1.print();
return 0;
}
运行结果:
通过以上例子、结果,可以看出采用了类模板,那么模板参数T可以接收各种类型来进行推演,只需要实例化想要的数据类型就行了,而对于传统的类,只能确定为一种类型,当想要接收其他类型时,又得造一个轮子,降低效率,从而体现了类模板的优势。