👀 Почему std::async может заблокировать ваш поток?

Многие думают, что std::async всегда создаёт новый поток. На самом деле это не так.

По умолчанию std::async использует политику запуска std::launch::async | std::launch::deferred. Это означает, что реализация сама решает, выполнить задачу асинхронно или отложить до вызова get().

auto future = std::async(heavy_task);
// Может НЕ запуститься прямо сейчас!
auto result = future.get(); // Тут может начать выполняться

🍴 Под капотом: При std::launch::deferred задача сохраняется как callable объект и выполняется синхронно при первом обращении к future. Никакого нового потока.

✏️ Что происходит в памяти: Создаётся shared state, хранящий либо результат, либо исключение. Deferred-задача живёт в виде объекта функции до момента вызова.

🧋Вывод: Если вам нужна гарантия параллельности, явно указывайте std::launch::async. Иначе рискуете получить синхронное выполнение там, где ожидали асинхронное.

auto future = std::async(std::launch::async, heavy_task);

📍Навигация: Вакансии • Задачи • Собесы

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

#под_капотом

🔥 Почему throw не просто делает goto к catch-блоку?

Возможно ты думал, что исключение — это прыжок в код обработчика. На самом деле между throw и catch происходит сложный процесс деструкции объектов.

Stack Unwinding — это механизм раскрутки стека, который компилятор генерирует автоматически. Когда летит исключение, среда выполнения проходит назад по стеку вызовов и вызывает деструкторы всех локальных объектов в обратном порядке их создания.

Компилятор создаёт специальные таблицы (exception tables в формате DWARF или SEH), которые содержат информацию о том, где какие объекты живут и какие деструкторы нужно вызвать. При броске исключения runtime читает эти таблицы и пошагово очищает стек.

void func() {
    Resource r1;  // деструктор будет вызван
    Resource r2;  // и этот тоже
    throw Error();
}

❌ Если во время раскрутки деструктор сам бросит исключение, вызывается std::terminate(). Поэтому правило: деструкторы должны быть noexcept.

❗️Stack unwinding гарантирует безопасность ресурсов, но имеет накладные расходы: даже если исключение не бросается, таблицы занимают место в бинарнике. В embedded-системах часто отключают исключения именно поэтому.

📍Навигация: Вакансии • Задачи • Собесы

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

#под_капотом

⚡️ От SFINAE к Concepts: эволюция метапрограммирования

Compile-time магия прошла долгий путь от криптографического SFINAE к читаемым concepts.

Эра 1: Классический SFINAE (C++98)

template<typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
increment(T value) {
    return value + 1;
}
// Что происходит? Кто знает...

Эра 2: Type traits (C++11/14)

template<typename T>
std::enable_if_t<std::is_integral_v<T>, T>
increment(T value) {
    return value + 1;
}
// Чуть лучше с _t и _v суффиксами

Эра 3: if constexpr (C++17)

template<typename T>
T process(T value) {
    if constexpr (std::is_integral_v<T>) {
        return value + 1;
    } else if constexpr (std::is_floating_point_v<T>) {
        return value * 1.1;
    } else {
        return value;
    }
}
// Читается как обычный код!

Эра 4: Concepts (C++20)

template<std::integral T>
T increment(T value) {
    return value + 1;
}

// Или
auto increment(std::integral auto value) {
    return value + 1;
}
// Красота и понятность!

😏 А какой подход вам больше нравится? Напиши в комментариях!

📍Навигация: Вакансии • Задачи • Собесы

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

#константная_правильность

🐥 Почему std::chrono::duration не хранит единицы измерения?

duration<int, std::milli> не хранит информацию о миллисекундах. На самом деле это compile-time магия.

✅ Как это работает:

duration — это просто обёртка над числом. Шаблонный параметр std::milli (он же std::ratio<1, 1000>) существует только на этапе компиляции.

duration<int64_t, std::milli> ms(1000);
// В памяти: просто int64_t со значением 1000
// Информации "это миллисекунды" в рантайме НЕТ

🍴 Механизм конверсии:

Когда вы пишете duration_cast<seconds>(ms), компилятор вычисляет 1000 / 1000 = 1 на этапе компиляции через механизм std::ratio. Никаких делений в рантайме при конверсии целых периодов.
Вывод: Zero-overhead абстракция. В release-сборке duration<int, milli> — это буквально int с type safety. Но осторожно: duration_cast может обрезать дробную часть при конверсии вниз.


📍Навигация: Вакансии • Задачи • Собесы

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

#под_капотом

✨ Литералы времени: пишите код, который читается

C++14 добавил user-defined literals для chrono. Это превращает магические числа в self-documenting код.

До:

std::this_thread::sleep_for(std::chrono::milliseconds(500));
std::chrono::seconds timeout(30);

После:

using namespace std::chrono_literals;

std::this_thread::sleep_for(500ms);
auto timeout = 30s;
auto delay = 1.5min;  // 90000ms внутри

Полный список:

auto ns = 100ns;   // nanoseconds
auto us = 100us;   // microseconds  
auto ms = 100ms;   // milliseconds
auto s = 100s;     // seconds
auto min = 100min; // minutes
auto h = 100h;     // hours

❗️Важно: Дробные литералы (1.5s) возвращают duration<double>, а не duration<int64_t>. Учитывайте при строгой типизации.

✅Добавьте using namespace std::chrono_literals; в каждый файл с chrono — читаемость кода скажет спасибо!

📍Навигация: Вакансии • Задачи • Собесы

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

#под_капотом