CKTIS / C++
std::suspend_never — attendere senza sospendere una coroutine
std::suspend_never di <coroutine> è un awaiter semplice che non sospende una coroutine e non produce alcun valore. Permette di specificare l’avvio o il completamento immediato di una coroutine; al completamento, occorre prestare attenzione alla durata dello stato.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <coroutine>
co_await std::suspend_never{};std::suspend_never è un tipo di <coroutine> i cui oggetti possono fungere direttamente da awaiter per co_await. Non sospende la coroutine e non produce alcun valore: il tipo del risultato è void. Al contrario, std::suspend_always, se usato direttamente come awaiter, sospende sempre la coroutine.
await_ready() restituisce true, quindi il protocollo di attesa salta await_suspend(std::coroutine_handle<>) e chiama await_resume(). Le ultime due funzioni non fanno nulla e restituiscono void; tutte e tre sono constexpr, const e noexcept. Questo impedisce la sospensione in quel punto specifico, non per l’intera coroutine. Un await_transform personalizzato dell’oggetto promise può cambiare l’interpretazione dell’operando di co_await.
Le espressioni co_await implicite per initial_suspend() e final_suspend() saltano await_transform, ma possono comunque selezionare un operator co_await sovraccaricato che fornisce un awaiter in grado di sospendere la coroutine. Il solo tipo restituito non garantisce quindi l’assenza di sospensione. Se l’oggetto std::suspend_never restituito da initial_suspend() funge esso stesso da awaiter, l’esecuzione passa subito al corpo della coroutine. Se l’oggetto restituito da final_suspend() funge esso stesso da awaiter, non c’è sospensione finale e lo stato della coroutine viene distrutto al completamento. Qualsiasi handle conservato che faccia riferimento a quello stato diventa dangling: in seguito non si devono chiamare tramite esso resume(), done() o destroy().
Nell’esempio, immediate_task non memorizza alcun handle. run() esegue entrambe le stampe prima di tornare a main() e il suo stato viene ripulito automaticamente. La voce riguarda C++23; il sito citato ospita una bozza dello standard in evoluzione, non una pubblicazione C++23 congelata. L’esecuzione in un ambiente di produzione non è stata attestata.
Esempi
#include <coroutine>
#include <exception>
#include <iostream>
struct immediate_task {
struct promise_type {
immediate_task get_return_object() noexcept { return {}; }
std::suspend_never initial_suspend() noexcept { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() noexcept {}
void unhandled_exception() noexcept { std::terminate(); }
};
};
immediate_task run() {
std::cout << "before\n";
co_await std::suspend_never{};
std::cout << "after\n";
co_return;
}
int main() {
run();
std::cout << "returned\n";
}
Risultato
before after returned
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.