微信公眾號：「小林coding」
用簡潔的方式，分享編程小知識，

背景

C++ 是很強大，有各種特性來提高代碼的可重用性，有助于減少開發的代碼量和作業量，

C++ 提高代碼的可重用性主要有兩方面：

繼承
模板

繼承的特性我已在前面篇章寫過了，本篇主要是說明「模板」的特性，

使用「模板」的特性設計，實際上也就是「泛型」程式設計，

函式模板

01 變數交換函式模板

假設我們設計一個交換兩個整型變數的值的函式，代碼如下：

// 交換兩個整型變數的值的Swap函式：
void Swap(int & x,int & y)
{
    int tmp = x;
    x = y;
    y = tmp;
}

如果是浮點型別的變數的值交換，則替換 int 型別為 double 即可，代碼如下：

// 交換兩個double型變數的值的Swap函式:
void Swap(double & x,double & y)
{
    double tmp = x;
    x = y;
    y = tmp;
}

那如果是其他變數型別的值交換，那不是每次都要重新寫一次 Swap 函式？是不是很繁瑣？且代碼后面會越來越冗余，

能否只寫一個 Swap 函式，就能交換各種型別的變數？

答案是肯定有的，就是用「函式模板」來解決，「函式模板」的形式：

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

具體 Swap 「函式模板」代碼如下：

template 就是模板定義的關鍵詞，T 代表的是任意變數的型別，

template <class T>
void Swap(T & x,T & y)
{
    T tmp = x;
    x = y;
    y = tmp;
}

那么定義好「函式模板」后，在編譯的時候，編譯器會根據傳入 Swap 函式的引數變數型別，自動生成對應引數變數型別的 Swap 函式：

int main()
{
    int n = 1,m = 2;
    Swap(n,m); //編譯器自動生成 void Swap(int & ,int & )函式
    
    double f = 1.2,g = 2.3;
    Swap(f,g); //編譯器自動生成 void Swap(double & ,double & )函式
    
    return 0;
}

上面的實體化函式模板的例子，是讓編譯器自己來判斷傳入的變數型別，那么我們也可以自己指定函式模板的變數型別，具體代碼如下：

int main()
{
    int n = 1,m = 2;
    Swap<int>(n,m);     // 指定模板函式的變數型別為int
    
    double f = 1.2,g = 2.3;
    Swap<double>(f,g); // 指定模板函式的變數型別為double
    
    return 0;
}

02 查詢陣列最大值函式模板

在舉一個例子，下面的 MaxElement 函式定義成了函式模板，這樣不管是 int、double、char 等型別的陣列，都可以使用該函式來查陣列最大的值，代碼如下：

// 求陣列最大元素的MaxElement函式模板
template <class T>
T MaxElement(T a[], int size) // size是陣列元素個數
{
    T tmpMax = a[0];
    for(int i = 1;i < size;++i)
    {
        if(tmpMax < a[i])
        {
            tmpMax = a[i];
        }
    }
    return tmpMax;
}

03 多個型別引數模板函式

函式模板中，可以不止一個型別的引數：

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

T1 是傳入的第一種任意變數型別，T2 是傳入的第二種任意變數型別，

04 函式模板的多載

函式模板可以多載，只要它們的形參表或型別引數表不同即可，

// 模板函式 1
template<class T1, class T2>
void print(T1 arg1, T2 arg2) 
{
    cout<< arg1 << " "<< arg2<<endl;
}

// 模板函式 2
template<class T>
void print(T arg1, T arg2) 
{
    cout<< arg1 << " "<< arg2<<endl;
}

// 模板函式 3
template<class T,class T2>
void print(T arg1, T arg2) 
{
    cout<< arg1 << " "<< arg2<<endl;
}

上面都是 print(引數1, 引數2) 模板函式的多載，因為「形參表」或「型別引數表」名字不同，

05 函式模板和函式的次序

在有多個函式和函式模板名字相同的情況下，編譯器如下規則處理一條函式呼叫陳述句：

先找引數完全匹配的普通函式（非由模板實體化而得的函式）；
再找引數完全匹配的模板函式；
再找實引數經過自動型別轉換后能夠匹配的普通函式；
上面的都找不到，則報錯，

代碼例子如下：

// 模板函式 - 1個引數型別
template <class T>
T Max(T a, T b) 
{
    cout << "TemplateMax" <<endl; return 0;
}

// 模板函式 - 2個引數型別
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() 
{
    int i=4, j=5;
    
    // 輸出MyMax - 匹配普通函式
    Max( 1.2, 3.4 ); 
    
    //輸出TemplateMax - 匹配引數一樣的模板函
    Max( i, j );
    
    //輸出TemplateMax2 - 匹配引數型別不同的模板函式
    Max( 1.2, 3 );   
    
    return 0;
}

匹配模板函式時，當模板函式只有一個引數型別時，傳入了不同的引數型別，是不進行型別自動轉換，具體例子如下：

// 模板函式 - 1個引數型別
template<class T>
T myFunction( T arg1, T arg2)
{ 
    cout<<arg1<<" "<<arg2<<"\n"; 
    return arg1;
}

...

// OK ：替換 T 為 int 型別
myFunction( 5, 7); 

// OK ：替換 T 為 double 型別  
myFunction(5.8, 8.4);

// error ：沒有匹配到myFunction(int, double)函式
myFunction(5, 8.4);

類模板

01 類模板的定義

為了多快好省地定義出一批相似的類,可以定義「類模板」，然后由類模板生成不同的類，

類模板的定義形式如下：

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

用類模板定義物件的寫法：

類模板名<真實型別引數表> 物件名(建構式實參表);

02 Pair類模板例子

接下來，用 Pair 類用類模板的方式的實作，Pair 是一對的意思，也就是實作一個鍵值對（key-value）的關系的類，

// 類模板
template <class T1, class T2>
class Pair
{
public:
    Pair(T1 k, T2 v):m_key(k),m_value(v) {};
    bool operator < (const Pair<T1,T2> & p) const;
private:
    T1 m_key;
    T2 m_value;
};

// 類模板里成員函式的寫法
template <class T1, class T2>
bool Pair<T1,T2>::operator < (const Pair<T1,T2> &p) const
{
    return m_value < p.m_value;
}

int main()
{
    Pair<string,int> Astudent("Jay",20); 
    Pair<string,int> Bstudent("Tom",21);
    
    cout << (Astudent < Bstudent) << endl;
    
    return 0;
}

輸出結果：

需要注意的是，同一個類模板的兩個模板類是不兼容的：

Pair<string,int> *p;
Pair<string,double> a;
p = & a; //錯誤！！

03 函式模板作為類模板成員

當函式模板作為類模板的成員函式時，是可以單獨寫成函式模板的形式，成員函式模板在使用的時候，編譯器才會把函式模板根據傳入的函式引數進行實體化，例子如下：

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

int main()
{
    A<int> a;
    a.Func('K');     //成員函式模板 Func被實體化
    a.Func("hello"); //成員函式模板 Func再次被實體化

    return 0;
}

04 類模板與非型別引數

類模板的“<型別引數表>”中可以出現非型別引數：

template <class T, int size>
class CArray
{
public:
    void Print( )
    {
        for( int i = 0;i < size; ++i)
        cout << array[i] << endl;
    }
private:
    T array[size];
};

CArray<double,40> a2;
CArray<int,50> a3; //a2和a3屬于不同的類

類模板與派生

01 類模板從類模板派生

上圖的代碼例子如下：

// 基類 - 類模板
template <class T1,class T2>
class A 
{
    T1 v1; T2 v2;
};

// 派生類 - 類模板
template <class T1,class T2>
class B:public A<T2,T1> 
{
    T1 v3; T2 v4;
};

// 派生類 - 類模板
template <class T>
class C:public B<T,T> 
{
    T v5;
};

int main() 
{
    B<int,double> obj1; 
    C<int> obj2;
    return 0;
}

02 類模板從模板類派生

上圖的代碼例子如下：

template <class T1,class T2>
class A 
{
    T1 v1; T2 v2;
};

template <class T>
class B:public A<int,double>  // A<int,double> 模板類
{
    T v;
};

int main() 
{
    //自動生成兩個模板類 ：A<int,double> 和 B<char>
    B<char> obj1;
    return 0;
}

03 類模板從普通類派生

上圖的代碼例子如下：

// 基類 - 普通類
class A 
{
    int v1;
};

// 派生類 - 類模板
template <class T>
class B:public A  // 所有從B實體化得到的類 ，都以A為基類
{ 
    T v;
};

int main() 
{
    B<char> obj1;
    return 0;
}

04 普通類從模板類派生

上圖的代碼例子如下：

template <class T>
class A 
{
    T v1;
};

class B:public A<int> 
{
    double v;
};

int main() 
{
    B obj1;
    return 0;
}

類模板與友元

01 函式、類、類的成員函式作為類模板的友元

代碼例子如下：

// 普通函式
void Func1() { } 

// 普通類
class A { }; 

// 普通類
class B 
{
    public:
    void Func() { } // 成員函式
};

// 類模板
template <class T>
class Tmp
{
    friend void Func1();    // 友元函式
    friend class A;         // 友元類
    friend void B::Func();  // 友元類的成員函式
}; // 任何從 Tmp 實體化來的類 ，都有以上三個友元

02 函式模板作為類模板的友元

// 類模板
template <class T1,class T2>
class Pair
{
private:
    T1 key;   //關鍵字
    T2 value; //值
public:
    Pair(T1 k,T2 v):key(k),value(v) { };
    
    // 友元函式模板
    template <class T3,class T4>
    friend ostream & operator<< (ostream & o, const Pair<T3,T4> & p);
};

// 函式模板
template <class T3,class T4>
ostream & operator<< (ostream & o, const Pair<T3,T4> & 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)

03 函式模板作為類的友元

// 普通類
class A
{
private:
    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;
}

輸出結果：

04 類模板作為類模板的友元

// 類模板
template <class T>
class B 
{
private:
    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); // 實體化B模板類
        cout << o.v << endl;
    }
};

int main()
{
    A<double> a;
    a.Func ();
    return 0;
}

輸出結果：

類模板與靜態成員變數

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

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; // da和ia不是相同模板類
    ia.PrintCount();
    da.PrintCount();
    return 0;
}

輸出：

1
1

上面的代碼需要注意的點：

類模板里的靜態成員初始化的時候，最前面要加template<>，
ia 和 da 物件是不同的模板類，因為型別引數是不一致，所以也就是不同的模板類，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/73331.html

標籤：C++

上一篇：使用技巧 --- 與VS Code相關

下一篇：關于非旋轉Treap

C++ 模板常見特性（函式模板、類模板）

背景

函式模板

01 變數交換函式模板

02 查詢陣列最大值函式模板

03 多個型別引數模板函式

04 函式模板的多載

05 函式模板和函式的次序

類模板

01 類模板的定義

02 Pair類模板例子

03 函式模板作為類模板成員

04 類模板與非型別引數

類模板與派生

01 類模板從類模板派生

02 類模板從模板類派生

03 類模板從普通類派生

04 普通類從模板類派生

類模板與友元

01 函式、類、類的成員函式作為類模板的友元

02 函式模板作為類模板的友元

03 函式模板作為類的友元

04 類模板作為類模板的友元

類模板與靜態成員變數