在 C++20 中，协程（Coroutines）支持异步生成器模式，核心是通过 co_yield 暂停执行并产出值，配合自定义的协程返回类型（如 generator<t></t>）实现懒求值、按需生成的迭代器行为。它不是“异步 I/O”意义上的 async/await（那需要 executor 和 awaitable），而是“异步生成”——即调用方可以一边取值、一边让生成逻辑在后台（或分步）计算，不阻塞主线程。

1. 用 std::generator（C++26 草案）或手动实现 generator<t></t>

C++20 标准库并未提供 generator，但 MSVC 和 libc++ 已实验性支持 std::generator（C++26 提案 P2471）。若用 GCC 或需跨平台兼容，推荐手动实现一个轻量 generator<t></t>，重点在于：

• 定义协程返回类型（含 promise_type）
• promise_type::get_return_object() 返回 generator 实例
• promise_type::yield_value(T&& v) 保存当前值并挂起
• generator 自带迭代器接口（begin()/end()），内部用 coroutine_handle 控制恢复

2. 基础同步生成器：斐波那契数列示例

这是理解 co_yield 最直观的例子——每次调用 ++it 触发一次恢复，产出下一个数：

generator<int> fib(int n) {
    int a = 0, b = 1;
    co_yield a;
    if (n <= 1) co_return;
    co_yield b;
    for (int i = 2; i < n; ++i) {
        int next = a + b;
        co_yield next;
        a = b;
        b = next;
    }
}

// 使用：
for (int x : fib(10)) {
    std::cout << x << " "; // 0 1 1 2 3 5 8 13 21 34
}

注意：co_yield 自动调用 promise_type::yield_value 并 suspend；co_return 结束协程。整个过程是同步的（无线程/await），但“按需生成”特性已具备。

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

创建类似纹身的设计，生成独特纹身

3. 真正的异步生成器：结合 awaitable + 定时/IO 操作

要让生成器“异步”，需在 co_yield 前插入可等待操作（例如延迟、网络读取）。关键点：

• 协程函数返回类型必须是 awaitable（如 task<t></t> 或自定义 awaitable）
• co_yield 仍用于产出值，但协程可在 yield 前 co_await sleep_for(...) 等待
• 产出值后协程挂起，控制权交还调度器；下次被 resume 时继续执行下一轮

示例：每秒产出一个递增数字（模拟异步数据流）：

task<void> ticker(generator<int>::push_type push) {
    for (int i = 0; ; ++i) {
        co_await std::experimental::suspend_until(
            std::chrono::steady_clock::now() + 1s);
        co_yield i; // 产出给 push（需 generator 支持 push 模式）
    }
}

⚠️ 注意：标准 generator 是 pull-based（调用方驱动），若要 push-based（生产者驱动+回调），需自己设计 push_type 或用 channel<t></t>（如 libunifex 或 cppcoro）。

4. 实用建议与避坑点

• co_yield 只能在协程函数中使用，且函数返回类型必须有合适的 promise_type
• 避免在 co_yield 后访问已移动或局部销毁的对象（yield 是 suspend，栈帧保留，但局部对象生命周期仍按作用域结束）
• 调试协程较难，建议先写同步版验证逻辑，再加 co_await
• GCC 12+ / Clang 16+ / MSVC 19.30+ 对 C++20 协程支持较完整；编译需加 -std=c++20 -fcoroutines（GCC/Clang）或 /std:c++20 /await（MSVC）

基本上就这些。用 co_yield 实现生成器本质是“用户态协作式迭代”，是否“异步”取决于你是否在里面 co_await 了真正异步的操作。它不复杂但容易忽略 promise_type 的细节和生命周期管理。