Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::suspend_always — sospensione incondizionata di una coroutine

std::suspend_always di <coroutine> è un semplice awaitable che sospende una coroutine senza produrre un valore. Non ne pianifica la ripresa: il codice che la gestisce deve conservare un handle e riprendere o distruggere la coroutine sospesa.

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

Sintassi

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

std::suspend_always di <coroutine> implementa il protocollo awaiter. await_ready() restituisce false, await_suspend(std::coroutine_handle<>) non fa nulla e restituisce void, e await_resume() non fa nulla e restituisce void. Tutti e tre i metodi sono constexpr, const e noexcept. Al contrario, std::suspend_never restituisce true da await_ready().

Quando questo oggetto è l’awaiter effettivo, co_await std::suspend_always{}; sospende la coroutine e restituisce il controllo al chiamante o a chi la riprende. Dopo la ripresa, l’esecuzione continua senza ottenere un valore. Il tipo non blocca il thread, non avvia un timer e non pianifica la ripresa. await_transform della promise o un operator co_await sovraccaricato possono modificare l’awaiter selezionato.

Nell’esempio, initial_suspend() ritarda l’esecuzione del corpo fino al primo resume(). La prima ripresa stampa A e raggiunge la sospensione esplicita; la seconda stampa B e raggiunge final_suspend(). Il distruttore del proprietario distrugge il frame conservato. La copia del proprietario è vietata per evitare una doppia distruzione.

Non riprendere una coroutine nel suo punto di sospensione finale e non usare un handle dopo che il suo frame è stato distrutto. Il resume() dell’esempio controlla done() prima di riprendere. Questa voce è destinata alla compilazione con -std=c++23; il documento fornito è una bozza in evoluzione, non una pubblicazione definitiva di C++23. Il supporto del compilatore e dell’ambiente di runtime di produzione deve essere verificato localmente.

Esempi

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

Risultato

created
A
paused
B
finished

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti