Namespaces
Variants

std::ranges:: owning_view

From cppreference.net
C++
Ranges library
Range adaptors
Defined in header <ranges>
template < ranges:: range R >

requires std:: movable < R > && ( ! /*is-initializer-list*/ < R > )
class owning_view

: public ranges:: view_interface < owning_view < R >>
(since C++20)

owning_view is a view that has unique ownership of a range . It is move-only and stores that range within it.

The constant /*is-initializer-list*/ < R > in the requires clause is true if and only if std:: remove_cvref_t < R > is a specialization of std::initializer_list .

Contents

Data members

Member Description
R r_ the underlying range
( exposition-only member object* )

Member functions

constructs an owning_view by value-initializing or move-constructing the stored range
(public member function)
move-assigns the stored range
(public member function)
returns a reference to the stored range
(public member function)
returns the beginning iterator of the stored range
(public member function)
returns the sentinel of the stored range
(public member function)
checks whether the stored range is empty
(public member function)
returns the size of the stored sized_range
(public member function)
(C++26)
returns the approximate size of the stored approximately_sized_range
(public member function)
returns the pointer to the beginning of the stored contiguous_range
(public member function)
Inherited from std::ranges::view_interface
(C++23)
returns a constant iterator to the beginning of the range
(public member function of std::ranges::view_interface<D> )
(C++23)
returns a sentinel for the constant iterator of the range
(public member function of std::ranges::view_interface<D> )
returns whether the derived view is not empty, provided only if ranges::empty is applicable to it
(public member function of std::ranges::view_interface<D> )
returns the first element in the derived view, provided if it satisfies forward_range
(public member function of std::ranges::view_interface<D> )
returns the last element in the derived view, provided only if it satisfies bidirectional_range and common_range
(public member function of std::ranges::view_interface<D> )
returns the n th element in the derived view, provided only if it satisfies random_access_range
(public member function of std::ranges::view_interface<D> )

std::ranges::owning_view:: owning_view

owning_view ( ) requires std:: default_initializable < R > = default ;
(1) (since C++20)
owning_view ( owning_view && other ) = default ;
(2) (since C++20)
constexpr owning_view ( R && t ) ;
(3) (since C++20)
1) Default constructor. Value-initializes r_ by its default member initializer ( = R ( ) ).
2) Move constructor. Move constructs r_ from that of other .
3) Move constructs r_ from t .

Parameters

other - another owning_view to move from
t - range to move from

Notes

owning_view does not explicitly define a copy constructor. owning_view is move-only.

std::ranges::owning_view:: operator=

owning_view & operator = ( owning_view && other ) = default ;
(since C++20)

Move assignment operator. Move assigns r_ from that of other .

Parameters

other - another owning_view to move from

Return value

* this

Notes

owning_view does not explicitly define a copy assignment operator. owning_view is move-only.

std::ranges::owning_view:: base

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

Returns a reference to the stored range, keeping value category and const-qualification.

Return value

1,2) r_
3,4) std :: move ( r_  )

std::ranges::owning_view:: begin

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

Returns ranges:: begin ( r_  ) .

std::ranges::owning_view:: end

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

Returns ranges:: end ( r_  ) .

std::ranges::owning_view:: empty

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

Returns ranges:: empty ( r_  ) .

std::ranges::owning_view:: size

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

Returns ranges:: size ( r_  ) .

std::ranges::owning_view:: reserve_hint

constexpr auto reserve_hint ( )
requires ranges :: approximately_sized_range < R > ;
(1) (since C++26)
constexpr auto reserve_hint ( ) const
requires ranges :: approximately_sized_range < const R > ;
(2) (since C++26)

Returns ranges :: reserve_hint ( r_  ) .

std::ranges::owning_view:: data

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

Returns ranges:: data ( r_  ) .

Helper templates

template < class T >

constexpr bool enable_borrowed_range < std :: ranges :: owning_view < T >> =

ranges:: enable_borrowed_range < T > ;
(since C++20)

This specialization of ranges:: enable_borrowed_range makes owning_view satisfy borrowed_range when the underlying range satisfies it.

Notes

Feature-test macro Value Std Feature
__cpp_lib_ranges_reserve_hint 202502L (C++26) ranges::approximately_sized_range and reserve_hint

Example

Run this code 
#include <cassert>
#include <iostream>
#include <ranges>
#include <string>
int main()
{
    using namespace std::literals;
    std::ranges::owning_view ov{"cosmos"s}; // the deduced type of R is std::string;
                                            // “ov” is the only owner of this string
    assert(
        ov.empty() == false &&
        ov.size() == 6 &&
        ov.size() == ov.base().size() &&
        ov.front() == 'c' &&
        ov.front() == *ov.begin() &&
        ov.back() == 's' &&
        ov.back() == *(ov.end() - 1) &&
        ov.data() == ov.base()
    );
    std::cout << "sizeof(ov): " << sizeof ov << '\n' // typically equal to sizeof(R)
              << "range-for: ";
    for (const char ch : ov)
        std::cout << ch;
    std::cout << '\n';
    std::ranges::owning_view<std::string> ov2;
    assert(ov2.empty());
//  ov2 = ov; // compile-time error: copy assignment operator is deleted
    ov2 = std::move(ov); // OK
    assert(ov2.size() == 6);
}

Possible output: 

sizeof(ov): 32
range-for: cosmos

See also

(C++20)
a view of the elements of some other range
(class template)
(C++20)
a view that includes all elements of a range
(alias template) (range adaptor object)