视图概念(View Concepts)
什么是视图(View)
视图是 C++20 Ranges 库中的核心概念。简单来说,视图是一种轻量级的、惰性求值的范围,它不拥有数据,只是描述了对底层范围要做的操作。视图的构造、移动和析构都是 O(1) 的,和底层数据量无关。
视图的关键特征:
- 惰性求值——创建视图时不做任何计算,只有在迭代时才逐个处理元素
- 不拥有数据——视图引用底层范围的元素,不复制它们
- O(1) 移动和析构——无论底层有多少元素
- 可组合——多个视图可以通过管道运算符
|串联
view 概念的定义
cpp
namespace std::ranges {
template<class T>
concept view = range<T> && movable<T> && enable_view<T>;
}一个类型要满足 view 概念,需要:
- 是一个
range(有 begin/end) - 是
movable的 - 通过
enable_view标记为视图
视图 vs 容器
| 特性 | 容器(如 vector) | 视图(如 filter_view) |
|---|---|---|
| 拥有元素 | 是 | 否(通常引用底层范围) |
| 拷贝开销 | O(N)——拷贝所有元素 | O(1) 或不可拷贝 |
| 移动开销 | O(1) | O(1) |
| 析构开销 | O(N)——释放所有元素 | O(1) |
| 求值方式 | 即时——元素立刻存在 | 惰性——迭代时才计算 |
| 管道组合 | 不支持 | 支持 ` |
| 内存分配 | 需要 | 不需要 |
如何创建自定义视图
有两种方式让自定义类型成为视图:
- 继承
std::ranges::view_interface<YourView>(推荐,CRTP 方式) - 继承
std::ranges::view_base - 特化
std::ranges::enable_view<YourView>为true
基本示例
cpp
#include <iostream>
#include <vector>
#include <ranges>
#include <string>
#include <algorithm>
// ============================
// 示例1:标准库中的视图
// ============================
void standard_views_demo() {
std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// filter_view:过滤偶数(惰性求值)
auto evens = data | std::views::filter([](int x) { return x % 2 == 0; });
// transform_view:每个元素乘以 10(惰性求值)
auto scaled = data | std::views::transform([](int x) { return x * 10; });
// take_view:只取前 5 个
auto first_five = data | std::views::take(5);
// 组合多个视图
auto pipeline = data
| std::views::filter([](int x) { return x % 2 == 0; })
| std::views::transform([](int x) { return x * x; })
| std::views::take(3);
// 迭代时才真正计算
std::cout << "偶数: ";
for (int v : evens) std::cout << v << " ";
std::cout << std::endl;
std::cout << "乘以10: ";
for (int v : scaled) std::cout << v << " ";
std::cout << std::endl;
std::cout << "前5个: ";
for (int v : first_five) std::cout << v << " ";
std::cout << std::endl;
std::cout << "组合管道: ";
for (int v : pipeline) std::cout << v << " "; // 4 16 36
std::cout << std::endl;
}
// ============================
// 示例2:视图是惰性的
// ============================
void lazy_demo() {
std::vector<int> data = {1, 2, 3, 4, 5};
int call_count = 0;
// 创建视图——此时 lambda 还没有被调用
auto view = data | std::views::transform([&call_count](int x) {
call_count++;
return x * x;
});
std::cout << "创建视图后的调用次数: " << call_count << std::endl; // 0
// 迭代——这时 lambda 才被调用
for (int v : view) {
// 每次迭代调用一次 lambda
}
std::cout << "迭代后的调用次数: " << call_count << std::endl; // 5
// 再次迭代——lambda 再次被调用(视图不缓存结果)
call_count = 0;
for (int v : view) {
// 再次调用
}
std::cout << "第二次迭代后的调用次数: " << call_count << std::endl; // 5
}
// ============================
// 示例3:视图不拥有数据
// ============================
void non_owning_demo() {
std::vector<int> data = {1, 2, 3, 4, 5};
// 视图引用 data 的元素
auto view = data | std::views::transform([](int x) { return x * 2; });
std::cout << "原始: ";
for (int v : view) std::cout << v << " ";
std::cout << std::endl;
// 修改底层数据
data[0] = 100;
// 视图反映修改
std::cout << "修改后: ";
for (int v : view) std::cout << v << " ";
std::cout << std::endl;
// 第一个元素变成 200(100 * 2)
}
// ============================
// 示例4:自定义视图(view_interface)
// ============================
// 自定义视图:返回范围中的每隔一个元素
template<std::ranges::forward_range R>
class stride_view : public std::ranges::view_interface<stride_view<R>> {
R base_; // 底层范围
int step_; // 步长
// 自定义迭代器
struct iterator {
using base_iter = std::ranges::iterator_t<R>;
using sentinel = std::ranges::sentinel_t<R>;
base_iter current_;
sentinel end_;
int step_;
using value_type = std::ranges::range_value_t<R>;
using difference_type = std::ranges::range_difference_t<R>;
iterator() = default;
iterator(base_iter begin, sentinel end, int step)
: current_(begin), end_(end), step_(step) {}
auto& operator*() const { return *current_; }
iterator& operator++() {
for (int i = 0; i < step_ && current_ != end_; ++i) {
++current_;
}
return *this;
}
iterator operator++(int) {
auto tmp = *this;
++(*this);
return tmp;
}
bool operator==(const iterator& other) const {
return current_ == other.current_;
}
bool operator!=(const iterator& other) const {
return !(*this == other);
}
// 哨兵比较
bool operator==(std::default_sentinel_t) const {
return current_ == end_;
}
};
public:
stride_view() = default;
stride_view(R base, int step) : base_(std::move(base)), step_(step) {}
auto begin() {
return iterator(std::ranges::begin(base_),
std::ranges::end(base_), step_);
}
auto end() {
return std::default_sentinel;
}
};
void custom_view_demo() {
std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 使用自定义视图:每隔 3 个取一个
stride_view sv(std::views::all(data), 3);
std::cout << "每隔3个: ";
for (int v : sv) std::cout << v << " ";
std::cout << std::endl;
// 输出: 1 4 7 10
}
// ============================
// 示例5:ref_view 和 owning_view
// ============================
void ref_owning_demo() {
std::vector<int> data = {1, 2, 3, 4, 5};
// ref_view:引用左值范围(不拥有数据)
auto rv = std::views::all(data);
// 等价于 std::ranges::ref_view(data)
// 检测是否是视图
static_assert(std::ranges::view<decltype(rv)>);
// 检测 vector 本身不是视图
static_assert(!std::ranges::view<std::vector<int>>);
std::cout << "ref_view: ";
for (int v : rv) std::cout << v << " ";
std::cout << std::endl;
}
// ============================
// 示例6:iota_view 生成视图
// ============================
void generator_view_demo() {
// iota_view:生成序列,不存储任何数据
auto numbers = std::views::iota(1, 11); // 1 到 10
std::cout << "iota: ";
for (int v : numbers) std::cout << v << " ";
std::cout << std::endl;
// 无穷序列 + take
auto first_20 = std::views::iota(1) | std::views::take(20);
std::cout << "前20个自然数: ";
for (int v : first_20) std::cout << v << " ";
std::cout << std::endl;
// empty_view 和 single_view
auto empty = std::views::empty<int>;
auto single = std::views::single(42);
std::cout << "single_view: ";
for (int v : single) std::cout << v << " ";
std::cout << std::endl;
}
int main() {
std::cout << "=== 标准视图 ===" << std::endl;
standard_views_demo();
std::cout << "\n=== 惰性求值 ===" << std::endl;
lazy_demo();
std::cout << "\n=== 非拥有 ===" << std::endl;
non_owning_demo();
std::cout << "\n=== 自定义视图 ===" << std::endl;
custom_view_demo();
std::cout << "\n=== ref_view ===" << std::endl;
ref_owning_demo();
std::cout << "\n=== 生成视图 ===" << std::endl;
generator_view_demo();
return 0;
}标准库提供的视图工厂
| 视图 | 说明 | 版本 |
|---|---|---|
views::empty<T> | 空视图 | C++20 |
views::single(val) | 只包含一个元素的视图 | C++20 |
views::iota(start) | 无限递增序列 | C++20 |
views::iota(start, end) | 有限递增序列 | C++20 |
views::istream<T>(stream) | 从流中读取元素 | C++20 |
views::repeat(val)(C++23) | 无限重复同一个值 | C++23 |
views::repeat(val, n)(C++23) | 重复 n 次 | C++23 |
适用场景
- 对数据进行过滤、变换、截取等操作而不分配新内存
- 用管道运算符组合多个操作
- 处理大数据集时避免中间容器的分配
- 惰性求值——只计算需要的元素
- 创建无限序列(配合 take 使用)
常见问题
视图会缓存计算结果吗?
大部分视图不缓存。每次迭代都会重新计算。有些视图(如 filter_view)会缓存 begin() 的结果以保证多次调用 begin() 返回一致的迭代器,但元素本身不会缓存。
视图的生命周期需要注意什么?
视图通常不拥有底层数据,所以必须确保底层范围在视图使用期间保持有效。对临时范围创建视图可能导致悬空引用。
owning_view 是什么?
owning_view(C++20 引入)是一个拥有底层范围的视图。它通过移动获取范围的所有权,解决了对临时范围创建视图的生命周期问题。
为什么 vector 不是 view?
因为 vector 的拷贝是 O(N) 的——拷贝时要复制所有元素。view 概念要求拷贝(如果可拷贝的话)是 O(1) 的。
注意事项
- 视图不拥有数据,底层范围必须在视图使用期间保持有效
- 视图是惰性的,不缓存结果——多次迭代会多次计算
- 视图的构造、移动和析构是 O(1) 的
- 自定义视图推荐继承
view_interface - 不要对临时容器创建视图(会悬空),除非使用
owning_view - C++23 放宽了 view 的部分要求(不再要求
default_initializable)
编译器支持情况
| 编译器 | Ranges 视图 | 最低版本 |
|---|---|---|
| GCC | 支持 | 10.0 |
| Clang | 支持 | 13.0 |
| MSVC | 支持 | 19.29 |
总结
视图是 C++20 Ranges 库的核心抽象——一种轻量级、惰性求值、不拥有数据的范围。视图在创建时不做任何计算,只有迭代时才逐个处理元素,避免了中间容器的内存分配。多个视图可以通过管道运算符 | 组合成处理流水线。视图的构造、移动和析构都是 O(1) 的,和数据量无关。标准库提供了丰富的视图适配器(filter、transform、take 等)和视图工厂(iota、empty、single 等)。自定义视图可以通过继承 view_interface 来实现,只需提供 begin() 和 end() 方法。