c++ --> 模板（二）

標籤：

1、模板的概念

　　為求兩個數的最大值，定義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 <類型 形參表>可以包含基礎資料型別 (Elementary Data Type)可以包含類類型.

 

請看以下程式:

//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; }int 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");}

程式運行結果：

較小整數：2較小實數：1.5

程式分析：main()函數中定義了兩個整型變數n1 , n2 兩個雙精確度類型變數d1 , d2然後調用min( n1, n2); 即執行個體化函數模板T min(T x, T y)其中Ｔ為int型，求出n1,n2中的最小值．同理調用min(d1,d2)時，求出d1,d2中的最小值．

 

 

3、類模板的寫法

定義一個類模板：

Template < class或者也可以用typename T >class類名｛　　//類定義．．．．．．｝；

說明：其中，template是聲明各模板的關鍵字，表示聲明一個模板，模板參數可以是一個，也可以是多個。

 

例如：定義一個類模板：

// ClassTemplate.h
#ifndef ClassTemplate_HH#define ClassTemplate_HHtemplate<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;int 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");}

程式運行結果：

I=3, J=5I=3, J=aI=2.9, J=10

 

 

4、非類型模版參數

一般來說，非類型模板參數可以是常整數（包括枚舉）或者指向外部連結化物件的指標。

那麼就是說，浮點數是不行的，指向內部連結化物件的指標是不行的。

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

結果：

2 11 6

 

 

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、仿函數

仿函數就是能像函數一樣工作的東西:
　　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，這樣就實現了 對“每個元素做同樣的事”這樣一種編程的思想。
特別的，如果仿函數是一個對象，這個對象是可以有成員變數的，這就讓 仿函數有了“狀態”，從而實現了更高的靈活性。

 

c++ --> 模板（二）