9 Вопрос: Что такое лямбда-выражение в C ++ 11?

вопрос создан в Wed, Nov 2, 2011 12:00 AM

Что такое лямбда-выражение в C ++ 11? Когда я буду использовать один? Какой класс проблем они решают, что было невозможно до их введения?

Несколько примеров и вариантов использования будут полезны.

    
1351
  1. Я видел случай, когда лямбда была очень полезна: мой коллега делал код, имеющий миллионы итераций для решения задачи оптимизации пространства. Алгоритм был намного быстрее при использовании лямбды, чем правильная функция! Компилятор - Visual C ++ 2013.
    2017-02-12 20: 03: 03Z
9 ответов                              9                         

Проблема

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

#include <algorithm>
#include <vector>

namespace {
  struct f {
    void operator()(int) {
      // do something
    }
  };
}

void func(std::vector<int>& v) {
  f f;
  std::for_each(v.begin(), v.end(), f);
}

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

В C ++ 03 у вас может возникнуть желание написать что-то вроде следующего, чтобы сохранить функтор локальным:

void func2(std::vector<int>& v) {
  struct {
    void operator()(int) {
       // do something
    }
  } f;
  std::for_each(v.begin(), v.end(), f);
}

однако это не разрешено, f нельзя передать в функцию шаблона в C ++ 03.

Новое решение

В C ++ 11 введены лямбда-выражения, позволяющие написать встроенный анонимный функтор для замены struct f. Для небольших простых примеров это может быть чище для чтения (оно хранит все в одном месте) и потенциально проще для поддержки, например, в самая простая форма:

void func3(std::vector<int>& v) {
  std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}

Лямбда-функции - просто синтаксический сахар для анонимных функторов.

Типы возврата

В простых случаях для вас выводится тип возврата лямбды, например:

void func4(std::vector<double>& v) {
  std::transform(v.begin(), v.end(), v.begin(),
                 [](double d) { return d < 0.00001 ? 0 : d; }
                 );
}

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

void func4(std::vector<double>& v) {
    std::transform(v.begin(), v.end(), v.begin(),
        [](double d) {
            if (d < 0.0001) {
                return 0;
            } else {
                return d;
            }
        });
}

Чтобы решить эту проблему, вы можете явно указать тип возвращаемого значения для лямбда-функции, используя -> T:

void func4(std::vector<double>& v) {
    std::transform(v.begin(), v.end(), v.begin(),
        [](double d) -> double {
            if (d < 0.0001) {
                return 0;
            } else {
                return d;
            }
        });
}

«Захват» переменных

Пока что мы не использовали ничего, кроме того, что было передано в лямбду, но мы также можем использовать другие переменные в лямбде. Если вы хотите получить доступ к другим переменным, вы можете использовать предложение capture ([] выражения), которое до сих пор не использовалось в этих примерах, например:

void func5(std::vector<double>& v, const double& epsilon) {
    std::transform(v.begin(), v.end(), v.begin(),
        [epsilon](double d) -> double {
            if (d < epsilon) {
                return 0;
            } else {
                return d;
            }
        });
}

Вы можете захватить как по ссылке, так и по значению, которое можно указать с помощью & и = соответственно:

  • [&epsilon] захват по ссылке
  • [&] фиксирует все переменные, используемые в лямбда-выражениях, по ссылке
  • [=] фиксирует все переменные, используемые в лямбда-выражениях, по значению
  • [&, epsilon] захватывает переменные, такие как [&], но эпсилон по значению
  • [=, &epsilon] захватывает переменные, такие как [=], но эпсилон по ссылке

Сгенерированный operator() по умолчанию равен const, при этом при обращении к ним по умолчанию будет получено значение const. Это приводит к тому, что каждый вызов с одним и тем же вводом будет давать один и тот же результат, однако вы можете пометить лямбду как mutable , чтобы запросить, чтобы получаемый operator() не был const.

    
1369
2018-08-14 09: 50: 26Z
  1. @ YАкк ты попал в ловушку. Лямбды без перехвата имеют неявное преобразование в указатели типов функций. функция преобразования const всегда ...
    2013-03-31 22: 17: 16Z
  2. @ JohannesSchaub-litb о подлый - и это происходит, когда вы вызываете () - это передается как лямбда с нулевым аргументом, но потому что () const не соответствует лямбда, он ищет преобразование типа, которое позволяет это, которое включает в себя неявное приведение к функции-указателю, а затем вызывает это! Sneaky!
    2013-04-01 00: 55: 59Z
  3. Интересно - я изначально думал, что лямбда-выражения являются анонимными функциями , а не функторами, и не понимал, как работают захваты.
    2014-03-09 01: 39: 54Z
  4. Если вы хотите использовать лямбда-выражения в качестве переменных в своей программе, вы можете использовать: std::function<double(int, bool)> f = [](int a, bool b) -> double { ... }; Но обычно мы позволяем компилятору выводить тип: auto f = [](int a, bool b) -> double { ... }; (и не забывайте до #include <functional>)
    2015-04-10 16: 15: 38Z
  5. Я полагаю, что не все понимают, почему return d < 0.00001 ? 0 : d; гарантированно возвращает double, когда один из операндов является целочисленной константой (это происходит из-за неявного правила продвижения оператора?: оператор, в котором 2-й и 3-й операнды уравновешиваются друг с другом посредством обычных арифметических преобразований независимо от того, какой из них выбирается). Изменение на 0.0 : d, возможно, облегчит понимание этого примера.
    2015-12-17 07: 32: 52Z

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

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

В C ++ лямбда-функция определяется следующим образом

[]() { } // barebone lambda

или во всей красе

[]() mutable -> T { } // T is the return type, still lacking throw()

[] - это список захвата, () - список аргументов и {} - тело функции.

Список захвата

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

  1. значение: [x]
  2. ссылка [& x]
  3. любая переменная, которая в данный момент находится в области видимости по ссылке [&]
  4. то же, что 3, но по значению [=]

Вы можете смешать любое из перечисленного в списке через запятую [x, &y].

Список аргументов

Список аргументов такой же, как и в любой другой функции C ++.

Тело функции

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

Вывод типа возврата

Если у лямбды есть только один оператор возврата, тип возврата может быть опущен и имеет неявный тип decltype(return_statement).

Mutable

Если лямбда помечена как изменяемая (например, []() mutable { }), то разрешается изменять значения, захваченные по значению.

Варианты использования

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

C ++ 14

В C ++ 14 лямбд были расширены различными предложениями.

Инициализированные лямбда-захваты

Элемент списка захвата теперь можно инициализировать с помощью =. Это позволяет переименовывать переменные и захватывать при перемещении. Пример взят из стандарта:

int x = 4;
auto y = [&r = x, x = x+1]()->int {
            r += 2;
            return x+2;
         }();  // Updates ::x to 6, and initializes y to 7.

и один взят из Википедии, показывающий, как снимать с std::move:

auto ptr = std::make_unique<int>(10); // See below for std::make_unique
auto lambda = [ptr = std::move(ptr)] {return *ptr;};

Общие лямбды

Лямбды теперь могут быть родовыми (auto будет эквивалентно T здесь, если T был аргумент шаблона типа где-то в окружающей области):

auto lambda = [](auto x, auto y) {return x + y;};

Улучшенное удержание типа возврата

C ++ 14 позволяет выводить типы возврата для каждой функции и не ограничивает ее функциямив форме return expression;. Это также распространяется на лямбды.

    
792
2014-06-03 09: 26: 10Z
  1. В вашем примере для инициализированных лямбда-захватов, приведенном выше, почему вы заканчиваете функцию lamba с помощью () ;? Это выглядит как [] () {} (); вместо [](){};. Также не должно ли значение x быть 5?
    2016-06-09 13: 25: 45Z
  2. @ RamakrishnanKannan: 1) функция () должна вызывать лямбду сразу после ее определения и возвращать y ее возвращаемое значение. Переменная y является целым числом, а не лямбда-выражением. 2) Нет, x = 5 является локальным для лямбды (захват по значению, у которого просто имя совпадает с именем внешней переменной области видимости x), и затем возвращается x + 2 = 5 + 2. Переназначение внешней переменной x происходит через ссылку r: r = &x; r += 2;, но это происходит с исходным значением 4.
    2016-07-14 13: 40: 13Z

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

[&](){ ...your code... }(); // immediately executed lambda expression

функционально эквивалентен

{ ...your code... } // simple code block

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

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

int a = []( int b ){ int r=1; while (b>0) r*=b--; return r; }(5); // 5!

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

[&]( std::function<void()> algorithm ) // wrapper section
   {
   ...your wrapper code...
   algorithm();
   ...your wrapper code...
   }
([&]() // algorithm section
   {
   ...your algorithm code...
   });

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

auto algorithm = [&]( double x, double m, double b ) -> double
   {
   return m*x+b;
   };

int a=algorithm(1,2,3), b=algorithm(4,5,6);

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

    
163
2015-11-24 09: 22: 53Z
  1. Вы поняли, что этот вопрос был задан 1,5 года назад и что последнее действие было почти 1 год назад? В любом случае, вы вносите интересные идеи, которых я раньше не видел!
    2013-03-01 08: 32: 38Z
  2. Спасибо за совет по одновременному определению и выполнению! Я думаю, что стоит отметить, что это работает как условие для if операторов: if ([i]{ for (char j : i) if (!isspace(j)) return false ; return true ; }()) // i is all whitespace, предполагая, что i является std::string
    2013-03-02 01: 13: 48Z
  3. Таким образом, следующее является допустимым выражением: [](){}();.
    2013-04-13 22: 35: 59Z
  4. Тьфу! Синтаксис Python (lambda: None)() гораздо более разборчивый.
    2013-05-30 03: 28: 54Z
  5. @ nobar - вы правы, я опечатка. Это законно (на этот раз я проверял) main() {{{{((([](){{}}())));}}}}
    2014-05-02 16: 05: 40Z

Ответы

В: Что такое лямбда-выражение в C ++ 11?

A: Под капотом это объект автоматически сгенерированного класса с перегрузкой operator () const . Такой объект называется closure и создается компилятором. Эта концепция «замыкания» близка к концепции связывания из C ++ 11. Но лямбды обычно генерируют лучший код. А вызовы через замыкания позволяют полностью встроить.

В: Когда я буду использовать один?

A: Определить "простую и маленькую логику" и попросить компилятор выполнить генерацию из предыдущего вопроса. Вы даете компилятору несколько выражений, которые вы хотите использовать внутри operator (). Все остальные вещи компилятор сгенерирует вам.

В: Какой класс проблем они решают, что было невозможно до их появления?

A: Это своего рода синтаксический сахар, похожий на перегрузку операторов вместо функций для пользовательских операций add, subrtact ... Но при этом сохраняется больше строк ненужного кода для переноса 1-3 строк реального логика для некоторых классов и т. д.! Некоторые инженеры считают, что если число строк меньше, то вероятность ошибиться в нем меньше (я тоже так думаю)

Пример использования

auto x = [=](int arg1){printf("%i", arg1); };
void(*f)(int) = x;
f(1);
x(1);

Дополнительные сведения о лямбдах, не охваченные вопросом. Игнорируйте этот раздел, если вы не заинтересованы

1. Захваченные значения. Что вы можете захватить

1,1. Вы можете ссылаться на переменную со статической продолжительностью хранения в лямбдах. Все они захвачены в плен.

1,2. Вы можете использовать лямбду для захвата значений «по значению». В этом случае захваченные переменные будут скопированы в объект функции (замыкание).

[captureVar1,captureVar2](int arg1){}

1,3. Вы можете захватить ссылки. &Амп; - в этом контексте означает ссылку, а не указатели.

   [&captureVar1,&captureVar2](int arg1){}

1,4. Существует нотация для захвата всех нестатических переменных по значению или по ссылке

  [=](int arg1){} // capture all not-static vars by value

  [&](int arg1){} // capture all not-static vars by reference

1,5. Существует нотация для захвата всех нестатических переменных по значению или по ссылке и указания чего-либо. Больше. Примеры: Захватить все нестатические переменные по значению, но по ссылке захватить Param2

[=,&Param2](int arg1){} 

Захватите все нестатические переменные по ссылке, но по значению Param2

[&,Param2](int arg1){} 

2. Возвращаемый тип удержания

2,1. Лямбда-тип возврата может быть выведен, если лямбда-выражение является одним выражением. Или вы можете указать это явно.

[=](int arg1)->trailing_return_type{return trailing_return_type();}

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

3. Захваченные значения. Что вы не можете захватить

3,1. Вы можете захватывать только локальные переменные, а не переменную-член объекта.

4. Сonversions

4.1 !! Лямбда не является указателем на функцию и не является анонимной функцией, но лямбды без захвата можно неявно преобразовать в указатель на функцию.

p.s.

  1. Более подробную информацию о лямбда-грамматике можно найти в Рабочем проекте для языка программирования C ++ # 337, 2012-01-16, 5.1.2. Лямбда-выражения, стр.88

  2. В C ++ 14 была добавлена ​​дополнительная функция, названная как "init capture". Позволяет произвольно выполнять декларацию закрывающих членов данных:

    auto toFloat = [](int value) { return float(value);};
    auto interpolate = [min = toFloat(0), max = toFloat(255)](int value)->float { return (value - min) / (max - min);};
    
38
2018-10-09 19: 57: 34Z
  1. Разве я не освещал что-то.? Почему я получил минус?
    2015-06-03 22: 51: 56Z
  2. Я добавляю информацию о захвате, вычете типа возврата в C ++ 11 после того, как кто-то дал мне минус. Это не было упомянуто в вопросе, но я добавляю это, чтобы ответить! Может быть, это была причина минуса моего поста без этого "лишнего раздела ...."
    2015-06-04 11: 01: 49Z
  3. Этот [&,=Param2](int arg1){} не является допустимым синтаксисом. Правильная форма будет [&,Param2](int arg1){}
    2017-04-15 08: 00: 24Z
  4. Спасибо. Сначала я попытался скомпилировать этот фрагмент. И егостранная ассиметрия в допустимых модификаторах в списке захвата //g ++ -std = c ++ 11 main.cpp -o test_bin; ./test_bin #include < stdio.h > int main () {#if 1 {int param = 0; auto f = [=, & param] (int arg1) mutable {param = arg1;}; F (111); printf ("% i \n", param); } #endif #if 0 {int param = 0; auto f = [&, = param] (int arg1) mutable {param = arg1;}; F (111); printf ("% i \n", param); } #endif return 0; }
    2017-04-16 13: 02: 45Z
  5. Выглядит, что новая строка не поддерживается в комментарии. Затем я открыл 5.1.2 лямбда-выражения, стр.88, «Рабочий проект, стандарт для языка программирования C ++», номер документа: # 337, 2012-01-16. И посмотрел в грамматический синтаксис. И ты прав. Не существует такой вещи, как захват через "= arg"
    2017-04-16 13: 07: 05Z

Лямбда-функция - это анонимная функция, которую вы создаете в строке. Он может захватывать переменные, как объяснили некоторые (например, http://www.stroustrup.com/C++11FAQ .html # lambda ), но есть некоторые ограничения. Например, если есть такой интерфейс обратного вызова,

void apply(void (*f)(int)) {
    f(10);
    f(20);
    f(30);
}

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

int col=0;
void output() {
    apply([](int data) {
        cout << data << ((++col % 10) ? ' ' : '\n');
    });
}

Но вы не можете сделать это:

void output(int n) {
    int col=0;
    apply([&col,n](int data) {
        cout << data << ((++col % 10) ? ' ' : '\n');
    });
}

из-за ограничений в стандарте C ++ 11. Если вы хотите использовать снимки, вы должны полагаться на библиотеку и

#include <functional> 

(или какой-либо другой библиотеке STL, такой как алгоритм, чтобы получить его косвенно), а затем работать с std :: function вместо передачи нормальных функций в качестве параметров, подобных этому:

#include <functional>
void apply(std::function<void(int)> f) {
    f(10);
    f(20);
    f(30);
}
void output(int width) {
    int col;
    apply([width,&col](int data) {
        cout << data << ((++col % width) ? ' ' : '\n');
    });
}
    
15
2015-03-11 00: 16: 13Z
  1. причина в том, что лямбда может преобразовываться в указатель на функцию, только если она не имеет перехвата. если бы apply был шаблоном, который принял функтор, он бы работал
    2015-03-10 23: 50: 06Z
  2. Но проблема в том, что если apply - это существующий интерфейс, вы не можете себе позволить объявить его иначе, чем обычная старая функция. Стандарт можно было бы спроектировать так, чтобы каждый раз при запуске такого лямбда-выражения генерировался новый экземпляр простой старой функции с генерируемыми жестко закодированными ссылками на захваченные переменные. Кажется, лямбда-функция генерируется во время компиляции. Есть и другие последствия. например, если вы объявляете статическую переменную, даже если вы переоцениваете лямбда-выражение, вы не получите новую статическую переменную.
    2015-03-11 00: 29: 58Z
  3. указатель на функцию часто предназначен для сохранения, и перехват лямбды может выходить за рамки. что только лямбды без захвата, конвертированные в указатели на функции, были разработаны
    2015-03-11 00: 37: 18Z
  4. Вы все равно должны обратить внимание на то, что переменные стека освобождаются по той же причине в любом случае. См. blogs.msdn.com. /b /nativeconcurrency /archive /2012/01/29 /… Пример, который я написал с помощью output и apply, написан так, что, если бы вместо него были разрешены и использовались указатели на функции, они также работали. Col остается распределенным до тех пор, пока не завершатся все вызовы функций из apply. Как бы вы переписали этот код для работы с использованием существующего интерфейса применения? Вы бы в конечном итоге использовали глобальные или статические переменные или более неясное преобразование кода?
    2015-03-11 01: 34: 26Z
  5. или, возможно, вы просто подразумеваете, что лямбда-выражения являются r-значениями и, следовательно, временными, но код остается постоянным (одноэлементным /статическим), поэтому его можно вызывать в будущем. В этом случае, возможно, функция должна оставаться выделеннойs до тех пор, пока его перехваты, выделенные стеком, остаются выделенными. Конечно, это может привести к беспорядку, если, например, в цикле размещено много вариантов функции.
    2015-03-11 01: 49: 20Z

Одно из лучших объяснений lambda expression дано автором C ++ Бьярном Страуструпом в его книге ***The C++ Programming Language***, глава 11 ( ISBN-13: 978-0321563842 ):

What is a lambda expression?

  

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

When would I use one?

  

Это особенно полезно, когда мы хотим передать операцию как   аргумент алгоритма. В контексте графических пользовательских интерфейсов   (и в других местах) такие операции часто называют обратными вызовами .

What class of problem do they solve that wasn't possible prior to their introduction?

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

  

эффективные способы оптимизации

Some examples

с помощью лямбда-выражения

void print_modulo(const vector<int>& v, ostream& os, int m) // output v[i] to os if v[i]%m==0
{
    for_each(begin(v),end(v),
        [&os,m](int x) { 
           if (x%m==0) os << x << '\n';
         });
}

или через функцию

class Modulo_print {
         ostream& os; // members to hold the capture list int m;
     public:
         Modulo_print(ostream& s, int mm) :os(s), m(mm) {} 
         void operator()(int x) const
           { 
             if (x%m==0) os << x << '\n'; 
           }
};

или даже

void print_modulo(const vector<int>& v, ostream& os, int m) 
     // output v[i] to os if v[i]%m==0
{
    class Modulo_print {
        ostream& os; // members to hold the capture list
        int m; 
        public:
           Modulo_print (ostream& s, int mm) :os(s), m(mm) {}
           void operator()(int x) const
           { 
               if (x%m==0) os << x << '\n';
           }
     };
     for_each(begin(v),end(v),Modulo_print{os,m}); 
}

если вам нужно, вы можете назвать lambda expression как показано ниже:

void print_modulo(const vector<int>& v, ostream& os, int m)
    // output v[i] to os if v[i]%m==0
{
      auto Modulo_print = [&os,m] (int x) { if (x%m==0) os << x << '\n'; };
      for_each(begin(v),end(v),Modulo_print);
 }

Или возьмите другой простой пример

void TestFunctions::simpleLambda() {
    bool sensitive = true;
    std::vector<int> v = std::vector<int>({1,33,3,4,5,6,7});

    sort(v.begin(),v.end(),
         [sensitive](int x, int y) {
             printf("\n%i\n",  x < y);
             return sensitive ? x < y : abs(x) < abs(y);
         });


    printf("sorted");
    for_each(v.begin(), v.end(),
             [](int x) {
                 printf("x - %i;", x);
             }
             );
}

будет генерировать следующий

  

0 р>      

1 р>      

0 р>      

1 р>      

0 р>      

1 р>      

0 р>      

1 р>      

0 р>      

1 р>      

0 отсортировано - 1; x - 3; x - 4; x - 5; x - 6; x - 7; x - 33;

[] - это список захвата или lambda introducer: если lambdas не требует доступа к их локальной среде, мы можем его использовать.

Цитата из книги:

  

Первым символом лямбда-выражения всегда является [. Лямбда   Интродуктор может принимать различные формы:

     

[] : пустой список захвата. это   подразумевает, что никакие локальные имена из окружающего контекста не могут быть использованы   в лямбда-теле. Для таких лямбда-выражений данные получаются из   аргументы или из нелокальных переменных.

     

[&] : неявный захват   ссылка. Все местные имена могут быть использованы. Все локальные переменные   доступ по ссылке.

     

[=] : неявный захват по значению. Все местные   имена могут быть использованы. Все имена относятся к копиям локальных переменных   берется в точке вызова лямбда-выражения.

     

[capture-list]: явный захват; список захвата - это список имен локальных переменных, которые должны быть захвачены (т.е. сохранены в объекте) по ссылке или по значению. Переменные с именами, которым предшествует & захвачены   ссылка. Другие переменные фиксируются по значению. Список захвата может   также содержат это и имена, сопровождаемые ... как элементы.

     

[&amp ;, capture-list] : неявно захватывает по ссылке все локальные переменные с именами, не упомянутыми в списке. Список захвата может содержать это. Перечисленным именам не может предшествовать &amp ;. Переменные, названные в   список захвата захвачен по значению.

     

[=, capture-list] : неявно захватывает по значению все локальные переменные с именами, не упомянутыми в списке. Список захвата не может содержать это. Перечисленным именам должен предшествовать &amp ;. Переменные, названные в списке захвата, захватываются по ссылке.

     

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

Additional

Lambda expression формат

 введите описание изображения здесь

Дополнительные ссылки:

11
2016-11-09 11: 11: 21Z

Ну, одно практическое применение, которое я обнаружил, - это сокращение кода котельной плиты. Например:

void process_z_vec(vector<int>& vec)
{
  auto print_2d = [](const vector<int>& board, int bsize)
  {
    for(int i = 0; i<bsize; i++)
    {
      for(int j=0; j<bsize; j++)
      {
        cout << board[bsize*i+j] << " ";
      }
      cout << "\n";
    }
  };
  // Do sth with the vec.
  print_2d(vec,x_size);
  // Do sth else with the vec.
  print_2d(vec,y_size);
  //... 
}

Без лямбды вам может понадобиться что-то сделать для разных случаев bsize. Конечно, вы могли бы создать функцию, но что, если вы хотите ограничить использование в рамках пользовательской функции Soul? природа лямбда выполняет это требование, и я использую его для этого случая.

    
2
2017-03-30 04: 24: 52Z

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

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

    
1
2017-05-23 12: 18: 29Z
  1. Это также можно сделать с помощью простой функции, которая даже соответствует тому, что говорит принятый ответ на вопрос, на который вы ссылаетесь.
    2016-09-09 02: 50: 47Z

Лямбда в c ++ обрабатывается как "функция, доступная на ходу". да, буквально на ходу, вы определяете это; используй это; и когда область родительской функции заканчивается, лямбда-функция исчезла.

c ++ представил его на c ++ 11, и все начали использовать его, как и везде. пример и что такое лямбда можно найти здесь https://en.cppreference.com/ж /CPP /язык /лямбда

я опишу, чего нет, но важно знать каждому программисту на c ++

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

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

Ниже приведен основной пример лямбды и того, что происходит в фоновом режиме.

Код пользователя:

int main()
{
  // Lambda & auto
  int member=10;
  auto endGame = [=](int a, int b){ return a+b+member;};

  endGame(4,5);

  return 0;

}

Как компиляция расширяет его:

int main()
{
  int member = 10;

  class __lambda_6_18
  {
    int member;
    public: 
    inline /*constexpr */ int operator()(int a, int b) const
    {
      return a + b + member;
    }

    public: __lambda_6_18(int _member)
    : member{_member}
    {}

  };

  __lambda_6_18 endGame = __lambda_6_18{member};
  endGame.operator()(4, 5);

  return 0;
}

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

    
1
2019-06-04 10: 22: 34Z
  1. да, буквально на ходу, вы определяете его; используй это; и когда родительская функция завершает область действия, лямбда-функция исчезла .. что, если функция возвращает лямбда-функцию вызывающей стороне?
    2019-06-05 01: 53: 38Z
  2. Это также не самое быстрое сравнение с обычной функцией. потому что у него есть некоторые накладные расходы, которые должны быть обработаны лямбда. Есть ли у васкогда-нибудь фактически запускал какой-либо тест для поддержки этого утверждения ? Напротив, шаблоны lambda + часто генерируют максимально быстрый код.
    2019-06-05 01: 57: 08Z
источник размещен Вот