泛型編程的第一步，掌握模板的特性！
- 2020 年 3 月 31 日
- 筆記
— 1 —
認識
C++ 是很強大，有各種特性來提高程式碼的可重用性，有助於減少開發的程式碼量和工作量。
C++ 提高程式碼的可重用性主要有兩方面：
- 繼承
- 模板
繼承的特性我已在前面篇章寫過了「C++ 一篇搞懂繼承的常見特性」。
本篇主要是說明「模板」的特性，使用「模板」的特性設計，實際上也就是「泛型」程式設計。
— 2 —
函數模板
|| 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 <class T> void Swap(T & x,T & y) { T tmp = x; x = y; y = tmp; }
template 就是模板定義的關鍵詞，T 代表的是任意變數的類型。
那麼定義好「函數模板」後，在編譯的時候，編譯器會根據傳入 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; }
- 第 4 行編譯器自動生成 void Swap(int &, int & ) 函數；
- 第 7 行編譯器自動生成 void Swap(double &, double & ) 函數。
上面的實例化函數模板的例子，是讓編譯器自己來判斷傳入的變數類型，那麼我們也可以自己指定函數模板的變數類型，具體程式碼如下：
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; }
- 第 4 行指定模板函數的變數類型為 int ；
- 第 7 行指定模板函數的變數類型為 double 。
— —
|| 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; }
- 第 27 行，輸出的是MyMax，因為匹配的是普通函數；
- 第 30 行，輸出的是輸出TemplateMax，因為匹配參數一樣的模板函；
- 第 33 行，輸出的是TemplateMax2，因為匹配參數類型不同的模板函數。
匹配模板函數時，當模板函數只有一個參數類型時，傳入了不同的參數類型，是不進行類型自動轉換，具體例子如下：
// 模板函數 - 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);
- 第 12 行，可以正常執行，替換 T 為 int 類型；
- 第 15 行，可以正常執行，替換 T 為 double 類型 ；
- 第 18 行，會執行錯誤！因為沒有匹配到 myFunction(int, double)函數。
— 3 —
類模板
|| 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屬於不同的類
— 4 —
類模板和派生
|| 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; }
- 第 16 行，在創建 B類 對象，會自動生成兩個模板類 ：A<int,double> 和 B<char> 。
— —
|| 03 類模板從普通類派生
上圖的程式碼例子如下：
// 基類 - 普通類 class A { int v1; }; // 派生類 - 類模板 template <class T> class B:public A // 所有從B實例化得到的類 ，都以A為基類 { T v; }; int main() { B<char> obj1; return 0; }
- 第 16 行，在創建 B 類對象前，會先構造基類 A 對象。
— —
|| 04 普通類從模板類派生
上圖的程式碼例子如下：
template <class T> class A { T v1; }; class B : public A<int> { double v; }; int main() { B obj1; return 0; }
- 第 14 行，在構造 B 類對象前，會先實例化 A 模板對象。
— 5 —
類模板與友元
|| 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 實例化來的類 ，都有以上三個友元
任何從 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
— 6 —
類模板與靜態成員函數
類模板中可以定義靜態成員，那麼從該類模板實例化得到的所有類，都包含同樣的靜態成員。
見下面的例子：
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 對象是不同的模板類，因為類型參數是不一致，所以也就是不同的模板類。
