WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::suspend_never — eine Coroutine ohne Aussetzen abwarten

std::suspend_never aus <coroutine> ist ein einfacher Awaiter, der eine Coroutine nicht aussetzt und keinen Wert liefert. Damit lässt sich ein sofortiger Start oder Abschluss einer Coroutine festlegen; beim Abschluss muss die Lebensdauer ihres Zustands sorgfältig beachtet werden.

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

Syntax

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

std::suspend_never ist ein Typ aus <coroutine>, dessen Objekte direkt als Awaiter für co_await dienen können. Er setzt die Coroutine nicht aus und liefert keinen Wert: Der Ergebnistyp ist void. Im Gegensatz dazu setzt std::suspend_always die Coroutine immer aus, wenn es direkt als Awaiter verwendet wird.

await_ready() gibt true zurück, sodass das Await-Protokoll await_suspend(std::coroutine_handle<>) überspringt und await_resume() aufruft. Die beiden letztgenannten Funktionen tun nichts und geben void zurück; alle drei sind constexpr, const und noexcept. Dadurch wird das Aussetzen an genau dieser Stelle verhindert, nicht jedoch während der gesamten Coroutine. Ein benutzerdefiniertes await_transform des Promise-Objekts kann die Interpretation des co_await-Operanden ändern.

Die impliziten co_await-Ausdrücke für initial_suspend() und final_suspend() überspringen await_transform, können aber dennoch einen überladenen operator co_await auswählen, der einen Awaiter liefert, der die Coroutine aussetzt. Der Rückgabetyp allein garantiert daher nicht, dass die Coroutine nicht ausgesetzt wird. Dient das von initial_suspend() zurückgegebene std::suspend_never-Objekt selbst als Awaiter, geht die Ausführung sofort in den Coroutine-Körper über. Dient das von final_suspend() zurückgegebene Objekt selbst als Awaiter, wird die Coroutine am Ende nicht ausgesetzt und ihr Zustand wird bei Abschluss zerstört. Jeder aufbewahrte Handle auf diesen Zustand wird ungültig – danach dürfen darüber weder resume(), done() noch destroy() aufgerufen werden.

Im Beispiel speichert immediate_task keinen Handle. run() führt beide Ausgaben aus, bevor die Funktion zu main() zurückkehrt, und ihr Zustand wird automatisch bereinigt. Der Eintrag bezieht sich auf C++23; die angegebene Website enthält einen fortlaufend weiterentwickelten Standardentwurf und keine unveränderliche C++23-Veröffentlichung. Eine Ausführung in einer Produktionslaufzeit wurde nicht bestätigt.

Beispiele

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

Ergebnis

before
after
returned

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