Быстро тестируем код через assert.

Сейчас научимся добавлять простые проверки прямо в код, чтобы убедиться, что функции работают правильно. Это особенно удобно на этапе отладки и для мини-тестов без фреймворков.

Подключим нужную библиотеку:

#include <cassert>
#include <iostream>

Предположим, у нас есть функция, которая должна возвращать квадрат числа. Реализуем её так:

int square(int x) {
    return x * x;
}

Теперь напишем несколько простых тестов с помощью assert, чтобы проверить, что функция работает правильно на базовых примерах:

int main() {
    assert(square(2) == 4);
    assert(square(-3) == 9);
    assert(square(0) == 0);
    std::cout << "Все тесты пройдены!\n";
    return 0;
}

Если проверка не пройдёт — программа остановится и покажет, где ошибка.

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

Assertion failed: square(2) == 5, file main.cpp, line 10

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

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

☕️ Сильная статья — понятный вход в ray tracing через базовую геометрию, лучи и построение изображения.

В этой статье:
• Как формируется изображение через плоскость проекции, камеру и направление лучей
• Почему пиксели можно представить как результат пересечения лучей со сценой
• Базовая логика, с которой начинается построение собственного трассировщика лучей

🔊 Продолжай читать на habr!

📣 C++ Ready | #статья

Почему std::async иногда не делает код асинхронным?

На первый взгляд кажется, что задача просто запускается в фоне, а выполнение сразу идет дальше. Но у std::async есть важная деталь: он возвращает std::future.

Если этот future не сохранить, он будет уничтожен в конце выражения. А для задачи, запущенной с std::launch::async, это может означать ожидание завершения прямо в деструкторе.

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

Из-за этого баг особенно неприятный: внешне все выглядит асинхронно, а по факту приложение тормозит в месте, где ты вообще не ждешь блокировки.

Если результат нужен позже, future надо сохранить и явно решить, когда именно его ждать.

auto fut = std::async(std::launch::async, [] {
    reindex();
});

std::cout << "after async\n";

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

🔥 Не потеряй future от std::async. Иначе “запустил в фоне” легко превращается в “случайно дождался здесь же”.

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

📂 Напоминалка для работы с Big O Notation!

Например, O(1) — выполняется за постоянное время, а O(n) растёт линейно от размера входных данных.

На картинке — основные виды сложности, которые чаще всего встречаются в алгоритмах и структурах данных.

Сохрани, чтобы не забыть!

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

constexpr-парсинг enum в C++: без простыни из if-else

Строки из конфига, CLI и env-переменных почти всегда нужно переводить в enum. И очень быстро код зарастает однотипными ветками if (s == "...").

Намного удобнее держать все соответствия в одной таблице. Тогда из неё можно сделать и парсинг строки в enum, и обратное преобразование enum в строку.

Сначала объявим сам enum:

enum class log_level {
    trace,
    debug,
    info,
    error
};

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

using namespace std::literals;

constexpr std::array mappings{
    std::pair{"trace"sv, log_level::trace},
    std::pair{"debug"sv, log_level::debug},
    std::pair{"info"sv,  log_level::info},
    std::pair{"error"sv, log_level::error},
};

После этого можно написать constexpr-парсер. Он просто проходит по таблице и ищет совпадение.

constexpr std::optional<log_level>
parse_log_level(std::string_view s) {
    for (auto [name, value] : mappings) {
        if (name == s)
            return value;
    }

Если строка неизвестна, вернём пустой результат. Это безопаснее, чем молча подставлять какое-то значение по умолчанию.

    return std::nullopt;
}

Из той же таблицы легко сделать обратное преобразование. Это удобно, когда нужно писать enum в логах, сообщениях об ошибках или конфиге.

constexpr std::string_view
to_string(log_level lvl) {
    for (auto [name, value] : mappings) {
        if (value == lvl)
            return name;
    }

Если значение не найдено, вернём запасной вариант.

    return "unknown";
}

Использование получается простым и читаемым:

auto lvl = parse_log_level("debug")
               .value_or(log_level::info);

std::cout << to_string(lvl) << '\n';

Один mapping в одном месте убирает дублирование, сокращает код и делает добавление новых enum-значений намного спокойнее.

🔥 Один mapping лучше десятка if-else веток.

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