c++20协程如何实现一个惰性求值的生成器(generator)？ (co_yield用法)_技术教程

co_yield是协程挂起点而非返回语句，它产出值并挂起协程，恢复后从下一行继续执行；必须在协程函数中使用，返回类型需满足generator要求，且需手动实现promise_type、迭代器和容器包装。

co_yield 是协程挂起点，不是返回值语句

很多人第一次写 co_yield 时会误以为它像 return 一样结束协程，其实它只是把值“产出”并挂起协程，下次恢复时从下一行继续执行。生成器的生命周期由调用方控制，协程函数体可能被反复恢复多次。

关键点：

co_yield 只能在协程函数（含 co_await、co_yield 或 co_return 的函数）中使用，且返回类型必须是满足 std::generator 要求的类（如自定义 generator）
不能在普通函数或 lambda 中用 co_yield
每次 co_yield expr 后，协程状态保存，expr 被拷贝或移动到生成器内部缓冲区（取决于 promise 类型实现）

手动实现 generator 需要三部分：promise_type、迭代器、容器包装

标准库 C++20 没有内置 std::generator（GCC 13/Clang 16+ 有实验性支持但不跨平台），所以得自己搭骨架。核心是定义一个 generator 类，它持有 coroutine

_handle，而 promise_type 决定 co_yield 怎么存值、怎么暂停。

最小可行结构示例（省略异常处理和移动语义）：

template 
class generator {
public:
    struct promise_type {
        T current_value_;
        generator get_return_object() { return generator{handle_type::from_promise(*this)}; }
        suspend_always initial_suspend() { return {}; }
        suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() { std::terminate(); }
        void return_void() {}
        suspend_always yield_value(T&& value) {
            current_value_ = std::move(value);
            return {};
        }
        // 注意：这里 yield_value 返回 suspend_always，表示每次 co_yield 后必挂起
    };

    using handle_type = std::coroutine_handle
    handle_type coro_;

    explicit generator(handle_type h) : coro_(h) {}
    generator(generator&& other) noexcept : coro_(other.coro_) { other.coro_ = nullptr; }
    ~generator() { if (coro_) coro_.destroy(); }

    class iterator {
        handle_type h_;
    public:
        iterator(handle_type h) : h_(h) {}
        T& operator*() { return h_.promise().current_value_; }
        iterator& operator++() {
            h_.resume();
            if (!h_.done()) return *this;
            h_ = nullptr;
            return *this;
        }
        bool operator!=(const iterator&) const { return h_ != nullptr && !h_.done(); }
    };

    iterator begin() {
        if (coro_) coro_.resume();
        return iterator{coro_};
    }
    iterator end() { return iterator{nullptr}; }
};

使用 co_yield 写生成器函数时，注意循环变量生命周期

常见陷阱：在 for 循环里 co_yield 局部变量地址（比如 co_yield &i），协程挂起后局部变量已析构，后续解引用就是未定义行为。

正确做法：

只 co_yield 值类型（int、std::string 等），让 promise 的 yield_value 移动或拷贝
若需返回对象引用，必须确保该对象在协程整个生命周期内有效（例如 static 变量、外部传入的 long-lived 容器元素）
避免在 co_yield 表达式中隐式构造临时对象并取其引用

错误示例：

generator bad_range(int n) {
    for (int i = 0; i < n; ++i) {
        co_yield i; // ✅ OK：i 是值，被拷贝
    }
}

generator dangerous() {
    std::string s = "hello";
    co_yield s; // ❌ 危险：s 在协程挂起后就销毁了
}

惰性求值真正生效的前提是：不提前触发 resume

生成器对象构造出来时，协程只走到 initial_suspend（我们设为 suspend_always），函数体尚未执行。只有调用 begin() 或显式 resume() 才开始运行到第一个 co_yield。

这意味着你可以链式组合、过滤、延迟启动：

把 generator g = range(1000000); 不会立刻计算百万个数
配合 filter 和 take 包装器，可以只跑前几个元素就停
注意：每个 co_yield 后协程挂起，但 promise 对象（含 current_value_）仍驻留在堆上（由 coroutine_handle 管理），内存开销比纯函数调用略高

真正容易被忽略的是：如果你忘了在 iterator::operator++ 里检查 h_.done()，就可能对已结束协程调用 resume()，导致崩溃或静默失败。