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-expressionco_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.