Menu
CoddyTech

Лямбда-выражения в деталях

Часть раздела Объектно-ориентированное программирование путешествия по C++ на Coddy. Урок 85 из 104.

Лямбда-выражения, появившиеся в C++11, — это анонимные функции, которые можно определить прямо в коде. Хотя ты уже видел простые лямбда-выражения со стандартными алгоритмами STL, понимание их полного синтаксиса открывает широкие возможности для захвата переменных и управления доступом к ним.

Полный синтаксис лямбда-выражения: [capture](parameters) mutable -> return_type { body }. Список захвата определяет, к каким внешним переменным лямбда-выражение может обращаться и каким образом:

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    
    auto byValue = [x]() { return x * 2; };        // Копия x
    auto byRef = [&y]() { y += 5; };               // Ссылка на y
    auto allByValue = [=]() { return x + y; };     // Копировать всё
    auto allByRef = [&]() { x++; y++; };           // Ссылки на всё
    auto mixed = [x, &y]() { y += x; };            // Сочетание обоих способов
    
    byRef();
    std::cout << y << "\n";  // 25
}

По умолчанию переменные, захваченные по значению, внутри лямбды являются const. Ключевое слово mutable позволяет изменять эти копии:

int counter = 0;
auto increment = [counter]() mutable {
    return ++counter;  // Изменяет копию, захваченную лямбдой
};

std::cout << increment() << "\n";  // 1
std::cout << increment() << "\n";  // 2
std::cout << counter << "\n";      // 0 - исходное значение не изменилось

В C++14 появились инициализирующие захваты, позволяющие создавать новые переменные или перемещать объекты в лямбда-выражение:

auto ptr = std::make_unique<int>(42);
auto lambda = [p = std::move(ptr)]() {
    return *p;
};  // Владение передано в lambda

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

challenge icon

Задание

Легко

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

Ты распределишь код по трём файлам:

  • EventDispatcher.h: Определи класс EventDispatcher, который управляет функциями обратного вызова событий.

    Диспетчер должен хранить функции обратного вызова с помощью std::vector из std::function<void()>. Добавь следующие методы:

    • addCallback(std::function<void()> callback): добавляет функцию обратного вызова в список
    • fireAll(): вызывает все сохранённые функции обратного вызова по порядку
    • clear(): удаляет все функции обратного вызова

    Тебе понадобится подключить <functional> и <vector>.

  • EventDispatcher.cpp: Реализуй методы диспетчера. Метод fireAll() должен просто пройтись по всем функциям обратного вызова и вызвать каждую из них.
  • main.cpp: Считай два входных значения:
    1. Базовое число (целое число)
    2. Множитель (целое число)

    Создай EventDispatcher и продемонстрируй различные способы захвата в лямбдах, добавив три функции обратного вызова:

    1. Лямбда, которая захватывает базовое число по значению и выводит: Base value: [base]
    2. Лямбда, которая захватывает множитель по ссылке, увеличивает его на 1, а затем выводит: Multiplier after increment: [multiplier]
    3. Изменяемая лямбда, которая захватывает переменную-счётчик (инициализированную значением 0) по значению, увеличивает её при каждом вызове и выводит: Call count: [counter]

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

    Наконец, после обоих раундов выведи итоговое значение переменной множителя из main, чтобы показать, как на неё повлиял захват по ссылке: Final multiplier: [multiplier]

Например, при входных значениях 10 и 5:

Base value: 10
Multiplier after increment: 6
Call count: 1
---
Base value: 10
Multiplier after increment: 7
Call count: 1
Final multiplier: 7

При входных значениях 42 и 0:

Base value: 42
Multiplier after increment: 1
Call count: 1
---
Base value: 42
Multiplier after increment: 2
Call count: 1
Final multiplier: 2

Обрати внимание на ключевые особенности: захват по значению сохраняет исходное значение базового числа, захват по ссылке изменяет фактическую переменную множителя в main (значение накапливается при каждом вызове), а счётчик изменяемой лямбды показывает 1 в каждом раунде. Это происходит потому, что fireAll() перебирает функции обратного вызова по значению: в каждом раунде вызывается свежая копия сохранённого std::function, захваченный счётчик которой начинается с 0 и увеличивается до 1, поэтому собственное состояние сохранённой функции обратного вызова не изменяется.

Попробуйте сами

#include <iostream>
#include "EventDispatcher.h"

using namespace std;

int main() {
    int base;
    int multiplier;
    cin >> base;
    cin >> multiplier;
    
    EventDispatcher dispatcher;
    
    // TODO: Добавьте лямбда-функцию, которая захватывает base ПО ЗНАЧЕНИЮ
    // Она должна вывести: "Base value: [base]"
    
    // TODO: Добавьте лямбда-функцию, которая захватывает multiplier ПО ССЫЛКЕ
    // Она должна увеличить multiplier на 1, затем вывести: "Multiplier after increment: [multiplier]"
    
    // TODO: Добавьте ИЗМЕНЯЕМУЮ лямбда-функцию, которая захватывает счётчик (инициализированный значением 0) по значению
    // Она должна увеличить счётчик и вывести: "Call count: [counter]"
    
    // TODO: Вызовите fireAll(), чтобы вызвать все обратные вызовы
    
    // TODO: Выведите "---" в качестве разделителя
    
    // TODO: Снова вызовите fireAll()
    
    // TODO: Выведите итоговое значение multiplier: "Final multiplier: [multiplier]"
    
    return 0;
}
quiz iconПроверьте себя

В этом уроке есть небольшой тест. Начните урок, чтобы ответить на вопросы и сохранить прогресс.

Все уроки раздела Объектно-ориентированное программирование

Потренируйтесь самостоятельно: Онлайн-компилятор C++