Boost C++ 库

BLL 定义了三种占位符类型：placeholder1_type、placeholder2_type 和 placeholder3_type。BLL 为每种占位符类型预定义了一个占位符变量：_1、_2 和 _3。但是，用户不一定非要使用这些占位符。通过定义占位符类型的新变量，可以轻松地定义具有替代名称的占位符。例如：

boost::lambda::placeholder1_type X;
boost::lambda::placeholder2_type Y;
boost::lambda::placeholder3_type Z;

定义了这些变量后，X += Y * Z 就等同于 _1 += _2 * _3。

占位符在 Lambda 表达式中的使用决定了生成的函数是零元、一元、二元还是三元函数。最高的占位符索引起决定性作用。例如：

_1 + 5              // unary
_1 * _1 + _1        // unary
_1 + _2             // binary
bind(f, _1, _2, _3) // 3-ary
_3 + 10             // 3-ary

请注意，最后一行创建了一个三元函数，该函数将 10 加到其 第三个 参数上。前两个参数被忽略。此外，Lambda 仿函数只有最小元数。您可以随时提供比实际需要的参数（最多支持的占位符数量）更多的参数。剩余的参数将被忽略。例如：

int i, j, k; 
_1(i, j, k)        // returns i, discards j and k
(_2 + _2)(i, j, k) // returns j+j, discards i and k

有关此功能背后的设计原理，请参阅 “Lambda 仿函数元数” 一节。

除了这三种占位符类型之外，还有第四种占位符类型 placeholderE_type。此占位符的使用在描述 Lambda 表达式中异常处理的 “异常” 一节中进行了定义。

当为占位符提供实际参数时，参数传递模式始终是通过引用。这意味着对占位符的任何副作用都会反映到实际参数中。例如：

int i = 1; 
(_1 += 2)(i);         // i is now 3
(++_1, cout << _1)(i) // i is now 4, outputs 4

基本规则是，任何至少有一个参数为 Lambda 表达式的 C++ 运算符调用本身就是一个 Lambda 表达式。几乎所有可重载的运算符都受支持。例如，以下是一个有效的 Lambda 表达式：

cout << _1, _2[_3] = _1 && false

然而，存在一些源于 C++ 运算符重载规则的限制，以及一些特殊情况。

int i; 
_1 = i;      // ok
i = _1;      // not ok. i is not a lambda expression

var(i) = _1; // ok

bool flag = true; int i = 0;
(_1 || ++_2)(flag, i);

for_each(a.begin(), a.end(), (++_1, cout << _1));

绑定表达式可以有两种形式：

bind(target-function, bind-argument-list)
bind(target-member-function, object-argument, bind-argument-list)

绑定表达式会延迟函数的调用。如果此目标函数是n元函数，则bind-argument-list也必须包含n个参数。在 BLL 的当前版本中，必须满足 0 <= n <= 9。对于成员函数，参数数量最多为 8，因为对象参数占用一个参数位置。基本上，bind-argument-list 必须是目标函数的有效参数列表，但任何参数都可以被占位符替换，或者更广泛地说，被 Lambda 表达式替换。请注意，目标函数也可以是 Lambda 表达式。绑定表达式的结果是零元、一元、二元或三元函数对象，具体取决于占位符在bind-argument-list中的使用情况（参见 “占位符” 一节）。

通过绑定表达式创建的 Lambda 仿函数的返回类型可以作为显式指定的模板参数给出，如下例所示：

bind<RET>(target-function, bind-argument-list)

只有当目标函数的返回类型无法推导时，才需要这样做。

接下来的几节将介绍不同类型的绑定表达式。

X foo(A, B, C); A a; B b; C c;
bind(foo, _1, _2, c)(a, b);
bind(&foo, _1, _2, c)(a, b);
bind(_1, a, b, c)(foo);

void foo(int);
void foo(float);
int i; 
  ...
bind(&foo, _1)(i);                            // error 
  ...
void (*pf1)(int) = &foo;
bind(pf1, _1)(i);                             // ok
bind(static_cast<void(*)(int)>(&foo), _1)(i); // ok

bind(target-member-function, object-argument, bind-argument-list)

bool A::foo(int) const; 
A a;
vector<int> ints; 
  ...
find_if(ints.begin(), ints.end(), bind(&A::foo, a, _1)); 
find_if(ints.begin(), ints.end(), bind(&A::foo, &a, _1));

bool A::foo(int); 
list<A> refs; 
list<A*> pointers; 
  ...
find_if(refs.begin(), refs.end(), bind(&A::foo, _1, 1)); 
find_if(pointers.begin(), pointers.end(), bind(&A::foo, _1, 1));

class A {
  int i; mutable int j;
public:

  A(int ii, int jj) : i(ii), j(jj) {};
  void set_i(int x) { i = x; }; 
  void set_j(int x) const { j = x; }; 
};

A a(0,0); int k = 1;
bind(&A::set_i, &a, _1)(k); // a.i == 1
bind(&A::set_j, &a, _1)(k); // a.j == 1

A a(0,0); int k = 1;
bind(&A::set_i, a, _1)(k); // error; a const copy of a is stored. 
                           // Cannot call a non-const function set_i
bind(&A::set_j, a, _1)(k); // a.j == 0, as a copy of a is modified

bind(&A::set_i, ref(a), _1)(k); // a.j == 1
bind(&A::set_j, cref(a), _1)(k); // a.j == 1

A a(0,0);
bind(&A::set_i, _1, 1)(a); // a.i == 1
bind(&A::set_j, _1, 1)(a); // a.j == 1

struct A { int data; };
A a;
bind(&A::data, _1)(a) = 1;     // a.data == 1

const A ca = a;
bind(&A::data, _1)(ca) = 1;     // error

struct A {
  typedef B result_type;
  B operator()(X, Y, Z); 
};

struct A {
  template <class Args> struct sig { typedef B type; }
  B operator()(X, Y, Z); 
};

struct A {

  // the return type equals the third argument type:
  template<class T1, class T2, class T3>
  T3 operator()(const T1& t1, const T2& t2, const T3& t3) const;

  template <class Args> 
  class sig {
    // get the third argument type (4th element)
    typedef typename 
      boost::tuples::element<3, Args>::type T3;
  public:
    typedef typename 
      boost::remove_cv<T3>::type type;
  };
};

返回类型推导系统可能无法推导出某些用户定义运算符或具有类对象的绑定表达式的返回类型。提供了一种特殊的 Lambda 表达式类型，用于显式声明返回类型并重写推导系统。要声明 Lambda 表达式 e 定义的 Lambda 仿函数的返回类型为 T，可以这样写：

ret<T>(e);

其效果是根本不为 Lambda 表达式 e 执行返回类型推导，而是将 T 用作返回类型。显然 T 不能是任意类型，Lambda 仿函数的实际结果必须隐式可转换为 T。例如：

A a; B b;
C operator+(A, B);
int operator*(A, B); 
  ...
ret<D>(_1 + _2)(a, b);     // error (C cannot be converted to D)
ret<C>(_1 + _2)(a, b);     // ok
ret<float>(_1 * _2)(a, b); // ok (int can be converted to float)
  ...
struct X {
  Y operator(int)();   
};
  ...
X x; int i;
bind(x, _1)(i);            // error, return type cannot be deduced
ret<Y>(bind(x, _1))(i);    // ok

对于绑定表达式，可以使用简写语法代替 ret。最后一行也可以写成：

bind<Z>(x, _1)(i);

此功能模仿了 Boost Bind 库 [bind]。

请注意，在嵌套的 Lambda 表达式中，必须在推导会失败的每个子表达式中使用 ret。例如：

A a; B b;
C operator+(A, B); D operator-(C);
  ...
ret<D>( - (_1 + _2))(a, b); // error 
ret<D>( - ret<C>(_1 + _2))(a, b); // ok

如果您发现自己反复使用 ret 具有相同的类型，那么扩展返回类型推导（参见 “扩展返回类型推导系统” 一节）是值得的。

struct F { int operator()(int i) const; }; 
F f;
  ...
bind(f, _1);           // fails, cannot deduce the return type
ret<int>(bind(f, _1)); // ok
  ...
bind(f, 1);            // fails, cannot deduce the return type
ret<int>(bind(f, 1));  // fails as well!

bind<int>(f, 1);       // ok

一元函数 constant、constant_ref 和 var 将它们的参数转换为 Lambda 仿函数，该仿函数实现恒等映射。前两个用于常量，最后一个用于变量。由于缺乏 Lambda 表达式的显式语法，这些延迟的常量和变量的使用有时是必要的。例如：

for_each(a.begin(), a.end(), cout << _1 << ' ');
for_each(a.begin(), a.end(), cout << ' ' << _1);

第一行按空格分隔输出 a 的元素，而第二行输出一个空格，然后输出 a 的元素，中间没有分隔符。原因是 cout << ' ' 的任一操作数都不是 Lambda 表达式，因此 cout << ' ' 会立即求值。为了延迟 cout << ' ' 的求值，必须有一个操作数显式标记为 Lambda 表达式。这可以通过 constant 函数来实现：

for_each(a.begin(), a.end(), cout << constant(' ') << _1);

constant(' ') 调用创建一个零元 Lambda 仿函数，该仿函数存储字符常量 ' ' 并在调用时返回对其的引用。函数 constant_ref 类似，但它存储其参数的 const 引用。constant 和 constant_ref 仅在运算符调用具有副作用时才需要，如上例所示。

有时我们需要延迟变量的求值。假设我们想按编号列表输出容器的元素：

int index = 0; 
for_each(a.begin(), a.end(), cout << ++index << ':' << _1 << '\n');
for_each(a.begin(), a.end(), cout << ++var(index) << ':' << _1 << '\n');

第一次 for_each 调用未按预期工作；index 只递增一次，并且其值仅写入输出流一次。通过使用 var 将 index 转换为 Lambda 表达式，可以获得所需的效果。

总而言之，var(x) 创建一个零元 Lambda 仿函数，该仿函数存储对变量 x 的引用。调用 Lambda 仿函数时，会返回对 x 的引用。

var_type<T>::type delayed_i(var(i));
constant_type<T>::type delayed_c(constant(c));

int i = 0; int j;
for_each(a.begin(), a.end(), (var(j) = _1, _1 = var(i), var(i) = var(j))); 

int i = 0; int j;
var_type<int>::type vi(var(i)), vj(var(j));
for_each(a.begin(), a.end(), (vj = _1, _1 = vi, vi = vj));

constant_type<char>::type space(constant(' '));
for_each(a.begin(),a.end(), cout << space << _1);

int i; 
i = _1;       // error
var(i) = _1;  // ok

BLL 定义了几个函数来创建表示控制结构的 Lambda 仿函数。它们都以 Lambda 仿函数作为参数并返回 void。我们先举一个例子，以下代码输出某个容器 a 的所有偶数元素：

for_each(a.begin(), a.end(), 
         if_then(_1 % 2 == 0, cout << _1));  

BLL 支持以下用于控制结构的函数模板：

if_then(condition, then_part)
if_then_else(condition, then_part, else_part)
if_then_else_return(condition, then_part, else_part)
while_loop(condition, body)
while_loop(condition) // no body case
do_while_loop(condition, body)
do_while_loop(condition) // no body case 
for_loop(init, condition, increment, body)
for_loop(init, condition, increment) // no body case
switch_statement(...)

除 if_then_else_return（它包装了对条件运算符的调用）外，所有控制结构 Lambda 仿函数的返回类型均为 void：

condition ? then_part : else_part

此运算符的返回类型规则有些复杂。基本上，如果分支类型相同，则该类型为返回类型。如果分支类型不同，则一个分支（例如类型为 A）必须可转换为另一个分支（例如类型为 B）。在这种情况下，结果类型为 B。此外，如果公共类型是左值，则返回类型也将是左值。

延迟变量在控制结构 Lambda 表达式中通常很常见。例如，这里我们使用 var 函数将 for_loop 的参数转换为 Lambda 表达式。代码的效果是对二维数组的每个元素加 1：

int a[5][10]; int i;
for_each(a, a+5, 
  for_loop(var(i)=0, var(i)<10, ++var(i), 
           _1[var(i)] += 1));  

BLL 支持一种替代的控制表达式语法，由 Joel de Guzmann 提出。通过重载 operator[]，我们可以更接近内置的控制结构。

if_(condition)[then_part]
if_(condition)[then_part].else_[else_part]
while_(condition)[body]
do_[body].while_(condition)
for_(init, condition, increment)[body]

例如，使用这种语法，上面的 if_then 示例可以写成：

for_each(a.begin(), a.end(), 
         if_(_1 % 2 == 0)[ cout << _1 ])  

随着经验的积累，我们可能会弃用这两种语法中的一种。

用于 switch 控制结构的 Lambda 表达式更复杂，因为 case 的数量可能不同。switch Lambda 表达式的一般形式是：

switch_statement(condition, 
  case_statement<label>(lambda expression),
  case_statement<label>(lambda expression),
  ...
  default_statement(lambda expression)
)

condition 参数必须是一个创建具有整型返回类型的 Lambda 仿函数的 Lambda 表达式。不同的 case 通过 case_statement 函数创建，可选的 default case 通过 default_statement 函数创建。case 标签作为显式指定的模板参数传递给 case_statement 函数，并且 break 语句隐式地包含在每个 case 中。例如，case_statement<1>(a)，其中 a 是某个 Lambda 仿函数，会生成以下代码：

case 1: 
  evaluate lambda functor a; 
  break;

switch_statement 函数针对最多 9 个 case 语句进行了特化。

作为具体示例，以下代码遍历容器 v 并为每个 0 输出“zero”，为每个 1 输出“one”，而对于任何其他值 n，则输出“other: n”。请注意，另一个 Lambda 表达式在 switch_statement 之后进行排序，以便在每个元素后输出换行符：

std::for_each(v.begin(), v.end(),
  ( 
    switch_statement(
      _1,
      case_statement<0>(std::cout << constant("zero")),
      case_statement<1>(std::cout << constant("one")),
      default_statement(cout << constant("other: ") << _1)
    ), 
    cout << constant("\n") 
  )
);

BLL 提供了用于抛出和捕获异常的 Lambda 仿函数。通过一元函数 throw_exception 创建用于抛出异常的 Lambda 仿函数。此函数的参数是要抛出的异常，或一个创建要抛出异常的 Lambda 仿函数。通过零元 rethrow 函数创建用于重新抛出异常的 Lambda 仿函数。

用于处理异常的 Lambda 表达式稍微复杂一些。try-catch 块的 Lambda 表达式的一般形式如下：

try_catch(
  lambda expression,
  catch_exception<type>(lambda expression),
  catch_exception<type>(lambda expression),
  ...
  catch_all(lambda expression)
)

第一个 Lambda 表达式是 try 块。每个 catch_exception 定义一个 catch 块，其中显式指定的模板参数定义了要捕获的异常类型。catch_exception 内的 Lambda 表达式定义了捕获异常时要执行的操作。请注意，生成的异常处理器以引用的方式捕获异常，即 catch_exception<T>(...) 会生成以下 catch 块：

catch(T& e) { ... }

最后一个 catch 块也可以是对 catch_exception<type> 的调用，或者对 catch_all 的调用，后者是等同于 catch(...) 的 Lambda 表达式。

示例 17.1，“在 Lambda 表达式中抛出和处理异常。” 演示了 BLL 异常处理工具的使用。第一个处理器捕获 foo_exception 类型的异常。请注意处理器体中 _1 占位符的使用。

第二个处理器展示了如何抛出异常，并演示了异常占位符 _e 的使用。它是一个特殊的占位符，在处理器体中指向被捕获的异常对象。这里我们处理 std::exception 类型的异常，该异常包含一个解释异常原因的字符串。可以使用零参数成员函数 what 来查询此解释。bind(&std::exception::what, _e) 表达式创建了用于进行此调用的 Lambda 函数。请注意，_e 不能在异常处理器 Lambda 表达式外部使用。第二个处理器的最后一行构造了一个新的异常对象，并使用 throw exception 抛出了它。在 Lambda 表达式中构造和析构对象在 “构造和析构” 一节中进行了介绍。

最后，第三个处理器（catch_all）演示了重新抛出异常。

for_each(
  a.begin(), a.end(),
  try_catch(
    bind(foo, _1),                 // foo may throw
    catch_exception<foo_exception>(
      cout << constant("Caught foo_exception: ") 
           << "foo was called with argument = " << _1
    ),
    catch_exception<std::exception>(
      cout << constant("Caught std::exception: ") 
           << bind(&std::exception::what, _e),
      throw_exception(bind(constructor<bar_exception>(), _1)))
    ),      
    catch_all(
      (cout << constant("Unknown"), rethrow())
    )
  )
);

运算符 new 和 delete 可以被重载，但它们的返回类型是固定的。特别是，返回类型不能是 Lambda 仿函数，这阻止了它们被重载用于 Lambda 表达式。无法获取构造函数的地址，因此构造函数不能用作绑定表达式中的目标函数。析构函数也是如此。为了规避这些限制，BLL 为 new 和 delete 调用以及构造函数和析构函数定义了包装器类。这些类的实例是函数对象，可以用作绑定表达式的目标函数。例如：

int* a[10];
for_each(a, a+10, _1 = bind(new_ptr<int>())); 
for_each(a, a+10, bind(delete_ptr(), _1));

new_ptr<int>() 表达式创建一个函数对象，该对象在调用时会调用 new int()，并将其包装在 bind 中使其成为 Lambda 仿函数。同样，delete_ptr() 表达式创建一个函数对象，该对象对其参数调用 delete。请注意，new_ptr<T>() 也可以接受参数。它们直接传递给构造函数调用，从而允许调用带参数的构造函数。

作为 Lambda 表达式中构造函数调用的示例，以下代码从两个容器 x 和 y 中读取整数，将它们组合成对，并将它们插入到第三个容器中：

vector<pair<int, int> > v;
transform(x.begin(), x.end(), y.begin(), back_inserter(v),
          bind(constructor<pair<int, int> >(), _1, _2));

表 17.1，“与构造和析构相关的函数对象。” 列出了所有与创建和销毁对象相关的函数对象，显示了创建和调用函数对象的表达式，以及求值该表达式的效果。

BLL 将常见的 STL 算法定义为函数对象类，这些类的实例可以用作绑定表达式中的目标函数。例如，以下代码遍历二维数组的元素并计算它们的总和。

int a[100][200];
int sum = 0;

std::for_each(a, a + 100, 
	      bind(ll::for_each(), _1, _1 + 200, protect(sum += _1)));

STL 算法的 BLL 版本是类，它们定义了函数调用运算符（或几个重载的运算符）来调用 std 命名空间中的相应函数模板。所有这些结构都位于子命名空间 boost::lambda:ll 中。

请注意，在 Lambda 表达式中很难表达重载的成员函数调用。这限制了嵌套 STL 算法的有用性，因为例如 begin 函数在容器模板中有多个重载定义。通常，无法编写类似于以下伪代码的内容：

std::for_each(a.begin(), a.end(), 
	      bind(ll::for_each(), _1.begin(), _1.end(), protect(sum += _1)));

但是，可以为一些常见特殊情况提供一些帮助。BLL 定义了两个辅助函数对象类 call_begin 和 call_end，它们分别包装对容器的 begin 和 end 函数的调用，并返回容器的 const_iterator 类型。使用这些辅助模板，上述代码变为：

std::for_each(a.begin(), a.end(), 
	      bind(ll::for_each(), 
                   bind(call_begin(), _1), bind(call_end(), _1),
                        protect(sum += _1)));