概念
模板是C++中非常厉害的设计，模板把通用的逻辑剥离出来，让不同的数据类型可以复用同一种模板的逻辑，甚至可以让不同的逻辑复用同一种模板逻辑（仿函数的设计）
模板可以帮助我们实现代码的重用和泛化，提高代码的灵活性和可维护性。
STL的容器就是对模板很好的运用，可参考
语法
template <typename T> //可以写成template <class T> class MyClass { // ... }; template <typename T> //可以写成template <class T> T add(T a, T b) { return a + b; }
在上面的示例中，MyClass 是一个类模板，add 是一个函数模板。通过使用 typename 或 class 关键字声明模板参数，T 就是未知类型
函数模板
通过使用函数模板，我们可以定义一种通用的函数，可以根据实际需要传不同的数据复用函数模板
函数模板的语法格式如下：
template <typename T> 返回类型 函数名(参数列表) { // 函数体 }
其中，template关键字表示这是一个函数模板，<typename T>表示定义了一个类型参数T，可以根据需要使用不同的类型来替换T，返回类型表示函数的返回类型，函数名表示函数的名称，参数列表表示函数的参数列表。
在函数模板中，可以使用类型参数T作为函数的参数类型、返回类型或局部变量的类型。例如：
template <typename T> T max(T a, T b) { return (a > b) ? a : b; }
上述代码定义了一个函数模板max，它接受两个参数a和b，这两个参数的类型都是T，并且返回类型也是T
使用函数模板时，需要在函数名后面加上尖括号<>，并在其中指定具体的类型。例如：
int result1 = max<int>(3, 5); // 使用int类型实例化函数模板 double result2 = max<double>(3.14, 2.71); // 使用double类型实例化函数模板
max<int>表示使用`int`类型实例化max函数模板，max<double>表示使用double类型实例化max函数模板。传不同的参数示例化的函数是不同的
函数模板还可以有多个类型参数，可以使用逗号分隔它们。例如：
template <typename T1, typename T2> void printPair(T1 a, T2 b) { cout << "(" << a << ", " << b << ")" << endl; }
使用函数模板时，需要指定每个类型参数的具体类型。例如：
printPair<int, double>(3, 3.14); // 使用int和double类型实例化函数模板
在上述代码中，printPair<int, double>表示使用int类型和double类型实例化printPair函数模板。
总结起来，函数模板是一种通用的函数定义，可以用于多种不同类型的参数。通过使用函数模板，可以编写一次代码，然后在不同的地方使用不同的数据类型进行调用。
类模板
通过使用类模板，我们可以定义一种通用的类模板，可以根据实际需要在不同场景下传入不同的类型实例化出不同的类。
类模板的语法格式如下：
template <typename T> //可以写成template <class T> class 类名 { // 成员变量和成员函数的定义 };
在类模板中，可以使用类型参数T作为成员变量的类型、成员函数的参数类型或返回类型。例如：
template <typename T> class Stack { private: T* data; int size; public: Stack(int capacity) { data = new T[capacity]; size = 0; } void push(T value) { data[size++] = value; } T pop() { return data[--size]; } };
上述代码定义了一个类模板Stack，它有一个私有成员变量data和size，分别表示存储数据的数组和当前栈的大小。类模板还有两个公有成员函数push和pop，分别用于向栈中压入元素和弹出栈顶元素。
使用类模板时，需要在类名后面加上尖括号<>，并在其中指定具体的类型。例如：
Stack<int> intStack(10); // 使用int类型实例化类模板 Stack<double> doubleStack(5); // 使用double类型实例化类模板
不然会报如下错误
Stack<int>表示使用int类型实例化Stack类模板，Stack<double>表示使用double类型实例化Stack类模板。根据实际的类型参数，编译器会生成相应的类定义。
类模板还可以有多个类型参数，可以使用逗号分隔它们。例如：
template <typename T1, typename T2> class Pair { private: T1 first; T2 second; public: Pair(T1 a, T2 b) { first = a; second = b; } void print() { cout << "(" << first << ", " << second << ")" << endl; } };
使用类模板时，需要指定每个类型参数的具体类型。例如：
Pair<int, double> p1(3, 3.14); // 使用int和double类型实例化类模板 Pair<string, int> p2("Hello", 5); // 使用string和int类型实例化类模板
非类型模板参数
模板参数分为：类型形参与非类型形参
类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称
非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用
// 定义一个模板类型的静态数组 template<class T, size_t N = 10> class array { public: T& operator[](size_t index){return _array[index];} const T& operator[](size_t index)const{return _array[index];} size_t size()const{return _size;} bool empty()const{return 0 == _size;} private: T _array[N]; size_t _size; }；
浮点数、类对象以及字符串是不允许作为非类型模板参数的。
非类型的模板参数必须在编译期就能确认结果。
模板的特化
概念：
在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特 化中分为函数模板特化与类模板特化
函数模板特化
必须要先有一个基础的函数模板
关键字 template 后面接一对空的尖括号 <>
函数名后跟一对尖括号，尖括号中指定需要特化的类型
函数形参表 : 必须要和模板函数的基础参数类型完全相同
// 函数模板 -- 参数匹配 template<class T> bool Less(T left, T right) { return left < right; } // 对Less函数模板进行特化 template<> bool Less<Date*>(Date* left, Date* right) //Date是日期类 { return *left < *right; }
下面是测试
类模板特化
全特化
全特化即是将模板参数列表中所有的参数都确定化
template<class T1, class T2> class Data { public: Data() {cout<<"Data<T1, T2>" <<endl;} private: T1 _d1; T2 _d2; }; template<> class Data<int, char> { public: Data() {cout<<"Data<int, char>" <<endl;} private: int _d1; char _d2; };
下面是测试
偏特化
任何针对模版参数进一步进行条件限制设计的特化版本
偏特化有以下两种表现方式：
部分特化
特化一部分参数
下面是测试代码
template<class T1, class T2> class Data { public: Data() {cout<<"Data<T1, T2>" <<endl;} private: T1 _d1; T2 _d2; }; template <class T1> class Data<T1, int> { public: Data() {cout<<"Data<T1, int>" <<endl;} private: T1 _d1; int _d2; };
限制参数
偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本
下面是测试代码
template<class T1, class T2> class Data { public: Data() {cout<<"Data<T1, T2>" <<endl;} private: T1 _d1; T2 _d2; }; //两个参数偏特化为指针类型 template <typename T1, typename T2> class Data <T1*, T2*> { public: Data() {cout<<"Data<T1*, T2*>" <<endl;} private: T1 _d1; T2 _d2; }; //两个参数偏特化为引用类型 template <typename T1, typename T2> class Data <T1&, T2&> { public: Data(const T1& d1, const T2& d2) : _d1(d1) , _d2(d2) { cout<<"Data<T1&, T2&>" <<endl; } private: const T1 & _d1; const T2 & _d2; };
分离编译
下面了解即可
C/C++程序要运行要经历以下步骤
预处理---> 编译---> 汇编---> 链接
预处理:将头文件展开
编译：头文件不参与编译，编译主要是检查语法错误，多个源文件单独分开编译
汇编：将文本文件翻译成二进制文件
链接：将多个编译好的源文件合成一个
如果将模板声明和定义分离会报链接错误
可参考下面这位大佬的文章
将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种
模板定义的位置显式实例化。这种方法不实用，不推荐使用
