模板（Template）指C++程序設計設計語言中採用類型作爲參數的程序設計，支持通用程序設計。C++ 的標準庫提供許多有用的函數大多結合了模板的觀念，如STL以及IO Stream。模板是C++支持參數化多態的工具，使用模板可以使用戶爲類或者函數聲明一種一般模式，使得類中的某些數據成員或者成員函數的參數、返回值取得任意類型。
模板是一種對類型進行參數化的工具；
通常有兩種形式：函數模板和類模板；
函數模板 針對僅參數類型不同的函數；
類模板 針對僅數據成員和成員函數類型不同的類。
使用模板的目的就是能夠讓程序員編寫與類型無關的代碼。
1.函數模板
template <class 形參名，class 形參名，…>
返回類型 函數名(參數列表)
{
函數體
}
其中template和class是關鍵字，class可以用typename 關鍵字代替，在這裏typename 和class沒區別，<>括號中的參數叫模板形參，模板形參和函數形參很相像，模板形參不能爲空。一但聲明瞭模板函數就可以用模板函數的形參名聲明類中的成員變量和成員函數，即可以在該函數中使用內置類型的地方都可以使用模板形參名。模板形參需要調用該模板函數時提供的模板實參來初始化模板形參，一旦編譯器確定了實際的模板實參類型就稱他實例化了函數模板的一個實例。比如swap的模板函數形式爲
template 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)。
2.類模板
1、類模板的格式爲：
template<class 形參名，class 形參名，…>
class 類名{ … };
類模板和函數模板都是以template開始後接模板形參列表組成，模板形參不能爲空，一但聲明瞭類模板就可以用類模板的形參名聲明類中的成員變量和成員函數，即可以在類中使用內置類型的地方都可以使用模板形參名來聲明。比如
template class A
{
public:
T a;
T b;
T hy(T c, T &d);
};
在類A中聲明瞭兩個類型爲T的成員變量a和b，還聲明瞭一個返回類型爲T帶兩個參數類型爲T的函數hy。
2、類模板對象的創建：比如一個模板類A，則使用類模板創建對象的方法爲A m;在類A後面跟上一個<>尖括號並在裏面填上相應的類型，這樣的話類A中凡是用到模板形參的地方都會被int 所代替。當類模板有兩個模板形參時創建對象的方法爲A<int, double> m;類型之間用逗號隔開。
3、對於類模板，模板形參的類型必須在類名後的尖括號中明確指定。比如A<2> m;用這種方法把模板形參設置爲int是錯誤的（編譯錯誤：error C2079: ‘a’ uses undefined class ‘A’），類模板形參不存在實參推演的問題。也就是說不能把整型值2推演爲int 型傳遞給模板形參。要把類模板形參調置爲int 型必須這樣指定A m。
4、在類模板外部定義成員函數的方法爲：
template<模板形參列表> 函數返回類型 類名<模板形參名>::函數名(參數列表){函數體}
比如有兩個模板形參T1，T2的類A中含有一個void h()函數，則定義該函數的語法爲：
template<class T1,class T2> void A<T1,T2>::h(){}。
注意：當在類外面定義類的成員時template後面的模板形參應與要定義的類的模板形參一致。
5、再次提醒注意：模板的聲明或定義只能在全局，命名空間或類範圍內進行。即不能在局部範圍，函數內進行，比如不能在main函數中聲明或定義一個模板。
3.模板的非類型形參
1 、非類型模板形參：模板的非類型形參也就是內置類型形參，如template<class T, int a> class B{};其中int a就是非類型的模板形參。
2、 非類型形參在模板定義的內部是常量值，也就是說非類型形參在模板的內部是常量。
3、 非類型模板的形參只能是整型，指針和引用，像double，String, String **這樣的類型是不允許的。但是double &，double *，對象的引用或指針是正確的。
4、 調用非類型模板形參的實參必須是一個常量表達式，即他必須能在編譯時計算出結果。
5 、注意：任何局部對象，局部變量，局部對象的地址，局部變量的地址都不是一個常量表達式，都不能用作非類型模板形參的實參。全局指針類型，全局變量，全局對象也不是一個常量表達式，不能用作非類型模板形參的實參。
6、 全局變量的地址或引用，全局對象的地址或引用const類型變量是常量表達式，可以用作非類型模板形參的實參。
7 、sizeof表達式的結果是一個常量表達式，也能用作非類型模板形參的實參。
8 、當模板的形參是整型時調用該模板時的實參必須是整型的，且在編譯期間是常量，比如template <class T, int a> class A{};如果有int b，這時A<int, b> m;將出錯，因爲b不是常量，如果const int b，這時A<int, b> m;就是正確的，因爲這時b是常量。
9 、非類型形參一般不應用於函數模板中，比如有函數模板template<class T, int a> void h(T b){}，若使用h(2)調用會出現無法爲非類型形參a推演出參數的錯誤，對這種模板函數可以用顯示模板實參來解決，如用h<int, 3>(2)這樣就把非類型形參a設置爲整數3。顯示模板實參在後面介紹。
10、 非類型模板形參的形參和實參間所允許的轉換
1、允許從數組到指針，從函數到指針的轉換。如：template <int *a> class A{}; int b[1]; A m;即數組到指針的轉換
2、const修飾符的轉換。如：template<const int *a> class A{}; int b; A<&b> m; 即從int *到const int *的轉換。
3、提升轉換。如：template class A{}; const short b=2; A m; 即從short到int 的提升轉換
4、整值轉換。如：template class A{}; A<3> m; 即從int 到unsigned int的轉換。
5、常規轉換。
4.類模板的默認模板類型形參
1、可以爲類模板的類型形參提供默認值，但不能爲函數模板的類型形參提供默認值。函數模板和類模板都可以爲模板的非類型形參提供默認值。
2、類模板的類型形參默認值形式爲：template<class T1, class T2=int> class A{};爲第二個模板類型形參T2提供int型的默認值。
3、類模板類型形參默認值和函數的默認參數一樣，如果有多個類型形參則從第一個形參設定了默認值之後的所有模板形參都要設定默認值，比如templateclass A{};就是錯誤的，因爲T1給出了默認值，而T2沒有設定。
4、在類模板的外部定義類中的成員時template 後的形參表應省略默認的形參類型。比如template<class T1, class T2=int> class A{public: void h();}; 定義方法爲template<class T1,class T2> void A<T1,T2>::h(){}。
5.模板的實例化
總結一下，C++只有模板顯式實例化(explicit instantiation),隱式實例化(implicit instantiation),特化(specialization,也譯作具體化，偏特化)。首先考慮如下模板函數代碼:
[cpp] view plaincopyprint?
template
void swap(T &a, T &b){
…
}
1.隱式實例化
我們知道，模板函數不是真正的函數定義，他只是如其名提供一個模板，模板只有在運行時纔會生成相應的實例，隱式實例化就是這種情況:
[cpp] view plaincopyprint?
int main(){
…
swap(a,b);
…
}
它會在運行到這裏的時候才生成相應的實例，很顯然的影響效率
這裏順便提一下swap(a,b);中的是可選的,因爲編譯器可以根據函數參數類型自動進行判斷,也就是說如果編譯器不不能自動判斷的時候這個就是必要的;
2.顯式實例化
前面已經提到隱式實例化可能影響效率,所以需要提高效率的顯式實例化,顯式實例化在編譯期間就會生成實例,方法如下:
[cpp] view plaincopyprint?
template void swap(int &a,int &b);
這樣就不會影響運行時的效率，但編譯時間隨之增加。
3.特化
這個swap可以處理一些基本類型如long int double,但是如果想處理用戶自定義的類型就不行了,特化就是爲了解決這個問題而出現的:
[cpp] view plaincopyprint?
template <> void swap(job a,job b){…}
其中job是用戶定義的類型.
6.模板的特化（具體化）和偏特化
類模板：
測試代碼如下：
#include
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 //由於只指定了一部分參數，剩下的未指定的需在參數列表中，否則報錯。
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
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
void fun(char a,T2 b){
cout<<“偏特化”<<ednl;
}
*/
int main()
{
int a=0;
char b=‘A’;
fun(a,a);
fun(a,b);
return 0;
}
運行截圖如下：
在這裏插入圖片描述
7.模板類的繼承
模板類的繼承包括四種：
1.（普通類繼承模板類）
2.（模板類繼承了普通類（非常常見））
3.（類模板繼承類模板）
4.（模板類繼承類模板，即繼承模板參數給出的基類）
其中，普通類繼承模板類比較簡單，如
1 template
2 class TBase{
3 T data;
4 ……
5 };
6 class Derived:public TBase{
7 ……
8 };
模板類繼承普通類：
1 class TBase{
2 ……
3 };
4 template
5 class TDerived:public TBase{
6 T data;
7 ……
8 };
類模板繼承類模板：
1 template
2 class TBase{
3 T data1;
4 ……
5 };
6 template<class T1,class T2>
7 class TDerived:public TBase{
8 T2 data2;
9 ……
10 };
模板類繼承模板參數給出的基類
——繼承哪個基類由模板參數決定
#include
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 Derived:public T{
public:
Derived():T(){cout<<“Derived founed”<<endl;}
};
void main()
{
Derived x;// BaseA作爲基類
Derived y;// BaseB作爲基類
Derived<Base C<int, 3> > z; // BaseC<int,3>作爲基類
模板實例化問題：
在我們使用類模板時，只有當代碼中使用了類模板的一個實例的名字，而且上下文環境要求必須存在類的定義時，這個類模板才被實例化。
1.聲明一個類模板的指針和引用，不會引起類模板的實例化，因爲沒有必要知道該類的定義。
2.定義一個類類型的對象時需要該類的定義，因此類模板會被實例化。
3.在使用sizeof()時，它是計算對象的大小，編譯器必須根據類型將其實例化出來，所以類模板被實例化.
4.new表達式要求類模板被實例化。
5.引用類模板的成員會導致類模板被編譯器實例化。
6.需要注意的是，類模板的成員函數本身也是一個模板。標準C++要求這樣的成員函數只有在被調用或者取地址的時候，才被實例化。用來實例化成員函數的類型，就是其成員函數要調用的那個類對象的類型
原文：https://blog.csdn.net/tonglin12138/article/details/88595747