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

CKTIS / C++

Korutiny

Korutina může pozastavit vykonávání a později v něm pokračovat, přičemž zachová potřebný stav. Klíčová slova co_await, co_yield a co_return spolupracují s typem promise a coroutine handle; automaticky nespouštějí vlákno ani plánovač.

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

Syntaxe

co_await expression; co_yield expression; co_return [expression];

Korutina je funkce, jejíž tělo obsahuje co_await, co_yield nebo co_return. Při pozastavení zachová stav potřebný k pokračování. Řízení se může vrátit do místa, odkud byla korutina zavolána nebo obnovena. Pokud však await_suspend() awaiteru vrátí handle na jinou korutinu, řízení přejde přímo na tuto korutinu. Neznamená to automatické paralelní vykonávání: samotná korutina nevytváří vlákno ani plánovač.

co_await používá protokol awaiteru: await_ready() kontroluje, zda je výsledek připraven, await_suspend() zajišťuje pozastavení a await_resume() poskytuje výsledek. Ne každé co_await skutečně ponechá korutinu pozastavenou. co_yield value čeká na výsledek promise.yield_value(value), aniž by použil await_transform objektu promise. Výslovně zapsaný výraz co_await promise.yield_value(value) naopak použije await_transform, pokud jej typ promise poskytuje. Nahrazení tedy může změnit chování nebo způsobit chybu při kompilaci. co_return ukončí tělo korutiny, místo aby předalo hodnotu přímo volajícímu.

Typ promise, obvykle dostupný jako promise_type návratového typu, určuje mimo jiné objekt výsledku, počáteční a koncové pozastavení, dokončení a zpracování výjimek. <coroutine> poskytuje std::coroutine_handle a std::suspend_always. Handle sám nespravuje životnost stavu: odpovědnost za jeho zničení musí být výslovně určena.

V příkladu je Task vlastníkem, který nelze kopírovat ani přesouvat. initial_suspend() odkládá spuštění těla a final_suspend() ponechává stav ke zničení destruktorem. std::suspend_always použitý v příkladu nepředává řízení přímo jiné korutině. Dvě obnovení vypíší 1 a 2; třetí díky done() nic neudělá. Obnovení dokončené nebo nepozastavené korutiny vede k nedefinovanému chování. Po zničení stavu korutiny vede k nedefinovanému chování i pokus o její obnovení pomocí handle odkazujícího na tento stav. Vynulování tohoto handle přiřazením nullptr je však dobře definované. Objekty, na které odkazují reference, musí zůstat dostatečně dlouho živé.

Tento záznam se týká C++23; příznak kompilátoru v repozitáři nepotvrzuje podporu v produkčním běhovém prostředí. Dodaný dokument je průběžně se vyvíjející pracovní návrh, nikoli konečné vydání C++23. Příklad vyžaduje místní ověření a při nezachycené výjimce záměrně volá std::terminate().

Příklady

#include <coroutine>
#include <exception>
#include <iostream>

class Task {
public:
    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() noexcept {}
        void unhandled_exception() noexcept { std::terminate(); }
    };

    using Handle = std::coroutine_handle<promise_type>;
    explicit Task(Handle handle) noexcept : handle_(handle) {}
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;
    ~Task() { handle_.destroy(); }

    void resume() {
        if (!handle_.done()) {
            handle_.resume();
        }
    }

private:
    Handle handle_;
};

Task steps() {
    std::cout << "1\n";
    co_await std::suspend_always{};
    std::cout << "2\n";
    co_return;
}

int main() {
    auto task = steps();
    task.resume();
    task.resume();
    task.resume();
}

Výsledek

1
2

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