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

CKTIS / C++

Korutiny

Korutina môže pozastaviť vykonávanie a neskôr v ňom pokračovať, pričom zachová potrebný stav. Kľúčové slová co_await, co_yield a co_return spolupracujú s typom promise a coroutine handle; automaticky nespúšťajú vlákno ani plánovač.

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

Syntax

co_await expression; co_yield expression; co_return [expression];

Korutina je funkcia, ktorej telo obsahuje co_await, co_yield alebo co_return. Pri pozastavení zachová stav potrebný na pokračovanie. Riadenie sa môže vrátiť na miesto, odkiaľ bola korutina zavolaná alebo obnovená. Ak však await_suspend() awaitera vráti handle na inú korutinu, riadenie prejde priamo na túto korutinu. Neznamená to automatické paralelné vykonávanie: samotná korutina nevytvára vlákno ani plánovač.

co_await používa protokol awaitera: await_ready() kontroluje, či je výsledok pripravený, await_suspend() zabezpečuje pozastavenie a await_resume() poskytuje výsledok. Nie každé co_await skutočne ponechá korutinu pozastavenú. co_yield value čaká na výsledok promise.yield_value(value) bez použitia await_transform objektu promise. Explicitne zapísaný výraz co_await promise.yield_value(value) naopak použije await_transform, ak ho typ promise poskytuje. Takéto nahradenie teda môže zmeniť správanie alebo spôsobiť chybu pri kompilácii. co_return ukončí telo korutiny namiesto toho, aby odovzdalo hodnotu priamo volajúcemu.

Typ promise, zvyčajne dostupný ako promise_type návratového typu, určuje okrem iného objekt výsledku, počiatočné a koncové pozastavenie, dokončenie a spracovanie výnimiek. <coroutine> poskytuje std::coroutine_handle a std::suspend_always. Handle sám nespravuje životnosť stavu: zodpovednosť za jeho zničenie musí byť výslovne určená.

V príklade je Task vlastníkom, ktorý nemožno kopírovať ani presúvať. initial_suspend() odkladá vykonanie tela a final_suspend() ponecháva stav na zničenie deštruktorom. std::suspend_always použitý v príklade neodovzdáva riadenie priamo inej korutine. Dve obnovenia vypíšu 1 a 2; tretie vďaka done() nič neurobí. Obnovenie dokončenej alebo nepozastavenej korutiny vedie k nedefinovanému správaniu. Po zničení stavu korutiny vedie k nedefinovanému správaniu aj pokus o jej obnovenie pomocou handle odkazujúceho na tento stav. Vynulovanie tohto handle priradením nullptr je však dobre definované. Objekty, na ktoré odkazujú referencie, musia zostať dostatočne dlho živé.

Tento záznam sa týka C++23; príznak kompilátora v repozitári nepotvrdzuje podporu v produkčnom runtime prostredí. Dodaný dokument je priebežne sa vyvíjajúci pracovný návrh, nie konečné vydanie C++23. Príklad si vyžaduje miestne overenie a pri neošetrenej výnimke zámerne volá std::terminate().

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

1
2

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

Zdroje