模板 Template

文章來自：http://www.cnblogs.com/gaojun/archive/2010/09/10/1823354.html

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)其中Ｔ爲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");

}

最後結果顯示：

 

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

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，這樣就實現了 對「每一個元素作一樣的事」這樣一種編程的思想。特別的，若是仿函數是一個對象，這個對象是能夠有成員變量的，這就讓 仿函數有了「狀態」，從而實現了更高的靈活性。