C++ C++ · 30 вопросов · ~85 мин · ⏱ Таймер 25:00 · Сложный ·

Корутины C++

Профессиональный тест разбирает корутину как преобразованную компилятором машину состояний. Вопросы охватывают promise_type, awaiter-протокол, время жизни coroutine frame, отмену и композицию задач — без упрощения “co_await просто ждёт”.

Отвечено: 0 из 30

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. В тесте 30 вопросов, время — 85 минут. Во многих заданиях недостаточно узнать конструкцию: проследите порядок вычислений, время жизни объектов, владение ресурсами и условия, при которых решение остаётся корректным. После завершения откроются правильные ответы, объяснения, общий результат и тематические шкалы.

Вопрос 1 из 30

Как компилятор находит promise_type корутины?

struct Task {
    struct promise_type {
        Task get_return_object();
        std::suspend_never initial_suspend() noexcept;
        std::suspend_always final_suspend() noexcept;
        void return_void();
        void unhandled_exception();
    };
};
Task run(int id);

Через виртуальный метод await, который компилятор ищет у возвращаемого типа Только через глобальный псевдоним `promise_type`, не зависящий от параметров функции Во время выполнения через RTTI возвращаемого объекта Через `std::coroutine_traits<Return, Args...>::promise_type` По члену с зарезервированным именем promise внутри тела функции

Вопрос 2 из 30

Для чего вызывается `get_return_object()`?

struct Task {
    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        // ...
    };
    std::coroutine_handle<promise_type> handle;
};

Создать объект, сразу возвращаемый вызывающему коду Чтобы удалить frame Чтобы вернуть значение co_return напрямую без promise Чтобы выбрать поток выполнения Чтобы обработать только исключение

Вопрос 3 из 30

Что определяет `initial_suspend()`?

struct promise_type {
    std::suspend_always initial_suspend() noexcept { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    // ...
};

Task job = run(); // начнёт ли тело выполняться сразу?

Сразу ли начнётся тело корутины Тип каждого co_await Какой exception будет брошен Как освобождается frame Размер стека потока

Вопрос 4 из 30

Зачем `unhandled_exception()` в promise?

struct promise_type {
    std::exception_ptr error;

    void unhandled_exception() noexcept {
        error = std::current_exception();
    }
};

Перехватывает исключение только из потока, который впоследствии вызовет resume Чтобы запретить throw внутри awaiter Чтобы вернуть false из co_await Сохранить исключение из тела, обычно как exception_ptr Чтобы заменить final_suspend

Вопрос 5 из 30

Что делает `return_value(v)` или `return_void()`?

struct promise_type {
    std::optional<int> result;

    void return_value(int value) noexcept {
        result = value;
    }
};

Task<int> answer() { co_return 42; }

Записывает значение напрямую в переменную, которой присваивается результат co_await этой корутины Вызывает await_suspend у последнего встреченного awaiter Передаёт значение или факт пустого возврата объекту promise в рамках протокола `co_return` Сразу разрушает promise и освобождает frame до выполнения final_suspend Безусловно преобразует возврат в исключение, которое сохранит unhandled_exception

Вопрос 6 из 30

В каком порядке вызываются основные методы awaiter?

struct Awaiter {
    bool await_ready() const noexcept;
    void await_suspend(std::coroutine_handle<> h);
    int await_resume();
};

int value = co_await Awaiter{};

await_resume, await_ready, await_suspend Порядок выбирается runtime await_ready вызывается после resume `await_ready` → `await_suspend` → `await_resume` Только await_suspend

Вопрос 7 из 30

Что означает `await_ready() == true`?

struct CachedValue {
    int value;
    bool await_ready() const noexcept { return true; }
    void await_suspend(std::coroutine_handle<>) noexcept;
    int await_resume() const noexcept { return value; }
};

int x = co_await CachedValue{42};

await_resume не вызывается Нужно уничтожить frame Будет создан новый поток Корутина обязана завершиться Результат готов, приостановка не нужна

Вопрос 8 из 30

Что получает `await_suspend(std::coroutine_handle<> h)`?

struct TimerAwaiter {
    std::chrono::milliseconds delay;
    bool await_ready() const noexcept { return false; }
    void await_suspend(std::coroutine_handle<> continuation);
    void await_resume() const noexcept {}
};

Указатель на promise корутины, которая будет ожидать текущую Дескриптор системного потока, на котором выполнялся последний участок кода Логический результат вызова `await_ready` без доступа к корутине Handle текущей корутины, которую предстоит приостановить Значение, ранее переданное выражением `co_return`

Вопрос 9 из 30

Что означает возврат bool из await_suspend?

struct Awaiter {
    bool await_ready() const noexcept { return false; }
    bool await_suspend(std::coroutine_handle<> h) {
        return schedule_or_continue(h);
    }
    Result await_resume();
};

false означает исключение Он задаёт await_resume false — продолжить, true — ждать bool игнорируется true уничтожает frame

Вопрос 10 из 30

Как `operator co_await` участвует в протоколе?

struct SocketRead {
    Socket& socket;
    auto operator co_await() & {
        return ReadAwaiter{socket};
    }
};

std::size_t n = co_await request.read_operation();

Преобразует исходный awaitable в awaiter с методами `await_ready`, `await_suspend` и `await_resume` Заменяет `coroutine_handle` целочисленным идентификатором операции Завершает корутину и передаёт значение в `return_value` объекта promise Создаёт `promise_type` и выбирает начальную точку приостановки Обязательно переносит продолжение корутины в отдельный системный поток

Вопрос 11 из 30

Где обычно хранятся локальные переменные, переживающие suspension point?

Task parse(Stream& stream) {
    Buffer buffer = co_await stream.read();
    auto header = parse_header(buffer);
    co_await validate(header);
    co_return;
}

Только в глобальной памяти В регистрах навсегда В promise вызывающей функции На обычном стеке уже вернувшегося вызова В coroutine frame

Вопрос 12 из 30

Кто обязан вызвать `handle.destroy()` для вручную управляемой корутины?

class Generator {
public:
    ~Generator() {
        if (handle_) handle_.destroy();
    }
    Generator(Generator&& other) noexcept
        : handle_(std::exchange(other.handle_, {})) {}
private:
    std::coroutine_handle<promise_type> handle_;
};

Владелец handle после завершения работы frame ОС при завершении каждого co_await Компилятор сразу после get_return_object Никто, frame всегда статический Первый awaiter, который увидит done(), может уничтожить frame независимо от владельца

Вопрос 13 из 30

Почему `final_suspend()` часто возвращает suspend_always?

struct promise_type {
    std::suspend_always final_suspend() noexcept { return {}; }
    void return_void() noexcept {}
    void unhandled_exception() { std::terminate(); }
};

// Владелец handle читает результат и затем вызывает destroy().

Чтобы initial_suspend не вызывался Чтобы корутина бесконечно выполнялась Чтобы пропустить деструкторы локальных объектов Чтобы владелец прочитал результат и вызвал destroy Чтобы исключение вышло наружу

Вопрос 14 из 30

Что опасно в корутине, принимающей `const std::string&` и приостанавливающейся?

Task log_later(const std::string& text) {
    co_await schedule_on(worker_pool);
    write_log(text); // ссылка может пережить аргумент вызова
}

log_later(std::string("temporary"));

Опасность только при пустой строке const запрещает suspension co_await продлевает жизнь любого аргумента Ссылка в frame может пережить строку вызывающего кода Параметры-ссылки всегда копируются в frame как string

Вопрос 15 из 30

Можно ли вызывать resume на already-done coroutine handle?

void resume_if_needed(std::coroutine_handle<> h) {
    if (h && !h.done()) {
        h.resume();
    }
}

Нет: вызов resume для уже завершившейся корутины не соответствует предусловиям Вызов возвращает false и оставляет frame без изменений Да: resume сбрасывает состояние и начинает корутину с initial_suspend заново Допустимо, если promise не хранит результат и имеет тривиальный деструктор Да: для done handle это определённый пустой вызов, эквивалентный destroy

Вопрос 16 из 30

Как task B обычно возвращает управление ожидающей корутине A?

struct FinalAwaiter {
    bool await_ready() const noexcept { return false; }
    std::coroutine_handle<> await_suspend(
        std::coroutine_handle<promise_type> h
    ) const noexcept {
        return h.promise().continuation;
    }
    void await_resume() const noexcept {}
};

B возобновляет сохранённый continuation A Копирует frame A внутрь B Возобновляет A в новом std::thread, потому что co_await всегда меняет поток Вызывает A как обычную функцию с начала Удаляет A и возвращает bool

Вопрос 17 из 30

Что такое symmetric transfer?

std::coroutine_handle<> await_suspend(
    std::coroutine_handle<> awaiting
) noexcept {
    continuation = awaiting;
    return child_handle; // передача выполнения другой корутине
}

Запуск двух потоков одновременно Прямая передача в handle другой корутины Передачу владения coroutine frame между двумя awaiter под общей блокировкой Обмен локальными переменными Копирование двух promise

Вопрос 18 из 30

Чем generator отличается от task?

Generator<int> numbers() {
    for (int i = 0; i < 3; ++i)
        co_yield i;
}

Task<int> answer() {
    co_return 42;
}

Generator не использует suspension points между выдаваемыми значениями Task не имеет promise и потому не поддерживает исключения Generator последовательно выдаёт несколько значений, а task представляет одно завершение или результат Generator обязан выполнять каждую итерацию в отдельном потоке Task может возвращать только void, тогда как generator — любой тип

Вопрос 19 из 30

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

Любое исключение из task немедленно вызывает terminate, даже если реализован `unhandled_exception` Promise сохраняет exception_ptr, а `await_resume` повторно выбрасывает исключение ожидающему коду Ошибка преобразуется в пустой указатель независимо от типа результата task Исключение теряется после `final_suspend`, если task был кем-то ожидаем Исключение перескакивает между стеками напрямую в момент throw без участия promise

Вопрос 20 из 30

Почему смешение eager и lazy tasks может давать неожиданный порядок побочных эффектов?

Порядок всегда одинаков Lazy task выполняется при компиляции Eager task не может приостанавливаться Initial_suspend не влияет на запуск Eager стартует при вызове, lazy — при resume/co_await

Вопрос 21 из 30

Как проверить отсутствие утечки coroutine frame?

Проверить достижение final_suspend, не проверяя последующий вызов destroy владельцем handle Счётчик promise и LeakSanitizer для всех путей Запустить один co_await без завершения Сравнить число resume и suspend, не отслеживая создание и уничтожение frame Проверить только результат co_return

Вопрос 22 из 30

Как воспроизвести гонку двойного resume?

Дважды последовательно вызвать resume после того, как done уже вернул true Добавить постоянную задержку к одному resume и считать отсутствие падения доказательством корректности Организовать два конкурирующих источника завершения, каждый из которых может возобновить один и тот же сохранённый handle Пометить handle volatile, не создавая двух конкурирующих путей Стереть тип handle перед хранением, не меняя протокол владения и возобновления

Вопрос 23 из 30

Что тестировать у отменяемой корутины?

Проверить успешное завершение и считать его достаточным для всех точек отмены Достаточно проверить stop_requested(): дальнейшее разрушение frame и ресурсов уже гарантировано Отмену в разных фазах и освобождение callback Только stop_requested после завершения Только размер stop_token

Вопрос 24 из 30

Как обнаружить ссылку на уничтоженный аргумент в frame?

Проверить только компиляцию Скопировать аргумент в локальную ссылку внутри корутины перед первой приостановкой Уничтожить аргумент до resume под AddressSanitizer Сделать аргумент static в тесте Вызвать destroy до resume и считать это проверкой

Вопрос 25 из 30

Почему breakpoint на строке с co_await иногда недостаточен?

Весь co_await исполняется только оптимизатором и отсутствует в отладочной сборке Любая корутина продолжает выполнение в другом процессе, которого не видит текущая сессия Оператор разворачивается в проверку готовности, приостановку, возобновление и получение результата Отладчик не умеет устанавливать точки останова в функциях, содержащих coroutine keywords Строка с co_await соответствует одной неделимой инструкции процессора

Вопрос 26 из 30

Всегда ли coroutine frame выделяется в куче?

Да: стандарт требует ровно один вызов malloc для каждой корутины Нет: frame обязан быть частью стека вызывающей функции до уничтожения return object Нет: реализация может устранить отдельную аллокацию frame, но полагаться на это как на гарантию нельзя Адрес размещения каждый раз выбирает пользователь обычным вызовом new в месте вызова корутины Динамическое размещение требуется только generator, но запрещено task

Вопрос 27 из 30

Что такое backpressure для coroutine pipeline?

Запускать производителя без ожидания, увеличивая очередь при отставании потребителя Уменьшать размер coroutine frame, не ограничивая число ожидающих элементов Ограничение темпа производителя Автоматическое увеличение стека Использовать relaxed-доступ к счётчику очереди вместо управления темпом производителя

Вопрос 28 из 30

Почему API должен документировать, на каком executor продолжится код после co_await?

От места возобновления зависят thread affinity, допустимые обращения к объектам и необходимая синхронизация Поток выполнения корутины принципиально не наблюдаем и потому не входит в контракт API После co_await язык запрещает захватывать mutex независимо от executor Стандарт гарантирует продолжение на том же системном потоке, где выполнен co_await Executor влияет лишь на отображаемое имя return type и не меняет контекст выполнения

Вопрос 29 из 30

Какой риск у task, который начинает работу, но его return object можно молча отбросить?

Риск только у void Временный return object неявно ожидает завершения корутины перед разрушением Работа и ошибки могут потеряться без detached-контракта Корутина всегда завершится до точки с запятой Отбрасывание уничтожает внешний мир

Вопрос 30 из 30

Когда callback может быть лучше пользовательской корутины?

Когда операция естественно возвращает значение через несколько последовательных ожиданий Когда операция состоит из длинной цепочки зависимых асинхронных шагов Для одного простого одноразового события Когда обработчик должен несколько раз приостанавливаться и сохранять локальное состояние Когда callback владеет общим состоянием через shared_ptr, независимо от сложности композиции

Ответьте на все 30 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу