DBG-макрос на std::source_location: удобно дебажим выражения с контекстом

Иногда хочется быстро подсмотреть значение переменной, а не протаскивать логгер, не ставить точку останова и не писать std::cout << ... руками.

Давайте сделаем простой DBG(expr), который в debug-сборке печатает:
• само выражение;
• его значение;
• файл, строку и функцию, где это произошло.

В релизе же макрос превратится в пустышку и не повлияет на производительность.

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

#include <iostream>
#include <string_view>
#include <source_location>

Сделаем вспомогательную функцию debug_print, которая принимает значение, текст выражения и информацию о месте вызова:

template <typename T>
void debug_print(const T& value,
                 std::string_view expr,
                 const std::source_location& loc = std::source_location::current())
{
    std::cerr << "[DBG] " << expr << " = " << value << "\n"
              << "  at " << loc.file_name() << ":" << loc.line()
              << " in " << loc.function_name() << "\n";
}

Теперь объявим макрос DBG, который работает только в debug-сборке (пока не определён NDEBUG):

#ifndef NDEBUG
    #define DBG(expr) debug_print((expr), #expr)
#else
    #define DBG(expr) ((void)0)
#endif

Проверим на простом примере:

#include <vector>

int main() {
    int x = 42;
    std::vector<int> v{1, 2, 3};

    DBG(x);
    DBG(v.size());
    DBG(v[1] + x);

    return 0;
}

При запуске debug-сборки увидим что-то вроде:

[DBG] x = 42
  at example.cpp:8 in main
[DBG] v.size() = 3
  at example.cpp:9 in main
[DBG] v[1] + x = 44
  at example.cpp:10 in main

А в релизной сборке (-DNDEBUG) все вызовы DBG(...) тихо исчезнут на этапе компиляции.

🔥 В итоге у тебя есть удобный DBG-макрос на чистом стандарте C++20: в отладке он показывает выражения с контекстом (файл, строка, функция), а в релизе не оставляет ни следа в бинарнике.

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

Как отключить странные неявные преобразования?

Классический сценарий — «обёртка» над типом: валюта, температура, идентификатор.
Если сделать конструктор из базового типа неявным, компилятор начнёт автоматически конвертировать значения, и функция может внезапно принять «лишние» аргументы.

Без explicit код вроде этого компилируется без всякого шума:

struct Celsius {
    double value;
    Celsius(double v) : value{v} {}  // неявное преобразование из double
};

void print_temperature(Celsius t);

print_temperature(36.6); // неявно создаётся Celsius{36.6}

Проблема: мы теряем контроль над тем, откуда вообще берётся Celsius, особенно когда перегрузок несколько.

С explicit всё становится предсказуемо:

struct Celsius {
    double value;
    explicit Celsius(double v) : value{v} {}
};

print_temperature(Celsius{36.6}); //  только явное создание
// print_temperature(36.6);       //  больше не компилируется

🔥 Итог: помечай конструкторы и операторы преобразования как explicit,
если не хочешь, чтобы тип «магически» получался из других.

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

Нужны ChatGPT, Cursor, но дорого?

😎 Lama Agent — топовые модели (GPT-5, Claude, Gemini) внедряются прямо в IDE и пишут код за вас!
- 150 запросов в день(4500 в месяц)
- Всего за ₽699
- Доступен в ✴️ VS Code, 👩‍💻 JetBrains, ✴️ Claude Code, PyCharm

😲 Lama Bot — тг-бот с лучшими нейросетями!
- 150 запросов в день
- Всего за ₽499 в месяц (есть и бесплатные модели)
- Бери и пользуйся — быстро и без рекламы

😱 Lama AI — узнавай самым первым о последних новостях из мира AI, IT и гик индустрии. Цена — бесценно.

Свой 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 | #практика