Какие есть риски при использовании лямбд?

Риски при использовании лямбд в C++

Лямбда-функции в C++ (введены в C++11) — это мощный инструмент, но они связаны с рядом подвохов и опасностей, которые могут привести к ошибкам, утечкам памяти и undefined behavior.

Риск 1: Захват переменных по ссылке

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

// ❌ ОПАСНО: захват по ссылке
auto lambda_bad = []() {
    int* dangerous = nullptr;
    {
        int x = 42;
        auto lambda = [&x]() { return x; };  // Захват x по ссылке
        dangerous = &x;  // Сохраняем указатель
    }  // x выходит из области видимости!
    
    return lambda_bad();  // Undefined behavior! x больше не существует
};

// ✅ ПРАВИЛЬНО: захват по значению
auto lambda_good = [](int x) {
    auto lambda = [x]() { return x; };  // Захват по значению
    return lambda;  // Безопасно!
};

Риск 2: Захват this в методах класса

Захват this по ссылке (по умолчанию в C++11) может привести к висячему указателю:

class Handler {
public:
    std::function<void()> getCallback() {
        // ❌ ОПАСНО: захватывает this
        return [this]() {
            std::cout << member_;
        };
    }
    
private:
    int member_ = 42;
};

// Использование
auto callback = []() {
    Handler h;
    auto cb = h.getCallback();
    return cb;  // h уничтожен, this — висячий указатель!
}();
callback();  // Undefined behavior!

// ✅ ПРАВИЛЬНО: используй shared_ptr
class Handler : public std::enable_shared_from_this<Handler> {
public:
    std::function<void()> getCallback() {
        auto self = shared_from_this();
        return [self]() {
            std::cout << self->member_;
        };
    }
    
private:
    int member_ = 42;
};

Риск 3: Захват в циклах

Захват переменной цикла по ссылке — частая ошибка:

// ❌ ОПАСНО: все лямбды захватят одну и ту же переменную i
std::vector<std::function<void()>> funcs;

for (int i = 0; i < 5; ++i) {
    funcs.push_back([&i]() {
        std::cout << i << " ";  // i всегда = 5 (конец цикла)
    });
}

for (auto& f : funcs) f();
// Вывод: 5 5 5 5 5 (вместо 0 1 2 3 4)

// ✅ ПРАВИЛЬНО вариант 1: захват по значению
for (int i = 0; i < 5; ++i) {
    funcs.push_back([i]() {  // Захват по значению
        std::cout << i << " ";
    });
}
// Вывод: 0 1 2 3 4

// ✅ ПРАВИЛЬНО вариант 2: init capture (C++14)
for (int i = 0; i < 5; ++i) {
    funcs.push_back([value = i]() {  // Явный захват по значению
        std::cout << value << " ";
    });
}

Риск 4: Недостаточно информации о типе

Тип лямбды не определён в compile-time, что усложняет отладку:

Auto l1 = [](int x) { return x * 2; };
auto l2 = [](int x) { return x * 2; };

// l1 и l2 имеют РАЗНЫЕ типы, хотя поведение идентично!
// std::is_same_v<decltype(l1), decltype(l2)> == false

// Поэтому нужно использовать std::function для хранения
std::function<int(int)> f1 = [](int x) { return x * 2; };
std::function<int(int)> f2 = [](int x) { return x * 2; };
// Теперь можно хранить вместе

Риск 5: Производительность std::function

Использование std::function оборачивает лямбду, добавляя overhead:

// ❌ Медленнее из-за виртуального вызова
std::function<int(int)> multiply = [](int x) { return x * 2; };
int result = multiply(5);  // Indirect call через vtable

// ✅ Быстрее — прямой вызов
auto multiply_fast = [](int x) { return x * 2; };
int result = multiply_fast(5);  // Inlined!

Риск 6: Захват больших объектов

По умолчанию при захвате по значению копируются ВСЕ переменные:

std::vector<int> large_vector(1000000);

// ❌ Копирует весь вектор!
auto lambda = [large_vector]() {
    std::cout << large_vector.size();
};

// ✅ Захватываем по ссылке (если гарантируем время жизни)
auto lambda = [&large_vector]() {
    std::cout << large_vector.size();
};

// ✅ Захватываем только нужное (C++17+)
auto lambda = [size = large_vector.size()]() {
    std::cout << size;
};

Риск 7: Mutable лямбды и побочные эффекты

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

int counter = 0;

auto increment = [counter]() mutable {
    ++counter;  // Меняет локальную копию counter
    std::cout << counter;
};

increment();  // Выводит 1
increment();  // Выводит 2
std::cout << counter;  // Выводит 0! counter не изменился

Риск 8: Exception safety

Исключения в лямбдах могут привести к утечкам, если неправильно управлять ресурсами:

// ❌ Может утечь ресурс
auto lambda = [ptr = new int(42)]() {
    if (*ptr > 40) throw std::runtime_error("Too big");
    std::cout << *ptr;
    delete ptr;  // Не вызовется!
};

// ✅ Exception-safe
auto lambda = [ptr = std::make_unique<int>(42)]() {
    if (*ptr > 40) throw std::runtime_error("Too big");
    std::cout << *ptr;
    // Автоматическое удаление через unique_ptr
};

Риск 9: Зависимость от порядка инициализации

class MyClass {
    std::function<void()> callback;
    int value = 42;
    
public:
    MyClass() {
        // ❌ Опасно: value может быть ещё не инициализирован
        callback = [this]() { std::cout << value; };
    }
};

Лучшие практики

• Захватывай по значению по умолчанию: [x, y]
• Использование this осторожнее: либо shared_ptr, либо явное копирование
• Будь внимателен с циклами: захватывай по значению или используй init capture
• Для массивов используй std::span (C++20) вместо захвата всего объекта
• Предпочитай auto обычным лямбдам вместо std::function, если возможно
• Тестируй время жизни захватываемых объектов
• Документируй поведение захватов для сложных случаев

Лямбды — это мощный инструмент, но требуют понимания семантики захватов!