C++ 模板常見特性（函數模板、類模板） 背景 函數模板 類模板 類模板與派生 類模板與友元 類模板與靜態成員變量

背景

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. 先找參數完全匹配的普通函數（非由模板實例化而得的函數）；
2. 再找參數完全匹配的模板函數；
3. 再找實參數經過自動類型轉換後能夠匹配的普通函數；
4. 上面的都找不到，則報錯。

代碼例子如下：

// 模板函數 - 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;
}

輸出結果：

1

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

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

輸出結果：

4

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

輸出結果：

10

類模板與靜態成員變量

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

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 對象是不同的模板類，因爲類型參數是不一致，所以也就是不同的模板類。