(三)boost::lambda源码分析

本文是lambda分析篇最重要的一篇。lambda源码比较庞大（把宏全部展开），只是对其中的小部分进行分析，小部分足以展示其难度和运行机理。

boost源码给我的感觉对基础知识要求很高，是对知识正确的运用（我们的朋友们已经走向了另一条路，喜马拉雅上还是要从中国这方爬比较合适）。lambda源码对模板技术的运用很高，比其它代码如pool，shared_ptr等等都要厉害。总体来看mpl源码是元编程的皎皎者，但是很难运用在实际的工作中。lambda应该是实际运用的出色者。



先看下面的代码：

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include "boost/lambda/lambda.hpp"
#include "boost/tuple/tuple.hpp"
//#include "boost/lambda/bind.hpp"
// Tuple to cons mapper --------------------------------------------------

int _tmain(int argc, _TCHAR* argv[])
{   
	using namespace boost::lambda;
	using namespace std;

	boost::tuple<int,double,string> triple(42, 3.245, "The amazing tuple!");
	int  a0  =  triple.get<0>();
	double  a1  =  triple.get<1>();
	string  a2  =  triple.get<2>();
	
	std::vector<int> vec(3);
	vec[0] = 12;
	vec[1] = 10;
	vec[2] = 7;

	//Transform using a lambda expression
	std::for_each(vec.begin(), vec.end(), std::cout<<_1);
	std::for_each(vec.begin(), vec.end(), std::cout<<_1<<' ');
	//std::transform(vec.begin(), vec.end(), vec.begin(), _1-= 4);
  
	return 0;
}

首先，主要研究lambda的运用：

std::for_each(vec.begin(), vec.end(), std::cout<<_1);

打印出容器中的元素，这些元素显然是连续的。如果要分开，可以写成：

std::cout<<_1<<' ' 或是std::cout<<_1<<std::endl;

简单的增加了后面的' '或是std::endl将使模板参数变得异常的复杂。

因此，先考虑不那么复杂的语句:

std::cout<<_1

上面语句一定先要展开_1,这个在源码中被定义成这样的形式：

boost::lambda::placeholder1_type& _1 = free1;
 boost::lambda::placeholder1_type free1 = boost::lambda::placeholder1_type();
 typedef const lambda_functor<placeholder<FIRST> >  placeholder1_type;
 template <int I> struct placeholder;
 
 template<> struct placeholder<FIRST> {
	 
	 template<class SigArgs> struct sig {
		 typedef typename detail::get_element_or_null_type<0, SigArgs>::type type;
	 };
	 
	 template<class RET, CALL_TEMPLATE_ARGS> 
		 RET call(CALL_FORMAL_ARGS) const { //这儿主要还是在于返回a
		 BOOST_STATIC_ASSERT(boost::is_reference<RET>::value); 
		 CALL_USE_ARGS; // does nothing, prevents warnings for unused args
		 return a; 
	 }
 };

上面要获得lambda_fuctor这个模板，它是由宏扩展而成：

BOOST_LAMBDA_BE2(operator<<, 
bitwise_action< leftshift_action>, 
A, 
const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)

上面这个流程先讨论到这儿。实际上由于这个流程指向的方向是非常复杂，只有充满勇气人才能人继续走下去。

前面讨论到：

std::cout<<_1

由于这个for_each:

template <class _InputIter, class _Function>
_Function for_each(_InputIter __first, _InputIter __last, _Function __f) {
	__STL_REQUIRES(_InputIter, _InputIterator);
	for ( ; __first != __last; ++__first)
		__f(*__first); //std::cout<<_1(*first);
	return __f;
}

所以实际上std::cout<<_1应该是这样的形式：

std::cout<<_1(*first);

根据重载操作符的<<的规则，第一个参数必是std::cout,那么这个

函看起来是这个样子：

std::cout<< lambda_functor<placeholder<FIRST> >(*first);
上面语句调用的函数看起来向下面这个样子：
operator <<(std::basic_ostream<char, std::char_traits<char> >&,  boost::lambda::lambda_functor<boost::lambda::placeholder<1> >& )

上面的operator<<从何而来？

#define BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      /
	template<class A, class Arg>                                                 /
	inline const                                                                 /
	lambda_functor<                                                              /
	lambda_functor_base<                                                       /
    ACTION,                                                                  /
    tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >        /
	>                                                                          /
	>                                                                            /
	OPER_NAME (CONSTA& a, const lambda_functor<Arg>& b) {                      /
	return                                                                     /
    lambda_functor_base<                                                     /
	ACTION,                                                                /
	tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >      /
    >                                                                        /
	(tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >(a, b)); /
}

由此语句展开：

BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)

展开过后为：

//上面的宏扩展成下面这个样子

   template<class A, class Arg>
   inline const
   lambda_functor<
   lambda_functor_base<
   bitwise_action< leftshift_action>,
   tuple<typename detail::convert_ostream_to_ref_others_to_c_plain_by_default<A>::type, lambda_functor<Arg> >
   >
   >
   operator<<  (A& a, const lambda_functor<Arg>& b){//operator<<是重载操作符,std::cout<<_1,std::cout对应第一个参数，_1对应第二参数。
   return
   lambda_functor_base<
   bitwise_action< leftshift_action>,
   tuple<typename detail::convert_ostream_to_ref_others_to_c_plain_by_default<A>::type, lambda_functor<Arg> >
   >
   (tuple<typename detail::convert_ostream_to_ref_others_to_c_plain_by_default<A>::type, lambda_functor<Arg> >(a, b));

}

这个函数同相对应：

operator <<(std::basic_ostream<char, std::char_traits<char> >&,  boost::lambda::lambda_functor<boost::lambda::placeholder<1> >& )

也就是：

A --------------------> std::basic_ostream<char,std::char_traits<char> >

boost::lambda::lambda_functor<boost::lambda::placeholder<1> > ------> const lambda_functor<Arg>&

而返回类型是：

const boost::tuples::tuple<std::basic_ostream<char,std::char_traits<char> > &,boost::lambda::lambda_functor<boost::lambda::placeholder<1> >,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> &

为什么返回类型如此重要，因为如果后面还有输出内容，那么不能少。std::cout<<_1<<' '，输出

' '少不了返回类型。

convert_ostream_to_ref_others_to_c_plain_by_default这个元函数类不讨论了。它的主要内容在

（一）boost::lambda分析中已经讨论了。

这样最终构造一个lambda_functor对象。

然后在for_each中，调用

template <class _InputIter, class _Function>
_Function for_each(_InputIter __first, _InputIter __last, _Function __f) {
	__STL_REQUIRES(_InputIter, _InputIterator);
	for ( ; __first != __last; ++__first)
		__f(*__first); //这句就是调用lambda_functor(*_first),因为lambda_functor对operator()进行了重载，所以最终是对operator()的调用。

	return __f;
}

lambda_functor调用如下：

template <class T>
class lambda_functor : public T 
{
public:
  typedef T inherited;

  lambda_functor() {}
  lambda_functor(const lambda_functor& l) : inherited(l) {}

  lambda_functor(const T& t) : inherited(t) {}

  template <class SigArgs> struct sig {
    typedef typename inherited::template 
      sig<typename SigArgs::tail_type>::type type;
  };

  // Note that this return type deduction template is instantiated, even 
  // if the nullary 
  // operator() is not called at all. One must make sure that it does not fail.
  typedef typename 
    inherited::template sig<null_type>::type
      nullary_return_type;

  nullary_return_type operator()() const { 
    return inherited::template 
      call<nullary_return_type>
        (cnull_type(), cnull_type(), cnull_type(), cnull_type()); 
  }
//对这个operator进行调用
  template<class A>
  typename inherited::template sig<tuple<A&> >::type
  operator()(A& a) const { 
    return inherited::template call<
      typename inherited::template sig<tuple<A&> >::type
    >(a, cnull_type(), cnull_type(), cnull_type());
  }
.................
................
...........

上面的operator()中的call调用实际上:

template<class Args>
class  lambda_functor_base<bitwise_action<leftshift_action>, Args>{
public:
	Args  args;
public:
	explicit lambda_functor_base(const Args& a):args(a){}
	template<class RET, class A, class B, class C, class Env>
	RET call(A& a, B& b, C& c, Env& env)const{
               //这儿快到终点了。get<0>(args)参数这儿代表std::cout;
               //get<1>(args)代表12，所以就像这样std::cout<<12
		return  detail::select(boost::tuples::get<0>(args), a, b, c, env)
			<<
			detail::select(boost::tuples::get<1>(args), a, b, c, env);
	}

	template<class SigArgs> struct sig{
		typedef typename
			detail::binary_rt<bitwise_action<leftshift_action>, Args, SigArgs>::type type; 
	};
};

std::cout<<_1与std::cout<<_1<<' '差别在哪儿？在于传入的args这个模板参数不同。

std::cout<<_1的模板参数类型是：

const boost::tuples::tuple<std::basic_ostream<char,std::char_traits<char> > &,
      boost::lambda::lambda_functor<boost::lambda::placeholder<1> >,
      boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,
	  boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,
      boost::tuples::null_type,boost::tuples::null_type> &

而std::cout<<_1<<' '的类型是：

const boost::tuples::tuple<boost::lambda::lambda_functor<
	boost::lambda::lambda_functor_base<
	boost::lambda::bitwise_action<boost::lambda::leftshift_action>,
	boost::tuples::tuple<std::basic_ostream<char,std::char_traits<char> > &,
	boost::lambda::lambda_functor<boost::lambda::placeholder<1> >,
	boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,
	boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,
	boost::tuples::null_type,boost::tuples::null_type> > >,char const ,
	boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,
	boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,
	boost::tuples::null_type,boost::tuples::null_type> &

可见要复杂得多。里面的boost::tuples::null_type可以略去不看。

如果仔细的阅读，还是可以理解的。不理解是不行的，只有理解了才能懂得其道理。

通过模板的递归调用最终还是std::cout<<_1<<' '这种形式。

这只是冰山一角，已足以展示其复杂性。