Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/ranges/ref view"

From cppreference.com
< cpp‎ | ranges
(P1870R1 safe_range)
m (rm members' rev-tags.)
 
(17 intermediate revisions by 5 users not shown)
Line 1: Line 1:
−
{{cpp/ranges/title | ref_view}}
+
{{cpp/ranges/title|ref_view}}
 
{{cpp/ranges/navbar}}
 
{{cpp/ranges/navbar}}
  
−
{{dcl begin}}
+
{{ddcl|header=ranges|since=c++20|1=
−
{{dcl header | ranges}}
+
template< ranges::range R >
−
{{dcl | since=c++20 | 1=
+
−
template<ranges::range R>
+
 
     requires std::is_object_v<R>
 
     requires std::is_object_v<R>
−
class ref_view : public ranges::view_interface<ref_view<R>>
+
class ref_view
 +
    : public ranges::view_interface<ref_view<R>>
 
}}
 
}}
−
{{dcl end}}
 
  
−
{{tt|ref_­view}} is a {{lconcept|view}} of the elements of some other {{lconcept|range}}. It wraps a reference to that {{tt|range}}.
+
{{tt|ref_view}} is a {{lconcept|view}} of the elements of some other {{lconcept|range}}. It wraps a reference to that {{tt|range}}.
−
 
+
−
===Helper template===
+
−
{{ddcl|1=
+
−
template<class T>
+
−
inline constexpr bool enable_safe_range<ranges::ref_view<T>> = true;
+
−
}}
+
−
This specialization of {{ltt|cpp/ranges/safe_range|std::ranges::enable_safe_range}} makes {{tt|ref_view}} satisfy {{lconcept|safe_range}}.
+
  
 
===Data members===
 
===Data members===
−
{{member | {{small|std::ranges::ref_view::}}r_ |
+
{{dsc begin}}
−
{{dcl begin}}
+
{{dsc hitem|Member name|Definition}}
−
{{dcl |1=
+
{{dsc expos mem obj|r_|private=yes|A pointer of type {{tt|R*}} to the underlying range.}}
−
R* r_ = nullptr; /* exposition-only */
+
{{dsc end}}
−
}}
+
−
{{dcl end}}
+
−
pointer to the referenced range
+
−
}}
+
  
 
===Member functions===
 
===Member functions===
−
{{member | {{small|std::ranges::ref_view::}}ref_view | 2=
+
{{dsc begin}}
−
{{dcl begin}}
+
{{dsc mem ctor|{{PAGENAME}}#ctor|constructs a {{tt|ref_view}} that references to the given range}}
−
{{dcl | num=1 |1=
+
{{dsc mem fun|title=base|{{PAGENAME}}#base|returns the references to the referenced range}}
−
constexpr ref_view() noexcept = default;
+
{{dsc mem fun|title=begin|{{PAGENAME}}#begin|returns the beginning iterator of the referenced range}}
−
}}
+
{{dsc mem fun|title=end|{{PAGENAME}}#end|returns the sentinel of the referenced range}}
−
{{dcl | num=2 |1=
+
{{dsc mem fun|title=empty|{{PAGENAME}}#empty|checks whether the referenced range is empty}}
−
template<__NotSameAs<ref_view> T>
+
{{dsc mem fun|title=size|{{PAGENAME}}#size|returns the size of the referenced {{lconcept|sized_range}}}}
 +
{{dsc mem fun|title=data|{{PAGENAME}}#data|returns the pointer to the beginning of the referenced {{lconcept|contiguous_range}}}}
 +
 
 +
{{cpp/ranges/view_interface/inherit|embedded=yes|empty=yes|size=yes|data=yes}}
 +
{{dsc end}}
 +
 
 +
{{anchor|ctor}}
 +
{{member|{{small|std::ranges::ref_view::}}ref_view|2=
 +
{{ddcl|since=c++20|
 +
template< /*different-from*/<ref_view> T >
 
     requires std::convertible_to<T, R&> && requires { _FUN(std::declval<T>()); }
 
     requires std::convertible_to<T, R&> && requires { _FUN(std::declval<T>()); }
−
constexpr ref_view(T&& t);
+
constexpr ref_view( T&& t );
 
}}
 
}}
−
{{dcl end}}
 
  
−
@1@ Initializes {{tt|r_}} with {{c|nullptr}}. A default-initialized {{tt|ref_view}} references no {{lconcept|range}}.
+
Initializes {{tti|r_}} with {{c|std::addressof(static_cast<R&>(std::forward<T>(t)))}}.
−
@2@ Initializes {{tt|r_}} with {{c|std::addressof(static_­cast<R&>(std::forward<T>(t)))}}.
+
  
−
Names {{tt|__NotSameAs}} and {{tt|_FUN}} are exposition-only. {{tt|__NotSameAs<T, U>}} is satisfied if and only if {{c|!std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U>>}}. The function {{tt|_FUN}} are declared as {{c|1=void _FUN(R&); void _FUN(R&&) = delete;}}.
+
{{c|/*different-from*/<T, U>}} is satisfied if and only if {{c|std::remove_cvref_t<T>}} and {{c|std::remove_cvref_t<U>}} are not the same type, and overloads of {{tti|_FUN}} are declared as {{c|1=void _FUN(R&); void _FUN(R&&) = delete;}}.
  
 
===Parameters===
 
===Parameters===
 
{{par begin}}
 
{{par begin}}
−
{{par | t | range to reference }}
+
{{par|t|range to reference}}
 
{{par end}}
 
{{par end}}
−
 
 
}}
 
}}
  
−
{{member | {{small|std::ranges::ref_view::}}base|
+
{{anchor|base}}
−
{{dcl begin}}
+
{{member|{{small|std::ranges::ref_view::}}base|
−
{{dcl |
+
{{ddcl|since=c++20|
 
constexpr R& base() const;
 
constexpr R& base() const;
 
}}
 
}}
−
{{dcl end}}
 
  
−
Equivalent to {{c|return *r_;}}
+
Equivalent to {{c|return *r_;}}.
 
}}
 
}}
  
−
{{member | {{small|std::ranges::ref_view::}}begin|
+
{{anchor|begin}}
−
{{dcl begin}}
+
{{member|{{small|std::ranges::ref_view::}}begin|
−
{{dcl |
+
{{ddcl|since=c++20|
 
constexpr ranges::iterator_t<R> begin() const;
 
constexpr ranges::iterator_t<R> begin() const;
 
}}
 
}}
−
{{dcl end}}
 
  
−
Equivalent to {{c|return ranges::begin(*r_);}}
+
Equivalent to {{c|return ranges::begin(*r_);}}.
 
}}
 
}}
  
−
{{member | {{small|std::ranges::ref_view::}}end|
+
{{anchor|end}}
−
{{dcl begin}}
+
{{member|{{small|std::ranges::ref_view::}}end|
−
{{dcl |
+
{{ddcl|since=c++20|
 
constexpr ranges::sentinel_t<R> end() const;
 
constexpr ranges::sentinel_t<R> end() const;
 
}}
 
}}
−
{{dcl end}}
 
  
−
Equivalent to {{c|return ranges::end(*r_);}}
+
Equivalent to {{c|return ranges::end(*r_);}}.
 
}}
 
}}
  
−
{{member | {{small|std::ranges::ref_view::}}empty|
+
{{anchor|empty}}
−
{{dcl begin}}
+
{{member|{{small|std::ranges::ref_view::}}empty|
−
{{dcl |
+
{{ddcl|since=c++20|
 
constexpr bool empty() const
 
constexpr bool empty() const
 
     requires requires { ranges::empty(*r_); };
 
     requires requires { ranges::empty(*r_); };
 
}}
 
}}
−
{{dcl end}}
 
  
−
Equivalent to {{c|return ranges::empty(*r_);}}
+
Equivalent to {{c|return ranges::empty(*r_);}}.
 
}}
 
}}
  
−
{{member | {{small|std::ranges::ref_view::}}size|
+
{{anchor|size}}
−
{{dcl begin}}
+
{{member|{{small|std::ranges::ref_view::}}size|
−
{{dcl |
+
{{ddcl|since=c++20|
 
constexpr auto size() const
 
constexpr auto size() const
−
     requires ranges::sized_range<R>
+
     requires ranges::sized_range<R>;
−
{ return ranges::size(*r_); }
+
 
}}
 
}}
−
{{dcl end}}
+
 
 +
Equivalent to {{c|return ranges::size(*r_);}}.
 
}}
 
}}
  
−
{{member | {{small|std::ranges::ref_view::}}data|
+
{{anchor|data}}
−
{{dcl begin}}
+
{{member|{{small|std::ranges::ref_view::}}data|
−
{{dcl |
+
{{ddcl|since=c++20|
 
constexpr auto data() const
 
constexpr auto data() const
−
     requires ranges::contiguous_range<R>
+
     requires ranges::contiguous_range<R>;
−
{ return ranges::data(*r_); }
+
 
}}
 
}}
−
{{dcl end}}
+
 
 +
Equivalent to {{c|return ranges::data(*r_);}}.
 
}}
 
}}
  
 
===Deduction guides===
 
===Deduction guides===
−
{{dcl begin}}
+
{{ddcl|since=c++20|
−
{{dcl|
+
template< class R >
−
template<class R>
+
ref_view( R& ) -> ref_view<R>;
−
ref_view(R&) -> ref_view<R>;
+
 
}}
 
}}
−
{{dcl end}}
+
 
 +
===Helper templates===
 +
{{ddcl|since=c++20|1=
 +
template< class T >
 +
constexpr bool enable_borrowed_range<ranges::ref_view<T>> = true;
 +
}}
 +
This specialization of {{rlpt|borrowed_range|std::ranges::enable_borrowed_range}} makes {{tt|ref_view}} satisfy {{lconcept|borrowed_range}}.
  
 
===Example===
 
===Example===
−
{{example}}
+
{{example
 +
|code=
 +
#include <iostream>
 +
#include <ranges>
 +
 
 +
int main()
 +
{
 +
    const std::string s{"cosmos"};
 +
 
 +
    const std::ranges::take_view tv{s, 3};
 +
    const std::ranges::ref_view rv{tv};
 +
 
 +
    std::cout
 +
        << std::boolalpha
 +
        << "call empty() : " << rv.empty() << '\n'
 +
        << "call size()  : " << rv.size() << '\n'
 +
        << "call begin() : " << *rv.begin() << '\n'
 +
        << "call end()  : " << *(rv.end() - 1) << '\n'
 +
        << "call data()  : " << rv.data() << '\n'
 +
        << "call base()  : " << rv.base().size() << '\n' // ~> tv.size()
 +
        << "range-for    : ";
 +
 
 +
    for (const auto c : rv)
 +
        std::cout << c;
 +
    std::cout << '\n';
 +
}
 +
|output=
 +
call empty() : false
 +
call size()  : 3
 +
call begin() : c
 +
call end()  : s
 +
call data()  : cosmos
 +
call base()  : 3
 +
range-for    : cos
 +
}}
 +
 
 +
===Defect reports===
 +
{{dr list begin}}
 +
{{dr list item|paper=P2325R3|std=C++20|before=default constructor was provided as {{lconcept|view}}<br>must be {{lconcept|default_initializable}}|after=removed along with the requirement}}
 +
{{dr list end}}
  
 
===See also===
 
===See also===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/utility/functional/dsc reference_wrapper}}
+
{{dsc inc|cpp/utility/functional/dsc reference_wrapper}}
−
{{dsc inc | cpp/ranges/dsc all_view}}
+
{{dsc inc|cpp/ranges/dsc owning_view}}
 +
{{dsc inc|cpp/ranges/dsc all_view}}
 
{{dsc end}}
 
{{dsc end}}
  
−
{{langlinks|ja|zh}}
+
{{langlinks|de|es|ja|ru|zh}}

Latest revision as of 22:57, 20 June 2024

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

    requires std::is_object_v<R>
class ref_view

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

ref_view is a view of the elements of some other range. It wraps a reference to that range.

Contents

[edit] Data members

Member name Definition
r_ (private) A pointer of type R* to the underlying range.
(exposition-only member object*)

[edit] Member functions

 constructs a ref_view that references to the given range
(public member function)
returns the references to the referenced range
(public member function)
returns the beginning iterator of the referenced range
(public member function)
returns the sentinel of the referenced range
(public member function)
checks whether the referenced range is empty
(public member function)
returns the size of the referenced sized_range
(public member function)
returns the pointer to the beginning of the referenced 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>) [edit]
(C++23)
 returns a sentinel for the constant iterator of the range.
(public member function of std::ranges::view_interface<D>) [edit]
returns whether the derived view is not empty. Provided if ranges::empty is applicable to it.
(public member function of std::ranges::view_interface<D>) [edit]
returns the first element in the derived view. Provided if it satisfies forward_range.
(public member function of std::ranges::view_interface<D>) [edit]
returns the last element in the derived view. Provided if it satisfies bidirectional_range and common_range.
(public member function of std::ranges::view_interface<D>) [edit]
returns the nth element in the derived view. Provided if it satisfies random_access_range.
(public member function of std::ranges::view_interface<D>) [edit]

std::ranges::ref_view::ref_view

template< /*different-from*/<ref_view> T >

    requires std::convertible_to<T, R&> && requires { _FUN(std::declval<T>()); }

constexpr ref_view( T&& t );
 (since C++20)

Initializes r_ with std::addressof(static_cast<R&>(std::forward<T>(t))).

/*different-from*/<T, U> is satisfied if and only if std::remove_cvref_t<T> and std::remove_cvref_t<U> are not the same type, and overloads of _FUN are declared as void _FUN(R&); void _FUN(R&&) = delete;.

Parameters

t - range to reference

std::ranges::ref_view::base

constexpr R& base() const;
 (since C++20)

Equivalent to return *r_;.

std::ranges::ref_view::begin

constexpr ranges::iterator_t<R> begin() const;
 (since C++20)

Equivalent to return ranges::begin(*r_);.

std::ranges::ref_view::end

constexpr ranges::sentinel_t<R> end() const;
 (since C++20)

Equivalent to return ranges::end(*r_);.

std::ranges::ref_view::empty

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

Equivalent to return ranges::empty(*r_);.

std::ranges::ref_view::size

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

Equivalent to return ranges::size(*r_);.

std::ranges::ref_view::data

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

Equivalent to return ranges::data(*r_);.

[edit] Deduction guides

template< class R >
ref_view( R& ) -> ref_view<R>;
 (since C++20)

[edit] Helper templates

template< class T >
constexpr bool enable_borrowed_range<ranges::ref_view<T>> = true;
 (since C++20)

This specialization of std::ranges::enable_borrowed_range makes ref_view satisfy borrowed_range.

[edit] Example

Run this code
#include <iostream>
#include <ranges>
 
int main()
{
    const std::string s{"cosmos"};
 
    const std::ranges::take_view tv{s, 3};
    const std::ranges::ref_view rv{tv};
 
    std::cout
        << std::boolalpha
        << "call empty() : " << rv.empty() << '\n'
        << "call size()  : " << rv.size() << '\n'
        << "call begin() : " << *rv.begin() << '\n'
        << "call end()   : " << *(rv.end() - 1) << '\n'
        << "call data()  : " << rv.data() << '\n'
        << "call base()  : " << rv.base().size() << '\n' // ~> tv.size()
        << "range-for    : ";
 
    for (const auto c : rv)
        std::cout << c;
    std::cout << '\n';
}

Output: 

call empty() : false
call size()  : 3
call begin() : c
call end()   : s
call data()  : cosmos
call base()  : 3
range-for    : cos

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
P2325R3 C++20 default constructor was provided as view
must be default_initializable 		removed along with the requirement

[edit] See also

(C++11)
 CopyConstructible and CopyAssignable reference wrapper
(class template) [edit]
(C++20)
 a view with unique ownership of some range
(class template) [edit]
(C++20)
 a view that includes all elements of a range
(alias template) (range adaptor object)[edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/ranges/ref_view&oldid=172702"