WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::suspend_always — bedingungsloses Anhalten einer Coroutine

std::suspend_always aus <coroutine> ist ein einfaches Awaitable, das eine Coroutine anhält, ohne einen Wert zu liefern. Es plant keine Fortsetzung: Der verwaltende Code muss einen Handle behalten und die angehaltene Coroutine fortsetzen oder zerstören.

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

Syntax

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

std::suspend_always aus <coroutine> implementiert das Awaiter-Protokoll. await_ready() gibt false zurück, await_suspend(std::coroutine_handle<>) tut nichts und gibt void zurück, und await_resume() tut ebenfalls nichts und gibt void zurück. Alle drei Methoden sind constexpr, const und noexcept. Im Gegensatz dazu gibt std::suspend_never bei await_ready() true zurück.

Wenn dieses Objekt tatsächlich als Awaiter verwendet wird, hält co_await std::suspend_always{}; die Coroutine an und gibt die Kontrolle an ihren Aufrufer oder Fortsetzer zurück. Nach der Fortsetzung läuft die Ausführung weiter, ohne einen Wert zu erhalten. Der Typ blockiert weder den Thread noch startet er einen Timer oder plant eine Fortsetzung. await_transform des Promise-Objekts oder ein überladenes operator co_await kann den ausgewählten Awaiter ändern.

Im Beispiel verzögert initial_suspend() die Ausführung des Coroutine-Körpers bis zum ersten resume(). Die erste Fortsetzung gibt A aus und erreicht die explizite Unterbrechung; die zweite gibt B aus und erreicht final_suspend(). Der Destruktor des Besitzers zerstört den aufbewahrten Frame. Das Kopieren des Besitzers ist untersagt, um eine doppelte Zerstörung zu verhindern.

Setze eine Coroutine nicht an ihrem abschließenden Haltepunkt fort und verwende keinen Handle, nachdem ihr Frame zerstört wurde. Das resume() des Beispiels prüft vor dem Fortsetzen done(). Dieser Eintrag zielt auf die Kompilierung mit -std=c++23; das angegebene Dokument ist ein fortlaufend überarbeiteter Entwurf und keine endgültige C++23-Veröffentlichung. Unterstützung durch Compiler und Produktionslaufzeit muss lokal überprüft werden.

Beispiele

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

Ergebnis

created
A
paused
B
finished

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