В этом разделе мы приводим основные примеры использования выражений лямбда BLL в вызовах алгоритма STL. Мы начинаем с простых выражений и работаем. Во-первых, мы инициализируем элементы контейнера, скажем,<list>, к значению.<1>:

list<int> v(10);
for_each(v.begin(), v.end(), _1 = 1);

The expression _1 = 1 creates a lambda functor which assigns the value 1 to every element in v.^[3]

Далее мы создаем контейнер указателей и заставляем их указывать на элементы в первом контейнере<v>:

vector<int*> vp(10); 
transform(v.begin(), v.end(), vp.begin(), &_1);

Выражение<&_1>создает объект функции для получения адреса каждого элемента в<v>. Адреса присваиваются соответствующим элементам в<vp>.

Следующий фрагмент кода изменяет значения в<v>. Для каждого элемента называется функция<foo>. Первоначальное значение элемента передается в качестве аргумента<foo>. Результат<foo>присваивается обратно элементу:

int foo(int);
for_each(v.begin(), v.end(), _1 = bind(foo, _1));

Следующим шагом является сортировка элементов<vp>:

sort(vp.begin(), vp.end(), *_1 > *_2);

В этом призыве к<sort>мы сортируем элементы по их содержимому в порядке убывания.

Наконец, следующий<for_each>вызов выводит сортированное содержимое<vp>, разделенное разрывами линий:

for_each(vp.begin(), vp.end(), cout << *_1 << '\n');

Обратите внимание, что нормальное (не-ламбда) выражение как субэкспрессия выражения лямбда оценивается немедленно. Это может вызвать сюрпризы. Например, если предыдущий пример переписан как

for_each(vp.begin(), vp.end(), cout << '\n' << *_1);

Субэкспрессия<cout << '\n'>оценивается немедленно, и эффект состоит в том, чтобы вывести один разрыв линии, за которым следуют элементы<vp>. BLL обеспечивает функции<constant>и<var>для превращения констант и, соответственно, переменных в лямбда-выражения и может использоваться для предотвращения немедленной оценки подвыражений:

for_each(vp.begin(), vp.end(), cout << constant('\n') << *_1);

Эти функции более подробно описаны вразделе под названием “ Задержка констант и переменных”.

Во время вызова лямбда-функтора фактические аргументы заменяются заполнителями. Заполнители не диктуют тип этих фактических аргументов. Основное правило заключается в том, что лямбда-функция может быть вызвана аргументами любых типов, если лямбда-выражение с выполненными заменами является действительным выражением C++. В качестве примера выражение<_1 + _2>создает двоичный лямбда-функтор. Его можно назвать с двумя объектами любых типов<A>и<B>, для которых определен<operator+(A,B)>(и для которых BLL знает тип возврата оператора, см. ниже).

C++ не имеет механизма для запроса типа выражения. Однако этот точный механизм имеет решающее значение для реализации лямбда-выражений C++. Следовательно, BLL включает в себя несколько сложную систему дедукции типа, которая использует набор классов признаков для дедукции результирующего типа функций лямбда. Он обрабатывает выражения, в которых операнды имеют встроенные типы, и многие выражения со стандартными типами библиотек. Многие из определяемых пользователем типов также охватываются, особенно если операторы, определяемые пользователем, соблюдают обычные соглашения при определении типов возврата.

Однако бывают случаи, когда тип возврата не может быть выведен. Предположим, что вы определили:

C operator+(A, B);

Вызов функции лямбда не выполняется, так как тип возврата не может быть выведен:

A a; B b; (_1 + _2)(a, b);

Для этого есть два альтернативных решения. Первый заключается в расширении системы вычета типа BLL для охвата ваших собственных типов (см.раздел под названием & #8220; Расширение системы вычета типа возврата & #8221;). Во-вторых, следует использовать специальное лямбда-выражение<ret>, которое определяет тип возврата на месте (см.раздел под названием & #8220; Пересмотр выведенного типа возврата & #8221;):

A a; B b; ret<C>(_1 + _2)(a, b);

Для выражений связывания тип возврата может быть определен как шаблонный аргумент функции связывания:

bind<int>(foo, _1, _2);

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

int i = 1; int j = 2; 
(_1 + _2)(i, j); // ok
(_1 + _2)(1, 2); // error (!)

Это ограничение не так плохо, как может показаться. Поскольку лямбда-функторы чаще всего называются внутри STL-алгоритмов, аргументы исходят из итераторов дереференций, а операторы дереференций редко возвращают значения r. И в тех случаях, когда они это делают, есть обходные пути, обсуждаемые вразделе под названием & #8220; Значения как фактические аргументы для лямбда-функторов & #8221;.

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

int i = 1;
(_1 = 2, _1 + i)(i);

Оператор запятой перегружен, чтобы объединить выражения лямбда в последовательность; получившийся унарный лямбда-функтор сначала присваивает 2 своему аргументу, а затем добавляет к нему значение<i>. Значение выражения в последней строке 3, а не 4. Иными словами, лямбда-выражение, которое создается<lambda x.(x = 2, x + 1)>, а не<lambda x.(x = 2, x + i)>.

Как уже говорилось, это поведение по умолчанию, для которого есть исключения. Точные правила следующие: