std::ranges::views::reverse, std::ranges::reverse_view
From cppreference.com
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Ranges library
(exposition-only member object*)
returns the approximate size of the underlying
(public member function)
returns a constant iterator to the beginning of the range
(public member function of
returns a sentinel for the constant iterator of the range
(public member function of
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++26)(C++26)
reverse_viewviews::reverse
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)
(C++23)(C++23)
(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)
Defined in header
<ranges>
template< ranges::view V >
(1)
(since C++20)
requires ranges::bidirectional_range <V>
class reverse_view
namespace views {
(2)
(since C++20)
inline constexpr /* unspecified */ reverse = /* unspecified */;
Call signature
template< ranges::viewable_range R >
(since C++20)
requires /* see below */
1) A range adaptor that represents a view of underlying
view with reversed order.2) RangeAdaptorObject. The expression views::reverse(e) is expression-equivalent to one of the following expressions, except that e is evaluated only once:
- e.base(), if the type of
eis a (possibly cv-qualified) specialization ofreverse_view; - otherwise, if the type of e is (possibly cv-qualified) ranges::subrange <std::reverse_iterator <I>, std::reverse_iterator <I>, K> for some iterator type
Iand valueKof typeranges::subrange_kind:
- ranges::subrange <I, I, K>(e.end().base(), e.begin().base(), e.size()), if
Kisranges::subrange_kind::sized; - otherwise ranges::subrange <I, I, K>(e.end().base(), e.begin().base());
- ranges::subrange <I, I, K>(e.end().base(), e.begin().base(), e.size()), if
- otherwise ranges::reverse_view{e}.
views::reverse unwraps reversed views if possible.A reverse_view always models bidirectional_range and common_range, and it models borrowed_range, sized_range, or random_access_range if the underlying view type V models the corresponding concept.
Contents
[edit] Data members
Member
Description
V base_ (private)
the underlying view(exposition-only member object*)
non-propagating-cache <ranges::iterator_t <V>>
(present only if
(exposition-only member object*)
cached_end_ (private) (present only if
V does not satisfy common_range)
an object that caches the result of calls to begin() (exposition-only member object*)
[edit] Member functions
(C++26)
approximately_sized_range (public member function)
Inherited from std::ranges::view_interface
returns whether the derived view is empty, provided only if it satisfies
(public member function of
sized_range or forward_range (public member function of
std::ranges::view_interface<D>) [edit]
(C++23)
(public member function of
std::ranges::view_interface<D>) [edit]
(C++23)
(public member function of
std::ranges::view_interface<D>) [edit]
returns whether the derived view is not empty, provided only if ranges::empty is applicable to it
(public member function of
(public member function of
std::ranges::view_interface<D>) [edit]
returns the first element in the derived view, provided if it satisfies
(public member function of
forward_range (public member function of
std::ranges::view_interface<D>) [edit]
returns the last element in the derived view, provided only if it satisfies
(public member function of
bidirectional_range and common_range (public member function of
std::ranges::view_interface<D>) [edit]
returns the
(public member function of
nth element in the derived view, provided only if it satisfies random_access_range (public member function of
std::ranges::view_interface<D>) [edit]
std::ranges::reverse_view::reverse_view
reverse_view() requires std::default_initializable <V> = default;
(1)
(since C++20)
constexpr reverse_view( V r );
(2)
(since C++20)
Parameters
r
-
range to reverse
std::ranges::reverse_view::base
constexpr V base() const& requires std::copy_constructible <V>;
(1)
(since C++20)
constexpr V base() &&;
(2)
(since C++20)
Returns the underlying view.
1) Copy-constructs the result from the underlying view. Equivalent to return
base_ ;.2) Move-constructs the result from the underlying view. Equivalent to return std::move(
base_ );.
std::ranges::reverse_view::begin
constexpr std::reverse_iterator <ranges::iterator_t <V>> begin();
(1)
(since C++20)
constexpr std::reverse_iterator <ranges::iterator_t <V>> begin()
requires ranges::common_range <V>;
(2)
(since C++20)
requires ranges::common_range <V>;
constexpr auto begin() const requires ranges::common_range <const V>;
(3)
(since C++20)
1) Returns std::make_reverse_iterator (ranges::next (ranges::begin (
base_ ), ranges::end (base_ ))). In order to provide the amortized constant time complexity required by the
range concept, this function caches the result within the cache object for use on subsequent calls.2,3) Equivalent to return std::make_reverse_iterator (ranges::end (
base_ ));.
std::ranges::reverse_view::end
constexpr std::reverse_iterator <ranges::iterator_t <V>> end();
(1)
(since C++20)
constexpr auto end() const requires ranges::common_range <const V>;
(2)
(since C++20)
Equivalent to return std::make_reverse_iterator (ranges::begin (base_ ));.
std::ranges::reverse_view::size
constexpr auto size() requires ranges::sized_range <V>;
(1)
(since C++20)
constexpr auto size() const requires ranges::sized_range <const V>;
(2)
(since C++20)
Returns the size of the view if the view is bounded. Equivalent to return ranges::size (base_ );.
std::ranges::as_rvalue_view::reserve_hint
constexpr auto reserve_hint()
requires ranges::approximately_sized_range<V>;
(1)
(since C++26)
requires ranges::approximately_sized_range<V>;
constexpr auto reserve_hint() const
requires ranges::approximately_sized_range<const V>;
(2)
(since C++26)
requires ranges::approximately_sized_range<const V>;
Returns ranges::reserve_hint(base_ ).
[edit] Deduction guides
template< class R >
reverse_view( R&& ) -> reverse_view<views::all_t <R>>;
(since C++20)
reverse_view( R&& ) -> reverse_view<views::all_t <R>>;
[edit] Helper templates
template< class T >
(since C++20)
constexpr bool enable_borrowed_range<std::ranges::reverse_view<T>> =
This specialization of std::ranges::enable_borrowed_range makes reverse_view satisfy borrowed_range when the underlying view satisfies it.
[edit] Notes
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_ranges_reserve_hint |
202502L |
(C++26) | ranges::approximately_sized_range and reserve_hint
|
[edit] Example
Run this code
#include <iostream> #include <ranges> int main() { static constexpr auto il = {3, 1, 4, 1, 5, 9}; std::ranges::reverse_view rv{il}; for (int i : rv) std::cout << i << ' '; std::cout << '\n'; for (int i : il | std::views::reverse) std::cout << i << ' '; std::cout << '\n'; // operator[] is inherited from std::view_interface for (auto i{0U}; i != rv.size(); ++i) std::cout << rv[i] << ' '; std::cout << '\n'; }
Output:
9 5 1 4 1 3 9 5 1 4 1 3 9 5 1 4 1 3
[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 |
|---|---|---|---|
| LWG 3494 | C++20 | reverse_view was never a borrowed_range
|
it is a borrowed_range if its underlying view is
|