Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Coroutine

Una coroutine può sospendere l’esecuzione e riprenderla in seguito, conservando lo stato necessario. Le parole chiave co_await, co_yield e co_return collaborano con un tipo promise e un handle di coroutine; non avviano automaticamente un thread o uno scheduler.

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

Sintassi

co_await expression; co_yield expression; co_return [expression];

Una coroutine è una funzione il cui corpo contiene co_await, co_yield o co_return. Quando si sospende, conserva lo stato necessario per continuare. Il controllo può tornare a chi l’ha chiamata o ripresa, ma se await_suspend() dell’awaiter restituisce un handle a un’altra coroutine, il controllo passa direttamente a quest’ultima. Questo non implica un’esecuzione parallela automatica: una coroutine da sola non crea né un thread né uno scheduler.

co_await usa il protocollo awaiter: await_ready() controlla se il risultato è pronto, await_suspend() gestisce la sospensione e await_resume() fornisce il risultato. Non ogni co_await lascia effettivamente sospesa la coroutine. co_yield value attende il risultato di promise.yield_value(value) senza applicare await_transform dell’oggetto promise. Scrivendo invece esplicitamente co_await promise.yield_value(value), si usa await_transform se il tipo promise lo mette a disposizione. La sostituzione può quindi cambiare il comportamento o causare un errore di compilazione. co_return conclude il corpo della coroutine, invece di passare un valore direttamente al chiamante.

Il tipo promise, di solito disponibile come promise_type del tipo restituito, controlla tra l’altro l’oggetto risultato, la sospensione iniziale e finale, il completamento e la gestione delle eccezioni. <coroutine> fornisce std::coroutine_handle e std::suspend_always. Un handle non gestisce da solo la durata dello stato: la responsabilità della sua distruzione deve essere esplicita.

Nell’esempio, Task è un proprietario non copiabile e non spostabile. initial_suspend() ritarda l’esecuzione del corpo, mentre final_suspend() conserva lo stato affinché venga distrutto dal distruttore. Lo std::suspend_always usato nell’esempio non trasferisce direttamente il controllo a un’altra coroutine. Due riprese stampano 1 e 2; la terza non fa nulla grazie a done(). Riprendere una coroutine terminata o non sospesa causa un comportamento indefinito. Dopo la distruzione dello stato della coroutine, anche tentare di riprenderla tramite un handle a quello stato causa un comportamento indefinito. Azzerare quell’handle assegnandogli nullptr è invece un’operazione ben definita. Gli oggetti a cui si accede tramite riferimenti devono rimanere in vita abbastanza a lungo.

Questa voce riguarda C++23; il flag del compilatore nel repository non attesta il supporto nell’ambiente di esecuzione di produzione. Il documento fornito è una bozza di lavoro in evoluzione, non un’edizione definitiva di C++23. L’esempio richiede una verifica locale e chiama intenzionalmente std::terminate() in caso di eccezione non gestita.

Esempi

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

Risultato

1
2

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