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

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.

Fontes