一、泛型编程
在之前，我们想要实现一个交换两个值的函数，我们要实现好多个（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; }
实现不同类型的交换，我们可以使用函数重载，写出来好多个；
但是，这也有不足之处：
1、函数重载只是参数类型不同，代码复用率比较低，只要有新的类型，就需要用户自己添加对应的函数。
2、代码可维护性较低，一个出错可能所以的重载都出错。
那我们可不可以只实现一个模版，让编译器根据不同的类型利用我们写的模版来自动生成相对应 的函数呢？
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
二、函数模版
2.1、函数模版概念
函数模版代表一个函数家族，该函数模版与类型无关，在使用的时候被参数化，根据实参类型产生函数特定的类型版本。
2.2、函数模版格式
template<typename T1,typename T2,........typename Tn>
返回值类型 函数名(函数参数){}
有了模版，对于上面的交换函数我们就可以这样写：
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 将T推演为int，通过实参 2.2 将T推演为double类型，但模板参数列表中只有一个T编译器无法确定此处到底该将T确定为int 或者 double类型而报错。
解决这个问题有两种方法，
1、强制类型转换。
2、模版函数显示实例化
2.4.2、显示实例化
显示实例化：在函数名后面的<>中指定模版参数的实际类型。
int main(void) { int a = 10; double b = 20.0; // 显式实例化 Add<int>(a, b); return 0; }
2.5、模版参数的匹配原则
1、一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
2、对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
3、模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
三、类模版
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;
扩展：
类模版在声明和定义分离时（类里面声明，类外面定义）与普通的类不同：
类里面声明：
类外面定义：
模版初阶大致内容就这些，后面还会深入学习模版的内容。
感谢各位大佬支持并指出问题，
如果本篇内容对你有帮助，可以一键三连支持以下，感谢支持！！！
