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

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

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

Ответы

Ответ 1

Проблема

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

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

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] захватывает переменные, такие как [=], но epsilon по ссылке

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

Ответ 2

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

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

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

[]() { } // barebone lambda

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

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

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

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

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

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

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

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

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

Тело функции

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

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

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

Mutable

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

Использовать случаи

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

С++ 14

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

Инициализированные снимки лямбда

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

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

Общие Lambdas

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

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

Улучшенная вычитание возвращаемого типа

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

Ответ 3

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

[&](){ ...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...
   });

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

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

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

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

Ответ 4

ответы

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

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

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

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

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

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

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

п.с.

Более подробную информацию о лямбда-грамматике можно найти в Рабочем проекте для языка программирования C++ # 337, 2012-01-16, 5.1.2. Лямбда-выражения, стр .88
В 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);};
```

Ответ 5

Лямбда-функция - анонимная функция, которую вы создаете в строке. Он может захватывать переменные, как объясняли некоторые (например, 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');
    });
}

из-за ограничений в стандарте С++ 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');
    });
}

Ответ 6

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

What is a lambda expression?

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

When would я 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; х - 3; х - 4; х - 5; х - 6; х - 7; х - 33;

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

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

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

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

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

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

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

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

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

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

Additional

Формат Lambda expression

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

Wiki
open-std.org, глава 5.1.2

Ответ 7

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

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. Конечно, вы могли бы создать функцию, но что, если вы хотите ограничить использование в рамках функции пользователя души? характер лямбда выполняет это требование, и я использую его для этого случая.

Ответ 8

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

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

я опишу, чего нет, но важно знать каждому программисту 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;
}

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

Ответ 9

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

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

Ответ 10

Я видел случай, когда лямбда была очень полезной: коллега из меня делал код, в котором миллионы итераций решались с проблемой оптимизации пространства. Алгоритм был намного более быстрым при использовании лямбда, чем правильной функции! Компилятор - это Visual С++ 2013.