co_yield 关键字与生成器模式 ​

什么是 co_yield ​

co_yield 是 C++20 协程中用于"产出一个值并挂起"的关键字。当协程执行到 co_yield expr 时,它会把 expr 的值传递给调用者,然后挂起自己。调用者取走这个值后,可以在合适的时候恢复协程,让它继续执行并产出下一个值。

co_yield expr 本质上是 co_await promise.yield_value(expr) 的语法糖。也就是说,co_yield 先调用承诺对象的 yield_value() 方法保存值,然后根据 yield_value() 的返回值决定是否挂起。

生成器模式 ​

生成器(Generator)是 co_yield 最典型的应用场景:一个协程函数不断地用 co_yield 产出值,调用者每次需要一个值就恢复协程拿一个。这种模式的好处是惰性求值——值是按需产生的,不会一次性全部计算出来。

生成器适合用于:

  • 无限序列(斐波那契数列、自然数序列等)
  • 大数据集的逐项处理(避免一次性加载到内存)
  • 管道式的数据变换

基本示例 ​

cpp
#include <coroutine>
#include <iostream>
#include <string>
#include <vector>
#include <cstdint>

// ============================
// Generator 类型定义(C++20 手写版)
// ============================

template<typename T>
struct Generator {
    struct promise_type {
        T current_value;  // 保存 co_yield 产出的值

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

        // 惰性启动:创建后不立即执行
        std::suspend_always initial_suspend() noexcept { return {}; }

        // 结束后挂起:让调用者有机会检查 done() 状态
        std::suspend_always final_suspend() noexcept { return {}; }

        // co_yield 调用此方法保存值,然后挂起
        std::suspend_always yield_value(T value) {
            current_value = std::move(value);
            return {};  // 返回 suspend_always,协程挂起
        }

        void return_void() {}

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

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

    explicit Generator(handle_type h) : handle_(h) {}

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

    // 禁止复制
    Generator(const Generator&) = delete;
    Generator& operator=(const Generator&) = delete;

    // 允许移动
    Generator(Generator&& other) noexcept : handle_(other.handle_) {
        other.handle_ = nullptr;
    }

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

    // 获取下一个值,返回 false 表示序列结束
    bool next() {
        if (handle_ && !handle_.done()) {
            handle_.resume();
            return !handle_.done();
        }
        return false;
    }

    // 获取当前产出的值
    const T& value() const {
        return handle_.promise().current_value;
    }

    // ---- 支持范围 for 循环的迭代器 ----

    struct iterator {
        handle_type handle_;
        bool done_;

        iterator() : handle_(nullptr), done_(true) {}
        explicit iterator(handle_type h) : handle_(h), done_(false) {
            if (handle_) {
                handle_.resume();
                done_ = handle_.done();
            }
        }

        iterator& operator++() {
            if (handle_) {
                handle_.resume();
                done_ = handle_.done();
            }
            return *this;
        }

        const T& operator*() const {
            return handle_.promise().current_value;
        }

        bool operator!=(const iterator& other) const {
            return done_ != other.done_;
        }
    };

    iterator begin() { return iterator{handle_}; }
    iterator end() { return iterator{}; }
};

// ============================
// 示例1:简单的整数范围生成器
// ============================

Generator<int> range(int start, int end, int step = 1) {
    for (int i = start; i < end; i += step) {
        co_yield i;  // 产出当前值,挂起
    }
    // 循环结束,隐式 co_return
}

void range_demo() {
    std::cout << "range(1, 6): ";
    auto gen = range(1, 6);
    while (gen.next()) {
        std::cout << gen.value() << " ";
    }
    std::cout << std::endl;

    // 使用范围 for 循环
    std::cout << "range(0, 10, 2): ";
    for (int v : range(0, 10, 2)) {
        std::cout << v << " ";
    }
    std::cout << std::endl;
}

// ============================
// 示例2:斐波那契数列(无限序列)
// ============================

Generator<std::uint64_t> fibonacci() {
    std::uint64_t a = 0, b = 1;
    while (true) {          // 无限循环——惰性求值,不会真的无限执行
        co_yield a;         // 产出当前值
        auto next = a + b;
        a = b;
        b = next;
    }
}

void fibonacci_demo() {
    std::cout << "前 12 个斐波那契数: ";
    auto fib = fibonacci();
    for (int i = 0; i < 12 && fib.next(); ++i) {
        std::cout << fib.value() << " ";
    }
    std::cout << std::endl;
}

// ============================
// 示例3:字符串逐字符生成
// ============================

Generator<char> chars(const std::string& str) {
    for (char c : str) {
        co_yield c;
    }
}

void string_generator_demo() {
    std::cout << "逐字符: ";
    for (char c : chars("Hello C++20")) {
        std::cout << "[" << c << "] ";
    }
    std::cout << std::endl;
}

// ============================
// 示例4:过滤生成器(管道模式)
// ============================

// 从另一个生成器中过滤出满足条件的元素
Generator<int> filter_even(Generator<int> source) {
    while (source.next()) {
        if (source.value() % 2 == 0) {
            co_yield source.value();
        }
    }
}

// 对生成器的每个元素做变换
Generator<int> transform_square(Generator<int> source) {
    while (source.next()) {
        co_yield source.value() * source.value();
    }
}

void pipeline_demo() {
    // 管道:range -> filter_even -> transform_square
    std::cout << "1-10 的偶数的平方: ";
    auto result = transform_square(filter_even(range(1, 11)));
    while (result.next()) {
        std::cout << result.value() << " ";
    }
    std::cout << std::endl;
    // 输出: 4 16 36 64 100
}

// ============================
// 示例5:从容器生成元素
// ============================

template<typename Container>
Generator<typename Container::value_type> from_container(Container cont) {
    for (auto& elem : cont) {
        co_yield elem;
    }
}

void container_demo() {
    std::vector<std::string> names{"Alice", "Bob", "Charlie"};

    std::cout << "容器元素: ";
    for (const auto& name : from_container(names)) {
        std::cout << name << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::cout << "=== 整数范围 ===" << std::endl;
    range_demo();

    std::cout << "\n=== 斐波那契 ===" << std::endl;
    fibonacci_demo();

    std::cout << "\n=== 字符串 ===" << std::endl;
    string_generator_demo();

    std::cout << "\n=== 管道过滤 ===" << std::endl;
    pipeline_demo();

    std::cout << "\n=== 容器 ===" << std::endl;
    container_demo();

    return 0;
}

co_yield 的工作原理 ​

co_yield expr 被编译器转换为:

cpp
co_await promise.yield_value(expr);

执行过程:

  1. 调用 promise.yield_value(expr),把值保存到承诺对象中
  2. yield_value() 返回一个 Awaiter(通常是 std::suspend_always)
  3. 对这个 Awaiter 执行 co_await 的标准流程
  4. 如果 Awaiter 要求挂起,协程就挂起
  5. 调用者通过承诺对象拿到保存的值
  6. 调用者恢复协程,协程从 co_yield 之后继续执行

C++20 手写 Generator vs C++23 std::generator ​

方面C++20 手写C++23 std::generator
代码量多(需要完整实现 promise_type 和迭代器)少(直接用)
头文件<coroutine><generator>
ranges 支持需要自己实现原生支持 input_range
递归生成器需要手动实现内置支持(co_yield std::ranges::elements_of)
异常安全自己负责标准保证
内存分配器自己实现支持自定义分配器

C++23 的 std::generator 用法:

cpp
// C++23
#include <generator>

std::generator<int> range(int start, int end) {
    for (int i = start; i < end; ++i) {
        co_yield i;
    }
}

// 直接用于范围 for 和 ranges 管道
for (int v : range(1, 10) | std::views::take(5)) {
    std::cout << v << " ";
}

适用场景 ​

  • 惰性序列生成(无限数列、大文件逐行读取)
  • 数据管道和变换链
  • 状态机的状态序列输出
  • 树或图的遍历(用 co_yield 产出每个节点)
  • 测试数据生成

常见问题 ​

co_yield 可以产出引用吗?

可以,但需要注意生命周期。如果 yield_value 保存的是引用,被引用的对象在协程恢复前不能被销毁。C++23 的 std::generator 支持引用语义。

无限生成器不会内存泄漏吗?

不会,只要正确销毁 Generator 对象(析构时 handle_.destroy())。无限循环只是意味着协程可以无限次恢复,但它不会自己运行——每次都要调用者主动恢复。

co_yield 和 co_return 可以在同一个协程中使用吗?

可以。co_return 表示协程结束。在生成器中,co_return 之后不能再产出值。如果协程的 promise_type 定义了 return_void(),协程末尾的 co_return; 可以省略。

yield_value 可以返回 suspend_never 吗?

可以,但这样 co_yield 就不会挂起协程了——值被保存后立即继续执行。这在大多数生成器场景下没有意义,但在某些特殊场景(如批量产出)可能有用。

注意事项 ​

  • co_yield 只能在协程函数体内使用
  • co_yield expr 等价于 co_await promise.yield_value(expr)
  • 生成器协程的 initial_suspend() 通常返回 suspend_always(惰性启动)
  • 生成器协程的 final_suspend() 必须返回 suspend_always(否则协程自动销毁,调用者无法检查 done())
  • C++20 没有标准的 Generator 类型,需要自己实现或用第三方库
  • C++23 提供了 std::generator,推荐优先使用
  • 注意协程帧的生命周期管理——Generator 对象析构时要销毁协程帧

编译器支持情况 ​

特性GCCClangMSVC
co_yield(C++20)10.014.019.28 (VS 2019 16.8)
std::generator(C++23)14.018.0(部分)19.35 (VS 2022 17.5)

总结 ​

co_yield 是 C++20 协程中实现生成器模式的核心关键字。它让协程可以"产出一个值并挂起",调用者取走值后再恢复协程产出下一个值。这种模式天然支持惰性求值——无限序列也不会占用无限内存,因为值是按需产生的。co_yield expr 的本质是 co_await promise.yield_value(expr),所以它的挂起行为完全由 yield_value() 的返回值控制。C++20 需要手写 Generator 类型(包括 promise_type 和迭代器),C++23 提供了标准的 std::generator 大幅简化了使用。生成器还可以组合成管道——一个生成器的输出作为另一个生成器的输入,实现数据的流式处理。