std::generator 协程生成器(C++23)
什么是 std::generator
std::generator 是 C++23 引入的第一个标准库协程类型,定义在 <generator> 头文件中。它让你可以用 co_yield 关键字编写生成序列的协程函数,返回的 generator 对象是一个惰性的、单次遍历的范围(input_range)。
#include <generator>
std::generator<int> count(int from, int to) {
for (int i = from; i <= to; i++) {
co_yield i; // 每次暂停,产出一个值
}
}generator 简化了自定义迭代器的编写——不需要手动管理状态机,编译器会自动处理协程的暂停和恢复。
基本示例
#include <iostream>
#include <generator>
#include <ranges>
#include <vector>
#include <string>
#include <cmath>
// ============================
// 示例1:最简单的生成器
// ============================
std::generator<int> simple_sequence() {
co_yield 1;
co_yield 2;
co_yield 3;
}
void basic_demo() {
std::cout << "简单序列: ";
for (int v : simple_sequence()) {
std::cout << v << " ";
}
std::cout << std::endl; // 1 2 3
}
// ============================
// 示例2:斐波那契数列
// ============================
std::generator<long long> fibonacci() {
long long a = 0, b = 1;
while (true) {
co_yield a;
auto next = a + b;
a = b;
b = next;
}
}
void fibonacci_demo() {
std::cout << "前15个斐波那契数: ";
for (auto f : fibonacci() | std::views::take(15)) {
std::cout << f << " ";
}
std::cout << std::endl;
// 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
}
// ============================
// 示例3:带参数的生成器
// ============================
std::generator<int> range(int start, int end, int step = 1) {
for (int i = start; i < end; i += step) {
co_yield i;
}
}
void param_demo() {
std::cout << "range(0, 10, 2): ";
for (int v : range(0, 10, 2)) {
std::cout << v << " ";
}
std::cout << std::endl; // 0 2 4 6 8
std::cout << "range(5, 15): ";
for (int v : range(5, 15)) {
std::cout << v << " ";
}
std::cout << std::endl; // 5 6 7 8 9 10 11 12 13 14
}
// ============================
// 示例4:无限序列
// ============================
std::generator<int> naturals(int start = 1) {
while (true) {
co_yield start++;
}
}
std::generator<int> primes() {
// 简单的素数生成器
for (int n : naturals(2)) {
bool is_prime = true;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
is_prime = false;
break;
}
}
if (is_prime) {
co_yield n;
}
}
}
void infinite_demo() {
std::cout << "前20个素数: ";
for (auto p : primes() | std::views::take(20)) {
std::cout << p << " ";
}
std::cout << std::endl;
}
// ============================
// 示例5:生成字符串序列
// ============================
std::generator<std::string> words(const std::string& text) {
std::string word;
for (char c : text) {
if (c == ' ' || c == '\n' || c == '\t') {
if (!word.empty()) {
co_yield word;
word.clear();
}
} else {
word += c;
}
}
if (!word.empty()) {
co_yield word;
}
}
void string_demo() {
std::string text = "Hello World This Is C++23 Generator";
std::cout << "单词:" << std::endl;
for (const auto& w : words(text)) {
std::cout << " [" << w << "]" << std::endl;
}
}
// ============================
// 示例6:递归生成器(elements_of)
// ============================
struct TreeNode {
int value;
TreeNode* left = nullptr;
TreeNode* right = nullptr;
};
// 递归中序遍历——用 elements_of 委托给子生成器
std::generator<int> inorder(const TreeNode* node) {
if (!node) co_return;
// co_yield elements_of 会展开子生成器的所有元素
co_yield std::ranges::elements_of(inorder(node->left));
co_yield node->value;
co_yield std::ranges::elements_of(inorder(node->right));
}
void tree_demo() {
// 4
// / \
// 2 6
// / \ / \
// 1 3 5 7
TreeNode n1{1}, n3{3}, n5{5}, n7{7};
TreeNode n2{2, &n1, &n3};
TreeNode n6{6, &n5, &n7};
TreeNode root{4, &n2, &n6};
std::cout << "中序遍历: ";
for (int v : inorder(&root)) {
std::cout << v << " ";
}
std::cout << std::endl; // 1 2 3 4 5 6 7
}
// ============================
// 示例7:与 Ranges 管道配合
// ============================
std::generator<int> squares() {
for (int i = 1; ; i++) {
co_yield i * i;
}
}
void pipeline_demo() {
// generator 是 input_range,可以用管道
auto result = squares()
| std::views::filter([](int x) { return x % 2 != 0; }) // 奇数平方
| std::views::take(5);
std::cout << "前5个奇数的平方: ";
for (int v : result) {
std::cout << v << " ";
}
std::cout << std::endl; // 1 9 25 49 81
}
// ============================
// 示例8:生成引用
// ============================
std::generator<const int&> ref_generator(const std::vector<int>& data) {
for (const int& v : data) {
co_yield v; // 产出引用而不是拷贝
}
}
void ref_demo() {
std::vector<int> data = {10, 20, 30};
std::cout << "引用生成: ";
for (int v : ref_generator(data)) {
std::cout << v << " ";
}
std::cout << std::endl;
}
int main() {
std::cout << "=== 简单序列 ===" << std::endl;
basic_demo();
std::cout << "\n=== 斐波那契 ===" << std::endl;
fibonacci_demo();
std::cout << "\n=== 带参数 ===" << std::endl;
param_demo();
std::cout << "\n=== 无限序列 ===" << std::endl;
infinite_demo();
std::cout << "\n=== 字符串 ===" << std::endl;
string_demo();
std::cout << "\n=== 递归树遍历 ===" << std::endl;
tree_demo();
std::cout << "\n=== 管道 ===" << std::endl;
pipeline_demo();
std::cout << "\n=== 引用 ===" << std::endl;
ref_demo();
return 0;
}generator vs 自定义迭代器 vs iota
| 特性 | std::generator | 自定义迭代器 | views::iota |
|---|---|---|---|
| 代码量 | 少(几行协程) | 多(状态机+迭代器类) | 最少(一行) |
| 灵活性 | 高(任意逻辑) | 高(任意逻辑) | 低(只能递增) |
| 范围类别 | input_range | 可以是任意类别 | 看具体配置 |
| 可复制 | 不可复制(move-only) | 取决于实现 | 可复制 |
| 多次遍历 | 不支持 | 取决于实现 | 支持 |
| 递归支持 | 支持(elements_of) | 手动实现 | 不适用 |
std::generator 的模板参数
template<class Ref, class V = void, class Allocator = void>
class generator;| 参数 | 说明 | 示例 |
|---|---|---|
| Ref | co_yield 产出的引用类型 | int(值), const int&(常量引用) |
| V | 值类型(通常自动推导) | 通常省略 |
| Allocator | 协程帧的分配器 | 通常省略(使用默认) |
适用场景
- 惰性生成无限序列(斐波那契、素数等)
- 简化复杂的迭代逻辑(树遍历、图遍历)
- 替代自定义迭代器的复杂实现
- 数据流处理管道
- 分词器、解析器等逐步产出结果的场景
常见问题
generator 可以多次遍历吗?
不可以。std::generator 是 input_range(单次遍历),而且是 move-only 的。每次调用协程函数会创建新的 generator。
generator 的性能如何?
协程的暂停/恢复有一定开销(通常比普通函数调用慢 2-3 倍),但对于大多数应用场景来说足够快。如果追求极致性能,手写迭代器仍然更快。
elements_of 是做什么的?
co_yield std::ranges::elements_of(rng) 可以将另一个范围或生成器的所有元素逐个产出,避免了手动循环。这对递归生成器特别有用。
generator 是线程安全的吗?
不是。generator 不能在多个线程中同时使用。它是一个同步的协程生成器。
注意事项
- generator 是 move-only 的,不能复制
- generator 是 input_range,只能单次遍历
- 协程函数中必须使用 co_yield 或 co_return
- 不要在生成器中使用 co_await(那是异步协程)
- 递归生成器使用
co_yield std::ranges::elements_of()委托 - 需要
<generator>头文件
编译器支持情况
| 编译器 | std::generator | 最低版本 |
|---|---|---|
| GCC | 支持 | 14.0 |
| Clang | 部分支持 | 18.0 |
| MSVC | 支持 | 19.40 (VS 2022 17.13) |
总结
std::generator 是 C++23 引入的第一个标准库协程类型,大幅简化了惰性序列生成器的编写。以前需要几十行代码实现的自定义迭代器,现在只需要一个协程函数和 co_yield 就能完成。generator 产出的序列是惰性的,只有在迭代时才计算下一个值,天然支持无限序列。它可以与 Ranges 管道无缝配合(filter、transform、take 等)。递归生成器通过 elements_of 支持高效的递归委托。generator 是 move-only 的 input_range,只能单次遍历。