Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

co_return — dokončenie korutiny

co_return ukončuje vykonávanie tela korutiny a odovzdáva jej výsledok objektu promise, namiesto toho, aby ho priamo vracalo ako bežný return. Korutina potom pokračuje do final_suspend(); dĺžka existencie jej stavu závisí od mechanizmu správy korutiny.

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

Syntax

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

co_return označuje dokončenie korutiny. Už jeho samotná prítomnosť spôsobí, že funkcia je korutinou, a to aj bez co_await alebo co_yield. Objekt vrátený volaním funkcie pochádza z promise.get_return_object(); operand co_return nemusí mať návratový typ funkcie.

Pre výraz iného typu než void alebo zoznam inicializátorov v zložených zátvorkách sa volá promise.return_value(...). co_return; volá promise.return_void(). Ak má operand typ void, najprv sa vyhodnotí výraz a potom sa zavolá return_void(). Tieto volania musia poskytovať výsledok typu void.

Riadenie potom pokračuje do final_suspend(). Dokončenie tela automaticky neznamená zničenie stavu korutiny. V príklade initial_suspend() umožňuje okamžité vykonanie tela, return_value(int) uloží 42 a final_suspend() zachová stav na preskúmanie. Deštruktor Result ho uvoľní pomocou destroy(); kopírovanie vlastníka je zakázané.

Telo korutiny nesmie obsahovať bežný return. V C++23 je dosiahnutie konca tela ekvivalentné vykonaniu co_return;, ak má typ objektu promise člen s názvom return_void. Ak tento člen existuje, ale implicitné volanie promise.return_void() nie je platné, program nie je správne utvorený. Ak typ objektu promise nemá žiadny člen s týmto názvom, dosiahnutie konca tela spôsobí nedefinované správanie. Tento záznam sa týka C++23; uvedená stránka obsahuje priebežne sa meniaci pracovný návrh, nie nemenný text C++23.

Prí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ýsledok

42

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje