KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::suspend_never — wachten zonder een coroutine op te schorten

std::suspend_never uit <coroutine> is een eenvoudige awaiter die een coroutine niet opschort en geen waarde oplevert. Hiermee kan een onmiddellijke start of voltooiing van een coroutine worden vastgelegd; bij voltooiing moet zorgvuldig op de levensduur van de status worden gelet.

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

Syntax

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

std::suspend_never is een type uit <coroutine> waarvan objecten direct als awaiter voor co_await kunnen dienen. Het schort de coroutine niet op en levert geen waarde op: het resultaat heeft het type void. Daartegenover staat std::suspend_always, dat de coroutine altijd opschort wanneer het direct als awaiter wordt gebruikt.

await_ready() geeft true terug, waardoor het await-protocol await_suspend(std::coroutine_handle<>) overslaat en await_resume() aanroept. De twee laatstgenoemde functies doen niets en geven void terug; alle drie zijn constexpr, const en noexcept. Dit voorkomt opschorting op dit specifieke punt, niet gedurende de hele coroutine. Een aangepaste await_transform van het promise-object kan de interpretatie van de co_await-operand wijzigen.

De impliciete co_await-expressies voor initial_suspend() en final_suspend() slaan await_transform over, maar kunnen nog steeds een overbelaste operator co_await selecteren die een awaiter levert die de coroutine opschort. Het retourtype alleen garandeert dus niet dat opschorting uitblijft. Als het door initial_suspend() teruggegeven std::suspend_never-object zelf als awaiter dient, gaat de uitvoering meteen verder in de body van de coroutine. Als het door final_suspend() teruggegeven object zelf als awaiter dient, is er geen opschorting aan het einde en wordt de toestand van de coroutine bij voltooiing vernietigd. Elke bewaarde handle naar die toestand wordt ongeldig; daarna mag je er geen resume(), done() of destroy() mee aanroepen.

In het voorbeeld slaat immediate_task geen handle op. run() voert beide afdrukken uit voordat de functie terugkeert naar main(), en de status wordt automatisch opgeruimd. Dit item gaat uit van C++23; de genoemde site bevat een zich ontwikkelend normontwerp, geen bevroren C++23-publicatie. Uitvoering in een productieomgeving is niet bevestigd.

Voorbeelden

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

struct immediate_task {
    struct promise_type {
        immediate_task get_return_object() noexcept { return {}; }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() noexcept {}
        void unhandled_exception() noexcept { std::terminate(); }
    };
};

immediate_task run() {
    std::cout << "before\n";
    co_await std::suspend_never{};
    std::cout << "after\n";
    co_return;
}

int main() {
    run();
    std::cout << "returned\n";
}

Resultaat

before
after
returned

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