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

CKTIS / C++

co_return — terminer une coroutine

co_return termine l’exécution du corps d’une coroutine et transmet son résultat à l’objet promise, au lieu de le renvoyer directement comme le ferait un return ordinaire. La coroutine passe ensuite à final_suspend() ; la durée de vie de son état dépend du mécanisme de gestion de la coroutine.

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

Syntaxe

co_return;
co_return expression;
co_return braced-init-list;

co_return marque la fin d’une coroutine. Sa seule présence suffit à faire d’une fonction une coroutine, même en l’absence de co_await ou de co_yield. L’objet renvoyé par l’appel de fonction provient de promise.get_return_object() ; l’opérande de co_return n’a pas besoin d’avoir le type de retour de la fonction.

Pour une expression d’un type autre que void ou une liste d’initialisation entre accolades, promise.return_value(...) est appelé. co_return; appelle promise.return_void(). Avec un opérande de type void, l’expression est d’abord évaluée, puis return_void() est appelé. Ces appels doivent produire un résultat de type void.

Le contrôle passe ensuite à final_suspend(). La fin du corps ne signifie pas que l’état de la coroutine est automatiquement détruit. Dans l’exemple, initial_suspend() permet au corps de s’exécuter immédiatement, return_value(int) stocke 42 et final_suspend() conserve l’état pour consultation. Le destructeur de Result le libère à l’aide de destroy() ; la copie du propriétaire est interdite.

Un corps de coroutine ne doit pas contenir de return ordinaire. En C++23, atteindre la fin du corps équivaut à exécuter co_return; si le type de l’objet promise possède un membre nommé return_void. Si ce membre existe mais que l’appel implicite à promise.return_void() est mal formé, le programme est mal formé. Si le type de l’objet promise ne possède aucun membre de ce nom, atteindre la fin du corps entraîne un comportement indéfini. Cette entrée concerne C++23 ; le site indiqué héberge un projet de norme en évolution, et non un texte C++23 figé.

Exemples

#include <coroutine>
#include <exception>
#include <iostream>

struct Result {
    struct promise_type;
    using Handle = std::coroutine_handle<promise_type>;

    struct promise_type {
        int value = 0;
        Result get_return_object() {
            return Result{Handle::from_promise(*this)};
        }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_value(int n) noexcept { value = n; }
        void unhandled_exception() noexcept { std::terminate(); }
    };

    Handle handle;
    explicit Result(Handle h) noexcept : handle(h) {}
    Result(const Result&) = delete;
    Result& operator=(const Result&) = delete;
    ~Result() { handle.destroy(); }

    int value() const { return handle.promise().value; }
};

Result answer() {
    co_return 42;
}

int main() {
    auto result = answer();
    std::cout << result.value() << '\n';
}

Résultat

42

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