Корутины

std::coroutine_handle — тонкая невладеющая обёртка над указателем на coroutine frame. С его помощью можно resume() корутину, проверить done(), вызвать destroy() и обратиться к promise(). Временем жизни фрейма он не управляет.

co_await expr приостанавливает корутину, пока expr не готово, и отдаёт его результат. co_yield v приостанавливает и передаёт v вызывающей стороне. co_return завершает корутину, опционально передавая результат через promise_type. Любое из трёх делает функцию корутиной.

promise_type — тип, который компилятор находит по возвращаемому типу и через который настраивается корутина. Он строит возвращаемый объект, решает приостановки в начале и конце, обрабатывает co_yield/co_return и ловит исключения. Без него хуки жизненного цикла не сгенерировать.

Приостановка означает, что корутина останавливается в определённой точке, сохраняет локальное состояние и позицию возобновления во фрейм и возвращает управление вызывающей стороне — без раскрутки стека и освобождения фрейма. Позже её можно возобновить с этой точки.

Поток — это вытесняемый контекст выполнения, планируемый ОС, со своим стеком, работающий параллельно на другом ядре. Корутина — приостанавливаемая функция с фреймом в куче, планируемая кооперативно; сама по себе она не даёт параллелизма.

Оно хранится в coroutine frame — сгенерированном компилятором объекте, обычно размещаемом в куче. Фрейм содержит promise_type, точку возобновления, параметры и локальные переменные, переживающие приостановку. Стековый фрейм вызывающей стороны исчезает после первой приостановки.

Генератор — корутина, которая лениво производит последовательность значений, по одному на возобновление, а не вычисляет их заранее. Он строится через co_yield, который приостанавливает и передаёт текущее значение вызывающей стороне. C++23 добавляет std::generator<T>.

Корутина не возвращает значение обычным способом — её результат должен проходить через promise_type посредством return_value/return_void. Обычный return обходит этот механизм, поэтому язык его запрещает; нужен co_return, который разворачивается в вызов promise.

Оба — тривиальные стандартные awaitable. У std::suspend_always метод await_ready() возвращает false, поэтому co_await всегда приостанавливает. У std::suspend_never он возвращает true, поэтому co_await не приостанавливает. Результата ни один не несёт.

Компилятор генерирует три вызова Awaitable: await_ready() решает, нужна ли приостановка; await_suspend(handle) выполняется при припаркованном фрейме; await_resume() даёт значение выражения при возобновлении.

Нет. co_await лишь приостанавливает корутину и возвращает управление вызывающему — поток он не порождает. Возобновление идёт в потоке, вызвавшем handle.resume(). Смена потока требует планирующего Awaitable.

Это ваш выбор, задаваемый через initial_suspend. suspend_never делает корутину жадной — при вызове она выполняется до первой приостановки. suspend_always делает её ленивой — она стартует при первом resume(). Генераторы обычно ленивы.

final_suspend() выполняется после тела и решает, останется ли фрейм живым. suspend_always сохраняет его, чтобы вызывающий прочитал результат или исключение; suspend_never уничтожил бы его сразу, оставив висячий handle.

Объявите тип с вложенным promise_type, чей yield_value сохраняет значение и возвращает suspend_always. Оберните coroutine_handle, дайте next()/value() и вызовите destroy() фрейма в деструкторе.

Он обязан дать get_return_object, initial_suspend, final_suspend (noexcept), unhandled_exception и ровно один из return_value либо return_void. Генератору нужен ещё yield_value. Отсутствие любого обязательного члена — некорректность.

co_yield v вызывает promise.yield_value(v) и приостанавливает корутину — её можно возобновить снова, порождая последовательность. co_return вызывает return_value/return_void и завершает корутину навсегда.

Callbacks просты, но вложены. Futures выглядят синхронно, но композиция неудобна. Корутины C++20 дают линейный co_await; senders/receivers C++26 добавляют schedulers.

Функция становится корутиной, если её тело использует co_await, co_yield или co_return. Компилятор превращает её в state machine с heap-аллоцированным frame. Тип возврата должен определять promise_type.

Корутины C++20 приостанавливают и возобновляют выполнение без блокирования потока. co_await/co_yield/co_return делают функцию корутиной; компилятор превращает её в state machine на куче. Тип возврата требует пользовательский promise.

Фрейм выделяется (обычно в куче) один раз при первом вызове корутины и освобождается при вызове destroy(). Компилятор может элиминировать heap-аллокацию (HALO), когда время жизни корутины ему полностью видимо.

Вызовите std::coroutine_handle<promise_type>::from_promise(*this) — он восстанавливает handle из адреса promise, так как promise лежит по известному смещению во фрейме. get_return_object() строит этим обёртку вызывающего.

coroutine_handle не владеет фреймом. Если потерять хэндл незавершённой корутины или не вызвать destroy(), фрейм утекает. Предотвращается обёрткой хэндла в RAII-тип, чей деструктор вызывает destroy(), и корректной move-семантикой, чтобы владение оставалось уникальным.

Параметр по значению копируется в coroutine frame, поэтому он живёт через приостановки всё время жизни корутины. Ссылочный параметр лишь указывает на объект вызывающей стороны — если она вернётся раньше, ссылка становится висячей, что является undefined behavior.

Если await_suspend вызывает handle.resume() для следующей корутины, а та возобновляет ещё одну, каждый resume() вкладывается в предыдущий стековый фрейм. Длинная цепочка не разматывается и переполняет стек; фреймы в куче этого не меняют.

Исключение, покинувшее тело, перехватывается компилятором и идёт в promise.unhandled_exception(). В стек возобновляющего кода оно не попадает. Типичный promise сохраняет std::current_exception() и перебрасывает позже из get().

void приостанавливает и возвращает управление вызывающему. bool делает то же при true, но false сразу возобновляет корутину. Возврат coroutine_handle<> — это symmetric transfer: handle возобновляется без роста стека.

Сделайте await_ready() возвращающим false, пусть await_suspend(handle) регистрирует I/O и сохраняет handle в колбэке завершения, а await_resume() возвращает результат. Колбэк вызывает handle.resume().

Параметр корутины по ссылке не копируется во фрейм — копируется лишь ссылка. Если объект вызывающего умирает до возобновления, его использование — UB. Стреляет после первой приостановки, когда стек вызывающего размотан.

Компилятор переписывает тело в конечный автомат внутри heap-фрейма. Целое — индекс возобновления — хранит, с какой точки продолжать; resume() диспетчеризует по нему (по сути switch), прыгая в нужное место с сохранёнными локальными.

Symmetric transfer — это возврат coroutine_handle<> из await_suspend, чтобы компилятор возобновил корутину хвостовым вызовом вместо вложенного resume(). Это решает переполнение стека при цепочках корутин.