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 产出值,调用者每次需要一个值就恢复协程拿一个。这种模式的好处是惰性求值——值是按需产生的,不会一次性全部计算出来。
生成器适合用于:
- 无限序列(斐波那契数列、自然数序列等)
- 大数据集的逐项处理(避免一次性加载到内存)
- 管道式的数据变换
基本示例
#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 被编译器转换为:
co_await promise.yield_value(expr);执行过程:
- 调用
promise.yield_value(expr),把值保存到承诺对象中 yield_value()返回一个 Awaiter(通常是std::suspend_always)- 对这个 Awaiter 执行
co_await的标准流程 - 如果 Awaiter 要求挂起,协程就挂起
- 调用者通过承诺对象拿到保存的值
- 调用者恢复协程,协程从
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 用法:
// 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 对象析构时要销毁协程帧
编译器支持情况
| 特性 | GCC | Clang | MSVC |
|---|---|---|---|
co_yield(C++20) | 10.0 | 14.0 | 19.28 (VS 2019 16.8) |
std::generator(C++23) | 14.0 | 18.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 大幅简化了使用。生成器还可以组合成管道——一个生成器的输出作为另一个生成器的输入,实现数据的流式处理。