Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Coroutines

Une coroutine peut suspendre son exécution puis la reprendre plus tard, tout en conservant l’état nécessaire. Les mots-clés co_await, co_yield et co_return coopèrent avec un type promise et un handle de coroutine ; ils ne lancent automatiquement ni thread ni ordonnanceur.

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

Syntaxe

co_await expression; co_yield expression; co_return [expression];

Une coroutine est une fonction dont le corps contient co_await, co_yield ou co_return. Lorsqu’elle se suspend, elle conserve l’état nécessaire à sa reprise. Le contrôle peut revenir à celui qui l’a appelée ou reprise, mais si await_suspend() de l’awaiter renvoie un handle vers une autre coroutine, le contrôle passe directement à cette dernière. Cela n’implique pas une exécution parallèle automatique : une coroutine seule ne crée ni thread ni ordonnanceur.

co_await utilise le protocole awaiter : await_ready() vérifie si le résultat est prêt, await_suspend() gère la suspension et await_resume() fournit le résultat. Tout co_await ne laisse pas nécessairement la coroutine suspendue. co_yield value attend le résultat de promise.yield_value(value) sans appliquer await_transform de l’objet promise. À l’inverse, co_await promise.yield_value(value) écrit explicitement utilise await_transform si le type promise le fournit. Ce remplacement peut donc modifier le comportement ou provoquer une erreur de compilation. co_return termine le corps de la coroutine au lieu de transmettre directement une valeur à son appelant.

Le type promise, généralement disponible sous la forme promise_type du type de retour, contrôle notamment l’objet résultat, la suspension initiale et finale, ainsi que la fin d’exécution et la gestion des exceptions. <coroutine> fournit std::coroutine_handle et std::suspend_always. Un handle ne gère pas à lui seul la durée de vie de l’état : la responsabilité de sa destruction doit être explicite.

Dans l’exemple, Task est un propriétaire non copiable et non déplaçable. initial_suspend() retarde l’exécution du corps, et final_suspend() conserve l’état jusqu’à sa destruction par le destructeur. Le std::suspend_always utilisé dans l’exemple ne transfère pas directement le contrôle à une autre coroutine. Deux reprises affichent 1 et 2 ; la troisième ne fait rien grâce à done(). Reprendre une coroutine terminée ou non suspendue entraîne un comportement indéfini. Après la destruction de l’état de la coroutine, tenter de la reprendre au moyen d’un handle vers cet état entraîne également un comportement indéfini. En revanche, réinitialiser ce handle en lui affectant nullptr est une opération bien définie. Les objets référencés doivent rester vivants suffisamment longtemps.

Cette entrée cible C++23 ; l’option du compilateur du dépôt n’atteste pas de la prise en charge par un environnement d’exécution de production. Le document fourni est un brouillon de travail en évolution, et non une édition C++23 définitive. L’exemple doit être vérifié localement et appelle volontairement std::terminate() en cas d’exception non gérée.

Exemples

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

Résultat

1
2

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources