1、template的使用
C++ 的高级玩法，当然包含了模板。模板（template）是实现代码重用机制的一种工具，它可以实现类型参数化，把类型定义为参数（模板元编程），从而实现了真正的代码可重用性。
模板是用来批量生成功能和形式都几乎相同的代码的。编译器就能在需要的时候，根据模板自动生成程序的代码。从同一个模板自动生成的代码，形式几乎是一样的。 模板就像一个做饼干的模具，至于饼干是什么味道，则要看具体实例化时制作饼干的材料。
模板可以分为两类，一个是函数模板，另外一个是类模板。
1.1、函数模板
函数模板比较简单，下面我们来看一个两者交换的例子就明白了:
template<typename T>
void swap(T& t1, T& t2)
{
T temp = t2;
t2 = t1;
t1 = temp;
}
1.2、类模板
类模板比函数模板稍微复杂一下，主要是实现时的书写，如下面的代码:
//stack.h
template<typename T>
class Stack
{
public:
Stack();
~Stack();
void push(T t);
T pop();
bool isEmpty();
private:
T* m_pT;
int m_maxSize;
int m_size;
};
//Stack.cpp
#include "Stack.h"
template<typename T>
Stack<T>::Stack()
{
m_maxSize = 100;
m_size = 0;
m_pT = new T[m_maxSize];
}
template<typename T>
Stack<T>::~Stack()
{
delete[] m_pT;
m_pT = nullptr;
}
template<typename T>
void Stack<T>::push(T t)
{
m_size++;
m_pT[m_size - 1] = t;
}
template<typename T>
T Stack<T>::pop()
{
T t = m_pT[m_size - 1];
m_size--;
return t;
}
template<typename T>
bool Stack<T>::isEmpty()
{
return m_size == 0;
}
上述类模板是模仿了一个栈，这个栈很简单，最多只能支持100个元素入栈。
通过上面的例子可知，在类模板中，通用类型可以作为普通成员变量，也可以作为成员函数的参数和返回值。
2、模板的实例化与具象化
2.1、实例化
模板的实例化有两种形式，分别是 显示实例化 和 隐式实例化。
显示实例化 就是直接命令编译器创建特定的实例。在使用模板之前，编译器会根据显示指定的类型生成模板实例。显示实例化有两种写法，具体如下：
template void swap2<int>(int& a, int& b); //声明时显示实例化，只需要声明，不需要实现
int a = 1, b= 2;
swap<int>(a, b); //使用时显示实例化
隐式实例化 类似普通的函数调用，在使用模板时，根据使用的类型，编译器进行推导，生成相应类型的实例。方便程序员的书写，但是增加编译器的负担。如下所示：
swap(a, b); //隐式实例化，和显示实例化的结果是一样的
2.2、具象化（专业化）
具象化就是模板中特化性质。例如上面书写的交换函数，如果传入的是char* 类型，使用 = 操作只是复制了指针数据，指针指向的内存有可能会失效，所以 = 操作可能会出现问题，我们需要进行单独的操作。如下:
template<>
void swap2(char*& a, char*& b)
{
//具象化
.....
}
具象化的定义应该在有常规模板的情况下，以 template<> 打头，通过名称来指出类型，并必须要有具体的实现。
函数在调用的过程时，编译器调用顺序是：常规函数 > 具体化模板函数 > 常规模板。
3、其它
一个类没有模板参数，但是成员函数有模板参数是可行的。代码如下：
class Util
{
public:
template<class T>
bool equal(T t1, T t2)
{
return t1 == t2;
}
};
int main()
{
Util aab;
std::cout << aab.equal<int>(a, b) << std::endl;
std::cout << aab.equal(1, 1) << std::endl;
}
在类模板的例子中栈的最大元素数量是写死的，可以使用模板的偏特化特性来自定义元素的最大数量。如下所示
template<typename T, int maxsize = 100>
class Stack
{
//和上面的例子一样
.....
}
template <class T,int maxsize> //这里和上面的不一样
Stack<T, maxsize>::Stack()
{
m_maxSize = maxsize; //最大数量通过外面传入
m_size = 0;
m_pT = new T[m_maxSize];
}
int main()
{
int maxsize = 1024;
Stack<int,1024> intStack;
for (int i = 0; i < maxsize; i++)
intStack.push(i);
}
感谢大家，我是假装很努力的YoungYangD（小羊）。
参考文档：
https://www.cnblogs.com/yangxiaoping/p/8268209.html
https://blog.csdn.net/qq_30835655/article/details/76850894
