CKTIS / C++
co_return — een coroutine afronden
co_return beëindigt de uitvoering van de coroutinebody en geeft het resultaat door aan het promise-object, in plaats van het rechtstreeks terug te geven zoals een gewone return. Daarna gaat de coroutine verder met final_suspend(); hoelang de toestand blijft bestaan, hangt af van het beheermechanisme van de coroutine.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
co_return;
co_return expression;
co_return braced-init-list;co_return markeert het einde van een coroutine. Alleen al de aanwezigheid ervan maakt een functie een coroutine, ook zonder co_await of co_yield. Het object dat de functieaanroep teruggeeft, komt uit promise.get_return_object(); de operand van co_return hoeft niet het returntype van de functie te hebben.
Voor een expressie met een ander type dan void of een lijst met accolades wordt promise.return_value(...) aangeroepen. co_return; roept promise.return_void() aan. Bij een operand van het type void wordt eerst de expressie geëvalueerd en daarna return_void() aangeroepen. Deze aanroepen moeten een resultaat van het type void opleveren.
Vervolgens gaat de uitvoering verder met final_suspend(). Het einde van de body betekent niet automatisch dat de coroutine-toestand wordt vernietigd. In het voorbeeld zorgt initial_suspend() ervoor dat de body meteen wordt uitgevoerd, slaat return_value(int) 42 op en bewaart final_suspend() de toestand om die te kunnen bekijken. De destructor van Result geeft de toestand vrij met destroy(); de eigenaar kopiëren is verboden.
Een coroutinebody mag geen gewone return bevatten. In C++23 staat het bereiken van het einde van de body gelijk aan het uitvoeren van co_return; als het type van het promise-object een lid met de naam return_void heeft. Als dat lid bestaat maar de impliciete aanroep promise.return_void() ongeldig is, is het programma niet welgevormd. Als het type van het promise-object geen lid met die naam heeft, leidt het bereiken van het einde van de body tot ongedefinieerd gedrag. Dit artikel behandelt C++23; de opgegeven site bevat een veranderend werkdocument, geen bevroren C++23-tekst.
Voorbeelden
#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';
}
Resultaat
42
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.