深度解析C++的函數模板與類模板

一、函數模板

1、定義

template <class 型別參數1，class 型別參數2,……>
傳回值類型 模板名 (形參表){
函數體
};

template <class T1, class T2>T2 print(T1 arg1, T2 arg2){    cout<< arg1 << " "<< arg2<<endl;    return arg2;}

2、不通過參數執行個體化函數模板

#include <iostream>using namespace std;template <class T>T Inc(T n){    return 1 + n;}int main(){    cout << Inc<double>(4)/2; //輸出 2.5    return 0;}

3、函數模板可以重載，只要它們的形參表或型別參數表不同即可

template<class T1, class T2>void print(T1 arg1, T2 arg2) {    cout<< arg1 << " "<< arg2<<endl;}template<class T>void print(T arg1, T arg2) {    cout<< arg1 << " "<< arg2<<endl;}template<class T,class T2>void print(T arg1, T arg2) {    cout<< arg1 << " "<< arg2<<endl;}

4、函數模板和函數的次序

在有多個函數和函數模板名字相同的情況下，編譯器如下處理一條函數調用語句

• 先找參數完全符合的普通函數(非由模板執行個體化而得的函數)。

• 再找參數完全符合的模板函數。

• 再找實參數經過自動類型轉換後能夠匹配的普通函數。

• 上面的都找不到，則報錯。

template <class T>T Max( T a, T b) {    cout << "TemplateMax" <<endl; return 0;}template <class T,class T2>T Max( T a, T2 b) {    cout << "TemplateMax2" <<endl; return 0;}double Max(double a, double b){    cout << "MyMax" << endl; return 0;}int main() {    Max( 1.2,3.4);     // 輸出MyMax    Max(4, 5);         //輸出TemplateMax    Max( 1.2, 3);      //輸出TemplateMax2    return 0;}

5、匹配模板函數時，不進行類型自動轉換

template<class T>T myFunction( T arg1, T arg2){ cout<<arg1<<" "<<arg2<<"\n"; return arg1;}……myFunction( 5, 7);      //ok ：replace T with intmyFunction( 5.8, 8.4);  //ok： ： replace T with doublemyFunction( 5, 8.4);    //error ，no matching function for callto 'myFunction(int, double)'

二、類模板

1、定義

在定義類的時候，加上一個/多個型別參數。在使用類模板時，指定型別參數應該如何替換成具體類型，編譯器據此產生相應的模板類。

template <class 型別參數1，class 型別參數2，……> //型別參數表
class 類模板名{
成員函數和成員變數
};

（1）類模板裡成員函數的寫法：
template <class 型別參數1，class 型別參數2，……> //型別參數表
傳回值類型 類模板名<型別參數名列表>::成員函數名（參數表）{
……
}
（2）用類模板定義對象的寫法：
類模板名 <真實型別參數表> 對象名(建構函式實參表);

// Pair類模板template <class T1,class T2>class Pair{public:    T1 key; //關鍵字    T2 value; //值    Pair(T1 k,T2 v):key(k),value(v) { };    bool operator < ( const Pair<T1,T2> & p) const;};template<class T1,class T2>bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const{  //Pair的成員函數 operator <    return key < p.key;}int main(){    Pair<string,int> student("Tom",19);   //執行個體化出一個類 Pair<string,int>    cout << student.key << " " << student.value;    return 0;}//輸出：Tom 19

2、用類模板定義對象

• 編譯器由類模板產生類的過程叫類模板的執行個體化。由類模板執行個體化得到的類，叫模板類。

• 同一個類模板的兩個模板類是不相容的。

3、函數模版作為類模板成員

template <class T>class A{    public:        template<class T2>        void Func( T2 t) { cout << t; } //成員函數模板};

4、類模板與非型別參數：類模板的“<型別參數表>”中可以出現非型別參數

template <class T, int size>class CArray{    T array[size];public:    void Print(){        for( int i = 0;i < size; ++i)        cout << array[i] << endl;    }};CArray<double,40> a2;CArray<int,50> a3;     //a2和a3屬於不同的類

5、類模板與派生

（1）類模板從類模板派生

template <class T1,class T2>              int main() {class A {                                        B<int,double> obj1;    T1 v1; T2 v2;                                C<int> obj2;};                                               return 0;template <class T1,class T2>              }class B:public A<T2,T1> {                 class B<int,double>:    T1 v3; T2 v4;                             public A<double,int>{};                                            int v3; double v4;template <class T>                        };class C:public B<T,T> {    T v5;};

（2）類模板從模板類派生

template <class T1,class T2>class A {    T1 v1; T2 v2;};template <class T>class B:public A<int,double> {    T v;};int main() {    B<char> obj1;     //自動產生兩個模板類 ：A<int,double> 和 B<char>    return 0;}

（3）類模板從普通類派生

class A {    int v1;};template <class T>    class B:public A { //所有從B執行個體化得到的類 ，都以A為基類    T v;};int main() {    B<char> obj1;    return 0;}

（4）普通類從模板類派生

template <class T>class A {    T v1;    int n;};class B:public A<int> {    double v;};int main() {    B obj1;    return 0;}

6、類模板與友員函數
（1）函數、類、類的成員函數作為類模板的友元

void Func1() { }class A { };class B{    public:        void Func() { }};template <class T>class Tmpl{    friend void Func1();    friend class A;    friend void B::Func();}; //任何從Tmp1執行個體化來的類 ，都有以上三個友元

（2）函數模板作為類模板的友元

#include <iostream>#include <string>using namespace std;template <class T1,class T2>class Pair{    private:        T1 key; //關鍵字        T2 value; //值    public:        Pair(T1 k,T2 v):key(k),value(v) { };        bool operator < ( const Pair<T1,T2> & p) const;        template <class T3,class T4>        friend ostream & operator<< ( ostream & o,const Pair<T3,T4> & p);};template <class T1,class T2>bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const{ //"小"的意思就是關鍵字小    return key < p.key;}template <class T1,class T2>ostream & operator<< (ostream & o,const Pair<T1,T2> & p){    o << "(" << p.key << "," << p.value << ")" ;    return o;}int main(){    Pair<string,int> student("Tom",29);    Pair<int,double> obj(12,3.14);    cout << student << " " << obj;    return 0;}//輸出：(Tom,29) (12,3.14)任意從 template <class T1,class T2>       ostream & operator<< (ostream & o,const Pair<T1,T2> & p)產生的函數，都是任意Pair摸板類的友元

（3）函數模板作為類的友元

#include <iostream>using namespace std;class A{    int v;public:    A(int n):v(n) { }    template <class T>    friend void Print(const T & p);};template <class T>void Print(const T & p){    cout << p.v;}int main() {    A a(4);    Print(a);    return 0;}//輸出：4

（4）類模板作為類模板的友元

template <class T>class B {    T v;public:    B(T n):v(n) { }    template <class T2>    friend class A;};template <class T>class A {    public:    void Func( )  {        B<int> o(10);        cout << o.v << endl;    }};

7、類模板與靜態成員變數

類模板中可以定義靜態成員 ，那麼從該類模板執行個體化得到的所有類 ，都包含同樣的靜態成員 。

#include <iostream>using namespace std;template <class T>class A{    private:        static int count;    public:        A() { count ++; }        ~A() { count -- ; };        A( A & ) { count ++ ; }        static void PrintCount() { cout << count << endl; }};template<> int A<int>::count = 0;template<> int A<double>::count = 0;int main(){    A<int> ia;    A<double> da;    ia.PrintCount();    da.PrintCount();    return 0;}//輸出：1  1