std::generator 协程生成器(C++23) ​

什么是 std::generator ​

std::generator 是 C++23 引入的第一个标准库协程类型,定义在 <generator> 头文件中。它让你可以用 co_yield 关键字编写生成序列的协程函数,返回的 generator 对象是一个惰性的、单次遍历的范围(input_range)。

cpp
#include <generator>

std::generator<int> count(int from, int to) {
    for (int i = from; i <= to; i++) {
        co_yield i;  // 每次暂停,产出一个值
    }
}

generator 简化了自定义迭代器的编写——不需要手动管理状态机,编译器会自动处理协程的暂停和恢复。

基本示例 ​

cpp
#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 的模板参数 ​

cpp
template<class Ref, class V = void, class Allocator = void>
class generator;
参数说明示例
Refco_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,只能单次遍历。