WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

co_return — eine Coroutine abschließen

co_return beendet die Ausführung des Coroutine-Rumpfs und übergibt das Ergebnis an das Promise-Objekt, statt es wie bei einem gewöhnlichen return direkt zurückzugeben. Danach fährt die Coroutine mit final_suspend() fort; wie lange ihr Zustand erhalten bleibt, hängt von der Coroutine-Verwaltung ab.

Version: C++23; repository compiler flag, production runtime not attested

Syntax

co_return;
co_return expression;
co_return braced-init-list;

co_return kennzeichnet den Abschluss einer Coroutine. Schon sein Vorhandensein macht eine Funktion zu einer Coroutine, auch ohne co_await oder co_yield. Das Objekt, das der Funktionsaufruf zurückgibt, stammt aus promise.get_return_object(); der Operand von co_return muss nicht den Rückgabetyp der Funktion haben.

Bei einem Ausdruck mit einem anderen Typ als void oder einer geschweiften Initialisierungsliste wird promise.return_value(...) aufgerufen. co_return; ruft promise.return_void() auf. Bei einem void-Operanden wird zunächst der Ausdruck ausgewertet und anschließend return_void() aufgerufen. Diese Aufrufe müssen ein Ergebnis vom Typ void liefern.

Danach wird die Ausführung mit final_suspend() fortgesetzt. Der Abschluss des Rumpfs bedeutet nicht automatisch, dass der Coroutine-Zustand zerstört wird. Im Beispiel lässt initial_suspend() den Rumpf sofort ausführen, return_value(int) speichert 42, und final_suspend() erhält den Zustand zur späteren Untersuchung. Der Destruktor von Result gibt ihn mit destroy() frei; das Kopieren des Besitzers ist untersagt.

Ein Coroutine-Rumpf darf kein gewöhnliches return enthalten. In C++23 ist das Erreichen des Rumpfendes gleichbedeutend mit co_return;, wenn der Promise-Typ ein Mitglied namens return_void hat. Gibt es dieses Mitglied, ist aber der implizite Aufruf promise.return_void() unzulässig, so ist das Programm nicht wohlgeformt. Hat der Promise-Typ kein Mitglied dieses Namens, führt das Erreichen des Rumpfendes zu undefiniertem Verhalten. Dieser Eintrag bezieht sich auf C++23; die angegebene Website enthält einen fortlaufend bearbeiteten Arbeitsentwurf, keinen eingefrorenen C++23-Text.

Beispiele

#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';
}

Ergebnis

42

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen