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

CKTIS / C++

Corutinas

Una corutina puede suspender la ejecución y reanudarla más tarde, conservando el estado que necesita. Las palabras clave co_await, co_yield y co_return colaboran con un tipo promise y un handle de corutina; no inician automáticamente un hilo ni un planificador.

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

Sintaxis

co_await expression; co_yield expression; co_return [expression];

Una corutina es una función cuyo cuerpo contiene co_await, co_yield o co_return. Al suspenderse, conserva el estado necesario para continuar. El control puede volver a quien la llamó o la reanudó, pero si await_suspend() del awaiter devuelve un handle de otra corutina, el control pasa directamente a esa corutina. Esto no implica ejecución paralela automática: una corutina por sí sola no crea ni un hilo ni un planificador.

co_await utiliza el protocolo awaiter: await_ready() comprueba si el resultado está listo, await_suspend() gestiona la suspensión y await_resume() proporciona el resultado. No todos los usos de co_await dejan realmente suspendida la corutina. co_yield value espera el resultado de promise.yield_value(value) sin aplicar await_transform del objeto promise. En cambio, si se escribe explícitamente co_await promise.yield_value(value), se usa await_transform si el tipo promise lo proporciona. Por tanto, la sustitución puede cambiar el comportamiento o provocar un error de compilación. co_return termina el cuerpo de la corutina, en lugar de pasar un valor directamente a quien la llamó.

El tipo promise, disponible normalmente como promise_type del tipo de retorno, controla, entre otras cosas, el objeto de resultado, la suspensión inicial y final, la finalización y el tratamiento de excepciones. <coroutine> proporciona std::coroutine_handle y std::suspend_always. Un handle no gestiona por sí solo el ciclo de vida del estado: la responsabilidad de destruirlo debe ser explícita.

En el ejemplo, Task es un propietario que no se puede copiar ni mover. initial_suspend() retrasa la ejecución del cuerpo, y final_suspend() conserva el estado para que lo destruya el destructor. El std::suspend_always que se usa en el ejemplo no transfiere el control directamente a otra corutina. Dos reanudaciones imprimen 1 y 2; la tercera no hace nada debido a done(). Reanudar una corutina terminada o no suspendida provoca un comportamiento indefinido. Si el estado de la corutina ya se ha destruido, intentar reanudarla mediante un handle a ese estado también provoca un comportamiento indefinido. En cambio, restablecer ese handle asignándole nullptr es una operación bien definida. Los objetos a los que se accede mediante referencias deben seguir vivos el tiempo suficiente.

Esta entrada se refiere a C++23; la opción del compilador del repositorio no acredita compatibilidad con el entorno de ejecución de producción. El documento proporcionado es un borrador de trabajo en evolución, no una edición definitiva de C++23. El ejemplo requiere verificación local y llama deliberadamente a std::terminate() si se produce una excepción no controlada.

Ejemplos

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

Resultado

1
2

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