C++20 Ranges库实战：简化容器操作，提升代码可读性

C++20 Ranges库实战：简化容器操作，提升代码可读性

C++20 引入的 Ranges 库，是对标准模板库 (STL) 的一次重大升级，它提供了一种更简洁、更易于理解和组合的方式来处理数据集合。Ranges 库的核心在于“范围”的概念，它代表一个可以迭代的元素序列，而 Ranges 库提供的工具可以让你以声明式的方式操作这些范围，从而减少代码的冗余和提高代码的可读性。

为什么要使用 Ranges？

在传统的 STL 编程中，我们通常需要使用迭代器来访问和操作容器中的元素。这种方式虽然灵活，但也很容易出错，并且代码往往显得冗长和难以理解。例如，以下代码使用 STL 算法 std::transform 将一个 std::vector 中的每个元素乘以 2，并将结果存储到另一个 std::vector 中：

#include <iostream>
#include <vector>
#include <algorithm>
 
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::vector<int> doubled_numbers(numbers.size());
 
    std::transform(numbers.begin(), numbers.end(), doubled_numbers.begin(), [](int n) { return n * 2; });
 
    for (int number : doubled_numbers) {
        std::cout << number << " ";
    }
    std::cout << std::endl; // 输出：2 4 6 8 10
 
    return 0;
}

这段代码虽然简单，但却包含了一些不必要的细节，例如，我们需要显式地指定输入范围的开始和结束迭代器，以及输出范围的开始迭代器。使用 Ranges 库，我们可以用更简洁的方式实现相同的功能：

#include <iostream>
#include <vector>
#include <algorithm>
#include <ranges>
 
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
 
    auto doubled_numbers = numbers | std::views::transform([](int n) { return n * 2; }) | std::ranges::to<std::vector>();
 
    for (int number : doubled_numbers) {
        std::cout << number << " ";
    }
    std::cout << std::endl; // 输出：2 4 6 8 10
 
    return 0;
}

可以看到，使用 Ranges 库的代码更加简洁和易于理解。我们使用管道操作符 | 将 numbers 传递给 std::views::transform 视图，该视图将每个元素乘以 2。然后，我们将结果传递给 std::ranges::to<std::vector>()，将结果转换为 std::vector。整个过程就像一条数据流，清晰地表达了我们的意图。

Ranges 库的核心概念

Ranges 库的核心概念包括：

• Range (范围)：一个可以迭代的元素序列。可以是容器、数组、迭代器对等。
• View (视图)：一个轻量级的、非拥有的 Range。View 不会复制数据，而是提供对底层数据的只读或可修改的访问。View 可以通过组合其他 View 来创建复杂的数据处理管道。
• Algorithm (算法)：用于操作 Range 的函数。Ranges 库提供了许多与 STL 算法类似的算法，但这些算法可以直接操作 Range，而不需要显式地指定迭代器。
• Action (动作)：直接修改 Range 的函数。与 Algorithm 不同，Action 通常会修改 Range 本身。
• Adapter (适配器)：用于将一个 Range 转换为另一个 Range 的函数。例如，std::views::transform 就是一个适配器，它可以将一个 Range 中的每个元素转换为另一个值。

常用的 Ranges View

Ranges 库提供了许多有用的 View，可以帮助我们轻松地处理数据集合。以下是一些常用的 View：

• std::views::all: 创建一个包含 Range 中所有元素的 View。这是最基本的 View，也是其他 View 的基础。

• std::views::filter: 创建一个只包含满足特定条件的元素的 View。例如，以下代码创建一个只包含偶数的 View：

  std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
  auto even_numbers = numbers | std::views::filter([](int n) { return n % 2 == 0; });
  // even_numbers 包含 {2, 4, 6}

• std::views::transform: 创建一个将 Range 中的每个元素转换为另一个值的 View。例如，以下代码创建一个将每个元素乘以 2 的 View：

  std::vector<int> numbers = {1, 2, 3, 4, 5};
  auto doubled_numbers = numbers | std::views::transform([](int n) { return n * 2; });
  // doubled_numbers 包含 {2, 4, 6, 8, 10}

• std::views::take: 创建一个只包含 Range 中前 N 个元素的 View。例如，以下代码创建一个只包含前 3 个元素的 View：

  std::vector<int> numbers = {1, 2, 3, 4, 5};
  auto first_three = numbers | std::views::take(3);
  // first_three 包含 {1, 2, 3}

• std::views::drop: 创建一个跳过 Range 中前 N 个元素的 View。例如，以下代码创建一个跳过前 2 个元素的 View：

  std::vector<int> numbers = {1, 2, 3, 4, 5};
  auto after_two = numbers | std::views::drop(2);
  // after_two 包含 {3, 4, 5}

• std::views::reverse: 创建一个以相反顺序包含 Range 中元素的 View。例如，以下代码创建一个反转顺序的 View：

  std::vector<int> numbers = {1, 2, 3, 4, 5};
  auto reversed_numbers = numbers | std::views::reverse;
  // reversed_numbers 包含 {5, 4, 3, 2, 1}

• std::views::join: 将一个包含 Range 的 Range 扁平化为一个 Range。例如，如果有一个 std::vector<std::vector<int>>，可以使用 std::views::join 将其转换为一个 std::vector<int>。

• std::views::split: 将一个 Range 分割成多个子 Range，分割点由分隔符指定。例如，可以将一个字符串按照空格分割成多个单词。

这些 View 可以组合使用，以创建复杂的数据处理管道。例如，以下代码创建一个只包含偶数，并将每个偶数乘以 2 的 View：

#include <iostream>
#include <vector>
#include <algorithm>
#include <ranges>
 
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
 
    auto even_doubled_numbers = numbers
                                 | std::views::filter([](int n) { return n % 2 == 0; })
                                 | std::views::transform([](int n) { return n * 2; });
 
    for (int number : even_doubled_numbers) {
        std::cout << number << " ";
    }
    std::cout << std::endl; // 输出：4 8 12
 
    return 0;
}

Ranges 算法

Ranges 库提供了许多与 STL 算法类似的算法，但这些算法可以直接操作 Range，而不需要显式地指定迭代器。以下是一些常用的 Ranges 算法：

• std::ranges::for_each: 对 Range 中的每个元素执行一个函数。
• std::ranges::count: 计算 Range 中等于特定值的元素数量。
• std::ranges::find: 在 Range 中查找第一个等于特定值的元素。
• std::ranges::sort: 对 Range 中的元素进行排序。
• std::ranges::copy: 将 Range 中的元素复制到另一个 Range 中。
• std::ranges::transform: 将 Range 中的每个元素转换为另一个值，并将结果存储到另一个 Range 中（与 std::views::transform 不同，这是一个算法，会直接修改目标 Range）。

例如，以下代码使用 std::ranges::for_each 打印 even_doubled_numbers 中的每个元素：

#include <iostream>
#include <vector>
#include <algorithm>
#include <ranges>
 
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
 
    auto even_doubled_numbers = numbers
                                 | std::views::filter([](int n) { return n % 2 == 0; })
                                 | std::views::transform([](int n) { return n * 2; });
 
    std::ranges::for_each(even_doubled_numbers, [](int n) { std::cout << n << " "; });
    std::cout << std::endl; // 输出：4 8 12
 
    return 0;
}

Ranges Action

Ranges Action 是直接修改 Range 的函数。一个常见的 Action 是 std::ranges::sort，它可以直接对容器进行排序。与算法不同，Action 通常会修改 Range 本身，而不是返回一个新的 Range。

#include <iostream>
#include <vector>
#include <algorithm>
#include <ranges>
 
int main() {
    std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6};
 
    std::ranges::sort(numbers); // 直接对 numbers 排序
 
    for (int number : numbers) {
        std::cout << number << " ";
    }
    std::cout << std::endl; // 输出：1 1 2 3 4 5 6 9
 
    return 0;
}

Ranges 库的优势

• 代码简洁性: Ranges 库可以显著减少代码的冗余，使代码更加简洁易懂。
• 可读性: Ranges 库使用声明式的方式来处理数据集合，可以更清晰地表达代码的意图。
• 可组合性: Ranges 库的 View 可以组合使用，以创建复杂的数据处理管道。
• 避免迭代器错误: Ranges 算法直接操作 Range，避免了手动使用迭代器时可能出现的错误。
• 延迟计算: Ranges 库的 View 通常是延迟计算的，这意味着只有在需要时才会计算结果。这可以提高性能，特别是对于大型数据集。

Ranges 库的性能考虑

虽然 Ranges 库提供了许多优势，但在使用时也需要考虑性能问题。Ranges 库的 View 通常是延迟计算的，这意味着每次访问 View 中的元素时，都需要重新计算。这可能会导致性能下降，特别是对于复杂的数据处理管道。

为了提高性能，可以采取以下措施：

• 避免不必要的 View 组合: View 组合越多，性能开销越大。尽量减少 View 的组合数量。
• 使用 std::ranges::to 将 View 转换为容器: 如果需要多次访问 View 中的元素，可以将 View 转换为容器，以避免重复计算。例如，std::ranges::to<std::vector> 可以将 View 转换为 std::vector。
• 使用 Ranges 算法而不是手动循环: Ranges 算法通常比手动循环更高效，因为 Ranges 算法可以利用编译器的优化。
• 了解不同 View 的性能特性: 不同的 View 具有不同的性能特性。例如，std::views::filter 的性能取决于过滤条件的复杂程度。

实际代码示例

示例 1：从文本文件中读取数字，过滤掉负数，并将剩余的数字平方后存储到另一个文件中。

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <algorithm>
#include <ranges>
 
int main() {
    std::ifstream input("input.txt");
    std::ofstream output("output.txt");
 
    if (!input.is_open() || !output.is_open()) {
        std::cerr << "Error opening files!" << std::endl;
        return 1;
    }
 
    auto numbers = std::istream_iterator<int>(input) | std::views::common;
 
    auto positive_squares = numbers
                            | std::views::filter([](int n) { return n > 0; })
                            | std::views::transform([](int n) { return n * n; });
 
    std::ranges::copy(positive_squares, std::ostream_iterator<int>(output, " "));
    output << std::endl;
 
    input.close();
    output.close();
 
    return 0;
}

示例 2：统计字符串中每个单词出现的次数。

#include <iostream>
#include <string>
#include <sstream>
#include <map>
#include <algorithm>
#include <ranges>
 
int main() {
    std::string text = "This is a test string. This string is a test.";
    std::stringstream ss(text);
 
    auto words = std::istream_iterator<std::string>(ss) | std::views::common;
 
    std::map<std::string, int> word_counts;
    std::ranges::for_each(words, [&word_counts](const std::string& word) { word_counts[word]++; });
 
    for (const auto& [word, count] : word_counts) {
        std::cout << word << ": " << count << std::endl;
    }
 
    return 0;
}

性能测试数据

为了评估 Ranges 库的性能，我们进行了一些简单的性能测试。测试环境如下：

• CPU：Intel Core i7-8700K
• 内存：16GB DDR4
• 编译器：GCC 11.2
• 操作系统：Ubuntu 20.04

我们比较了使用 Ranges 库和使用传统 STL 算法的性能。测试用例包括：

• 过滤: 从一个包含 100 万个整数的 std::vector 中过滤出偶数。
• 转换: 将一个包含 100 万个整数的 std::vector 中的每个元素乘以 2。
• 排序: 对一个包含 100 万个整数的 std::vector 进行排序。

测试结果如下：

从测试结果可以看出，Ranges 库的性能与传统的 STL 算法相比略有下降，但下降幅度不大。在某些情况下，Ranges 库的性能甚至可能优于 STL 算法，这取决于具体的测试用例和编译器优化。

Ranges 库的局限性

• 学习曲线: Ranges 库引入了新的概念和语法，需要一定的学习成本。
• 编译器支持: 虽然 C++20 已经发布，但并非所有编译器都完全支持 Ranges 库。在使用 Ranges 库之前，需要确保编译器支持所需的特性。
• 调试难度: 由于 Ranges 库使用了延迟计算，因此在调试时可能会遇到一些困难。例如，在调试器中查看 View 中的元素时，可能会发现元素的值还没有被计算出来。

总结

C++20 Ranges 库是一个强大的工具，可以帮助我们更简洁、更易于理解和组合的方式来处理数据集合。虽然 Ranges 库存在一些局限性，但它仍然是 C++ 编程的一个重要组成部分。通过学习和使用 Ranges 库，我们可以提高代码的可读性和可维护性，并减少代码的冗余。希望本文能够帮助你入门 C++20 Ranges 库，并在实际项目中应用它。