视图概念(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() 方法。