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

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

Проблема

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 (the []of expression), которое до сих пор не использовалось в этих примерах, например:

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.

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

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

Случаи использования

Библиотека, определяемая стандартом 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;. Это также распространяется на лямбды.

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

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

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

ответы

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

п.с.

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

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

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

What is a lambda expression?

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

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

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

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

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

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

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

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

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

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

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

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

Additional

Lambda expression формат

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

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

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

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

Лямбда в 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;
}

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

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

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