CKTIS / C++
co_await — attendere in una coroutine
L’espressione co_await usa il protocollo awaiter per sospendere eventualmente una coroutine e ottenere poi un risultato. Non avvia autonomamente un thread né fornisce una pianificazione; la ripresa deve essere gestita dall’implementazione utilizzata.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
co_await cast-expressionco_await expression indica un possibile punto di sospensione di una coroutine, non un’attesa bloccante di un thread. Inserire un’espressione di questo tipo nel corpo di una funzione la rende una coroutine. Il tipo dell’oggetto promise si ricava da std::coroutine_traits, che deve fornire un promise_type appropriato per il tipo di ritorno e i tipi dei parametri della coroutine (compreso il parametro oggetto per una funzione membro non statica). Il tipo di ritorno non deve necessariamente contenere un promise_type annidato. L’operatore non crea da sé né un thread né uno scheduler.
Per un co_await esplicito, se la ricerca di await_transform nel tipo dell’oggetto promise trova una dichiarazione, l’awaitable è il risultato della chiamata a await_transform su tale oggetto con l’operando come argomento. Altrimenti, l’awaitable è l’operando originale. Se la risoluzione degli overload seleziona un operator co_await per l’awaitable, il risultato della chiamata viene usato come awaiter. Solo se l’insieme dei candidati per operator co_await è vuoto si usa come awaiter l’awaitable stesso, dopo l’eventuale trasformazione. Se l’insieme non è vuoto ma non contiene alcuna funzione applicabile, l’espressione co_await è mal formata. L’awaiter fornisce await_ready(), await_suspend(h) e await_resume(). L’espressione ha il tipo e la categoria di valore del risultato di await_resume().
Il risultato di await_ready() viene convertito contestualmente in bool. Se la conversione produce true, la coroutine non viene sospesa; questo vale anche quando il risultato è un oggetto di un tipo di classe il cui explicit operator bool() restituisce true. Se la conversione produce false, la coroutine viene sospesa e viene chiamato await_suspend(h). Se il tipo di ritorno di await_suspend è void, il ritorno dalla chiamata non induce di per sé il meccanismo di co_await a riprendere la coroutine. Tuttavia, await_suspend può riprenderla direttamente o fare in modo che la riprenda un altro thread, anche prima che la chiamata termini. Un risultato di tipo bool pari a false fa riprendere immediatamente la coroutine; restituire un handle di coroutine trasferisce l’esecuzione alla coroutine indicata. await_resume() fornisce il risultato quando l’esecuzione continua.
L’esempio usa std::suspend_always: run() stampa start e restituisce il controllo; resume() le permette di stampare resumed. final_suspend() lascia il frame sospeso affinché il distruttore di Task possa liberarlo. Non riprendere mai una coroutine nel suo punto di sospensione finale; gli oggetti usati dopo la ripresa devono essere ancora in vita.
Questa voce riguarda C++23; il sito indicato pubblica una bozza in evoluzione, non un testo C++23 definitivo. La compatibilità con l’ambiente di runtime di produzione non è attestata.
Esempi
#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();
}
Risultato
start caller resumed
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.