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

CKTIS / C++

Corrotinas

Uma corrotina pode suspender a execução e retomá-la mais tarde, preservando o estado de que necessita. As palavras-chave co_await, co_yield e co_return cooperam com um tipo promise e um handle de corrotina; não iniciam automaticamente uma thread ou um escalonador.

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

Sintaxe

co_await expression; co_yield expression; co_return [expression];

Uma corrotina é uma função cujo corpo contém co_await, co_yield ou co_return. Quando suspende a execução, preserva o estado necessário para continuar. O controlo pode regressar a quem a chamou ou retomou, mas, se await_suspend() do awaiter devolver um handle para outra corrotina, o controlo passa diretamente para essa corrotina. Isto não implica execução paralela automática: uma corrotina, por si só, não cria uma thread nem um escalonador.

co_await utiliza o protocolo awaiter: await_ready() verifica se o resultado está pronto, await_suspend() trata da suspensão e await_resume() fornece o resultado. Nem todos os usos de co_await deixam efetivamente a corrotina suspensa. co_yield value aguarda o resultado de promise.yield_value(value) sem aplicar await_transform do objeto promise. Em contrapartida, ao escrever explicitamente co_await promise.yield_value(value), é utilizado await_transform se o tipo promise o disponibilizar. A substituição pode, portanto, alterar o comportamento ou provocar um erro de compilação. co_return termina o corpo da corrotina, em vez de passar um valor diretamente a quem a chamou.

O tipo promise, normalmente disponível como promise_type do tipo de retorno, controla, entre outras coisas, o objeto de resultado, a suspensão inicial e final, a conclusão e o tratamento de exceções. <coroutine> fornece std::coroutine_handle e std::suspend_always. Um handle não gere, por si só, o tempo de vida do estado: a responsabilidade pela sua destruição tem de ser explícita.

No exemplo, Task é um proprietário que não pode ser copiado nem movido. initial_suspend() adia a execução do corpo e final_suspend() conserva o estado para ser destruído pelo destrutor. O std::suspend_always utilizado no exemplo não transfere o controlo diretamente para outra corrotina. Duas retomas imprimem 1 e 2; a terceira não faz nada devido a done(). Retomar uma corrotina terminada ou não suspensa causa comportamento indefinido. Depois de destruído o estado da corrotina, tentar retomá-la através de um handle para esse estado também causa comportamento indefinido. Já repor esse handle atribuindo-lhe nullptr é uma operação bem definida. Os objetos referenciados têm de permanecer vivos durante tempo suficiente.

Esta entrada destina-se a C++23; a opção do compilador no repositório não atesta o suporte no ambiente de execução de produção. O documento fornecido é um rascunho de trabalho em evolução, não uma edição definitiva de C++23. O exemplo requer verificação local e chama deliberadamente std::terminate() se ocorrer uma exceção não tratada.

Exemplos

#include <coroutine>
#include <exception>
#include <iostream>

class Task {
public:
    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() noexcept {}
        void unhandled_exception() noexcept { std::terminate(); }
    };

    using Handle = std::coroutine_handle<promise_type>;
    explicit Task(Handle handle) noexcept : handle_(handle) {}
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;
    ~Task() { handle_.destroy(); }

    void resume() {
        if (!handle_.done()) {
            handle_.resume();
        }
    }

private:
    Handle handle_;
};

Task steps() {
    std::cout << "1\n";
    co_await std::suspend_always{};
    std::cout << "2\n";
    co_return;
}

int main() {
    auto task = steps();
    task.resume();
    task.resume();
    task.resume();
}

Resultado

1
2

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