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

CKTIS / C++

std::suspend_always — suspensión incondicional de una corrutina

std::suspend_always de <coroutine> es un awaitable sencillo que suspende una corrutina sin producir un valor. No programa su reanudación: el código que la gestiona debe conservar un handle y reanudar o destruir la corrutina suspendida.

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

Sintaxis

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

std::suspend_always de <coroutine> implementa el protocolo awaiter. await_ready() devuelve false, await_suspend(std::coroutine_handle<>) no hace nada y devuelve void, y await_resume() tampoco hace nada y devuelve void. Los tres métodos son constexpr, const y noexcept. En cambio, std::suspend_never devuelve true desde await_ready().

Cuando este objeto es el awaiter efectivo, co_await std::suspend_always{}; suspende la corrutina y devuelve el control a quien la llamó o la reanuda. Tras reanudarla, la ejecución continúa sin obtener ningún valor. El tipo no bloquea el hilo, no inicia un temporizador ni programa la reanudación. await_transform de la promesa o un operator co_await sobrecargado pueden cambiar el awaiter seleccionado.

En el ejemplo, initial_suspend() retrasa la ejecución del cuerpo hasta el primer resume(). La primera reanudación imprime A y llega a la suspensión explícita; la segunda imprime B y llega a final_suspend(). El destructor del propietario destruye el frame conservado. Se prohíbe copiar el propietario para evitar una doble destrucción.

No reanudes una corrutina en su punto de suspensión final ni uses un handle después de que se haya destruido su frame. El resume() del ejemplo comprueba done() antes de reanudar. Esta entrada está destinada a compilarse con -std=c++23; el documento proporcionado es un borrador en evolución, no una publicación definitiva de C++23. La compatibilidad del compilador y del entorno de ejecución de producción debe verificarse localmente.

Ejemplos

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

struct Task {
    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() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;

    explicit Task(std::coroutine_handle<promise_type> h) : handle(h) {}
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;
    ~Task() { handle.destroy(); }

    void resume() {
        if (!handle.done()) handle.resume();
    }
};

Task work() {
    std::cout << "A\n";
    co_await std::suspend_always{};
    std::cout << "B\n";
}

int main() {
    auto task = work();
    std::cout << "created\n";
    task.resume();
    std::cout << "paused\n";
    task.resume();
    std::cout << "finished\n";
}

Resultado

created
A
paused
B
finished

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