Какие риски есть при использовании лямбда-выражений в C++?

Давай разберем эту тему про лямбды, а то тут, бля, подводных камней — овердохуища. Сидишь такой, пишешь код, и вроде всё работает, а потом — бац! — и программа твоя накрылась медным тазом, а ты сидишь и думаешь: «Какого хуя?».

Вот смотри, самый пиздатый подводный камень — это когда ты ловишь переменные по ссылке, а они уже сдохли. Представь себе, ёпта.

auto make_dangerous_lambda() {
    int local_var = 42;
    // Захват по ссылке. Лямбда переживет 'local_var' -> неопределенное поведение.
    return [&]() { std::cout << local_var; };
}
// Вызов возвращенной лямбды приведет к чтению мусора.

Вот это, бля, классика! Ты создал лямбду внутри функции, она схватила local_var за горло (по ссылке), а потом функция закончилась, переменная умерла, а твоя лямбда, как дурак, продолжает пытаться её прочитать. И ты получаешь не пойми что — мусор, креш, или просто волшебные цифры на экране. Доверия к такому коду — ноль ебать.

Дальше идёт, бля, хитрая жопа с неявным захватом. Смотри.

int global_counter = 0;
int value = 10;

// [=] захватывает ВСЕ нестатические локальные переменные по значению,
// но также неявно захватывает `global_counter` по ссылке!
auto lambda = [=]() { return value + global_counter; };
// Изменение global_counter извне влияет на результат лямбды.

Вот тут, сука, и кроется подстава. Ты думаешь: «А, [=] — значит, всё по значению, безопасно». Ан нет, чувак! Глобальные переменные и статические члены класса эта штука хватает по ссылке! Получается, твоя «безопасная» лямбда на самом деле зависит от какой-то внешней хуйни, которая может поменяться когда угодно. Подозрение ебать чувствую к такому коду.

Ну и, конечно, производительность. Если ты будешь с помощью [=] таскать за собой большие объекты, копируя их в каждую лямбду, то твоя программа начнёт жрать память и процессорное время, как не в себя. Это пиздец как неэффективно. А если везде [&] налепить, компилятору будет тяжело оптимизировать, потому что он не знает, не поменялась ли там какая переменная извне. В общем, волнение ебать за перфоманс.

А ещё есть, бля, рекурсия. Хочешь лямбду, которая вызывает сама себя? Приготовься к танцам с бубном.

// Для рекурсии нужно использовать std::function или фиксировать тип через auto в аргументе.
std::function<int(int)> factorial = [&factorial](int n) -> int {
    return n <= 1 ? 1 : n * factorial(n - 1);
};
// Или с использованием Y-комбинатора (более эффективно, но сложнее).

Тут без std::function или какого-нибудь хитровыебанного Y-комбинатора не обойтись. Прям мудя какая-то, а не программирование.

Так что же делать, спросишь ты? А вот, слушай сюда, правила простые, как три копейки:

1. Не ленись, пиши явно. Вместо тупого [=] или [&] пиши [var1, &var2]. Ты сразу видишь, что и как захвачено. Никаких сюрпризов.
2. В методах класса не еби мозг. Хочешь работать с полями класса — захватывай [this] или, если ты на современном стандарте, [=, this]. Это чтобы случайно не поймать что-то лишнее по ссылке и не получить висячую ссылку.
3. Для асинхронщины — только по значению. Если твоя лямбда улетает в какой-нибудь std::async или в поток, и будет жить дольше текущего scope, то захват только по значению ([=]) или через умные указатели вроде std::shared_ptr. Иначе будет тебе, чувак, хиросима и нигерсраки в одном флаконе.

Запомни это, и твой код будет меньше похож на пиздатый сюрприз, а больше на что-то работающее и предсказуемое. Всё гениальное — просто, но только если не накосячить с захватом в лямбдах, ёпта.