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

CKTIS / C++

std::suspend_never — esperar sin suspender una corrutina

std::suspend_never de <coroutine> es un awaiter sencillo que no suspende una corrutina ni produce ningún valor. Permite especificar el inicio o la finalización inmediata de una corrutina; al finalizar, hay que prestar atención a la duración de vida de su estado.

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

Sintaxis

#include <coroutine>
co_await std::suspend_never{};

std::suspend_never es un tipo de <coroutine> cuyos objetos pueden actuar directamente como awaiters de co_await. No suspende la corrutina ni produce ningún valor: el tipo del resultado es void. En cambio, std::suspend_always, cuando se usa directamente como awaiter, siempre suspende la corrutina.

await_ready() devuelve true, por lo que el protocolo de espera omite await_suspend(std::coroutine_handle<>) y llama a await_resume(). Las dos últimas funciones no hacen nada y devuelven void; las tres son constexpr, const y noexcept. Esto evita la suspensión en este punto concreto, no durante toda la corrutina. Un await_transform personalizado del objeto promise puede cambiar cómo se interpreta el operando de co_await.

Las expresiones co_await implícitas de initial_suspend() y final_suspend() omiten await_transform, pero aun así pueden seleccionar un operator co_await sobrecargado que proporcione un awaiter que suspenda la corrutina. Por tanto, el tipo de retorno por sí solo no garantiza que no haya suspensión. Si el objeto std::suspend_never devuelto por initial_suspend() actúa él mismo como awaiter, la ejecución pasa directamente al cuerpo de la corrutina. Si el objeto devuelto por final_suspend() actúa él mismo como awaiter, no hay suspensión final y el estado de la corrutina se destruye al completarse. Cualquier handle conservado que apunte a ese estado queda colgante; después no se debe llamar a resume(), done() ni destroy() a través de él.

En el ejemplo, immediate_task no almacena ningún handle. run() realiza las dos impresiones antes de volver a main(), y su estado se limpia automáticamente. La entrada se refiere a C++23; el sitio citado contiene un borrador de la norma en evolución, no una publicación inmutable de C++23. No se ha acreditado su ejecución en un entorno de producción.

Ejemplos

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

struct immediate_task {
    struct promise_type {
        immediate_task get_return_object() noexcept { return {}; }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() noexcept {}
        void unhandled_exception() noexcept { std::terminate(); }
    };
};

immediate_task run() {
    std::cout << "before\n";
    co_await std::suspend_never{};
    std::cout << "after\n";
    co_return;
}

int main() {
    run();
    std::cout << "returned\n";
}

Resultado

before
after
returned

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