Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

std::suspend_always — bezwarunkowe zawieszenie korutyny

std::suspend_always z nagłówka <coroutine> to prosty obiekt oczekiwania, który zawiesza korutynę i nie zwraca wartości. Nie planuje jej wznowienia: kod zarządzający musi zachować uchwyt i wznowić albo zniszczyć zawieszoną korutynę.

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

Składnia

#include <coroutine>
co_await std::suspend_always{};

std::suspend_always z nagłówka <coroutine> implementuje protokół oczekiwania. await_ready() zwraca false, await_suspend(std::coroutine_handle<>) nic nie robi i zwraca void, a await_resume() nic nie robi i zwraca void. Wszystkie trzy metody są constexpr, const i noexcept. Dla porównania std::suspend_never zwraca true z await_ready().

Gdy ten obiekt jest faktycznym awaiterem, co_await std::suspend_always{}; zawiesza korutynę i oddaje sterowanie wywołującemu lub wznawiającemu. Po wznowieniu wykonanie przechodzi dalej bez uzyskania wartości. Typ nie blokuje wątku, nie uruchamia timera ani nie planuje wznowienia. Metoda await_transform obiektu promise lub przeciążony operator co_await mogą zmienić wybór awaitera.

W przykładzie initial_suspend() opóźnia wykonanie ciała do pierwszego resume(). Pierwsze wznowienie wypisuje A i dociera do jawnego zawieszenia; drugie wypisuje B i dochodzi do final_suspend(). Destruktor właściciela niszczy zachowaną ramkę. Kopiowanie właściciela jest zabronione, aby uniknąć podwójnego zniszczenia.

Nie wolno wznawiać korutyny w końcowym punkcie zawieszenia ani używać uchwytu po zniszczeniu ramki. Przykładowy resume() sprawdza done() przed wznowieniem. Wpis jest przeznaczony do kompilacji z -std=c++23; podany dokument to rozwijany szkic, a nie zamrożona publikacja C++23. Obsługa kompilatora i środowiska produkcyjnego wymaga lokalnej weryfikacji.

Przykłady

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

struct Task {
    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() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;

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

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

Task work() {
    std::cout << "A\n";
    co_await std::suspend_always{};
    std::cout << "B\n";
}

int main() {
    auto task = work();
    std::cout << "created\n";
    task.resume();
    std::cout << "paused\n";
    task.resume();
    std::cout << "finished\n";
}

Wynik

created
A
paused
B
finished

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

Źródła