c++怎么使用C++20的协程（coroutine）_c++20协程机制与使用示例解析_技术教程

c++kquote>C++20引入协程支持，通过co_await、co_yield、co_return实现异步编程与生成器；核心组件包括promise_type、coroutine_handle和awaiter，需手动管理生命周期并结合编译器支持使用。

C++20 引入了原生的协程支持，这是一种语言级别的特性，允许函数在执行过程中暂停并恢复，而无需阻塞线程。这为异步编程、生成器、状态机等场景提供了更简洁、高效的实现方式。要使用 C++20 协程，需要理解其核心机制和基本组件。

协程的基本概念与关键组件

一个 C++20 协程函数必须包含以下关键字之一：co_await、co_yield 或 co_return。一旦函数中出现这些关键字，编译器就会将其识别为协程，并生成相应的状态机代码。

协程的核心依赖于三个关键部分：

promise_type：定义协程内部行为，如返回值如何处理、异常如何传播、初始/最终挂起点等。
handle（coroutine_handle）：用于手动控制协程的生命周期，比如恢复（resume）或销毁（destroy）。
awaiter：由 co_await 表达式调用的对象，决定是否挂起、何时恢复。

简单示例：实现一个同步生成器

下面是一个使用 co_yield 实现的整数序列生成器，模拟 Python 中的生成器行为。

#include 
#include 
#include 

struct Generator {
    struct promise_type {
        int current_value;

        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        Generator get_return_object() {
            return Generator(std::coroutine_handle::from_promise(*this));
        }

        void return_void() {}

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

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

    std::coroutine_handle handle;

    explicit Generator(std::coroutine_handle h) : handle(h) {}

    ~Generator() {
        if (handle) handle.destroy();
    }

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

    bool move_next() {
        if (!handle.done())
            handle.resume();
        return !handle.done();
    }
};

Generator range(int from, int to) {
    for (int i = from; i < to; ++i) {
        co_yield i;
    }
}

int main() {
    auto gen = range(1, 6);
    while (gen.move_next()) {
        std::cout << gen.value() << ' ';
    }
    // 输出: 1 2 3 4 5
}

这个例子中，range 是一个协程函数，每次调用 co_yield 时都会暂停，并保存当前状态。外部通过 move_next() 恢复执行，直到完成。

异步任务示例：使用 co_await 模拟延迟操作

协程也适用于异步任务建模。虽然 C++20 标准库未提供完整的异步框架（如 awaitable 网络 I/O），但我们可以自定义简单的 awaiter 来演示机制。

#include 
#include 
#include 
#include 

struct Awaiter {
    bool await_ready() { return false; } // 总是挂起

    void await_suspend(std::coroutine_handle<> h) {
        std::thread([h]() mutable {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            h.resume(); // 1秒后恢复
        }).detach();
    }

    void await_resume() {}
};

struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
};

Task async_work() {
    std::cout << "开始异步工作...\n";
    co_await Awaiter{};
    std::cout << "工作完成!\n";
}

int main() {
    async_work();
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待完成
}

这里 co_await Awaiter{} 使协程挂起，新线程延时 1 秒后调用 handle.resume() 恢复协程继续执行。