c++怎么使用C++20的coroutines协程_c++ C++20 coroutines使用方法

C++20协程基于co_await、co_yield、co_return关键字，通过promise_type和状态机实现生成器或异步操作，需编译器支持并配合自定义awaiter与句柄管理。

要使用C++20的协程（coroutines），你需要了解三个核心概念：可暂停的函数（即协程）、promise type 和 awaiter。C++20协程不是像Go或Python那样“开箱即用”的轻量级线程，而是提供底层机制，需要你配合自定义类型来实现具体行为。

1. 协程的基本特征

一个函数是协程，只要它内部使用了以下关键字之一：

• co_await：挂起执行，等待某个操作完成
• co_yield：暂停并返回一个值（类似生成器）
• co_return：结束协程，并将结果传回

编译器会把包含这些关键字的函数转换为状态机。

2. 最简单的协程例子：无限生成器

下面是一个使用 co_yield 实现的简单整数生成器：

立即学习“C++免费学习笔记（深入）”；

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

struct Generator {
    struct promise_type {
        int current_value;

        Generator get_return_object() {
            return Generator(std::coroutine_handle<promise_type>::from_promise(*this));
        }

        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }

        void return_void() {}

        std::suspend_always yield_value(int value) {
            current_value = value;
            return {};
        }

        void unhandled_exception() {
            std::terminate();
        }
    };

    using handle_type = std::coroutine_handle<promise_type>;
    handle_type h_;

    explicit Generator(handle_type h) : h_(h) {}
    ~Generator() { if (h_) h_.destroy(); }

    // 移动构造
    Generator(Generator&& other) noexcept : h_(other.h_) {
        other.h_ = nullptr;
    }

    Generator& operator=(Generator&& other) noexcept {
        if (this != &other) {
            if (h_) h_.destroy();
            h_ = other.h_;
            other.h_ = nullptr;
        }
        return *this;
    }

    // 删除拷贝
    Generator(const Generator&) = delete;
    Generator& operator=(const Generator&) = delete;

    int value() const { return h_.promise().current_value; }

    bool move_next() {
        if (!h_ || h_.done()) return false;
        h_.resume();
        return !h_.done();
    }
};

Generator int_sequence(int start = 0, int step = 1) {
    auto value = start;
    while (true) {
        co_yield value;
        value += step;
    }
}

int main() {
    auto gen = int_sequence(10, 5);

    for (int i = 0; i < 5; ++i) {
        if (gen.move_next()) {
            std::cout << "Value: " << gen.value() << '\n';
        }
    }

    return 0;
}

输出：

AssemblyAI

转录和理解语音的AI模型

下载

Value: 10
Value: 15
Value: 20
Value: 25
Value: 30

3. 关键组件说明

promise_type 是协程逻辑的核心，它控制协程的生命周期和行为：

• get_return_object()：协程开始时调用，返回外部使用的对象（如 Generator）
• initial_suspend()：协程启动后是否立即挂起。返回 std::suspend_always 表示挂起，std::suspend_never 表示继续运行
• final_suspend()：协程结束时是否挂起。通常设为 suspend_always 防止自动销毁
• yield_value(T)：处理 co_yield，保存值并决定是否挂起
• return_void() 或 return_value()：处理 co_return
• unhandled_exception()：处理异常

4. 编译和启用C++20协程

确保你的编译器支持C++20协outines：

• g++：至少使用 g++-10，并加上 -std=c++20 和 -fcoroutines（某些版本需要）
• Clang：Clang 14+ 支持较好，同样使用 -std=c++20
• MSVC：Visual Studio 2019 16.11+ 原生支持

例如 g++ 编译命令：

g++ -std=c++20 -fcoroutines -o coroutine_example coroutine_example.cpp

5. 使用 co_await 等待异步操作

你可以定义自己的 awaiter 类型来配合 co_await：

struct simple_awaiter {
    bool await_ready() { return false; } // 返回 true 则不挂起
    void await_suspend(std::coroutine_handle<> h) {
        // 可以安排其他任务，然后手动恢复 h()
        h.resume(); // 立即恢复 —— 实际中可能延迟
    }
    int await_resume() { return 42; }
};

Generator example_with_await() {
    auto val = co_await simple_awaiter{};
    co_return val;
}

co_await 会调用 await_ready、await_suspend、await_resume 来控制挂起与恢复流程。