泛型编程
假如我们要写一个两数交换的函数，按我们之前学的知识，我们会这样。
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;
}
int main()
{
int a = 1, b = 2;
//Swap(a, b);
Swap(a, b);
double c = 1.1, d = 2.22;
//Swap(a, b);
Swap(c, d);
return 0;
}
这是函数重载，按我们的理解，再增加不同的类型的数进行交换又要写一个函数，这样就需要不断的去写函数。
所以这里就引出了我们接下来要说的泛型编程。
函数模板
格式
template<typename T>
template是关键字，
T是模板类型名称，可以随便给。
定义多个模板参数
template<typename x, typename y>
上面交换的代码可以写成这样
template<class T>
void Swap(T& x, T& y)
{
T tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 1, b = 2;
//Swap(a, b);
Swap(a, b);
double c = 1.1, d = 2.22;
//Swap(c,d);
Swap(c, d);
return 0;
}
它是针对广泛的类型来进行编程的。T具体的类型是什么我也不知道。
写成这样，无论什么类型的数据进行交换都只需要写这一个模板。
模板调用的是同一个函数吗？
那现在问题来了，Swap(a, b);和Swap(c, d);调用的是同一个函数吗？
通过调试我们发现好像是这样，但是只看这个是不够的，还是看一下汇编，结果发现函数地址不一样，所以肯定不是同一个函数。
其实我们仔细想想也知道，不可能是同一个，同一个指令是一样的。那函数要建立栈帧，这两个栈帧大小一样吗？
要交换的数的类型不一样，函数栈帧的大小也肯定不一样。
模板的实现原理
那现在又有一个问题，上面两个swap函数调用的是不是模板？
其实不是，这么说吧！Swap(a, b);编译器会判断出a，b的类型是int，继而对模板进行一定的推演，判断出T的类型是int,然后根据模板实例化一个用int数据交换的函数。实际函数调用的不是模板，而是调用的是模板生成的代码。
其实函数一点也没有减少，只是有了模板编译器帮我们生成了。
T不明确
下面看这段代码会报错吗？
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10;
double d1 = 10.11;
Add(a1, d1);
return 0;
}
答案是会报错，这是因为模板再推演实例化的时候出现了歧义，他不知道T的类型是int还是double;
那怎么办呢？
很简单，强制类型转换。这是根据实参传递给形参，自动推演模板类型
Add(a1, (int)d1);
Add((double) a1, d1);
那除了强制类型转换还有没有别的方法呢？
显示实例化
Add<int>(a1, d1)
Add<double>(a1, d1)
模板实例化的函数和普通函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
return left + right;
}
请问能同时存在吗？
能！
那编译器会调用哪个函数？
编译器有个原则，调用谁的成本低就调用谁。很显然如果调用模板实例化的函数需要推演实例化这些东西，所以它会调用普通函数。
那如果非要调用模板实例化的函数呢？
显示实例化
编译器自己选择？
其实编译器非常聪明，它会调用跟它更加匹配的那个函数。
类模板
类模板就是定义一个模板参数，整个类里面都可以用。
那现在问题来了，之前学习的typedef不够用吗？
答案是不够，比如写一个栈，
typedef int STDateType;
class Stack
{
private:
STDateType* _a;
size_t _top;
size_t _capacity;
};
int main()
{
Stack st;
return 0;
}
现在我栈上既要存储int又要存储double数据就办不到了！
类模板写法
template<class T>
class Stack
{
public:
Stack(int capaicty = 4)
{
_a = new T[capaicty];
_top = 0;
_capacity = capaicty;
}
~Stack()
{
delete[] _a;
_capacity = _top = 0;
}
private:
T* _a;
size_t _top;
size_t _capacity;
};
类模板用法
怎么用呢？必须得显示实例化。
int main()
{
Stack<int> st1; // int
Stack<double> st2; // double
return 0;
}
注意事项
1.模板的名字不能直接表示类型，加上模板参数才能表示类型
vector <int> v1;
2.类里面如果声明和定义分离怎么写？
class Vector
{
~Vector();
};
template<class T>
Vector<T>::~Vector()//不能只指定类名，得指定类型
{
delete[] _pData;
_pData = nullptr;
_size = _capacity = 0;
}
3.类模板声明和定义一定要放在同一个文件。
如果声明和定义分离会出现链接错误。
