Ranges#

C++20 在std::ranges命名空间中提供了大多数算法的受限版本，也就是受限算法，并且引入了范围库（Ranges Library），其可组合且不易出错，功能十分强大
~~让高贵的C++20玩家迭代器跟python的一样好用~~

视图 views#

views 可以以用管道符 | 组合多个视图和算法，并且它们拥有惰性计算的特性，即不会立即计算结果，而是按需生成。

通常，我们直接在range-based loops中使用views过滤和更改特定的值，使代码更加简洁

示例(filter)：

1
#include <iostream>
2
#include <ranges>
3
#include <vector>
4

5
int main() {
6
    std::vector<int> nums = {1, 2, 3, 4, 5, 6};
7

8
    //定义lambda函数even
9
    auto even = [](int n) { return n % 2 == 0; };
10

11
    // 过滤偶数
12
    for (auto& x : nums | std::views::filter(even)) {
13
        std::cout << x << " ";
14
    }
15
    // 输出：2 4 6
16
}

示例(transform)：

1
#include <iostream>
2
#include <ranges>
3
#include <vector>
4

5
int main() {
6
    std::vector<int> nums = {1, 2, 3, 4, 5, 6};
7

8
    auto even = [](int n) { return n % 2 == 0; };
9
    auto pow = [](int n) { return n * n; };
10

11
    for (auto x : nums | std::views::filter(even) | std::views::transform(pow)) {
12
        std::cout << x << " ";
13
    }
14
    // 输出：4 16 36
15
}

示例(enumerate、reverse)：

1
#include <iostream>
2
#include <ranges>
3

4
int main() {
5
    auto const numbers = {3, 1, 4, 1, 5, 9, 2, 6};
6

7
    for (auto [index, value]: numbers | std::views::enumerate | std::views::reverse) {
8
        std::cout << index << ": " << value << '\n';
9
    }
10

11
    return 0;
12
}

输出：

受限函数#

C++20 在 <algorithm> 头文件中为大多数算法都增加了定义于std::ranges::的版本，这些函数可以直接传入容器、view 或自定义范围对象，而不需要手动指定迭代器，比如：

std::ranges::sort
std::ranges::find
std::ranges::min_element
std::ranges::max_element
std::ranges::reverse
std::ranges::copy
std::ranges::copy_if
std::ranges::for_each

示例(sort)

1
#include <vector>
2
#include <ranges>
3
#include <algorithm>
4
#include <iostream>
5

6
int main() {
7
    std::vector<int> v = {5, 2, 8, 1};
8
    std::ranges::sort(v); // 直接对容器排序
9

10
    for (const auto& i : v) { std::cout << i << ' '; }
11
    //输出 1 2 5 8
12
}

示例(min_element/min)

1
#include <vector>
2
#include <ranges>
3
#include <algorithm>
4
#include <iostream>
5

6
int main() {
7
    std::vector<int> v = {5, 2, 8, 1};
8

9
    auto it = std::ranges::min_element(v); //返回一个迭代器
10
    if (it != v.end()) { std::cout << *it << ' '; }
11

12
    auto min = std::ranges::min(v); //直接返回值
13
    std::cout << min;
14
}

示例(next_permutation)

~~来猴戏一下全排列~~

1
#include <algorithm>
2
#include <iostream>
3
#include <string>
4

5
int main() {
6
  std::string a {"abc"};
7
  do {
8
    for (const auto& i : a) { std::cout << i << " "; }
9
    std::cout << "\n";
10
  } while (std::ranges::next_permutation(a).found);
11
}

~~猴戏还得是python~~

1
from itertools import permutations
2

3
a: str = "abc"
4
for p in permutations(a):
5
    print(' '.join(p))

输出：

1
a b c
2
a c b
3
b a c
4
b c a
5
c a b
6
c b a

NOTE
为了防止悬空迭代器，view（比如 filter 之后的结果）只返回std::ranges::dangling，正如其名，这个类型不是实际的容器，不能被受限函数们直接使用

如果希望保存views的结果，我们需要手动收集，例如：

1
#include <iostream>
2
#include <vector>
3
#include <ranges>
4
#include <algorithm>
5

6
int main() {
7
    auto const numbers = {3, 1, 4, 1, 5, 9, 2, 6};
8

9
    auto even = [](int n) { return n % 2 == 0; };
10

11
    // 使用 std::ranges::to 收集 （C++23)
12
    std::vector<int> evens = std::ranges::to<std::vector<int>>(numbers | std::views::filter(even));
13

14
    // 直接遍历收集
15
    std::vector<int> evens;
16
    for (int n : numbers | std::views::filter(even)) {
17
        evens.push_back(n);
18
    }
19

20
    auto min = std::ranges::min_element(evens); //✔
21

22
    if (min != evens.end()) { std::cout << *min << std::endl; }
23

24
    return 0;
25
}