一、泛型编程
在之前，我们想要实现一个交换两个值的函数，我们要实现好多个（int类型、double类型、char类型以及自定义类型）对于每一个类型，我们都需要实现一个交换函数：
int Swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
double Swap(double& x, double& y)
{
double tmp = x;
x = y;
y = tmp;
}
char Swap(char& x, char& y)
{
char tmp = x;
x = y;
y = tmp;
}实现不同类型的交换，我们可以使用函数重载，写出来好多个；
但是，这也有不足之处：
那我们可不可以只实现一个模版，让编译器根据不同的类型利用我们写的模版来自动生成相对应 的函数呢？
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
二、函数模版
2.1、函数模版概念
2.2、函数模版格式
有了模版，对于上面的交换函数我们就可以这样写：
template<typename T>
void Swap(T& x, T& y)
{
T tmp = x;
x = y;
y = tmp;
}注意：这里typename 是定义模版参数的关键字，也可以使用class （不能用struct 代替class）
2.3、函数模版原理
编译器会根据参数类型生成不同的函数，这里可以通过汇编代码看一下：
#include<iostream>
template<typename T>
void Swap(T& x, T& y)
{
T tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 1, b = 2;
Swap(a, b);
double c = 1.1, d = 2.2;
Swap(c, d);
return 0;
}
这里可以看到，编译器根据不同的参数，生成了不同的函数，Swap<int>、Swap<double>
2.4、函数模版实例化
在使用不同类型的参数使用函数模版时，称为函数模版的实例化。
模版的实例化又分为：隐式实例化和显式实例化。
2.4.1、隐式实例化
所谓隐式实例化，就是让编译器根据实参推演模版参数的实际类型
但是这样也会遇到一些问题，就比如如下函数：
template<typename T>
T Add(const T& x, const T& y)
{
return x + y;
}
int main()
{
int a = Add(1, 2); //两个int类型
int b = Add(1.1, 2.2); //两个double类型
int c = Add(1, 2.2); // int double 类型
return 0;
}
如上述情况，编译器会报错：没有与参数列表匹配的函数模版。
解决这个问题有两种方法，
1、强制类型转换。
2、模版函数显示实例化
2.4.2、显示实例化
int main(void)
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
return 0;
}2.5、模版参数的匹配原则
三、类模版
3.1、类模版的定义格式
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};这里简单实现一下。
//类模版
template<typename T>
class Stack
{
public:
Stack(int capacity = 4)
{
_arr = new T[capacity];
_top = 0;
_capacity = capacity;
}
~Stack()
{
delete[] _arr;
_arr = nullptr;
_top = _capacity = 0;
}
void Push(T& x);
void Pop();
bool Empty()
{
return _top == 0;
}
private:
T* _arr;
size_t _top;
size_t _capacity;
};
template<typename T>
void Stack<T>::Push(T& x)
{
if (_top >= _capacity)
{
T* tmp = (T*)realloc(_arr, sizeof(T) * 2 * _capacity);
if (tmp == nullptr)
{
exit(1);
}
_arr = tmp;
_capacity *= 2;
}
_arr[_top++] = x;
}
template<typename T>
void Stack<T>::Pop()
{
_top--;
}
3.2、类模版的实例化
注意：类模版名字不是真正的类，实例化的结果才是真正的类。
//Stack类名，Stack<int>/Stack<double>才是类型
Stack<int> s1;
Stack<double> s2;扩展：
类模版在声明和定义分离时（类里面声明，类外面定义）与普通的类不同：
类里面声明：
类外面定义：
模版初阶大致内容就这些，后面还会深入学习模版的内容。
感谢各位大佬支持并指出问题，
如果本篇内容对你有帮助，可以一键三连支持以下，感谢支持！！！
