Свой defer в стиле Go: выполняем код при выходе из scope!

Иногда нужно гарантированно “убраться” при выходе из функции: закрыть файл, освободить ресурс, что-то залогировать.

В Go для этого есть defer, а в C++ мы можем сделать похожее поведение через RAII и лямбды — на чистом стандарте.

Подключаем заголовки:

#include <cstdio>
#include <utility>

Сделаем небольшой helper Defer, который запоминает лямбду и вызывает её в деструкторе (то есть при выходе из области видимости):

template <typename F>
class Defer {
public:
    explicit Defer(F&& f)
        : func_(std::forward<F>(f)) {}
    Defer(const Defer&) = delete;
    Defer& operator=(const Defer&) = delete;
    ~Defer() {
        func_();
    }
private:
    F func_;
};
template <typename F>
Defer<F> make_defer(F&& f) {
    return Defer<F>{std::forward<F>(f)};
}

Теперь используем make_defer как “defer” — описываем, что должно выполниться при выходе из функции, и больше об этом не думаем:

int main() {
    std::FILE* f = std::fopen("data.txt", "w");
    if (!f) {
        std::perror("fopen");
        return 1;
    }
    auto close_file = make_defer([&] {
        std::puts("closing file...");
        std::fclose(f);
    });
    std::puts("writing...");
    std::fputs("hello\n", f);
    if (std::ferror(f)) {
        std::puts("write error");
        return 1; // defer всё равно сработает
    }
    std::puts("ok");
    return 0; // здесь тоже автоматически закроем файл
}

При запуске увидим примерно такое:

writing...
ok
closing file...

🔥 Если же мы выйдем раньше (через return при ошибке), лямбда из make_defer всё равно вызовется — файл будет закрыт, даже если в функции несколько разных точек выхода.

📣 C++ Ready | #практика

Как аккуратно разобрать результат функции на несколько значений?

Функции нередко возвращают несколько значений сразу: диапазон, координаты, параметры.
Классический вариант — std::tuple или std::pair, которые потом читают через std::get<0>, std::get<1> и прочую «магическую нумерацию индексов»:

auto result = minmax(data);
std::cout << std::get<0>(result) << " " << std::get<1>(result); // что из этого min, а что max?

При чтении кода приходится постоянно держать в голове, что такое 0 и 1, легко перепутать порядок.

С C++17 можно аккуратно «распаковать» результат в говорящие имена через structured bindings:

const auto [min, max] = minmax(data);

Теперь из строки сразу понятно, что вернула функция, а порядок значений фиксируется явно в одном месте.

🔥 Итог: возвращай std::tuple / std::pair, а на приёме сразу раскладывай их в осмысленные имена через structured bindings — так код становится короче и читается без расшифровки индексов.

📣 C++ Ready | #совет

💅 ProProProgs — ресурс для программистов на русском!

На этом сайте собраны учебники и статьи по Python, JavaScript, Java, C/C++ и даже по искусственному интеллекту. Если хочешь учиться результативно, разобраться с языком или модулем — можно открыть нужную тему и идти шаг за шагом.

📌 Оставляю ссылочку: proproprogs.ru

📣 C++ Ready | #ресурс

Ограничиваем значения аккуратно — std::clamp!

Во многих местах нужно держать значение в пределах: проценты 0–100, яркость 0–255, уровень громкости и т.п. Часто это пишут руками через if, но в C++17+ есть готовая функция std::clamp.

Сначала классический “ручной” вариант, который встречается в каждом втором проекте:

int normalize_volume(int value) {
    if (value < 0) value = 0;
    if (value > 100) value = 100;
    return value;
}

Теперь тот же самый смысл через std::clamp — читается как «ограничить value диапазоном [0, 100]»:

int normalize_volume(int value) {
    return std::clamp(value, 0, 100);
}

std::clamp работает и с другими типами — например, можно ограничить координату по ширине окна:

int clamp_x(int x, int window_width) {
    return std::clamp(x, 0, window_width - 1);
}

Код становится короче и выразительнее: сразу видно, что это именно ограничение диапазона, а не какая-то сложная логика.

🔥 Используй std::clamp везде, где значения не должны “вываливаться” из диапазона — меньше кода, меньше шансов ошибиться в условиях.

📣 C++ Ready | #практика