Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

co_return — zakończenie korutyny

co_return kończy wykonywanie ciała korutyny i przekazuje wynik obiektowi promise, zamiast zwracać go bezpośrednio jak zwykłe return. Następnie korutyna przechodzi do final_suspend(); czas życia jej stanu zależy od mechanizmu zarządzania korutyną.

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

Składnia

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

co_return oznacza zakończenie korutyny. Sama obecność tej instrukcji sprawia, że funkcja jest korutyną, nawet bez co_await i co_yield. Obiekt zwracany przez wywołanie funkcji powstaje dzięki promise.get_return_object(); operand co_return nie musi mieć typu zwracanego funkcji.

Dla wyrażenia o typie innym niż void oraz listy w klamrach wywoływane jest promise.return_value(...). co_return; wywołuje promise.return_void(). Przy operandzie typu void najpierw obliczane jest wyrażenie, a następnie wywoływane return_void(). Te wywołania muszą dawać wynik typu void.

Następnie sterowanie przechodzi do final_suspend(). Zakończenie ciała nie oznacza automatycznie zniszczenia stanu korutyny. W przykładzie initial_suspend() pozwala od razu wykonać ciało, return_value(int) zapisuje 42, a final_suspend() zachowuje stan do odczytu. Destruktor Result zwalnia go przez destroy(); kopiowanie właściciela jest zabronione.

W ciele korutyny nie wolno używać zwykłego return. W C++23 dojście do końca ciała jest równoważne co_return;, jeśli typ obiektu promise ma składową o nazwie return_void. Jeśli taka składowa istnieje, ale wynikające z tego wywołanie promise.return_void() jest niepoprawne, program jest niepoprawny. Jeśli typ obiektu promise nie ma składowej o tej nazwie, dojście do końca ciała powoduje niezdefiniowane zachowanie. Wpis dotyczy C++23; podany serwis udostępnia rozwijany szkic, nie zamrożony tekst C++23.

Przykłady

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

Wynik

42

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła