24 Ranges library [ranges]

24.1 General [ranges.general]

This clause describes components for dealing with ranges of elements.

The following subclauses describe range and view requirements, and components for range primitives as summarized in Table 88 .

Table 88: Ranges library summary [tab:range.summary]

	Subclause	Header
[range.access]	Range access	<ranges>
[range.req]	Requirements
[range.utility]	Range utilities
[range.factories]	Range factories
[range.adaptors]	Range adaptors

24.2 Header <ranges> synopsis [ranges.syn]

#include <initializer_list>
#include <iterator>

namespace std::ranges {
  inline namespace unspecified {
    // [range.access], range access
    inline constexpr unspecified begin = unspecified;
    inline constexpr unspecified end = unspecified;
    inline constexpr unspecified cbegin = unspecified;
    inline constexpr unspecified cend = unspecified;
    inline constexpr unspecified rbegin = unspecified;
    inline constexpr unspecified rend = unspecified;
    inline constexpr unspecified crbegin = unspecified;
    inline constexpr unspecified crend = unspecified;

    inline constexpr unspecified size = unspecified;
    inline constexpr unspecified empty = unspecified;
    inline constexpr unspecified data = unspecified;
    inline constexpr unspecified cdata = unspecified;
  }

  // [range.range], ranges
  template<class T>
    concept range = see below;

  template<range T>
    inline constexpr bool enable_safe_range = false;

  template<class T>
    concept safe_range = see below;

  template<range R>
    using iterator_t = decltype(ranges::begin(declval<R&>()));
  template<range R>
    using sentinel_t = decltype(ranges::end(declval<R&>()));
  template<range R>
    using range_difference_t = iter_difference_t<iterator_t<R>>;
  template<range R>
    using range_value_t = iter_value_t<iterator_t<R>>;
  template<range R>
    using range_reference_t = iter_reference_t<iterator_t<R>>;
  template<range R>
    using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;

  // [range.sized], sized ranges
  template<class>
    inline constexpr bool disable_sized_range = false;

  template<class T>
    concept sized_range = see below;

  // [range.view], views
  template<class T>
    inline constexpr bool enable_view = see below;

  struct view_base { };

  template<class T>
    concept view = see below;

  // [range.refinements], other range refinements
  template<class R, class T>
    concept output_range = see below;

  template<class T>
    concept input_range = see below;

  template<class T>
    concept forward_range = see below;

  template<class T>
    concept bidirectional_range = see below;

  template<class T>
    concept random_access_range = see below;

  template<class T>
    concept contiguous_range = see below;

  template<class T>
    concept common_range = see below;

  template<class T>
    concept viewable_range = see below;

  // [view.interface], class template view_interface
  template<class D>
    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
  class view_interface;

  // [range.subrange], sub-ranges
  enum class subrange_kind : bool { unsized, sized };

  template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K = see below>
    requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
  class subrange;

  template<input_or_output_iterator I, sentinel_for<I> S, subrange_kind K>
    inline constexpr bool enable_safe_range<subrange<I, S, K>> = true;

  // [range.dangling], dangling iterator handling
  struct dangling;

  template<range R>
    using safe_iterator_t = conditional_t<safe_range<R>, iterator_t<R>, dangling>;

  template<range R>
    using safe_subrange_t =
      conditional_t<safe_range<R>, subrange<iterator_t<R>>, dangling>;

  // [range.empty], empty view
  template<class T>
    requires is_object_v<T>
  class empty_view;

  template<class T>
    inline constexpr bool enable_safe_range<empty_view<T>> = true;

  namespace views {
    template<class T>
      inline constexpr empty_view<T> empty{};
  }

  // [range.single], single view
  template<copy_constructible T>
    requires is_object_v<T>
  class single_view;

  namespace views { inline constexpr unspecified single = unspecified; }

  // [range.iota], iota view
  template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
    requires weakly-equality-comparable-with<W, Bound>
  class iota_view;

  template<weakly_incrementable W, semiregular Bound>
    inline constexpr bool enable_safe_range<iota_view<W, Bound>> = true;

  namespace views { inline constexpr unspecified iota = unspecified; }

  // [range.istream], istream view
  template<movable Val, class CharT, class Traits = char_traits<CharT>>
    requires see below
  class basic_istream_view;
  template<class Val, class CharT, class Traits>
    basic_istream_view<Val, CharT, Traits> istream_view(basic_istream<CharT, Traits>& s);

  // [range.all], all view
  namespace views { inline constexpr unspecified all = unspecified; }

  template<viewable_range R>
    using all_view = decltype(views::all(declval<R>()));

  template<range R>
    requires is_object_v<R>
  class ref_view;

  template<class T>
    inline constexpr bool enable_safe_range<ref_view<T>> = true;

  // [range.filter], filter view
  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class filter_view;

  namespace views { inline constexpr unspecified filter = unspecified; }

  // [range.transform], transform view
  template<input_range V, copy_constructible F>
    requires view<V> && is_object_v<F> &&
             regular_invocable<F&, range_reference_t<V>>
  class transform_view;

  namespace views { inline constexpr unspecified transform = unspecified; }

  // [range.take], take view
  template<view> class take_view;

  namespace views { inline constexpr unspecified take = unspecified; }

  // [range.take.while], take while view
  template<view V, class Pred>
    requires input_range<V> && is_object_v<Pred> &&
      indirect_unary_predicate<const Pred, iterator_t<V>>
    class take_while_view;

  namespace views { inline constexpr unspecified take_while = unspecified; }

  // [range.drop], drop view
  template<view V>
    class drop_view;

  namespace views { inline constexpr unspecified drop = unspecified; }

  // [range.drop.while], drop while view
  template<view V, class Pred>
    requires input_range<V> && is_object_v<Pred> &&
      indirect_unary_predicate<const Pred, iterator_t<V>>
    class drop_while_view;

  namespace views { inline constexpr unspecified drop_while = unspecified; }

  // [range.join], join view
  template<input_range V>
    requires view<V> && input_range<range_reference_t<V>> &&
             (is_reference_v<range_reference_t<V>> ||
              view<range_value_t<V>>)
  class join_view;

  namespace views { inline constexpr unspecified join = unspecified; }

  // [range.split], split view
  template<class R>
    concept tiny-range = see below;   // exposition only

  template<input_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
             (forward_range<V> || tiny-range<Pattern>)
  class split_view;

  namespace views { inline constexpr unspecified split = unspecified; }

  // [range.counted], counted view
  namespace views { inline constexpr unspecified counted = unspecified; }

  // [range.common], common view
  template<view V>
    requires (!common_range<V> && copyable<iterator_t<V>>)
  class common_view;

  namespace views { inline constexpr unspecified common = unspecified; }

  // [range.reverse], reverse view
  template<view V>
    requires bidirectional_range<V>
  class reverse_view;

  namespace views { inline constexpr unspecified reverse = unspecified; }

  // [range.elements], elements view
  template<input_range V, size_t N>
    requires see below;
  class elements_view;

  template<class R>
    using keys_view = elements_view<all_view<R>, 0>;
  template<class R>
    using values_view = elements_view<all_view<R>, 1>;

  namespace views {
    template<size_t N>
      inline constexpr unspecified elements = unspecified ;
    inline constexpr unspecified keys = unspecified ;
    inline constexpr unspecified values = unspecified ;
  }
}

namespace std {
  namespace views = ranges::views;

  template<class I, class S, ranges::subrange_kind K>
  struct tuple_size<ranges::subrange<I, S, K>>
    : integral_constant<size_t, 2> {};
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_element<0, ranges::subrange<I, S, K>> {
    using type = I;
  };
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_element<1, ranges::subrange<I, S, K>> {
    using type = S;
  };
}

Within this clause, for some integer-like type X ([iterator.concept.winc]), make-unsigned-like-t(X) denotes make_unsigned_t<X> if X is an integer type; otherwise, it denotes a corresponding unspecified unsigned-integer-like type of the same width as X.

For an object x of type X, make-unsigned-like(x) is x explicitly converted to make-unsigned-like-t(X).

24.3 Range access [range.access]

In addition to being available via inclusion of the <ranges> header, the customization point objects in [range.access] are available when <iterator> ([iterator.synopsis]) is included.

24.3.1 ranges::begin [range.access.begin]

The name ranges::begin denotes a customization point object ([customization.point.object]).

Given a subexpression E and an lvalue t that denotes the same object as E, if E is an rvalue and enable_safe_range<remove_cvref_t<decltype((E))>> is false, ranges::begin(E) is ill-formed.

Otherwise, ranges::begin(E) is expression-equivalent to:

(1.1)
t + 0 if t is of array type ([basic.compound]).
(1.2)
Otherwise, decay-copy(t.begin()) if it is a valid expression and its type I models input_or_output_iterator.
(1.3)
Otherwise, decay-copy(begin(t)) if it is a valid expression and its type I models input_or_output_iterator with overload resolution performed in a context that includes the declarations:
```
template<class T> void begin(T&&) = delete;
template<class T> void begin(initializer_list<T>&&) = delete;
  
```
and does not include a declaration of ranges::begin.
(1.4)
Otherwise, ranges::begin(E) is ill-formed.
[ Note
: This case can result in substitution failure when ranges::begin(E) appears in the immediate context of a template instantiation. — end note
]

[ Note

Whenever ranges::begin(E) is a valid expression, its type models input_or_output_iterator.

— end note

]

24.3.2 ranges::end [range.access.end]

The name ranges::end denotes a customization point object ([customization.point.object]).

Given a subexpression E and an lvalue t that denotes the same object as E, if E is an rvalue and enable_safe_range<remove_cvref_t<decltype((E))>> is false, ranges::end(E) is ill-formed.

Otherwise, ranges::end(E) is expression-equivalent to:

(1.1)
t + extent_v<T> if E is of array type ([basic.compound]) T.
(1.2)
Otherwise, decay-copy(t.end()) if it is a valid expression and its type S models
```
sentinel_for<decltype(ranges::begin(E))>
  
```
(1.3)
Otherwise, decay-copy(end(t)) if it is a valid expression and its type S models
```
sentinel_for<decltype(ranges::begin(E))>
  
```
with overload resolution performed in a context that includes the declarations:
```
template<class T> void end(T&&) = delete;
template<class T> void end(initializer_list<T>&&) = delete;
  
```
and does not include a declaration of ranges::end.
(1.4)
Otherwise, ranges::end(E) is ill-formed.
[ Note
: This case can result in substitution failure when ranges::end(E) appears in the immediate context of a template instantiation. — end note
]

[ Note

Whenever ranges::end(E) is a valid expression, the types S and I of ranges::end(E) and ranges::begin(E) model sentinel_for<S, I>.

— end note

]

24.3.3 ranges::cbegin [range.access.cbegin]

The name ranges::cbegin denotes a customization point object .

The expression ranges::cbegin(E) for some subexpression E of type T is expression-equivalent to:

(1.1)
ranges::begin(static_cast<const T&>(E)) if E is an lvalue.
(1.2)
Otherwise, ranges::begin(static_cast<const T&&>(E)).

[ Note

Whenever ranges::cbegin(E) is a valid expression, its type models input_or_output_iterator.

— end note

]

24.3.4 ranges::cend [range.access.cend]

The name ranges::cend denotes a customization point object .

The expression ranges::cend(E) for some subexpression E of type T is expression-equivalent to:

(1.1)
ranges::end(static_cast<const T&>(E)) if E is an lvalue.
(1.2)
Otherwise, ranges::end(static_cast<const T&&>(E)).

[ Note

Whenever ranges::cend(E) is a valid expression, the types S and I of ranges::cend(E) and ranges::cbegin(E) model sentinel_for<S, I>.

— end note

]

24.3.5 ranges::rbegin [range.access.rbegin]

The name ranges::rbegin denotes a customization point object ([customization.point.object]).

Given a subexpression E and an lvalue t that denotes the same object as E, if E is an rvalue and enable_safe_range<remove_cvref_t<decltype((E))>> is false, ranges::rbegin(E) is ill-formed.

Otherwise, ranges::rbegin(E) is expression-equivalent to:

(1.1)
decay-copy(t.rbegin()) if it is a valid expression and its type I models input_or_output_iterator.
(1.2)
Otherwise, decay-copy(rbegin(t)) if it is a valid expression and its type I models input_or_output_iterator with overload resolution performed in a context that includes the declaration:
```
template<class T> void rbegin(T&&) = delete;
  
```
and does not include a declaration of ranges::rbegin.
(1.3)
Otherwise, make_reverse_iterator(ranges::end(t)) if both ranges::begin(t) and ranges::end(t) are valid expressions of the same type I which models bidirectional_iterator ([iterator.concept.bidir]).
(1.4)
Otherwise, ranges::rbegin(E) is ill-formed.
[ Note
: This case can result in substitution failure when ranges::rbegin(E) appears in the immediate context of a template instantiation. — end note
]

[ Note

Whenever ranges::rbegin(E) is a valid expression, its type models input_or_output_iterator.

— end note

]

24.3.6 ranges::rend [range.access.rend]

The name ranges::rend denotes a customization point object ([customization.point.object]).

Given a subexpression E and an lvalue t that denotes the same object as E, if E is an rvalue and enable_safe_range<remove_cvref_t<decltype((E))>> is false, ranges::rend(E) is ill-formed.

Otherwise, ranges::rend(E) is expression-equivalent to:

(1.1)
decay-copy(t.rend()) if it is a valid expression and its type S models
```
sentinel_for<decltype(ranges::rbegin(E))>
  
```
(1.2)
Otherwise, decay-copy(rend(t)) if it is a valid expression and its type S models
```
sentinel_for<decltype(ranges::rbegin(E))>
  
```
with overload resolution performed in a context that includes the declaration:
```
template<class T> void rend(T&&) = delete;
  
```
and does not include a declaration of ranges::rend.
(1.3)
Otherwise, make_reverse_iterator(ranges::begin(t)) if both ranges::begin(t) and ranges::end(t) are valid expressions of the same type I which models bidirectional_iterator ([iterator.concept.bidir]).
(1.4)
Otherwise, ranges::rend(E) is ill-formed.
[ Note
: This case can result in substitution failure when ranges::rend(E) appears in the immediate context of a template instantiation. — end note
]

[ Note

Whenever ranges::rend(E) is a valid expression, the types S and I of ranges::rend(E) and ranges::rbegin(E) model sentinel_for<S, I>.

— end note

]

24.3.7 ranges::crbegin [range.access.crbegin]

The name ranges::crbegin denotes a customization point object .

The expression ranges::crbegin(E) for some subexpression E of type T is expression-equivalent to:

(1.1)
ranges::rbegin(static_cast<const T&>(E)) if E is an lvalue.
(1.2)
Otherwise, ranges::rbegin(static_cast<const T&&>(E)).

[ Note

Whenever ranges::crbegin(E) is a valid expression, its type models input_or_output_iterator.

— end note

]

24.3.8 ranges::crend [range.access.crend]

The name ranges::crend denotes a customization point object .

The expression ranges::crend(E) for some subexpression E of type T is expression-equivalent to:

(1.1)
ranges::rend(static_cast<const T&>(E)) if E is an lvalue.
(1.2)
Otherwise, ranges::rend(static_cast<const T&&>(E)).

[ Note

Whenever ranges::crend(E) is a valid expression, the types S and I of ranges::crend(E) and ranges::crbegin(E) model sentinel_for<S, I>.

— end note

]

24.3.9 ranges::size [range.prim.size]

The name size denotes a customization point object .

The expression ranges::size(E) for some subexpression E with type T is expression-equivalent to:

(1.1)
decay-copy(extent_v<T>) if T is an array type ([basic.compound]).
(1.2)
Otherwise, if disable_sized_range<remove_cv_t<T>> ([range.sized]) is false:
- (1.2.1)
  decay-copy(E.size()) if it is a valid expression and its type I is integer-like ([iterator.concept.winc]).
- (1.2.2)
  Otherwise, decay-copy(size(E)) if it is a valid expression and its type I is integer-like with overload resolution performed in a context that includes the declaration:
```
template<class T> void size(T&&) = delete;
    
```
  and does not include a declaration of ranges::size.
(1.3)
Otherwise, make-unsigned-like(ranges::end(E) - ranges::begin(E)) ([range.subrange]) if it is a valid expression and the types I and S of ranges::begin(E) and ranges::end(E) (respectively) model both sized_sentinel_for<S, I> ([iterator.concept.sizedsentinel]) and forward_iterator<I>. However, E is evaluated only once.
(1.4)
Otherwise, ranges::size(E) is ill-formed.
[ Note
: This case can result in substitution failure when ranges::size(E) appears in the immediate context of a template instantiation. — end note
]

[ Note

Whenever ranges::size(E) is a valid expression, its type is integer-like.

— end note

]

24.3.10 ranges::empty [range.prim.empty]

The name empty denotes a customization point object .

The expression ranges::empty(E) for some subexpression E is expression-equivalent to:

(1.1)
bool((E).empty()) if it is a valid expression.
(1.2)
Otherwise, (ranges::size(E) == 0) if it is a valid expression.
(1.3)
Otherwise, EQ, where EQ is bool(ranges::begin(E) == ranges::end(E)) except that E is only evaluated once, if EQ is a valid expression and the type of ranges::begin(E) models forward_iterator.
(1.4)
Otherwise, ranges::empty(E) is ill-formed.
[ Note
: This case can result in substitution failure when ranges::empty(E) appears in the immediate context of a template instantiation. — end note
]

[ Note

Whenever ranges::empty(E) is a valid expression, it has type bool.

— end note

]

24.3.11 ranges::data [range.prim.data]

The name data denotes a customization point object .

The expression ranges::data(E) for some subexpression E is expression-equivalent to:

(1.1)
If E is an lvalue, decay-copy(E.data()) if it is a valid expression of pointer to object type.
(1.2)
Otherwise, if ranges::begin(E) is a valid expression whose type models contiguous_iterator, to_address(ranges::begin(E)).
(1.3)
Otherwise, ranges::data(E) is ill-formed.
[ Note
: This case can result in substitution failure when ranges::data(E) appears in the immediate context of a template instantiation. — end note
]

[ Note

Whenever ranges::data(E) is a valid expression, it has pointer to object type.

— end note

]

24.3.12 ranges::cdata [range.prim.cdata]

The name cdata denotes a customization point object .

The expression ranges::cdata(E) for some subexpression E of type T is expression-equivalent to:

(1.1)
ranges::data(static_cast<const T&>(E)) if E is an lvalue.
(1.2)
Otherwise, ranges::data(static_cast<const T&&>(E)).

[ Note

Whenever ranges::cdata(E) is a valid expression, it has pointer to object type.

— end note

]

24.4 Range requirements [range.req]

24.4.1 General [range.req.general]

Ranges are an abstraction that allow a C++ program to operate on elements of data structures uniformly.

Calling ranges::begin on a range returns an object whose type models input_or_output_iterator ([iterator.concept.iterator]).

Calling ranges::end on a range returns an object whose type S, together with the type I of the object returned by ranges::begin, models sentinel_for<S, I>.

The library formalizes the interfaces, semantics, and complexity of ranges to enable algorithms and range adaptors that work efficiently on different types of sequences.

The range concept requires that ranges::begin and ranges::end return an iterator and a sentinel, respectively.

The sized_range concept refines range with the requirement that the number of elements in the range can be determined in constant time using the ranges::size function.

The view concept specifies requirements on a range type with constant-time destruction and move operations.

Several refinements of range group requirements that arise frequently in concepts and algorithms.

Common ranges are ranges for which ranges::begin and ranges::end return objects of the same type.

Random access ranges are ranges for which ranges::begin returns a type that models random_access_iterator ([iterator.concept.random.access]).

(Contiguous, bidirectional, forward, input, and output ranges are defined similarly.)

Viewable ranges can be converted to views.

24.4.2 Ranges [range.range]

The range concept defines the requirements of a type that allows iteration over its elements by providing an iterator and sentinel that denote the elements of the range.

🔗

template<class T>
  concept range =
    requires(T& t) {
      ranges::begin(t);                         // sometimes equality-preserving (see below)
      ranges::end(t);
    };

The required expressions ranges::begin(t) and ranges::end(t) of the range concept do not require implicit expression variations ([concepts.equality]).

Given an expression t such that decltype((t)) is T&, T models range only if

(3.1)
[ranges::begin(t), ranges::end(t)) denotes a range ([iterator.requirements.general]),
(3.2)
both ranges::begin(t) and ranges::end(t) are amortized constant time and non-modifying, and
(3.3)
if the type of ranges::begin(t) models forward_iterator, ranges::begin(t) is equality-preserving.

[ Note

Equality preservation of both ranges::begin and ranges::end enables passing a range whose iterator type models forward_iterator to multiple algorithms and making multiple passes over the range by repeated calls to ranges::begin and ranges::end.

Since ranges::begin is not required to be equality-preserving when the return type does not model forward_iterator, repeated calls might not return equal values or might not be well-defined; ranges::begin should be called at most once for such a range.

— end note

]

🔗

template<class T>
  concept safe_range =
    range<T> &&
      (is_lvalue_reference_v<T> || enable_safe_range<remove_cvref_t<T>>);

Given an expression E such that decltype((E)) is T, T models safe_range only if the validity of iterators obtained from the object denoted by E is not tied to the lifetime of that object.

[ Note

Since the validity of iterators is not tied to the lifetime of an object whose type models safe_range, a function can accept arguments of such a type by value and return iterators obtained from it without danger of dangling.

— end note

]

🔗

template<class>
  inline constexpr bool enable_safe_range = false;

Remarks: Pursuant to [namespace.std], users may specialize enable_safe_range for cv-unqualified program-defined types.

Such specializations shall be usable in constant expressions ([expr.const]) and have type const bool.

[ Example

Each specialization S of class template subrange ([range.subrange]) models safe_range because

enable_safe_range<S> is specialized to have the value true, and
S's iterators do not have validity tied to the lifetime of an S object because they are “borrowed” from some other range.

— end example

]

24.4.3 Sized ranges [range.sized]

The sized_range concept specifies the requirements of a range type that knows its size in constant time with the size function.

🔗

template<class T>
  concept sized_range =
    range<T> &&
    !disable_sized_range<remove_cvref_t<T>> &&
    requires(T& t) { ranges::size(t); };

Given an lvalue t of type remove_reference_t<T>, T models sized_range only if

(2.1)
ranges::size(t) is $O (1)$ , does not modify t, and is equal to ranges::distance(t), and
(2.2)
if iterator_t<T> models forward_iterator, ranges::size(t) is well-defined regardless of the evaluation of ranges::begin(t).
[ Note
: ranges::size(t) is otherwise not required to be well-defined after evaluating ranges::begin(t). For example, ranges::size(t) might be well-defined for a sized_range whose iterator type does not model forward_iterator only if evaluated before the first call to ranges::begin(t). — end note
]

[ Note

The complexity requirement for the evaluation of ranges::size is non-amortized, unlike the case for the complexity of the evaluations of ranges::begin and ranges::end in the range concept.

— end note

]

🔗

template<class>
  inline constexpr bool disable_sized_range = false;

Remarks: Pursuant to [namespace.std], users may specialize disable_sized_range for cv-unqualified program-defined types.

Such specializations shall be usable in constant expressions ([expr.const]) and have type const bool.

[ Note

disable_sized_range allows use of range types with the library that satisfy but do not in fact model sized_range.

— end note

]

24.4.4 Views [range.view]

The view concept specifies the requirements of a range type that has constant time move construction, move assignment, and destruction; that is, the cost of these operations is independent of the number of elements in the view.

🔗

template<class T>
  concept view =
    range<T> && movable<T> && default_constructible<T> && enable_view<T>;

T models view only if:

(2.1)
T has $O (1)$ move construction; and
(2.2)
T has $O (1)$ move assignment; and
(2.3)
T has $O (1)$ destruction; and
(2.4)
copy_constructible<T> is false, or T has $O (1)$ copy construction; and
(2.5)
copyable<T> is false, or T has $O (1)$ copy assignment.

[ Example

Examples of views are:

A range type that wraps a pair of iterators.
A range type that holds its elements by shared_ptr and shares ownership with all its copies.
A range type that generates its elements on demand.

Most containers are not views since destruction of the container destroys the elements, which cannot be done in constant time.

— end example

]

Since the difference between range and view is largely semantic, the two are differentiated with the help of enable_view.

🔗

template<class T>
  inline constexpr bool enable_view = see below;

Remarks: For a type T, the default value of enable_view<T> is:

(5.1)
If derived_from<T, view_base> is true, true.
(5.2)
Otherwise, if T is a specialization of class template initializer_list ([support.initlist]), set ([set]), multiset ([multiset]), unordered_set ([unord.set]), unordered_multiset ([unord.multiset]), or match_results ([re.results]), false.
(5.3)
Otherwise, if both T and const T model range and range_reference_t<T> is not the same type as range_reference_t<const T>, false.
[ Note
: Deep const-ness implies element ownership, whereas shallow const-ness implies reference semantics. — end note
]
(5.4)
Otherwise, true.

Pursuant to [namespace.std], users may specialize enable_view to true for cv-unqualified program-defined types which model view, and false for types which do not.

Such specializations shall be usable in constant expressions ([expr.const]) and have type const bool.

24.5 Range utilities [range.utility]

The components in this subclause are general utilities for representing and manipulating ranges.

24.5.1 Helper concepts [range.utility.helpers]

Many of the types in subclause [range.utility] are specified in terms of the following exposition-only concepts:

template<class R>
  concept simple-view =                         // exposition only
    view<R> && range<const R> &&
    same_as<iterator_t<R>, iterator_t<const R>> &&
    same_as<sentinel_t<R>, sentinel_t<const R>>;

template<input_iterator I>
  concept has-arrow =                           // exposition only
    is_pointer_v<I> || requires(I i) { i.operator->(); };

template<class T, class U>
  concept not-same-as =                         // exposition only
    !same_as<remove_cvref_t<T>, remove_cvref_t<U>>;

24.5.2 View interface [view.interface]

The class template view_interface is a helper for defining view-like types that offer a container-like interface.

It is parameterized with the type that is derived from it.

namespace std::ranges {
  template<class D>
    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
  class view_interface : public view_base {
  private:
    constexpr D& derived() noexcept {                   // exposition only
      return static_cast<D&>(*this);
    }
    constexpr const D& derived() const noexcept {       // exposition only
      return static_cast<const D&>(*this);
    }
  public:
    constexpr bool empty() requires forward_range<D> {
      return ranges::begin(derived()) == ranges::end(derived());
    }
    constexpr bool empty() const requires forward_range<const D> {
      return ranges::begin(derived()) == ranges::end(derived());
    }

    constexpr explicit operator bool()
      requires requires { ranges::empty(derived()); } {
        return !ranges::empty(derived());
      }
    constexpr explicit operator bool() const
      requires requires { ranges::empty(derived()); } {
        return !ranges::empty(derived());
      }

    constexpr auto data() requires contiguous_iterator<iterator_t<D>> {
      return to_address(ranges::begin(derived()));
    }
    constexpr auto data() const
      requires range<const D> && contiguous_iterator<iterator_t<const D>> {
        return to_address(ranges::begin(derived()));
      }

    constexpr auto size() requires forward_range<D> &&
      sized_sentinel_for<sentinel_t<D>, iterator_t<D>> {
        return ranges::end(derived()) - ranges::begin(derived());
      }
    constexpr auto size() const requires forward_range<const D> &&
      sized_sentinel_for<sentinel_t<const D>, iterator_t<const D>> {
        return ranges::end(derived()) - ranges::begin(derived());
      }

    constexpr decltype(auto) front() requires forward_range<D>;
    constexpr decltype(auto) front() const requires forward_range<const D>;

    constexpr decltype(auto) back() requires bidirectional_range<D> && common_range<D>;
    constexpr decltype(auto) back() const
      requires bidirectional_range<const D> && common_range<const D>;

    template<random_access_range R = D>
      constexpr decltype(auto) operator[](range_difference_t<R> n) {
        return ranges::begin(derived())[n];
      }
    template<random_access_range R = const D>
      constexpr decltype(auto) operator[](range_difference_t<R> n) const {
        return ranges::begin(derived())[n];
      }
  };
}

The template parameter D for view_interface may be an incomplete type.

Before any member of the resulting specialization of view_interface other than special member functions is referenced, D shall be complete, and model both derived_from<view_interface<D>> and view.

24.5.2.1 Members [view.interface.members]

🔗

constexpr decltype(auto) front() requires forward_range<D>;
constexpr decltype(auto) front() const requires forward_range<const D>;

Preconditions: !empty().

Effects: Equivalent to: return *ranges::begin(derived());

🔗

constexpr decltype(auto) back() requires bidirectional_range<D> && common_range<D>;
constexpr decltype(auto) back() const
  requires bidirectional_range<const D> && common_range<const D>;

Preconditions: !empty().

Effects: Equivalent to: return *ranges::prev(ranges::end(derived()));

24.5.3 Sub-ranges [range.subrange]

The subrange class template combines together an iterator and a sentinel into a single object that models the view concept.

Additionally, it models the sized_range concept when the final template parameter is subrange_kind::sized.

namespace std::ranges {
  template<class T>
    concept pair-like =                                    // exposition only
      !is_reference_v<T> && requires(T t) {
        typename tuple_size<T>::type;   // ensures tuple_size<T> is complete
        requires derived_from<tuple_size<T>, integral_constant<size_t, 2>>;
        typename tuple_element_t<0, remove_const_t<T>>;
        typename tuple_element_t<1, remove_const_t<T>>;
        { get<0>(t) } -> convertible_to<const tuple_element_t<0, T>&>;
        { get<1>(t) } -> convertible_to<const tuple_element_t<1, T>&>;
      };

  template<class T, class U, class V>
    concept pair-like-convertible-to =                     // exposition only
      !range<T> && pair-like<remove_reference_t<T>> &&
      requires(T&& t) {
        { get<0>(std::forward<T>(t)) } -> convertible_to<U>;
        { get<1>(std::forward<T>(t)) } -> convertible_to<V>;
      };

  template<class T, class U, class V>
    concept pair-like-convertible-from =                   // exposition only
      !range<T> && pair-like<T> && constructible_from<T, U, V>;

  template<class T>
    concept iterator-sentinel-pair =                       // exposition only
      !range<T> && pair-like<T> &&
      sentinel_for<tuple_element_t<1, T>, tuple_element_t<0, T>>;

  template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K =
      sized_sentinel_for<S, I> ? subrange_kind::sized : subrange_kind::unsized>
    requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
  class subrange : public view_interface<subrange<I, S, K>> {
  private:
    static constexpr bool StoreSize =                           // exposition only
      K == subrange_kind::sized && !sized_sentinel_for<S, I>;
    I begin_ = I();                                             // exposition only
    S end_ = S();                                               // exposition only
    make-unsigned-like-t(iter_difference_t<I>) size_ = 0;  // exposition only; present only
                                                                // when StoreSize is true
  public:
    subrange() = default;

    constexpr subrange(I i, S s) requires (!StoreSize);

    constexpr subrange(I i, S s, make-unsigned-like-t(iter_difference_t<I>) n)
      requires (K == subrange_kind::sized);

    template<not-same-as<subrange> R>
      requires safe_range<R> &&
               convertible_to<iterator_t<R>, I> && convertible_to<sentinel_t<R>, S>
    constexpr subrange(R&& r) requires (!StoreSize || sized_range<R>);

    template<safe_range R>
      requires convertible_to<iterator_t<R>, I> && convertible_to<sentinel_t<R>, S>
    constexpr subrange(R&& r, make-unsigned-like-t(iter_difference_t<I>) n)
      requires (K == subrange_kind::sized)
        : subrange{ranges::begin(r), ranges::end(r), n}
    {}

    template<not-same-as<subrange> PairLike>
      requires pair-like-convertible-to<PairLike, I, S>
    constexpr subrange(PairLike&& r) requires (!StoreSize)
      : subrange{std::get<0>(std::forward<PairLike>(r)),
                 std::get<1>(std::forward<PairLike>(r))}
    {}

    template<pair-like-convertible-to<I, S> PairLike>
    constexpr subrange(PairLike&& r, make-unsigned-like-t(iter_difference_t<I>) n)
      requires (K == subrange_kind::sized)
      : subrange{std::get<0>(std::forward<PairLike>(r)),
                 std::get<1>(std::forward<PairLike>(r)), n}
    {}

    template<not-same-as<subrange> PairLike>
      requires pair-like-convertible-from<PairLike, const I&, const S&>
    constexpr operator PairLike() const;

    constexpr I begin() const requires copyable<I>;
    [[nodiscard]] constexpr I begin() requires (!copyable<I>);
    constexpr S end() const;

    constexpr bool empty() const;
    constexpr make-unsigned-like-t(iter_difference_t<I>) size() const
      requires (K == subrange_kind::sized);

    [[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) const &
      requires forward_iterator<I>;
    [[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) &&;
    [[nodiscard]] constexpr subrange prev(iter_difference_t<I> n = 1) const
      requires bidirectional_iterator<I>;
    constexpr subrange& advance(iter_difference_t<I> n);
  };

  template<input_or_output_iterator I, sentinel_for<I> S>
    subrange(I, S, make-unsigned-like-t(iter_difference_t<I>)) ->
      subrange<I, S, subrange_kind::sized>;

  template<iterator-sentinel-pair P>
    subrange(P) -> subrange<tuple_element_t<0, P>, tuple_element_t<1, P>>;

  template<iterator-sentinel-pair P>
    subrange(P, make-unsigned-like-t(iter_difference_t<tuple_element_t<0, P>>)) ->
      subrange<tuple_element_t<0, P>, tuple_element_t<1, P>, subrange_kind::sized>;

  template<safe_range R>
    subrange(R&&) ->
      subrange<iterator_t<R>, sentinel_t<R>,
               (sized_range<R> || sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
                 ? subrange_kind::sized : subrange_kind::unsized>;

  template<safe_range R>
    subrange(R&&, make-unsigned-like-t(range_difference_t<R>)) ->
      subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;

  template<size_t N, class I, class S, subrange_kind K>
    requires (N < 2)
    constexpr auto get(const subrange<I, S, K>& r);

  template<size_t N, class I, class S, subrange_kind K>
    requires (N < 2)
    constexpr auto get(subrange<I, S, K>&& r);
}

namespace std {
  using ranges::get;
}

24.5.3.1 Constructors and conversions [range.subrange.ctor]

🔗

constexpr subrange(I i, S s) requires (!StoreSize);

Preconditions: [i, s) is a valid range.

Effects: Initializes begin_ with std::move(i) and end_ with s.

🔗

constexpr subrange(I i, S s, make-unsigned-like-t(iter_difference_t<I>) n)
  requires (K == subrange_kind::sized);

Preconditions: [i, s) is a valid range, and n == make-unsigned-like(ranges::distance(i, s)).

Effects: Initializes begin_ with std::move(i) and end_ with s.

If StoreSize is true, initializes size_ with n.

[ Note

Accepting the length of the range and storing it to later return from size() enables subrange to model sized_range even when it stores an iterator and sentinel that do not model sized_sentinel_for.

— end note

]

🔗

template<not-same-as<subrange> R>
  requires safe_range<R> &&
           convertible_to<iterator_t<R>, I> && convertible_to<sentinel_t<R>, S>
constexpr subrange(R&& r) requires (!StoreSize || sized_range<R>);

Effects: Equivalent to:

(6.1)
If StoreSize is true, subrange{ranges::begin(r), ranges::end(r), ranges::size(r)}.
(6.2)
Otherwise, subrange{ranges::begin(r), ranges::end(r)}.

🔗

template<not-same-as<subrange> PairLike>
  requires pair-like-convertible-from<PairLike, const I&, const S&>
constexpr operator PairLike() const;

Effects: Equivalent to: return PairLike(begin_, end_);

24.5.3.2 Accessors [range.subrange.access]

🔗

constexpr I begin() const requires copyable<I>;

Effects: Equivalent to: return begin_;

🔗

[[nodiscard]] constexpr I begin() requires (!copyable<I>);

Effects: Equivalent to: return std::move(begin_);

🔗

constexpr S end() const;

Effects: Equivalent to: return end_;

🔗

constexpr bool empty() const;

Effects: Equivalent to: return begin_ == end_;

🔗

constexpr make-unsigned-like-t(iter_difference_t<I>) size() const
  requires (K == subrange_kind::sized);

Effects:

(5.1)
If StoreSize is true, equivalent to: return size_;
(5.2)
Otherwise, equivalent to: return make-unsigned-like(end_ - begin_);

🔗

[[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) const &
  requires forward_iterator<I>;

Effects: Equivalent to:

auto tmp = *this;
tmp.advance(n);
return tmp;

🔗

[[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) &&;

Effects: Equivalent to:

advance(n);
return std::move(*this);

🔗

[[nodiscard]] constexpr subrange prev(iter_difference_t<I> n = 1) const
  requires bidirectional_iterator<I>;

Effects: Equivalent to:

auto tmp = *this;
tmp.advance(-n);
return tmp;

🔗

constexpr subrange& advance(iter_difference_t<I> n);

Effects: Equivalent to:

(9.1)

If StoreSize is true,

auto d = n - ranges::advance(begin_, n, end_);
if (d >= 0)
  size_ -= make-unsigned-like(d);
else
  size_ += make-unsigned-like(-d);
return *this;

(9.2)

Otherwise,

ranges::advance(begin_, n, end_);
return *this;

🔗

template<size_t N, class I, class S, subrange_kind K>
  requires (N < 2)
  constexpr auto get(const subrange<I, S, K>& r);
template<size_t N, class I, class S, subrange_kind K>
  requires (N < 2)
  constexpr auto get(subrange<I, S, K>&& r);

Effects: Equivalent to:

if constexpr (N == 0)
  return r.begin();
else
  return r.end();

24.5.4 Dangling iterator handling [range.dangling]

The tag type dangling is used together with the template aliases safe_iterator_t and safe_subrange_t to indicate that an algorithm that typically returns an iterator into or subrange of a range argument does not return an iterator or subrange which could potentially reference a range whose lifetime has ended for a particular rvalue range argument which does not model safe_range ([range.range]).

namespace std::ranges {
  struct dangling {
    constexpr dangling() noexcept = default;
    template<class... Args>
      constexpr dangling(Args&&...) noexcept { }
  };
}

[ Example

vector<int> f();
auto result1 = ranges::find(f(), 42);                                   // #1
static_assert(same_as<decltype(result1), ranges::dangling>);
auto vec = f();
auto result2 = ranges::find(vec, 42);                                   // #2
static_assert(same_as<decltype(result2), vector<int>::iterator>);
auto result3 = ranges::find(subrange{vec}, 42);                         // #3
static_assert(same_as<decltype(result3), vector<int>::iterator>);

The call to ranges::find at #1 returns ranges::dangling since f() is an rvalue vector; the vector could potentially be destroyed before a returned iterator is dereferenced.

However, the calls at #2 and #3 both return iterators since the lvalue vec and specializations of subrange model safe_range.

— end example

]

24.6 Range factories [range.factories]

This subclause defines range factories, which are utilities to create a view.

Range factories are declared in namespace std::ranges::views.

24.6.1 Empty view [range.empty]

24.6.1.1 Overview [range.empty.overview]

empty_view produces a view of no elements of a particular type.

[ Example

empty_view<int> e;
static_assert(ranges::empty(e));
static_assert(0 == e.size());

— end example

]

24.6.1.2 Class template empty_view [range.empty.view]

namespace std::ranges {
  template<class T>
    requires is_object_v<T>
  class empty_view : public view_interface<empty_view<T>> {
  public:
    static constexpr T* begin() noexcept { return nullptr; }
    static constexpr T* end() noexcept { return nullptr; }
    static constexpr T* data() noexcept { return nullptr; }
    static constexpr size_t size() noexcept { return 0; }
    static constexpr bool empty() noexcept { return true; }
  };
}

24.6.2 Single view [range.single]

24.6.2.1 Overview [range.single.overview]

single_view produces a view that contains exactly one element of a specified value.

[ Example

single_view s{4};
for (int i : s)
  cout << i;        // prints 4

— end example

]

24.6.2.2 Class template single_view [range.single.view]

namespace std::ranges {
  template<copy_constructible T>
    requires is_object_v<T>
  class single_view : public view_interface<single_view<T>> {
  private:
    semiregular-box<T> value_;      // exposition only (see [range.semi.wrap])
  public:
    single_view() = default;
    constexpr explicit single_view(const T& t);
    constexpr explicit single_view(T&& t);
    template<class... Args>
      requires constructible_from<T, Args...>
    constexpr single_view(in_place_t, Args&&... args);

    constexpr T* begin() noexcept;
    constexpr const T* begin() const noexcept;
    constexpr T* end() noexcept;
    constexpr const T* end() const noexcept;
    static constexpr size_t size() noexcept;
    constexpr T* data() noexcept;
    constexpr const T* data() const noexcept;
  };
}

🔗

constexpr explicit single_view(const T& t);

Effects: Initializes value_ with t.

🔗

constexpr explicit single_view(T&& t);

Effects: Initializes value_ with std::move(t).

🔗

template<class... Args>
constexpr single_view(in_place_t, Args&&... args);

Effects: Initializes value_ as if by value_{in_place, std::forward<Args>(args)...}.

🔗

constexpr T* begin() noexcept;
constexpr const T* begin() const noexcept;

Effects: Equivalent to: return data();

🔗

constexpr T* end() noexcept;
constexpr const T* end() const noexcept;

Effects: Equivalent to: return data() + 1;

🔗

static constexpr size_t size() noexcept;

Effects: Equivalent to: return 1;

🔗

constexpr T* data() noexcept;
constexpr const T* data() const noexcept;

Effects: Equivalent to: return value_.operator->();

24.6.2.3 views::single [range.single.adaptor]

The name views::single denotes a customization point object ([customization.point.object]).

For some subexpression E, the expression views::single(E) is expression-equivalent to single_view{E}.

24.6.3 Iota view [range.iota]

24.6.3.1 Overview [range.iota.overview]

iota_view generates a sequence of elements by repeatedly incrementing an initial value.

[ Example

for (int i : iota_view{1, 10})
  cout << i << ' '; // prints: 1 2 3 4 5 6 7 8 9

— end example

]

24.6.3.2 Class template iota_view [range.iota.view]

namespace std::ranges {
  template<class I>
    concept decrementable =     // exposition only
      see below;
  template<class I>
    concept advanceable =       // exposition only
      see below;

  template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
    requires weakly-equality-comparable-with<W, Bound>
  class iota_view : public view_interface<iota_view<W, Bound>> {
  private:
    // [range.iota.iterator], class iota_view::iterator
    struct iterator;            // exposition only
    // [range.iota.sentinel], class iota_view::sentinel
    struct sentinel;            // exposition only
    W value_ = W();             // exposition only
    Bound bound_ = Bound();     // exposition only
  public:
    iota_view() = default;
    constexpr explicit iota_view(W value);
    constexpr iota_view(type_identity_t<W> value,
                        type_identity_t<Bound> bound);

    constexpr iterator begin() const;
    constexpr auto end() const;
    constexpr iterator end() const requires same_as<W, Bound>;

    constexpr auto size() const requires see below;
  };

  template<class W, class Bound>
    requires (!is-integer-like<W> || !is-integer-like<Bound> ||
      (is-signed-integer-like<W> == is-signed-integer-like<Bound>))
    iota_view(W, Bound) -> iota_view<W, Bound>;
}

Let IOTA-DIFF-T(W) be defined as follows:

(1.1)
If W is not an integral type, or if it is an integral type and sizeof(iter_difference_t<W>) is greater than sizeof(W), then IOTA-DIFF-T(W) denotes iter_difference_t<W>.
(1.2)
Otherwise, IOTA-DIFF-T(W) is a signed integer type of width greater than the width of W if such a type exists.
(1.3)
Otherwise, IOTA-DIFF-T(W) is an unspecified signed-integer-like type ([iterator.concept.winc]) of width not less than the width of W.
[ Note
: It is unspecified whether this type satisfies weakly_incrementable. — end note
]

The exposition-only decrementable concept is equivalent to:

🔗

template<class I>
  concept decrementable =
    incrementable<I> && requires(I i) {
      { --i } -> same_as<I&>;
      { i-- } -> same_as<I>;
    };

When an object is in the domain of both pre- and post-decrement, the object is said to be decrementable.

Let a and b be equal objects of type I.

I models decrementable only if

(4.1)
If a and b are decrementable, then the following are all true:
- (4.1.1)
  addressof(--a) == addressof(a)
- (4.1.2)
  bool(a-- == b)
- (4.1.3)
  bool(((void)a--, a) == --b)
- (4.1.4)
  bool(++(--a) == b).
(4.2)
If a and b are incrementable, then bool(--(++a) == b).

The exposition-only advanceable concept is equivalent to:

🔗

template<class I>
  concept advanceable =
    decrementable<I> && totally_ordered<I> &&
    requires(I i, const I j, const IOTA-DIFF-T(I) n) {
      { i += n } -> same_as<I&>;
      { i -= n } -> same_as<I&>;
      I(j + n);
      I(n + j);
      I(j - n);
      { j - j } -> convertible_to<IOTA-DIFF-T(I)>;
    };

Let D be IOTA-DIFF-T(I).

Let a and b be objects of type I such that b is reachable from a after n applications of ++a, for some value n of type D.

I models advanceable only if

(a += n) is equal to b.
addressof(a += n) is equal to addressof(a).
I(a + n) is equal to (a += n).
For any two positive values x and y of type D, if I(a + D(x + y)) is well-defined, then I(a + D(x + y)) is equal to I(I(a + x) + y).
I(a + D(0)) is equal to a.
If I(a + D(n - 1)) is well-defined, then I(a + n) is equal to [](I c) { return ++c; }(I(a + D(n - 1))).
(b += -n) is equal to a.
(b -= n) is equal to a.
addressof(b -= n) is equal to addressof(b).
I(b - n) is equal to (b -= n).
D(b - a) is equal to n.
D(a - b) is equal to D(-n).
bool(a <= b) is true.

🔗

constexpr explicit iota_view(W value);

Preconditions: Bound denotes unreachable_sentinel_t or Bound() is reachable from value.

Effects: Initializes value_ with value.

🔗

constexpr iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);

Preconditions: Bound denotes unreachable_sentinel_t or bound is reachable from value.

When W and Bound model totally_ordered_with, then bool(value <= bound) is true.

Effects: Initializes value_ with value and bound_ with bound.

🔗

constexpr iterator begin() const;

Effects: Equivalent to: return iterator{value_};

🔗

constexpr auto end() const;

Effects: Equivalent to:

if constexpr (same_as<Bound, unreachable_sentinel_t>)
  return unreachable_sentinel;
else
  return sentinel{bound_};

🔗

constexpr iterator end() const requires same_as<W, Bound>;

Effects: Equivalent to: return iterator{bound_};

🔗

constexpr auto size() const requires see below;

Effects: Equivalent to:

if constexpr (is-integer-like<W> && is-integer-like<Bound>)
  return (value_ < 0)
    ? ((bound_ < 0)
      ? make-unsigned-like(-value_) - make-unsigned-like(-bound_)
      : make-unsigned-like(bound_) + make-unsigned-like(-value_))
    : make-unsigned-like(bound_) - make-unsigned-like(value_);
else
  return make-unsigned-like(bound_ - value_);

Remarks: The expression in the requires-clause is equivalent to

(same_as<W, Bound> && advanceable<W>) || (integral<W> && integral<Bound>) ||
  sized_sentinel_for<Bound, W>

24.6.3.3 Class iota_view::iterator [range.iota.iterator]

namespace std::ranges {
  template<class W, class Bound>
  struct iota_view<W, Bound>::iterator {
  private:
    W value_ = W();             // exposition only
  public:
    using iterator_category = see below;
    using value_type = W;
    using difference_type = IOTA-DIFF-T(W);

    iterator() = default;
    constexpr explicit iterator(W value);

    constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);

    constexpr iterator& operator++();
    constexpr void operator++(int);
    constexpr iterator operator++(int) requires incrementable<W>;

    constexpr iterator& operator--() requires decrementable<W>;
    constexpr iterator operator--(int) requires decrementable<W>;

    constexpr iterator& operator+=(difference_type n)
      requires advanceable<W>;
    constexpr iterator& operator-=(difference_type n)
      requires advanceable<W>;
    constexpr W operator[](difference_type n) const
      requires advanceable<W>;

    friend constexpr bool operator==(const iterator& x, const iterator& y)
      requires equality_comparable<W>;

    friend constexpr bool operator<(const iterator& x, const iterator& y)
      requires totally_ordered<W>;
    friend constexpr bool operator>(const iterator& x, const iterator& y)
      requires totally_ordered<W>;
    friend constexpr bool operator<=(const iterator& x, const iterator& y)
      requires totally_ordered<W>;
    friend constexpr bool operator>=(const iterator& x, const iterator& y)
      requires totally_ordered<W>;
    friend constexpr compare_three_way_result_t<W> operator<=>(
        const iterator& x, const iterator& y)
      requires totally_ordered<W> && three_way_comparable<W>;

    friend constexpr iterator operator+(iterator i, difference_type n)
      requires advanceable<W>;
    friend constexpr iterator operator+(difference_type n, iterator i)
      requires advanceable<W>;

    friend constexpr iterator operator-(iterator i, difference_type n)
      requires advanceable<W>;
    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
      requires advanceable<W>;
  };
}

iterator::iterator_category is defined as follows:

(1.1)
If W models advanceable, then iterator_category is random_access_iterator_tag.
(1.2)
Otherwise, if W models decrementable, then iterator_category is bidirectional_iterator_tag.
(1.3)
Otherwise, if W models incrementable, then iterator_category is forward_iterator_tag.
(1.4)
Otherwise, iterator_category is input_iterator_tag.

[ Note

Overloads for iter_move and iter_swap are omitted intentionally.

— end note

]

🔗

constexpr explicit iterator(W value);

Effects: Initializes value_ with value.

🔗

constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);

Effects: Equivalent to: return value_;

[ Note

The noexcept clause is needed by the default iter_move implementation.

— end note

]

🔗

constexpr iterator& operator++();

Effects: Equivalent to:

++value_;
return *this;

🔗

constexpr void operator++(int);

Effects: Equivalent to ++*this.

🔗

constexpr iterator operator++(int) requires incrementable<W>;

Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

🔗

constexpr iterator& operator--() requires decrementable<W>;

Effects: Equivalent to:

--value_;
return *this;

🔗

constexpr iterator operator--(int) requires decrementable<W>;

Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

🔗

constexpr iterator& operator+=(difference_type n)
  requires advanceable<W>;

Effects: Equivalent to:

if constexpr (is-integer-like<W> && !is-signed-integer-like<W>) {
  if (n >= difference_type(0))
    value_ += static_cast<W>(n);
  else
    value_ -= static_cast<W>(-n);
} else {
  value_ += n;
}
return *this;

🔗

constexpr iterator& operator-=(difference_type n)
  requires advanceable<W>;

Effects: Equivalent to:

if constexpr (is-integer-like<W> && !is-signed-integer-like<W>) {
  if (n >= difference_type(0))
    value_ -= static_cast<W>(n);
  else
    value_ += static_cast<W>(-n);
} else {
  value_ -= n;
}
return *this;

🔗

constexpr W operator[](difference_type n) const
  requires advanceable<W>;

Effects: Equivalent to: return W(value_ + n);

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires equality_comparable<W>;

Effects: Equivalent to: return x.value_ == y.value_;

🔗

friend constexpr bool operator<(const iterator& x, const iterator& y)
  requires totally_ordered<W>;

Effects: Equivalent to: return x.value_ < y.value_;

🔗

friend constexpr bool operator>(const iterator& x, const iterator& y)
  requires totally_ordered<W>;

Effects: Equivalent to: return y < x;

🔗

friend constexpr bool operator<=(const iterator& x, const iterator& y)
  requires totally_ordered<W>;

Effects: Equivalent to: return !(y < x);

🔗

friend constexpr bool operator>=(const iterator& x, const iterator& y)
  requires totally_ordered<W>;

Effects: Equivalent to: return !(x < y);

🔗

friend constexpr compare_three_way_result_t<W>
  operator<=>(const iterator& x, const iterator& y)
    requires totally_ordered<W> && three_way_comparable<W>;

Effects: Equivalent to: return x.value_ <=> y.value_;

🔗

friend constexpr iterator operator+(iterator i, difference_type n)
  requires advanceable<W>;

Effects: Equivalent to: return i += n;

🔗

friend constexpr iterator operator+(difference_type n, iterator i)
  requires advanceable<W>;

Effects: Equivalent to: return i + n;

🔗

friend constexpr iterator operator-(iterator i, difference_type n)
  requires advanceable<W>;

Effects: Equivalent to: return i -= n;

🔗

friend constexpr difference_type operator-(const iterator& x, const iterator& y)
  requires advanceable<W>;

Effects: Equivalent to:

using D = difference_type;
if constexpr (is-integer-like<W>) {
  if constexpr (is-signed-integer-like<W>)
    return D(D(x.value_) - D(y.value_));
  else
    return (y.value_ > x.value_)
      ? D(-D(y.value_ - x.value_))
      : D(x.value_ - y.value_);
} else {
  return x.value_ - y.value_;
}

24.6.3.4 Class iota_view::sentinel [range.iota.sentinel]

namespace std::ranges {
  template<class W, class Bound>
  struct iota_view<W, Bound>::sentinel {
  private:
    Bound bound_ = Bound();     // exposition only
  public:
    sentinel() = default;
    constexpr explicit sentinel(Bound bound);

    friend constexpr bool operator==(const iterator& x, const sentinel& y);

    friend constexpr iter_difference_t<W> operator-(const iterator& x, const sentinel& y)
      requires sized_sentinel_for<Bound, W>;
    friend constexpr iter_difference_t<W> operator-(const sentinel& x, const iterator& y)
      requires sized_sentinel_for<Bound, W>;
  };
}

🔗

constexpr explicit sentinel(Bound bound);

Effects: Initializes bound_ with bound.

🔗

friend constexpr bool operator==(const iterator& x, const sentinel& y);

Effects: Equivalent to: return x.value_ == y.bound_;

🔗

friend constexpr iter_difference_t<W> operator-(const iterator& x, const sentinel& y)
  requires sized_sentinel_for<Bound, W>;

Effects: Equivalent to: return x.value_ - y.bound_;

🔗

friend constexpr iter_difference_t<W> operator-(const sentinel& x, const iterator& y)
  requires sized_sentinel_for<Bound, W>;

Effects: Equivalent to: return -(y - x);

24.6.3.5 views::iota [range.iota.adaptor]

The name views::iota denotes a customization point object ([customization.point.object]).

For some subexpressions E and F, the expressions views::iota(E) and views::iota(E, F) are expression-equivalent to iota_view{E} and iota_view{E, F}, respectively.

24.6.4 Istream view [range.istream]

24.6.4.1 Overview [range.istream.overview]

basic_istream_view models input_range and reads (using operator>>) successive elements from its corresponding input stream.

[ Example

auto ints = istringstream{"0 1  2   3     4"};
ranges::copy(istream_view<int>(ints), ostream_iterator<int>{cout, "-"});
// prints 0-1-2-3-4-

— end example

]

24.6.4.2 Class template basic_istream_view [range.istream.view]

namespace std::ranges {
  template<class Val, class CharT, class Traits>
    concept stream-extractable =                // exposition only
      requires(basic_istream<CharT, Traits>& is, Val& t) {
         is >> t;
      };

  template<movable Val, class CharT, class Traits>
    requires default_constructible<Val> &&
      stream-extractable<Val, CharT, Traits>
  class basic_istream_view : public view_interface<basic_istream_view<Val, CharT, Traits>> {
  public:
    basic_istream_view() = default;
    constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream);

    constexpr auto begin()
    {
      if (stream_) {
        *stream_ >> object_;
      }
      return iterator{*this};
    }

    constexpr default_sentinel_t end() const noexcept;

  private:
    struct iterator;                                    // exposition only
    basic_istream<CharT, Traits>* stream_{};            // exposition only
    Val object_ = Val();                                // exposition only
  };
}

🔗

constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream);

Effects: Initializes stream_ with addressof(stream).

🔗

constexpr default_sentinel_t end() const noexcept;

Effects: Equivalent to: return default_sentinel;

🔗

template<class Val, class CharT, class Traits>
basic_istream_view<Val, CharT, Traits> istream_view(basic_istream<CharT, Traits>& s);

Effects: Equivalent to: return basic_istream_view<Val, CharT, Traits>{s};

24.6.4.3 Class template basic_istream_view::iterator [range.istream.iterator]

namespace std::ranges {
  template<class Val, class CharT, class Traits>
  class basic_istream_view<Val, CharT, Traits>::iterator {      // exposition only
  public:
    using iterator_category = input_iterator_tag;
    using difference_type = ptrdiff_t;
    using value_type = Val;

    iterator() = default;
    constexpr explicit iterator(basic_istream_view& parent) noexcept;

    iterator(const iterator&) = delete;
    iterator(iterator&&) = default;

    iterator& operator=(const iterator&) = delete;
    iterator& operator=(iterator&&) = default;

    iterator& operator++();
    void operator++(int);

    Val& operator*() const;

    friend bool operator==(const iterator& x, default_sentinel_t);

  private:
    basic_istream_view* parent_{};                              // exposition only
  };
}

🔗

constexpr explicit iterator(basic_istream_view& parent) noexcept;

Effects: Initializes parent_ with addressof(parent).

🔗

iterator& operator++();

Preconditions: parent_->stream_ != nullptr is true.

Effects: Equivalent to:

*parent_->stream >> parent_->object_;
return *this;

🔗

void operator++(int);

Preconditions: parent_->stream_ != nullptr is true.

Effects: Equivalent to ++*this.

🔗

Val& operator*() const;

Preconditions: parent_->stream_ != nullptr is true.

Effects: Equivalent to: return parent_->value_;

🔗

friend bool operator==(const iterator& x, default_sentinel_t);

Effects: Equivalent to: return x.parent_ == nullptr || !*x.parent_->stream_;

24.7 Range adaptors [range.adaptors]

This subclause defines range adaptors, which are utilities that transform a range into a view with custom behaviors.

These adaptors can be chained to create pipelines of range transformations that evaluate lazily as the resulting view is iterated.

Range adaptors are declared in namespace std::ranges::views.

The bitwise OR operator is overloaded for the purpose of creating adaptor chain pipelines.

The adaptors also support function call syntax with equivalent semantics.

[ Example

vector<int> ints{0,1,2,3,4,5};
auto even = [](int i){ return 0 == i % 2; };
auto square = [](int i) { return i * i; };
for (int i : ints | views::filter(even) | views::transform(square)) {
  cout << i << ' '; // prints: 0 4 16
}
assert(ranges::equal(ints | views::filter(even), views::filter(ints, even)));

— end example

]

24.7.1 Range adaptor objects [range.adaptor.object]

A range adaptor closure object is a unary function object that accepts a viewable_range argument and returns a view.

For a range adaptor closure object C and an expression R such that decltype((R)) models viewable_range, the following expressions are equivalent and yield a view:

C(R)
R | C

Given an additional range adaptor closure object D, the expression C | D is well-formed and produces another range adaptor closure object such that the following two expressions are equivalent:

R | C | D
R | (C | D)

A range adaptor object is a customization point object ([customization.point.object]) that accepts a viewable_range as its first argument and returns a view.

If a range adaptor object accepts only one argument, then it is a range adaptor closure object.

If a range adaptor object accepts more than one argument, then the following expressions are equivalent:

adaptor(range, args...)
adaptor(args...)(range)
range | adaptor(args...)

In this case, adaptor(args...) is a range adaptor closure object.

24.7.2 Semiregular wrapper [range.semi.wrap]

Many types in this subclause are specified in terms of an exposition-only class template semiregular-box.

semiregular-box<T> behaves exactly like optional<T> with the following differences:

(1.1)
semiregular-box<T> constrains its type parameter T with copy_constructible<T> && is_object_v<T>.

(1.2)

If T models default_constructible, the default constructor of semiregular-box<T> is equivalent to:

constexpr semiregular-box() noexcept(is_nothrow_default_constructible_v<T>)
  : semiregular-box{in_place}
{ }

(1.3)

If assignable_from<T&, const T&> is not modeled, the copy assignment operator is equivalent to:

semiregular-box& operator=(const semiregular-box& that)
  noexcept(is_nothrow_copy_constructible_v<T>)
{
  if (that) emplace(*that);
  else reset();
  return *this;
}

(1.4)

If assignable_from<T&, T> is not modeled, the move assignment operator is equivalent to:

semiregular-box& operator=(semiregular-box&& that)
  noexcept(is_nothrow_move_constructible_v<T>)
{
  if (that) emplace(std::move(*that));
  else reset();
  return *this;
}

24.7.3 All view [range.all]

views::all returns a view that includes all elements of its range argument.

The name views::all denotes a range adaptor object ([range.adaptor.object]).

For some subexpression E, the expression views::all(E) is expression-equivalent to:

(2.1)
decay-copy(E) if the decayed type of E models view.
(2.2)
Otherwise, ref_view{E} if that expression is well-formed.
(2.3)
Otherwise, subrange{E}.

24.7.3.1 Class template ref_view [range.ref.view]

ref_view is a view of the elements of some other range.

namespace std::ranges {
  template<range R>
    requires is_object_v<R>
  class ref_view : public view_interface<ref_view<R>> {
  private:
    R* r_ = nullptr;            // exposition only
  public:
    constexpr ref_view() noexcept = default;

    template<not-same-as<ref_view> T>
      requires see below
    constexpr ref_view(T&& t);

    constexpr R& base() const { return *r_; }

    constexpr iterator_t<R> begin() const { return ranges::begin(*r_); }
    constexpr sentinel_t<R> end() const { return ranges::end(*r_); }

    constexpr bool empty() const
      requires requires { ranges::empty(*r_); }
    { return ranges::empty(*r_); }

    constexpr auto size() const requires sized_range<R>
    { return ranges::size(*r_); }

    constexpr auto data() const requires contiguous_range<R>
    { return ranges::data(*r_); }
  };
  template<class R>
    ref_view(R&) -> ref_view<R>;
}

🔗

template<not-same-as<ref_view> T>
  requires see below
constexpr ref_view(T&& t);

Remarks: Let FUN denote the exposition-only functions

void FUN(R&);
void FUN(R&&) = delete;

The expression in the requires-clause is equivalent to

convertible_to<T, R&> && requires { FUN(declval<T>()); }

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

24.7.4 Filter view [range.filter]

24.7.4.1 Overview [range.filter.overview]

filter_view presents a view of the elements of an underlying sequence that satisfy a predicate.

[ Example

vector<int> is{ 0, 1, 2, 3, 4, 5, 6 };
filter_view evens{is, [](int i) { return 0 == i % 2; }};
for (int i : evens)
  cout << i << ' '; // prints: 0 2 4 6

— end example

]

24.7.4.2 Class template filter_view [range.filter.view]

namespace std::ranges {
  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class filter_view : public view_interface<filter_view<V, Pred>> {
  private:
    V base_ = V();                      // exposition only
    semiregular-box<Pred> pred_;  // exposition only

    // [range.filter.iterator], class filter_view::iterator
    class iterator;                     // exposition only
    // [range.filter.sentinel], class filter_view::sentinel
    class sentinel;                     // exposition only

  public:
    filter_view() = default;
    constexpr filter_view(V base, Pred pred);
    template<input_range R>
      requires viewable_range<R> && constructible_from<V, all_view<R>>
    constexpr filter_view(R&& r, Pred pred);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr iterator begin();
    constexpr auto end() {
      if constexpr (common_range<V>)
        return iterator{*this, ranges::end(base_)};
      else
        return sentinel{*this};
    }
  };

  template<class R, class Pred>
    filter_view(R&&, Pred) -> filter_view<all_view<R>, Pred>;
}

🔗

constexpr filter_view(V base, Pred pred);

Effects: Initializes base_ with std::move(base) and initializes pred_ with std::move(pred).

🔗

template<input_range R>
  requires viewable_range<R> && constructible_from<V, all_view<R>>
constexpr filter_view(R&& r, Pred pred);

Effects: Initializes base_ with views::all(std::forward<R>(r)) and initializes pred_ with std::move(pred).

🔗

constexpr iterator begin();

Preconditions: pred_.has_value().

Returns: {*this, ranges::find_if(base_, ref(*pred_))}.

Remarks: In order to provide the amortized constant time complexity required by the range concept when filter_view models forward_range, this function caches the result within the filter_view for use on subsequent calls.

24.7.4.3 Class filter_view::iterator [range.filter.iterator]

namespace std::ranges {
  template<class V, class Pred>
  class filter_view<V, Pred>::iterator {
  private:
    iterator_t<V> current_ = iterator_t<V>();   // exposition only
    filter_view* parent_ = nullptr;             // exposition only
  public:
    using iterator_concept  = see below;
    using iterator_category = see below;
    using value_type        = range_value_t<V>;
    using difference_type   = range_difference_t<V>;

    iterator() = default;
    constexpr iterator(filter_view& parent, iterator_t<V> current);

    constexpr iterator_t<V> base() const &
      requires copyable<iterator_t<V>>;
    constexpr iterator_t<V> base() &&;
    constexpr range_reference_t<V> operator*() const;
    constexpr iterator_t<V> operator->() const
      requires has-arrow<iterator_t<V>> && copyable<iterator_t<V>>;

    constexpr iterator& operator++();
    constexpr void operator++(int);
    constexpr iterator operator++(int) requires forward_range<V>;

    constexpr iterator& operator--() requires bidirectional_range<V>;
    constexpr iterator operator--(int) requires bidirectional_range<V>;

    friend constexpr bool operator==(const iterator& x, const iterator& y)
      requires equality_comparable<iterator_t<V>>;

    friend constexpr range_rvalue_reference_t<V> iter_move(const iterator& i)
      noexcept(noexcept(ranges::iter_move(i.current_)));
    friend constexpr void iter_swap(const iterator& x, const iterator& y)
      noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
      requires indirectly_swappable<iterator_t<V>>;
  };
}

Modification of the element a filter_view::iterator denotes is permitted, but results in undefined behavior if the resulting value does not satisfy the filter predicate.

iterator::iterator_concept is defined as follows:

(2.1)
If V models bidirectional_range, then iterator_concept denotes bidirectional_iterator_tag.
(2.2)
Otherwise, if V models forward_range, then iterator_concept denotes forward_iterator_tag.
(2.3)
Otherwise, iterator_concept denotes input_iterator_tag.

iterator::iterator_category is defined as follows:

(3.1)
Let C denote the type iterator_traits<iterator_t<V>>::iterator_category.
(3.2)
If C models derived_from<bidirectional_iterator_tag>, then iterator_category denotes bidirectional_iterator_tag.
(3.3)
Otherwise, if C models derived_from<forward_iterator_tag>, then iterator_category denotes forward_iterator_tag.
(3.4)
Otherwise, iterator_category denotes C.

🔗

constexpr iterator(filter_view& parent, iterator_t<V> current);

Effects: Initializes current_ with std::move(current) and parent_ with addressof(parent).

🔗

constexpr iterator_t<V> base() const &
  requires copyable<iterator_t<V>>;

Effects: Equivalent to: return current_;

🔗

constexpr iterator_t<V> base() &&;

Effects: Equivalent to: return std::move(current_);

🔗

constexpr range_reference_t<V> operator*() const;

Effects: Equivalent to: return *current_;

🔗

constexpr iterator_t<V> operator->() const
  requires has-arrow<iterator_t<V>> && copyable<iterator_t<V>>;

Effects: Equivalent to: return current_;

🔗

constexpr iterator& operator++();

Effects: Equivalent to:

current_ = ranges::find_if(std::move(++current_), ranges::end(parent_->base_),
                           ref(*parent_->pred_));
return *this;

🔗

constexpr void operator++(int);

Effects: Equivalent to ++*this.

🔗

constexpr iterator operator++(int) requires forward_range<V>;

Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

🔗

constexpr iterator& operator--() requires bidirectional_range<V>;

Effects: Equivalent to:

do
  --current_;
while (!invoke(*parent_->pred_, *current_));
return *this;

🔗

constexpr iterator operator--(int) requires bidirectional_range<V>;

Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires equality_comparable<iterator_t<V>>;

Effects: Equivalent to: return x.current_ == y.current_;

🔗

friend constexpr range_rvalue_reference_t<V> iter_move(const iterator& i)
  noexcept(noexcept(ranges::iter_move(i.current_)));

Effects: Equivalent to: return ranges::iter_move(i.current_);

🔗

friend constexpr void iter_swap(const iterator& x, const iterator& y)
  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
  requires indirectly_swappable<iterator_t<V>>;

Effects: Equivalent to ranges::iter_swap(x.current_, y.current_).

24.7.4.4 Class filter_view::sentinel [range.filter.sentinel]

namespace std::ranges {
  template<class V, class Pred>
  class filter_view<V, Pred>::sentinel {
  private:
    sentinel_t<V> end_ = sentinel_t<V>();       // exposition only
  public:
    sentinel() = default;
    constexpr explicit sentinel(filter_view& parent);

    constexpr sentinel_t<V> base() const;

    friend constexpr bool operator==(const iterator& x, const sentinel& y);
  };
}

🔗

constexpr explicit sentinel(filter_view& parent);

Effects: Initializes end_ with ranges::end(parent.base_).

🔗

constexpr sentinel_t<V> base() const;

Effects: Equivalent to: return end_;

🔗

friend constexpr bool operator==(const iterator& x, const sentinel& y);

Effects: Equivalent to: return x.current_ == y.end_;

24.7.4.5 views::filter [range.filter.adaptor]

The name views::filter denotes a range adaptor object ([range.adaptor.object]).

For some subexpressions E and P, the expression views::filter(E, P) is expression-equivalent to filter_view{E, P}.

24.7.5 Transform view [range.transform]

24.7.5.1 Overview [range.transform.overview]

transform_view presents a view of an underlying sequence after applying a transformation function to each element.

[ Example

vector<int> is{ 0, 1, 2, 3, 4 };
transform_view squares{is, [](int i) { return i * i; }};
for (int i : squares)
  cout << i << ' '; // prints: 0 1 4 9 16

— end example

]

24.7.5.2 Class template transform_view [range.transform.view]

namespace std::ranges {
  template<input_range V, copy_constructible F>
    requires view<V> && is_object_v<F> &&
             regular_invocable<F&, range_reference_t<V>>
  class transform_view : public view_interface<transform_view<V, F>> {
  private:
    // [range.transform.iterator], class template transform_view::iterator
    template<bool> struct iterator;             // exposition only
    // [range.transform.sentinel], class template transform_view::sentinel
    template<bool> struct sentinel;             // exposition only

    V base_ = V();                              // exposition only
    semiregular-box<F> fun_;                    // exposition only

  public:
    transform_view() = default;
    constexpr transform_view(V base, F fun);
    template<input_range R>
      requires viewable_range<R> && constructible_from<V, all_view<R>>
    constexpr transform_view(R&& r, F fun);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr iterator<false> begin();
    constexpr iterator<true> begin() const
      requires range<const V> &&
               regular_invocable<const F&, range_reference_t<const V>>;

    constexpr sentinel<false> end();
    constexpr iterator<false> end() requires common_range<V>;
    constexpr sentinel<true> end() const
      requires range<const V> &&
               regular_invocable<const F&, range_reference_t<const V>>;
    constexpr iterator<true> end() const
      requires common_range<const V> &&
               regular_invocable<const F&, range_reference_t<const V>>;

    constexpr auto size() requires sized_range<V> { return ranges::size(base_); }
    constexpr auto size() const requires sized_range<const V>
    { return ranges::size(base_); }
  };

  template<class R, class F>
    transform_view(R&&, F) -> transform_view<all_view<R>, F>;
}

🔗

constexpr transform_view(V base, F fun);

Effects: Initializes base_ with std::move(base) and fun_ with std::move(fun).

🔗

template<input_range R>
  requires viewable_range<R> && constructible_from<V, all_view<R>>
constexpr transform_view(R&& r, F fun);

Effects: Initializes base_ with views::all(std::forward<R>(r)) and fun_ with std::move(fun).

🔗

constexpr iterator<false> begin();

Effects: Equivalent to:

return iterator<false>{*this, ranges::begin(base_)};

🔗

constexpr iterator<true> begin() const
  requires range<const V> &&
           regular_invocable<const F&, range_reference_t<const V>>;

Effects: Equivalent to:

return iterator<true>{*this, ranges::begin(base_)};

🔗

constexpr sentinel<false> end();

Effects: Equivalent to:

return sentinel<false>{ranges::end(base_)};

🔗

constexpr iterator<false> end() requires common_range<V>;

Effects: Equivalent to:

return iterator<false>{*this, ranges::end(base_)};

🔗

constexpr sentinel<true> end() const
  requires range<const V> &&
           regular_invocable<const F&, range_reference_t<const V>>;

Effects: Equivalent to:

return sentinel<true>{ranges::end(base_)};

🔗

constexpr iterator<true> end() const
  requires common_range<const V> &&
           regular_invocable<const F&, range_reference_t<const V>>;

Effects: Equivalent to:

return iterator<true>{*this, ranges::end(base_)};

24.7.5.3 Class template transform_view::iterator [range.transform.iterator]

namespace std::ranges {
  template<class V, class F>
  template<bool Const>
  class transform_view<V, F>::iterator {
  private:
    using Parent =                              // exposition only
      conditional_t<Const, const transform_view, transform_view>;
    using Base   =                              // exposition only
      conditional_t<Const, const V, V>;
    iterator_t<Base> current_ =                 // exposition only
      iterator_t<Base>();
    Parent* parent_ = nullptr;                  // exposition only
  public:
    using iterator_concept  = see below;
    using iterator_category = see below;
    using value_type        =
      remove_cvref_t<invoke_result_t<F&, range_reference_t<Base>>>;
    using difference_type   = range_difference_t<Base>;

    iterator() = default;
    constexpr iterator(Parent& parent, iterator_t<Base> current);
    constexpr iterator(iterator<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;

    constexpr iterator_t<Base> base() const &
      requires copyable<iterator_t<Base>>;
    constexpr iterator_t<Base> base() &&;
    constexpr decltype(auto) operator*() const
    { return invoke(*parent_->fun_, *current_); }

    constexpr iterator& operator++();
    constexpr void operator++(int);
    constexpr iterator operator++(int) requires forward_range<Base>;

    constexpr iterator& operator--() requires bidirectional_range<Base>;
    constexpr iterator operator--(int) requires bidirectional_range<Base>;

    constexpr iterator& operator+=(difference_type n)
      requires random_access_range<Base>;
    constexpr iterator& operator-=(difference_type n)
      requires random_access_range<Base>;
    constexpr decltype(auto) operator[](difference_type n) const
      requires random_access_range<Base>
    { return invoke(*parent_->fun_, current_[n]); }

    friend constexpr bool operator==(const iterator& x, const iterator& y)
      requires equality_comparable<iterator_t<Base>>;

    friend constexpr bool operator<(const iterator& x, const iterator& y)
      requires random_access_range<Base>;
    friend constexpr bool operator>(const iterator& x, const iterator& y)
      requires random_access_range<Base>;
    friend constexpr bool operator<=(const iterator& x, const iterator& y)
      requires random_access_range<Base>;
    friend constexpr bool operator>=(const iterator& x, const iterator& y)
      requires random_access_range<Base>;
    friend constexpr compare_three_way_result_t<iterator_t<Base>>
      operator<=>(const iterator& x, const iterator& y)
        requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;

    friend constexpr iterator operator+(iterator i, difference_type n)
      requires random_access_range<Base>;
    friend constexpr iterator operator+(difference_type n, iterator i)
      requires random_access_range<Base>;

    friend constexpr iterator operator-(iterator i, difference_type n)
      requires random_access_range<Base>;
    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
      requires random_access_range<Base>;

    friend constexpr decltype(auto) iter_move(const iterator& i)
      noexcept(noexcept(invoke(*i.parent_->fun_, *i.current_)))
    {
      if constexpr (is_lvalue_reference_v<decltype(*i)>)
        return std::move(*i);
      else
        return *i;
    }

    friend constexpr void iter_swap(const iterator& x, const iterator& y)
      noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
      requires indirectly_swappable<iterator_t<Base>>;
  };
}

iterator::iterator_concept is defined as follows:

(1.1)
If V models random_access_range, then iterator_concept denotes random_access_iterator_tag.
(1.2)
Otherwise, if V models bidirectional_range, then iterator_concept denotes bidirectional_iterator_tag.
(1.3)
Otherwise, if V models forward_range, then iterator_concept denotes forward_iterator_tag.
(1.4)
Otherwise, iterator_concept denotes input_iterator_tag.

Let C denote the type iterator_traits<iterator_t<Base>>::iterator_category.

If C models derived_from<contiguous_iterator_tag>, then iterator_category denotes random_access_iterator_tag; otherwise, iterator_category denotes C.

🔗

constexpr iterator(Parent& parent, iterator_t<Base> current);

Effects: Initializes current_ with std::move(current) and parent_ with addressof(parent).

🔗

constexpr iterator(iterator<!Const> i)
  requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;

Effects: Initializes current_ with std::move(i.current_) and parent_ with i.parent_.

🔗

constexpr iterator_t<Base> base() const &
  requires copyable<iterator_t<Base>>;

Effects: Equivalent to: return current_;

🔗

constexpr iterator_t<Base> base() &&;

Effects: Equivalent to: return std::move(current_);

🔗

constexpr iterator& operator++();

Effects: Equivalent to:

++current_;
return *this;

🔗

constexpr void operator++(int);

Effects: Equivalent to ++current_.

🔗

constexpr iterator operator++(int) requires forward_range<Base>;

Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

🔗

constexpr iterator& operator--() requires bidirectional_range<Base>;

Effects: Equivalent to:

--current_;
return *this;

🔗

constexpr iterator operator--(int) requires bidirectional_range<Base>;

Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

🔗

constexpr iterator& operator+=(difference_type n)
  requires random_access_range<Base>;

Effects: Equivalent to:

current_ += n;
return *this;

🔗

constexpr iterator& operator-=(difference_type n)
  requires random_access_range<Base>;

Effects: Equivalent to:

current_ -= n;
return *this;

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires equality_comparable<iterator_t<Base>>;

Effects: Equivalent to: return x.current_ == y.current_;

🔗

friend constexpr bool operator<(const iterator& x, const iterator& y)
  requires random_access_range<Base>;

Effects: Equivalent to: return x.current_ < y.current_;

🔗

friend constexpr bool operator>(const iterator& x, const iterator& y)
  requires random_access_range<Base>;

Effects: Equivalent to: return y < x;

🔗

friend constexpr bool operator<=(const iterator& x, const iterator& y)
  requires random_access_range<Base>;

Effects: Equivalent to: return !(y < x);

🔗

friend constexpr bool operator>=(const iterator& x, const iterator& y)
  requires random_access_range<Base>;

Effects: Equivalent to: return !(x < y);

🔗

friend constexpr compare_three_way_result_t<iterator_t<Base>>
  operator<=>(const iterator& x, const iterator& y)
    requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;

Effects: Equivalent to: return x.current_ <=> y.current_;

🔗

friend constexpr iterator operator+(iterator i, difference_type n)
  requires random_access_range<Base>;
friend constexpr iterator operator+(difference_type n, iterator i)
  requires random_access_range<Base>;

Effects: Equivalent to: return iterator{*i.parent_, i.current_ + n};

🔗

friend constexpr iterator operator-(iterator i, difference_type n)
  requires random_access_range<Base>;

Effects: Equivalent to: return iterator{*i.parent_, i.current_ - n};

🔗

friend constexpr difference_type operator-(const iterator& x, const iterator& y)
  requires random_access_range<Base>;

Effects: Equivalent to: return x.current_ - y.current_;

🔗

friend constexpr void iter_swap(const iterator& x, const iterator& y)
  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
  requires indirectly_swappable<iterator_t<Base>>;

Effects: Equivalent to ranges::iter_swap(x.current_, y.current_).

24.7.5.4 Class template transform_view::sentinel [range.transform.sentinel]

namespace std::ranges {
  template<class V, class F>
  template<bool Const>
  class transform_view<V, F>::sentinel {
  private:
    using Parent =                                      // exposition only
      conditional_t<Const, const transform_view, transform_view>;
    using Base = conditional_t<Const, const V, V>;      // exposition only
    sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
  public:
    sentinel() = default;
    constexpr explicit sentinel(sentinel_t<Base> end);
    constexpr sentinel(sentinel<!Const> i)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;

    constexpr sentinel_t<Base> base() const;

    friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);

    friend constexpr range_difference_t<Base>
      operator-(const iterator<Const>& x, const sentinel& y)
        requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
    friend constexpr range_difference_t<Base>
      operator-(const sentinel& y, const iterator<Const>& x)
        requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
  };
}

🔗

constexpr explicit sentinel(sentinel_t<Base> end);

Effects: Initializes end_ with end.

🔗

constexpr sentinel(sentinel<!Const> i)
  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;

Effects: Initializes end_ with std::move(i.end_).

🔗

constexpr sentinel_t<Base> base() const;

Effects: Equivalent to: return end_;

🔗

friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);

Effects: Equivalent to: return x.current_ == y.end_;

🔗

friend constexpr range_difference_t<Base>
  operator-(const iterator<Const>& x, const sentinel& y)
    requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;

Effects: Equivalent to: return x.current_ - y.end_;

🔗

friend constexpr range_difference_t<Base>
  operator-(const sentinel& y, const iterator<Const>& x)
    requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;

Effects: Equivalent to: return x.end_ - y.current_;

24.7.5.5 views::transform [range.transform.adaptor]

The name views::transform denotes a range adaptor object ([range.adaptor.object]).

For some subexpressions E and F, the expression views::transform(E, F) is expression-equivalent to transform_view{E, F}.

24.7.6 Take view [range.take]

24.7.6.1 Overview [range.take.overview]

take_view produces a view of the first N elements from another view, or all the elements if the adapted view contains fewer than N.

[ Example

vector<int> is{0,1,2,3,4,5,6,7,8,9};
take_view few{is, 5};
for (int i : few)
  cout << i << ' '; // prints: 0 1 2 3 4

— end example

]

24.7.6.2 Class template take_view [range.take.view]

namespace std::ranges {
  template<view V>
  class take_view : public view_interface<take_view<V>> {
  private:
    V base_ = V();                                      // exposition only
    range_difference_t<V> count_ = 0;                   // exposition only
    // [range.take.sentinel], class template take_view::sentinel
    template<bool> struct sentinel;                     // exposition only
  public:
    take_view() = default;
    constexpr take_view(V base, range_difference_t<V> count);
    template<viewable_range R>
      requires constructible_from<V, all_view<R>>
    constexpr take_view(R&& r, range_difference_t<V> count);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr auto begin() requires (!simple-view<V>) {
      if constexpr (sized_range<V>) {
        if constexpr (random_access_range<V>)
          return ranges::begin(base_);
        else
          return counted_iterator{ranges::begin(base_), size()};
      } else
        return counted_iterator{ranges::begin(base_), count_};
    }

    constexpr auto begin() const requires range<const V> {
      if constexpr (sized_range<const V>) {
        if constexpr (random_access_range<const V>)
          return ranges::begin(base_);
        else
          return counted_iterator{ranges::begin(base_), size()};
      } else
        return counted_iterator{ranges::begin(base_), count_};
    }

    constexpr auto end() requires (!simple-view<V>) {
      if constexpr (sized_range<V>) {
        if constexpr (random_access_range<V>)
          return ranges::begin(base_) + size();
        else
          return default_sentinel;
      } else
        return sentinel<false>{ranges::end(base_)};
    }

    constexpr auto end() const requires range<const V> {
      if constexpr (sized_range<const V>) {
        if constexpr (random_access_range<const V>)
          return ranges::begin(base_) + size();
        else
          return default_sentinel;
      } else
        return sentinel<true>{ranges::end(base_)};
    }

    constexpr auto size() requires sized_range<V> {
      auto n = ranges::size(base_);
      return ranges::min(n, static_cast<decltype(n)>(count_));
    }

    constexpr auto size() const requires sized_range<const V> {
      auto n = ranges::size(base_);
      return ranges::min(n, static_cast<decltype(n)>(count_));
    }
  };

  template<range R>
    take_view(R&&, range_difference_t<R>)
      -> take_view<all_view<R>>;
}

🔗

constexpr take_view(V base, range_difference_t<V> count);

Effects: Initializes base_ with std::move(base) and count_ with count.

🔗

template<viewable_range R>
  requires constructible_from<V, all_view<R>>
constexpr take_view(R&& r, range_difference_t<V> count);

Effects: Initializes base_ with views::all(std::forward<R>(r)) and count_ with count.

24.7.6.3 Class template take_view::sentinel [range.take.sentinel]

namespace std::ranges {
  template<class V>
  template<bool Const>
  class take_view<V>::sentinel {
  private:
    using Base = conditional_t<Const, const V, V>;      // exposition only
    using CI = counted_iterator<iterator_t<Base>>;      // exposition only
    sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
  public:
    sentinel() = default;
    constexpr explicit sentinel(sentinel_t<Base> end);
    constexpr sentinel(sentinel<!Const> s)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;

    constexpr sentinel_t<Base> base() const;

    friend constexpr bool operator==(const CI& y, const sentinel& x);
  };
}

🔗

constexpr explicit sentinel(sentinel_t<Base> end);

Effects: Initializes end_ with end.

🔗

constexpr sentinel(sentinel<!Const> s)
  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;

Effects: Initializes end_ with std::move(s.end_).

🔗

constexpr sentinel_t<Base> base() const;

Effects: Equivalent to: return end_;

🔗

friend constexpr bool operator==(const CI& y, const sentinel& x);

Effects: Equivalent to: return y.count() == 0 || y.base() == x.end_;

24.7.6.4 views::take [range.take.adaptor]

The name views::take denotes a range adaptor object ([range.adaptor.object]).

For some subexpressions E and F, the expression views::take(E, F) is expression-equivalent to take_view{E, F}.

24.7.7 Take while view [range.take.while]

24.7.7.1 Overview [range.take.while.overview]

Given a unary predicate pred and a view r, take_while_view produces a view of the range [begin(r), ranges::find_if_not(r, pred)).

[ Example

auto input = istringstream{"0 1 2 3 4 5 6 7 8 9"};
auto small = [](const auto x) noexcept { return x < 5; };
auto small_ints = istream_view<int>(input) | views::take_while(small);
for (const auto i : small_ints) {
  cout << i << ' ';                             // prints 0 1 2 3 4
}
auto i = 0;
input >> i;
cout << i;                                      // prints 6

— end example

]

24.7.7.2 Class template take_while_view [range.take.while.view]

namespace std::ranges {
  template<view V, class Pred>
  requires input_range<V> && is_object_v<Pred> &&
    indirect_unary_predicate<const Pred, iterator_t<V>>
  class take_while_view : public view_interface<take_while_view<V, Pred>> {
    template<bool> class sentinel;                      // exposition only

    V base_;                                            // exposition only
    semiregular-box<Pred> pred_;                        // exposition only

  public:
    take_while_view() = default;
    constexpr take_while_view(V base, Pred pred);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr const Pred& pred() const;

    constexpr auto begin() requires (!simple-view<V>)
    { return ranges::begin(base_); }

    constexpr auto begin() const requires range<const V>
    { return ranges::begin(base_); }

    constexpr auto end() requires (!simple-view<V>)
    { return sentinel<false>(ranges::end(base_), addressof(*pred_)); }

    constexpr auto end() const requires range<const V>
    { return sentinel<true>(ranges::end(base_), addressof(*pred_)); }
  };

  template<class R, class Pred>
    take_while_view(R&&, Pred) -> take_while_view<all_view<R>, Pred>;
}

🔗

constexpr take_while_view(V base, Pred pred);

Effects: Initializes base_ with std::move(base) and pred_ with std::move(pred).

🔗

constexpr const Pred& pred() const;

Effects: Equivalent to: return *pred_;

24.7.7.3 Class template take_while_view::sentinel [range.take.while.sentinel]

namespace std::ranges {
  template<class V>
  template<bool Const>
  class take_while_view<V>::sentinel {                  // exposition only
    using base_t = conditional_t<Const, const V, V>;    // exposition only

    sentinel_t<base_t> end_ = sentinel_t<base_t>();     // exposition only
    const Pred* pred_{};                                // exposition only
  public:
    sentinel() = default;
    constexpr explicit sentinel(sentinel_t<base_t> end, const Pred* pred);
    constexpr sentinel(sentinel<!Const> s)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t<base_t>>;

    constexpr sentinel_t<base_t> base() const { return end_; }

    friend constexpr bool operator==(const iterator_t<base_t>& x, const sentinel& y);
  };
}

🔗

constexpr explicit sentinel(sentinel_t<base_t> end, const Pred* pred);

Effects: Initializes end_ with end and pred_ with pred.

🔗

constexpr sentinel(sentinel<!Const> s)
  requires Const && convertible_to<sentinel_t<V>, sentinel_t<base_t>>;

Effects: Initializes end_ with s.end_ and pred_ with s.pred_.

🔗

friend constexpr bool operator==(const iterator_t<base_t>& x, const sentinel& y);

Effects: Equivalent to: return y.end_ == x || !invoke(*y.pred_, *x);

24.7.7.4 views::take_while [range.take.while.adaptor]

The name views::take_while denotes a range adaptor object ([range.adaptor.object]).

For some subexpressions E and F, the expression views::take_while(E, F) is expression-equivalent to take_while_view{E, F}.

24.7.8 Drop view [range.drop]

24.7.8.1 Overview [range.drop.overview]

drop_view produces a view excluding the first N elements from another view, or an empty range if the adapted view contains fewer than N elements.

[ Example

auto ints = views::iota(0) | views::take(10);
auto latter_half = drop_view{ints, 5};
for (auto i : latter_half) {
  cout << i << ' ';                             // prints 5 6 7 8 9
}

— end example

]

24.7.8.2 Class template drop_view [range.drop.view]

namespace std::ranges {
  template<view V>
  class drop_view : public view_interface<drop_view<V>> {
  public:
    drop_view() = default;
    constexpr drop_view(V base, range_difference_t<V> count);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr auto begin()
      requires (!(simple-view<V> && random_access_range<V>));
    constexpr auto begin() const
      requires random_access_range<const V>;

    constexpr auto end()
      requires (!simple-view<V>)
    { return ranges::end(base_); }

    constexpr auto end() const
      requires range<const V>
    { return ranges::end(base_); }

    constexpr auto size()
      requires sized_range<V>
    {
      const auto s = ranges::size(base_);
      const auto c = static_cast<decltype(s)>(count_);
      return s < c ? 0 : s - c;
    }

    constexpr auto size() const
      requires sized_range<const V>
    {
      const auto s = ranges::size(base_);
      const auto c = static_cast<decltype(s)>(count_);
      return s < c ? 0 : s - c;
    }
  private:
    V base_;                                    // exposition only
    range_difference_t<V> count_;               // exposition only
  };

  template<class R>
    drop_view(R&&, range_difference_t<R>) -> drop_view<all_view<R>>;
}

🔗

constexpr drop_view(V base, range_difference_t<V> count);

Preconditions: count >= 0 is true.

Effects: Initializes base_ with std::move(base) and count_ with count.

🔗

constexpr auto begin()
  requires (!(simple-view<V> && random_access_range<V>));
constexpr auto begin() const
  requires random_access_range<const V>;

Returns: ranges::next(ranges::begin(base_), count_, ranges::end(base_)).

Remarks: In order to provide the amortized constant-time complexity required by the range concept when drop_view models forward_range, the first overload caches the result within the drop_view for use on subsequent calls.

[ Note

Without this, applying a reverse_view over a drop_view would have quadratic iteration complexity.

— end note

]

24.7.8.3 views::drop [range.drop.adaptor]

The name views::drop denotes a range adaptor object ([range.adaptor.object]).

For some subexpressions E and F, the expression views::drop(E, F) is expression-equivalent to drop_view{E, F}.

24.7.9 Drop while view [range.drop.while]

24.7.9.1 Overview [range.drop.while.overview]

Given a unary predicate pred and a view r, drop_while_view produces a view of the range [ranges::find_if_not(r, pred), ranges::end(r)).

[ Example

constexpr auto source = "  \t   \t   \t   hello there";
auto is_invisible = [](const auto x) { return x == ' ' || x == '\t'; };
auto skip_ws = drop_while_view{source, is_invisible};
for (auto c : skip_ws) {
  cout << c;                                    // prints hello there with no leading space
}

— end example

]

24.7.9.2 Class template drop_while_view [range.drop.while.view]

namespace std::ranges {
  template<view V, class Pred>
  requires input_range<V> && is_object_v<Pred> &&
    indirect_unary_predicate<const Pred, iterator_t<V>>
  class drop_while_view : public view_interface<drop_while_view<V, Pred>> {
  public:
    drop_while_view() = default;
    constexpr drop_while_view(V base, Pred pred);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr const Pred& pred() const;

    constexpr auto begin();

    constexpr auto end()
    { return ranges::end(base_); }

  private:
    V base_;                                            // exposition only
    semiregular-box<Pred> pred_;                        // exposition only
  };

  template<class R, class Pred>
    drop_while_view(R&&, Pred) -> drop_while_view<all_view<R>, Pred>;
}

🔗

constexpr drop_while_view(V base, Pred pred);

Effects: Initializes base_ with std::move(base) and pred_ with std::move(pred).

🔗

constexpr const Pred& pred() const;

Effects: Equivalent to: return *pred_;

🔗

constexpr auto begin();

Returns: ranges::find_if_not(base_, cref(*pred_)).

Remarks: In order to provide the amortized constant-time complexity required by the range concept when drop_while_view models forward_range, the first call caches the result within the drop_while_view for use on subsequent calls.

[ Note

Without this, applying a reverse_view over a drop_while_view would have quadratic iteration complexity.

— end note

]

24.7.9.3 views::drop_while [range.drop.while.adaptor]

The name views::drop_while denotes a range adaptor object ([range.adaptor.object]).

For some subexpressions E and F, the expression views::drop_while(E, F) is expression-equivalent to drop_while_view{E, F}.

24.7.10 Join view [range.join]

24.7.10.1 Overview [range.join.overview]

join_view flattens a view of ranges into a view.

[ Example

vector<string> ss{"hello", " ", "world", "!"};
join_view greeting{ss};
for (char ch : greeting)
  cout << ch;                                   // prints: hello world!

— end example

]

24.7.10.2 Class template join_view [range.join.view]

namespace std::ranges {
  template<input_range V>
    requires view<V> && input_range<range_reference_t<V>> &&
             (is_reference_v<range_reference_t<V>> ||
              view<range_value_t<V>>)
  class join_view : public view_interface<join_view<V>> {
  private:
    using InnerRng =                    // exposition only
      range_reference_t<V>;
    // [range.join.iterator], class template join_view::iterator
    template<bool Const>
      struct iterator;                  // exposition only
    // [range.join.sentinel], class template join_view::sentinel
    template<bool Const>
      struct sentinel;                  // exposition only

    V base_ = V();                      // exposition only
    all_view<InnerRng> inner_ =         // exposition only, present only when !is_reference_v<InnerRng>
      all_view<InnerRng>();
  public:
    join_view() = default;
    constexpr explicit join_view(V base);

    template<input_range R>
      requires viewable_range<R> && constructible_from<V, all_view<R>>
    constexpr explicit join_view(R&& r);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr auto begin() {
      return iterator<simple-view<V>>{*this, ranges::begin(base_)};
    }

    constexpr auto begin() const
    requires input_range<const V> &&
             is_reference_v<range_reference_t<const V>> {
      return iterator<true>{*this, ranges::begin(base_)};
    }

    constexpr auto end() {
      if constexpr (forward_range<V> &&
                    is_reference_v<InnerRng> && forward_range<InnerRng> &&
                    common_range<V> && common_range<InnerRng>)
        return iterator<simple-view<V>>{*this, ranges::end(base_)};
      else
        return sentinel<simple-view<V>>{*this};
    }

    constexpr auto end() const
    requires input_range<const V> &&
             is_reference_v<range_reference_t<const V>> {
      if constexpr (forward_range<const V> &&
                    is_reference_v<range_reference_t<const V>> &&
                    forward_range<range_reference_t<const V>> &&
                    common_range<const V> &&
                    common_range<range_reference_t<const V>>)
        return iterator<true>{*this, ranges::end(base_)};
      else
        return sentinel<true>{*this};
    }
  };

  template<class R>
    explicit join_view(R&&) -> join_view<all_view<R>>;
}

🔗

constexpr explicit join_view(V base);

Effects: Initializes base_ with std::move(base).

🔗

template<input_range R>
  requires viewable_range<R> && constructible_from<V, all_view<R>>
constexpr explicit join_view(R&& r);

Effects: Initializes base_ with views::all(std::forward<R>(r)).

24.7.10.3 Class template join_view::iterator [range.join.iterator]

namespace std::ranges {
template<class V>
  template<bool Const>
  struct join_view<V>::iterator {
  private:
    using Parent =                                              // exposition only
      conditional_t<Const, const join_view, join_view>;
    using Base   = conditional_t<Const, const V, V>;            // exposition only

    static constexpr bool ref_is_glvalue =                      // exposition only
      is_reference_v<range_reference_t<Base>>;

    iterator_t<Base> outer_ = iterator_t<Base>();               // exposition only
    iterator_t<range_reference_t<Base>> inner_ =                // exposition only
      iterator_t<range_reference_t<Base>>();
    Parent* parent_ = nullptr;                                  // exposition only

    constexpr void satisfy();                                   // exposition only
  public:
    using iterator_concept  = see below;
    using iterator_category = see below;
    using value_type        = range_value_t<range_reference_t<Base>>;
    using difference_type   = see below;

    iterator() = default;
    constexpr iterator(Parent& parent, iterator_t<V> outer);
    constexpr iterator(iterator<!Const> i)
      requires Const &&
               convertible_to<iterator_t<V>, iterator_t<Base>> &&
               convertible_to<iterator_t<InnerRng>,
                              iterator_t<range_reference_t<Base>>>;

    constexpr decltype(auto) operator*() const { return *inner_; }

    constexpr iterator_t<Base> operator->() const
      requires has-arrow<iterator_t<Base>> && copyable<iterator_t<Base>>;

    constexpr iterator& operator++();
    constexpr void operator++(int);
    constexpr iterator operator++(int)
      requires ref_is_glvalue && forward_range<Base> &&
               forward_range<range_reference_t<Base>>;

    constexpr iterator& operator--()
      requires ref_is_glvalue && bidirectional_range<Base> &&
               bidirectional_range<range_reference_t<Base>>;

    constexpr iterator operator--(int)
      requires ref_is_glvalue && bidirectional_range<Base> &&
               bidirectional_range<range_reference_t<Base>>;

    friend constexpr bool operator==(const iterator& x, const iterator& y)
      requires ref_is_glvalue && equality_comparable<iterator_t<Base>> &&
               equality_comparable<iterator_t<range_reference_t<Base>>>;

    friend constexpr decltype(auto) iter_move(const iterator& i)
    noexcept(noexcept(ranges::iter_move(i.inner_))) {
      return ranges::iter_move(i.inner_);
    }

    friend constexpr void iter_swap(const iterator& x, const iterator& y)
      noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));
  };
}

iterator::iterator_concept is defined as follows:

(1.1)
If ref_is_glvalue is true and Base and range_reference_t<Base> each model bidirectional_range, then iterator_concept denotes bidirectional_iterator_tag.
(1.2)
Otherwise, if ref_is_glvalue is true and Base and range_reference_t<Base> each model forward_range, then iterator_concept denotes forward_iterator_tag.
(1.3)
Otherwise, iterator_concept denotes input_iterator_tag.

iterator::iterator_category is defined as follows:

(2.1)
Let OUTERC denote iterator_traits<iterator_t<Base>>::iterator_category, and let INNERC denote iterator_traits<iterator_t<range_reference_t<Base>>>::iterator_category.
(2.2)
If ref_is_glvalue is true and OUTERC and INNERC each model derived_from<bidirectional_iterator_tag>, iterator_category denotes bidirectional_iterator_tag.
(2.3)
Otherwise, if ref_is_glvalue is true and OUTERC and INNERC each model derived_from<forward_iterator_tag>, iterator_category denotes forward_iterator_tag.
(2.4)
Otherwise, if OUTERC and INNERC each model derived_from<input_iterator_tag>, iterator_category denotes input_iterator_tag.
(2.5)
Otherwise, iterator_category denotes output_iterator_tag.

iterator::difference_type denotes the type:

common_type_t<
  range_difference_t<Base>,
  range_difference_t<range_reference_t<Base>>>

join_view iterators use the satisfy function to skip over empty inner ranges.

🔗

constexpr void satisfy();       // exposition only

Effects: Equivalent to:

auto update_inner = [this](range_reference_t<Base> x) -> auto& {
  if constexpr (ref_is_glvalue) // x is a reference
    return x;
  else
    return (parent_->inner_ = views::all(std::move(x)));
};

for (; outer_ != ranges::end(parent_->base_); ++outer_) {
  auto& inner = update_inner(*outer_);
  inner_ = ranges::begin(inner);
  if (inner_ != ranges::end(inner))
    return;
}
if constexpr (ref_is_glvalue)
  inner_ = iterator_t<range_reference_t<Base>>();

🔗

constexpr iterator(Parent& parent, iterator_t<V> outer)

Effects: Initializes outer_ with std::move(outer) and parent_ with addressof(parent); then calls satisfy().

🔗

constexpr iterator(iterator<!Const> i)
  requires Const &&
           convertible_to<iterator_t<V>, iterator_t<Base>> &&
           convertible_to<iterator_t<InnerRng>,
                          iterator_t<range_reference_t<Base>>>;

Effects: Initializes outer_ with std::move(i.outer_), inner_ with std::move(i.inner_), and parent_ with i.parent_.

🔗

constexpr iterator_t<Base> operator->() const
  requires has-arrow<iterator_t<Base>> && copyable<iterator_t<Base>>;

Effects: Equivalent to return inner_;

🔗

constexpr iterator& operator++();

Let inner-range be:

(9.1)
If ref_is_glvalue is true, *outer_.
(9.2)
Otherwise, parent_->inner_.

Effects: Equivalent to:

auto&& inner_rng = inner-range;
if (++inner_ == ranges::end(inner_rng)) {
  ++outer_;
  satisfy();
}
return *this;

🔗

constexpr void operator++(int);

Effects: Equivalent to: ++*this.

🔗

constexpr iterator operator++(int)
  requires ref_is_glvalue && forward_range<Base> &&
           forward_range<range_reference_t<Base>>;

Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

🔗

constexpr iterator& operator--()
  requires ref_is_glvalue && bidirectional_range<Base> &&
           bidirectional_range<range_reference_t<Base>>;

Effects: Equivalent to:

if (outer_ == ranges::end(parent_->base_))
  inner_ = ranges::end(*--outer_);
while (inner_ == ranges::begin(*outer_))
  inner_ = ranges::end(*--outer_);
--inner_;
return *this;

🔗

constexpr iterator operator--(int)
  requires ref_is_glvalue && bidirectional_range<Base> &&
           bidirectional_range<range_reference_t<Base>>;

Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires ref_is_glvalue && equality_comparable<iterator_t<Base>> &&
           equality_comparable<iterator_t<range_reference_t<Base>>>;

Effects: Equivalent to: return x.outer_ == y.outer_ && x.inner_ == y.inner_;

🔗

friend constexpr void iter_swap(const iterator& x, const iterator& y)
  noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));

Effects: Equivalent to: return ranges::iter_swap(x.inner_, y.inner_);

24.7.10.4 Class template join_view::sentinel [range.join.sentinel]

namespace std::ranges {
  template<class V>
  template<bool Const>
  struct join_view<V>::sentinel {
  private:
    using Parent =                                      // exposition only
      conditional_t<Const, const join_view, join_view>;
    using Base   = conditional_t<Const, const V, V>;    // exposition only
    sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
  public:
    sentinel() = default;

    constexpr explicit sentinel(Parent& parent);
    constexpr sentinel(sentinel<!Const> s)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;

    friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
  };
}

🔗

constexpr explicit sentinel(Parent& parent);

Effects: Initializes end_ with ranges::end(parent.base_).

🔗

constexpr sentinel(sentinel<!Const> s)
  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;

Effects: Initializes end_ with std::move(s.end_).

🔗

friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);

Effects: Equivalent to: return x.outer_ == y.end_;

24.7.10.5 views::join [range.join.adaptor]

The name views::join denotes a range adaptor object ([range.adaptor.object]).

For some subexpression E, the expression views::join(E) is expression-equivalent to join_view{E}.

24.7.11 Split view [range.split]

24.7.11.1 Overview [range.split.overview]

split_view takes a view and a delimiter, and splits the view into subranges on the delimiter.

The delimiter can be a single element or a view of elements.

[ Example

string str{"the quick brown fox"};
split_view sentence{str, ' '};
for (auto word : sentence) {
  for (char ch : word)
    cout << ch;
  cout << '*';
}
// The above prints: the*quick*brown*fox*

— end example

]

24.7.11.2 Class template split_view [range.split.view]

namespace std::ranges {
  template<auto> struct require-constant;       // exposition only

  template<class R>
  concept tiny-range =                          // exposition only
    sized_range<R> &&
    requires { typename require-constant<remove_reference_t<R>::size()>; } &&
    (remove_reference_t<R>::size() <= 1);

  template<input_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
             (forward_range<V> || tiny-range<Pattern>)
  class split_view : public view_interface<split_view<V, Pattern>> {
  private:
    V base_ = V();                              // exposition only
    Pattern pattern_ = Pattern();               // exposition only
    iterator_t<V> current_ = iterator_t<V>();   // exposition only, present only if !forward_range<V>
    // [range.split.outer], class template split_view::outer_iterator
    template<bool> struct outer_iterator;       // exposition only
    // [range.split.inner], class template split_view::inner_iterator
    template<bool> struct inner_iterator;       // exposition only
  public:
    split_view() = default;
    constexpr split_view(V base, Pattern pattern);

    template<input_range R, forward_range P>
      requires constructible_from<V, all_view<R>> &&
               constructible_from<Pattern, all_view<P>>
    constexpr split_view(R&& r, P&& p);

    template<input_range R>
      requires constructible_from<V, all_view<R>> &&
               constructible_from<Pattern, single_view<range_value_t<R>>>
    constexpr split_view(R&& r, range_value_t<R> e);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr auto begin() {
      if constexpr (forward_range<V>)
        return outer_iterator<simple-view<V>>{*this, ranges::begin(base_)};
      else {
        current_ = ranges::begin(base_);
        return outer_iterator<false>{*this};
      }
    }

    constexpr auto begin() const requires forward_range<V> && forward_range<const V> {
      return outer_iterator<true>{*this, ranges::begin(base_)};
    }

    constexpr auto end() requires forward_range<V> && common_range<V> {
      return outer_iterator<simple-view<V>>{*this, ranges::end(base_)};
    }

    constexpr auto end() const {
      if constexpr (forward_range<V> && forward_range<const V> && common_range<const V>)
        return outer_iterator<true>{*this, ranges::end(base_)};
      else
        return default_sentinel;
    }
  };

  template<class R, class P>
    split_view(R&&, P&&) -> split_view<all_view<R>, all_view<P>>;

  template<input_range R>
    split_view(R&&, range_value_t<R>)
      -> split_view<all_view<R>, single_view<range_value_t<R>>>;
}

🔗

constexpr split_view(V base, Pattern pattern);

Effects: Initializes base_ with std::move(base), and pattern_ with std::move(pattern).

🔗

template<input_range R, forward_range P>
  requires constructible_from<V, all_view<R>> &&
           constructible_from<Pattern, all_view<P>>
constexpr split_view(R&& r, P&& p);

Effects: Initializes base_ with views::all(std::forward<R>(r)), and pattern_ with views::all(std::forward<P>(p)).

🔗

template<input_range R>
  requires constructible_from<V, all_view<R>> &&
           constructible_from<Pattern, single_view<range_value_t<R>>>
constexpr split_view(R&& r, range_value_t<R> e);

Effects: Initializes base_ with views::all(std::forward<R>(r)), and pattern_ with single_view{std::move(e)}.

24.7.11.3 Class template split_view::outer_iterator [range.split.outer]

namespace std::ranges {
  template<class V, class Pattern>
  template<bool Const>
  struct split_view<V, Pattern>::outer_iterator {
  private:
    using Parent =                              // exposition only
      conditional_t<Const, const split_view, split_view>;
    using Base   =                              // exposition only
      conditional_t<Const, const V, V>;
    Parent* parent_ = nullptr;                  // exposition only
    iterator_t<Base> current_ =                 // exposition only, present only if V models forward_range
      iterator_t<Base>();

  public:
    using iterator_concept  =
      conditional_t<forward_range<Base>, forward_iterator_tag, input_iterator_tag>;
    using iterator_category = input_iterator_tag;
    // [range.split.outer.value], class split_view::outer_iterator::value_type
    struct value_type;
    using difference_type   = range_difference_t<Base>;

    outer_iterator() = default;
    constexpr explicit outer_iterator(Parent& parent)
      requires (!forward_range<Base>);
    constexpr outer_iterator(Parent& parent, iterator_t<Base> current)
      requires forward_range<Base>;
    constexpr outer_iterator(outer_iterator<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t<const V>>;

    constexpr value_type operator*() const;

    constexpr outer_iterator& operator++();
    constexpr decltype(auto) operator++(int) {
      if constexpr (forward_range<Base>) {
        auto tmp = *this;
        ++*this;
        return tmp;
      } else
        ++*this;
    }

    friend constexpr bool operator==(const outer_iterator& x, const outer_iterator& y)
      requires forward_range<Base>;

    friend constexpr bool operator==(const outer_iterator& x, default_sentinel_t);
  };
}

Many of the following specifications refer to the notional member current of outer_iterator.

current is equivalent to current_ if V models forward_range, and parent_->current_ otherwise.

🔗

constexpr explicit outer_iterator(Parent& parent)
  requires (!forward_range<Base>);

Effects: Initializes parent_ with addressof(parent).

🔗

constexpr outer_iterator(Parent& parent, iterator_t<Base> current)
  requires forward_range<Base>;

Effects: Initializes parent_ with addressof(parent) and current_ with std::move(current).

🔗

constexpr outer_iterator(outer_iterator<!Const> i)
  requires Const && convertible_to<iterator_t<V>, iterator_t<const V>>;

Effects: Initializes parent_ with i.parent_ and current_ with std::move(i.current_).

🔗

constexpr value_type operator*() const;

Effects: Equivalent to: return value_type{*this};

🔗

constexpr outer_iterator& operator++();

Effects: Equivalent to:

const auto end = ranges::end(parent_->base_);
if (current == end) return *this;
const auto [pbegin, pend] = subrange{parent_->pattern_};
if (pbegin == pend) ++current;
else {
  do {
    auto [b, p] = ranges::mismatch(std::move(current), end, pbegin, pend);
    current = std::move(b);
    if (p == pend) {
      break;            // The pattern matched; skip it
    }
  } while (++current != end);
}
return *this;

🔗

friend constexpr bool operator==(const outer_iterator& x, const outer_iterator& y)
  requires forward_range<Base>;

Effects: Equivalent to: return x.current_ == y.current_;

🔗

friend constexpr bool operator==(const outer_iterator& x, default_sentinel_t);

Effects: Equivalent to: return x.current == ranges::end(x.parent_->base_);

24.7.11.4 Class split_view::outer_iterator::value_type [range.split.outer.value]

namespace std::ranges {
  template<class V, class Pattern>
  template<bool Const>
  struct split_view<V, Pattern>::outer_iterator<Const>::value_type
    : view_interface<value_type> {
  private:
    outer_iterator i_ = outer_iterator();               // exposition only
  public:
    value_type() = default;
    constexpr explicit value_type(outer_iterator i);

    constexpr inner_iterator<Const> begin() const requires copyable<outer_iterator>;
    constexpr inner_iterator<Const> begin() requires (!copyable<outer_iterator>);
    constexpr default_sentinel_t end() const;
  };
}

🔗

constexpr explicit value_type(outer_iterator i);

Effects: Initializes i_ with std::move(i).

🔗

constexpr inner_iterator<Const> begin() const requires copyable<outer_iterator>;

Effects: Equivalent to: return inner_iterator<Const>{i_};

🔗

constexpr inner_iterator<Const> begin() requires (!copyable<outer_iterator>);

Effects: Equivalent to: return inner_iterator<Const>{std::move(i_)};

🔗

constexpr default_sentinel_t end() const;

Effects: Equivalent to: return default_sentinel;

24.7.11.5 Class template split_view::inner_iterator [range.split.inner]

namespace std::ranges {
  template<class V, class Pattern>
  template<bool Const>
  struct split_view<V, Pattern>::inner_iterator {
  private:
    using Base =
      conditional_t<Const, const V, V>;                 // exposition only
    outer_iterator<Const> i_ = outer_iterator<Const>(); // exposition only
    bool incremented_ = false;                          // exposition only
  public:
    using iterator_concept  = typename outer_iterator<Const>::iterator_concept;
    using iterator_category = see below;
    using value_type        = range_value_t<Base>;
    using difference_type   = range_difference_t<Base>;

    inner_iterator() = default;
    constexpr explicit inner_iterator(outer_iterator<Const> i);

    constexpr decltype(auto) operator*() const { return *i_.current; }

    constexpr inner_iterator& operator++();
    constexpr decltype(auto) operator++(int) {
      if constexpr (forward_range<V>) {
        auto tmp = *this;
        ++*this;
        return tmp;
      } else
        ++*this;
    }

    friend constexpr bool operator==(const inner_iterator& x, const inner_iterator& y)
      requires forward_range<Base>;

    friend constexpr bool operator==(const inner_iterator& x, default_sentinel_t);

    friend constexpr decltype(auto) iter_move(const inner_iterator& i)
    noexcept(noexcept(ranges::iter_move(i.i_.current))) {
      return ranges::iter_move(i.i_.current);
    }

    friend constexpr void iter_swap(const inner_iterator& x, const inner_iterator& y)
      noexcept(noexcept(ranges::iter_swap(x.i_.current, y.i_.current)))
      requires indirectly_swappable<iterator_t<Base>>;
  };
}

The typedef-name iterator_category denotes:

(1.1)
forward_iterator_tag if iterator_traits<iterator_t<Base>>::iterator_category models
derived_from<forward_iterator_tag>;
(1.2)
otherwise, iterator_traits<iterator_t<Base>>::iterator_category.

🔗

constexpr explicit inner_iterator(outer_iterator<Const> i);

Effects: Initializes i_ with std::move(i).

🔗

constexpr inner_iterator& operator++() const;

Effects: Equivalent to:

incremented_ = true;
if constexpr (!forward_range<Base>) {
  if constexpr (Pattern::size() == 0) {
    return *this;
  }
}
++i_.current;
return *this;

🔗

friend constexpr bool operator==(const inner_iterator& x, const inner_iterator& y)
  requires forward_range<Base>;

Effects: Equivalent to: return x.i_.current_ == y.i_.current_;

🔗

friend constexpr bool operator==(const inner_iterator& x, default_sentinel_t);

Effects: Equivalent to:

auto [pcur, pend] = subrange{x.i_.parent_->pattern_};
auto end = ranges::end(x.i_.parent_->base_);
if constexpr (tiny-range<Pattern>) {
  const auto & cur = x.i_.current;
  if (cur == end) return true;
  if (pcur == pend) return x.incremented_;
  return *cur == *pcur;
} else {
  auto cur = x.i_.current;
  if (cur == end) return true;
  if (pcur == pend) return x.incremented_;
  do {
    if (*cur != *pcur) return false;
    if (++pcur == pend) return true;
  } while (++cur != end);
  return false;
}

🔗

friend constexpr void iter_swap(const inner_iterator& x, const inner_iterator& y)
  noexcept(noexcept(ranges::iter_swap(x.i_.current, y.i_.current)))
  requires indirectly_swappable<iterator_t<Base>>;

Effects: Equivalent to ranges::iter_swap(x.i_.current, y.i_.current).

24.7.11.6 views::split [range.split.adaptor]

The name views::split denotes a range adaptor object ([range.adaptor.object]).

For some subexpressions E and F, the expression views::split(E, F) is expression-equivalent to split_view{E, F}.

24.7.12 Counted view [range.counted]

A counted view presents a view of the elements of the counted range ([iterator.requirements.general]) [i, n) for some iterator i and non-negative integer n.

The name views::counted denotes a customization point object ([customization.point.object]).

Let E and F be expressions, and let T be decay_t<decltype((E))>.

Then the expression views::counted(E, F) is expression-equivalent to:

(2.1)
If T models input_or_output_iterator and decltype((F)) models convertible_to<iter_difference_t<T>>,
- (2.1.1)
  subrange{E, E + static_cast<iter_difference_t<T>>(F)} if T models random_access_iterator.
- (2.1.2)
  Otherwise, subrange{counted_iterator{E, F}, default_sentinel}.
(2.2)
Otherwise, views::counted(E, F) is ill-formed.
[ Note
: This case can result in substitution failure when views::counted(E, F) appears in the immediate context of a template instantiation. — end note
]

24.7.13 Common view [range.common]

24.7.13.1 Overview [range.common.overview]

common_view takes a view which has different types for its iterator and sentinel and turns it into a view of the same elements with an iterator and sentinel of the same type.

[ Note

common_view is useful for calling legacy algorithms that expect a range's iterator and sentinel types to be the same.

— end note

]

[ Example

// Legacy algorithm:
template<class ForwardIterator>
size_t count(ForwardIterator first, ForwardIterator last);

template<forward_range R>
void my_algo(R&& r) {
  auto&& common = common_view{r};
  auto cnt = count(common.begin(), common.end());
  // ...
}

— end example

]

24.7.13.2 Class template common_view [range.common.view]

namespace std::ranges {
  template<view V>
    requires (!common_range<V> && copyable<iterator_t<V>>)
  class common_view : public view_interface<common_view<V>> {
  private:
    V base_ = V();  // exposition only
  public:
    common_view() = default;

    constexpr explicit common_view(V r);

    template<viewable_range R>
      requires (!common_range<R> && constructible_from<V, all_view<R>>)
    constexpr explicit common_view(R&& r);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr auto size() requires sized_range<V> {
      return ranges::size(base_);
    }
    constexpr auto size() const requires sized_range<const V> {
      return ranges::size(base_);
    }

    constexpr auto begin() {
      if constexpr (random_access_range<V> && sized_range<V>)
        return ranges::begin(base_);
      else
        return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::begin(base_));
    }

    constexpr auto begin() const requires range<const V> {
      if constexpr (random_access_range<const V> && sized_range<const V>)
        return ranges::begin(base_);
      else
        return common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::begin(base_));
    }

    constexpr auto end() {
      if constexpr (random_access_range<V> && sized_range<V>)
        return ranges::begin(base_) + ranges::size(base_);
      else
        return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::end(base_));
    }

    constexpr auto end() const requires range<const V> {
      if constexpr (random_access_range<const V> && sized_range<const V>)
        return ranges::begin(base_) + ranges::size(base_);
      else
        return common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::end(base_));
    }
  };

  template<class R>
    common_view(R&&) -> common_view<all_view<R>>;
}

🔗

constexpr explicit common_view(V base);

Effects: Initializes base_ with std::move(base).

🔗

template<viewable_range R>
  requires (!common_range<R> && constructible_from<V, all_view<R>>)
constexpr explicit common_view(R&& r);

Effects: Initializes base_ with views::all(std::forward<R>(r)).

24.7.13.3 views::common [range.common.adaptor]

The name views::common denotes a range adaptor object ([range.adaptor.object]).

For some subexpression E, the expression views::common(E) is expression-equivalent to:

(1.1)
views::all(E), if decltype((E)) models common_range and views::all(E) is a well-formed expression.
(1.2)
Otherwise, common_view{E}.

24.7.14 Reverse view [range.reverse]

24.7.14.1 Overview [range.reverse.overview]

reverse_view takes a bidirectional view and produces another view that iterates the same elements in reverse order.

[ Example

vector<int> is {0,1,2,3,4};
reverse_view rv {is};
for (int i : rv)
  cout << i << ' '; // prints: 4 3 2 1 0

— end example

]

24.7.14.2 Class template reverse_view [range.reverse.view]

namespace std::ranges {
  template<view V>
    requires bidirectional_range<V>
  class reverse_view : public view_interface<reverse_view<V>> {
  private:
    V base_ = V();  // exposition only
  public:
    reverse_view() = default;

    constexpr explicit reverse_view(V r);

    template<viewable_range R>
      requires bidirectional_range<R> && constructible_from<V, all_view<R>>
    constexpr explicit reverse_view(R&& r);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr reverse_iterator<iterator_t<V>> begin();
    constexpr reverse_iterator<iterator_t<V>> begin() requires common_range<V>;
    constexpr reverse_iterator<iterator_t<const V>> begin() const
      requires common_range<const V>;

    constexpr reverse_iterator<iterator_t<V>> end();
    constexpr reverse_iterator<iterator_t<const V>> end() const
      requires common_range<const V>;

    constexpr auto size() requires sized_range<V> {
      return ranges::size(base_);
    }
    constexpr auto size() const requires sized_range<const V> {
      return ranges::size(base_);
    }
  };

  template<class R>
    reverse_view(R&&) -> reverse_view<all_view<R>>;
}

🔗

constexpr explicit reverse_view(V base);

Effects: Initializes base_ with std::move(base).

🔗

template<viewable_range R>
  requires bidirectional_range<R> && constructible_from<V, all_view<R>>
constexpr explicit reverse_view(R&& r);

Effects: Initializes base_ with views::all(std::forward<R>(r)).

🔗

constexpr reverse_iterator<iterator_t<V>> begin();

Returns:

make_reverse_iterator(ranges::next(ranges::begin(base_), ranges::end(base_)))

Remarks: In order to provide the amortized constant time complexity required by the range concept, this function caches the result within the reverse_view for use on subsequent calls.

🔗

constexpr reverse_iterator<iterator_t<V>> begin() requires common_range<V>;
constexpr reverse_iterator<iterator_t<const V>> begin() const
  requires common_range<const V>;

Effects: Equivalent to: return make_reverse_iterator(ranges::end(base_));

🔗

constexpr reverse_iterator<iterator_t<V>> end();
constexpr reverse_iterator<iterator_t<const V>> end() const
  requires common_range<const V>;

Effects: Equivalent to: return make_reverse_iterator(ranges::begin(base_));

24.7.14.3 views::reverse [range.reverse.adaptor]

The name views::reverse denotes a range adaptor object ([range.adaptor.object]).

For some subexpression E, the expression views::reverse(E) is expression-equivalent to:

(1.1)
If the type of E is a (possibly cv-qualified) specialization of reverse_view, equivalent to E.base().
(1.2)
Otherwise, if the type of E is cv-qualified
```
subrange<reverse_iterator<I>, reverse_iterator<I>, K>
```
for some iterator type I and value K of type subrange_kind,
- (1.2.1)
  if K is subrange_kind::sized, equivalent to:
```
subrange<I, I, K>(E.end().base(), E.begin().base(), E.size())
```
- (1.2.2)
  otherwise, equivalent to:
```
subrange<I, I, K>(E.end().base(), E.begin().base())
```
However, in either case E is evaluated only once.
(1.3)
Otherwise, equivalent to reverse_view{E}.

24.7.15 Elements view [range.elements]

24.7.15.1 Overview [range.elements.overview]

elements_view takes a view of tuple-like values and a size_t, and produces a view with a value-type of the

N^{th}

element of the adapted view's value-type.

The name views::elements<N> denotes a range adaptor object ([range.adaptor.object]).

For some subexpression E and constant expression N, the expression views::elements<N>(E) is expression-equivalent to elements_view<all_view<decltype((E))>, N>{E}.

[ Example

auto historical_figures = map{
  {"Lovelace"sv, 1815},
  {"Turing"sv, 1912},
  {"Babbage"sv, 1791},
  {"Hamilton"sv, 1936}
};

auto names = historical_figures | views::elements<0>;
for (auto&& name : names) {
  cout << name << ' ';          // prints Babbage Hamilton Lovelace Turing 
}

auto birth_years = historical_figures | views::elements<1>;
for (auto&& born : birth_years) {
  cout << born << ' ';          // prints 1791 1936 1815 1912 
}

— end example

]

keys_view is an alias for elements_view<all_view<R>, 0>, and is useful for extracting keys from associative containers.

[ Example

auto names = keys_view{historical_figures};
for (auto&& name : names) {
  cout << name << ' ';          // prints Babbage Hamilton Lovelace Turing 
}

— end example

]

values_view is an alias for elements_view<all_view<R>, 1>, and is useful for extracting values from associative containers.

[ Example

auto is_even = [](const auto x) { return x % 2 == 0; };
cout << ranges::count_if(values_view{historical_figures}, is_even);     // prints 2

— end example

]

24.7.15.2 Class template elements_view [range.elements.view]

namespace std::ranges {
  template<class T, size_t N>
  concept has-tuple-element =                   // exposition only
    requires(T t) {
      typename tuple_size<T>::type;
      requires N < tuple_size_v<T>;
      typename tuple_element_t<N, T>;
      { get<N>(t) } -> const tuple_element_t<N, T>&;
    };


  template<input_range V, size_t N>
    requires view<V> && has-tuple-element<range_value_t<V>, N> &&
      has-tuple-element<remove_reference_t<range_reference_t<V>>, N>
  class elements_view : public view_interface<elements_view<V, N>> {
  public:
    elements_view() = default;
    constexpr explicit elements_view(V base);

    constexpr V base() const& requires copy_constructible<V> { return base_; }
    constexpr V base() && { return std::move(base_); }

    constexpr auto begin() requires (!simple-view<V>)
    { return iterator<false>(ranges::begin(base_)); }

    constexpr auto begin() const requires simple-view<V>
    { return iterator<true>(ranges::begin(base_)); }

    constexpr auto end() requires (!simple-view<V>)
    { return ranges::end(base_); }

    constexpr auto end() const requires simple-view<V>
    { return ranges::end(base_); }

    constexpr auto size() requires sized_range<V>
    { return ranges::size(base_); }

    constexpr auto size() const requires sized_range<const V>
    { return ranges::size(base_); }

  private:
    template<bool> struct iterator;                     // exposition only
    V base_ = V();                                      // exposition only
  };
}

🔗

constexpr explicit elements_view(V base);

Effects: Initializes base_ with std::move(base).

24.7.15.3 Class template elements_view::iterator [range.elements.iterator]

namespace std::ranges {
  template<class V, size_t N>
  template<bool Const>
  class elements_view<V, N>::iterator {                 // exposition only
    using base_t = conditional_t<Const, const V, V>;
    friend iterator<!Const>;

    iterator_t<base_t> current_;
  public:
    using iterator_category = typename iterator_traits<iterator_t<base_t>>::iterator_category;
    using value_type = remove_cvref_t<tuple_element_t<N, range_value_t<base_t>>>;
    using difference_type = range_difference_t<base_t>;

    iterator() = default;
    constexpr explicit iterator(iterator_t<base_t> current);
    constexpr iterator(iterator<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t<base_t>>;

    constexpr iterator_t<base_t> base() const &
      requires copyable<iterator_t<base_t>>;
    constexpr iterator_t<base_t> base() &&;

    constexpr decltype(auto) operator*() const
    { return get<N>(*current_); }

    constexpr iterator& operator++();
    constexpr void operator++(int) requires (!forward_range<base_t>);
    constexpr iterator operator++(int) requires forward_range<base_t>;

    constexpr iterator& operator--() requires bidirectional_range<base_t>;
    constexpr iterator operator--(int) requires bidirectional_range<base_t>;

    constexpr iterator& operator+=(difference_type x)
      requires random_access_range<base_t>;
    constexpr iterator& operator-=(difference_type x)
      requires random_access_range<base_t>;

    constexpr decltype(auto) operator[](difference_type n) const
      requires random_access_range<base_t>
    { return get<N>(*(current_ + n)); }

    friend constexpr bool operator==(const iterator& x, const iterator& y)
      requires equality_comparable<iterator_t<base_t>>;
    friend constexpr bool operator==(const iterator& x, const sentinel_t<base_t>& y);

    friend constexpr bool operator<(const iterator& x, const iterator& y)
      requires random_access_range<base_t>;
    friend constexpr bool operator>(const iterator& x, const iterator& y)
      requires random_access_range<base_t>;
    friend constexpr bool operator<=(const iterator& y, const iterator& y)
      requires random_access_range<base_t>;
    friend constexpr bool operator>=(const iterator& x, const iterator& y)
      requires random_access_range<base_t>;
    friend constexpr compare_three_way_result_t<iterator_t<base_t>>
      operator<=>(const iterator& x, const iterator& y)
        requires random_access_range<base_t> && three_way_comparable<iterator_t<base_t>>;

    friend constexpr iterator operator+(const iterator& x, difference_type y)
      requires random_access_range<base_t>;
    friend constexpr iterator operator+(difference_type x, const iterator& y)
      requires random_access_range<base_t>;
    friend constexpr iterator operator-(const iterator& x, difference_type y)
      requires random_access_range<base_t>;
    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
      requires random_access_range<base_t>;

    friend constexpr difference_type
      operator-(const iterator<Const>& x, const sentinel_t<base_t>& y)
        requires sized_sentinel_for<sentinel_t<base_t>, iterator_t<base_t>>;
    friend constexpr difference_type
      operator-(const sentinel_t<base_t>& x, const iterator<Const>& y)
        requires sized_sentinel_for<sentinel_t<base_t>, iterator_t<base_t>>;
  };
}

🔗

constexpr explicit iterator(iterator_t<base_t> current);

Effects: Initializes current_ with std::move(current).

🔗

constexpr iterator(iterator<!Const> i)
  requires Const && convertible_to<iterator_t<V>, iterator_t<base_t>>;

Effects: Initializes current_ with std::move(i.current_).

🔗

constexpr iterator_t<base_t> base() const &
  requires copyable<iterator_t<base_t>>;

Effects: Equivalent to: return current_;

🔗

constexpr iterator_t<base_t> base() &&;

Effects: Equivalent to: return std::move(current_);

🔗

constexpr iterator& operator++();

Effects: Equivalent to:

++current_;
return *this;

🔗

constexpr void operator++(int) requires (!forward_range<base_t>);

Effects: Equivalent to: ++current_.

🔗

constexpr iterator operator++(int) requires forward_range<base_t>;

Effects: Equivalent to:

auto temp = *this;
++current_;
return temp;

🔗

constexpr iterator& operator--() requires bidirectional_range<base_t>;

Effects: Equivalent to:

--current_;
return *this;

🔗

constexpr iterator operator--(int) requires bidirectional_range<base_t>;

Effects: Equivalent to:

auto temp = *this;
--current_;
return temp;

🔗

constexpr iterator& operator+=(difference_type n);
  requires random_access_range<base_t>;

Effects: Equivalent to:

current_ += n;
return *this;

🔗

constexpr iterator& operator-=(difference_type n)
  requires random_access_range<base_t>;

Effects: Equivalent to:

current_ -= n;
return *this;

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires equality_comparable<base_t>;

Effects: Equivalent to: return x.current_ == y.current_;

🔗

friend constexpr bool operator==(const iterator& x, const sentinel_t<base_t>& y);

Effects: Equivalent to: return x.current_ == y;

🔗

friend constexpr bool operator<(const iterator& x, const iterator& y)
  requires random_access_range<base_t>;

Effects: Equivalent to: return x.current_ < y.current_;

🔗

friend constexpr bool operator>(const iterator& x, const iterator& y)
  requires random_access_range<base_t>;

Effects: Equivalent to: return y < x;

🔗

friend constexpr bool operator<=(const iterator& x, const iterator& y)
  requires random_access_range<base_t>;

Effects: Equivalent to: return !(y < x);

🔗

friend constexpr bool operator>=(const iterator& x, const iterator& y)
  requires random_access_range<base_t>;

Effects: Equivalent to: return !(x < y);

🔗

friend constexpr compare_three_way_result_t<iterator_t<base_t>>
  operator<=>(const iterator& x, const iterator& y)
    requires random_access_range<base_t> && three_way_comparable<iterator_t<base_t>>;

Effects: Equivalent to: return x.current_ <=> y.current_;

🔗

friend constexpr iterator operator+(const iterator& x, difference_type y)
  requires random_access_range<base_t>;

Effects: Equivalent to: return iterator{x} += y;

🔗

friend constexpr iterator operator+(difference_type x, const iterator& y)
  requires random_access_range<base_t>;

Effects: Equivalent to: return y + x;

🔗

constexpr iterator operator-(const iterator& x, difference_type y)
  requires random_access_range<base_t>;

Effects: Equivalent to: return iterator{x} -= y;

🔗

constexpr difference_type operator-(const iterator& x, const iterator& y)
  requires random_access_range<base_t>;

Effects: Equivalent to: return x.current_ - y.current_;

🔗

friend constexpr difference_type
  operator-(const iterator<Const>& x, const sentinel_t<base_t>& y)
    requires sized_sentinel_for<sentinel_t<base_t>, iterator_t<base_t>>;

Effects: Equivalent to: return x.current_ - y;

🔗

friend constexpr difference_type
  operator-(const sentinel_t<base_t>& x, const iterator<Const>& y)
    requires sized_sentinel_for<sentinel_t<base_t>, iterator_t<base_t>>;

Effects: Equivalent to: return -(y - x);

24 Ranges library [ranges]

24.1 General [ranges.general]

24.2 Header <ranges> synopsis [ranges.syn]

24.3 Range access [range.access]

24.3.1 ranges​::​begin [range.access.begin]

24.3.2 ranges​::​end [range.access.end]

24.3.3 ranges​::​cbegin [range.access.cbegin]

24.3.4 ranges​::​cend [range.access.cend]

24.3.5 ranges​::​rbegin [range.access.rbegin]

24.3.6 ranges​::​rend [range.access.rend]

24.3.7 ranges​::​crbegin [range.access.crbegin]

24.3.8 ranges​::​crend [range.access.crend]

24.3.9 ranges​::​size [range.prim.size]

24.3.10 ranges​::​empty [range.prim.empty]

24.3.11 ranges​::​data [range.prim.data]

24.3.12 ranges​::​cdata [range.prim.cdata]

24.4 Range requirements [range.req]

24.4.1 General [range.req.general]

24.4.2 Ranges [range.range]

24.4.3 Sized ranges [range.sized]

24.4.4 Views [range.view]

24.4.5 Other range refinements [range.refinements]

24.5 Range utilities [range.utility]

24.5.1 Helper concepts [range.utility.helpers]

24.5.2 View interface [view.interface]

24.5.2.1 Members [view.interface.members]

24.5.3 Sub-ranges [range.subrange]

24.5.3.1 Constructors and conversions [range.subrange.ctor]

24.5.3.2 Accessors [range.subrange.access]

24.5.4 Dangling iterator handling [range.dangling]

24.6 Range factories [range.factories]

24.6.1 Empty view [range.empty]

24.6.1.1 Overview [range.empty.overview]

24.6.1.2 Class template empty_­view [range.empty.view]

24.6.2 Single view [range.single]

24.6.2.1 Overview [range.single.overview]

24.6.2.2 Class template single_­view [range.single.view]

24.6.2.3 views​::​single [range.single.adaptor]

24.6.3 Iota view [range.iota]

24.6.3.1 Overview [range.iota.overview]

24.6.3.2 Class template iota_­view [range.iota.view]

24.6.3.3 Class iota_­view​::​iterator [range.iota.iterator]

24.6.3.4 Class iota_­view​::​sentinel [range.iota.sentinel]

24.6.3.5 views​::​iota [range.iota.adaptor]

24.6.4 Istream view [range.istream]

24.6.4.1 Overview [range.istream.overview]

24.6.4.2 Class template basic_­istream_­view [range.istream.view]

24.6.4.3 Class template basic_­istream_­view​::​iterator [range.istream.iterator]

24.7 Range adaptors [range.adaptors]

24.7.1 Range adaptor objects [range.adaptor.object]

24.7.2 Semiregular wrapper [range.semi.wrap]

24.7.3 All view [range.all]

24.7.3.1 Class template ref_­view [range.ref.view]

24.7.4 Filter view [range.filter]

24.7.4.1 Overview [range.filter.overview]

24.7.4.2 Class template filter_­view [range.filter.view]

24.7.4.3 Class filter_­view​::​iterator [range.filter.iterator]

24.7.4.4 Class filter_­view​::​sentinel [range.filter.sentinel]

24.7.4.5 views​::​filter [range.filter.adaptor]

24.7.5 Transform view [range.transform]

24.7.5.1 Overview [range.transform.overview]

24.7.5.2 Class template transform_­view [range.transform.view]

24.7.5.3 Class template transform_­view​::​iterator [range.transform.iterator]

24.7.5.4 Class template transform_­view​::​sentinel [range.transform.sentinel]

24.7.5.5 views​::​transform [range.transform.adaptor]

24.7.6 Take view [range.take]

24.7.6.1 Overview [range.take.overview]

24.7.6.2 Class template take_­view [range.take.view]

24.7.6.3 Class template take_­view​::​sentinel [range.take.sentinel]

24.7.6.4 views​::​take [range.take.adaptor]

24.7.7 Take while view [range.take.while]

24.7.7.1 Overview [range.take.while.overview]

24.7.7.2 Class template take_­while_­view [range.take.while.view]

24.7.7.3 Class template take_­while_­view​::​sentinel [range.take.while.sentinel]

24.7.7.4 views​::​take_­while [range.take.while.adaptor]

24.7.8 Drop view [range.drop]

24.7.8.1 Overview [range.drop.overview]

24.7.8.2 Class template drop_­view [range.drop.view]

24.7.8.3 views​::​drop [range.drop.adaptor]

24.7.9 Drop while view [range.drop.while]

24.3.1 ranges::begin [range.access.begin]

24.3.2 ranges::end [range.access.end]

24.3.3 ranges::cbegin [range.access.cbegin]

24.3.4 ranges::cend [range.access.cend]

24.3.5 ranges::rbegin [range.access.rbegin]

24.3.6 ranges::rend [range.access.rend]

24.3.7 ranges::crbegin [range.access.crbegin]

24.3.8 ranges::crend [range.access.crend]

24.3.9 ranges::size [range.prim.size]

24.3.10 ranges::empty [range.prim.empty]

24.3.11 ranges::data [range.prim.data]

24.3.12 ranges::cdata [range.prim.cdata]

24.6.1.2 Class template empty_view [range.empty.view]

24.6.2.2 Class template single_view [range.single.view]

24.6.2.3 views::single [range.single.adaptor]

24.6.3.2 Class template iota_view [range.iota.view]

24.6.3.3 Class iota_view::iterator [range.iota.iterator]

24.6.3.4 Class iota_view::sentinel [range.iota.sentinel]

24.6.3.5 views::iota [range.iota.adaptor]

24.6.4.2 Class template basic_istream_view [range.istream.view]

24.6.4.3 Class template basic_istream_view::iterator [range.istream.iterator]

24.7.3.1 Class template ref_view [range.ref.view]

24.7.4.2 Class template filter_view [range.filter.view]

24.7.4.3 Class filter_view::iterator [range.filter.iterator]

24.7.4.4 Class filter_view::sentinel [range.filter.sentinel]

24.7.4.5 views::filter [range.filter.adaptor]

24.7.5.2 Class template transform_view [range.transform.view]

24.7.5.3 Class template transform_view::iterator [range.transform.iterator]

24.7.5.4 Class template transform_view::sentinel [range.transform.sentinel]

24.7.5.5 views::transform [range.transform.adaptor]

24.7.6.2 Class template take_view [range.take.view]

24.7.6.3 Class template take_view::sentinel [range.take.sentinel]

24.7.6.4 views::take [range.take.adaptor]

24.7.7.2 Class template take_while_view [range.take.while.view]

24.7.7.3 Class template take_while_view::sentinel [range.take.while.sentinel]

24.7.7.4 views::take_while [range.take.while.adaptor]

24.7.8.2 Class template drop_view [range.drop.view]

24.7.8.3 views::drop [range.drop.adaptor]

24.7.9.2 Class template drop_while_view [range.drop.while.view]

24.7.9.3 views::drop_while [range.drop.while.adaptor]

24.7.10.2 Class template join_view [range.join.view]

24.7.10.3 Class template join_view::iterator [range.join.iterator]

24.7.10.4 Class template join_view::sentinel [range.join.sentinel]

24.7.10.5 views::join [range.join.adaptor]

24.7.11.2 Class template split_view [range.split.view]

24.7.11.3 Class template split_view::outer_iterator [range.split.outer]

24.7.11.4 Class split_view::outer_iterator::value_type [range.split.outer.value]

24.7.11.5 Class template split_view::inner_iterator [range.split.inner]

24.7.11.6 views::split [range.split.adaptor]

24.7.13.2 Class template common_view [range.common.view]

24.7.13.3 views::common [range.common.adaptor]

24.7.14.2 Class template reverse_view [range.reverse.view]

24.7.14.3 views::reverse [range.reverse.adaptor]

24.7.15.2 Class template elements_view [range.elements.view]

24.7.15.3 Class template elements_view::iterator [range.elements.iterator]