KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::suspend_always — onvoorwaardelijke opschorting van een coroutine

std::suspend_always uit <coroutine> is een eenvoudige awaitable die een coroutine opschort zonder een waarde op te leveren. Het plant geen hervatting: de beheercode moet een handle bewaren en de opgeschorte coroutine hervatten of vernietigen.

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

Syntax

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

std::suspend_always uit <coroutine> implementeert het awaiter-protocol. await_ready() retourneert false, await_suspend(std::coroutine_handle<>) doet niets en retourneert void, en await_resume() doet eveneens niets en retourneert void. Alle drie methoden zijn constexpr, const en noexcept. std::suspend_never retourneert daarentegen true vanuit await_ready().

Wanneer dit object daadwerkelijk de awaiter is, schort co_await std::suspend_always{}; de coroutine op en geeft het de controle terug aan de aanroeper of hervatter. Na hervatting gaat de uitvoering verder zonder een waarde te verkrijgen. Het type blokkeert de thread niet, start geen timer en plant geen hervatting. await_transform van de promise of een overbelaste operator co_await kan de gekozen awaiter veranderen.

In het voorbeeld stelt initial_suspend() de uitvoering van de coroutine-body uit tot de eerste resume(). De eerste hervatting schrijft A en bereikt de expliciete opschorting; de tweede schrijft B en bereikt final_suspend(). De destructor van de eigenaar vernietigt het bewaarde frame. Kopiëren van de eigenaar is verboden om dubbele vernietiging te voorkomen.

Hervat een coroutine niet op het uiteindelijke opschortingspunt en gebruik geen handle nadat het frame is vernietigd. De resume() van het voorbeeld controleert done() voordat de coroutine wordt hervat. Dit item is bedoeld voor compilatie met -std=c++23; het meegeleverde document is een voortdurend bijgewerkt concept, geen definitieve C++23-publicatie. Ondersteuning door compiler en productie-runtime moet lokaal worden gecontroleerd.

Voorbeelden

#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";
}

Resultaat

created
A
paused
B
finished

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen