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

CKTIS / C++

co_await — esperar en una corrutina

La expresión co_await utiliza el protocolo awaiter para suspender opcionalmente una corrutina y obtener después un resultado. No inicia por sí misma un hilo ni proporciona planificación; la implementación utilizada debe encargarse de reanudarla.

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

Sintaxis

co_await cast-expression

co_await expression marca un posible punto de suspensión de una corrutina, no una espera bloqueante de un hilo. Incluir una expresión así en el cuerpo de una función la convierte en corrutina. El tipo de su objeto promise se obtiene mediante std::coroutine_traits, que debe proporcionar un promise_type adecuado para el tipo de retorno y los tipos de los parámetros de la corrutina (incluido el parámetro de objeto en una función miembro no estática). El propio tipo de retorno no necesita tener un promise_type anidado. El operador no crea por sí mismo ni un hilo ni un planificador.

En un co_await explícito, si la búsqueda de await_transform en el tipo del objeto promise encuentra una declaración, el awaitable es el resultado de llamar a await_transform sobre ese objeto con el operando como argumento. De lo contrario, el awaitable es el operando original. Si la resolución de sobrecargas selecciona un operator co_await para el awaitable, el resultado de la llamada se utiliza como awaiter. Solo si el conjunto de candidatos para operator co_await está vacío se utiliza como awaiter el propio awaitable, ya transformado si se aplicó la transformación. Si el conjunto no está vacío pero no contiene ninguna función viable, la expresión co_await está mal formada. El awaiter proporciona await_ready(), await_suspend(h) y await_resume(). La expresión tiene el tipo y la categoría de valor del resultado de await_resume().

El resultado de await_ready() se convierte contextualmente a bool. Si la conversión da true, la corrutina no se suspende; esto incluye el caso en que el resultado es un objeto de un tipo de clase cuyo explicit operator bool() devuelve true. Si la conversión da false, la corrutina se suspende y se llama a await_suspend(h). Si el tipo de retorno de await_suspend es void, el retorno de la llamada no hace por sí solo que el mecanismo de co_await reanude la corrutina. Sin embargo, await_suspend puede reanudarla directamente o hacer que otro hilo la reanude, incluso antes de que termine la llamada. Un resultado de tipo bool con valor false reanuda la corrutina inmediatamente, y devolver un manejador de corrutina transfiere la ejecución a la corrutina indicada. await_resume() proporciona el resultado cuando continúa la ejecución.

El ejemplo usa std::suspend_always: run() imprime start y devuelve el control; resume() permite que imprima resumed. final_suspend() deja el frame suspendido para que lo libere el destructor de Task. No reanudes nunca una corrutina en su punto de suspensión final; los objetos utilizados tras la reanudación deben seguir existiendo.

Esta entrada se refiere a C++23; el sitio indicado publica un borrador en evolución, no un texto C++23 definitivo. No se certifica la compatibilidad con el entorno de ejecución de producción.

Ejemplos

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

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

    struct promise_type {
        Task get_return_object() {
            return Task{Handle::from_promise(*this)};
        }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() noexcept {}
        void unhandled_exception() noexcept { std::terminate(); }
    };

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

Task run() {
    std::cout << "start\n";
    co_await std::suspend_always{};
    std::cout << "resumed\n";
}

int main() {
    auto task = run();
    std::cout << "caller\n";
    task.handle.resume();
}

Resultado

start
caller
resumed

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