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

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

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

[]() { } // barebone lambda

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

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

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

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

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

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

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

аргумент

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

тело функции

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

тип возврата вычет

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

Mutable

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

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

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

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!

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

[&]( 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: под капотом, это объект класса автоматически с перегрузкой оператор () const. Такой объект называется закрытие и создан компилятором. Эта концепция "закрытия" близка к концепции привязки из C++11. Но lambdas обычно генерируют лучший код. И звонки через закрытие позволяют полностью inlining.

Q: когда бы я использовал один?

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

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

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

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

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

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

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

1.1. Вы можете ссылаться на переменную со статической продолжительностью хранения в lambdas. Они все в плену.

1.2. Вы можете использовать лямбда для значений захвата "по значению". В таком случае захваченные vars будут скопированы в объект функции (закрытие).

[captureVar1,captureVar2](int arg1){}

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

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

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

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

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

1.5. Существует нотация для захвата всех нестатических vars по значению или по ссылке и указания smth. больше. Образцы: Захват всех нестатических vars по значению, но по ссылке захват Param2

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

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

[&,Param2](int arg1){} 

2. Тип возврата вычет

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

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

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

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

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

4. Конверсии

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

п.з.

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

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

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

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?

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

When would I use one?

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

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

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

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

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 sortedx-1; x-3;x - 4;x - 5;x - 6;x - 7; x - 33;

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

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

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

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

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

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

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

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

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

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

Additional

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

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

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

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