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 管道可以构建清晰的数据流处理架构