C++20 Ranges 库避坑指南：告别迭代器，让代码飞起来！

各位卷王好！今天咱们聊聊 C++20 引入的 Ranges 库。这玩意儿一出来，号称要革迭代器的命，让代码更简洁、更高效。但实际用起来，坑也不少。今天我就结合实际项目经验，带你避开这些坑，真正让 Ranges 库为你的代码加速。

1. Ranges 库的核心概念：别再盯着迭代器了！

传统的 C++ 里，我们操作容器，离不开迭代器。但迭代器这玩意儿，用起来繁琐，还容易出错。Ranges 库的核心思想，就是把操作的数据范围（Range）和操作的算法（Algorithm）分离，让代码更关注于“做什么”，而不是“怎么做”。

1.1 Range 的定义：不只是容器！

Range 可以简单理解为一个可以迭代的东西。但它比传统的容器更宽泛。一个 Range 可以是：

• 一个完整的容器，比如 std::vector、std::list。
• 容器的一部分，比如从 vector 的第 3 个元素到第 8 个元素。
• 甚至是一个自定义的、动态生成的数据序列。

1.2 View 的妙用：数据变形的魔法！

View 是 Ranges 库的灵魂！它可以让你在不修改原始数据的前提下，对 Range 进行各种转换、过滤和组合。你可以把 View 想象成一个“懒加载”的管道，只有在真正需要数据的时候，才会进行计算。

常见的 View 包括：

• transform：对 Range 中的每个元素应用一个函数，生成一个新的 Range。

  std::vector<int> numbers = {1, 2, 3, 4, 5};
  auto squared_numbers = numbers | std::views::transform([](int n){ return n * n; });
  
  // squared_numbers 包含了 {1, 4, 9, 16, 25}，但 numbers 并没有被修改
  

• filter：根据一个条件，过滤 Range 中的元素，生成一个新的 Range。

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

• take 和 drop：分别取 Range 的前 N 个元素和丢弃前 N 个元素。

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

• join：将一个包含 Range 的 Range 展平为一个 Range。

  std::vector<std::vector<int>> matrix = {{1, 2}, {3, 4, 5}};
  auto flattened = matrix | std::views::join;
  
  // flattened 包含了 {1, 2, 3, 4, 5}
  

• split：将一个 Range 分割成多个 Range，分割点由一个分隔符决定。

  std::string text = "hello,world,how,are,you";
  auto words = text | std::views::split(',');
  
  // words 是一个包含多个 Range 的 Range，每个 Range 对应一个单词
  

1.3 Action 的威力：直接修改，简单粗暴！

和 View 不同，Action 是直接修改 Range 的操作。比如 std::ranges::sort 可以直接对一个 Range 进行排序。

std::vector<int> numbers = {5, 2, 1, 4, 3};
std::ranges::sort(numbers);

// numbers 现在包含了 {1, 2, 3, 4, 5}

1.4 Algorithm 的进化：更简洁的调用方式！

Ranges 库也对 C++ 的标准算法进行了升级，让它们可以更方便地操作 Range。比如，你可以直接用 std::ranges::for_each 遍历一个 Range，而不需要指定迭代器。

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::ranges::for_each(numbers, [](int n){ std::cout << n << " "; });

// 输出：1 2 3 4 5

2. Ranges 库的优势：代码更短、效率更高！

2.1 代码简洁性：告别迭代器，拥抱链式调用！

Ranges 库最大的优势，就是可以告别繁琐的迭代器，用更简洁的链式调用来表达复杂的操作。

比如，我们要从一个 vector 中筛选出偶数，然后求平方，最后求和。用传统的迭代器，代码可能是这样的：

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<int> even_numbers;
for (int n : numbers) {
    if (n % 2 == 0) {
        even_numbers.push_back(n * n);
    }
}
int sum = 0;
for (int n : even_numbers) {
    sum += n;
}
std::cout << "Sum: " << sum << std::endl;

而用 Ranges 库，代码可以简化成这样：

std::vector<int> numbers = {1, 2, 3, 4, 5};
int sum = std::ranges::fold_left(numbers | std::views::filter([](int n){ return n % 2 == 0; }) | std::views::transform([](int n){ return n * n; }), 0, std::plus{});
std::cout << "Sum: " << sum << std::endl;

是不是简洁多了？

2.2 性能优化：延迟计算，避免不必要的拷贝！

Ranges 库的另一个优势，就是可以进行延迟计算。这意味着，只有在真正需要数据的时候，才会进行计算。这可以避免不必要的拷贝和中间变量，提高代码的效率。

比如，上面的例子中，filter 和 transform 都是 View，它们不会立即执行，而是等到 fold_left 需要数据的时候，才会按需计算。这样就避免了生成中间的 even_numbers vector，节省了内存和时间。

3. Ranges 库的坑：一不小心，性能暴跌！

虽然 Ranges 库有很多优点，但用不好，也会掉坑里。下面我就结合实际项目经验，总结几个常见的坑：

3.1 避免过度使用 View：链式调用不是越多越好！

虽然链式调用很简洁，但过度使用 View 也会导致性能问题。因为每个 View 都会引入一定的开销，如果链式调用太长，这些开销就会累积起来，导致性能下降。

比如，下面的代码：

std::vector<int> numbers = {1, 2, 3, 4, 5};
auto result = numbers | std::views::filter([](int n){ return n % 2 == 0; }) | std::views::transform([](int n){ return n * n; }) | std::views::take(2);
for (int n : result) {
    std::cout << n << " ";
}

这段代码看起来很简洁，但实际上效率并不高。因为 filter、transform 和 take 都是 View，它们会生成中间的 Range，导致多次迭代和计算。特别是当 numbers 很大时，性能问题会更加明显。

优化建议：

• 尽量减少 View 的数量，避免不必要的链式调用。

• 如果需要多次迭代同一个 Range，可以考虑将 View 的结果缓存到一个容器中。

• 使用 std::ranges::to 将 View 转换为容器，避免重复计算。

  std::vector<int> numbers = {1, 2, 3, 4, 5};
  auto result = numbers | std::views::filter([](int n){ return n % 2 == 0; }) | std::views::transform([](int n){ return n * n; }) | std::views::take(2) | std::ranges::to<std::vector<int>>();
  for (int n : result) {
      std::cout << n << " ";
  }
  

3.2 注意 dangling reference：View 的生命周期要小心！

View 只是一个数据的“引用”，它并不拥有数据的所有权。这意味着，如果原始数据被销毁，View 就会变成一个“悬空引用”（dangling reference），访问它会导致未定义行为。

比如，下面的代码：

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

auto even_numbers = create_numbers();
for (int n : even_numbers) { // 访问悬空引用，导致未定义行为
    std::cout << n << " ";
}

这段代码的问题在于，create_numbers 函数返回了一个 View，这个 View 引用了函数内部的 numbers vector。当 create_numbers 函数执行完毕后，numbers vector 被销毁，even_numbers 就变成了悬空引用。在后面的循环中访问 even_numbers，就会导致未定义行为。

优化建议：

• 确保 View 的生命周期不长于原始数据的生命周期。

• 避免从函数中返回 View，除非你能保证原始数据在函数外部仍然有效。

• 使用 std::ranges::to 将 View 转换为容器，拥有数据的所有权。

  auto create_numbers = []() {
      std::vector<int> numbers = {1, 2, 3, 4, 5};
      return numbers | std::views::filter([](int n){ return n % 2 == 0; }) | std::ranges::to<std::vector<int>>();
  };
  
  auto even_numbers = create_numbers();
  for (int n : even_numbers) { // 安全访问
      std::cout << n << " ";
  }
  

3.3 小心 range-v3 库的“陷阱”：标准库才是王道！

在 C++20 之前，很多人使用 range-v3 库来体验 Ranges 的特性。但是，range-v3 库和 C++20 标准库的 Ranges 库并不完全兼容。如果你在项目中同时使用了这两个库，可能会遇到一些意想不到的问题。

比如，range-v3 库中的 View 和 C++20 标准库中的 View 的类型不同，不能直接混用。而且，range-v3 库中的一些 View 的行为也可能和 C++20 标准库中的 View 不同。

优化建议：

• 尽量使用 C++20 标准库的 Ranges 库，避免使用 range-v3 库。
• 如果必须同时使用这两个库，要注意它们之间的差异，避免混用。
• 仔细阅读文档，了解每个 View 的行为和限制。

4. 自定义 Range：打造专属的数据处理管道！

除了使用标准库提供的 Range 和 View，你还可以自定义 Range 和 View，来满足特定的需求。这可以让你更好地控制数据的处理流程，提高代码的灵活性和可复用性。

4.1 自定义 Range：封装复杂的数据结构！

你可以通过实现 begin 和 end 函数，来定义自己的 Range。比如，你可以把一个树形结构封装成一个 Range，然后用 Ranges 库的算法来遍历它。

#include <iostream>
#include <ranges>

struct TreeNode {
    int value;
    TreeNode* left;
    TreeNode* right;
};

class TreeRange {
public:
    TreeRange(TreeNode* root) : root_(root) {}

    TreeNode* begin() const {
        // 这里需要实现一个迭代器，用于遍历树
        // 为了简化，这里直接返回根节点
        return root_;
    }

    TreeNode* end() const {
        // 这里需要返回一个表示结束的迭代器
        // 为了简化，这里返回 nullptr
        return nullptr;
    }

private:
    TreeNode* root_;
};

// 为了让 TreeRange 能够和 Ranges 库的算法一起使用，需要提供一个迭代器
class TreeIterator {
public:
    using iterator_category = std::input_iterator_tag;
    using value_type = int;
    using difference_type = std::ptrdiff_t;
    using pointer = int*;
    using reference = int&;

    TreeIterator(TreeNode* node) : current_(node) {}

    reference operator*() const {
        return current_->value;
    }

    TreeIterator& operator++() {
        // 这里需要实现树的遍历逻辑
        // 为了简化，这里直接返回 nullptr
        current_ = nullptr;
        return *this;
    }

    bool operator!=(const TreeIterator& other) const {
        return current_ != other.current_;
    }

private:
    TreeNode* current_;
};

namespace std {
namespace ranges {
    template<> struct iterator_traits<TreeIterator> {
        using iterator_category = std::input_iterator_tag;
        using value_type = int;
        using difference_type = std::ptrdiff_t;
        using pointer = int*;
        using reference = int&;
    };

    template<> concept range<TreeRange> = true;
    template<> concept input_range<TreeRange> = true;
    template<> concept forward_range<TreeRange> = true;

    template<> 
    inline TreeIterator begin(const TreeRange& r) { return TreeIterator{r.begin()}; }
    template<> 
    inline TreeIterator end(const TreeRange& r) { return TreeIterator{r.end()}; }

}
}

int main() {
    TreeNode* root = new TreeNode{1, nullptr, nullptr};
    TreeRange tree_range(root);

    // 使用 Ranges 库的算法来遍历树
    std::ranges::for_each(tree_range, [](int value){ std::cout << value << " "; });

    return 0;
}

4.2 自定义 View：实现特定的数据转换！

你可以通过实现 view_interface 接口，来定义自己的 View。比如，你可以实现一个 View，用于将一个字符串中的每个字符转换成大写。

#include <iostream>
#include <ranges>
#include <string>
#include <algorithm>

// 自定义 View，将字符串中的每个字符转换成大写
class ToUpperView : public std::ranges::view_interface<ToUpperView> {
private:
    std::string str_;

public:
    ToUpperView(std::string str) : str_(std::move(str)) {}

    auto begin() const {
        return std::ranges::begin(str_);
    }

    auto end() const {
        return std::ranges::end(str_);
    }

    // 实现 element 的访问
    char element(size_t n) const {
        return std::toupper(str_[n]);
    }

    // 实现 size 和 data
    size_t size() const {
        return str_.size();
    }

    const char* data() const {
        return str_.data();
    }
};

// View 的适配器，方便链式调用
namespace std {
namespace ranges {
    template (typename R)
    auto operator|(R&& r, ToUpperView to_upper) {
        return ToUpperView(std::forward(r));
    }
}
}

int main() {
    std::string text = "hello world";
    ToUpperView upper_view(text);

    // 使用自定义的 View
    for (char c : upper_view) {
        std::cout << c << " ";
    }
    std::cout << std::endl;

    // 链式调用
    for (char c : text | ToUpperView{}) {
        std::cout << c << " ";
    }
    std::cout << std::endl;

    return 0;
}

5. Ranges 库的未来：拥抱更简洁、更高效的 C++！

Ranges 库是 C++20 中最重要的特性之一。它不仅可以简化代码，提高效率，还可以让代码更易于理解和维护。虽然 Ranges 库还有一些坑需要注意，但只要掌握了正确的使用方法，就能让你的 C++ 代码飞起来！

未来，Ranges 库还会继续发展， появятся 更多的 Range 和 View，更强大的算法，让 C++ 更加现代化、更加强大。让我们一起期待 Ranges 库的未来吧！

最后的建议：

• 多看文档，了解每个 Range 和 View 的行为和限制。
• 多写代码，实践 Ranges 库的各种用法。
• 多思考，探索 Ranges 库的更多可能性。

希望这篇文章能帮助你更好地理解和使用 Ranges 库。如果你有任何问题或建议，欢迎在评论区留言！我们一起学习，一起进步！