Лямбда-функция - довольно интуитивно понятная концепция Modern C ++,  представленная в C ++ 11, поэтому в интернете уже есть множество статей по обучению лямбда-функциям. Но, тем не менее, остаются некоторые темы (такие как IIFE, типы лямбды и т.д.), о которых стоит упомянуть.

Что такое лямбда-функция?

Лямбда-выражениями называются безымянные локальные функции, которые можно создавать прямо внутри какого-либо выражения. Лямбда-выражения в C++ — это краткая форма записи анонимных функторов 

Другими словами, это просто синтаксический сахар. Синтаксис лямбда-функции определяется как:

[ capture list ] (parameters) -> return-type   {        method definition } 

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

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

Почему мы должны использовать лямбда-функцию?

C ++ включает в себя много полезных универсальных функций, таких как std::for_each, что может быть удобно. К сожалению, они также могут быть довольно громоздкими, особенно если функтор, который вы хотите применить, уникален для конкретной функции. Рассмотрим следующий код для примера:

struct print {     void operator()(int element)     {         cout << element << endl;     } }; int main(void) {     std::vector<int> v = {1, 2, 3, 4, 5};     std::for_each(v.begin(), v.end(), print());     return 0; }

Если вы используете print один раз, в этом конкретном месте, кажется излишним писать целый класс, просто чтобы сделать что-то тривиальное и одноразовое.

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

std::for_each(v.begin(), v.end(), [](int element) { cout << element << endl; });

Как лямбда-функции работают внутри?

[&i] ( ) { std::cout << i; } // is equivalent to struct anonymous {     int &m_i;     anonymous(int &i) : m_i(i) {}     inline auto operator()() const     {        std::cout << i;     } };

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

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

Кроме того, вы можете объявить переменную / объект в аргументе лямбда-функции, который станет аргументом для вызова оператора, т.е. operator()

Преимущества использования лямбда-функции

1. Нулевая стоимость абстракции. Да! Вы правильно прочитали. Лямбда не влияет на производительность и так же быстра, как обычная функция.
2. Кроме того, код становится компактным, структурированным и выразительным.

Изучение лямбда-выражения

Захват по ссылке / значению

int main() {     int x = 100, y = 200;     auto print = [&] { // Capturing object by reference         std::cout << __PRETTY_FUNCTION__ << " : " << x << " , " << y << std::endl;     };     print();     return 0; }

Результат:

main()::<lambda()> : 100 , 200

В приведенном выше примере упомянут & в списке захвата. который захватывает переменную x & y в качестве ссылки. По аналогии, = обозначает захваченное значение, которое создаст элемент данных того же типа в замыкании, и будет выполнено назначение копирования.

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

Список лямбда-захвата

В следующей таблице показаны разные варианты использования одного и того же:

Передача лямбды в качестве параметра

template <typename Functor> void f(Functor functor) {     std::cout << __PRETTY_FUNCTION__ << std::endl; } /* Or alternatively you can use this void f(std::function<int(int)> functor) {     std::cout << __PRETTY_FUNCTION__ << std::endl; }  */ int g() { static int i = 0; return i++; } int main() {     auto lambda_func = [i = 0]() mutable { return i++; };     f(lambda_func); // Pass lambda     f(g);           // Pass function }

Результат:

Function Type : void f(Functor) [with Functor = main()::<lambda(int)>] Function Type : void f(Functor) [with Functor = int (*)(int)]

Вы также можете передать лямбда-функцию в качестве аргумента другой функции.

Если вы заметили, здесь объявлена переменная. В результате каждый раз, когда вы вызываете lambda_func, она будет возвращаться и увеличиваться.

Перехват переменной в лямбда-выражении 

class Example { public:     Example() : m_var(10) {}     void func()     {         [=]() { std::cout << m_var << std::endl; }(); // IIFE     } private:     int m_var; }; int main() {     Example e;     e.func(); }

this указатель также может быть захвачен с помощью [this], [=] или [&], В любом из этих случаев члены данных класса (включая private) будут доступны, как и в обычном методе.

Как вы видете, использовано дополнительные () в конце объявления лямбда-функции, которое вызывало его сразу после объявления. Ето называется  IIFE  ( выражение для немедленного вызова функции ).

Типы C ++ лямбда-функций

Общая лямбда

const auto l = [](auto a, auto b, auto c) {}; // is equivalent to struct anonymous {     template <class T0, class T1, class T2>     auto operator()(T0 a, T1 b, T2 c) const     {     } };

Общая лямбда, представленная в C ++ 14,  может захватывать параметры с auto спецификатором.

Variadic универсальный лямбда

void print() {} template <typename First, typename... Rest> void print(const First &first, Rest &&... args) {     std::cout << first << std::endl;     print(args...); } int main() {     auto variadic_generic_lambda = [](auto... param) {         print(param...);     };     variadic_generic_lambda(1, "lol", 1.1); }

Лямбда с переменным пакетом параметров будет полезна во многих сценариях, таких как отладка, повторная работа с вводом различных данных и т.д.

mutable лямбда-функция

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

[]() mutable {} // is equivalent to struct anonymous {     auto operator()()  // call operator     {     } };

Мы уже видели пример этого выше. 

Лямбда как указатель на функцию

#include <iostream> #include <type_traits> int main() {     auto funcPtr = +[] {};     static_assert(std::is_same<decltype(funcPtr), void (*)()>::value); }

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

Возвращающие лямбда-функции высшего порядка

const auto less_than = [](auto x) {     return [x](auto y) {         return y < x;     }; }; int main(void) {     auto less_than_five = less_than(5);     std::cout << less_than_five(3) << std::endl;     std::cout << less_than_five(10) << std::endl;     return 0; }

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

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

Начиная с C ++ 17, лямбда-выражение может быть объявлено как  constexpr .

constexpr auto sum = [](const auto &a, const auto &b) { return a + b; }; /*     is equivalent to     constexpr struct anonymous     {         template <class T1, class T2>         constexpr auto operator()(T1 a, T2 b) const         {             return a + b;         }     }; */ constexpr int answer = sum(10, 10);

Даже если вы не укажете constexpr оператор вызова функции будет constexpr в любом случае, если это удовлетворяет все требования функции.