首先模版就相当于一个模具，可以用它模造出很多实例化的物，形象的比如：
就像是用同一个模具，当放进去的蛋糕原料不同，那么生成的蛋糕种类也不同一样，这里形象的把类型比作原料；而又可以充分解释类模版和模版类的关系，也就是模具和蛋糕的关系，利用类模版具体化出模版类来（以下会涉及讲到）。
以下是对模版的分类：
下面展开来讲：
一·函数模版：
简述：首先与类型无关，在使用的时候才会被实参化，根据实参类型而产生特定的类型，有一个匹配的概念。
模版格式：template +返回值类型 函数名(参数列表){}
typename是用来定义模板参数关键字，也可以使用class但不能使用struct代替 class。
下面用代码写一个简单的函数模版：
template
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
利用模版实现了一个简单的不同类型之间的交换。
1.函数模版实例化：
①模版实例化概念：即编译器调用相应的函数；而如果类型不同，每次调用的不会是同一个函数。
②当传参给模版，它会进行参数匹配，完成实例化出 实函数然后在调用，这两个不是同一个。
函数模版实例化分为 显示实例化和隐式实例化，下面展开讲解：
1.1显示实例化：
即在函数名后的<>中指定模板参数的实际类型。
代码展示：
template
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a = 10;
double b = 20.0;
Add(a, b);
return 0;
}
1.2隐式实例化：
即编译器自己进行的内部参数匹配，生成对应函数：如：
template
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
Add(a1, a2);
Add(d1, d2);//这里编译器就会自己匹配函数，而如果两个数类型不同，而且类型T只有一个，那么就需要强转【Add(a, (int)d)】或者显示实例化，否则报错
1.3函数模版匹配原则：
①如果有一个与函数模版同名的非模版函数（有明确的类型），而模版传参时候恰好是同类型，这时就无需匹配，直接调用已存在的那个同名非模版函数。
如：
int Add(int left, int right)
{
return left + right;
}
template
T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2);
Add(1, 2);
}
②如果有两个可以进行匹配的参数，那么就不用像一个的那样强转了。
int Add(int left, int right)
{
return left + right;
}
template
T1 Add(T1 left, T2 right)
{
return left + right;
}
void Test()
{
Add(1, 2); //这里可以直接调用现成的
Add(1, 2.0); //编译器自己匹配
}
③模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。
如：
template
void fun2(T a, T b)
{ std::cout<<<< std::endl;
}
void funl(double a,double b)
{std::cout<< a<<<< b<< std::endl;
}
void test(){
fun1(10.0,20);//普通函数可以自己强转
fun2(10.0,20);//由于只有一个T，故不能要么自己强转，要么T1，T2。
}
二·类模版：
1.1类模版的定义格式：
template
class 类模板名 {
};
类模版根据传参匹配生成初始化对应的类。
1.2类模版的实例化：
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的 类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。
简单来说对于栈这个类模版 stack只是它的类名，而要进行实例化匹配，它的模版类类型应该是stack<类型>+对象名字。
如：
// Stack是类名，Stack才是类型
Stack st1;
Stack st2;
下面用一个栈的例子来说明一下类模版：
template
class stack {
public:
stack(int count = 4)
:_array(new T[count])
, _top(0)
, _capacity(count) {
}
void push(const T& n);
~stack(){
delete[]_array;
_array = nullptr;
_capacity = _top = 0;
}
private:
T* _array;
size_t _top;
int _capacity;
};
//在类内对类模版成员函数声明，类外定义，需要声明模版，以及类模版的类。
template
void stack::push(const T&n) {
if (_capacity== _top) {
T p = new T[_capacity 2];//这里c++不能像c一样用realloc扩容，只能new新空间，拷贝，再赋给_array。
memcpy(p, _array, _top);
delete[]_array;
_array = p;
_capacity = _capacity * 2;
}
_array[_top] = n;
_top++;
}
int main() {
stack(2);//机制：类模版根据参数类型识别出要模出哪种类型的stack，利用类的类型转换，去调用类模版的相应参数成员函数，拿它去初始化临时对象，再拷给最后的对象。
stack('a');
return 0;
}*/
但是如果要是声明，定义“大分家”是行不通的，比如声明在.h:而定义在.cpp；这样就会链接错误引起报错。 因此一般不建议这样做。
