一、泛型编程

泛型编程：编写与类型无关的通用代码，代码复用的一种方法

在 C++ 中，我们可以通过函数重载实现通用的交换函数 Swap ，但是有一些缺点

• 重载函数只有类型不同，使得代码复用率不好，需要使用新类型时，就必须自己写该类型的重载函数
• 当有一个重载函数出错时，可能需要检查所有的函数

void Swap(int& a, int& b)
{int tmp = a;a = b;b = tmp;
}void Swap(double& a, double& b)
{double tmp = a;a = b;b = tmp;
}

于是 C++ 中引入了模板，可以给函数或类设置模板类型参数，模板类型参数在函数或类中表示广泛的类型，在使用时会替换为正在使用的这个类型

//class 关键字可以换成 typename 关键字，注意：这里不能使用 struct 关键字
template<class T1, class T2,...> //T1、T2,... 是模板类型参数，表示广泛的类型

模板是泛型编程的基础，给函数或类添加模板类型参数，就称为 函数模板 和 类模板

模板是与具体类型无关的通用代码，当我们使用模板并填充某种类型时，编译器就会根据该类型实例化出该模板样式的代码

二、 函数模板

函数模板是与具体类型无关的函数代码，当我们调用模板函数时，编译器会根据实参的类型实例化出该函数模板样式的代码

于是交换函数的通用版本就可以用函数模板简单的实现了

#include <iostream>using namespace std;//T 代表广泛的类型，是调用该模板函数时实参的类型
template<class T> void Swap(T& a, T& b)
{T tmp = a;a = b;b = tmp;
}int main()
{int a1 = 1, b1 = 2;Swap(a1, b1); //向 Swap 模板函数填充 int，编译器自动生成 int 版 Swapcout << a1 << " " << b1 << endl;	//输出 2 1double a2 = 1.11, b2 = 2.22;Swap(a2, b2); //向 Swap 模板函数填充 double，编译器自动生成 double 版 Swapcout << a2 << " " << b2 << endl;	//输出 2.22 1.11char a3 = 'a', b3 = 'b';Swap(a3, b3); //向 Swap 模板函数填充 char，编译器自动生成 char 版 Swapcout << a3 << " " << b3 << endl;	//输出 b areturn 0;
}

在编译阶段，编译器根据实参的类型实例化出该函数模板样式的函数代码

在调用模板函数时：

• 编译器根据实参类型填充模板，然后实例化出实参类型的函数模板样式的代码，这种方式称为 隐式实例化

• 在函数名和参数之间加上 <type>，指定类型 type 填充模板，然后实例化出 type 类型的函数模板样式的代码，这种方式称为 显示实例化

#include <iostream>using namespace std;template<class T> void Swap(T& a, T& b)
{T tmp = a;a = b;b = tmp;
}int main()
{int a = 1, b = 2;Swap<int>(a, b); //指定 int 类型填充模板函数 Swap，编译器自动生成 int 版 Swapcout << a << " " << b << endl;	//输出 2 1return 0;
}

其实库中已经实现了通用的交换函数 swap，以后直接使用即可

非模板函数可以和函数模板同名，并且允许函数模板实例化出的函数和非模板函数一样

#include <iostream>using namespace std;int Add(const int& left, const int& right)
{return left + right;
}template<class T>
T Add(const T& left, const T& right)
{return left + right;
}int main()
{//默认调用非模板函数cout << Add(1, 2) << endl; //输出 3//可以实例化出和非模板函数一样的函数//调用函数模板实例化的 int 版cout << Add<int>(1, 2) << endl; //输出 3return 0;
}

调用普通函数时，如果实参和形参数类型不同，可以隐式类型转换，但在以隐式实例化的方式调用模板函数时，如果实参和形参类型不同，不会隐式类型转换

当普通函数和模板函数重名时，并且函数调用传递的实参类型和普通函数的形参类型不匹配时，如果函数模板可以实例化出更匹配参数类型的函数，则会调用函数模板实例化的函数，否则调用普通函数

#include <iostream>using namespace std;int Add(const int& left, const int& right)
{return left + right;
}template<class T1, class T2>
T1 Add(const T1& left, const T2& right)
{return left + (T1)right;
}int main()
{//当函数模板可以实例化出更匹配参数的函数时，调用函数模板实例化的函数Add(1, 2.2);return 0;
}

三、类模板

类模板是与具体类型无关的类代码，用模板类实例化对象时，需要在类名后加上 <type>，指定类型 type 填充模板，然后实例化出 type 类型的类模板样式的代码

于是 Stack 类的通用版本就可以用类模板简单的实现了

#include <iostream>using namespace std;template<class T> class Stack
{
public:Stack(int capacity = 4): _a(new T[capacity]), _top(0), _capacity(capacity){}~Stack();private:T* _a;int _top;int _capacity;
};//当成员函数在类外定义时，需要加上模板类型参数列表
//注意：Stack<T>(T 表示广泛的类型) 才是模板类的类名
template<class T>  Stack<T>::~Stack()
{if (_a){delete[] _a;_a = nullptr;_top = _capacity = 0;}
}int main()
{//Stack<int> 为存储整形元素的栈类的类型名Stack<int> s1; //指定 int 类型填充模板类 Stack，编译器自动生成 int 版 Stack//Stack<char> 为存储字符元素的栈类的类型名Stack<char> s2;//指定 char 类型填充模板类 Stack，编译器自动生成 char 版 Stackreturn 0;
}

注意：使用类模板定义对象时，没有东西可以识别为类模板所需要填充的类型，因此类模板只能显示实例化

模板和函数重载的底层原理是一样的，只是重复的事情交给了编译器而已