CKTIS / C++
co_return — completare una coroutine
co_return termina l’esecuzione del corpo di una coroutine e consegna il risultato all’oggetto promise, invece di restituirlo direttamente come farebbe un return ordinario. La coroutine prosegue quindi con final_suspend(); la durata del suo stato dipende dal meccanismo di gestione della coroutine.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
co_return;
co_return expression;
co_return braced-init-list;co_return contrassegna il completamento di una coroutine. La sua sola presenza rende una funzione una coroutine, anche senza co_await o co_yield. L’oggetto restituito dalla chiamata alla funzione proviene da promise.get_return_object(); l’operando di co_return non deve necessariamente avere il tipo restituito dalla funzione.
Per un’espressione di tipo diverso da void o per una lista di inizializzazione tra parentesi graffe, viene chiamato promise.return_value(...). co_return; chiama promise.return_void(). Con un operando di tipo void, l’espressione viene prima valutata e poi viene chiamato return_void(). Queste chiamate devono produrre un risultato di tipo void.
Il controllo passa quindi a final_suspend(). Il completamento del corpo non comporta automaticamente la distruzione dello stato della coroutine. Nell’esempio, initial_suspend() permette al corpo di essere eseguito immediatamente, return_value(int) memorizza 42 e final_suspend() conserva lo stato per poterlo esaminare. Il distruttore di Result lo rilascia usando destroy(); copiare il proprietario è vietato.
Il corpo di una coroutine non deve contenere un return ordinario. In C++23, raggiungere la fine del corpo equivale a eseguire co_return; se il tipo dell’oggetto promise ha un membro di nome return_void. Se tale membro esiste ma la chiamata implicita a promise.return_void() non è ben formata, il programma non è ben formato. Se il tipo dell’oggetto promise non ha alcun membro con quel nome, raggiungere la fine del corpo causa un comportamento indefinito. Questa voce riguarda C++23; il sito indicato ospita una bozza di lavoro in evoluzione, non un testo C++23 definitivo e immutabile.
Esempi
#include <coroutine>
#include <exception>
#include <iostream>
struct Result {
struct promise_type;
using Handle = std::coroutine_handle<promise_type>;
struct promise_type {
int value = 0;
Result get_return_object() {
return Result{Handle::from_promise(*this)};
}
std::suspend_never initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_value(int n) noexcept { value = n; }
void unhandled_exception() noexcept { std::terminate(); }
};
Handle handle;
explicit Result(Handle h) noexcept : handle(h) {}
Result(const Result&) = delete;
Result& operator=(const Result&) = delete;
~Result() { handle.destroy(); }
int value() const { return handle.promise().value; }
};
Result answer() {
co_return 42;
}
int main() {
auto result = answer();
std::cout << result.value() << '\n';
}
Risultato
42
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.