泛型编程
C语言中交换两个变量数据的内容一般是这样实现的
#include<iostream>
using namespace std;
void swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
int main()
{
int x = 5;
int y = 7;
swap(&x,&y);
cout << "x=" << x << " ";
cout << "y=" << y << " ";
}
但自从学了C++引用以后 就不用再传地址和用指针接受实参地址了，直接使用引用 既高效又不开辟栈帧空间。
#include<iostream>
using namespace std;
void swap(int &xx, int&yy)
{
int tmp = xx;
xx = yy;
yy = tmp;
}
int main()
{
int x = 5;
int y = 7;
swap(x,y);
cout << "x=" << x << " ";
cout << "y=" << y << " ";
}
结果是一样的。
但如果要实现多种不同类型数据之间的交换呢？
C++可以使用函数重载
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;
}虽然函数重载可以实现 但有几个不好的地方
模板
函数模板
#include<iostream>
using namespace std;
template<class T>
void swap(const T&x, const T&y)
{
T tmp = x;
x = y;
y = x;
}
int main()
{
int x = 5;
int y = 7;
swap(x,y);
cout << "x=" << x << " ";
cout << "y=" << y << " ";
}
函数模板的格式
template<typename T1,typename T2,.......typename Tn>
返回值类型 函数名(参数）
typename是用来定义模板参数的关键字,也可以用class。(一般是用class,但不能以struct替代class)
#include<iostream>
using namespace std;
template<class T>
void swap(const T&x, const T&y)
{
T tmp = x;
x = y;
y = x;
}
int main()
{
int x = 5;
int y = 7;
double a = 1.34;
double b = 2.34;
swap(x,y);
swap(a, b);
cout << "x=" << x << endl;
cout << "y=" << y << endl;
cout << "a=" << a << endl;
cout << "b=" << b << endl;
}
模板会根据你传的实参类型自动推演生成对应数据类型的函数。
但它们俩调用的却不是同一个函数 通过反汇编就可以看出来
编译器自动完成的事情。
函数模板的原理
要清楚模板是在编译阶段就调用完成的。
#include<iostream>
using namespace std;
template<class T,class Y>
T add(const T& x, const Y& y)
{
return x + y;
}
int main()
{
int a = 4;
double b = 3.14;
int ret=add(a, b);
cout << ret << endl;
}
函数模板的实例化
模板参数语法其实很类似函数参数，函数参数定义的形参对象，模板参数定义的是类型
用不同类型的参数使用函数模板时，是函数模板的实例化。
而实例化又分为隐式实例化和显示实例化
隐式实例化：让编译器根据实参类型推演模板参数实际类型的过程
显式实例化: 在函数名后的<>中指定模板参数的实际类型
#include<iostream>
using namespace std;
template<class T>
T Add(const T& x, const T& y)
{
return x + y;
}
int main()
{
int a = 5;
int b = 11;
double c = 3.14;
double d = 4.14;
int ret = Add(a, b);
double ret1 = Add(c, d);
int ret2 =Add(a, d);error
该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
所以为了解决这个问题 1.要么用户自己强转 2.要么显式实例化
int ret3 = Add(a, (int)d);
cout << ret << endl;
cout << ret1 << endl;
cout << ret3 << endl;
显式实例化
cout << Add<int>(a, c) << endl;
cout << Add<double>(a, b) << endl;
}
一般这种时候就要显式实例化
否则编译器也不知道f是返回值是什么？
模板参数的匹配原则
一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
#include<iostream>
using namespace std;
普通函数
int Add(const int x, const int y)
{
cout << "(const int x, const int y)" << endl;
return x + y;
}
函数模板
template<class T>
T Add(const T& x, const T& y)
{
cout << "(const T& x, const T& y)" << endl;
return x + y;
}
int main()
{
Add(1, 2);
Add(1.1,1.2);
}
当我把函数模板屏蔽后再运行
double到int可以进行隐式类型转换 所以去调用了普通函数。
由此我们可以发现模板参数匹配调用原则：
1.有现成的吃现成的 （第一个int类型去调用普通函数 第二个double类型去调用函数模板）
2.有适合的吃适合的，哪怕自己要现做
3.没有就将就吃 （函数模板屏蔽后，去调用普通函数)
类模板
类模板的格式
template<class T1,class T2class Tn>
class 类模板名
{
// 类内成员定义
}
#include<iostream>
using namespace std;
template<class T>
class stack
{
public:n
stack(int n = 4)
{
cout << "stack(int n = 4)" << endl;
_a = new T[n];
_top = 0;
_capacity = n;
}
~stack()
{
cout << "~stack()" << endl;
delete _a;
_a = nullptr;
_top = _capacity = 0;
}
private:
T* _a;
int _top;
int _capacity;
};
如果想声明和定义分离这样写
但模板一般声明和定义都是在一个文件写的 不会分开写 因为会产生链接错误
暂且先不讲 我在模板进阶再详细说
template<class T>
Stack<T>::Stack(int n)
{
cout << "Stack(int n = 4)" << endl;
_a = new T[n];
_top = 0;
_capacity = n;
}
int main()
{
显式实例化
stack<int>st;
stack<double>st;
}拿栈来做例子，C语言里面如果栈里面要存int和double类型数据 还要typedef 成intdatatype 或者doubledatatype 还要把类型名改成stackint 或者stackdouble
而有了类模板以后就避免了这种低效用法，直接显式实例化要存的类型数据，类模板参数直接推演出对应存储数据类型。
类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。
#include<iostream>
#include<vector>
#include<stack>
using namespace std;
int main()
{
vector是类名 vector<int>才是类型
vector<int>s;
同理stack是类名 stack<double>才是类型
stack<double>st;
return 0;
}总结：普通类----类名是类型 类模板----类名<数据类型>才是整个类的类型。
