范围适配器管道操作 ​

什么是范围适配器 ​

范围适配器(Range Adaptor)是 C++20 Ranges 库中用来创建视图的工具。每个适配器接受一个范围(以及可能的额外参数),返回一个新的视图。适配器本身不做任何计算,只是描述了要对数据做什么操作。

适配器有两种调用方式:

cpp
// 直接调用
auto v1 = std::views::filter(data, pred);

// 管道语法(推荐)
auto v2 = data | std::views::filter(pred);

管道语法 | 是通过重载 operator| 实现的,它让多个操作可以从左到右串联起来,就像 Unix 命令行的管道一样。

管道运算符的工作原理 ​

cpp
data | std::views::filter(pred) | std::views::transform(fn) | std::views::take(5)

等价于嵌套调用:

cpp
std::views::take(std::views::transform(std::views::filter(data, pred), fn), 5)

管道语法把从内到外的嵌套变成了从左到右的线性流,可读性大幅提升。

C++20 标准适配器一览 ​

适配器说明额外参数
views::all将范围包装为视图无
views::filter(pred)保留满足谓词的元素谓词
views::transform(fn)变换每个元素变换函数
views::take(n)取前 n 个元素数量
views::take_while(pred)取满足条件的前缀谓词
views::drop(n)跳过前 n 个元素数量
views::drop_while(pred)跳过满足条件的前缀谓词
views::reverse反转顺序无
views::join展平嵌套范围无
views::split(delim)按分隔符分割分隔符
views::lazy_split(delim)惰性分割分隔符
views::elements<N>提取元组的第 N 个元素编译期索引
views::keys提取键(等价于 elements<0>)无
views::values提取值(等价于 elements<1>)无
views::common转换为 common_range无
views::counted(it, n)从迭代器开始取 n 个迭代器和数量

基本示例 ​

cpp
#include <iostream>
#include <vector>
#include <string>
#include <ranges>
#include <map>
#include <algorithm>

// ============================
// 示例1:基本管道操作
// ============================

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

    // 管道:过滤偶数 → 平方 → 取前3个
    auto result = data
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::transform([](int x) { return x * x; })
        | std::views::take(3);

    // 输出: 4 16 36
    std::cout << "管道结果: ";
    for (int v : result) std::cout << v << " ";
    std::cout << std::endl;
}

// ============================
// 示例2:管道 vs 传统写法
// ============================

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

    // 传统写法:需要中间容器
    std::vector<int> evens;
    std::copy_if(data.begin(), data.end(), std::back_inserter(evens),
                 [](int x) { return x % 2 == 0; });

    std::vector<int> squared;
    std::transform(evens.begin(), evens.end(), std::back_inserter(squared),
                   [](int x) { return x * x; });

    // 只取前3个
    std::cout << "传统写法: ";
    for (std::size_t i = 0; i < 3 && i < squared.size(); ++i) {
        std::cout << squared[i] << " ";
    }
    std::cout << std::endl;

    // 管道写法:无中间容器,惰性求值
    auto pipeline = data
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::transform([](int x) { return x * x; })
        | std::views::take(3);

    std::cout << "管道写法: ";
    for (int v : pipeline) std::cout << v << " ";
    std::cout << std::endl;
}

// ============================
// 示例3:拉模型(Pull Model)
// ============================

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

    int filter_count = 0;
    int transform_count = 0;

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

    // 迭代管道
    for (int v : pipeline) {
        std::cout << v << " ";
    }
    std::cout << std::endl;

    // filter 被调用了多少次?不是 10 次!
    // 因为 take(2) 只需要 2 个偶数,filter 找到第 2 个偶数后就停了
    std::cout << "filter 调用次数: " << filter_count << std::endl;
    std::cout << "transform 调用次数: " << transform_count << std::endl;
}

// ============================
// 示例4:字符串处理管道
// ============================

void string_pipeline_demo() {
    std::vector<std::string> words = {
        "Hello", "World", "C++", "Ranges", "Are", "Great", "In", "2026"
    };

    // 过滤长度大于 3 的单词,转换为大写首字母
    auto result = words
        | std::views::filter([](const std::string& s) {
            return s.size() > 3;
        })
        | std::views::transform([](const std::string& s) {
            return s + "!";
        });

    std::cout << "处理后: ";
    for (const auto& s : result) std::cout << s << " ";
    std::cout << std::endl;
}

// ============================
// 示例5:map 的 keys 和 values
// ============================

void map_pipeline_demo() {
    std::map<std::string, int> scores = {
        {"Alice", 95}, {"Bob", 82}, {"Charlie", 78},
        {"Diana", 91}, {"Eve", 88}
    };

    // 提取所有分数大于 85 的学生名字
    auto top_students = scores
        | std::views::filter([](const auto& pair) {
            return pair.second > 85;
        })
        | std::views::keys;

    std::cout << "优秀学生: ";
    for (const auto& name : top_students) std::cout << name << " ";
    std::cout << std::endl;

    // 提取所有分数
    auto all_scores = scores | std::views::values;
    std::cout << "所有分数: ";
    for (int score : all_scores) std::cout << score << " ";
    std::cout << std::endl;
}

// ============================
// 示例6:生成序列管道
// ============================

void iota_pipeline_demo() {
    // 无限序列 + 管道
    auto result = std::views::iota(1)
        | std::views::filter([](int x) { return x % 3 == 0; })
        | std::views::transform([](int x) { return x * x; })
        | std::views::take(5);

    // 3 的倍数的平方,取前 5 个:9 36 81 144 225
    std::cout << "3的倍数的平方: ";
    for (int v : result) std::cout << v << " ";
    std::cout << std::endl;
}

// ============================
// 示例7:保存管道供复用
// ============================

void reusable_pipeline_demo() {
    // 可以把不带范围的适配器组合保存起来
    auto even_squares = std::views::filter([](int x) { return x % 2 == 0; })
                      | std::views::transform([](int x) { return x * x; });

    std::vector<int> v1 = {1, 2, 3, 4, 5};
    std::vector<int> v2 = {10, 11, 12, 13, 14, 15};

    // 同一个管道应用到不同的数据上
    std::cout << "v1 偶数平方: ";
    for (int v : v1 | even_squares) std::cout << v << " ";
    std::cout << std::endl;

    std::cout << "v2 偶数平方: ";
    for (int v : v2 | even_squares) std::cout << v << " ";
    std::cout << std::endl;
}

// ============================
// 示例8:drop_while 和 take_while
// ============================

void while_demo() {
    std::vector<int> data = {1, 3, 5, 2, 4, 6, 7, 8};

    // 跳过开头的奇数
    auto after_odds = data | std::views::drop_while([](int x) {
        return x % 2 != 0;
    });
    std::cout << "跳过开头奇数: ";
    for (int v : after_odds) std::cout << v << " ";
    std::cout << std::endl;

    // 取开头的奇数
    auto leading_odds = data | std::views::take_while([](int x) {
        return x % 2 != 0;
    });
    std::cout << "开头的奇数: ";
    for (int v : leading_odds) std::cout << v << " ";
    std::cout << std::endl;
}

int main() {
    std::cout << "=== 基本管道 ===" << std::endl;
    basic_pipeline_demo();

    std::cout << "\n=== 管道 vs 传统 ===" << std::endl;
    comparison_demo();

    std::cout << "\n=== 拉模型 ===" << std::endl;
    pull_model_demo();

    std::cout << "\n=== 字符串管道 ===" << std::endl;
    string_pipeline_demo();

    std::cout << "\n=== map 操作 ===" << std::endl;
    map_pipeline_demo();

    std::cout << "\n=== 无限序列 ===" << std::endl;
    iota_pipeline_demo();

    std::cout << "\n=== 可复用管道 ===" << std::endl;
    reusable_pipeline_demo();

    std::cout << "\n=== while 系列 ===" << std::endl;
    while_demo();

    return 0;
}

管道执行模型 ​

管道采用拉模型(Pull Model):消费端(for 循环)向上游请求下一个元素,请求沿管道反向传播到数据源。

for 循环 ← take(3) ← transform ← filter ← vector
  请求元素    检查数量    变换元素    过滤元素    提供元素

这和传统的推模型(逐步处理全部数据、存到中间容器)不同。拉模型的好处是只计算需要的元素——如果 take(3) 只要 3 个结果,上游不会多算。

适用场景 ​

  • 数据处理流水线(过滤 + 变换 + 截取)
  • 避免中间容器的内存分配
  • 处理大数据集或无限序列
  • 代码可读性——从左到右的数据流
  • map/set 的键值分离操作
  • 复用管道逻辑(保存适配器组合)

常见问题 ​

管道中的 lambda 什么时候执行?

只在迭代时执行。创建管道时不会调用任何 lambda。每次迭代到一个元素时,该元素依次通过管道中的每个步骤。

管道可以保存和复用吗?

可以。不绑定到具体范围的适配器组合可以保存为变量,然后用 | 应用到不同的范围上。

管道的性能怎么样?

现代编译器对视图管道的优化非常好,生成的汇编代码通常和手写循环一样。惰性求值还避免了中间容器的分配,在某些场景下比传统写法更快。

管道可以修改底层数据吗?

如果底层范围是可写的,某些视图(如 filter、reverse)允许通过迭代器修改元素。transform 视图返回的是变换后的值,不能直接修改。

注意事项 ​

  • 管道是惰性的——不迭代就不计算
  • 视图不缓存结果——多次迭代会多次计算
  • 注意底层范围的生命周期——视图不拥有数据
  • 不要对临时容器创建视图管道(除非用 owning_view)
  • 某些适配器组合可能改变范围的类别(如 filter 会降低为 bidirectional)
  • 管道的错误信息可能比较长,但概念约束会指出问题所在

编译器支持情况 ​

编译器Ranges 管道操作最低版本
GCC支持10.0
Clang支持13.0
MSVC支持19.29

总结 ​

范围适配器管道是 C++20 Ranges 库中最具表现力的特性。通过 | 运算符,多个操作可以从左到右串联成可读的数据处理流水线,就像 Unix 管道一样。管道采用拉模型和惰性求值——只在迭代时才计算,只计算需要的元素,不分配中间容器。适配器组合可以保存为变量在不同数据上复用。标准库提供了丰富的适配器(filter、transform、take、drop、reverse、join、keys、values 等),覆盖了大部分常见的数据处理需求。