Что такое лямбда-выражение в С++ 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 вводит 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
.
mutable
грим operator()
неконстантные или он делает копии локальных переменными mutable
? Заключение просто делает состояние лямбды mutable
, operator()
остается const
.
const
всегда ...
Концепция лямбда-функции С++ возникает в исчислении лямбда и функциональном программировании. Лямбда - неназванная функция, которая полезна (в реальном программировании, а не в теории) для коротких фрагментов кода, которые невозможно повторно использовать, и их не стоит называть.
В С++ функция лямбда определяется следующим образом
[]() { } // barebone lambda
или во всей красе
[]() mutable -> T { } // T is the return type, still lacking throw()
[]
- это список захвата, ()
список аргументов и {}
тело функции.
Список захвата определяет, что извне лямбда должно быть доступно внутри тела функции и как. Это может быть:
Вы можете смешать все вышеперечисленное в списке, разделенном запятыми [x, &y]
.
Список аргументов такой же, как и в любой другой функции С++.
Код, который будет выполняться при вызове лямбда.
Если lambda имеет только один оператор return, возвращаемый тип может быть опущен и имеет неявный тип decltype(return_statement)
.
Если лямбда отмечена как изменяемая (например, []() mutable { }
), ей разрешено изменять значения, которые были зафиксированы по значению.
Библиотека, определенная стандартом ISO, сильно выигрывает от lambdas и повышает удобство использования нескольких баров, так как теперь пользователям не нужно загромождать свой код небольшими функторами в некоторой доступной области.
В С++ 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 может быть общим (auto
будет эквивалентен T
здесь, если
T
были аргументом шаблона типа где-то в окружении):
auto lambda = [](auto x, auto y) {return x + y;};
С++ 14 позволяет выводить возвращаемые типы для каждой функции и не ограничивает ее функциями вида return expression;
. Это также распространяется на лямбда.
r = &x; r += 2;
, но это происходит с первоначальным значением 4.
Лямбда-выражения обычно используются для инкапсуляции алгоритмов, чтобы они могли быть переданы другой функции. Однако можно выполнить лямбда сразу после определения:
[&](){ ...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);
Если последующее профилирование показывает значительные служебные издержки инициализации для объекта функции, вы можете переписать это как обычную функцию.
if
: if ([i]{ for (char j : i) if (!isspace(j)) return false ; return true ; }()) // i is all whitespace
, предполагая, что i
std::string
ответы
Q: Что такое лямбда-выражение в C++ 11?
A: Под капотом это объект автогенерируемого класса с перегрузкой operator() const. Такой объект называется замыканием и создается компилятором. Эта концепция "закрытия" находится рядом с концепцией связывания из C++ 11. Но lambdas обычно генерируют лучший код. И звонки через закрытие позволяют полностью встраивать.
В: Когда я его буду использовать?
A: Определить "простую и малую логику" и запросить компилятор выполнить генерацию из предыдущего вопроса. Вы даете компилятору некоторые выражения, которые вы хотите быть внутри оператора(). Все остальные компиляторы создадут для вас.
Вопрос: Какой класс проблем они решают, что было невозможно до их введения?
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. Вы можете использовать лямбда для значений захвата "по значению". В этом случае захваченные вары будут скопированы в объект функции (закрытие).
[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. Он содержит обозначения для захвата всех нестатических варов по значению или путем ссылки и указания smth. Больше. Примеры. Захват всех нестатических варов по значению, но путем захвата ссылки Param2
[=,&Param2](int arg1){}
Захват всех нестатических варов по ссылке, но с помощью захвата значения Param2
[&,Param2](int arg1){}
2. Вывод типа возврата
2.1. Возвращаемый тип Lambda может быть выведен, если лямбда - это одно выражение. Или вы можете явно указать его.
[=](int arg1)->trailing_return_type{return trailing_return_type();}
Если lambda имеет более одного выражения, тогда тип возвращаемого значения должен быть задан с помощью возвращаемого типа возврата. Кроме того, подобный синтаксис может применяться к автофункциям и функциям-членам
3. Захваченные значения. Что вы не можете захватить
3.1. Вы можете захватывать только локальные вары, а не переменную-член объекта.
4. Собрания
4.1. lambda не является указателем на функцию и не является анонимной функцией, но может быть неявно преобразован в указатель функции.
п.с.
Подробнее о лямбда-грамматической информации можно найти в Рабочем проекте для языка программирования C++ # 337, 2012-01-16, 5.1.2. Лямбда-выражения, с.88
В C++ 14 добавлена дополнительная функция, названная "захват init". Он позволяет выполнять произвольное объявление членов данных о закрытии:
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');
});
}
из-за ограничений в стандарте С++ 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');
});
}
apply
был шаблон, который принял функтор, он бы работал
Одно из лучших объяснений lambda expression
дано автором C++ Бьярне Страуступом в его книге ***The C++ Programming Language***
глава 11 (ISBN-13: 978-0321563842):
What is a lambda expression?
Выражение лямбда, иногда также называемое лямбда-функцией или (строго говоря, но разговорно) как лямбда, является упрощенной нотацией для определения и использования анонимного функционального объекта. Вместо того, чтобы определять именованный класс с помощью оператора(), позже создавая объект этого класса и, наконец, вызывая его, мы можем использовать сокращенное обозначение.
When would я 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});
}
если вам нужно u, можно назвать 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]: неявно захватывать по ссылке все локальные переменные с именами, а не men-, указанными в списке. Этот список может содержать список захвата. Перечисленным именам не может предшествовать &. Переменные, названные в списке захвата, записываются по значению.
• [=, capture-list]: неявно захватывать по значению все локальные переменные с именами, не указанными в списке. Список захвата не может содержать этого. Перечисленным именам должно предшествовать &. Vari- ables, названные в списке захвата, записываются по ссылке.
Обратите внимание, что локальное имя, которому предшествует &, всегда фиксируется ссылкой, а локальное имя, а не pre-, уступающее & всегда, записывается по значению. Только захват по ссылке позволяет изменять переменные в вызывающей среде.
Additional
Формат Lambda expression
Дополнительные ссылки:
Хорошо, одно практическое применение, которое я обнаружил, - это уменьшение кодовой таблички. Например:
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
. Конечно, вы могли бы создать функцию, но что, если вы хотите ограничить использование в рамках функции пользователя души? характер лямбда выполняет это требование, и я использую его для этого случая.
Одна проблема, которую он решает: Код проще, чем lambda для вызова в конструкторе, который использует функцию выходного параметра для инициализации члена const
Вы можете инициализировать член const вашего класса с вызовом функции, которая устанавливает ее значение, возвращая свой вывод в качестве выходного параметра.
Я видел случай, когда лямбда была очень полезной: коллега из меня делал код, в котором миллионы итераций решались с проблемой оптимизации пространства. Алгоритм был намного более быстрым при использовании лямбда, чем правильной функции! Компилятор - это Visual С++ 2013.