Chapter 42: Ranges
核心问题与阅读主线
C++20 Ranges 把传统 STL 的“双 iterator 区间”升级为由 range 边界、iterator/sentinel 分离、concept 约束、projection 与延迟 view 管线组成的接口层。写好 Ranges 代码的关键不在语法更短,而在于判清谁拥有元素、约束落在哪一层以及求值何时触发。
全章共用代码样本(下文各节持续拆解)
本章用一个订单列表贯穿全章:std::vector<Order> 拥有元素存储,std::ranges::sort 立即原地排序,std::views::filter 与 std::views::transform 组成延迟管线,集中暴露边界检查、callable 约束与生命周期问题。
#include <algorithm>
#include <iostream>
#include <ranges>
#include <string>
#include <vector>
struct Order {
int id;
std::string customer;
int amount;
bool paid;
};
int main() {
std::vector<Order> orders{
{1, "Ada", 120, true},
{2, "Bjarne", 80, false},
{3, "Carol", 240, true},
{4, "Dennis", 60, false},
};
std::ranges::sort(orders, std::ranges::less{}, &Order::amount);
auto unpaid_amounts = orders
| std::views::filter([](const Order& order) { return !order.paid; })
| std::views::transform(&Order::amount);
for (int amount : unpaid_amounts) {
std::cout << amount << '\n';
}
}
这段样本同时呈现三条主线:orders 提供存储,立即执行的 std::ranges::sort 借助 &Order::amount 提取排序键,而 unpaid_amounts 只是尚未求值的 view 管线,直到 range-for 迭代才按需访问元素。
关键事实
std::ranges 并未废除传统 iterator-pair 算法;依据标准草案的 range requirements 与 algorithms requirements,std::ranges 算法的 range 重载会在约束检查通过后,经 ranges::begin(r) 与 ranges::end(r) 分派到底层 iterator/sentinel 实现。
42.1 range concept 与 iterator + sentinel
range 的核心定义是:对象 r 支持 std::ranges::begin(r) 返回起始迭代器、支持 std::ranges::end(r) 返回终止哨兵(sentinel),二者共同描述一个半开区间。与传统 iterator pair 要求两端同型不同,Ranges 把“当前位置”与“何时结束”拆开,只要满足 sentinel_for<S, I> 即可比较终止。
#include <ranges>
template <class T>
concept simplified_range = requires(T& value) {
std::ranges::begin(value);
std::ranges::end(value);
};
不同序列对 begin/end 的组合方式不同:标准容器(如 std::vector<int>)的迭代器与哨兵同型,称为 common_range;而输入流、条件截断或无界生成序列可用轻量 sentinel 仅保存终止条件(如读到流尾、命中条件或外部截断点)。
#include <algorithm>
#include <ranges>
#include <vector>
void sort_numbers(std::vector<int>& numbers) {
std::ranges::sort(numbers);
}
std::ranges::sort(numbers) 能通过编译,不只因为 numbers 是 range。与传统 std::sort(v.begin(), v.end()) 在模板深处报错不同,Ranges 将校验拆为三层显式检查:
| 检查层级 | 关键 concept / 机制 | 核心判定问题 | 典型示例 |
|---|---|---|---|
| 边界层 | range、common_range、sentinel_for<S, I> | 能否取得起止位置并判断结束 | 数组、容器、view |
| 能力层 | input_range、forward_range、bidirectional_range、random_access_range、contiguous_range | 迭代器支持单趟、多趟还是随机访问 | sort 要求 random_access_iterator |
| 语义层 | 元素可移动/交换、comparator 与 projection | 元素操作与 callable 是否满足算法契约 | sortable、严格弱序比较 |
核心判断
阅读 Ranges 代码先区分“拥有存储的容器”与“借用视图”:orders 是 owning range(拥有元素内存),unpaid_amounts 是 view 管线(仅提供新的 begin/end 访问层,元素仍留在 orders 中),后续所有生命周期判断都从这条边界出发。
42.2 std::ranges::begin / end 与 ranges algorithm
std::ranges::begin 与 std::ranges::end 是 customization point object(CPO),用于统一不同序列的边界获取规则。依据标准草案的 range access,CPO 按固定顺序解析边界,并拦截不安全的右值等 ill-formed 调用:
- 内置数组:直接产生首元素指针与尾后指针(数组没有成员
begin()); - 成员函数:优先调用对象自身的
r.begin()/r.end(); - 自由函数:通过参数依赖查找(ADL)匹配用户类型提供的
begin(r)/end(r)。
泛型代码应统一调用 std::ranges::begin(r) 而非 r.begin(),这样数组、标准容器、自定义类型以及临时 range 的 borrowed range 规则都能在 CPO 层集中处理:
#include <iostream>
#include <ranges>
void print_first(auto&& range) {
auto it = std::ranges::begin(range);
auto last = std::ranges::end(range);
if (it != last) {
std::cout << *it << '\n';
}
}
int main() {
int values[] = {10, 20, 30};
print_first(values);
}
定义在 std::ranges 命名空间中的算法是函数对象,通常同时提供“iterator/sentinel”与“整个 range”两类重载。例如标准草案 sorting algorithms 中的 std::ranges::sort,其 range 重载返回与生命周期相关的 borrowed_iterator_t<R>:
#include <algorithm>
#include <ranges>
#include <vector>
void two_entries(std::vector<int>& values) {
std::ranges::sort(values.begin(), values.end());
std::ranges::sort(values);
}
直接传入整个 range(std::ranges::sort(values))不只是少写一对边界调用,它在接口层带来三项实质收益:
- 消除跨容器误配:由算法统一调用
std::ranges::begin/end,杜绝“begin来自容器 A、end来自容器 B”的错配。 - 约束前移报错:签名直接声明
random_access_range、sortable、indirect_unary_predicate等 concept,失败点指向缺失的能力条件,而不是深藏在operator<、++it或it + n的模板展开里。 - 执行时机明确:
std::ranges算法在调用处立即遍历输入(原地修改或返回结果 iterator、subrange、布尔值),而 view adaptor 只构造轻量延迟管线。
排查顺序
阅读 std::ranges 算法源码或定位编译报错时,按四步追踪:1) 找到算法函数对象的公开重载签名;2) 看 range 重载如何分派到 iterator/sentinel 版本并计算 borrowed_iterator_t<R>;3) 核对签名上的 concept 约束;4) 检查循环体内的 ranges::begin/end、std::invoke、iter_move 与 iter_swap。
42.3 projection
Projection 的作用是在算法将元素交给 comparator、predicate 或目标值比较之前,先通过 std::invoke(proj, element) 完成键提取或成员映射;成员指针、函数对象与 lambda 都可作为投影参数。在订单排序中,Projection 把“取哪个字段”与“按什么序比较”拆成两个正交参数:
#include <algorithm>
#include <ranges>
#include <string>
#include <vector>
struct Order {
int id;
std::string customer;
int amount;
bool paid;
};
void traditional_sort(std::vector<Order>& orders) {
std::sort(orders.begin(), orders.end(), [](const Order& left, const Order& right) {
return left.amount < right.amount;
});
}
void ranges_sort(std::vector<Order>& orders) {
std::ranges::sort(orders, std::ranges::less{}, &Order::amount);
}
调用 std::ranges::sort 时,算法对元素 a、b 先计算 std::invoke(&Order::amount, a) 与 std::invoke(&Order::amount, b),再把两个金额整数交给通用比较器 std::ranges::less{}。同一套机制也适用于查找算法:
#include <algorithm>
#include <ranges>
#include <string>
#include <vector>
struct Order {
int id;
std::string customer;
int amount;
bool paid;
};
bool has_amount_240(const std::vector<Order>& orders) {
auto it = std::ranges::find(orders, 240, &Order::amount);
return it != orders.end();
}
Projection 让约束清晰落在接口上:查找要求 Order::amount 可与 240 比较,排序要求投影结果在 comparator 下满足严格弱序(标准草案也直接按 comparisons 与 projections 次数刻画排序复杂度)。
边界与误区
Projection 仅读取映射值,不改变底层元素存储;若投影返回引用且被 comparator/predicate 修改,会直接破坏算法不变式。工程上应把 projection 写成无副作用、低开销的纯键提取,避免修改元素、依赖可变外部状态或执行昂贵 I/O。
日常选型常在 projection 与 std::views::transform 之间取舍,二者职责分工如下:
| 对比维度 | Projection(算法 proj 参数) | std::views::transform |
|---|---|---|
| 执行位置 | 单次算法内部每次比较或判定前通过 std::invoke 调用 | 构造 view 管线并在迭代器解引用时转换 |
| 返回形态 | 不生成新 range,返回原 range 的 iterator 或算法结果 | 生成新的转换视图,元素类型为转换后结果 |
| 优先场景 | 单次排序、查找或去重按某字段判定 | 后续多个管线步骤或消费端持续使用转换后序列 |
42.4 lazy evaluation
在 Ranges 中,lazy evaluation 指 view adaptor 构造管线时只保存底层 range 与操作对象,把过滤和转换推迟到迭代器推进与解引用时发生。下面的代码让这一执行顺序直接可观测:
#include <iostream>
#include <ranges>
#include <vector>
int main() {
std::vector<int> values{1, 2, 3, 4};
auto pipeline = values
| std::views::filter([](int value) {
std::cout << "filter " << value << '\n';
return value % 2 == 0;
})
| std::views::transform([](int value) {
std::cout << "transform " << value << '\n';
return value * 10;
});
std::cout << "before loop\n";
for (int value : pipeline) {
std::cout << "result " << value << '\n';
}
}
运行时 before loop 会最先输出,随后每次循环才按需推进到下一个满足条件的元素;transform 仅作用于通过 filter 的元素,全程无需分配中间 std::vector<int>:
图中各环节之间并不缓冲中间结果:filter 迭代器在递增时跳过不满足条件的元素直到命中或抵达 sentinel,transform 迭代器在解引用时才调用转换函数。因此,省略中间分配的收益与延迟求值的运行时风险同源——源 range 的生命周期、可重入能力与谓词求值全部绑定到最终迭代时刻。
最常见的陷阱是返回引用了局部容器的 view 管线:
#include <ranges>
#include <vector>
// 简化示例:展示生命周期风险,工程代码应重新设计所有权。
auto dangling_pipeline() {
std::vector<int> values{1, 2, 3, 4};
return values | std::views::filter([](int value) { return value % 2 == 0; });
}
函数返回后局部 values 已销毁,返回的 view 持有悬垂引用;工程上应改由调用方传入存活期足够的 range、在函数内消费管线,或返回拥有结果的容器(或明确的 owning view 方案)。
汇总 view 管线的三项核心工程边界:
| 边界维度 | 触发根因 | 工程约束 |
|---|---|---|
| 生命周期 | view 通常仅持有底层 range 的非拥有引用 | 源对象必须覆盖管线从构造到最终迭代完成的全部存活期 |
| 重复遍历 | 部分数据源为单趟输入(如输入流 input_range) | 能否多趟遍历取决于底层类别(如 forward_range)与每层 adaptor 是否保留能力 |
| 副作用时机 | filter 与 transform 在迭代和解引用时反复触发 | 保持谓词与转换纯函数化,副作用统一放在 source → view pipeline → algorithm/loop 消费端 |
边界与误区
filter 谓词或 transform 若携带日志、修改外部变量或依赖时间,不仅会在每次迭代时触发,重复遍历或算法多次解引用同一位置还会造成重复执行;把副作用留在最终循环或输出端才能确保行为可复盘。
42.5 与传统 algorithm 对比
传统 STL algorithm 以 iterator pair 为接口核心,Ranges algorithm 则把区间边界、ability concept、projection 与 view 组合全部纳入标准接口层。传统写法的优势在于兼容 C++11 及海量既有第三方接口;Ranges 的价值则不仅是“少写 begin/end”,而是把区间归属、键提取与约束检查明确写进函数签名:
#include <algorithm>
#include <ranges>
#include <string>
#include <vector>
struct Order {
int id;
std::string customer;
int amount;
bool paid;
};
void compare_styles(std::vector<Order>& orders) {
std::sort(orders.begin(), orders.end(), [](const Order& left, const Order& right) {
return left.amount < right.amount;
});
std::ranges::sort(orders, std::ranges::less{}, &Order::amount);
}
两代接口在七个工程维度上的取舍如下:
| 对比维度 | 传统 STL algorithm | C++20 Ranges |
|---|---|---|
| 接口边界 | 接收 first, last,调用者保证二者属同一有效区间 | 可直接传入 range,由算法统一调用 ranges::begin/end |
| 终止模型 | 多数要求首尾 iterator 同型 | 支持 iterator + sentinel 异型终止,覆盖条件与流式序列 |
| 类型约束 | 依赖模板参数命名,实例化深处才暴露类型错误 | 通过 range、sortable 等 concept 在签名处前置检查 |
| 键提取 | 常把字段访问混入 comparator / predicate lambda | 通过 projection 单独提取键,保持 comparator 通用 |
| 组合方式 | 每次调用对应一次独立遍历,串联常需中间容器 | 支持用 view adaptor 拼装可组合管线后再统一消费 |
| 执行时机 | 调用即立即执行 | std::ranges 算法立即执行;view adaptor 延迟到迭代执行 |
| 生命周期风险 | 仍存在 iterator 失效风险 | view 管线会将源对象引用存入表达式,需额外校验源存活期 |
将旧代码迁移至 Ranges 时,可按以下五步核对:
- 标准与工具链:确认目标模块已启用 C++20 且标准库支持 ranges。
- range 与借用检查:确认输入满足
range,若传入临时右值则检查是否满足 borrowed range。 - 能力匹配:核对算法所需的 iterator 能力(如
sort需随机访问,find仅需输入迭代)。 - 拆分 projection:把成员访问从 lambda 挪至
projection参数,保留纯比较逻辑在 comparator。 - 管线生命周期:若引入 view 管线,明确最终消费点与源对象的存活覆盖关系。
以下迁移后的查找函数展示 std::ranges::find 配合 projection 的常见用法:
#include <algorithm>
#include <ranges>
#include <string>
#include <vector>
struct Order {
int id;
std::string customer;
int amount;
bool paid;
};
Order* find_order(std::vector<Order>& orders, int id) {
auto it = std::ranges::find(orders, id, &Order::id);
if (it == orders.end()) {
return nullptr;
}
return &*it;
}
边界与误区
find_order 虽未创建中间容器,但返回的 Order*(以及内部得到的 iterator)依然受 std::vector<Order> 自身的失效规则支配:一旦后续发生扩容、元素删除或容器销毁,指针即刻悬垂。Ranges 改善的是算法调用契约,不会改变底层容器的失效语义。
最小自检任务
阅读下面代码,从 range 边界、执行时机与生命周期三个维度判断:std::ranges::sort 调用后 orders 是否已完成排序、&Order::amount 作用在哪个对象上,以及函数返回后 result 能否安全迭代。
#include <algorithm>
#include <ranges>
#include <string>
#include <vector>
struct Order {
int id;
std::string customer;
int amount;
bool paid;
};
auto make_result() {
std::vector<Order> orders{
{1, "Ada", 120, true},
{2, "Bjarne", 80, false},
{3, "Carol", 240, true},
};
std::ranges::sort(orders, std::ranges::less{}, &Order::amount);
auto result = orders
| std::views::filter([](const Order& order) { return order.paid; })
| std::views::transform(&Order::customer);
return result;
}
本章知识点总结
- range 与 sentinel 分离
std::ranges::begin(r)与std::ranges::end(r)定义半开区间,sentinel 可与 iterator 异型(如条件截断或流结束),满足sentinel_for<S, I>即可判断终止。 - 三层能力检查
range仅保证边界可取,算法还会在签名上通过 concept 前置核对 iterator 能力(如random_access_iterator)与元素可比较/可交换等语义约束。 - CPO 统一入口
std::ranges::begin/end按内置数组、成员函数、ADL 自由函数顺序获取边界,让std::ranges算法能以统一接口覆盖数组、容器与视图。 - projection 与 comparator 解耦
std::invoke(proj, elem)在比较前提取键,把字段访问留给 projection、把序关系留给 comparator,且 projection 应保持无副作用。 - 立即算法与延迟管线
std::ranges::sort等算法立即遍历并可能修改输入;std::views管线仅保存访问结构,筛选与转换推迟到迭代与解引用时按需执行。 - view 生命周期与遍历能力
view 不拥有底层存储,源 range 寿命必须覆盖迭代全周期;管线能否多次遍历取决于底层
range类别及各层 adaptor 是否保留能力。 - 迁移与容器失效边界
迁移旧算法应依次核对 C++20 支持、range/borrowed 约束、iterator 能力、projection 拆分与生命周期,但返回的 iterator/指针仍受底层容器失效规则约束。