一． 什么是Lambda
所謂Lambda，簡(jiǎn)單的說(shuō)就是快速的小函數(shù)生成。
在C++中，STL的很多算法都要求使用者提供一個(gè)函數(shù)對(duì)象。例如for_each函數(shù)，會(huì)要求用戶提供一個(gè)表明“行為”的函數(shù)對(duì)象。以vector<bool>為例，如果想使用for_each對(duì)其中的各元素全部賦值為true，一般需要這么一個(gè)函數(shù)對(duì)象，

  class  filler
  {
  public :
   void   operator ()( bool   & i)  const   {i  =   true ;}
 } ;

這樣實(shí)現(xiàn)不但麻煩，而且不直觀。而如果使用lambda，則允許用戶使用一種直觀和見(jiàn)解的方式來(lái)處理這個(gè)問(wèn)題。以boost.lambda為例，剛才的問(wèn)題可以這么解決：

for_each(v.begin(), v.end(), _1  =   true );

那么下面，就讓我們來(lái)實(shí)現(xiàn)一個(gè)lambda庫(kù)。

二． 戰(zhàn)前分析
首先要說(shuō)明的是，我并沒(méi)有讀過(guò)boost.lambda或其他任何lambda庫(kù)的代碼，因此如代碼有雷同，純屬巧合。
開(kāi)始實(shí)現(xiàn)以前，首先要分析出大致的實(shí)現(xiàn)手法。先讓我們來(lái)看幾段使用Lambda的代碼
 

for_each(v.begin(), v.end(), _1  =   1 );
  /**/ /* --------------------------------------------- */
 vector < int *>  vp( 10 ); 
 transform(v.begin(), v.end(), vp.begin(),  & _1);  /**/ /* --------------------------------------------- */
 sort(vp.begin(), vp.end(),  * _1  >   * _2);
  /**/ /* --------------------------------------------- */
  int  b  =   * find_if(v.begin, v.end(), _1  >=   3   &&  _1  <   5 );
  /**/ /* --------------------------------------------- */
 for_each(vp.begin(), vp.end(), cout  <<   * _1  <<   ' \n ' );
  /**/ /* --------------------------------------------- */
 for_each(vp.begin(), vp.end(), cout  <<  constant( ' \n ' )  <<   * _1);

看了之后，我們可以思考一些問(wèn)題：
1．_1, _2是什么？
顯然_1和_2都滿足C++對(duì)于標(biāo)識(shí)符的要求，可見(jiàn)_1和_2都是對(duì)象。
2．_1 = 1是在做什么？
既然_1是一個(gè)對(duì)象，那么_1的類必然重載了operator=(int)。那么operator=返回什么呢？該函數(shù)所返回的對(duì)象被傳入for_each的第3個(gè)參數(shù)，可見(jiàn)其返回了一個(gè)函數(shù)對(duì)象。現(xiàn)在整個(gè)流程就很清楚了。_1 = 1調(diào)用了operator=，其返回了一個(gè)函數(shù)對(duì)象，該函數(shù)對(duì)象能夠?qū)?shù)1賦值為1。
Ok，回答了這兩個(gè)問(wèn)題之后，我們的思路就很清晰了。如果要實(shí)現(xiàn)operator=，那么至少要實(shí)現(xiàn)2個(gè)類，一個(gè)用于產(chǎn)生_1的對(duì)象，另一個(gè)用于代表operator=返回的函數(shù)對(duì)象。

三． 動(dòng)工
首先實(shí)現(xiàn)一個(gè)能夠范型的進(jìn)行賦值的函數(shù)對(duì)象類：

 template < typename T >
  class  assignment
  {
  T value;
  public :
  assignment( const  T &  v) : value(v) {}
  template < typename T2 >
  T2 &   operator ()(T2  & rhs)  const   {  return  rhs  =  value; }
 } ; 

其中operator()被聲明為模版函數(shù)以支持不同類型之間的賦值。
然后我們就可以書寫_1的類來(lái)返回assignment

  class  holder
  {
  public :
  template < typename T >
  assignment < T >   operator = ( const  T &  t)  const
   {
    return  assignment < T > (t);
  }
 } ;

由于該類是一個(gè)空類，因此我們可以在其后放心大膽的寫上：

  static  holder _1;

Ok，現(xiàn)在一個(gè)最簡(jiǎn)單的lambda就完工了。你可以寫

for_each(v.begin(), v.end(), _1  =   1 );

而不用手動(dòng)寫一個(gè)函數(shù)對(duì)象。

四． 問(wèn)題分析
雖然基本上一個(gè)Lambda已經(jīng)初步實(shí)現(xiàn)出來(lái)了，但是仔細(xì)想想，問(wèn)題也是很多的。
1, 我們現(xiàn)在是把_1和functor看成兩個(gè)不同的存在，會(huì)導(dǎo)致代碼的重復(fù)。
2, 目前這個(gè)Lambda還無(wú)法實(shí)現(xiàn)如_1 = 2 = 3這樣的鏈?zhǔn)讲僮鳌?br>3, 我們沒(méi)有設(shè)計(jì)好如何處理多個(gè)參數(shù)的functor。
下面我們可以對(duì)這幾個(gè)問(wèn)題進(jìn)行分析。

五． 問(wèn)題1：一致性
首先來(lái)看看1，合并_1和functor的最佳方法就是把_1本身也變成functor。那么_1的operator()會(huì)做什么事情呢？|
很明顯，_1的operator()僅僅應(yīng)該返回傳進(jìn)來(lái)的參數(shù)本身。

struct  holder
  {
   //
  template < typename T >
  T &   operator ()( const  T &  r)  const
   {
    return  (T & )r;
  }
 } ;

這樣的話assignment也必須相應(yīng)改動(dòng)：

template < typename Left, typename Right >
  class  assignment
  {
  Left l;
  Right r;
  public :
  assignment( const  Left &  l,  const  Right &  r) : l(l), r(r) {}
  template < typename T2 >
  T2 &   operator ()(T2  & rhs)  const   {  return  l(rhs)  =  r; }
 } ; 

同時(shí)，holder的operator=也需要改動(dòng)：

template < typename T >
 assignment < holder, T >   operator = ( const  T &  t)  const
  {
   return  assignment < holder, T > ( * this , t);
 }

好，這樣holder也成為了一個(gè)functor，這為我們以后添加功能節(jié)省了很多代碼。
你可能也注意到，常數(shù)和functor地位也不平等。

return  l(rhs)  =  r;

在這一句中，r沒(méi)有調(diào)用operator()而l調(diào)用了。這樣以后就要不時(shí)的區(qū)分常數(shù)和functor，是不良的設(shè)計(jì)。
那么我們仿造holder的做法實(shí)現(xiàn)一個(gè)常數(shù)類:

template < typename Tp >
  class  constant_t
  {
   const  Tp t;
  public :
  constant_t( const  Tp &  t) : t(t) {}
  template < typename T >
   const  Tp &   operator ()( const  T &  r)  const
   {
    return  t;
  }
 } ;

該functor的operator()無(wú)視參數(shù)，直接返回內(nèi)部所存儲(chǔ)的常數(shù)。
下面就可以修改holder的operator=了

template < typename T >
 assignment < holder, constant_t < T >   >   operator = ( const  T &  t)  const
  {
   return  assignment < holder, constant_t < T >   > ( * this , constant_t < T > (t));
 }

同時(shí)也要修改assignment的operator()

 template < typename T2 >
 T2 &   operator ()(T2  & rhs)  const   {  return  l(rhs)  =  r(rhs); }

現(xiàn)在代碼看起來(lái)就很一致了。

六． 問(wèn)題2：鏈?zhǔn)讲僮?br>現(xiàn)在讓我們來(lái)看看如何處理鏈?zhǔn)讲僮鳌?br>其實(shí)問(wèn)題1已經(jīng)為我們處理掉了大量的問(wèn)題。如果_1，functor，常量彼此之間不統(tǒng)一為functor，那么鏈?zhǔn)讲僮鞯臅r(shí)候就要時(shí)刻小心一個(gè)對(duì)象是_1還是functor還是常量，會(huì)大大增加編碼的難度。
事實(shí)上，首先要解決的是，如何知道一個(gè)functor的operator()的返回值的類型。遺憾的是，我并沒(méi)有找到非常自動(dòng)的辦法，因此我們得讓functor自己來(lái)告訴我們返回值的類型。
比較麻煩的是，operator()的返回值一般和其參數(shù)的類型相關(guān)，而operator()通常是一個(gè)模版函數(shù)，因此其返回值類型并不能用一個(gè)簡(jiǎn)單的typedef來(lái)指定，而必須實(shí)現(xiàn)一個(gè)trait。
現(xiàn)在我們?cè)赼ssignment內(nèi)部聲明一個(gè)nested-struct

template < typename T >
  struct  result_1
  {
  typedef typename  ref < typename Left::result_1 < T > ::result > ::reference result;
 } ;

那么如果參數(shù)為T，其返回值類型就為result_1<T>::result。上面代碼的ref<T>為一個(gè)類型轉(zhuǎn)換類，作用是返回T的引用。不直接加上&符號(hào)的原因是如果T本身就是Q的引用Q&，那么Q&&是非法的。因此ref的實(shí)現(xiàn)即為：

template < typename T >
  struct   ref
  {
  typedef T &  reference;
 } ;
 template < typename T >
  struct   ref < T &>
  {
  typedef T &  reference;
 } ;

有了result_1之后，就可以把operator()改寫一下：

 template < typename T >
 typename result_1 < T > ::result  operator ()( const  T &  t)  const
  {
   return  l(t)  =  r(t);
 }

可能大家已經(jīng)注意到我定義assignment的operator()的返回類型的時(shí)候，是直接將其定義為L(zhǎng)eft的operator()返回類型的引用形式，如果實(shí)際上處理的對(duì)象的operator=并不是按照常理來(lái)聲明的，那么這段代碼可能就編譯不過(guò)。這的確是一個(gè)很麻煩的事情。實(shí)際上，在gcc下，使用typeof關(guān)鍵字可以很容易的得到該類型的operator=的返回類型，就可以讓這段代碼變得更有通用性。然而為了實(shí)現(xiàn)可移植性，我不得不放棄這個(gè)誘人的想法。
 同理我們可以給constant_t和holder加上這個(gè)result_1。
 
有了這個(gè)result_1，鏈?zhǔn)讲僮骶秃?jiǎn)單多了。現(xiàn)在唯一要做的事情就是讓所有的functor都重載各種操作符以產(chǎn)生新的functor。假設(shè)我們有add和divide兩個(gè)類，那么
_1 / 3 + 5會(huì)出現(xiàn)的構(gòu)造方式是：
 _1 / 3調(diào)用holder的operator/ 返回一個(gè)divide的對(duì)象
 +5 調(diào)用divide的對(duì)象返回一個(gè)add對(duì)象。
最后的布局是:
                         Add
                       /     \
                  Divide     5
                  /    \
                _1      3
似乎一切都解決了？不。
你可以想象一下一個(gè)完整的Lambda庫(kù)，它必然能夠重載C++幾乎所有的操作符。假設(shè)其重載了10個(gè)操作符，那么至少會(huì)有10個(gè)代表這些操作符的functor類。大體上來(lái)講，每一種操作符所對(duì)應(yīng)的functor都應(yīng)當(dāng)能夠由鏈?zhǔn)讲僮鳟a(chǎn)生別的任意一種操作符所對(duì)應(yīng)的functor。(例如：*_1 = 2既是由operator*的functor產(chǎn)生operator=的functor)。可想而知這樣一共能產(chǎn)生10*10=100種產(chǎn)生方式。這是對(duì)編碼的一個(gè)大挑戰(zhàn)。
如何簡(jiǎn)化這個(gè)問(wèn)題呢？我們不妨假定，任意一種操作符的functor，都能夠產(chǎn)生任意一種操作符的functor，這樣，每一種操作符的functor都擁有一樣的產(chǎn)生方案。如果某種轉(zhuǎn)換確實(shí)是不合法的（例如：A/B=C無(wú)論如何也不可能合法），那么在試圖產(chǎn)生新functor的時(shí)候會(huì)出現(xiàn)編譯錯(cuò)誤。幸好C++的模版是如果不使用就不編譯的，因此這種編譯錯(cuò)誤不會(huì)干擾到正常的使用，這正是我們所要的。
ＯＫ，我們的方法呼之欲出了。既然所有的functor都具有一樣的產(chǎn)生方案，那么不如大家都不要實(shí)現(xiàn)，等到最后統(tǒng)一的在所有的functor里面加上這么一系列的產(chǎn)生代碼吧。例如，如果要添加從某functor XXX到operator=的functor的產(chǎn)生代碼：

 template < typename Right >
 assignment < XXX, typename picker_maker < Right > ::result  >   operator = ( const  
 Right &  rt)  const
  {
   return  assignment < XXX, typename picker_maker < Right > ::result  > ( * this , rt);
 }

下面對(duì)該代碼的一些細(xì)節(jié)方面作一些解釋
XXX指的是原來(lái)的functor的類型，picker_maker<T>是一個(gè)類型變換的trait，如果T是一個(gè)常量，那么他會(huì)返回constant_t<T>,否則返回T本身。
因此如果該函數(shù)聲明在assignment的內(nèi)部，那么就實(shí)現(xiàn)了連等，如果聲明在的dereference（解引用）的內(nèi)部，就允許（*A = B）的行為發(fā)生。
最后，如何把這些函數(shù)塞到各個(gè)functor的聲明里邊呢？當(dāng)然可以用宏，但是。。。大家都知道這樣不好。
除了宏之外還可以用的方式就是繼承。我們可以寫一個(gè)類叫做picker，該類實(shí)現(xiàn)了所有的如上的產(chǎn)生函數(shù)。然后讓所有的functor繼承自它。
且慢，也許立刻就有人跳出來(lái)說(shuō)：這樣的話那個(gè)XXX怎么寫呢？這樣不是會(huì)導(dǎo)致循環(huán)依賴么？這樣不是會(huì)有downcast么？
正解，讓picker做基類確實(shí)不是一個(gè)好主意。反過(guò)來(lái)，讓picker繼承functor卻是一個(gè)不錯(cuò)的方法。下面是picker的聲明：

template < class  Action >
  class  picker :  public  Action
  {
  public :
  picker( const  Action &  act) : Action(act) {}
    // all the operator overloaded
 } ;

Picker<Ｔ>繼承自Ｔ，唯一的作用就是給Ｔ添加上了各種操作符的重載函數(shù)。
現(xiàn)在所有參與行動(dòng)的functor都要套上一層picker, _1被聲明為 picker<holder>, 并且holder中所重載的操作符除了operator()之外全部被移到了picker內(nèi)。而picker中的操作符重載的返回的functor也必須套上一個(gè)picker:

template < typename Right >
 picker < assignment < Action, typename picker_maker < Right > ::result  >   >   operator = ( const  Right &  rt)  const
  {
   return  assignment < Action, typename picker_maker < Right > ::result  >  ( * this , rt);
 }

Piker_maker返回的也是picker<T>，或者picker<constant_t<T> >
使用picker還帶來(lái)一個(gè)額外的好處。之前提到picker_maker要區(qū)分functor和常量，有了picker，區(qū)分的方法就非常簡(jiǎn)單了：凡是屬于picker<T>的都是functor，否則就是常量。

template  < typename T >   struct  picker_maker
  {
  typedef picker < constant_t < T >   >  result;
 } ;
 template  < typename T >   struct  picker_maker < picker < T >   >
  {
  typedef picker < T >  result;
 } ;

下面總的結(jié)構(gòu)就有了：
 functor專心模擬操作符的行為，并實(shí)現(xiàn)一個(gè)result_1來(lái)告訴別人自己的返回類型。
 picker專心負(fù)責(zé)操作符之間的產(chǎn)生關(guān)系，由它來(lái)聯(lián)系操作符合functor。
 picker<functor>構(gòu)成了實(shí)際參與操作的對(duì)象。
至此鏈?zhǔn)讲僮魍昝缹?shí)現(xiàn)。

七． 問(wèn)題3
如何使用多參數(shù)的函數(shù)對(duì)象呢？考慮_1=_2，這個(gè)functor必須接受2個(gè)參數(shù)，因此所產(chǎn)生的assignment對(duì)象的operator()必須能接收2個(gè)參數(shù)。

template < typename T1, typename T2 >
  ???   operator ()( const  T1 &  t1,  const  T2 &  t2)  const
  {
   return  lt(t1, t2)  =  rt(t1, t2);
 }

很明顯，這個(gè)函數(shù)的返回類型會(huì)依賴于T1，T2，因此result_1已經(jīng)無(wú)法適用，我們就只好再寫一個(gè)result_2:

 template < typename T1, typename T2 >
  struct  result_2
  {
  typedef typename  ref < typename Left::result_2 < T1, T2 > ::result > ::reference result;
 } ;

顯然，各個(gè)functor似乎根本不理會(huì)各個(gè)參數(shù)那個(gè)是_1, 那個(gè)是_2, 那么最后是怎么選擇的呢？
這個(gè)差事就留給了holder自己。
        

template < int  Order >
  class  holder;
 template <>
  class  holder < 1 >
  {
  public :
  template < typename T >
   struct  result_1
   {
   typedef T &  result;
  } ;
  template < typename T1, typename T2 >
   struct  result_2
   {
   typedef T1 &  result;
  } ;
  template < typename T >
  typename result_1 < T > ::result  operator ()( const  T &  r)  const
   {
    return  (T & )r;
  }
  template < typename T1, typename T2 >
  typename result_2 < T1, T2 > ::result  operator ()( const  T1 &  r1,  const  T2 &  r2)  const
   {
    return  (T1 & )r1;
  }
 } ;

 template <>
  class  holder < 2 >
  {
  public :
  template < typename T >
   struct  result_1
   {
   typedef T &  result;
  } ;
  template < typename T1, typename T2 >
   struct  result_2
   {
   typedef T2 &  result;
  } ;
  template < typename T >
  typename result_1 < T > ::result  operator ()( const  T &  r)  const
   {
    return  (T & )r;
  }
  template < typename T1, typename T2 >
  typename result_2 < T1, T2 > ::result  operator ()( const  T1 &  r1,  const  T2 &  r2)  const
   {
    return  (T2 & )r2;
  }
 } ;

新的holder變成了holder<int>, holder<n>的n個(gè)參數(shù)的operator()會(huì)返回第n個(gè)參數(shù)的值。而_1,_2也相應(yīng)變?yōu)閜icker<holder<1> >, picker<holder<2> >。
現(xiàn)在讓我們來(lái)看看(_1 = _2)(i. j)是怎么調(diào)用的：
 首先 assignment::operator(int, int)被調(diào)用：

return  l(i, j)  =  r(i, j);

 先后調(diào)用holder<1>::operator()(int, int)和holder<2>::operator()(int, int)

   return  ( int & )i;
   return  ( int & )j;

最后執(zhí)行i = j;
可見(jiàn)，參數(shù)被正確的選擇了。

八． 中期總結(jié)
目前的結(jié)果是這樣的，為了支持一個(gè)操作符，我們需要作如下幾件事：
 1。 實(shí)現(xiàn)一個(gè)functor，該functor的operator()要能執(zhí)行該操作符的語(yǔ)義
 2。 在該functor中實(shí)現(xiàn)result_1至result_n，其中n是支持參數(shù)的最大值。
 3。 在picker中實(shí)現(xiàn)一個(gè)操作符重載，返回該functor

九. 簡(jiǎn)化
很明顯，要支持一個(gè)操作符所要做的工作太多了，而且在每個(gè)functor中申明result_1至result_n，可見(jiàn)如果n發(fā)生變化，維護(hù)的開(kāi)銷極大。
我們現(xiàn)在需要找到一個(gè)自動(dòng)生成這種functor的方法。
首先，我們注意到result_x的形式很統(tǒng)一。對(duì)于各種操作符，其返回值無(wú)非下列幾種：
 1. 返回值。如果本身為引用，就去掉引用。  
   +-*/&|^等
 2. 返回引用。
   =,各種復(fù)合賦值等
 3. 返回固定類型。
   各種邏輯/比較操作符(返回bool)
 4. 原樣返回。
   operator,
 5. 返回解引用的類型。
   operator*(單目)
 6. 返回地址。
   operator&(單目)
 7. 下表訪問(wèn)返回類型。
   operator[]
 8. 如果左操作數(shù)是一個(gè)stream，返回引用，否則返回值
   operator<<和operator>>

OK，這樣我們將返回值類型總結(jié)為以上8種，就可以將各種result_x從functor中剝離出來(lái)了。
例如針對(duì)第一條，我們實(shí)現(xiàn)一個(gè)policy類：

template < typename Left >
  struct  value_return
  {
  template < typename T >
   struct  result_1
   {
   typedef typename const_value < typename Left::template result_1 < T > ::result_type > ::value_type result_type;
  } ;

  template < typename T1, typename T2 >
   struct  result_2
   {
   typedef typename const_value < typename Left::template result_2 < T1, T2 > ::result_type > ::value_type result_type;
  } ;
 } ;

其中const_value是一個(gè)將一個(gè)類型轉(zhuǎn)為其非引用形式的trait

下面我們來(lái)剝離functor中的operator()
首先operator里面的代碼全是下面的形式：

return  l(t) op r(t)
  return  l(t1, t2) op r(t1, t2)
  return  op l(t)
  return  op l(t1, t2)
  return  l(t) op
  return  l(t1, t2) op
  return  l(t)[r(t)]
  return  l(t1, t2)[r(t1, t2)]

很自然的，我們會(huì)想到用函數(shù)替代這種操作符行為以獲得更加一致的形式：
 單目： return f(l(t), r(t));
  return f(l(t1, t2), r(t1, t2));
 雙目： return f(l(t));
  return f(l(t1, t2));
下面就是f的實(shí)現(xiàn)，以operator/為例

struct  meta_divide
  {
  template  < typename T1, typename T2 >
   static  ret execute( const  T1 &  t1,  const  T2 &  t2) 
   {
    return  t1  /  t2;
  }  
 } ;

這個(gè)工作可以讓宏來(lái)做：

#define  DECLARE_META_BIN_FUNC(op, desc, ret) struct meta_##desc{\
  template  < typename T1, typename T2 >  \
   static  ret execute( const  T1 &  t1,  const  T2 &  t2)  { return  ((T1 & )t1) op ((T2 & )t2);}  };

以后可以直接用
 DECLARE_META_BIN_FUNC(/, divide, T1)
來(lái)申明meta_divide。同樣還可以申明宏DECLARE_META_UNY_PRE_FUNC和DECLARE_META_UNY_POST_FUNC來(lái)產(chǎn)生單目前綴和后綴操作符的函數(shù)
（ps.我本堅(jiān)持該lambda實(shí)現(xiàn)不使用宏的，但是在這種小劑量的又很一致的代碼面前，使用宏實(shí)在是很誘人。。。）

下面就是要把operator()和result_x拼湊起來(lái)，形成一個(gè)我們要的functor,下面是一個(gè)單目的functor的實(shí)現(xiàn)體

template < typename Left, typename Right, typename Rettype, typename FuncType >
  class  unary_op :  public  Rettype
  {
      Left l;
  public :
      unary_op( const  Left &  l) : l(l) {}

  template < typename T >
      typename Rettype::template result_1 < T > ::result_type  operator ()( const  T &  t)  const
       {
           return  FuncType::execute(l(t));
      }

      template < typename T1, typename T2 >
      typename Rettype::template result_2 < T1, T2 > ::result_type  operator ()( const  T1 &  t1,  const  T2 &  t2)  const
       {
           return  FuncType::execute(l(t1, t2));
      }
 } ;

同樣還可以申明一個(gè)binary_op

template < typename Left, typename Right, typename Rettype, typename FuncType >
  class  binary_op :  public  Rettype
  {
      Left l;
  Right r;
  public :
      binary_op( const  Left &  l, const  Right &  r) : l(l), r(r) {}

  template < typename T >
      typename Rettype::template result_1 < T > ::result_type  operator ()( const  T &  t)  const
       {
           return  FuncType::execute(l(t), r(t));
      }

      template < typename T1, typename T2 >
      typename Rettype::template result_2 < T1, T2 > ::result_type  operator ()( const  T1 &  t1,  const  T2 &  t2)  const
       {
           return  FuncType::execute(l(t1, t2), r(t1, t2));
      }
 } ;

很完美不是么，unary_op/binary_op繼承了Rettype, 也就擁有了該類所定一個(gè)全部result_x, 同時(shí)使用FuncType來(lái)執(zhí)行運(yùn)算符操作，很漂亮
比如要支持操作符operator+，則需要寫一行
 DECLARE_META_BIN_FUNC(+, add, T1)
那么binary_op<Left, Right, value_return, meta_add>就自然是operator+（雙目）的functor，不需要自己手動(dòng)實(shí)現(xiàn)。
停！不要陶醉在這美妙的幻覺(jué)中！
如果把這段代碼拿到VC7或VC8下編譯，你會(huì)得到很有趣的結(jié)果。。。
好了，這不是我們的錯(cuò)，但是確實(shí)我們應(yīng)該解決它。
這實(shí)際上是vc的bug，解決方法是不要去使用typename Rettype::template result_2<T1, T2>::result_type這樣的形式。（感謝vbvan）
下面是修改過(guò)的unary_op

template < typename Left, typename OpClass, typename RetType >
  class  unary_op
  {
  Left l;
   
  public :

  unary_op( const  Left &  l) : l(l) {}

  template < typename T >
   struct  result_1
   {
   typedef typename RetType::template result_1 < T > ::result_type result_type;
  } ;

  template < typename T1, typename T2 >
   struct  result_2
   {
   typedef typename RetType::template result_2 < T1, T2 > ::result_type result_type;
  } ;

  template < typename T1, typename T2 >
  typename result_2 < T1, T2 > ::result_type  operator ()( const  T1 &  t1,  const  T2 &  t2)  const
   {
    return  OpClass::execute(lt(t1, t2));
  }

  template < typename T >
  typename result_1 < T > ::result_type  operator ()( const  T &  t)  const
   {
    return  OpClass::execute(lt(t));
  }

 } ;

該方法避免直接使用RetType的result_x，而自己申明一個(gè)對(duì)應(yīng)的result_x做一次中轉(zhuǎn)，雖然其實(shí)毫無(wú)意義，卻恰好避開(kāi)了vc的bug
好啦，現(xiàn)在才真正完美了。
現(xiàn)在在picker里面就可以這么添加了：

template < typename Right >
 picker < binary_op < Action, typename picker_maker < Right > ::result_type, ref_return < Action > , meta_add_assign >   >   operator += ( const  Right &  rt)  const
  {
   return  binary_op < Action, typename picker_maker < Right > ::result_type, ref_return < Action > , meta_add_assign > ( * this , rt);
 }

有點(diǎn)長(zhǎng)不是么？不過(guò)實(shí)際代碼量減少了很多，而且此后如果支持的參數(shù)上限發(fā)生變化，我們就只需要修改binary_op和unary_op就行了。

十． bind
既然都做到這份上了，我們順便把bind也做了吧，其實(shí)事情已經(jīng)變得很簡(jiǎn)單了。
先來(lái)分析一下一段例子

int  foo( int  x,  int  y) { return  x  -  y;}
bind(foo, _1, constant( 2 )( 1 )   // return -1
bind(foo, _2, _1)( 3 ,  6 )   // return foo(6, 3) == 3

可見(jiàn)bind是一系列重載函數(shù)，返回某種functor，該functor的執(zhí)行就是執(zhí)行傳進(jìn)bind的函數(shù)指針并正確的確定參數(shù)。
我們來(lái)寫個(gè)簡(jiǎn)單的。
首先要知道一個(gè)函數(shù)的返回類型，我們使用一個(gè)trait來(lái)實(shí)現(xiàn)：
對(duì)于函數(shù)對(duì)象類的版本：

 template < typename Func >
  struct  functor_trait
  {
  typedef typename Func::result_type result_type;
 } ;

對(duì)于無(wú)參數(shù)函數(shù)的版本：

template < typename Ret >
  struct  functor_trait < Ret ( * )() >
  {
  typedef Ret result_type;
 } ;

對(duì)于單參數(shù)函數(shù)的版本：

template < typename Ret, typename V1 >
  struct  functor_trait < Ret ( * )(V1) >
  {
  typedef Ret result_type;
 } ;

對(duì)于雙參數(shù)函數(shù)的版本：

template < typename Ret, typename V1, typename V2 >
  struct  functor_trait < Ret ( * )(V1, V2) >
  {
  typedef Ret result_type;
 } ;

等等。。。
然后我們就可以仿照value_return寫一個(gè)policy

template < typename Func >
  struct  func_return
  {
  template < typename T >
   struct  result_1
   {
   typedef typename functor_trait < Func > ::result_type result_type;
  } ;

  template < typename T1, typename T2 >
   struct  result_2
   {
   typedef typename functor_trait < Func > ::result_type result_type;
  } ;
 } ;

最后一個(gè)單參數(shù)binder就很容易寫出來(lái)了

template < typename Func, typename aPicker >
  class  binder_1
  {
  Func fn;
  aPicker pk;
  public :

  template < typename T >
   struct  result_1
   {
   typedef typename func_return < Func > ::template result_1 < T > ::result_type result_type;
  } ;

  template < typename T1, typename T2 >
   struct  result_2
   {
   typedef typename func_return < Func > ::template result_2 < T1, T2 > ::result_type result_type;
  } ;

  binder_1(Func fn,  const  aPicker &  pk) : fn(fn), pk(pk) {}

  template < typename T >
  typename result_1 < T > ::result_type  operator ()( const  T &  t)  const
   {
    return  fn(pk(t));
  }
  template < typename T1, typename T2 >
  typename result_2 < T1, T2 > ::result_type  operator ()( const  T1 &  t1,  const  T2 &  t2)  const
   {
    return  fn(pk(t1, t2));
  }
 } ;

一目了然不是么？
最后實(shí)現(xiàn)bind
 

template < typename Func, typename aPicker >
 picker < binder_1 < Func, aPicker >   >  bind( const  Func fn,  const  aPicker &  pk)
  {
   return  binder_1 < Func, aPicker > (fn, pk);
 }

2個(gè)以上參數(shù)的bind可以同理實(shí)現(xiàn)。
另外還可以照樣實(shí)現(xiàn)一系列binder來(lái)綁定類成員函數(shù)/變量，手法雷同，就不詳細(xì)介紹了。

十一． phoenix
Boost.phoenix可能知道的人不多，讓我們來(lái)看一段代碼吧： 

for_each(v.begin(), v.end(),
 (
  do_
  [
   cout  <<  _1  <<   " ,  "
  ]
  .while_( -- _1),
  cout  <<  var( " \n " )
  )
 );

是不是華麗的讓人撞墻？其實(shí)這個(gè)比想象的好實(shí)現(xiàn)的多。還是照慣例分析一下吧：
首先do_很明顯是個(gè)對(duì)象，該對(duì)象重載了operator[]，接受一個(gè)functor作為參數(shù)，并返回另一個(gè)對(duì)象，該對(duì)象有一個(gè)成員函數(shù)while_，同樣接受一個(gè)functor作為參數(shù)，并返回一個(gè)functor, 最后2個(gè)functor用operator, 生成一個(gè)新的functor
operator,的實(shí)現(xiàn)這里略過(guò)了，請(qǐng)參照前面的描述。
那么我們就照著這個(gè)思路來(lái)實(shí)現(xiàn)吧：
 

template < typename Cond, typename Actor >
  class  do_while
  { 
  Cond cd;
  Actor act;
  public :
  template < typename T >
   struct  result_1
   {
   typedef  int  result_type;
  } ;

  do_while( const  Cond &  cd,  const  Actor &  act) : cd(cd), act(act) {}

  template < typename T >
  typename result_1 < T > ::result_type  operator ()( const  T &  t)  const
   {
    do
    {
    act(t);
   }
    while  (cd(t));
    return   0 ;
  }
 } ;

這就是最終的functor，我略去了result_2和2個(gè)參數(shù)的operator().
代碼很清晰，但是還是讓我來(lái)解釋一下為什么要用int作為返回類型。
其實(shí)對(duì)于do-while語(yǔ)義，返回類型是無(wú)意義的，然而將其定義為void會(huì)影響在某些情況下return的簡(jiǎn)潔性，因?yàn)閞eturn一個(gè)void是不合法的。
因此我們將其定為int，并返回0，這樣減少了其它地方編碼的復(fù)雜度。
下面就是產(chǎn)生這個(gè)functor的類：
 

template < typename Actor >
  class  do_while_actor
  {
  Actor act;
  public :
  do_while_actor( const  Actor &  act) : act(act) {}

  template < typename Cond >
  picker < do_while < Cond, Actor >   >  while_( const  Cond &  cd)  const ;
 } ;

簡(jiǎn)單吧，注意到這個(gè)while_函數(shù)，它自動(dòng)的生成了一個(gè)do_while對(duì)象。
最后，是那個(gè)do_
 

class  do_while_invoker
  {
  public :
  template < typename Actor >
  do_while_actor < Actor >   operator [](Actor act)  const
   {
    return  do_while_actor < Actor > (act);
  }
 } do_;

好啦，現(xiàn)在明白do_[xxx].while_(xxx)是怎么工作的吧?
同樣的，我們還可以做if_, while_, for_, switch_等。
最后來(lái)說(shuō)說(shuō)怎么處理break和continue
顯然break的語(yǔ)義超出了我們的能力范圍，然而卻是有一個(gè)東西很適合模擬其行為，那就是異常。
具體實(shí)現(xiàn)手法這里就不羅嗦了。