Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::suspend_never — aguardar sem suspender uma coroutine

std::suspend_never de <coroutine> é um awaiter simples que não suspende uma coroutine nem produz qualquer valor. Permite especificar o início ou a conclusão imediata de uma coroutine; na conclusão, é necessário ter cuidado com o tempo de vida do seu estado.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

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

std::suspend_never é um tipo de <coroutine> cujos objetos podem funcionar diretamente como awaiters de co_await. Não suspende a coroutine nem produz qualquer valor: o tipo do resultado é void. Em contrapartida, std::suspend_always, quando usado diretamente como awaiter, suspende sempre a coroutine.

await_ready() devolve true, pelo que o protocolo de espera omite await_suspend(std::coroutine_handle<>) e chama await_resume(). As duas últimas funções não fazem nada e devolvem void; as três são constexpr, const e noexcept. Isto impede a suspensão neste ponto específico, não ao longo de toda a coroutine. Um await_transform personalizado do objeto promise pode alterar a interpretação do operando de co_await.

As expressões co_await implícitas de initial_suspend() e final_suspend() ignoram await_transform, mas podem ainda selecionar um operator co_await sobrecarregado que fornece um awaiter capaz de suspender a coroutine. O tipo de retorno, por si só, não garante, portanto, que não haja suspensão. Se o próprio objeto std::suspend_never devolvido por initial_suspend() for usado como awaiter, a execução passa imediatamente para o corpo da coroutine. Se o próprio objeto devolvido por final_suspend() for usado como awaiter, não há suspensão final e o estado da coroutine é destruído quando esta termina. Qualquer handle guardado que refira esse estado fica inválido — não se deve chamar posteriormente resume(), done() ou destroy() através dele.

No exemplo, immediate_task não guarda qualquer handle. run() efetua as duas impressões antes de regressar a main(), e o seu estado é limpo automaticamente. Esta entrada tem como referência C++23; o site indicado disponibiliza um projeto de norma em evolução, não uma publicação C++23 imutável. A execução num ambiente de produção não foi atestada.

Exemplos

#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

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes