发布于 由admin

C++20 ‘Ranges’ 库：如何利用管道操作符 `|` 实现类似函数式编程的延迟计算视图？

各位编程爱好者，欢迎来到本次关于C++20 Ranges库的深度技术讲座。今天，我们将聚焦于Ranges库中最具革命性和函数式编程风格的特性之一：如何利用管道操作符 | 实现类似函数式编程的延迟计算视图。

C++作为一门追求高性能和底层控制的语言，在过去很长一段时间里，其标准库在数据处理和算法组合方面，与一些现代函数式语言（如Haskell、F#，甚至Python、JavaScript等的高阶函数）相比，显得有些笨重和不直观。传统C++算法通常操作一对迭代器，返回结果也往往通过修改原地数据或写入新的迭代器来实现，这使得算法的链式组合变得困难，常常需要创建大量的中间容器，造成不必要的内存分配和拷贝开销。

C++20 Ranges库的引入，彻底改变了这一局面。它将“范围”提升为一等公民，并提供了一套全新的、高度可组合的算法和视图。其中，管道操作符 | 的运用，使得我们能够以一种声明式、链式、直观的方式构建数据处理流水线，更重要的是，它完美地支持了“延迟计算”这一函数式编程的核心思想。

传统算法的困境：冗长、低效与不直观

在C++20之前，如果我们要对一个数据集合进行一系列操作，例如：从一个整数列表中筛选出偶数，然后将它们翻倍，最后只取出前三个结果进行打印，我们可能会这样编写代码：

#include <iostream>
#include <vector>
#include <algorithm> // for std::transform, std::copy_if
#include <numeric>   // for std::iota

void traditional_approach() {
    std::cout << "--- 传统C++算法的困境 ---" << std::endl;
    std::vector<int> numbers(10);
    std::iota(numbers.begin(), numbers.end(), 1); // numbers = {1, 2, ..., 10}

    // 1. 筛选偶数：需要一个中间容器
    std::vector<int> evens;
    std::copy_if(numbers.begin(), numbers.end(), std::back_inserter(evens),
                 [](int n){ return n % 2 == 0; });
    // evens = {2, 4, 6, 8, 10}

    // 2. 将偶数翻倍：又需要一个中间容器
    std::vector<int> doubled_evens;
    std::transform(evens.begin(), evens.end(), std::back_inserter(doubled_evens),
                   [](int n){ return n * 2; });
    // doubled_evens = {4, 8, 12, 16, 20}

    // 3. 取前三个：可能需要临时容器或手动循环
    std::vector<int> first_three;
    if (doubled_evens.size() >= 3) {
        std::copy_n(doubled_evens.begin(), 3, std::back_inserter(first_three));
    } else {
        first_three = doubled_evens;
    }
    // first_three = {4, 8, 12}

    // 4. 打印结果
    std::cout << "Processed numbers (traditional): ";
    for (int n : first_three) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    std::cout << "--- 传统C++算法困境结束 ---" << std::endl;
}

这段代码存在几个显而易见的问题：

  1. 冗长且不直观： 为了实现简单的筛选、转换、截取操作，代码被分割成多个步骤，每一步都需要定义新的中间容器。这使得代码的意图被实现细节所掩盖。
  2. 效率低下： 每次操作都会创建新的 std::vector 并进行元素的内存分配和拷贝。对于大规模数据集，这将导致显著的内存和CPU开销。
  3. 难以组合： 算法之间缺乏直接的“管道”机制，使得链式调用变得复杂。我们不能直接将一个算法的输出作为另一个算法的输入，除非通过中间容器。
  4. 急切求值： 所有的中间结果都会立即计算并存储起来，即使我们最终可能只关心少数几个元素。

这些问题在函数式编程中通常通过高阶函数和延迟计算来解决。C++20 Ranges库正是借鉴了这些思想，通过引入“视图”（Views）和管道操作符 |，为C++带来了优雅的解决方案。

C++20 Ranges基础：构建延迟计算的基石

C++20 Ranges库的核心概念围绕着 range、view 和 range adaptor 展开。

std::ranges 命名空间

所有C++20 Ranges相关的概念、算法和视图都位于 std::ranges 命名空间下。为了方便，我们通常会引入 std::views 命名空间中的所有内容，它包含了各种用于创建和组合视图的函数对象。

#include <ranges> // 包含Ranges库的主要头文件
namespace views = std::views; // 常用别名

Range 概念

在C++20中，range 是一个核心概念，它泛指任何可以被迭代的序列。任何满足 std::ranges::range 概念的类型（例如 std::vector、std::list、std::array，甚至C风格数组，以及我们后面要讨论的视图）都可以作为Ranges算法的输入。一个类型只要能提供 begin() 和 end() 成员函数或自由函数，返回有效的迭代器，它就可能是一个 range。

View 概念：轻量级、非拥有的、可组合的序列

view 是Ranges库的灵魂所在，也是实现延迟计算的关键。一个 view 是一个轻量级的、非拥有的（non-owning）的 range。这意味着：

  1. 非拥有性： view 不拥有它所引用的数据。它只是提供了访问底层数据的一种“视角”或“透视”。这意味着创建 view 不会复制数据，也不会分配新的内存。
  2. O(1) 拷贝/移动： 拷贝或移动一个 view 的开销是常数时间，因为它只涉及复制或移动几个内部指针或迭代器，而不是底层数据。
  3. 可组合性： view 可以像乐高积木一样被组合起来，形成更复杂的视图，而无需创建中间数据。
  4. 延迟计算（Laziness）： 这是最重要的一点。view 本身并不会立即执行其操作。它只是描述了如何从其底层数据派生出新的序列。只有当您真正开始迭代 view 并请求元素时，它才会按需执行必要的操作来生成这些元素。

视图的这些特性使其成为构建高效、内存友好的数据处理管道的理想选择。

Range Adaptors：操作View的函数对象

range adaptor 是一类特殊的函数对象，它们接受一个 range 作为输入，并返回一个新的 view。这些适配器通常位于 std::views 命名空间下。例如：

  • std::views::filter(predicate)：创建一个只包含满足 predicate 条件的元素的新视图。
  • std::views::transform(function)：创建一个将每个元素应用 function 转换后的新视图。
  • std::views::take(count)：创建一个只包含前 count 个元素的新视图。

这些适配器是构建管道的基本构件。

管道操作符 |：函数式链式调用的魔法

现在，我们来重点探讨管道操作符 |。在C++20 Ranges中，| 操作符被重载，以提供一种类似函数式语言的、高度可读的链式调用语法。它的作用是将左侧的 range 或 view 的结果传递给右侧的 range adaptor，然后 range adaptor 返回一个新的 view，这个新的 view 又可以作为下一个 | 操作符的左侧操作数。

其语法形式通常是：

source_range | adaptor1 | adaptor2 | adaptor3 ...

这读起来就像一个数据流：source_range 的数据“流经” adaptor1，然后其结果“流经” adaptor2，以此类推。

range_adaptor_closure 对象：| 的幕后英雄

要理解 | 操作符的魔法，我们需要了解 range_adaptor_closure 对象。std::views 中的所有 range adaptor（如 filter、transform 等）实际上都是返回 range_adaptor_closure 类型的函数对象。

当您写 std::views::filter([](int n){ return n % 2 == 0; }) 时，这本身并不会立即执行过滤操作，它只是创建了一个“过滤器”的描述，一个 range_adaptor_closure 对象。这个对象重载了 operator|，使其能够与一个 range 结合。

具体来说，std::views::filter 和 std::views::transform 等适配器函数都是柯里化（curried）的。它们首先接受一个函数（谓词或转换函数），然后返回一个“闭包对象”。这个闭包对象重载了两个版本的 operator|：

  1. range_type | closure_object：将 range_type 传递给闭包对象，生成一个新的 view。
  2. closure_object1 | closure_object2：将两个闭包对象组合成一个新的闭包对象。这允许您预先构建复杂的适配器链，然后将其应用于数据。

这种设计使得 | 操作符既可以用于数据流，也可以用于适配器本身的组合，提供了极大的灵活性。

代码示例：将传统代码重写为管道风格

让我们用Ranges和管道操作符重写前面传统方法的例子：

#include <iostream>
#include <vector>
#include <ranges>    // 包含Ranges库的主要头文件
#include <numeric>   // for std::iota
#include <string>    // for std::views::split example

namespace views = std::views; // 常用别名

void ranges_pipeline_approach() {
    std::cout << "--- C++20 Ranges 管道操作符 ---" << std::endl;
    std::vector<int> numbers(10);
    std::iota(numbers.begin(), numbers.end(), 1); // numbers = {1, 2, ..., 10}

    // 使用管道操作符构建数据处理流水线
    auto processed_numbers_view = numbers
                                | views::filter([](int n){ // 筛选偶数
                                    std::cout << "  Filtering: " << n << std::endl;
                                    return n % 2 == 0;
                                })
                                | views::transform([](int n){ // 将偶数翻倍
                                    std::cout << "  Transforming: " << n << std::endl;
                                    return n * 2;
                                })
                                | views::take(3); // 取前三个结果

    std::cout << "View pipeline created, no operations performed yet." << std::endl;

    // 只有在迭代时，操作才真正执行 (延迟计算)
    std::cout << "Processed numbers (Ranges): ";
    for (int n : processed_numbers_view) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    std::cout << "--- C++20 Ranges 管道操作符结束 ---" << std::endl;
}

int main() {
    traditional_approach();
    std::cout << "n" << std::endl;
    ranges_pipeline_approach();
    return 0;
}

运行 ranges_pipeline_approach 函数，您会发现 Filtering 和 Transforming 的打印语句是交错出现的，并且只对真正需要的元素执行。例如，当 filter 处理到第一个偶数 2 时，它会被 transform 翻倍成 4，然后立即被 for 循环消费。接着，filter 继续处理 3 (跳过)，4 (翻倍成 8)，以此类推，直到 take(3) 满足条件，循环停止。这就是延迟计算的直观体现。

对比分析表格：

特性 传统C++算法 C++20 Ranges + ` ` 操作符
可读性 多个语句，中间变量多，意图不明显 声明式，链式调用，清晰表达数据流向
内存效率 频繁创建中间 std::vector，内存开销大 view 非拥有，不复制数据，零中间容器
CPU效率 急切求值，可能计算不必要的数据 延迟计算，按需处理，只计算最终所需的数据
组合性 依赖中间容器传递数据，组合复杂 通过 | 运算符自然链式组合，高度模块化
代码量 实现相同逻辑需要更多行代码 显著减少样板代码，更简洁
错误处理 编译错误通常在单步操作上 复杂的模板元编程可能导致复杂的编译错误信息
学习曲线 熟悉迭代器对即可 需理解 range、view、adaptor、概念等新范式

核心View Adaptors：构建数据处理管道

C++20提供了丰富的标准 view adaptor，它们是构建强大数据处理管道的基石。以下是一些最常用和最具代表性的：

std::views::filter：条件过滤

根据提供的谓词（一个返回 bool 的函数对象）筛选元素。

// 筛选出大于5的偶数
std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto filtered_view = nums | views::filter([](int n){ return n > 5 && n % 2 == 0; });
// 结果: {6, 8, 10}
for (int n : filtered_view) { std::cout << n << " "; } // 输出: 6 8 10
std::cout << std::endl;

std::views::transform：元素转换

将提供的函数应用于 range 中的每个元素，生成一个转换后的新视图。

// 将数字平方
std::vector<int> nums = {1, 2, 3, 4, 5};
auto squared_view = nums | views::transform([](int n){ return n * n; });
// 结果: {1, 4, 9, 16, 25}
for (int n : squared_view) { std::cout << n << " "; } // 输出: 1 4 9 16 25
std::cout << std::endl;

std::views::take & std::views::drop：截取与跳过

  • views::take(count)：从 range 的开头获取 count 个元素。
  • views::drop(count)：从 range 的开头跳过 count 个元素。
std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 取前5个元素
auto first_five = nums | views::take(5);
// 结果: {1, 2, 3, 4, 5}
for (int n : first_five) { std::cout << n << " "; } // 输出: 1 2 3 4 5
std::cout << std::endl;

// 跳过前3个元素
auto after_three = nums | views::drop(3);
// 结果: {4, 5, 6, 7, 8, 9, 10}
for (int n : after_three) { std::cout << n << " "; } // 输出: 4 5 6 7 8 9 10
std::cout << std::endl;

std::views::take_while & std::views::drop_while：条件截取与跳过

  • views::take_while(predicate)：从 range 的开头获取元素，直到遇到第一个不满足 predicate 的元素。
  • views::drop_while(predicate)：从 range 的开头跳过元素，直到遇到第一个不满足 predicate 的元素。
std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 获取所有小于等于5的元素
auto less_than_equal_five = nums | views::take_while([](int n){ return n <= 5; });
// 结果: {1, 2, 3, 4, 5}
for (int n : less_than_equal_five) { std::cout << n << " "; } // 输出: 1 2 3 4 5
std::cout << std::endl;

// 跳过所有小于等于5的元素
auto after_less_than_equal_five = nums | views::drop_while([](int n){ return n <= 5; });
// 结果: {6, 7, 8, 9, 10}
for (int n : after_less_than_equal_five) { std::cout << n << " "; } // 输出: 6 7 8 9 10
std::cout << std::endl;

std::views::reverse：反转序列

创建一个反向遍历原始 range 的视图。

std::vector<int> nums = {1, 2, 3, 4, 5};
auto reversed_view = nums | views::reverse;
// 结果: {5, 4, 3, 2, 1}
for (int n : reversed_view) { std::cout << n << " "; } // 输出: 5 4 3 2 1
std::cout << std::endl;

std::views::join：扁平化嵌套序列

将一个由 range 组成的 range 扁平化为一个单一的 range。

std::vector<std::vector<int>> nested_nums = {{1, 2}, {3, 4, 5}, {6}};
auto joined_view = nested_nums | views::join;
// 结果: {1, 2, 3, 4, 5, 6}
for (int n : joined_view) { std::cout << n << " "; } // 输出: 1 2 3 4 5 6
std::cout << std::endl;

std::vector<std::string> words = {"hello", "world"};
auto joined_chars = words | views::join; // join strings into a range of chars
// 结果: {'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'}
for (char c : joined_chars) { std::cout << c << " "; } // 输出: h e l l o w o r l d
std::cout << std::endl;

std::views::split：按分隔符分割

将一个 range 按指定的分隔符分割成一个由子 range 组成的 range。

std::string sentence = "This is a sample sentence.";
auto word_views = sentence | views::split(' ');
// 结果: {"This", "is", "a", "sample", "sentence."} (每个都是一个string_view)
for (auto word_view : word_views) {
    std::cout << std::string(word_view.begin(), word_view.end()) << " | ";
}
std::cout << std::endl;

// 使用字符串作为分隔符 (C++23)
#if __cpp_lib_ranges_as_rvalue_view >= 202207L // Check for C++23 feature
    std::string data = "value1,value2,value3";
    auto csv_parts = data | views::split(std::string_view(","));
    for (auto part_view : csv_parts) {
        std::cout << "CSV part: " << std::string(part_view.begin(), part_view.end()) << std::endl;
    }
#endif

std::views::iota：生成整数序列

生成一个递增的整数序列。这个视图是无限的，因此通常需要与 take 或 take_while 结合使用。

// 生成从0到4的整数
auto count_up = views::iota(0) | views::take(5);
// 结果: {0, 1, 2, 3, 4}
for (int n : count_up) { std::cout << n << " "; } // 输出: 0 1 2 3 4
std::cout << std::endl;

std::views::zip (C++23)：多序列合并

将多个 range 的元素按位置组合成一个由 std::tuple 组成的 range。

#if __cpp_lib_ranges_zip >= 202110L // Check for C++23 feature
    std::vector<int> a = {1, 2, 3};
    std::vector<char> b = {'a', 'b', 'c', 'd'}; // 长度不匹配时，zip会以最短的为准
    std::vector<double> c = {1.1, 2.2, 3.3};

    for (auto&& [num, ch, dbl] : views::zip(a, b, c)) {
        std::cout << num << ", " << ch << ", " << dbl << std::endl;
    }
    // 输出:
    // 1, a, 1.1
    // 2, b, 2.2
    // 3, c, 3.3
#endif

std::views::enumerate (C++23)：带索引的遍历

将 range 的元素与其索引组合成一个由 std::pair 或 std::tuple 组成的 range。

#if __cpp_lib_ranges_enumerate >= 202207L // Check for C++23 feature
    std::vector<std::string> fruits = {"apple", "banana", "cherry"};
    for (auto&& [index, fruit] : views::enumerate(fruits)) {
        std::cout << "Index " << index << ": " << fruit << std::endl;
    }
    // 输出:
    // Index 0: apple
    // Index 1: banana
    // Index 2: cherry
#endif

std::views::common：使View具有相同的begin/end迭代器类型

有些 view 的 begin() 和 end() 返回的迭代器类型不同（例如 filter_view）。common_view 会将它们包装成相同的类型，这在某些需要 sentinel 和 iterator 类型匹配的算法或容器构造中很有用。

std::vector<int> nums = {1, 2, 3, 4, 5};
auto filtered = nums | views::filter([](int n){ return n % 2 == 0; });
// auto common_filtered = filtered | views::common; // 将filtered的begin和end迭代器类型统一
// common_filtered.begin() 和 common_filtered.end() 现在是相同类型

这些 view adaptor 可以任意组合，形成极其强大且富有表现力的数据处理链。

深度解析延迟计算与性能优势

延迟计算是C++20 Ranges库的核心优势之一，它通过 view 的设计得以实现。

Views如何实现延迟计算：不存储数据，仅存储操作

当您创建一个 view 链（例如 source | views::filter(...) | views::transform(...)）时，系统并不会立即执行任何操作，也不会创建任何中间数据结构来存储结果。相反，它只是构建了一个“操作描述”的链条。每个 view 对象都只存储了：

  1. 对其前一个 range 或 view 的引用（通常是 const& 或 && 引用）。
  2. 它自己的操作逻辑（例如 filter 的谓词，transform 的转换函数）。

当您开始迭代这个最终的 view 时（例如通过 for (auto&& x : my_view)），迭代器会“拉动”（pull）数据：

  • 最外层的 view 的迭代器会向其前一个 view 请求元素。
  • 这个请求会层层传递，直到达到原始的 source range。
  • source range 提供一个元素。
  • 这个元素会逐层向上，经过每个 view 的操作（例如 transform 转换，filter 检查）。
  • 一旦一个元素通过了所有 view 的操作并且被认为是最终结果的一部分，它就会被传递给 for 循环进行消费。
  • 这个过程按需重复，直到 for 循环结束或 view 耗尽元素。

这意味着：

  • 按需计算： 只有当元素被请求时，相应的计算才会发生。
  • 元素级处理： 每个元素都是独立地、按顺序地流经整个管道。一个元素的处理完成，下一个元素才开始处理。
  • 无中间存储： 除了原始数据和少量迭代器状态外，没有额外的内存用于存储中间结果。

内存效率：避免中间容器的创建与销毁

如前所述，传统方法中为了链式操作，常常需要创建多个 std::vector 或其他容器来存储中间结果。这些容器的创建和销毁都伴随着堆内存的分配和释放，这本身就是昂贵的操作。

而 view 完全避免了这些开销。它们不拥有数据，只是提供了一个抽象层，使得数据看起来像是经过了转换。这对于处理大型数据集尤其重要，因为它可以显著降低内存峰值，甚至允许处理超出可用内存大小的逻辑无限序列。

CPU效率：按需计算，避免不必要的处理

延迟计算也带来了显著的CPU效率提升：

  • 最短路径原则： 如果您使用 views::take(N)，那么管道中的其他操作将只对前N个满足条件的元素执行。一旦N个元素被消费，整个管道就会停止拉取数据。这避免了对后续不必要元素的计算。
  • 融合优化： 现代编译器在某些情况下可以对 view 链进行优化，将多个操作“融合”在一起，进一步减少每个元素的处理开销。例如，一个 filter 和一个 transform 可能被优化为一个单一的循环，其中条件检查和转换操作在每次迭代中同时进行。

无限序列的处理能力：std::views::iota

std::views::iota 是一个典型的例子，它能生成一个潜在的无限整数序列。如果没有延迟计算和 views::take 这样的适配器，处理无限序列将是不可能的。

#include <iostream>
#include <ranges>
#include <vector>

namespace views = std::views;

void process_infinite_sequence() {
    std::cout << "--- 处理无限序列 ---" << std::endl;
    // 生成从1开始，过滤偶数，取前5个，并平方
    auto result_view = views::iota(1) // 从1开始的无限序列
                     | views::filter([](int n){
                         std::cout << "  Filtering (infinite): " << n << std::endl;
                         return n % 2 == 0; // 筛选偶数
                       })
                     | views::transform([](int n){
                         std::cout << "  Transforming (infinite): " << n << std::endl;
                         return n * n; // 平方
                       })
                     | views::take(5); // 只取前5个结果

    std::cout << "Infinite view pipeline created. Iterating..." << std::endl;
    for (int n : result_view) {
        std::cout << "Consumed (infinite): " << n << std::endl;
    }
    std::cout << "--- 无限序列处理结束 ---" << std::endl;
}

运行此代码会清晰地展示，iota 持续生成数字，filter 和 transform 仅在需要时被调用，直到 take(5) 收集到5个元素。如果没有 take(5)，这个循环将永远运行。

代码示例：对比Eager vs Lazy的内存与计算开销

我们通过一个更具体的例子来展示内存和计算的对比。

#include <iostream>
#include <vector>
#include <ranges>
#include <chrono>
#include <numeric>

namespace views = std::views;

// Helper to simulate work and track calls
int transform_count = 0;
int filter_count = 0;

int slow_transform(int n) {
    transform_count++;
    // std::this_thread::sleep_for(std::chrono::milliseconds(1)); // Simulate heavy work
    return n * 2;
}

bool slow_filter(int n) {
    filter_count++;
    // std::this_thread::sleep_for(std::chrono::milliseconds(1)); // Simulate heavy work
    return n % 2 == 0;
}

void compare_eager_lazy(int data_size) {
    std::cout << "n--- 比较急切与延迟计算 (数据量: " << data_size << ") ---" << std::endl;
    std::vector<int> numbers(data_size);
    std::iota(numbers.begin(), numbers.end(), 0);

    // --- 急切计算 (Eager Evaluation) ---
    transform_count = 0;
    filter_count = 0;
    auto start_eager = std::chrono::high_resolution_clock::now();

    std::vector<int> temp1;
    temp1.reserve(data_size / 2); // Best case pre-allocation
    for (int n : numbers) {
        if (slow_filter(n)) {
            temp1.push_back(n);
        }
    }

    std::vector<int> temp2;
    temp2.reserve(temp1.size());
    for (int n : temp1) {
        temp2.push_back(slow_transform(n));
    }

    std::vector<int> eager_result;
    for (int i = 0; i < std::min((int)temp2.size(), 5); ++i) { // Take 5 elements
        eager_result.push_back(temp2[i]);
    }

    auto end_eager = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> eager_ms = end_eager - start_eager;

    std::cout << "急切计算: " << eager_ms.count() << " ms" << std::endl;
    std::cout << "  Filter calls: " << filter_count << ", Transform calls: " << transform_count << std::endl;
    std::cout << "  结果 (前5个): ";
    for (int n : eager_result) { std::cout << n << " "; }
    std::cout << std::endl;

    // --- 延迟计算 (Lazy Evaluation with Ranges) ---
    transform_count = 0;
    filter_count = 0;
    auto start_lazy = std::chrono::high_resolution_clock::now();

    auto lazy_view = numbers
                   | views::filter(slow_filter)
                   | views::transform(slow_transform)
                   | views::take(5); // 只取前5个结果

    std::vector<int> lazy_result;
    for (int n : lazy_view) {
        lazy_result.push_back(n);
    }

    auto end_lazy = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> lazy_ms = end_lazy - start_lazy;

    std::cout << "延迟计算: " << lazy_ms.count() << " ms" << std::endl;
    std::cout << "  Filter calls: " << filter_count << ", Transform calls: " << transform_count << std::endl;
    std::cout << "  结果 (前5个): ";
    for (int n : lazy_result) { std::cout << n << " "; }
    std::cout << std::endl;
    std::cout << "--- 比较结束 ---" << std::endl;
}

// int main() { // Already have a main, this is for demonstration
//     compare_eager_lazy(100);    // Small data size
//     compare_eager_lazy(10000);  // Medium data size
//     compare_eager_lazy(1000000); // Large data size
//     return 0;
// }

运行 compare_eager_lazy(1000000)，您会观察到：

  • 急切计算会对整个 1,000,000 个元素执行 filter 和 transform，即使最终只需要5个结果。它会创建两个大型中间 std::vector。
  • 延迟计算会显著减少 filter 和 transform 的调用次数，因为 views::take(5) 会在获得5个元素后立即停止拉取。它不会创建任何中间容器。

这种效率差异在处理大数据集、流式数据或需要复杂链式操作的场景中尤为明显。

终端操作：消费View并产生结果

view 是惰性的。它们本身不会执行任何操作，也不会产生任何结果，直到它们被“消费”为止。消费 view 的方式通常被称为“终端操作”或“汇聚操作”。

常见的终端操作包括：

  1. 显式 for 循环： 最直接的方式就是使用基于范围的 for 循环。这也是我们前面例子中一直使用的方式。

    for (auto&& element : my_view) {
    // ... 处理 element ...
}

    这里 auto&& 是最佳实践，可以避免不必要的拷贝，并处理 view 可能返回的代理对象。

  2. std::ranges::for_each： 相当于一个函数式的 for 循环，对 view 中的每个元素应用一个函数。

    std::vector<int> nums = {1, 2, 3};
nums | views::transform([](int n){ return n * 10; })
     | std::ranges::for_each([](int n){ std::cout << n << " "; }); // Output: 10 20 30
std::cout << std::endl;

  3. std::ranges::copy： 将 view 的内容复制到另一个容器中。

    std::vector<int> nums = {1, 2, 3, 4, 5};
std::vector<int> result_vec;
nums | views::filter([](int n){ return n % 2 != 0; })
     | views::transform([](int n){ return n + 1; })
     | std::ranges::copy(std::back_inserter(result_vec));
// result_vec = {2, 4, 6}
for (int n : result_vec) { std::cout << n << " "; } // Output: 2 4 6
std::cout << std::endl;

  4. std::ranges::to (C++23)： 这是C++23中一个非常方便的新特性，允许您直接将 view 转换为指定的容器类型。

    #if __cpp_lib_ranges_to_container >= 202202L // Check for C++23 feature
    std::vector<int> nums = {1, 2, 3, 4, 5};
    std::vector<int> result_vec_cpp23 = nums
                                      | views::filter([](int n){ return n % 2 != 0; })
                                      | views::transform([](int n){ return n + 1; })
                                      | std::ranges::to<std::vector>(); // C++23
    // result_vec_cpp23 = {2, 4, 6}
    for (int n : result_vec_cpp23) { std::cout << n << " "; } // Output: 2 4 6
    std::cout << std::endl;

    // 也可以转换为其他容器类型
    std::list<std::string> words = {"alpha", "beta", "gamma"};
    std::set<char> first_chars = words
                               | views::transform([](const std::string& s){ return s.front(); })
                               | std::ranges::to<std::set>(); // C++23
    // first_chars = {'a', 'b', 'g'}
    for (char c : first_chars) { std::cout << c << " "; } // Output: a b g (set maintains order)
    std::cout << std::endl;
#endif

这些终端操作是触发 view 链执行的“扳机”。在没有终端操作的情况下，view 链只是一个潜在操作的描述，不会消耗任何资源。

实际应用场景与高级技巧

C++20 Ranges库在许多领域都有广泛的应用潜力：

  1. 日志文件分析：

    • 读取大型日志文件（可能使用自定义的行视图）。
    • views::filter 筛选特定级别的日志（ERROR, WARN）。
    • views::transform 提取关键信息（时间戳、消息）。
    • views::take 或 views::drop 处理最新/最旧的日志。
    • views::split 解析日志行中的字段。

  2. 传感器数据处理：

    • 从传感器流中获取数据。
    • views::filter 剔除异常值或噪声。
    • views::transform 进行单位转换或校准。
    • views::chunk (C++23) 或自定义适配器进行滑动窗口平均或聚合。
    • views::take_while 持续处理直到满足某个条件。

  3. 构建复杂查询：

    • 模拟数据库查询语言，对内存中的对象集合进行“查询”。
    • 结合 filter、transform、join 等操作，构建复杂的筛选、投影和连接逻辑。
    • 自定义 view adaptor 可以实现特定领域的查询操作。

  4. 字符串处理：

    • views::split 分割字符串。
    • views::transform 对每个单词进行大小写转换。
    • views::filter 筛选特定长度的单词。
    • views::join 重新组合字符串。

高级技巧：自定义View Adaptors (概念性提及)

虽然标准库提供了很多 view adaptor，但您也可以创建自己的。这通常涉及到定义一个类，该类重载了 operator| 或继承自 std::ranges::range_adaptor_closure<YourAdaptor>。自定义适配器允许您封装复杂的、特定于业务逻辑的管道步骤，进一步提高代码的复用性和表达力。这超出了本次讲座的深度，但在设计领域特定语言（DSL）时非常有用。

Ranges的优势与潜在挑战

优势：

  • 代码简洁性与可读性： 管道操作符 | 使得数据流向一目了然，代码更接近自然语言的描述。
  • 强大的组合性与表达力： 各种 view 可以无缝组合，构建出任意复杂的数据处理逻辑。
  • 卓越的性能： 延迟计算和零中间容器避免了不必要的内存分配和拷贝，显著提升了内存和CPU效率。
  • 类型安全与编译期检查： Ranges库是基于概念（Concepts）构建的，大部分错误可以在编译期捕获。
  • 与标准算法的无缝集成： Ranges算法可以直接操作 view，并且 view 也可以作为传统算法的输入。

潜在挑战：

  • 学习曲线： range、view、concept 等新概念，以及函数式编程的思维模式，对于习惯传统C++的开发者来说，需要一定的学习时间。
  • 调试复杂度： 管道中的错误可能导致复杂的模板错误信息。当 view 链很长时，理解数据在每个阶段的状态可能需要更多技巧。
  • 生命周期管理： view 是非拥有的，这意味着它们引用的底层数据必须在 view 存在期间保持有效。如果 view 的生命周期超过了其引用的数据，就会导致悬垂引用（dangling reference），引发未定义行为。 
    // 危险！source_vec 在函数结束时被销毁，但 dangling_view 仍然存在
auto create_dangling_view() {
    std::vector<int> source_vec = {1, 2, 3};
    return source_vec | views::filter([](int n){ return n > 1; });
}
// 调用 create_dangling_view() 得到的 view 将引用已销毁的内存

    解决此问题的方法是确保 view 引用的数据具有足够长的生命周期，或者在C++23中可以使用 std::ranges::to 将 view 的内容立即复制到拥有的容器中。

  • 错误信息： 由于Ranges库大量使用了模板元编程和概念，当出现编译错误时，错误信息可能会非常冗长和晦涩。

未来展望：C++23及更高版本对Ranges的增强

C++20 Ranges只是一个开始。C++23进一步增强了Ranges库的功能，例如：

  • std::ranges::to： 如前所述，这是一个极其方便的工具，简化了将 view 内容收集到容器的过程。
  • 更多实用View Adaptors： std::views::zip、std::views::enumerate 极大地提升了处理多个序列或带索引序列的便利性。std::views::chunk、std::views::slide 则提供了对序列进行分块或滑动窗口操作的能力。

可以预见，未来的C++标准将继续扩展Ranges库，使其在表达力、效率和易用性方面达到新的高度。Ranges库正在成为C++处理数据的新范式，它将函数式编程的优雅与C++的性能完美结合。

总结

C++20 Ranges库及其管道操作符 | 为C++带来了函数式编程风格的延迟计算视图。通过理解 range、view 和 range adaptor 的核心概念，并熟练运用 | 操作符，开发者可以编写出更简洁、更高效、更易于理解和维护的数据处理代码。虽然存在学习曲线和生命周期管理的挑战，但Ranges库所带来的巨大优势，使其成为现代C++开发中不可或缺的强大工具。掌握Ranges，将使您能够以全新的视角处理数据，并编写出更具表现力的C++程序。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注