Skip to main content

Chapter 42: Ranges

核心问题与阅读主线

本章导读5 个核心小节 · 附自检与总结

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 algorithmC++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 时,可按以下五步核对:

  1. 标准与工具链:确认目标模块已启用 C++20 且标准库支持 ranges。
  2. range 与借用检查:确认输入满足 range,若传入临时右值则检查是否满足 borrowed range。
  3. 能力匹配:核对算法所需的 iterator 能力(如 sort 需随机访问,find 仅需输入迭代)。
  4. 拆分 projection:把成员访问从 lambda 挪至 projection 参数,保留纯比较逻辑在 comparator。
  5. 管线生命周期:若引入 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/指针仍受底层容器失效规则约束。