# std::ranges::owning_view

< cpp‎ | ranges

定义于头文件 `<ranges>` |  |
template<ranges::range R> requires std::movable<R> && (!/*is-initializer-list*/<R>) class owning_view : public ranges::view_interface<owning_view<R>> |  | (C++20 起)

`owning_view` 是拥有 `range` 的独占所有权的 `view` 。它为仅移动并在其内部存储该 `range` 。

requires 子句中的 /*is-initializer-list*/<R> 为 true 当且仅当 std::remove_cvref_t<R> 为 std::initializer_list 的特化。

### 数据成员

`owning_view` 的典型实现仅拥有一个非静态数据成员： `R` 类型的底层范围。此处显示该成员为 `r_` （名字仅用于阐释）。

### 成员函数

(构造函数) (C++20) | 通过值初始化或移动构造存储的范围构造 `owning_view` (公开成员函数)
operator= (C++20) | 移动赋值存储的范围 (公开成员函数)
base (C++20) | 返回到存储的范围的引用 (公开成员函数)
begin (C++20) | 返回存储的范围的起始迭代器 (公开成员函数)
end (C++20) | 返回存储的范围的哨位 (公开成员函数)
empty (C++20) | 检查存储的范围是否为空 (公开成员函数)
size (C++20) | 返回存储的 `sized_range` 的大小 (公开成员函数)
data (C++20) | 返回指向存储的 `contiguous_range` 起始的指针 (公开成员函数)
##### 继承自 std::ranges::view_interface
operator bool (C++20) | 返回派生视图是否为非空。若 ranges::empty 可应用于它则提供。 (`std::ranges::view_interface<D>` 的公开成员函数)
front (C++20) | 返回派生视图中的首元素。若视图满足 `forward_range` 则提供。 (`std::ranges::view_interface<D>` 的公开成员函数)
back (C++20) | 返回派生视图中的末元素。若视图满足 `bidirectional_range` 与 `common_range` 则提供。 (`std::ranges::view_interface<D>` 的公开成员函数)
operator[] (C++20) | 返回派生视图中的第 n 个元素。若视图满足 `random_access_range` 则提供。 (`std::ranges::view_interface<D>` 的公开成员函数)

## std::ranges::owning_view::owning_view

owning_view() requires std::default_initializable<R> = default; | (1) | (C++20 起)
owning_view( owning_view&& other ) = default; | (2) | (C++20 起)
constexpr owning_view( R&& t ); | (3) | (C++20 起)
owning_view( const owning_view& ) = delete; | (4) | (C++20 起)

1) 默认构造函数。由其默认成员初始化器（= R()）值初始化存储的范围。
2) 复制构造函数。从 `other` 的存储范围移动构造存储范围。
3) 从 `t` 移动构造存储范围。
4) 复制构造函数被删除。 `owning_view` 为仅移动。

### 参数

other | - | 要移动的 `owning_view`
t | - | 要移动的范围

## std::ranges::owning_view::operator=

owning_view& opeartor=( owning_view&& other ) = default; | (1) | (C++20 起)
owning_view& operator=( const owning_view& ) = delete; | (2) | (C++20 起)

1) 移动赋值运算符。从 `other` 的存储范围移动赋值存储范围。
2) 复制赋值运算符被删除。 `owning_view` 为仅移动。

### 参数

other | - | 要移动的另一 `owning_view`

### 返回值

*this 。

## std::ranges::owning_view::base

constexpr R& base() & noexcept; | (1) | (C++20 起)
constexpr const R& base() const & noexcept; | (2) | (C++20 起)
constexpr R&& base() && noexcept; | (3) | (C++20 起)
constexpr const R&& base() const && noexcept; | (4) | (C++20 起)

返回到存储的范围的引用，保持值类别与 const 限定。

1-2) 等价于 return r_; 。
3-4) 等价于 return std::move(r_); 。

## std::ranges::owning_view::begin

constexpr ranges::iterator_t<R> begin(); | (1) | (C++20 起)
constexpr auto begin() const requires ranges::range<const R>; | (2) | (C++20 起)

等价于 return ranges::begin(r_); 。

## std::ranges::owning_view::end

constexpr ranges::sentinel_t<R> end(); | (1) | (C++20 起)
constexpr auto end() const requires ranges::range<const R>; | (2) | (C++20 起)

等价于 return ranges::end(r_); 。

## std::ranges::owning_view::empty

constexpr bool empty() requires requires { ranges::empty(r_); }; | (1) | (C++20 起)
constexpr bool empty() const requires requires { ranges::empty(r_); }; | (2) | (C++20 起)

等价于 return ranges::empty(r_); 。

## std::ranges::owning_view::size

constexpr auto size() requires ranges::sized_range<R>; | (1) | (C++20 起)
constexpr auto size() const requires ranges::sized_range<const R>; | (2) | (C++20 起)

等价于 return ranges::size(r_); 。

## std::ranges::owning_view::data

constexpr auto data() requires ranges::contiguous_range<R>; | (1) | (C++20 起)
constexpr auto data() const requires ranges::contiguous_range<const R>; | (2) | (C++20 起)

等价于 return ranges::data(r_); 。

### 辅助模板

template<class T> inline constexpr bool enable_borrowed_range<std::ranges::owning_view<T>> = std::ranges::enable_borrowed_range<T>; |  | (C++20 起)

`std::ranges::enable_borrowed_range` 的此特化使得 `owning_view` 在底层范围满足 `borrowed_range` 时满足它。

### 示例

    #include <ranges>
    #include <string>
    #include <cassert>
    #include <iostream>

    int main()
    {
        using namespace std::literals;
        std::ranges::owning_view ov{ "cosmos"s }; // 推导的 R 类型为 std::string ；
                                                  // `ov` 为此字符串的唯一所有者
        std::cout
            << std::boolalpha
            << "call empty() : " << ov.empty() << '\n'
            << "call size()  : " << ov.size() << '\n'
            << "call front() : " << ov.front() << '\n' // 同 *(ov.begin())
            << "call back()  : " << ov.back() << '\n' // 等于 *(ov.end()-1)
            << "call data()  : " << ov.data() << '\n'
            << "call base()  : " << ov.base().size() << '\n' // ~> ov.size()
            << "sizeof(ov)   : " << sizeof(ov) << '\n' // 常等于 sizeof(R)
            << "range-for    : \"";

        for (const char c: ov)
            std::cout << c;
        std::cout << "\"\n";

        std::ranges::owning_view<std::string> ov2;
        assert(ov2.empty());
    //  ov2 = ov; // 编译时错误：复制赋值运算符被删除
        ov2 = std::move(ov); // OK
        assert(ov.empty());
        assert(ov2.size() == 6);
    }

可能的输出：

    call empty() : false
    call size()  : 6
    call front() : c
    call back()  : s
    call data()  : cosmos
    call base()  : 6
    sizeof(ov)   : 32
    range-for    : "cosmos"

### 参阅

ranges::ref_view (C++20) | 某个其他 `range` 的元素的 `view` (类模板)
views::all_t views::all (C++20) | 包含 `range` 的所有元素的 `view` (别名模板) (范围适配器对象)