背景
C++ 是很強(qiáng)大瞬浓，有各種特性來提高代碼的可重用性，有助于減少開發(fā)的代碼量和工作量机打。
C++ 提高代碼的可重用性主要有兩方面：
- 繼承
- 模板
繼承的特性我已在前面篇章寫過了矫户，本篇主要是說明「模板」的特性。
使用「模板」的特性設(shè)計残邀，實(shí)際上也就是「泛型」程序設(shè)計皆辽。
函數(shù)模板
01 變量交換函數(shù)模板
假設(shè)我們設(shè)計一個交換兩個整型變量的值的函數(shù)，代碼如下：
// 交換兩個整型變量的值的Swap函數(shù)：
void Swap(int & x,int & y)
{
int tmp = x;
x = y;
y = tmp;
}
如果是浮點(diǎn)類型的變量的值交換芥挣，則替換 int 類型為 double 即可驱闷，代碼如下：
// 交換兩個double型變量的值的Swap函數(shù):
void Swap(double & x,double & y)
{
double tmp = x;
x = y;
y = tmp;
}
那如果是其他變量類型的值交換，那不是每次都要重新寫一次 Swap 函數(shù)空免？是不是很繁瑣空另？且代碼后面會越來越冗余。
能否只寫一個 Swap 函數(shù)蹋砚，就能交換各種類型的變量扼菠？
答案是肯定有的，就是用「函數(shù)模板」來解決坝咐，「函數(shù)模板」的形式：
template <class 類型參數(shù)1循榆，class 類型參數(shù)2，...>
返回值類型 模板名 (形參表)
{
函數(shù)體
};
具體 Swap 「函數(shù)模板」代碼如下：
template 就是模板定義的關(guān)鍵詞墨坚，T 代表的是任意變量的類型秧饮。
template <class T>
void Swap(T & x,T & y)
{
T tmp = x;
x = y;
y = tmp;
}
那么定義好「函數(shù)模板」后，在編譯的時候，編譯器會根據(jù)傳入 Swap 函數(shù)的參數(shù)變量類型浦楣，自動生成對應(yīng)參數(shù)變量類型的 Swap 函數(shù)：
int main()
{
int n = 1,m = 2;
Swap(n,m); //編譯器自動生成 void Swap(int & ,int & )函數(shù)
double f = 1.2,g = 2.3;
Swap(f,g); //編譯器自動生成 void Swap(double & ,double & )函數(shù)
return 0;
}
上面的實(shí)例化函數(shù)模板的例子袖肥，是讓編譯器自己來判斷傳入的變量類型，那么我們也可以自己指定函數(shù)模板的變量類型振劳，具體代碼如下：
int main()
{
int n = 1,m = 2;
Swap<int>(n,m); // 指定模板函數(shù)的變量類型為int
double f = 1.2,g = 2.3;
Swap<double>(f,g); // 指定模板函數(shù)的變量類型為double
return 0;
}
02 查詢數(shù)組最大值函數(shù)模板
在舉一個例子椎组，下面的 MaxElement 函數(shù)定義成了函數(shù)模板，這樣不管是 int历恐、double寸癌、char 等類型的數(shù)組，都可以使用該函數(shù)來查數(shù)組最大的值弱贼，代碼如下：
// 求數(shù)組最大元素的MaxElement函數(shù)模板
template <class T>
T MaxElement(T a[], int size) // size是數(shù)組元素個數(shù)
{
T tmpMax = a[0];
for(int i = 1;i < size;++i)
{
if(tmpMax < a[i])
{
tmpMax = a[i];
}
}
return tmpMax;
}
03 多個類型參數(shù)模板函數(shù)
函數(shù)模板中蒸苇，可以不止一個類型的參數(shù)：
template <class T1, class T2>
T2 MyFun(T1 arg1, T2 arg2)
{
cout<< arg1 << " "<< arg2<<endl;
return arg2;
}
T1 是傳入的第一種任意變量類型，T2 是傳入的第二種任意變量類型吮旅。
04 函數(shù)模板的重載
函數(shù)模板可以重載溪烤，只要它們的形參表或類型參數(shù)表不同即可。
// 模板函數(shù) 1
template<class T1, class T2>
void print(T1 arg1, T2 arg2)
{
cout<< arg1 << " "<< arg2<<endl;
}
// 模板函數(shù) 2
template<class T>
void print(T arg1, T arg2)
{
cout<< arg1 << " "<< arg2<<endl;
}
// 模板函數(shù) 3
template<class T,class T2>
void print(T arg1, T arg2)
{
cout<< arg1 << " "<< arg2<<endl;
}
上面都是 print(參數(shù)1, 參數(shù)2) 模板函數(shù)的重載庇勃，因?yàn)椤感螀⒈怼够颉割愋蛥?shù)表」名字不同檬嘀。
05 函數(shù)模板和函數(shù)的次序
在有多個函數(shù)和函數(shù)模板名字相同的情況下，編譯器如下規(guī)則處理一條函數(shù)調(diào)用語句：
- 先找參數(shù)完全匹配的普通函數(shù)（非由模板實(shí)例化而得的函數(shù)）责嚷；
- 再找參數(shù)完全匹配的模板函數(shù)鸳兽；
- 再找實(shí)參數(shù)經(jīng)過自動類型轉(zhuǎn)換后能夠匹配的普通函數(shù)；
- 上面的都找不到，則報錯。
代碼例子如下：
// 模板函數(shù) - 1個參數(shù)類型
template <class T>
T Max(T a, T b)
{
cout << "TemplateMax" <<endl; return 0;
}
// 模板函數(shù) - 2個參數(shù)類型
template <class T, class T2>
T Max(T a, T2 b)
{
cout << "TemplateMax2" <<endl; return 0;
}
// 普通函數(shù)
double Max(double a, double b)
{
cout << "MyMax" << endl;
return 0;
}
int main()
{
int i=4, j=5;
// 輸出MyMax - 匹配普通函數(shù)
Max( 1.2, 3.4 );
//輸出TemplateMax - 匹配參數(shù)一樣的模板函
Max( i, j );
//輸出TemplateMax2 - 匹配參數(shù)類型不同的模板函數(shù)
Max( 1.2, 3 );
return 0;
}
匹配模板函數(shù)時另绩，當(dāng)模板函數(shù)只有一個參數(shù)類型時，傳入了不同的參數(shù)類型衷掷，是不進(jìn)行類型自動轉(zhuǎn)換，具體例子如下：
// 模板函數(shù) - 1個參數(shù)類型
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)函數(shù)
myFunction(5, 8.4);
類模板
01 類模板的定義
為了多快好省地定義出一批相似的類,可以定義「類模板」柿菩，然后由類模板生成不同的類棍鳖。
類模板的定義形式如下：
template <class 類型參數(shù)1，class 類型參數(shù)2碗旅，...> //類型參數(shù)表
class 類模板名
{
成員函數(shù)和成員變量
};
用類模板定義對象的寫法：
類模板名<真實(shí)類型參數(shù)表> 對象名(構(gòu)造函數(shù)實(shí)參表);
02 Pair類模板例子
接下來渡处，用 Pair 類用類模板的方式的實(shí)現(xiàn)，Pair 是一對的意思祟辟，也就是實(shí)現(xiàn)一個鍵值對（key-value）的關(guān)系的類医瘫。
// 類模板
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;
};
// 類模板里成員函數(shù)的寫法
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;
}
輸出結(jié)果：
1
需要注意的是，同一個類模板的兩個模板類是不兼容的：
Pair<string,int> *p;
Pair<string,double> a;
p = & a; //錯誤＞衫А醇份！
03 函數(shù)模板作為類模板成員
當(dāng)函數(shù)模板作為類模板的成員函數(shù)時稼锅，是可以單獨(dú)寫成函數(shù)模板的形式，成員函數(shù)模板在使用的時候僚纷，編譯器才會把函數(shù)模板根據(jù)傳入的函數(shù)參數(shù)進(jìn)行實(shí)例化矩距，例子如下：
// 類模板
template <class T>
class A
{
public:
template<class T2>
void Func(T2 t) { cout << t; } // 成員函數(shù)模板
};
int main()
{
A<int> a;
a.Func('K'); //成員函數(shù)模板 Func被實(shí)例化
a.Func("hello"); //成員函數(shù)模板 Func再次被實(shí)例化
return 0;
}
04 類模板與非類型參數(shù)
類模板的“<類型參數(shù)表>”中可以出現(xiàn)非類型參數(shù)：
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實(shí)例化得到的類 ，都以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 函數(shù)怖竭、類锥债、類的成員函數(shù)作為類模板的友元
代碼例子如下：
// 普通函數(shù)
void Func1() { }
// 普通類
class A { };
// 普通類
class B
{
public:
void Func() { } // 成員函數(shù)
};
// 類模板
template <class T>
class Tmp
{
friend void Func1(); // 友元函數(shù)
friend class A; // 友元類
friend void B::Func(); // 友元類的成員函數(shù)
}; // 任何從 Tmp 實(shí)例化來的類 ，都有以上三個友元
02 函數(shù)模板作為類模板的友元
// 類模板
template <class T1,class T2>
class Pair
{
private:
T1 key; //關(guān)鍵字
T2 value; //值
public:
Pair(T1 k,T2 v):key(k),value(v) { };
// 友元函數(shù)模板
template <class T3,class T4>
friend ostream & operator<< (ostream & o, const Pair<T3,T4> & p);
};
// 函數(shù)模板
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;
}
輸出結(jié)果：
(Tom,29) (12,3.14)
03 函數(shù)模板作為類的友元
// 普通類
class A
{
private:
int v;
public:
A(int n):v(n) { }
template <class T>
friend void Print(const T & p); // 函數(shù)模板
};
// 函數(shù)模板
template <class T>
void Print(const T & p)
{
cout << p.v;
}
int main()
{
A a(4);
Print(a);
return 0;
}
輸出結(jié)果：
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); // 實(shí)例化B模板類
cout << o.v << endl;
}
};
int main()
{
A<double> a;
a.Func ();
return 0;
}
輸出結(jié)果：
10
類模板與靜態(tài)成員變量
類模板中可以定義靜態(tài)成員痊臭，那么從該類模板實(shí)例化得到的所有類哮肚，都包含同樣的靜態(tài)成員。
template <class T>
class A
{
private:
static int count; // 靜態(tài)成員
public:
A() { count ++; }
~A() { count -- ; };
A( A & ) { count ++ ; }
static void PrintCount() { cout << count << endl; } // 靜態(tài)函數(shù)
};
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
上面的代碼需要注意的點(diǎn)：
- 類模板里的靜態(tài)成員初始化的時候广匙，最前面要加
template<>允趟。 - ia 和 da 對象是不同的模板類，因?yàn)轭愋蛥?shù)是不一致鸦致，所以也就是不同的模板類潮剪。
