范围概念(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_rangebegin 和 end 返回同一类型大部分标准容器
std::ranges::borrowed_range迭代器生命周期不依赖范围std::string_view、std::span
std::ranges::viewable_range可以转换为视图大部分范围
std::ranges::constant_range(C++23)元素不可修改const 容器

基本示例 ​

cpp
#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;
}

标准容器的范围类别 ​

容器inputforwardbidirectionalrandom_accesscontiguoussizedcommon
vectorYYYYYYY
arrayYYYYYYY
stringYYYYYYY
dequeYYYYNYY
listYYYNNYY
forward_listYYNNNNY
set/mapYYYNNYY
unordered_set/mapYYNNNYY
C 数组YYYYYYY
string_viewYYYYYYY
spanYYYYYYY

适用场景 ​

  • 用概念约束函数模板的参数(只接受特定类别的范围)
  • 在 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 同类型)。这些概念用于约束函数模板参数,让编译器在调用方提供了不满足要求的范围时给出清晰的错误信息。