WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Coroutinen

Eine Coroutine kann ihre Ausführung unterbrechen und später fortsetzen, wobei sie den benötigten Zustand bewahrt. Die Schlüsselwörter co_await, co_yield und co_return arbeiten mit einem Promise-Typ und einem Coroutine-Handle zusammen; sie starten nicht automatisch einen Thread oder Scheduler.

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

Syntax

co_await expression; co_yield expression; co_return [expression];

Eine Coroutine ist eine Funktion, deren Rumpf co_await, co_yield oder co_return enthält. Beim Anhalten bewahrt sie den für die Fortsetzung benötigten Zustand. Die Kontrolle kann an die Stelle zurückkehren, die die Coroutine aufgerufen oder fortgesetzt hat. Gibt await_suspend() des Awaiters jedoch ein Handle auf eine andere Coroutine zurück, geht die Kontrolle direkt an diese Coroutine über. Das bedeutet keine automatische parallele Ausführung: Eine Coroutine allein erzeugt weder einen Thread noch einen Scheduler.

co_await verwendet das Awaiter-Protokoll: await_ready() prüft, ob das Ergebnis bereit ist, await_suspend() behandelt das Anhalten und await_resume() liefert das Ergebnis. Nicht jedes co_await lässt die Coroutine tatsächlich angehalten zurück. co_yield value wartet auf das Ergebnis von promise.yield_value(value), ohne await_transform des Promise-Objekts anzuwenden. Ein ausdrücklich geschriebenes co_await promise.yield_value(value) verwendet dagegen await_transform, sofern der Promise-Typ es bereitstellt. Das Ersetzen kann daher das Verhalten ändern oder zu einem Kompilierungsfehler führen. co_return beendet den Coroutine-Rumpf, statt einen Wert direkt an den Aufrufer zu übergeben.

Der Promise-Typ, meist als promise_type des Rückgabetyps verfügbar, bestimmt unter anderem das Ergebnisobjekt, das anfängliche und abschließende Anhalten sowie den Umgang mit Abschluss und Ausnahmen. <coroutine> stellt std::coroutine_handle und std::suspend_always bereit. Ein Handle verwaltet die Lebensdauer des Zustands nicht selbst: Die Zuständigkeit für dessen Zerstörung muss ausdrücklich geregelt sein.

Im Beispiel ist Task ein nicht kopierbarer und nicht verschiebbarer Besitzer. initial_suspend() verzögert die Ausführung des Rumpfs, und final_suspend() hält den Zustand zur Zerstörung durch den Destruktor bereit. Das im Beispiel verwendete std::suspend_always übergibt die Kontrolle nicht direkt an eine andere Coroutine. Zwei Fortsetzungen geben 1 und 2 aus; die dritte bewirkt wegen done() nichts. Das Fortsetzen einer beendeten oder nicht angehaltenen Coroutine führt zu undefiniertem Verhalten. Wurde der Zustand der Coroutine bereits zerstört, führt ein Fortsetzungsversuch über ein Handle auf diesen Zustand ebenfalls zu undefiniertem Verhalten. Das Zurücksetzen dieses Handles durch Zuweisung von nullptr ist dagegen wohldefiniert. Objekte, auf die über Referenzen zugegriffen wird, müssen lange genug leben.

Dieser Eintrag bezieht sich auf C++23; das Compiler-Flag im Repository bestätigt keine Unterstützung in einer Produktionslaufzeitumgebung. Das bereitgestellte Dokument ist ein fortlaufend überarbeiteter Arbeitsentwurf, keine endgültige C++23-Ausgabe. Das Beispiel muss lokal überprüft werden und ruft bei einer unbehandelten Ausnahme absichtlich std::terminate() auf.

Beispiele

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

Ergebnis

1
2

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen