KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Coroutines

Een coroutine kan de uitvoering onderbreken en later hervatten, terwijl de benodigde toestand behouden blijft. De sleutelwoorden co_await, co_yield en co_return werken samen met een promise-type en een coroutine-handle; ze starten niet automatisch een thread of scheduler.

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

Syntax

co_await expression; co_yield expression; co_return [expression];

Een coroutine is een functie waarvan de body co_await, co_yield of co_return bevat. Bij onderbreking bewaart ze de toestand die nodig is om verder te gaan. De controle kan teruggaan naar de code die de coroutine heeft aangeroepen of hervat. Geeft await_suspend() van de awaiter echter een handle naar een andere coroutine terug, dan gaat de controle rechtstreeks over naar die coroutine. Dit betekent niet dat er automatisch parallelle uitvoering plaatsvindt: een coroutine op zichzelf maakt geen thread of scheduler aan.

co_await gebruikt het awaiter-protocol: await_ready() controleert of het resultaat klaar is, await_suspend() behandelt de onderbreking en await_resume() levert het resultaat. Niet elke co_await laat de coroutine daadwerkelijk onderbroken achter. co_yield value wacht op het resultaat van promise.yield_value(value) zonder await_transform van het promise-object toe te passen. Een expliciet geschreven co_await promise.yield_value(value) gebruikt await_transform wel als het promise-type die functie aanbiedt. De vervanging kan dus het gedrag veranderen of een compilatiefout opleveren. co_return beëindigt de coroutine-body in plaats van een waarde rechtstreeks aan de aanroeper door te geven.

Het promise-type, doorgaans beschikbaar als promise_type van het returntype, bepaalt onder meer het resultaatobject, de initiële en finale onderbreking, de voltooiing en de afhandeling van uitzonderingen. <coroutine> levert std::coroutine_handle en std::suspend_always. Een handle beheert de levensduur van de toestand niet zelf: de verantwoordelijkheid voor het vernietigen ervan moet expliciet zijn.

In het voorbeeld is Task een eigenaar die niet kopieerbaar en niet verplaatsbaar is. initial_suspend() stelt de uitvoering van de body uit, en final_suspend() houdt de toestand beschikbaar voor vernietiging door de destructor. Het voorbeeld gebruikt std::suspend_always, dat de controle niet rechtstreeks aan een andere coroutine overdraagt. Twee hervattingen drukken 1 en 2 af; de derde doet niets dankzij done(). Het hervatten van een voltooide of niet-onderbroken coroutine leidt tot ongedefinieerd gedrag. Nadat de toestand van de coroutine is vernietigd, leidt een poging om de coroutine via een handle naar die toestand te hervatten eveneens tot ongedefinieerd gedrag. Die handle resetten door er nullptr aan toe te wijzen is daarentegen welgedefinieerd. Objecten waarnaar via referenties wordt verwezen, moeten lang genoeg blijven bestaan.

Dit artikel is gericht op C++23; de compileroptie in de repository bevestigt geen ondersteuning in een productie-runtimeomgeving. Het aangeleverde document is een evoluerend werkconcept, geen definitieve C++23-editie. Het voorbeeld moet lokaal worden gecontroleerd en roept bij een niet-afgehandelde uitzondering bewust std::terminate() aan.

Voorbeelden

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

Resultaat

1
2

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