[range.adaptors]

24.7.1 General [range.adaptors.general]

Subclause [range.adaptors] 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.

2

#

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

3

#

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

The adaptors also support function call syntax with equivalent semantics.

4

#

[Example 1: 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.2 Range adaptor objects [range.adaptor.object]

1

#

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)

2

#

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 .

3

#

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

4

#

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.3 Semiregular wrapper [range.semi.wrap]

1

#

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_initializable, 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.4 All view [range.all]

24.7.4.1 General [range.all.general]

1

#

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

2

#

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

Given a 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.4.2 Class template ref_view [range.ref.view]

1

#

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);

2

#

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

3

#

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>()); }

24.7.5 Filter view [range.filter]

24.7.5.1 Overview [range.filter.overview]

1

#

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

2

#

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

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

3

#

[Example 1: 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.5.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); constexpr V base() const& requires copy_constructible<V> { return base_; } constexpr V base() && { return std::move(base_); } constexpr const Pred& pred() const; 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<views::all_t<R>, Pred>; }

🔗

constexpr filter_view(V base, Pred pred);

1

#

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

🔗

constexpr const Pred& pred() const;

2

#

Effects: Equivalent to: return *pred_;

🔗

constexpr iterator begin();

3

#

Preconditions: pred_.has_value().

4

#

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

5

#

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.5.3 Class filter_view::iterator [range.filter.iterator]

namespace std::ranges { template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred> requires view<V> && is_object_v<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>>; }; }

1

#

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.

2

#

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.

3

#

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);

4

#

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

🔗

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

5

#

Effects: Equivalent to: return current_;

🔗

constexpr iterator_t<V> base() &&;

6

#

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

🔗

constexpr range_reference_t<V> operator*() const;

7

#

Effects: Equivalent to: return *current_;

🔗

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

8

#

Effects: Equivalent to: return current_;

🔗

constexpr iterator& operator++();

9

#

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

🔗

constexpr void operator++(int);

10

#

Effects: Equivalent to ++*this.

🔗

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

11

#

Effects: Equivalent to: auto tmp = *this; ++*this; return tmp;

🔗

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

12

#

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

🔗

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

13

#

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>>;

14

#

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_)));

15

#

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>>;

16

#

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

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

namespace std::ranges { template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred> requires view<V> && is_object_v<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);

1

#

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

🔗

constexpr sentinel_t<V> base() const;

2

#

Effects: Equivalent to: return end_;

🔗

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

3

#

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

24.7.6 Transform view [range.transform]

24.7.6.1 Overview [range.transform.overview]

1

#

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

2

#

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

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

3

#

[Example 1: 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.6.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>> && can-reference<invoke_result_t<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); 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<views::all_t<R>, F>; }

🔗

constexpr transform_view(V base, F fun);

1

#

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

🔗

constexpr iterator<false> begin();

2

#

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>>;

3

#

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

🔗

constexpr sentinel<false> end();

4

#

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

🔗

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

5

#

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>>;

6

#

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>>;

7

#

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

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

namespace std::ranges { template<input_range V, copy_constructible F> requires view<V> && is_object_v<F> && regular_invocable<F&, range_reference_t<V>> && can-reference<invoke_result_t<F&, range_reference_t<V>>> 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 auto 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>>; }; }

1

#

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.

2

#

iterator::iterator_category is defined as follows: Let C denote the type iterator_traits<iterator_t<Base>>::iterator_category.

(2.1)
If is_lvalue_reference_v<invoke_result_t<F&, range_reference_t<Base>>> is true, then
- (2.1.1)
  if C models derived_from<contiguous_iterator_tag>, iterator_category denotes random_access_iterator_tag;
- (2.1.2)
  otherwise, iterator_category denotes C.
(2.2)
Otherwise, iterator_category denotes input_iterator_tag.

🔗

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

3

#

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>>;

4

#

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

🔗

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

5

#

Effects: Equivalent to: return current_;

🔗

constexpr iterator_t<Base> base() &&;

6

#

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

🔗

constexpr iterator& operator++();

7

#

Effects: Equivalent to: ++current_; return *this;

🔗

constexpr void operator++(int);

8

#

Effects: Equivalent to ++current_.

🔗

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

9

#

Effects: Equivalent to: auto tmp = *this; ++*this; return tmp;

🔗

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

10

#

Effects: Equivalent to: --current_; return *this;

🔗

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

11

#

Effects: Equivalent to: auto tmp = *this; --*this; return tmp;

🔗

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

12

#

Effects: Equivalent to: current_ += n; return *this;

🔗

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

13

#

Effects: Equivalent to: current_ -= n; return *this;

🔗

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

14

#

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

🔗

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

15

#

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

🔗

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

16

#

Effects: Equivalent to: return y < x;

🔗

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

17

#

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

🔗

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

18

#

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

🔗

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

19

#

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>;

20

#

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

🔗

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

21

#

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>;

22

#

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>>;

23

#

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

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

namespace std::ranges { template<input_range V, copy_constructible F> requires view<V> && is_object_v<F> && regular_invocable<F&, range_reference_t<V>> && can-reference<invoke_result_t<F&, range_reference_t<V>>> 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);

1

#

Effects: Initializes end_ with end.

🔗

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

2

#

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

🔗

constexpr sentinel_t<Base> base() const;

3

#

Effects: Equivalent to: return end_;

🔗

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

4

#

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>>;

5

#

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>>;

6

#

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

24.7.7 Take view [range.take]

24.7.7.1 Overview [range.take.overview]

1

#

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.

2

#

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

Let E and F be expressions, let T be remove_cvref_t<decltype((E))>, and let D be range_difference_t<decltype((E))>.

If decltype((F)) does not model convertible_to<D>, views::take(E, F) is ill-formed.

Otherwise, the expression views::take(E, F) is expression-equivalent to:

(2.1)
If T is a specialization of ranges::empty_view ([range.empty.view]), then ((void) F, decay-copy(E)).
(2.2)
Otherwise, if T models random_access_range and sized_range and is
- (2.2.1)
  a specialization of span ([views.span]) where T::extent == dynamic_extent,
- (2.2.2)
  a specialization of basic_string_view ([string.view]),
- (2.2.3)
  a specialization of ranges::iota_view ([range.iota.view]), or
- (2.2.4)
  a specialization of ranges::subrange ([range.subrange]),
then T{ranges::begin(E), ranges::begin(E) + min<D>(ranges::size(E), F)}, except that E is evaluated only once.
(2.3)
Otherwise, ranges::take_view{E, F}.

3

#

[Example 1: 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.7.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); 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 { auto sz = size(); return counted_iterator{ranges::begin(base_), sz}; } } 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 { auto sz = size(); return counted_iterator{ranges::begin(base_), sz}; } } 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<views::all_t<R>>; }

🔗

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

1

#

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

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

namespace std::ranges { template<view 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);

1

#

Effects: Initializes end_ with end.

🔗

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

2

#

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

🔗

constexpr sentinel_t<Base> base() const;

3

#

Effects: Equivalent to: return end_;

🔗

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

4

#

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

24.7.8 Take while view [range.take.while]

24.7.8.1 Overview [range.take.while.overview]

1

#

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)).

2

#

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

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

3

#

[Example 1: 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.8.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>> { // [range.take.while.sentinel], class template take_while_view::sentinel template<bool> class sentinel; // exposition only V base_ = V(); // 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<views::all_t<R>, Pred>; }

🔗

constexpr take_while_view(V base, Pred pred);

1

#

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

🔗

constexpr const Pred& pred() const;

2

#

Effects: Equivalent to: return *pred_;

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

namespace std::ranges { template<view V, class Pred> requires input_range<V> && is_object_v<Pred> && indirect_unary_predicate<const Pred, iterator_t<V>> template<bool Const> class take_while_view<V, Pred>::sentinel { // exposition only using Base = conditional_t<Const, const V, V>; // exposition only sentinel_t<Base> end_ = sentinel_t<Base>(); // exposition only const Pred* pred_ = nullptr; // exposition only public: sentinel() = default; constexpr explicit sentinel(sentinel_t<Base> end, const Pred* pred); constexpr sentinel(sentinel<!Const> s) requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>; constexpr sentinel_t<Base> base() const { return end_; } friend constexpr bool operator==(const iterator_t<Base>& x, const sentinel& y); }; }

🔗

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

1

#

Effects: Initializes end_ with end and pred_ with pred.

🔗

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

2

#

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

🔗

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

3

#

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

24.7.9 Drop view [range.drop]

24.7.9.1 Overview [range.drop.overview]

1

#

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.

2

#

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

Let E and F be expressions, let T be remove_cvref_t<decltype((E))>, and let D be range_difference_t<decltype((E))>.

If decltype((F)) does not model convertible_to<D>, views::drop(E, F) is ill-formed.

Otherwise, the expression views::drop(E, F) is expression-equivalent to:

(2.1)
If T is a specialization of ranges::empty_view ([range.empty.view]), then ((void) F, decay-copy(E)).
(2.2)
Otherwise, if T models random_access_range and sized_range and is
- (2.2.1)
  a specialization of span ([views.span]) where T::extent == dynamic_extent,
- (2.2.2)
  a specialization of basic_string_view ([string.view]),
- (2.2.3)
  a specialization of ranges::iota_view ([range.iota.view]), or
- (2.2.4)
  a specialization of ranges::subrange ([range.subrange]),
then T{ranges::begin(E) + min<D>(ranges::size(E), F), ranges::end(E)}, except that E is evaluated only once.
(2.3)
Otherwise, ranges::drop_view{E, F}.

3

#

[Example 1: 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.9.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_ = V(); // exposition only range_difference_t<V> count_ = 0; // exposition only }; template<class R> drop_view(R&&, range_difference_t<R>) -> drop_view<views::all_t<R>>; }

🔗

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

1

#

Preconditions: count >= 0 is true.

2

#

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>;

3

#

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

4

#

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 1:

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

— end note]

24.7.10 Drop while view [range.drop.while]

24.7.10.1 Overview [range.drop.while.overview]

1

#

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)).

2

#

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

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

3

#

[Example 1: 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.10.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_ = V(); // exposition only semiregular-box<Pred> pred_; // exposition only }; template<class R, class Pred> drop_while_view(R&&, Pred) -> drop_while_view<views::all_t<R>, Pred>; }

🔗

constexpr drop_while_view(V base, Pred pred);

1

#

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

🔗

constexpr const Pred& pred() const;

2

#

Effects: Equivalent to: return *pred_;

🔗

constexpr auto begin();

3

#

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

4

#

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 1:

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

— end note]

24.7.11 Join view [range.join]

24.7.11.1 Overview [range.join.overview]

1

#

join_view flattens a view of ranges into a view .

2

#

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

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

3

#

[Example 1: vector<string> ss{"hello", " ", "world", "!"}; join_view greeting{ss}; for (char ch : greeting) cout << ch; // prints: hello world! — end example]

24.7.11.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 views::all_t<InnerRng> inner_ = // exposition only, present only when !is_reference_v<InnerRng> views::all_t<InnerRng>(); public: join_view() = default; constexpr explicit join_view(V base); constexpr V base() const& requires copy_constructible<V> { return base_; } constexpr V base() && { return std::move(base_); } constexpr auto begin() { constexpr bool use_const = simple-view<V> && is_reference_v<range_reference_t<V>>; return iterator<use_const>{*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<views::all_t<R>>; }

🔗

constexpr explicit join_view(V base);

1

#

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

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

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>>) 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<Base> 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>> && common_range<range_reference_t<Base>>; constexpr iterator operator--(int) requires ref-is-glvalue && bidirectional_range<Base> && bidirectional_range<range_reference_t<Base>> && common_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_))); }; }

1

#

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.

2

#

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.

3

#

iterator::difference_type denotes the type: common_type_t< range_difference_t<Base>, range_difference_t<range_reference_t<Base>>>

4

#

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

🔗

constexpr void satisfy();       // exposition only

5

#

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<Base> outer);

6

#

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>>>;

7

#

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>>;

8

#

Effects: Equivalent to return inner_;

🔗

constexpr iterator& operator++();

9

#

Let inner-range be:

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

10

#

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

🔗

constexpr void operator++(int);

11

#

Effects: Equivalent to: ++*this.

🔗

constexpr iterator operator++(int)
  requires ref-is-glvalue && forward_range<Base> &&
           forward_range<range_reference_t<Base>>;

12

#

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>> &&
           common_range<range_reference_t<Base>>;

13

#

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>> &&
           common_range<range_reference_t<Base>>;

14

#

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>>>;

15

#

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_)));

16

#

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

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

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>>) 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);

1

#

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

🔗

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

2

#

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

🔗

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

3

#

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

24.7.12 Split view [range.split]

24.7.12.1 Overview [range.split.overview]

1

#

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.

2

#

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

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

3

#

[Example 1: 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.12.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> requires constructible_from<V, views::all_t<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<views::all_t<R>, views::all_t<P>>; template<input_range R> split_view(R&&, range_value_t<R>) -> split_view<views::all_t<R>, single_view<range_value_t<R>>>; }

🔗

constexpr split_view(V base, Pattern pattern);

1

#

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

🔗

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

2

#

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

24.7.12.3 Class template split_view::outer-iterator [range.split.outer]

namespace std::ranges { 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>) 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<Base>>; 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); }; }

1

#

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>);

2

#

Effects: Initializes parent_ with addressof(parent).

🔗

constexpr outer-iterator(Parent& parent, iterator_t<Base> current)
  requires forward_range<Base>;

3

#

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<Base>>;

4

#

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

🔗

constexpr value_type operator*() const;

5

#

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

🔗

constexpr outer-iterator& operator++();

6

#

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>;

7

#

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

🔗

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

8

#

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

24.7.12.4 Class split_view::outer-iterator::value_type [range.split.outer.value]

namespace std::ranges { 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>) 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);

1

#

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

🔗

constexpr inner-iterator<Const> begin() const requires copyable<outer-iterator>;

2

#

Effects: Equivalent to: return inner-iterator<Const>{i_};

🔗

constexpr inner-iterator<Const> begin() requires (!copyable<outer-iterator>);

3

#

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

🔗

constexpr default_sentinel_t end() const;

4

#

Effects: Equivalent to: return default_sentinel;

24.7.12.5 Class template split_view::inner-iterator [range.split.inner]

namespace std::ranges { 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>) 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>>; }; }

1

#

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);

2

#

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

🔗

constexpr inner-iterator& operator++();

3

#

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>;

4

#

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

🔗

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

5

#

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>>;

6

#

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

24.7.13 Counted view [range.counted]

1

#

A counted view presents a view of the elements of the counted range ([iterator.requirements.general])

i + [0, n)

for an iterator i and non-negative integer n.

2

#

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

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

If decltype((F)) does not model convertible_to<D>, views::counted(E, F) is ill-formed.

[Note 1:

This case can result in substitution failure when views::counted(E, F) appears in the immediate context of a template instantiation.

— end note]

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

(2.1)
If T models contiguous_iterator, then span{to_address(E), static_cast<D>(F)}.
(2.2)
Otherwise, if T models random_access_iterator, then subrange{E, E + static_cast<D>(F)}, except that E is evaluated only once.
(2.3)
Otherwise, subrange{counted_iterator{E, F}, default_sentinel}.

24.7.14 Common view [range.common]

24.7.14.1 Overview [range.common.overview]

1

#

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.

2

#

[Note 1:

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

— end note]

3

#

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

Given a subexpression E, the expression views::common(E) is expression-equivalent to:

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

4

#

[Example 1: // 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.14.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, views::all_t<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 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_)); } 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> common_view(R&&) -> common_view<views::all_t<R>>; }

🔗

constexpr explicit common_view(V base);

1

#

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

🔗

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

2

#

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

24.7.15 Reverse view [range.reverse]

24.7.15.1 Overview [range.reverse.overview]

1

#

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

2

#

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

Given a subexpression E, the expression views::reverse(E) is expression-equivalent to:

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

3

#

[Example 1: 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.15.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); 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 auto begin() const requires common_range<const V>; constexpr reverse_iterator<iterator_t<V>> end(); constexpr auto 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<views::all_t<R>>; }

🔗

constexpr explicit reverse_view(V base);

1

#

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

🔗

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

2

#

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

3

#

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 auto begin() const requires common_range<const V>;

4

#

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

🔗

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

5

#

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

24.7.16 Elements view [range.elements]

24.7.16.1 Overview [range.elements.overview]

1

#

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.

2

#

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

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

[Example 1: 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]

3

#

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

[Example 2: auto names = keys_view{historical_figures}; for (auto&& name : names) { cout << name << ' '; // prints Babbage Hamilton Lovelace Turing } — end example]

4

#

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

[Example 3: 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.16.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) } -> convertible_to<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() { return sentinel<false>{ranges::end(base_)}; } constexpr auto end() requires common_range<V> { return iterator<false>{ranges::end(base_)}; } constexpr auto end() const requires range<const V> { return sentinel<true>{ranges::end(base_)}; } constexpr auto end() const requires common_range<const V> { return iterator<true>{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: // [range.elements.iterator], class template elements_view::iterator template<bool> struct iterator; // exposition only // [range.elements.sentinel], class template elements_view::sentinel template<bool> struct sentinel; // exposition only V base_ = V(); // exposition only }; }

🔗

constexpr explicit elements_view(V base);

1

#

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

24.7.16.3 Class template elements_view::iterator [range.elements.iterator]

namespace std::ranges { 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> template<bool Const> class elements_view<V, N>::iterator { // exposition only using Base = conditional_t<Const, const V, V>; // exposition only iterator_t<Base> current_ = iterator_t<Base>(); public: using iterator_category = typename iterator_traits<iterator_t<Base>>::iterator_category; using value_type = remove_cvref_t<tuple_element_t<N, range_value_t<Base>>>; using difference_type = range_difference_t<Base>; iterator() = default; constexpr explicit iterator(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 get<N>(*current_); } constexpr iterator& operator++(); constexpr void operator++(int) requires (!forward_range<Base>); 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 x) requires random_access_range<Base>; constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>; constexpr decltype(auto) operator[](difference_type n) const requires random_access_range<Base> { return get<N>(*(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 auto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>; friend constexpr iterator operator+(const iterator& x, difference_type y) requires random_access_range<Base>; friend constexpr iterator operator+(difference_type x, const iterator& y) requires random_access_range<Base>; friend constexpr iterator operator-(const iterator& x, difference_type y) requires random_access_range<Base>; friend constexpr difference_type operator-(const iterator& x, const iterator& y) requires random_access_range<Base>; }; }

🔗

constexpr explicit iterator(iterator_t<Base> current);

1

#

Effects: Initializes current_ with std::move(current).

🔗

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

2

#

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

🔗

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

3

#

Effects: Equivalent to: return current_;

🔗

constexpr iterator_t<Base> base() &&;

4

#

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

🔗

constexpr iterator& operator++();

5

#

Effects: Equivalent to: ++current_; return *this;

🔗

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

6

#

Effects: Equivalent to: ++current_.

🔗

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

7

#

Effects: Equivalent to: auto temp = *this; ++current_; return temp;

🔗

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

8

#

Effects: Equivalent to: --current_; return *this;

🔗

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

9

#

Effects: Equivalent to: auto temp = *this; --current_; return temp;

🔗

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

10

#

Effects: Equivalent to: current_ += n; return *this;

🔗

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

11

#

Effects: Equivalent to: current_ -= n; return *this;

🔗

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

12

#

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

🔗

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

13

#

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

🔗

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

14

#

Effects: Equivalent to: return y < x;

🔗

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

15

#

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

🔗

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

16

#

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

🔗

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

17

#

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

🔗

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

18

#

Effects: Equivalent to: return iterator{x} += y;

🔗

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

19

#

Effects: Equivalent to: return y + x;

🔗

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

20

#

Effects: Equivalent to: return iterator{x} -= y;

🔗

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

21

#

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

24.7.16.4 Class template elements_view::sentinel [range.elements.sentinel]

namespace std::ranges { 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> template<bool Const> class elements_view<V, N>::sentinel { // exposition only private: 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> other) 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& x, const iterator<Const>& y) requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>; }; }

🔗

constexpr explicit sentinel(sentinel_t<Base> end);

1

#

Effects: Initializes end_ with end.

🔗

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

2

#

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

🔗

constexpr sentinel_t<Base> base() const;

3

#

Effects: Equivalent to: return end_;

🔗

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

4

#

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>>;

5

#

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

🔗

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

6

#

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

24 Ranges library [ranges]

24.7 Range adaptors [range.adaptors]

24.7.1 General [range.adaptors.general]

24.7.2 Range adaptor objects [range.adaptor.object]

24.7.3 Semiregular wrapper [range.semi.wrap]

24.7.4 All view [range.all]

24.7.4.1 General [range.all.general]

24.7.4.2 Class template ref_­view [range.ref.view]

24.7.5 Filter view [range.filter]

24.7.5.1 Overview [range.filter.overview]

24.7.5.2 Class template filter_­view [range.filter.view]

24.7.5.3 Class filter_­view​::​iterator [range.filter.iterator]

24.7.5.4 Class filter_­view​::​sentinel [range.filter.sentinel]

24.7.6 Transform view [range.transform]

24.7.6.1 Overview [range.transform.overview]

24.7.6.2 Class template transform_­view [range.transform.view]

24.7.6.3 Class template transform_­view​::​iterator [range.transform.iterator]

24.7.6.4 Class template transform_­view​::​sentinel [range.transform.sentinel]

24.7.7 Take view [range.take]

24.7.7.1 Overview [range.take.overview]

24.7.7.2 Class template take_­view [range.take.view]

24.7.7.3 Class template take_­view​::​sentinel [range.take.sentinel]

24.7.8 Take while view [range.take.while]

24.7.8.1 Overview [range.take.while.overview]

24.7.8.2 Class template take_­while_­view [range.take.while.view]

24.7.8.3 Class template take_­while_­view​::​sentinel [range.take.while.sentinel]

24.7.9 Drop view [range.drop]

24.7.9.1 Overview [range.drop.overview]

24.7.9.2 Class template drop_­view [range.drop.view]

24.7.10 Drop while view [range.drop.while]

24.7.10.1 Overview [range.drop.while.overview]

24.7.10.2 Class template drop_­while_­view [range.drop.while.view]

24.7.11 Join view [range.join]

24.7.11.1 Overview [range.join.overview]

24.7.11.2 Class template join_­view [range.join.view]

24.7.11.3 Class template join_­view​::​iterator [range.join.iterator]

24.7.11.4 Class template join_­view​::​sentinel [range.join.sentinel]

24.7.12 Split view [range.split]

24.7.12.1 Overview [range.split.overview]

24.7.12.2 Class template split_­view [range.split.view]

24.7.12.3 Class template split_­view​::​outer-iterator [range.split.outer]

24.7.12.4 Class split_­view​::​outer-iterator​::​value_­type [range.split.outer.value]

24.7.12.5 Class template split_­view​::​inner-iterator [range.split.inner]

24.7.13 Counted view [range.counted]

24.7.14 Common view [range.common]

24.7.14.1 Overview [range.common.overview]

24.7.14.2 Class template common_­view [range.common.view]

24.7.15 Reverse view [range.reverse]

24.7.15.1 Overview [range.reverse.overview]

24.7.15.2 Class template reverse_­view [range.reverse.view]

24.7.16 Elements view [range.elements]

24.7.16.1 Overview [range.elements.overview]

24.7.16.2 Class template elements_­view [range.elements.view]

24.7.16.3 Class template elements_­view​::​iterator [range.elements.iterator]

24.7.16.4 Class template elements_­view​::​sentinel [range.elements.sentinel]

24.7.4.2 Class template ref_view [range.ref.view]

24.7.5.2 Class template filter_view [range.filter.view]

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

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

24.7.6.2 Class template transform_view [range.transform.view]

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

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

24.7.7.2 Class template take_view [range.take.view]

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

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

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

24.7.9.2 Class template drop_view [range.drop.view]

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

24.7.11.2 Class template join_view [range.join.view]

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

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

24.7.12.2 Class template split_view [range.split.view]

24.7.12.3 Class template split_view::outer-iterator [range.split.outer]

24.7.12.4 Class split_view::outer-iterator::value_type [range.split.outer.value]

24.7.12.5 Class template split_view::inner-iterator [range.split.inner]

24.7.14.2 Class template common_view [range.common.view]

24.7.15.2 Class template reverse_view [range.reverse.view]

24.7.16.2 Class template elements_view [range.elements.view]

24.7.16.3 Class template elements_view::iterator [range.elements.iterator]

24.7.16.4 Class template elements_view::sentinel [range.elements.sentinel]