🍴 Callback chain (цепочка обработчиков)

Надоело писать if-else лесенки для обработки событий? Лямбды превращают это в изящную цепочку.

Паттерн Chain of Responsibility через лямбды позволяет регистрировать обработчики, которые выполняются последовательно, пока кто-то не обработает событие:

#include <vector>
#include <functional>
#include <algorithm>

template<typename Event>
class CallbackChain {
    using Handler = std::function<bool(const Event&)>;
    std::vector<Handler> handlers_;

public:
    // Добавить обработчик в конец цепочки
    void add_handler(Handler handler) {
        handlers_.push_back(std::move(handler));
    }
    
    // Добавить обработчик в начало (высокий приоритет)
    void add_handler_front(Handler handler) {
        handlers_.insert(handlers_.begin(), std::move(handler));
    }
    
    // Обработать событие (возвращает true, если кто-то обработал)
    bool handle(const Event& event) const {
        for (const auto& handler : handlers_) {
            if (handler(event)) {
                return true;  // Обработчик вернул true - останавливаемся
            }
        }
        return false;  // Никто не обработал
    }
    
    // Уведомить всех обработчиков (не останавливаясь)
    void notify_all(const Event& event) const {
        for (const auto& handler : handlers_) {
            handler(event);  // Игнорируем возвращаемое значение
        }
    }
    
    // Очистить все обработчики
    void clear() { handlers_.clear(); }
    
    size_t size() const { return handlers_.size(); }
};

Использование для обработки HTTP-запросов:

struct HttpRequest {
    std::string path;
    std::string method;
    std::map<std::string, std::string> params;
};

CallbackChain<HttpRequest> router;

// Регистрируем обработчики
router.add_handler([](const HttpRequest& req) {
    if (req.path == "/api/users" && req.method == "GET") {
        handle_get_users();
        return true;  // Обработали
    }
    return false;  // Не наш запрос
});

router.add_handler([](const HttpRequest& req) {
    if (req.path.starts_with("/api/")) {
        return handle_api_request(req);
    }
    return false;
});

// В главном цикле
void process_request(const HttpRequest& req) {
    if (!router.handle(req)) {
        send_404_error();
    }
}

Библиотека C/C++ разработчика

#шаблонный_код

🍿 Лямбды в STL: где они сияют

STL-алгоритмы — основное применение лямбд в C++. Они превратили императивные циклы в декларативные выражения, делающие код выразительнее и безопаснее.

Классика — std::transform:

std::transform(vec.begin(), vec.end(), vec.begin(), [](int x) { return x * 2; });

умножает все элементы на два. Или std::sort с кастомным компаратором:

std::sort(vec.begin(), vec.end(), [](const auto& a, const auto& b) { return a.priority > b.priority; });

Предикатные алгоритмы особенно элегантны:

std::count_if, std::find_if, std::remove_if

Вместо циклов с условиями — одна строка:

auto count = std::count_if(vec.begin(), vec.end(), [](int x) { return x > 0; });

Логика фильтрации инкапсулирована и переиспользуема.


C++20 ranges делают это ещё лучше:

auto result = vec | std::views::filter([](int x) { return x % 2 == 0; }) | std::views::transform([](int x) { return x * x; });

— цепочка трансформаций без промежуточных контейнеров.

Лямбды с алгоритмами — это функциональное программирование в C++. Код становится декларативным, меньше ручного управления итераторами, меньше ошибок off-by-one. Оптимизатор видит больше возможностей для векторизации.

Как часто вы заменяете циклы на STL-алгоритмы с лямбдами?

Библиотека C/C++ разработчика

#междусобойчик