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>.

Использование заполнителей в лямбда-выражении определяет, является ли полученная функция нулярной, унарной, бинарной или 3-аричной. Самый высокий индекс плаценты является решающим. Например:

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

Заметим, что последняя строка создает 3-арную функцию, которая добавляет<10>к еетретийаргумент. Первые два аргумента отброшены. Кроме того, лямбда-функторы имеют только минимальное удобство. Всегда можно привести больше аргументов (по количеству поддерживаемых заполнителей), которые действительно необходимы. Остальные аргументы просто отбрасываются. Например:

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 functor arity ”для обоснования дизайна этой функциональности.

В дополнение к этим трем типам заполнителей существует также четвертый тип заполнителей<placeholderE_type>. Использование этого заполнителя определяется вразделе под названием & #8220; Исключения & #8221;, описывающем обработку исключений в выражениях лямбда.

Когда фактический аргумент предоставляется для заполнителя, режим прохождения параметра всегда ссылается. Это означает, что любые побочные эффекты для заполнителя отражаются на фактическом аргументе. Например:

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

Основное правило заключается в том, что любое обращение оператора C++ с хотя бы одним аргументом, являющимся лямбда-выражением, само по себе является лямбда-выражением. Поддерживаются практически все перегруженные операторы. Например, следующее является действительным выражением лямбда:

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-ary, то<bind-argument-list>должен содержатьnаргументы. В текущей версии BLL должно быть 0<= n<=9. Для членских функций число аргументов должно быть не более 8, так как объектный аргумент занимает одну аргументную позицию. По сути,<bind-argument-list>должен быть обоснованным списком аргументов для целевой функции, за исключением того, что любой аргумент может быть заменен заполнителем или, в более общем смысле, лямбда-выражением. Обратите внимание, что целевой функцией может быть лямбда-выражение. Результатом выражения связывания является либо нулевой, унарный, бинарный или 3-аричный функциональный объект в зависимости от использования заполнителей в<bind-argument-list>(см.раздел под названием & #8220; Заполнители & #8221;).

Тип возврата лямбда-функтора, созданный выражением связывания, может быть задан как явно заданный параметр шаблона, как в следующем примере:

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

Система вычета типа возврата может быть не в состоянии вывести типы возврата некоторых операторов, определенных пользователем, или связать выражения с объектами класса. Предусмотрен специальный лямбда-тип выражения, в котором четко указывается тип возврата и преобладает система вычета. Чтобы указать, что тип возврата лямбда-функтора, определяемый выражением лямбда<e>, равен<T>, можно написать:

ret<T>(e);

Эффект заключается в том, что вычет типа возврата вообще не выполняется для выражения лямбда<e>, а вместо этого<T>используется в качестве типа возврата. Очевидно, что<T>не может быть произвольным типом, истинный результат лямбда-функтора должен быть неявно конвертируемым в<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[связывает].

Обратите внимание, что внутри вложенных лямбда-выражений<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>многократно с одними и теми же типами, стоит при продлении вычета типа возврата (см.раздел под названием & #8220; Расширение системы вычета типа возврата & #8221;).

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>превращают свой аргумент в лямбда-функтор, реализующий отображение идентичности. Первые два относятся к константам, вторые — к переменным. Использование этихотсроченныхконстант и переменных иногда необходимо из-за отсутствия явного синтаксиса для лямбда-выражений. Например:

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

Первая линия выводит элементы<a>, разделенные пространствами, в то время как вторая линия выводит пространство, за которым следуют элементы<a>без каких-либо разделителей. Причина этого в том, что ни один из операндов<cout << ' '>не является лямбда-выражением, поэтому<cout << ' '>оценивается немедленно. Чтобы отсрочить оценку<cout << ' '>, один из операндов должен быть явно обозначен как лямбда-выражение. Это достигается с помощью функции<constant>:

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

Звонок<constant(' ')>создает нулевой лямбда-функтор, который сохраняет константу символа<' '>и возвращает ссылку на него при вызове. Функция<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>выражение лямбда, мы получаем желаемый эффект.

В сумме<var(x)>создает нулевой лямбда-функтор, который хранит ссылку на переменную<x>. Когда лямбда-функтор вызывается, ссылка на<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 определяет несколько функций для создания лямбда-функторов, которые представляют структуры управления. Все они принимают лямбда-функторы в качестве параметров и возвращаются<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(...)

Типы возврата всей конструкции управления лямбда-функтора составляют<void>, за исключением<if_then_else_return>, который обертывает вызов условному оператору.

condition ? then_part : else_part

Правила возврата для этого оператора несколько сложны. В основном, если ветви имеют один и тот же тип, то это тип возврата. Если тип ветвей отличается, одна ветвь, скажем типа<A>, должна быть конвертируемой в другую ветвь, скажем типа<B>. В этой ситуации тип результата<B>. Кроме того, если общий тип является lvalue, то возвратный тип также будет lvalue.

Задержанные переменные, как правило, являются обычным явлением в выражениях лямбда контрольной структуры. Например, здесь мы используем функцию<var>, чтобы превратить аргументы<for_loop>в выражения лямбды. Эффект кода заключается в добавлении 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 поддерживает альтернативный синтаксис для управляющих выражений, предложенный Жоэлем де Гусманном. Перегружая<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>более сложны, поскольку число случаев может варьироваться. Общая форма выражения переключателя лямбда:

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

Аргумент<condition>должен быть лямбда-выражением, создающим лямбда-функтор с интегральным типом возврата. Различные случаи создаются с функциями<case_statement>и необязательным случаем по умолчанию с функцией<default_statement>. Ярлыки случая приведены как явно указанные шаблонные аргументы для<case_statement>функций, а утверждения<break>неявно являются частью каждого случая. Например,<case_statement<1>(a)>, где<a>является неким лямбда-функтором, генерирует код:

case 1: 
  evaluate lambda functor a; 
  break;

Функция<switch_statement>специализирована для до 9 заявлений о случаях.

В качестве конкретного примера, следующий код повторяется над некоторым контейнером<v>и оптутами& #8220;ноль& #8221;для каждого<0>,& #8220;один& #8221;для каждого<1>и& #8220;другой:<n>& #8221;для любого другого значения<n>. Обратите внимание, что после<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 предоставляет лямбда-функторы, которые бросают и ловят исключения. Ламбда-функторы для метания исключений создаются с унарной функцией<throw_exception>. Аргументом этой функции является исключение, которое должно быть брошено, или лямбда-функтор, который создает исключение, которое должно быть брошено. Ламбда-функтор для переброски исключений создается с нулевой функцией<rethrow>.

Выражения лямбда для обработки исключений несколько сложнее. Общая форма выражения лямбда для блоков «попробовать поймать» выглядит следующим образом:

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

Первое выражение лямбда — пробный блок. Каждый<catch_exception>определяет блок улова, где явно указанный аргумент шаблона определяет тип исключения для улова. Выражение лямбда в<catch_exception>определяет действия, которые следует предпринять, если будет поймано исключение. Обратите внимание, что результирующие обработчики исключений улавливают исключения в качестве ссылок, т.е.<catch_exception<T>(...)>приводит к блоку улова:

catch(T& e) { ... }

Последний блок улова может быть вызовом<catch_exception<type>>или<catch_all>, что является выражением лямбда, эквивалентным<catch(...)>.

Пример 18.1, “ Бросать и обрабатывать исключения в выражениях лямбда. ”демонстрирует использование инструментов обработки исключений BLL. Первый обработчик ловит исключения типа<foo_exception>. Обратите внимание на использование<_1>заполнителя в корпусе обработчика.

Второй обработчик показывает, как выбрасывать исключения, и демонстрирует использованиезаполнителя исключения<_e>. Это специальный заполнитель, который относится к пойманному объекту исключения в теле обработчика. Здесь мы имеем дело с исключением типа<std::exception>, которое несет строку, объясняющую причину исключения. Это объяснение можно задать с помощью функции члена с нулевым аргументом<what>. Выражение<bind(&std::exception::what, _e)>создает функцию лямбда для совершения этого вызова. Обратите внимание, что<_e>не может быть использовано за пределами выражения обработчика исключений. Последняя линия второго обработчика конструирует новый объект исключения и бросает его<throw exception>. Конструирование и разрушение объектов в выражениях лямбды объясняется вразделе под названием & #8220; Строительство и разрушение & #8221;

Наконец, третий обработчик<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>могут быть перегружены, но их типы возврата фиксированы. В частности, типы возврата не могут быть лямбда-функторами, что предотвращает их перегрузку для лямбда-выражений. Невозможно взять адрес конструктора, поэтому конструкторы не могут использоваться в качестве целевых функций в выражениях связей. То же самое касается и деструкторов. Как способ обойти эти ограничения, 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>, делает его лямбда-функтором. Таким же образом выражение<delete_ptr()>создает объект функции, который вызывает<delete>на свой аргумент. Обратите внимание, что<new_ptr<T>>()также могут принимать аргументы. Они передаются непосредственно конструктору и, таким образом, позволяют звонить конструкторам, которые принимают аргументы.

В качестве примера вызовов конструктора в лямбда-выражениях следующий код читает целые числа из двух контейнеров<x>и<y>, конструирует из них пары и вставляет их в третий контейнер:

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

Table 18.1, “Construction and destruction related function objects.” lists all the function objects related to creating and destroying objects, showing the expression to create and call the function object, and the effect of evaluating that expression.

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

BLL-версии алгоритмов STL представляют собой классы, которые определяют оператор вызова функции (или несколько перегруженных) для вызова соответствующих шаблонов функций в пространстве имен<std>. Все эти структуры размещаются в подименном пространстве<boost::lambda:ll>.

Обратите внимание, что нет простого способа выразить перегруженный вызов функции члена в выражении лямбда. Это ограничивает полезность вложенных алгоритмов 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)));