Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Korutyny

Korutyna może zawiesić wykonanie i później je wznowić, zachowując potrzebny stan. Słowa kluczowe co_await, co_yield i co_return współpracują z typem obietnicy i uchwytem korutyny; nie uruchamiają automatycznie wątku ani planisty.

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

Składnia

co_await expression; co_yield expression; co_return [expression];

Korutyna to funkcja, której ciało zawiera co_await, co_yield lub co_return. Przy zawieszeniu zachowuje stan potrzebny do kontynuacji. Sterowanie może wrócić do miejsca wywołania lub wznowienia, ale jeśli await_suspend() awaitera zwróci uchwyt do innej korutyny, sterowanie przechodzi bezpośrednio do tej korutyny. Nie oznacza to automatycznej pracy równoległej: samo użycie korutyny nie tworzy wątku ani planisty.

co_await korzysta z protokołu awaitera: await_ready() sprawdza gotowość, await_suspend() obsługuje zawieszenie, a await_resume() dostarcza wynik. Nie każde co_await faktycznie pozostawia korutynę zawieszoną. co_yield value stosuje protokół oczekiwania do wyniku promise.yield_value(value) z pominięciem await_transform obietnicy. Jawnie zapisane co_await promise.yield_value(value) korzysta z await_transform, jeśli typ obietnicy je udostępnia, więc taka zamiana może zmienić zachowanie lub spowodować błąd kompilacji. co_return kończy ciało korutyny, zamiast przekazywać wartość bezpośrednio jej wywołującemu.

Typ obietnicy, zwykle dostępny jako promise_type typu zwracanego, określa m.in. obiekt wyniku, początkowe i końcowe zawieszenie oraz obsługę zakończenia i wyjątków. <coroutine> udostępnia std::coroutine_handle i std::suspend_always. Uchwyt sam nie zarządza czasem życia stanu: potrzebna jest jednoznaczna odpowiedzialność za jego zniszczenie.

W przykładzie Task jest niekopiowalnym, nieprzenoszalnym właścicielem. initial_suspend() opóźnia wykonanie ciała, a final_suspend() pozostawia stan do zniszczenia przez destruktor. Użyte w przykładzie std::suspend_always nie przekazuje sterowania bezpośrednio do innej korutyny. Dwa wznowienia wypisują 1 i 2; trzecie nic nie robi dzięki done(). Wznowienie korutyny zakończonej lub niezawieszonej jest niezdefiniowanym zachowaniem. Po zniszczeniu stanu korutyny próba wznowienia jej za pomocą uchwytu do tego stanu również prowadzi do niezdefiniowanego zachowania, ale przypisanie temu uchwytowi wartości nullptr w celu jego wyzerowania jest dobrze zdefiniowane. Obiekty wskazywane przez referencje muszą żyć wystarczająco długo.

Zakres wpisu to C++23; flaga kompilatora w repozytorium nie potwierdza obsługi w środowisku produkcyjnym. Podany dokument jest rozwijanym szkicem, a nie utrwalonym wydaniem C++23. Przykład wymaga lokalnej weryfikacji i celowo kończy program przez std::terminate() przy nieobsłużonym wyjątku.

Przykłady

#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();
}

Wynik

1
2

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

Źródła