std::generator 与异步模式

上一节我们手写了一个 Generator<T>,需要约 60 行样板代码。C++23 直接将这个模式标准化为 std::generator<T>——开箱即用,零样板。本节还将探索生成器与 Ranges 的集成,以及基于协程的异步编程模式。

编译器支持

std::generator 需要 C++23 支持。GCC 14+、Clang 18+、MSVC 17.10+ 均已支持。编译时加 -std=c++23 或 /std:c++latest。头文件为 <generator>。

std::generator<T> — 告别样板代码

有了 std::generator,只需写协程函数本身,无需手动实现 promise_type 和迭代器:

#include <generator>
#include <iostream>
#include <ranges>

// 斐波那契数列 — 无限惰性序列
std::generator<long long> fibonacci() {
    long long a = 0, b = 1;
    while (true) {
        co_yield a;
        auto next = a + b;
        a = b;
        b = next;
    }
}

int main() {
    // std::generator 满足 ranges::input_range
    for (auto val : fibonacci() | std::views::take(15)) {
        std::cout << val << " ";
    }
    // 输出: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
}

对比上一节的手写版本,使用 std::generator 时你只关注算法逻辑——promise_type、迭代器、handle 管理全部由标准库处理。

惰性序列实战

生成器的核心价值在于按需计算——只有当消费者请求下一个值时,生成器才会执行到下一个 co_yield。

#include <generator>
#include <fstream>
#include <string>

// 逐行读取文件 — 不会一次性加载整个文件到内存
std::generator<std::string> read_lines(const std::string& path) {
    std::ifstream file(path);
    std::string line;
    while (std::getline(file, line)) {
        co_yield std::move(line);
    }
}

// 无限序列:自然数
std::generator<int> naturals(int start = 0) {
    while (true) {
        co_yield start++;
    }
}

// 过滤序列:只产出满足条件的值
std::generator<int> primes() {
    auto is_prime = [](int n) {
        if (n < 2) return false;
        for (int i = 2; i * i <= n; ++i)
            if (n % i == 0) return false;
        return true;
    };

    for (int n = 2; ; ++n) {
        if (is_prime(n)) co_yield n;
    }
}

// 使用
void example() {
    // 前100个素数
    for (auto p : primes() | std::views::take(100)) {
        process(p);
    }

    // 文件中包含 "error" 的行
    for (auto&& line : read_lines("/var/log/app.log")
                       | std::views::filter([](auto& s) {
                             return s.contains("error");
                         })) {
        std::cout << line << "\n";
    }
}

Generator + Ranges 集成

std::generator<T> 满足 std::ranges::input_range 概念,因此可以无缝接入 Ranges 管道:

#include <generator>
#include <ranges>
#include <iostream>
#include <format>

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

int main() {
    // generator 作为 range 源,接管道操作
    auto result = iota_gen(1, 100)
        | std::views::filter([](int n) { return n % 3 == 0; })
        | std::views::transform([](int n) { return n * n; })
        | std::views::take(10);

    for (int val : result) {
        std::cout << val << " ";
    }
    // 输出: 9 36 81 144 225 324 441 576 729 900

    // 用 generator 替代自定义 view:更简单!
    auto squares = [](auto&& range) -> std::generator<int> {
        for (auto val : range) {
            co_yield val * val;
        }
    };
}

Generator vs Views

std::generator 是 input_range(单遍遍历),而标准 views 通常是 forward_range 或更强。如果你需要多次遍历,仍应使用 views 或将结果物化到容器中。Generator 适合一次性消费的惰性序列。

递归生成器 — std::ranges::elements_of

生成器经常需要"展平"子生成器的结果。C++23 提供了 std::ranges::elements_of 来处理递归情况:

#include <generator>
#include <filesystem>
#include <string>

namespace fs = std::filesystem;

// 递归遍历目录树
std::generator<fs::path> walk_directory(const fs::path& dir) {
    for (auto& entry : fs::directory_iterator(dir)) {
        if (entry.is_directory()) {
            // 递归:展平子目录的所有结果
            co_yield std::ranges::elements_of(
                walk_directory(entry.path())
            );
        } else {
            co_yield entry.path();
        }
    }
}

// 递归展平嵌套向量
std::generator<int> flatten(const std::vector<std::vector<int>>& nested) {
    for (auto& inner : nested) {
        for (int val : inner) {
            co_yield val;
        }
    }
}

// 树的中序遍历
struct TreeNode {
    int value;
    TreeNode* left = nullptr;
    TreeNode* right = nullptr;
};

std::generator<int> inorder(TreeNode* node) {
    if (!node) co_return;

    co_yield std::ranges::elements_of(inorder(node->left));
    co_yield node->value;
    co_yield std::ranges::elements_of(inorder(node->right));
}

// 使用
void example() {
    for (auto& path : walk_directory("/home/user/project")
                      | std::views::filter([](auto& p) {
                            return p.extension() == ".cpp";
                        })) {
        std::cout << path << "\n";
    }
}

递归生成器的栈开销

elements_of 使用对称转移(symmetric transfer),避免了递归调用带来的协程帧嵌套。但每层递归仍然会分配一个协程帧。对于非常深的递归(比如万级节点的不平衡树),仍需注意内存使用。

异步生成器模式

标准的 std::generator 是同步的——co_yield 后立即挂起等待消费者拉取。但在实际应用中,我们常需要"异步生成"数据。以下展示这种模式的设计思路:

// 概念:异步生成器(标准库尚未提供,但模式很清晰)
// 消费时需要 co_await 来获取下一个值

// 模拟分页 API 调用
template<typename T>
struct AsyncGenerator; // 自定义实现略...

// 分页 API 消费模式的伪代码
AsyncGenerator<User> fetch_all_users(HttpClient& client) {
    std::string next_cursor = "";
    do {
        // co_await 异步 HTTP 请求
        auto page = co_await client.get("/users?cursor=" + next_cursor);
        for (auto& user : page.items) {
            co_yield user;  // 逐个产出
        }
        next_cursor = page.next_cursor;
    } while (!next_cursor.empty());
}

// 消费端
Task<void> process_users(HttpClient& client) {
    // 每次迭代可能触发网络请求
    for co_await (auto& user : fetch_all_users(client)) {
        if (user.active) {
            co_await send_notification(user);
        }
    }
}

实际应用示例

示例:惰性 CSV 解析器

#include <generator>
#include <string>
#include <vector>
#include <sstream>
#include <fstream>

struct CsvRow {
    std::vector<std::string> fields;
};

// 解析单行 CSV
CsvRow parse_row(const std::string& line) {
    CsvRow row;
    std::istringstream stream(line);
    std::string field;
    while (std::getline(stream, field, ',')) {
        row.fields.push_back(field);
    }
    return row;
}

// 惰性 CSV 读取器:逐行解析,不缓存整个文件
std::generator<CsvRow> read_csv(const std::string& path,
                                 bool skip_header = true) {
    std::ifstream file(path);
    std::string line;

    if (skip_header) {
        std::getline(file, line);  // 跳过表头
    }

    while (std::getline(file, line)) {
        if (line.empty()) continue;
        co_yield parse_row(line);
    }
}

// 使用:处理百万行 CSV,内存占用恒定
void process_large_csv() {
    double total_sales = 0.0;
    int count = 0;

    for (auto& row : read_csv("sales_data.csv")) {
        if (row.fields.size() >= 3) {
            total_sales += std::stod(row.fields[2]);
            ++count;
        }
    }
    std::cout << std::format("平均销售额: {:.2f}\n",
                              total_sales / count);
}

示例:无限数据流管道

#include <generator>
#include <ranges>
#include <random>
#include <iostream>
#include <numeric>
#include <deque>

// 模拟传感器数据流
std::generator<double> sensor_stream() {
    std::mt19937 rng(42);
    std::normal_distribution<> dist(20.0, 5.0);  // 均值20, 标准差5
    while (true) {
        co_yield dist(rng);
    }
}

// 滑动窗口平均
std::generator<double> moving_average(std::generator<double> source,
                                       size_t window_size) {
    std::deque<double> window;
    for (double val : source) {
        window.push_back(val);
        if (window.size() > window_size) {
            window.pop_front();
        }
        double avg = std::accumulate(window.begin(), window.end(), 0.0)
                     / window.size();
        co_yield avg;
    }
}

// 异常检测:超出阈值时发出警报
std::generator<std::pair<double, bool>>
anomaly_detector(std::generator<double> source, double threshold) {
    for (double val : source) {
        bool is_anomaly = (val > threshold || val < -threshold);
        co_yield {val, is_anomaly};
    }
}

int main() {
    auto pipeline = sensor_stream()
        // 注意:这里演示概念,实际中 generator 参数传递需要仔细设计
        ;

    int count = 0;
    for (auto val : pipeline | std::views::take(1000)) {
        if (val > 30.0) {  // 简单阈值检测
            std::cout << std::format("异常值: {:.2f}\n", val);
        }
        if (++count % 100 == 0) {
            std::cout << std::format("已处理 {} 个数据点\n", count);
        }
    }
}

本节小结

  • std::generator<T>(C++23)是标准化的同步生成器,零样板代码实现惰性序列
  • 生成器天然适合文件逐行读取、无限序列、按需计算等场景——内存占用恒定
  • std::generator 满足 input_range,可直接接入 std::views 管道
  • std::ranges::elements_of 实现递归生成器的展平,适用于树遍历和目录递归
  • 异步生成器模式(尚未标准化)将同步生成器思想扩展到异步 I/O 场景
  • 实际应用中,生成器 + Ranges 管道可以构建清晰的数据流处理架构