Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

co_return — completar una corrutina

co_return termina la ejecución del cuerpo de una corrutina y entrega el resultado al objeto promise, en lugar de devolverlo directamente como hace un return ordinario. A continuación, la corrutina continúa con final_suspend(); la duración de su estado depende del mecanismo de gestión de la corrutina.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

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

co_return marca la finalización de una corrutina. Su mera presencia convierte una función en corrutina, incluso sin co_await ni co_yield. El objeto que devuelve la llamada a la función procede de promise.get_return_object(); el operando de co_return no tiene por qué ser del tipo de retorno de la función.

Para una expresión de tipo distinto de void o una lista de inicialización entre llaves, se llama a promise.return_value(...). co_return; llama a promise.return_void(). Si el operando es de tipo void, primero se evalúa la expresión y después se llama a return_void(). Estas llamadas deben producir un resultado de tipo void.

A continuación, el control pasa a final_suspend(). Que el cuerpo termine no significa que el estado de la corrutina se destruya automáticamente. En el ejemplo, initial_suspend() permite que el cuerpo se ejecute de inmediato, return_value(int) almacena 42 y final_suspend() conserva el estado para consultarlo. El destructor de Result lo libera mediante destroy(); está prohibido copiar el propietario.

El cuerpo de una corrutina no debe contener un return ordinario. En C++23, llegar al final del cuerpo equivale a ejecutar co_return; si el tipo del objeto promise tiene un miembro llamado return_void. Si ese miembro existe pero la llamada implícita a promise.return_void() está mal formada, el programa está mal formado. Si el tipo del objeto promise no tiene ningún miembro con ese nombre, llegar al final del cuerpo provoca un comportamiento indefinido. Esta entrada trata sobre C++23; el sitio proporcionado aloja un borrador de trabajo en evolución, no un texto de C++23 congelado.

Ejemplos

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

Resultado

42

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes