技術標籤：C++c++template模板

寫在前面

模板（Template）指C++程式設計設計語言中採用型別作為引數的程式設計，支援通用程式設計。C++ 的標準庫提供許多有用的函式大多結合了模板的觀念，如STL以及IO Stream。模板是C++支援引數化多型的工具，使用模板可以使使用者為類或者函式宣告一種一般模式，使得類中的某些資料成員或者成員函式的引數、返回值取得任意型別。
模板是 C++ 的一項功能，使得類和函式能夠支援泛型。
模板是一種對型別進行引數化的工具；
通常有兩種形式：函式模板和類模板；
函式模板 針對僅引數型別不同的函式；
類模板 針對僅資料成員和成員函式型別不同的類。

1.函式模板

　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)。

2.類模板

1、類模板的格式為：

　　　　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。

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 <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是使用者定義的型別.

6.模板的特化（具體化）和偏特化

類模板：

測試程式碼如下：

#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;
}

執行截圖如下：

7.模板類的繼承

模板類的繼承包括四種：

1.（普通類繼承模板類）

2.（模板類繼承了普通類（非常常見））

3.（類模板繼承類模板）

4.（模板類繼承類模板，即繼承模板引數給出的基類）

其中，普通類繼承模板類比較簡單，如

1 template<class T>
2 class TBase{
3     T data;
4 ……
5 };
6 class Derived:public TBase<int>{
7 ……
8 };

模板類繼承普通類：

1 class TBase{
2 ……
3 };
4 template<class T>
5 class TDerived:public TBase{
6 T data;
7 ……
8 };

類模板繼承類模板：

 1 template<class T>
 2 class TBase{
 3 T data1;
 4 ……
 5 };
 6 template<class T1,class T2>
 7 class TDerived:public TBase<T1>{
 8 T2 data2;
 9 ……
10 };

模板類繼承模板引數給出的基類
——繼承哪個基類由模板引數決定

#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>作為基類
    

模板例項化問題：

在我們使用類模板時，只有當代碼中使用了類模板的一個例項的名字，而且上下文環境要求必須存在類的定義時，這個類模板才被例項化。

1.宣告一個類模板的指標和引用，不會引起類模板的例項化，因為沒有必要知道該類的定義。

2.定義一個類型別的物件時需要該類的定義，因此類模板會被例項化。

3.在使用sizeof()時，它是計算物件的大小，編譯器必須根據型別將其例項化出來，所以類模板被例項化.

4.new表示式要求類模板被例項化。

5.引用類模板的成員會導致類模板被編譯器例項化。

6.需要注意的是，類模板的成員函式本身也是一個模板。標準C++要求這樣的成員函式只有在被呼叫或者取地址的時候，才被例項化。用來例項化成員函式的型別，就是其成員函式要呼叫的那個類物件的型別