CKTIS / C++
std::suspend_always — sospensione incondizionata di una coroutine
std::suspend_always di <coroutine> è un semplice awaitable che sospende una coroutine senza produrre un valore. Non ne pianifica la ripresa: il codice che la gestisce deve conservare un handle e riprendere o distruggere la coroutine sospesa.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <coroutine>
co_await std::suspend_always{};std::suspend_always di <coroutine> implementa il protocollo awaiter. await_ready() restituisce false, await_suspend(std::coroutine_handle<>) non fa nulla e restituisce void, e await_resume() non fa nulla e restituisce void. Tutti e tre i metodi sono constexpr, const e noexcept. Al contrario, std::suspend_never restituisce true da await_ready().
Quando questo oggetto è l’awaiter effettivo, co_await std::suspend_always{}; sospende la coroutine e restituisce il controllo al chiamante o a chi la riprende. Dopo la ripresa, l’esecuzione continua senza ottenere un valore. Il tipo non blocca il thread, non avvia un timer e non pianifica la ripresa. await_transform della promise o un operator co_await sovraccaricato possono modificare l’awaiter selezionato.
Nell’esempio, initial_suspend() ritarda l’esecuzione del corpo fino al primo resume(). La prima ripresa stampa A e raggiunge la sospensione esplicita; la seconda stampa B e raggiunge final_suspend(). Il distruttore del proprietario distrugge il frame conservato. La copia del proprietario è vietata per evitare una doppia distruzione.
Non riprendere una coroutine nel suo punto di sospensione finale e non usare un handle dopo che il suo frame è stato distrutto. Il resume() dell’esempio controlla done() prima di riprendere. Questa voce è destinata alla compilazione con -std=c++23; il documento fornito è una bozza in evoluzione, non una pubblicazione definitiva di C++23. Il supporto del compilatore e dell’ambiente di runtime di produzione deve essere verificato localmente.
Esempi
#include <coroutine>
#include <exception>
#include <iostream>
struct Task {
struct promise_type {
Task get_return_object() {
return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
}
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() noexcept {}
void unhandled_exception() { std::terminate(); }
};
std::coroutine_handle<promise_type> handle;
explicit Task(std::coroutine_handle<promise_type> h) : handle(h) {}
Task(const Task&) = delete;
Task& operator=(const Task&) = delete;
~Task() { handle.destroy(); }
void resume() {
if (!handle.done()) handle.resume();
}
};
Task work() {
std::cout << "A\n";
co_await std::suspend_always{};
std::cout << "B\n";
}
int main() {
auto task = work();
std::cout << "created\n";
task.resume();
std::cout << "paused\n";
task.resume();
std::cout << "finished\n";
}
Risultato
created A paused B finished
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.