Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

co_return — dokončení korutiny

co_return ukončuje provádění těla korutiny a předává její výsledek objektu promise, místo aby jej vracel přímo jako běžný return. Korutina pak pokračuje do final_suspend(); doba existence jejího stavu závisí na mechanismu správy korutiny.

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

Syntaxe

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

co_return označuje dokončení korutiny. Už jeho samotná přítomnost způsobí, že je funkce korutinou, a to i bez co_await nebo co_yield. Objekt vrácený voláním funkce pochází z promise.get_return_object(); operand co_return nemusí mít návratový typ funkce.

Pro výraz jiného než void typu nebo seznam inicializátorů ve složených závorkách se volá promise.return_value(...). co_return; volá promise.return_void(). Má-li operand typ void, nejprve se vyhodnotí výraz a poté se zavolá return_void(). Tyto funkce musí mít výsledek typu void.

Řízení pak pokračuje do final_suspend(). Dokončení těla automaticky neznamená zničení stavu korutiny. V příkladu initial_suspend() umožní okamžité spuštění těla, return_value(int) uloží 42 a final_suspend() zachová stav pro pozdější kontrolu. Destruktor Result jej uvolní pomocí destroy(); kopírování vlastníka je zakázáno.

Tělo korutiny nesmí obsahovat běžný return. V C++23 je dosažení konce těla ekvivalentní provedení co_return;, pokud má typ objektu promise člen s názvem return_void. Pokud tento člen existuje, ale implicitní volání promise.return_void() není platné, program není správně utvořený. Pokud typ objektu promise nemá žádný člen s tímto názvem, dosažení konce těla způsobí nedefinované chování. Tento záznam se týká C++23; uvedený web obsahuje průběžně se měnící pracovní návrh, nikoli neměnný text C++23.

Příklady

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

Výsledek

42

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje