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

CKTIS / C++

co_await — aguardar numa coroutine

A expressão co_await utiliza o protocolo awaiter para suspender opcionalmente uma coroutine e obter depois um resultado. Não inicia, por si só, uma thread nem fornece escalonamento; a implementação utilizada tem de tratar da retoma.

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

Sintaxe

co_await cast-expression

co_await expression assinala um possível ponto de suspensão de uma coroutine, não uma espera bloqueante de uma thread. Incluir uma expressão deste tipo no corpo de uma função torna-a uma coroutine. O tipo do objeto promise é determinado através de std::coroutine_traits, que tem de fornecer um promise_type adequado para o tipo de retorno e os tipos dos parâmetros da coroutine (incluindo o parâmetro de objeto no caso de uma função membro não estática). O próprio tipo de retorno não precisa de ter um promise_type aninhado. O operador não cria, por si só, uma thread nem um escalonador.

Num co_await explícito, se a pesquisa de await_transform no tipo do objeto promise encontrar uma declaração, o awaitable é o resultado da chamada a await_transform nesse objeto, com o operando como argumento. Caso contrário, o awaitable é o operando original. Se a resolução de sobrecargas selecionar um operator co_await para o awaitable, o resultado da chamada é utilizado como awaiter. Só quando o conjunto de candidatos a operator co_await está vazio se utiliza como awaiter o próprio awaitable, já transformado se tiver havido transformação. Se o conjunto não estiver vazio, mas não contiver nenhuma função viável, a expressão co_await é malformada. O awaiter fornece await_ready(), await_suspend(h) e await_resume(). A expressão tem o tipo e a categoria de valor do resultado de await_resume().

O resultado de await_ready() é convertido contextualmente para bool. Se a conversão produzir true, a coroutine não é suspensa. Isto inclui o caso em que o resultado é um objeto de um tipo de classe cujo explicit operator bool() devolve true. Se a conversão produzir false, a coroutine é suspensa e é chamado await_suspend(h). Se o tipo de retorno de await_suspend for void, o regresso da chamada não leva, por si só, o mecanismo de co_await a retomar a coroutine. No entanto, await_suspend pode retomá-la diretamente ou fazer com que outra thread a retome, mesmo antes de a chamada terminar. Um resultado de tipo bool com o valor false retoma imediatamente a coroutine; devolver um handle de coroutine transfere a execução para a coroutine indicada. await_resume() fornece o resultado quando a execução prossegue.

O exemplo utiliza std::suspend_always: run() escreve start e devolve o controlo; resume() permite-lhe escrever resumed. final_suspend() deixa a frame suspensa para que o destrutor de Task a possa libertar. Nunca retome uma coroutine no seu ponto de suspensão final; os objetos utilizados após a retoma têm de continuar vivos.

Esta entrada diz respeito a C++23; o site indicado publica um rascunho em evolução, não um texto C++23 fixo. A compatibilidade com o ambiente de execução de produção não está atestada.

Exemplos

#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

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