C++20 Ranges & Views 管道式编程 on Dorkytiger 的小屋

一、Ranges 解决了一个什么痛？

Mon, 01 Jan 0001 00:00:00 +0000

痛点：你有一段数据处理逻辑——筛选、转换、取前 N 个。传统写法会产生多个中间容器：

std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 传统风格：产生两个临时 vector
std::vector<int> evens;
std::copy_if(data.begin(), data.end(), std::back_inserter(evens),
             [](int x) { return x % 2 == 0; });        // ① 分配 evens

std::vector<int> doubled;
std::transform(evens.begin(), evens.end(), std::back_inserter(doubled),
               [](int x) { return x * 10; });           // ② 分配 doubled

std::vector<int> top3;
std::copy_n(doubled.begin(), 3, std::back_inserter(top3)); // ③ 分配 top3

// 3 次分配、3 次遍历、3N 次拷贝

Ranges 的做法：

auto result = data
    | std::views::filter([](int x) { return x % 2 == 0; })
    | std::views::transform([](int x) { return x * 10; })
    | std::views::take(3);

// 0 次分配、1 次遍历、0 次多余拷贝

Ranges 的核心承诺：写出表达力强的代码，但不付出性能代价。

二、`view` 和 `container` 的区别——必须搞懂

Mon, 01 Jan 0001 00:00:00 +0000

std::vector<int> data = {1, 2, 3, 4, 5};

// view（视图）：不拥有数据，不分配内存
auto v = data | std::views::filter([](int x) { return x % 2 == 1; });
// 此时什么也没发生！v 只是记住了 data 的引用和 filter 条件

for (int x : v) { // 遍历时才触发计算
    std::cout << x; // 1 3 5
}

// container（容器）：拥有数据，分配内存
std::vector<int> c;
std::copy_if(data.begin(), data.end(), std::back_inserter(c),
             [](int x) { return x % 2 == 1; });
// 此时已经完成了筛选，c 持有 [1, 3, 5]

一句话区分：view 像 string_view——只是看一眼，不拿过来。container 像 string——复制一份归自己所有。

三、常用的 View——什么时候用？

Mon, 01 Jan 0001 00:00:00 +0000

View	作用	什么时候用
`filter(pred)`	筛选满足条件的元素	过滤无效数据、错误剔除
`transform(func)`	对每个元素做转换	数据类型转换、字段提取、数值计算
`take(N)`	取前 N 个	分页（取第 1 页）、取 TopK
`drop(N)`	跳过前 N 个	分页（跳过前一页）
`reverse`	反转顺序	最近操作记录（最新在最前）
`join`	展平嵌套容器	`vector<vector<int>>` 变 `vector<int>`
`split(delim)`	按分隔符分割	CSV 解析、命令行参数分割

组合使用案例：日志分析

std::vector<LogEntry> logs = get_logs();

// 需求：找出最近 10 条 ERROR 级别的错误消息，按倒序显示
auto recent_errors = logs
    | std::views::filter([](const LogEntry& e) { return e.level == "ERROR"; })
    | std::views::reverse                              // 最新的在前面
    | std::views::take(10)                             // 只要 10 条
    | std::views::transform([](const LogEntry& e) { return e.message; });
// 一次遍历完成，没有中间容器，没有多余拷贝

四、惰性求值为什么快？——底层原理

Mon, 01 Jan 0001 00:00:00 +0000

auto pipeline = data
    | std::views::filter([](int x) { return x % 2 == 0; })
    | std::views::transform([](int x) { return x * 10; })
    | std::views::take(3);

for (int x : pipeline) {
    std::cout << x;
}

for 循环中每次迭代发生了什么：

第 1 次迭代：
  take 问 transform："给我下一个值"
  transform 问 filter："给我下一个值"
  filter 问 data："给我下一个值"
  data 给 filter：1 → filter 检查 1%2==0？→ false → "跳过，下一个"
  data 给 filter：2 → filter 检查 2%2==0？→ true → 把 2 给 transform
  transform 计算 2*10=20 → 把 20 给 take
  take 计数 1/3 → 把 20 吐给 for 循环
  cout << 20

第 2 次迭代：
  take 问 transform：再给我一个
  transform 问 filter：再给我一个
  data 给 filter：3 → false → 跳过
  data 给 filter：4 → true → transform → 40 → take(2/3) → cout

第 3 次迭代：
  同样得到 60 → 输出
  take 计数到达 3 → 告诉 for："结束了"

总共遍历了 data 的前 6 个元素（到 6），而非全部 data。

关键：每次只处理一个元素通过整个管道，管道中的每个"站"都是按需工作。最坏情况下只遍历 data 一遍。

五、什么时候不该用 Ranges？

Mon, 01 Jan 0001 00:00:00 +0000

// ❌ 场景 1：你需要多次遍历同一结果
auto filtered = data | std::views::filter(...);
for (int x : filtered) { ... }  // 第一次遍历：计算
for (int x : filtered) { ... }  // 第二次遍历：重新计算（性能浪费！）

// ✅ 应该把结果收集到容器中
auto filtered_vec = data
    | std::views::filter(...)
    | std::ranges::to<std::vector>();  // C++23

// ❌ 场景 2：你的操作有副作用，且依赖执行顺序
// filter/transform 的计算顺序不是从左到右严格保证的

// ✅ 什么时候应该无脑用 Ranges？
// 当你只需要遍历一次，且不需要持有结果时——天生适合 Ranges

六、第七阶段总结

Mon, 01 Jan 0001 00:00:00 +0000

Ranges 的本质：
    用 | 管道连接多个 view，惰性求值，一次遍历
    不产生中间容器，不分配额外内存

常用 View：
    filter → 筛选；transform → 转换
    take/drop → 截取；reverse → 反转
    join → 展平；split → 分割

适用场景：
    一次性的数据处理管道
    避免多层 for 循环嵌套
    日志/数据流的链式处理

不适用的场景：
    需要多次遍历时
    操作依赖固定执行顺序时