范围概念(Range Concepts)
什么是范围(Range)
C++20 的 Ranges 库对"可以迭代的东西"做了系统化的抽象。一个范围就是提供了 begin() 和 end() 的任何类型——数组、容器、字符串、甚至自定义类型都可以是范围。
Ranges 库用 C++20 的概念(Concepts)来分类不同能力的范围,形成了一个从弱到强的层次结构。
范围概念层次
range(最基本:有 begin 和 end)
├── input_range(可以读取一次)
│ └── forward_range(可以多次读取)
│ └── bidirectional_range(可以双向迭代)
│ └── random_access_range(可以随机访问)
│ └── contiguous_range(元素在内存中连续)
└── output_range(可以写入)| 概念 | 要求 | 典型类型 |
|---|---|---|
std::ranges::range | 有 begin() 和 end() | 几乎所有容器和数组 |
std::ranges::input_range | 可以读取元素,至少遍历一次 | std::istream_iterator 包装的范围 |
std::ranges::output_range | 可以写入元素 | std::back_insert_iterator 包装的范围 |
std::ranges::forward_range | 可以多次遍历 | std::forward_list、std::unordered_set |
std::ranges::bidirectional_range | 可以双向遍历 | std::list、std::set、std::map |
std::ranges::random_access_range | 可以通过下标随机访问 | std::deque |
std::ranges::contiguous_range | 元素在内存中连续存储 | std::vector、std::array、std::string |
std::ranges::sized_range | 可以 O(1) 获取大小 | 大部分标准容器 |
std::ranges::common_range | begin 和 end 返回同一类型 | 大部分标准容器 |
std::ranges::borrowed_range | 迭代器生命周期不依赖范围 | std::string_view、std::span |
std::ranges::viewable_range | 可以转换为视图 | 大部分范围 |
std::ranges::constant_range(C++23) | 元素不可修改 | const 容器 |
基本示例
#include <iostream>
#include <vector>
#include <list>
#include <forward_list>
#include <deque>
#include <array>
#include <string>
#include <string_view>
#include <set>
#include <ranges>
#include <concepts>
#include <span>
// ============================
// 示例1:检测范围类别
// ============================
template<typename R>
void describe_range(const char* name) {
std::cout << name << ": ";
if constexpr (std::ranges::contiguous_range<R>)
std::cout << "contiguous ";
else if constexpr (std::ranges::random_access_range<R>)
std::cout << "random_access ";
else if constexpr (std::ranges::bidirectional_range<R>)
std::cout << "bidirectional ";
else if constexpr (std::ranges::forward_range<R>)
std::cout << "forward ";
else if constexpr (std::ranges::input_range<R>)
std::cout << "input ";
if constexpr (std::ranges::sized_range<R>)
std::cout << "sized ";
if constexpr (std::ranges::common_range<R>)
std::cout << "common ";
if constexpr (std::ranges::borrowed_range<R>)
std::cout << "borrowed ";
std::cout << std::endl;
}
void detect_demo() {
describe_range<std::vector<int>>("vector<int>");
describe_range<std::list<int>>("list<int>");
describe_range<std::forward_list<int>>("forward_list<int>");
describe_range<std::deque<int>>("deque<int>");
describe_range<std::array<int, 5>>("array<int,5>");
describe_range<std::string>("string");
describe_range<std::string_view>("string_view");
describe_range<std::set<int>>("set<int>");
describe_range<std::span<int>>("span<int>");
}
// ============================
// 示例2:用概念约束函数参数
// ============================
// 只接受可以随机访问的范围
void sort_range(std::ranges::random_access_range auto& r) {
std::ranges::sort(r);
}
// 只接受可以双向遍历的范围
void reverse_print(const std::ranges::bidirectional_range auto& r) {
for (auto it = std::ranges::rbegin(r); it != std::ranges::rend(r); ++it) {
std::cout << *it << " ";
}
std::cout << std::endl;
}
// 接受任何输入范围
void print_range(const std::ranges::input_range auto& r) {
for (const auto& elem : r) {
std::cout << elem << " ";
}
std::cout << std::endl;
}
// 只接受连续内存范围
void process_contiguous(std::ranges::contiguous_range auto& r) {
// 可以安全地获取底层指针
auto* ptr = std::ranges::data(r);
auto sz = std::ranges::size(r);
std::cout << "连续范围: 地址=" << ptr << " 大小=" << sz << std::endl;
}
void constraint_demo() {
std::vector<int> vec = {5, 3, 1, 4, 2};
std::list<int> lst = {5, 3, 1, 4, 2};
// vector 满足 random_access_range
sort_range(vec);
print_range(vec);
// list 满足 bidirectional_range,但不满足 random_access_range
// sort_range(lst); // 编译错误:list 不是 random_access_range
reverse_print(lst);
// vector 满足 contiguous_range
process_contiguous(vec);
}
// ============================
// 示例3:sized_range
// ============================
// 只接受可以高效获取大小的范围
template<std::ranges::sized_range R>
void print_with_size(const R& r) {
std::cout << "大小: " << std::ranges::size(r) << " 元素: ";
for (const auto& elem : r) {
std::cout << elem << " ";
}
std::cout << std::endl;
}
void sized_demo() {
std::vector<int> vec = {1, 2, 3};
std::list<int> lst = {4, 5, 6};
print_with_size(vec); // vector 是 sized_range
print_with_size(lst); // list 也是 sized_range
// forward_list 不是 sized_range(没有 size() 方法)
// std::forward_list<int> fwd = {7, 8, 9};
// print_with_size(fwd); // 编译错误
}
// ============================
// 示例4:borrowed_range
// ============================
// borrowed_range 的迭代器不依赖范围本身的生命周期
void borrowed_demo() {
// string_view 是 borrowed_range——迭代器指向外部字符串
std::string str = "hello world";
std::string_view sv = str;
// 从临时 string_view 获取的迭代器仍然有效
auto it = std::ranges::find(std::string_view("hello"), 'l');
// it 仍然有效,因为 string_view 是 borrowed_range
// span 也是 borrowed_range
int arr[] = {1, 2, 3, 4, 5};
auto it2 = std::ranges::find(std::span(arr), 3);
std::cout << "borrowed_range 查找结果: " << *it << ", " << *it2 << std::endl;
}
// ============================
// 示例5:common_range
// ============================
void common_demo() {
// 大部分容器是 common_range(begin 和 end 返回同一类型)
std::vector<int> vec = {1, 2, 3};
static_assert(std::ranges::common_range<std::vector<int>>);
// 某些视图不是 common_range(end 返回 sentinel)
auto view = std::views::iota(1, 10);
// iota_view 的 begin 和 end 可能返回不同类型
// 用 std::views::common 转换为 common_range
auto common_view = view | std::views::common;
// 现在 begin 和 end 返回同一类型,可以传给旧的算法
}
// ============================
// 示例6:ranges::begin/end/size/data
// ============================
void primitives_demo() {
std::vector<int> vec = {10, 20, 30, 40, 50};
int arr[] = {1, 2, 3};
// ranges::begin 和 ranges::end 统一的接口
auto b = std::ranges::begin(vec);
auto e = std::ranges::end(vec);
std::cout << "第一个元素: " << *b << std::endl;
// ranges::size
std::cout << "vector 大小: " << std::ranges::size(vec) << std::endl;
std::cout << "数组大小: " << std::ranges::size(arr) << std::endl;
// ranges::data(连续范围)
auto* ptr = std::ranges::data(vec);
std::cout << "数据指针: " << ptr << std::endl;
// ranges::empty
std::cout << "是否为空: " << std::boolalpha << std::ranges::empty(vec) << std::endl;
}
int main() {
std::cout << "=== 范围类别检测 ===" << std::endl;
detect_demo();
std::cout << "\n=== 概念约束 ===" << std::endl;
constraint_demo();
std::cout << "\n=== sized_range ===" << std::endl;
sized_demo();
std::cout << "\n=== borrowed_range ===" << std::endl;
borrowed_demo();
std::cout << "\n=== 范围基本操作 ===" << std::endl;
primitives_demo();
return 0;
}标准容器的范围类别
| 容器 | input | forward | bidirectional | random_access | contiguous | sized | common |
|---|---|---|---|---|---|---|---|
vector | Y | Y | Y | Y | Y | Y | Y |
array | Y | Y | Y | Y | Y | Y | Y |
string | Y | Y | Y | Y | Y | Y | Y |
deque | Y | Y | Y | Y | N | Y | Y |
list | Y | Y | Y | N | N | Y | Y |
forward_list | Y | Y | N | N | N | N | Y |
set/map | Y | Y | Y | N | N | Y | Y |
unordered_set/map | Y | Y | N | N | N | Y | Y |
| C 数组 | Y | Y | Y | Y | Y | Y | Y |
string_view | Y | Y | Y | Y | Y | Y | Y |
span | Y | Y | Y | Y | Y | Y | Y |
适用场景
- 用概念约束函数模板的参数(只接受特定类别的范围)
- 在 if constexpr 中根据范围类别选择不同算法
- 编写通用的范围处理函数
- 理解标准库算法对范围类别的要求
常见问题
range 和容器有什么区别?
range 是一个更广泛的概念——任何有 begin() 和 end() 的东西都是 range。容器拥有自己的元素,而 range 可以只是一个视图(不拥有元素)。所有容器都是 range,但不是所有 range 都是容器。
为什么需要 borrowed_range?
当你对一个临时范围调用算法(如 ranges::find(get_temp_vec(), 42)),返回的迭代器可能指向已销毁的临时对象。borrowed_range 标记那些迭代器不依赖范围生命周期的类型(如 string_view、span),让编译器知道从临时对象获取的迭代器是安全的。
什么是 sentinel?
sentinel 是 C++20 引入的概念,用来标记范围的结尾。和传统的 end() 返回同类型迭代器不同,sentinel 可以是不同类型——比如空终止字符串的 sentinel 可以是一个检查 '\0' 的特殊类型。common_range 要求 begin 和 end 返回相同类型。
注意事项
- 范围概念形成严格的层次结构(contiguous 包含 random_access 包含 bidirectional...)
sized_range是独立的——不是所有 forward_range 都是 sized_range(如forward_list)borrowed_range也是独立的——只有特定类型(如string_view、span)才满足- 使用
std::ranges::命名空间下的函数(如ranges::begin)而不是std::(如std::begin)来获得更好的范围支持 - C++23 新增了
constant_range概念
编译器支持情况
| 编译器 | Ranges 库 | 最低版本 |
|---|---|---|
| GCC | 支持 | 10.0 |
| Clang | 支持 | 13.0 |
| MSVC | 支持 | 19.29 (VS 2019 16.10) |
总结
C++20 的范围概念对可迭代类型做了系统化的分类,从最基本的 range(有 begin/end)到最强的 contiguous_range(元素连续存储),形成了清晰的层次结构。每个概念对应特定的能力:input_range 可读、forward_range 可多次遍历、bidirectional_range 可双向、random_access_range 可下标访问、contiguous_range 可用指针算术。还有独立的概念如 sized_range(高效获取大小)、borrowed_range(迭代器不依赖范围生命周期)、common_range(begin/end 同类型)。这些概念用于约束函数模板参数,让编译器在调用方提供了不满足要求的范围时给出清晰的错误信息。