С++. Лямбда-функции. Знакомство с синтаксисом
Что такое лямбда-функции в С++? Я попытаюсь дать вам понять доступное и очень понятное объяснение.
- Лямбда-функции — это то же, что функциональные_объекты_классов, но имеющие свой собственный синтаксис сущности.
К лямбда-функции можно относиться как к обычной функции, но из-за странного на первый взгляд синтаксиса, коды с этими лямбда-функциями может быть сложно читать. Состоит лямбда-функция из двух основных частей: квадратные скобки и фигурные скобки.
|
1 2 3 4 |
//Листинг #1 Лямбда-функция C++11 mingw int main(){ []{}; } |
Такое написание аналог объявления пустой обычной функции, только в нашем случае функция получается анонимной, потому что имя задавать лямбда-функции не нужно. Они обычно используются, как правило, везде для объявления анонимных функций.
Поскольку лямбда-функции могут заменять функции, то давайте произведём вызов.
|
1 2 3 4 5 6 7 8 9 |
//Листинг #2 Использование лямбда-функции C++11 mingw #include <iostream> using namespace std; int main() { []{ cout << "lambda-func\n"; }; //Это объявление []{ cout << "lambda-func\n"; }(); //А вызов делается с помощью круглых скобок в конце } |
В круглые скобки вызова можно отдавать значения аргументов, но тут такое дело, что где-то должны быть описаны типы принимаемых лямбда-функцией значений, и эти типы описываются в круглых скобках слева от фигурных:
|
1 2 3 4 5 6 7 8 9 10 |
//Листинг #3 Лямбда-функции Параметры и аргументы С++11 mingw #include <iostream> using namespace std; int main() { [](const int x){ cout << "x == " << x; }(10); //Отдаём аргументы cout << "\n\n"; [](const int x, const double d){ cout << "x == " << x << "\nd == " << d; }(10, 20.3); //Принимаем в параметры лямбда-функции переданные значения } |
Квадратные скобки представляют собой своеобразную ловушку для захвата внешних по отношению к лямбда-функции переменных. Можно отлавливать всё, что находится в той же области видимости, где расположилась сама лямбда-функция. Есть несколько вариантов отлова: по значению, по ссылке, захват указателя this по значению, можно захватывать или отдельные переменные, или всё, что есть в зоне видимости.
Если мы захватываем что-то по значению, то внутри лямбда-функции такая захваченная сущность получает себе атрибут "только для чтения", отчего внутри лямбда-функции изменениям захваченное не подлежит:
|
1 2 3 4 5 6 7 8 9 |
//Листинг #4.1 Лямбда-функции Захват по значению #include <iostream> int main() { int x; [x]{ x++; }; //захвачен x, но попытка изменить значение x //приводит к ошибке компиляции } |
|
1 2 3 4 5 6 7 8 9 10 11 |
//Листинг #4.2 Лямбда-функции Захват по значению #include <iostream> using std::cout; int main() { int x = 10; [x]{ cout << x; }(); //захвачен x, выводим значение на экран } |
Захват по ссылке позволяет лямбда-функции напрямую влиять на сущность, и любые изменения внутри лямбда-функции происходят так, как если бы лямбда-функции и не было:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
//Листинг #5 Лямбда-функции Захват по ссылке #include <iostream> using std::cout; int main() { int x = 10; [&x](){ x++; }(); //Изменяем x внутри, не забываем запустить лямбда-функцию cout << x << '\n'; //x поменял своё значение } |
Захватывать можно как по отдельности каждую переменную, так и скопом всё, что есть:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
//Листинг #6.1 Лямбда-функции Захваты #include <iostream> using std::cout; int main() { int x = 10; double y = 5.5; [&x, y](){ }(); //захват x по ссылке, y по значению } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
//Листинг #6.2 Захват всех значений из доступной области видимости #include <iostream> using std::cout; int main() { int x = 10; double y = 5.5; [&](){ x++, y = y + 10; }(); //захват всех значений по ссылке из текущей области видимости cout << "x == " << x << '\n'; //11 cout << "y == " << y << '\n'; //15 } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//Листинг #6.3 Лямбда-функции Захваты #include <iostream> using std::cout; int main() { int x = 10; double y = 5.5; [=](){ int z = x; }(); //захват всех значений по значению из текущей области видимости } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
//Листинг #6.4 Лямбда-функции Захваты #include <iostream> using std::cout; class MyClass{ const int x = 100; public: void show(){ [this]{ cout << x; }(); //захват this } }; int main() { MyClass m; m.show(); } |
Если вы уберёте захват this в листинге #6.4, То пример просто не скомпилируется. Сам же захват this позволяет легко использовать внутри лямбда-функции все переменные, объявленные в классе:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
//Листинг #6.5 Лямбда-функции Захваты #include <iostream> using std::cout; class MyClass{ int x = 100; double y = 5.5; public: void foo(){ int y = z; [this] {x++; y = 20; ////z++;}(); //захват this, все переменные класса стали доступны //но не внешние переменные области видимости лямбда-функции!! } void print() const { cout << "x == " << x << '\n'; cout << "y == " << y << '\n'; } }; int main() { MyClass m; m.foo(); m.print(); } |
Надеюсь, примеров достаточно, чтобы понять, что это за захват такой. Захватывать можно только автоматические переменные. Это означает, что нельзя захватывать такие, как глобальные, статические. В примере ниже будет показана попытка захвата по значению, и, как вы помните, захват по значению делает захваченное только для чтения, но не изменения. В нашем же случае изменение произойдёт, потому что никакого захвата не будет.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
//Листинг #7 Лямбда-функции Захватывать можно только переменные с автоматическим классом хранения mingw C++11 #include <iostream> using std::cout; int global_value = 10; int main() { [=](){ x++; }(); cout << global_value << '\n'; //всё удачно скомпилировалось } |
Обратите внимание на предупреждение, которое выдаёт компилятор, если у вас включен вывод предупреждений. Компилятор будет пытаться дать вам понять, что произошла попытка захвата неавтоматической переменной. Подобную ошибку легко словить от недостатка знаний или по невнимательности, так что помните этот момент и не подловитесь, выискивать такие проблемы довольно сложно.
Чтобы захватывать несколько сущностей, нужно в захвате разделять их запятыми:
******************
Лямбда-функции в С++ можно запоминать в объекты. Тип у лямбда-функций анонимный, поэтому при указании его используют ключевое слово auto, благодаря которому тип выводится автоматически:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
//Листинг #8 Запоминание лямбда-функций в объекты C++11 mingw #include <iostream> #include <functional> using std::cout; int main() { auto lambda_fun1 = []{}; //Запомнили лямбда-функцию в объект auto lambda_fun2 = []{ return 200; }; //Запомнили лямбда-функцию в объект auto hello_world1 = []{ cout << "hello"; }; auto hello_world2 = [](const char* S){ cout << S; }; //вызываем лямбда-функции с помощью объектов-хранителей lambda_fun1(); //пустая, ничего не произойдёт lambda_fun2(); //ничего не произойдёт cout << lambda_fun2() << '\n'; //выведет на экран 200 cout << '\n'; hello_world1(); //выведет на экран "hello" cout << '\n'; hello_world2("hi-hi-hi"); //выведет на экран "hi-hi-hi" } |
Запомненные лямбда-функции можно использовать как обычные переменные: пересылать их в функции и классы, удобно встраивать в места, где нужны функторы. Если вы разобрались с тем, что описывалось чуть выше, то поймёте листинг #8 без особого труда. Но вы, наверное, обратили внимание, что в одном варианте из двух случаев используется cout, а в другом нет. Это связано с тем, что в том варианте, где используется, возвращается некоторое значение, и лямбда-функция автоматически определяет его тип, в нашем случае тип возвращаемого значения определяется как int, а как нам известно, cout умеет работать c этим типом, поэтому такое вот возможно. В другом же случае нет возвращаемого значения, и тип определяется как void, а с этим товарищем cout Не дружит, вот и всё объяснение. В некоторых случаях компилятор может не определить наиболее предпочтительный тип, и тогда возвращаемый из лямбда-функции тип надо указывать явно:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
////Листинг #9.1 Возникновение необходимости явного указания возвращаемого из лямбда-функции типа C++11 mingw #include <iostream> using std::cout; int main() { auto lambda_fun = []{ int x = 10; if (x == 10) return 5; else return 1.6; //компилятор не знает, что выбрать для результирующего объекта лямбды: int или double }; } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
////Листинг #9.2 Возникновение необходимости явного указания возвращаемого из лямбда-функции типа C++11 mingw #include <iostream> using std::cout; int main() { auto lambda_fun = []()->double{ //явно указываем, что возвращаемый тип будет double int x = 10; if (x == 10) return 5; else return 1.6; //теперь всё ОК }; cout << lambda_fun(); } |
Надеюсь, и с присваиванием мы разобрались. Может возникнуть вопрос "А как передать объект-хранитель_лямбды в функцию?". Естественно, что если мы имеем объект, то можем его пересылать и принимать.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
//Листинг #10.1 Передаём лямбда-функцию в независимую функцию C++11 mingw #include <iostream> using std::cout; void foo(double (*ptr)()){ //Создали функцию для приёма лямбда-функции cout << ptr() << '\n'; //приняли лямбда-функцию в ptr и используем её } int main() { auto lambda_fun = []()->double{ //явно указываем, что возвращаемый тип будет double int x = 10; if (x == 10) return 5; else return 1.6; //теперь всё ОК }; foo(lambda_fun); } |
Как вы можете увидеть, я использовал функцию, принимающую указатель на функцию, и это вполне подошло для приёма лямбда-функции. Но лучше использовать немного другой способ (немного дальше я объясню почему):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
//Листинг #10.2 Передаём лямбда-функцию в независимую функцию C++11 mingw #include <iostream> #include <functional> using std::cout; using std::function; void foo(function<double()> ptr){ //Создали функцию для приёма лямбда-функции cout << ptr() << '\n'; //приняли лямбда-функцию в ptr и используем её } int main() { auto lambda_fun = []()->double{ return 200.5; }; foo(lambda_fun); } |
Листинг #9.2 может казаться сложным, но если вы внимательно присмотритесь, то обнаружите, что ничего сложного нет. Для многих из вас, да и для меня, новый элемент немного незнаком, но понять, как использовать его, довольно-таки просто. Используя заголовочный файл functional, мы получаем возможность использовать std::function, которым мы обозначим тип нашей лямбда-функции. Поскольку моя версия лямбда-функции возвращает тип double, то в угловых скобках типа function мы и пишем этот double, а поскольку мы имеем не просто тип, а функцию, то ставим круглые скобки. Поскольку моя версия лямбда-функции имитировала функцию без параметров, то в круглых скобках ничего указывать не нужно. Если бы были параметры, то требовалось бы указать их типы:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//Листинг #10.3 Передаём лямбда-функцию в независимую функцию C++11 mingw //использование std::functional #include <iostream> #include <functional> #include <string> using std::cout; using std::function; using std::string; void foo(function<double(int, string)> ptr){ //2. Типы этих параметров указываются в круглых скобках cout << ptr(0, "") << '\n'; //3. Вызываем нашу лямбда-функцию,не забываем, что она сейчас с параметрами } int main() { auto lambda_fun = [](int x, string S)->double{ //1. у лямбда-функции появились параметры return 200.5; }; foo(lambda_fun); } |
Того же эффекта можно добиться с помощью использования шаблонов:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
//Листинг #10.4 Передаём лямбда-функцию в независимую функцию C++11 mingw //использование шаблонов #include <iostream> #include <functional> #include <string> using std::cout; using std::function; using std::string; template <typename T> void foo(T ptr){ //Тип автоматически подставится cout << ptr(0, "") << '\n'; } int main() { auto lambda_fun = [](int x, string S)->double{ //1. у лямбда-функции появились параметры return 200.5; }; foo(lambda_fun); } |
Не буду писать о том, какой из этих трёх способов лучше, потому что не знаю ни как они устроены, ни что толком они делают. Но могу сказать, что вариант с шаблоном наиболее лаконичный, отчего привлекательнее. Вы увидели то, что должны были посмотреть: передачу лямбда-функции в функции, и, надеюсь, теперь у вас с этим трудностей не будет. Дальше по тексту я ещё распишу про это, если кому-то того, что есть вдруг недостаточно. Использовать указатель на функцию не всегда возможно, а использование std::function предполагает дополнительные расходы и времязатраты. Вариант же с шаблоном может здорово оптимизироваться компиляторами.
Вернёмся немного назад, к захватам, поговорим про них ещё. Мы знаем про захваты и умеем сохранять лямбда-функции в объекты. Давайте посмотрим на следующий код:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
//Листинг #12 #include <iostream> using std::cout; int main() { int x = 1; int y = 2; auto lambda_fun = [x, &y]{ cout << "x == " << x << '\n'; cout << "y == " << y << '\n'; cout << "\n\n"; }; lambda_fun(); //1,2 x = y = 100; lambda_fun(); //1,100 x = 200; lambda_fun(); //1,100 y = 77; lambda_fun(); //1,77 } |
Как вы легко можете заметить, x не изменяется, а y изменяется. Связано это с тем, что в первом случае внутри лямбда-функции создаётся локальная копия x, а с y работа происходит с влиянием извнутри лямбда-функции на вовне, поскольку y захвачен по ссылке, то и работает лямбда-функция с ним как если бы обычная функция работала с параметром, принятым по ссылке. Для значения x была создана отдельная временная переменная, в которую и скопировано значение, и при этом эта переменная живёт только внутри лямбда-функции, она локальна по отношению к ней, поэтому внешнее воздействие на x её не затрагивает.
Иногда нужно выполнить захват объекта по значению и иметь возможность изменять значение внутри лямбда-функции. Поскольку по умолчанию мы получаем объект только для чтения, для такого случая нужна подсказка компилятору: необходимо задействовать ключевое слово mutable:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
#include <iostream> #include <functional> using std::cout; int main() { int x = 10; auto lambda_func = [x]() mutable{ return ++x; }; cout << lambda_func() << '\n'; cout << lambda_func() << '\n'; cout << lambda_func() << '\n'; } |
Внутренняя для лямбда-функции x теперь успешно изменяется, но не запутайтесь: внешняя остаётся какой была — поскольку сам весь этот процесс ничем не отличается от работы обычной функции с параметрами по значению. Поскольку лямбда-функция умеет хранить внутреннее состояние, то состояние x сохраняется, пока живёт объект, хранящий лямбда-функцию.
Поскольку лямбда-функции можно запоминать в объекты, объекты-хранители лямбда-функций можно использовать для пересылки в функции, классы, т. е. использовать их как если бы они были обычными переменными. И вот возникает вопрос, а как передать лямбда-функцию в нелямбда-функцию? В некоторых случаях достаточно обойтись функцией, принимающей указатель на функцию, при этом нужно следить, чтобы тип принимаемого указателя соответствовал пересылаемой функции.
|
1 2 3 4 5 6 7 8 9 |
//Листинг #13.1 Пересылка лямбда-функции в другую функцию void foo(void (*p)()){ p(); //выполняем пришедшую функцию } int main() { auto lambda = []{}; //аналог функции void lambda(){} foo(lambda); //пересылаем лямбда-функцию в foo и там и запускаем } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
//Листинг #13.2 Пересылка лямбда-функции в другую функцию #include <iostream> #include <string> using std::string; using std::cout; void foo(void (*p)(string)){ p("HELLO"); //выполняем пришедшую функцию } int main() { auto lambda = [](string S){ cout << S << '\n'; }; //аналог функции void lambda(string){} foo(lambda); //пересылаем лямбда-функцию в foo и там и запускаем } |
Лямбда-функции можно передавать и друг в друга:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
//Листинг #13.3 Пересылка лямбда-функции в лямбда-функцию #include <iostream> #include <string> using std::string; using std::cout; int main() { auto lambda = [](string S){ cout << S << '\n'; }; //ВАРИАНТ1 [](auto type){ type("HELLO"); }(lambda); //вызов на месте cout << '\n'; //ВАРИАНТ2 auto my_func = [](auto type){ type("my_func"); }; //Запомнили в объект my_func(lambda); //использовали запомненный объект } |
Было бы неплохо, если всё было бы так просто с написанием параметров принимающей функции, и параметр ограничивался бы указателем на функцию, но не всегда это прокатывает. Это сработает только при следующих условиях:
- Если лямбда-функция не захватывает переменные
- Если лямбда-функция не является шаблоном
- Если типы аргументов и возвращаемых значений совпадают
Вот, например, код, в котором происходит попытка использовать захваченную переменную, этот код не компилируется, потому что подобные лямбда-функции не способны быть приведены к указателю:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
//Листинг #14.1 Неудачная попытка передачи лямбда-функции в параметр другой функции #include <iostream> #include <string> using std::string; using std::cout; void foo(void (*ptr)()){ ptr(); } int main() { int x; auto lambda = [&](){ x++; }; foo(lambda); } |
Можно было бы показать пример попроще, но с ним есть некоторые нюансы:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
//Листинг #14.2 Попытка привести лямбда-функцию к указателю на функцию #include <string> using std::string; using std::cout; void foo(void (*ptr)()){ ptr(); } int main() { int x; auto lambda = [&](){}; foo(lambda); } |
Листинг #14.2 имеет скрытую проблему. В старых компиляторах этот код может компилироваться, в более новых он компилироваться не будет. Поэтому будем ориентироваться на листинг #14.1. Поскольку есть захват лямбда-функцией, то лямбда-функция к указателю привестись не может, а если она не может привестись к указателю, то и параметр принимающей функции, параметр-указатель, не может подобрать объект-хранитель этой лямбда-функции. Такая вот незадача. Из-за таких ситуаций предпочтение отдаётся не параметрам-указателям_на_функции. В стандартной библиотеке шаблонов существует специальная обёртка, которая позволит обозначить тип для приёма какой угодно функции, в том числе и лямбда-функции. Использование его может показаться запутанным, но если вы хорошо понимаете синтаксис указателей на функции, то проблемы у вас не возникнет. А если вы уже успели понять эту часть, когда я её затронул, то в тем более.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
//Листинг #15.1 Использование std::function #include <iostream> #include <functional> using std::function; //используем тип для приёма функций using std::cout; void foo(function<void()> ptr){ ptr(); } int main() { int x = 100; auto lambda = [&](){ x++; }; foo(lambda); cout << x << '\n'; //теперь x == 101 } |
Немного объясню о синтаксисе std::function. В угловых скобках обозначается тип принимаемой функции. Поскольку тип нашей лямбда-функции соответствовал типу void, то на этот раз в угловых скобках тип обозначился void. Если бы тип результирующего объекта лямбда-функции был другим, то вместо этого void указывался бы он. А поскольку это всё-таки функция, к этому типу добавляется список формальных параметров. Но о параметрах чуть позднее.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
//Листинг #15.2 Использование std::function #include <iostream> #include <functional> using std::function; //используем тип для приёма функций using std::cout; void foo(function<double()> ptr){ //std::function для функции типа double foo() ptr(); } int main() { int x = 100; auto lambda = [&]()->double{ return x++; }; //тип возвращаемого объекта double foo(lambda); cout << x << '\n'; //теперь x == 101 } |
Остаётся надеяться, что стало понятно, что именно подаётся в угловые скобки. Рядом с угловыми скобками используются круглые, обозначающие список формальных параметров принимаемой функции. Поскольку в этот раз у нас использовалась лямбда-функция, соответствующая функции без параметров, круглые скобки оставались пустыми. Если бы лямбда-функция соответствовала функции с параметрами, то типы тех параметров были бы описаны в круглых скобках:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
//Листинг #15.3 Использование std::function #include <iostream> #include <functional> #include <string> using std::function; //используем тип для приёма функций using std::cout; using std::string; void foo(function<double(string)> ptr){ //std::function для функции типа double foo(string) ptr("HELLO"); } int main() { int x = 100; auto lambda = [&](string)->double{ return x++; }; //лямбда-функция соответствует функции double lambda(string) foo(lambda); } |
Остаётся надеяться, что эта тема дала вам понять то многое, что не предлагают другие товарищи, описывающие лямбда-функции, и теперь вы их сможете использовать и даже читать чужие, не мучаясь от их синтаксиса. Но учтите, что всего о лямбда-функциях я не написал, есть ещё какие-то моменты, которые я упустил.
При присваивании лямбда-функций в объекты особо невнимательные мы можем иногда запутаться и ненароком запомнить не функцию, а результирующий объект:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//Листинг #16 Немного запутались, будьте внимательны к вызовам функций и к использованию их названий не для вызова #include <iostream> using std::cout; int main() { auto lambda = [] () { return 0; }(); //поскольку функция вызывается, то в lambda сохранится 0, а не лямбда-функция cout << lambda << '\n'; //можно не заметить подвох cout << lambda() << '\n'; //вызов функции должен был происходить так, но сейчас оно не функция } |
Одна из рекомендаций хорошего стиля: делать лямбда-функции как можно проще, и использовать вместо них именованные функции, если необходимый фрагмент кода не умещается в одну или две строки. Это связано с тем фактом, что лямбда-функции имея своеобразный синтаксис могут очень сильно осложнить прочтение кода, поэтому не злоупотребляйте ими.
Немного о терминах, с которыми вы или встречались, или совсем скоро встретитесь:
Замыкание (closure) — результирующий объект, создаваемый лямбда-функцией.
Класс замыкания (closure class) — класс, из которого инстанцируется замыкание.
Лямбда-интродьюсер — Те скобки, которые предназначены для захвата, со всем своим содержимым.
trailing-return-type — возвращаемый из лямбды явно тип для создаваемого лямбдой конечного объекта
capture-list — список захватываемых объектов. В него входят все те значения, которые захватываются явно. Общее обозначение всего того, что не &, =, this,
Захват всего скопом с помощью [=] или [&] может показаться хорошей идеей, но можно напороться на скрытую ловушку: поймать висячую ссылку.
- Во время захвата явно перечисляйте захватываемые локальные переменные.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
//Листинг #17 Захват this C++17 #include <iostream> class MyClass { int x; public: int y; void my_method(){ [=]{ //Вы можете думать, что захватили лямбдой {х}, но это не так //{x} не локальная переменная, а атрибут класса //вы захватили {this} вместо {x} }; // [x]{} //Поскольку {x} атрибут класса, вы не можете захватить его как обычную переменную // [this->x]{}; //И даже так не выйдет, потому что область видимости атрибутов //это то же, что если бы вы обращались к {х}, //а он в другой зоне видимости //Можно захватить сам {this}, тогда все атрибуты класса станут доступны лямбде [this]{ x; y; }; //Теперь и {x} и {y} доступны лямбде //А можно захватывать отдельные атрибуты [x=x]{}; //создание внутренней для лямбда одноимённой копии {x} [&x=x]{}; //создание внутренней для лямбда одноимённо ссылки на атрибут {x} //Можно сделать вне лямбда-функции ссылку на атрибут int &rx = x; [rx]{}; //захватили {x} по значению, внутри лямбды {rx} то же, что настоящий {x} [&rx]{}; //захватили ссылку на {x} } }; int main() { } |
Вы когда захватываете всё скопом, используя [&] или [=], то можете упустить из виду некоторые моменты (или по незнанию, или от невнимательности), и потом, если случится так, что некоторый объект с лямбда-функцией переживёт собственную лямбда-функцию, то дальнейшие обращения к объекту будут вести к непредсказуемому поведению программы.
Небольшая шпаргалка по способам захвата:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
//Листинг #18.1 Захваты #include <iostream> using std::cout; int main() { int x,y,z; [&]{}; //захват всех локальных переменных из области видимости лямбда //по ссылке [=]{}; //захват всех по значению [=,&y]{}; //захват всех по значению, за исключением {y}, //который хватается по ссылке [&z, y]{}; //захват {z} по ссылке, {y} по значению [x = x]{}; //С++14, создание локальной в лямбда х и присваивание хватаемого х [&x =x]{}; //C++14, создание внутри лямбда ссылки и адресация её на внешний локальный x // [this]{}; //захват указателя {this} //для классов // [*this]{}; //захват казателя {this} по значению //для классов [x](int x) mutable throw() ->int { cout << "OK"; } (100); //пример полной формы } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
//Листинг #18.2 Захваты #include <iostream> using std::cout; class MyClass{ int x,y,z; public: MyClass():x(100),y(200),z(300){}; //инициализация атрибутов класса значениями void m1(); void m2(); void m3(); }; void MyClass::m1(){ [this]{ //захват указателя this x = 150; //выполняется как если бы мы захватывали скопом атрибуты по ссылке y = 250; x = 150; }(); //выполняем лямбда-функцию cout << "x == " << x << '\n'; //настоящие атрибуты поменяли свои значения cout << "y == " << y << '\n'; cout << "z == " << z << '\n'; } void MyClass::m2(){ [*this]{ //захват указателя this по значению x = 150; //атрибуты получили абилку {только для чтения}, y = 250; //как если бы мы их захватывали по значению, x = 150; //поэтому не компилируется }(); cout << "x == " << x << '\n'; cout << "y == " << y << '\n'; cout << "z == " << z << '\n'; } int main() { MyClass mc; mc.m1(); } |
Есть ещё один такой скользоватый момент. Например, если мы используем захват по умолчанию, но не используем внутри лямбды некоторые переменные, потенциально готовые к использованию, то такие неиспользованные переменные считаются как незахваченные:
|
1 2 3 4 5 6 |
int main(){ int x(100), y(200), z(300); //локальные переменные [=]{}; //ничего не захвачено [=]{ x++; z++;}; //захвачены x и z } |
Объясняется это тем фактом, что при захвате создаются локальные переменные, каждое создание, в нашем случае с захватом по значению, сопровождается копированием. Нецелесообразно создавать большое число копий, если в конечном счёте они всё равно использованы не будут. Представляете, сколько можно потерять во времени, если впустую будут копироваться большие объекты? Если захватывать по ссылке, то, конечно, потери в производительности не такие огромные, но зачем опять же создавать ссылки на те объекты, которые в конечном итоге использованы внутри лямбда не будут? Другое дело, когда идёт прямой захват какого-то объекта, если программист обозначет его своим именем, то даже если внутри лямбда он использоваться не будет, такой объект считается захваченным лямбдой:
|
1 2 3 4 5 6 |
int main(){ int x(100), y(200), z(300); //локальные переменные [x]{}; //захвачены x, хоть и не использован } |
Такая вот существует тонкость захвата.
Разумеется, есть ещё и другие моменты, касаемые лямбда-функций, но я, пожалуй, остановлюсь на этом. Я бы их описал, но я не могу учесть всех аспектов. Если вы освоили что-нибудь нужное, то это здорово.
5 комментариев на «“С++. Лямбда-функции. Знакомство с синтаксисом”»
Добавить комментарий
Случайная книга в электронном формате
Спасибо автору! Написанное очень помогло!
Увидеть бы пример создания массива указателей на Лямбда функции. Статья классная.
Само собой, массив указателей на функции предполагает, как и любой массив, что в хранении будут использоваться однотипные данные или ссылки на однотипные данные, т. е. сейчас лямбда-функции в массиве все должны быть с одинаковой сигнатурой. А так это обычный масив указателей на функции.
Для лямбд с захватом надо использовать std::function, использовать обычные указатели на лямбды с захватом не получится.
проверил работает? В квадратных скобочках можно передавать параметры для захвата контекста как угодно а в аргументах лямбды как и сказал админ всё должно совпадать. А здесь не приходят уведомления на эл. почту если вам отвечают?
Мне? Приходят. Незарегистрированным, наверное, нет, не знаю. Регистрацию я вроде убрал. Есть некоторые технические сложности и моё незнание, мешающие исправить это. Впрочем, вернул регистрацию. Но вход может плохо работать: в смысле, что при правильных входных авторизации пишет будто неверный логин или пароль (в теме сайта устаревший код, из-за чего такая фигня).
Сообщение написано непонятно: Вы что, себя спрашиваете и себе отвечаете?