CKTIS / C++
co_return — concluir uma coroutine
co_return termina a execução do corpo de uma coroutine e entrega o resultado ao objeto promise, em vez de o devolver diretamente como faria um return normal. Em seguida, a coroutine prossegue para final_suspend(); o tempo de vida do seu estado depende do mecanismo de gestão da coroutine.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
co_return;
co_return expression;
co_return braced-init-list;co_return assinala a conclusão de uma coroutine. A sua simples presença faz com que uma função seja uma coroutine, mesmo sem co_await ou co_yield. O objeto devolvido pela chamada da função provém de promise.get_return_object(); o operando de co_return não tem de ser do tipo de retorno da função.
Para uma expressão de tipo diferente de void ou uma lista de inicialização entre chavetas, é chamado promise.return_value(...). co_return; chama promise.return_void(). Com um operando de tipo void, a expressão é primeiro avaliada e, em seguida, é chamado return_void(). Estas chamadas têm de produzir um resultado do tipo void.
O controlo prossegue então para final_suspend(). A conclusão do corpo não significa que o estado da coroutine seja automaticamente destruído. No exemplo, initial_suspend() permite que o corpo seja executado imediatamente, return_value(int) armazena 42 e final_suspend() preserva o estado para consulta. O destrutor de Result liberta-o através de destroy(); é proibido copiar o proprietário.
O corpo de uma coroutine não pode conter um return normal. Em C++23, chegar ao fim do corpo equivale a executar co_return; se o tipo do objeto promise tiver um membro com o nome return_void. Se esse membro existir mas a chamada implícita a promise.return_void() for malformada, o programa é malformado. Se o tipo do objeto promise não tiver nenhum membro com esse nome, chegar ao fim do corpo causa comportamento indefinido. Esta entrada diz respeito a C++23; o site indicado contém um projeto de norma em evolução, não um texto C++23 congelado.
Exemplos
#include <coroutine>
#include <exception>
#include <iostream>
struct Result {
struct promise_type;
using Handle = std::coroutine_handle<promise_type>;
struct promise_type {
int value = 0;
Result get_return_object() {
return Result{Handle::from_promise(*this)};
}
std::suspend_never initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_value(int n) noexcept { value = n; }
void unhandled_exception() noexcept { std::terminate(); }
};
Handle handle;
explicit Result(Handle h) noexcept : handle(h) {}
Result(const Result&) = delete;
Result& operator=(const Result&) = delete;
~Result() { handle.destroy(); }
int value() const { return handle.promise().value; }
};
Result answer() {
co_return 42;
}
int main() {
auto result = answer();
std::cout << result.value() << '\n';
}
Resultado
42
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.