原文出处：C++模板大总结

前言：

大家好，我是小涂，今天给大家分享一篇关于c++模板总结概述.

模板（Template）指C++程序设计设计语言中采用类型作为参数的程序设计，支持通用程序设计。C++的标准库提供许多有用的函数大多结合了模板的观念，如STL以及IO Stream。模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。

模板是一种对类型进行参数化的工具；通常有两种形式：函数模板和类模板:

使用模板的目的就是能够让程序员编写与类型无关的代码.

一、函数模板：

template <class 形参名，class 形参名，......>   
返回类型 函数名(参数列表)  
{  
      函数体  
}

其中template和class是关键字，class可以用typename 关键字代替，在这里typename 和class没区别，<>括号中的参数叫模板形参，模板形参和函数形参很相像，模板形参不能为空。一但声明了模板函数就可以用模板函数的形参名声明类中的成员变量和成员函数，即可以在该函数中使用内置类型的地方都可以使用模板形参名。模板形参需要调用该模板函数时提供的模板实参来初始化模板形参，一旦编译器确定了实际的模板实参类型就称他实例化了函数模板的一个实例。比如swap的模板函数形式为：

template <class T> void swap(T& a, T& b){}，

当调用这样的模板函数时类型T就会被被调用时的类型所代替，比如swap(a,b)其中a和b是int 型，这时模板函数swap中的形参T就会被int所代替，模板函数就变为swap(int &a, int &b)。而当swap(c,d)其中c和d是double类型时，模板函数会被替换为swap(double &a, double &b)，这样就实现了函数的实现与类型无关的代码。

注意：对于函数模板而言不存在 h(int,int) 这样的调用，不能在函数调用的参数中指定模板形参的类型，对函数模板的调用应使用实参推演来进行，即只能进行h(2,3) 这样的调用，或者int a, b; h(a,b)。

二、类模板：

类模板的格式为：

template<class  形参名，class 形参名，…>  
class 类名{ ... };

类模板和函数模板都是以template开始后接模板形参列表组成，模板形参不能为空，一但声明了类模板就可以用类模板的形参名声明类中的成员变量和成员函数，即可以在类中使用内置类型的地方都可以使用模板形参名来声明。比如：

template<class T> class A  
{  
   public:   
   T a;  
   T b;   
   T hy(T c, T &d);  
};

在类A中声明了两个类型为T的成员变量a和b，还声明了一个返回类型为T带两个参数类型为T的函数hy。

类模板对象的创建：比如一个模板类A，则使用类模板创建对象的方法为A m;在类A后面跟上一个<>尖括号并在里面填上相应的类型，这样的话类A中凡是用到模板形参的地方都会被int所代替。当类模板有两个模板形参时创建对象的方法为A m;类型之间用逗号隔开。

对于类模板，模板形参的类型必须在类名后的尖括号中明确指定。比如A<2> m;用这种方法把模板形参设置为int是错误的（编译错误：error C2079:‘a’ uses undefined class ‘A’），类模板形参不存在实参推演的问题。也就是说不能把整型值2推演为int型传递给模板形参。要把类模板形参调置为int 型必须这样指定A m。

在类模板外部定义成员函数的方法为：

template<模板形参列表> 函数返回类型 类名<模板形参名>::函数名(参数列表){函数体}

比如有两个模板形参T1，T2的类A中含有一个void h()函数，则定义该函数的语法为：

template<class T1,class T2> void A<T1,T2>::h(){}。

注意：当在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致。模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。

三、模板的非类型形参：

四、类模板的默认模板类型形参：

五、模板的实例化:

总结一下，C++只有模板显式实例化(explicit instantiation),隐式实例化(implicit instantiation),特化(specialization,也译作具体化，偏特化)。首先考虑如下模板函数代码:

[cpp] view plaincopyprint?  
template <typename T>    
void swap(T &a, T &b){    
    ...    
}

1、隐式实例化：

我们知道，模板函数不是真正的函数定义，他只是如其名提供一个模板，模板只有在运行时才会生成相应的实例，隐式实例化就是这种情况:

[cpp] view plaincopyprint?  
int main(){    
    ....    
    swap<int>(a,b);    
    ....    
}

它会在运行到这里的时候才生成相应的实例，很显然的影响效率这里顺便提一下swap(a,b);中的是可选的,因为编译器可以根据函数参数类型自动进行判断,也就是说如果编译器不不能自动判断的时候这个就是必要的。

2、显式实例化：

前面已经提到隐式实例化可能影响效率,所以需要提高效率的显式实例化,显式实例化在编译期间就会生成实例,方法如下:

[cpp] view plaincopyprint?  
template void swap<int>(int &a,int &b);

这样就不会影响运行时的效率，但编译时间随之增加。

3、特化：

这个swap可以处理一些基本类型如long int double,但是如果想处理用户自定义的类型就不行了,特化就是为了解决这个问题而出现的:

[cpp] view plaincopyprint?  
template <> void swap<job>(job a,job b){...}

其中job是用户定义的类型.

六、模板的特化（具体化）和偏特化：

类模板：

测试代码如下：

#include <iostream>  
using namespace std;  

template<typename T1,typename T2>  
class Test{  
public:  
    Test(T1 i,T2 j):a(i),b(j){cout<<"模板类"<<endl;}  
private:  
    T1 a;  
    T2 b;  
};  

template<>   //全特化，由于是全特化，参数都指定了，参数列表故为空。  
class Test<int ,char>{  
public:  
    Test(int i,char j):a(i),b(j){cout<<"全特化"<<endl;}  
private:  
    int a;  
    int b;  
};  

template<typename T2> //由于只指定了一部分参数，剩下的未指定的需在参数列表中，否则报错。  
class Test<char,T2>{  
public:  
    Test(char i,T2 j):a(j),b(j){cout<<"个数偏特化"<<endl;}  
private:  
    char a;  
    T2 b;  
};  

template<typename T1,typename T2> //这是范围上的偏特化  
class Test<T1*,T2*>{  
public:  
    Test(T1* i,T2* j):a(i),b(j){cout<<"指针偏特化"<<endl;}  
private:  
    T1* a;  
    T2* b;  
};  

template<typename T1,typename T2>//同理这也是范围上的偏特化  
class Test<T1 const,T2 const>{  
public:  
    Test(T1 i,T2 j):a(i),b(j){cout<<"const偏特化"<<endl;}  
private:  
    T1 a;  
    T2 b;  
};  


int main()  
{  
    int a;  
    Test<double,double> t1(0.1,0.2);  
    Test<int,char> t2(1,'A');  
    Test<char,bool> t3('A',true);  
    Test<int*,int*> t4(&a,&a);  
    Test<const int,const int> t5(1,2);  
    return 0;  
}

结果：

函数模板：

#include <iostream>  
using namespace std;  

//模板函数  
template<typename T1,typename T2>  
void fun(T1 a,T2 b){  
    cout<<"模板函数"<<endl;  
}

//全特化  
template<>  
void fun(int a,char b){  
    cout<<"全特化"<<endl;  
}

//函数不存在偏特化，以下代码是错误的  
/*  
template<typename T2>  
void fun(char a,T2 b){  
    cout<<"偏特化"<<ednl;  
}  
*/  


int main()  
{  
    int a=0;  
    char b='A';  
    fun(a,a);  
    fun(a,b);  
    return 0;  
}

结果：

七、模板类的继承：

模板类的继承包括四种：：

其中，普通类继承模板类比较简单，如：

template<class T>  
class TBase{  
    T data;  
……  
}; 

class Derived:public TBase<int>{  
……  
};

模板类继承普通类：

class TBase{  
……  
}; 

template<class T>  
class TDerived:public TBase{  
T data;  
……  
};

类模板继承类模板：

template<class T>  
class TBase{  
T data1;  
……  
}; 

template<class T1,class T2>  
class TDerived:public TBase<T1>{  
T2 data2;  
……  
};

模板类继承模板参数给出的基类 ——继承哪个基类由模板参数决定：

#include<iostream>  
using namespace std;  

class BaseA{  
public:  
    BaseA(){cout<<"BaseA founed"<<endl;}  
};  

class BaseB{  
public:  
    BaseB(){cout<<"BaseB founed"<<endl;}  
};  

template<typename T, int rows>  
class BaseC{  
private:  
    T data;  
public:  
    BaseC():data(rows){  
        cout<<"BaseC founed "<< data << endl;}  
};  

template<class T>  
class Derived:public T{  
public:  
    Derived():T(){cout<<"Derived founed"<<endl;}  
};  


void main()  
{  
    Derived<Base A> x;// BaseA作为基类  
    Derived<Base B> y;// BaseB作为基类  
    Derived<Base C<int, 3> > z; // BaseC<int,3>作为基类  

}

八、模板实例化问题：

在我们使用类模板时，只有当代码中使用了类模板的一个实例的名字，而且上下文环境要求必须存在类的定义时，这个类模板才被实例化：

文章来源参考：

https://tonglin.blog.csdn.net/article/details