Double operator() ( doublex, doubley ) const

// ^ Аргументы как аргументы оригинальной лямбды

{

return3.0 * x / ( y + 2.0 ); // <- Тело как в теле оригинальной лямбды

}

};

std::transform(

vX.begin(), vX.end(), vY.begin(),

std::back_inserter( vR ),

Labmda_1()

);

Итак, ЛЯМБДА-выражение в языке С++ - это неименованный функциональный объект, тело и код создания которого автоматически генерируется компилятором на основе заданных программистом инструкций. Лямбда-выражения с подходящими форматами аргументов и возвращаемым типом могут быть использованы во всех конструкциях, где могут использоваться вызываемые сущности.

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

Эту же идею можно применить для упрощения ранее созданной вспомогательной функции для вывода содержимого последовательности на экран - предоставляемое лямбда-выражение максимально простым способом задает что именно нужно сделать с каждым из элементов перебираемой последовательности:

template< typenameInputIt >

voidprintCollection ( InputIt _first, InputIt _last, const char* _prefix )

{

std::cout << _prefix;

std::for_each( _first, _last,
[] ( typenameInputIt::value_type x )
{
std::cout << x << ' ';
}
);

std::cout << std::endl;

}

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

std::sort(

employees.begin(), employees.end(),

[] ( constEmployee * _pEmployee1, constEmployee * _pEmployee2 ) -> bool

{

if( _pEmployee1->getName() < _pEmployee2->getName() )

return true;

else if( _pEmployee1->getName() == _pEmployee2->getName() )

return_pEmployee1->getAge() < _pEmployee2->getAge();

Else

return false;

}

);

Очевидно, применение лямбд намного привлекательнее прежних устаревающих способов записи и особенно комбинирования функциональных объектов. В целом, лямбда-выражения значительно разгружают сложность использования функциональных объектов для управления поведением алгоритмов. Это делает более привлекательным также и использование стандартных алгоритмов STL, ранее скованное сложностью записи каких-либо нетривиальных предикатов для реально встречающихся на практике случаев.

При необходимости, лямбда-выражения могут быть вложенными, однако не стоит увлекаться написанием настолько сложного для восприятия кода. Обычно, крупное лямбда-выражение стоит разбить на несколько вспомогательных функций.

Std::function

Пусть в программе имеется три варианта сортировки данных о сотрудниках:

● в алфавитном порядке по фамилии;

● в порядке убывания зарплаты;

● в порядке убывания возраста.

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

enum classEmployeeSortMode

{

Alphabetical,

Salaries,

Age

};

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

voidsortEmployees (

std::vector< Employee * > & _employees,

EmployeeSortMode _sortMode

)

{

// Выбираем способ сортировки в зависимости от режима

switch( _sortMode )

{

// Сортировка по алфавиту

caseEmployeeSortMode::Alphabetical:

std::sort(

_employees.begin(), _employees.end(),

[] ( constEmployee * _pEmployee1,
constEmployee * _pEmployee2 )

{

return_pEmployee1->getName() < _pEmployee2->getName();

}

);

break;

// Сортировка по возрасту

caseEmployeeSortMode::Age:

std::sort(

_employees.begin(), _employees.end(),

[] ( constEmployee * _pEmployee1,
constEmployee * _pEmployee2 )

{

return_pEmployee1->getAge() > _pEmployee2->getAge();

}

);

break;

// Сортировка по зарплате

caseEmployeeSortMode::Salaries:

std::sort(

_employees.begin(), _employees.end(),

[] ( constEmployee * _pEmployee1,
constEmployee * _pEmployee2 )

{

return _pEmployee1->getSalary() > _pEmployee2->getSalary();

}

);

break;

// Неизвестный режим сортировки

default:

throwstd::logic_error( "Unexpected sort mode" );

}

}

Такой вариант решения содержит немало повторяющегося кода по вызову алгоритма sort. По сути, между режимами сортировки отличается только лямбда-выражение, определяющее критерий сравнения сотрудников. Для упрощения кода имеет смысл выделить выбор предиката в зависимости от режима в отдельную функцию, а в данной функции вызывать сортировку лишь однократно.

Это намерение моментально наталкивается на вопрос - а какой тип имеют эти лямбда-выражения? До лямбда-выражений мы бы выбирали бы функцию сравнения при помощи указателя на функцию определенной сигнатуры, однако каждый функциональный объект и, соответственно, каждое лямбда-выражение, имеют свой уникальный тип. В случае лямбда-выражений этот тип еще и полностью зависит от компилятора. В контексте шаблонов это никого не смущает, поскольку тип лямбда-выражения нигде в коде явно не указывается. В нашей же ситуации необходимо записать какой-то конкретный тип для возврата лямбда-выражения из вспомогательной функции, который подойдет к каждому из 3 лямбда-выражений.

В стандартной библиотеке имеется специальное средство std::function, представляющее собой универсальную абстракцию вызываемой сущности определенного формата. Объявление для такого объекта выглядит следующим довольно необычным образом (все же, немного симпатичней, чем указатели на функции):

std::function< bool( constEmployee *, constEmployee * ) > comparator;

^ ^

возвращаемый -------- формальные аргументы -----
тип

Объект std::function можно инициализировать одним из возможных вариантов вызываемой сущности:

● указателем на функцию:

boolMyEmployeeCompareFunction ( constEmployee *, constEmployee * );

comparator = & myEmployeeCompareFunction;

● функциональным объектом:

structMyEmployeeCompareFunctor

{

bool operator() ( constEmployee *, constEmployee * ) const;

};

comparator = & MyEmployeeCompareFunctor();

● лямбда-выражением:

comparator = [] ( constEmployee *, constEmployee * ) { … }

После инициализации объект std::function можно свободно передавать по значению или по ссылке. Окружающий std::function код вовсе не обязан быть шаблонным. Для вызова используется стандартный функциональный синтаксис:

boolresult = comparator( employees[ 0 ], employees[ 1 ] );

Итак, преобразуем программу к желаемому виду. Пусть выбор лямбда-выражения в зависимости от желаемого режима сортировки происходит в следующей функции:

std::function< bool( constEmployee *, constEmployee * ) >

getEmployeeSortingPredicate ( EmployeeSortMode _sortMode )

{

// Выбираем предикат для сортировки в зависимости от режима

switch( _sortMode )

{

// Сортировка по алфавиту

caseEmployeeSortMode::Alphabetical:

return[] ( constEmployee * _pEmployee1, constEmployee * _pEmployee2 )

{

return_pEmployee1->getName() < _pEmployee2->getName();

};

// Сортировка по возрасту

caseEmployeeSortMode::Age:

return[] ( constEmployee * _pEmployee1, constEmployee * _pEmployee2 )

{

return_pEmployee1->getAge() > _pEmployee2->getAge();

};

// Сортировка по зарплате

caseEmployeeSortMode::Salaries:

return[] ( constEmployee * _pEmployee1, constEmployee * _pEmployee2 )

{

return_pEmployee1->getSalary() > _pEmployee2->getSalary();

};

// Неизвестный режим сортировки

default:

throwstd::logic_error( "Unexpected sort mode" );

}

}

Основная функция сортировки заметно упрощается:

voidsortEmployees ( std::vector< Employee * > & _employees,
EmployeeSortMode _sortMode )

{

std::sort(

_employees.begin(),

_employees.end(),

getEmployeeSortingPredicate( _sortMode ) // выбор предиката по режиму

);

}

Протестируем решение при помощи простой тестовой программы:

intmain ()

{

// Набор тестовых данных о сотрудниках

std::vector< Employee * > employees;

employees.push_back( newEmployee( "Ivanov", 25, 1000.0 ) );

employees.push_back( newEmployee( "Ivanov", 45, 2000.0 ) );

employees.push_back( newEmployee( "Petrov", 50, 750.0 ) );

employees.push_back( newEmployee( "Sidorov", 34, 1200.0 ) );

// Сортировка по возрасту

std::cout << "===== By Age ===== " << std::endl;

sortEmployees( employees, EmployeeSortMode::Age );

printEmployees( employees );

// Сортировка по зарплате

std::cout << "===== By Salary ===== " << std::endl;

sortEmployees( employees, EmployeeSortMode::Salaries );

printEmployees( employees );

// Сортировка по алфавиту

std::cout << "===== By Name ===== " << std::endl;

sortEmployees( employees, EmployeeSortMode::Alphabetical );

printEmployees( employees );

// Освобождение объектов

std::for_each(
employees.begin(), employees.end(),
[] ( Employee * pE ) { deletepE; }
);

}

В результате запуска получим следующий результат: