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

基本规则是，任何 C++ 运算符调用，只要其中至少一个参数是 lambda 表达式，则其本身也是 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 函数类似，只是它存储对其参数的常量引用。只有当运算符调用具有副作用时，才需要 constant 和 consant_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(...)

所有控制结构 lambda 仿函数的返回类型都是 void，但 if_then_else_return 除外，它包装了对条件运算符的调用

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 仿函数。用于抛出异常的 lambda 仿函数是使用一元函数 throw_exception 创建的。此函数的参数是要抛出的异常，或创建要抛出的异常的 lambda 仿函数。用于重新抛出异常的 lambda 仿函数是使用零元 rethrow 函数创建的。

用于处理异常的 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 中读取整数，从中构造 pair，并将它们插入到第三个容器中

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 算法定义为函数对象类，其实例可以用作 bind 表达式中的目标函数。例如，以下代码迭代二维数组的元素，并计算它们的总和。

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

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

BLL 版本的 STL 算法是类，它们定义了函数调用运算符（或多个重载运算符）来调用 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)));