KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

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.

Bronnen