CKTIS / C++
co_await — wachten in een coroutine
De co_await-expressie gebruikt het awaiter-protocol om een coroutine eventueel te onderbreken en daarna een resultaat te verkrijgen. De expressie start zelf geen thread en verzorgt geen planning; de gebruikte implementatie moet het hervatten regelen.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
co_await cast-expressionco_await expression markeert een mogelijk onderbrekingspunt van een coroutine; het is geen blokkerende wachtbewerking voor een thread. Door zo’n expressie in de functiebody op te nemen, wordt de functie een coroutine. Het type van het promise-object wordt bepaald via std::coroutine_traits, dat een passend promise_type moet bieden voor het retourtype en de parametertypen van de coroutine (inclusief de objectparameter bij een niet-statische lidfunctie). Het retourtype hoeft zelf geen genest promise_type te hebben. De operator zelf maakt geen thread en geen scheduler aan.
Als bij een expliciete co_await een declaratie van await_transform wordt gevonden in het type van het promise-object, is de awaitable het resultaat van de aanroep van await_transform op dat object met de operand als argument. Anders is de oorspronkelijke operand de awaitable. Als overloadresolutie een operator co_await voor de awaitable selecteert, wordt het resultaat van die aanroep als awaiter gebruikt. Alleen als de kandidatenverzameling voor operator co_await leeg is, wordt de awaitable zelf als awaiter gebruikt, na de eventuele omzetting. Is de kandidatenverzameling niet leeg, maar bevat ze geen toepasbare functie, dan is de co_await-expressie ongeldig. De awaiter biedt await_ready(), await_suspend(h) en await_resume(). De expressie heeft het type en de waardecategorie van het resultaat van await_resume().
Het resultaat van await_ready() wordt contextueel geconverteerd naar bool. Levert de conversie true op, dan wordt de coroutine niet onderbroken. Dat geldt ook als het resultaat een object van een klassetype is waarvan de explicit operator bool() true teruggeeft. Levert de conversie false op, dan wordt de coroutine onderbroken en wordt await_suspend(h) aangeroepen. Als await_suspend het retourtype void heeft, leidt de terugkeer uit de aanroep op zichzelf niet tot hervatting door het co_await-mechanisme. await_suspend kan de coroutine echter zelf hervatten of ervoor zorgen dat een andere thread haar hervat, zelfs voordat de aanroep terugkeert. Een bool-resultaat met de waarde false hervat de coroutine onmiddellijk; het teruggeven van een coroutine-handle draagt de uitvoering over aan de aangegeven coroutine. await_resume() levert het resultaat wanneer de uitvoering verdergaat.
Het voorbeeld gebruikt std::suspend_always: run() drukt start af en geeft de controle terug; resume() zorgt ervoor dat zij resumed kan afdrukken. final_suspend() laat het frame onderbroken, zodat de destructor van Task het kan vrijgeven. Hervat een coroutine nooit op haar definitieve onderbrekingspunt; objecten die na hervatting worden gebruikt, moeten nog bestaan.
Dit artikel richt zich op C++23; de opgegeven site publiceert een evoluerend concept, geen vastgelegde C++23-tekst. Compatibiliteit met de productie-runtime is niet bevestigd.
Voorbeelden
#include <coroutine>
#include <exception>
#include <iostream>
struct Task {
struct promise_type;
using Handle = std::coroutine_handle<promise_type>;
struct promise_type {
Task get_return_object() {
return Task{Handle::from_promise(*this)};
}
std::suspend_never initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() noexcept {}
void unhandled_exception() noexcept { std::terminate(); }
};
Handle handle;
explicit Task(Handle h) noexcept : handle(h) {}
Task(const Task&) = delete;
Task& operator=(const Task&) = delete;
~Task() { handle.destroy(); }
};
Task run() {
std::cout << "start\n";
co_await std::suspend_always{};
std::cout << "resumed\n";
}
int main() {
auto task = run();
std::cout << "caller\n";
task.handle.resume();
}
Resultaat
start caller resumed
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.