1. 模板的概念。
我們已經學過重載(Overloading),對重載函數而言,C++的檢查機制能通過函數參數的不同及所屬類的不同。正確的調用重載函數。例如,爲求兩個數的最大值,我們定義MAX()函數需要對不同的數據類型分別定義不同重載(Overload)版本。
//函數1.
int max(int x,int y);
{return(x>y)?x:y ;}
//函數2.
float max( float x,float y){
return (x>y)? x:y ;}
//函數3.
double max(double x,double y)
{return (c>y)? x:y ;}
但如果在主函數中,我們分別定義了 char a,b; 那麼在執行max(a,b);時 程序就會出錯,因爲我們沒有定義char類型的重載版本。
現在,我們再重新審視上述的max()函數,它們都具有同樣的功能,即求兩個數的最大值,能否只寫一套代碼解決這個問題呢?這樣就會避免因重載函數定義不 全面而帶來的調用錯誤。爲解決上述問題C++引入模板機制,模板定義:模板就是實現代碼重用機制的一種工具,它可以實現類型參數化,即把類型定義爲參數, 從而實現了真正的代碼可重用性。模版可以分爲兩類,一個是函數模版,另外一個是類模版。
2. 函數模板的寫法
函數模板的一般形式如下:
Template <class或者也可以用typename T>
返回類型 函數名(形參表)
{//函數定義體 }
說明: template是一個聲明模板的關鍵字,表示聲明一個模板關鍵字class不能省略,如果類型形參多餘一個 ,每個形參前都要加class <類型 形參表>可以包含基本數據類型可以包含類類型.
請看以下程序:
//Test.cpp
#include <iostream>
using std::cout;
using std::endl;
//聲明一個函數模版,用來比較輸入的兩個相同數據類型的參數的大小,class也可以被typename代替,
//T可以被任何字母或者數字代替。
template <class T>
T min(T x,T y)
{ return(x<y)?x:y;}
void main( )
{
int n1=2,n2=10;
double d1=1.5,d2=5.6;
cout<< "較小整數:"<<min(n1,n2)<<endl;
cout<< "較小實數:"<<min(d1,d2)<<endl;
system("PAUSE");
}
程序運行結果:
程序分析:main()函數中定義了兩個整型變量n1 , n2 兩個雙精度類型變量d1 , d2然後調用min( n1, n2); 即實例化函數模板T min(T x, T y)其中T爲int型,求出n1,n2中的最小值.同理調用min(d1,d2)時,求出d1,d2中的最小值.
3. 類模板的寫法
定義一個類模板:
Template < class或者也可以用typename T >
class類名{
//類定義......
};
說明:其中,template是聲明各模板的關鍵字,表示聲明一個模板,模板參數可以是一個,也可以是多個。
例如:定義一個類模板:
// ClassTemplate.h
#ifndef ClassTemplate_HH
#define ClassTemplate_HH
template<typename T1,typename T2>
class myClass{
private:
T1 I;
T2 J;
public:
myClass(T1 a, T2 b);//Constructor
void show();
};
//這是構造函數
//注意這些格式
template <typename T1,typename T2>
myClass<T1,T2>::myClass(T1 a,T2 b):I(a),J(b){}
//這是void show();
template <typename T1,typename T2>
void myClass<T1,T2>::show()
{
cout<<"I="<<I<<", J="<<J<<endl;
}
#endif
// Test.cpp
#include <iostream>
#include "ClassTemplate.h"
using std::cout;
using std::endl;
void main()
{
myClass<int,int> class1(3,5);
class1.show();
myClass<int,char> class2(3,'a');
class2.show();
myClass<double,int> class3(2.9,10);
class3.show();
system("PAUSE");
}
最後結果顯示:
一般來說,非類型模板參數可以是常整數(包括枚舉)或者指向外部鏈接對象的指針。
那麼就是說,浮點數是不行的,指向內部鏈接對象的指針是不行的。
template<typename T, int MAXSIZE>
class Stack{
Private:
T elems[MAXSIZE];
…
};
Int main()
{
Stack<int, 20> int20Stack;
Stack<int, 40> int40Stack;
…
};
5.使用模板類型
有時模板類型是一個容器或類,要使用該類型下的類型可以直接調用,以下是一個可打印STL中順序和鏈的容器的模板函數
template <typename T>
void print(T v)
{
T::iterator itor;
for (itor = v.begin(); itor != v.end(); ++itor)
{
cout << *itor << " ";
}
cout << endl;
}
void main(int argc, char **argv){
list<int> l;
l.push_back(1);
l.push_front(2);
if(!l.empty())
print(l);
vector<int> vec;
vec.push_back(1);
vec.push_back(6);
if(!vec.empty())
print(vec);
}
打印結果
類型推導的隱式類型轉換
在決定模板參數類型前,編譯器執行下列隱式類型轉換:
左值變換
修飾字轉換
派生類到基類的轉換
見《C++ Primer》([注2],P500)對此主題的完備討論。
簡而言之,編譯器削弱了某些類型屬性,例如我們例子中的引用類型的左值屬性。舉例來說,編譯器用值類型實例化函數模板,而不是用相應的引用類型。
同樣地,它用指針類型實例化函數模板,而不是相應的數組類型。
它去除const修飾,絕不會用const類型實例化函數模板,總是用相應的非 const類型,不過對於指針來說,指針和 const 指針是不同的類型。
底線是:自動模板參數推導包含類型轉換,並且在編譯器自動決定模板參數時某些類型屬性將丟失。這些類型屬性可以在使用顯式函數模板參數申明時得以保留。
6. 模板的特化
如果我們打算給模板函數(類)的某個特定類型寫一個函數,就需要用到模板的特化,比如我們打算用 long 類型調用 max 的時候,返回小的值(原諒我舉了不恰當的例子):
template<> // 這代表了下面是一個模板函數
long max<long>( long a, long b ) // 對於 vc 來說,這裏的 <long> 是可以省略的
{
return a > b ? b : a;
}
實際上,所謂特化,就是代替編譯器完成了對指定類型的特化工作,現代的模板庫中,大量的使用了這個技巧。
對於偏特化,則只針對模板類型中部分類型進行特化,如
template<T1, T2>
class MyClass;
template<T1, T2>
class MyCalss<int, T2>//偏特化
7. 仿函數
仿函數這個詞經常會出現在模板庫裏(比如 STL),那麼什麼是仿函數呢?
顧名思義:仿函數就是能像函數一樣工作的東西,請原諒我用東西這樣一個代詞,下面我會慢慢解釋。
void dosome( int i )
這個 dosome 是一個函數,我們可以這樣來使用它: dosome(5);
那麼,有什麼東西可以像這樣工作麼?
答案1:重載了 () 操作符的對象,因此,這裏需要明確兩點:
1 仿函數不是函數,它是個類;
2 仿函數重載了()運算符,使得它的對你可以像函數那樣子調用(代碼的形式好像是在調用比如:
struct DoSome
{
void operator()( int i );
}
DoSome dosome;
這裏類(對 C++ 來說,struct 和類是相同的) 重載了 () 操作符,因此它的實例 dosome 可以這樣用 dosome(5); 和上面的函數調用一模一樣,不是麼?所以 dosome 就是一個仿函數了。
實際上還有答案2:
函數指針指向的對象。
typedef void( *DoSomePtr )( int );
typedef void( DoSome )( int );
DoSomePtr *ptr=&func;
DoSome& dosome=*ptr;
dosome(5); // 這裏又和函數調用一模一樣了。
當然,答案3 成員函數指針指向的成員函數就是意料之中的答案了。
8. 仿函數的用處
不管是對象還是函數指針等等,它們都是可以被作爲參數傳遞,或者被作爲變量保存的。因此我們就可以把一個仿函數傳遞給一個函數,由這個函數根據需要來調用這個仿函數(有點類似回調)。
STL 模板庫中,大量使用了這種技巧,來實現庫的“靈活”。
比如:
for_each, 它的源代碼大致如下:
template< typename Iterator, typename Functor >
void for_each( Iterator begin, Iterator end, Fucntor func )
{
for( ; begin!=end; begin++ )
func( *begin );
}
這個 for 循環遍歷了容器中的每一個元素,對每個元素調用了仿函數 func,這樣就實現了 對“每個元素做同樣的事”這樣一種編程的思想。
特別的,如果仿函數是一個對象,這個對象是可以有成員變量的,這就讓 仿函數有了“狀態”,從而實現了更高的靈活性。