26 Ranges library [ranges]

26.6 Range factories [range.factories]

26.6.1 General [range.factories.general]

1
#
Subclause [range.factories] defines range factories, which are utilities to create a view.
2
#
Range factories are declared in namespace std​::​ranges​::​views.

26.6.2 Empty view [range.empty]

26.6.2.1 Overview [range.empty.overview]

1
#
empty_view produces a view of no elements of a particular type.
2
#
[Example 1: auto e = views::empty<int>; static_assert(ranges::empty(e)); static_assert(0 == e.size()); — end example]

26.6.2.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; } }; }

26.6.3 Single view [range.single]

26.6.3.1 Overview [range.single.overview]

1
#
single_view produces a view that contains exactly one element of a specified value.
2
#
The name views​::​single denotes a customization point object ([customization.point.object]).
Given a subexpression E, the expression views​::​single(E) is expression-equivalent to single_view<decay_t<decltype((E))>>(E).
3
#
[Example 1: for (int i : views::single(4)) cout << i; // prints 4 — end example]

26.6.3.2 Class template single_view [range.single.view]

🔗
namespace std::ranges { template<move_constructible T> requires is_object_v<T> class single_view : public view_interface<single_view<T>> { private: movable-box<T> value_; // exposition only (see [range.move.wrap]) public: single_view() requires default_initializable<T> = default; constexpr explicit single_view(const T& t) requires copy_constructible<T>; constexpr explicit single_view(T&& t); template<class... Args> requires constructible_from<T, Args...> constexpr explicit 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; }; template<class T> single_view(T) -> single_view<T>; }
🔗
constexpr explicit single_view(const T& t) requires copy_constructible<T>;
1
#
Effects: Initializes value_ with t.
🔗
constexpr explicit single_view(T&& t);
2
#
Effects: Initializes value_ with std​::​move(t).
🔗
template<class... Args> requires constructible_from<T, Args...> constexpr explicit single_view(in_place_t, Args&&... args);
3
#
Effects: Initializes value_ as if by value_{in_place, std​::​forward<Args>(args)...}.
🔗
constexpr T* begin() noexcept; constexpr const T* begin() const noexcept;
4
#
Effects: Equivalent to: return data();
🔗
constexpr T* end() noexcept; constexpr const T* end() const noexcept;
5
#
Effects: Equivalent to: return data() + 1;
🔗
static constexpr size_t size() noexcept;
6
#
Effects: Equivalent to: return 1;
🔗
constexpr T* data() noexcept; constexpr const T* data() const noexcept;
7
#
Effects: Equivalent to: return value_.operator->();

26.6.4 Iota view [range.iota]

26.6.4.1 Overview [range.iota.overview]

1
#
iota_view generates a sequence of elements by repeatedly incrementing an initial value.
2
#
The name views​::​iota denotes a customization point object ([customization.point.object]).
Given 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.
3
#
[Example 1: for (int i : views::iota(1, 10)) cout << i << ' '; // prints 1 2 3 4 5 6 7 8 9 — end example]

26.6.4.2 Class template iota_view [range.iota.view]

🔗
namespace std::ranges { template<class I> concept decrementable = see below; // exposition only template<class I> concept advanceable = see below; // exposition only template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t> requires weakly-equality-comparable-with<W, Bound> && copyable<W> 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() requires default_initializable<W> = default; constexpr explicit iota_view(W value); constexpr explicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound); constexpr explicit iota_view(iterator first, see below last); constexpr iterator begin() const; constexpr auto end() const; constexpr iterator end() const requires same_as<W, Bound>; constexpr bool empty() const; 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>; }
1
#
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 1: 
    It is unspecified whether this type satisfies weakly_incrementable.
    — end note]
2
#
The exposition-only decrementable concept is equivalent to:
🔗
template<class I> concept decrementable = // exposition only incrementable<I> && requires(I i) { { --i } -> same_as<I&>; { i-- } -> same_as<I>; };
3
#
When an object is in the domain of both pre- and post-decrement, the object is said to be decrementable.
4
#
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.2)
    If a and b are incrementable, then bool(--(++a) == b).
5
#
The exposition-only advanceable concept is equivalent to:
🔗
template<class I> concept advanceable = // exposition only 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);
6
#
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.
7
#
Effects: Initializes value_ with value.
🔗
constexpr explicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
8
#
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.
9
#
Effects: Initializes value_ with value and bound_ with bound.
🔗
constexpr explicit iota_view(iterator first, see below last);
10
#
Effects: Equivalent to:
  • (10.1)
    If same_as<W, Bound> is true, iota_view(first.value_, last.value_).
  • (10.2)
    Otherwise, if Bound denotes unreachable_sentinel_t, iota_view(first.value_, last).
  • (10.3)
    Otherwise, iota_view(first.value_, last.bound_).
11
#
Remarks: The type of last is:
🔗
constexpr iterator begin() const;
12
#
Effects: Equivalent to: return iterator{value_};
🔗
constexpr auto end() const;
13
#
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>;
14
#
Effects: Equivalent to: return iterator{bound_};
🔗
constexpr bool empty() const;
15
#
Effects: Equivalent to: return value_ == bound_;
🔗
constexpr auto size() const requires see below;
16
#
Effects: Equivalent to: if constexpr (is-integer-like<W> && is-integer-like<Bound>) return (value_ < 0) ? ((bound_ < 0) ? to-unsigned-like(-value_) - to-unsigned-like(-bound_) : to-unsigned-like(bound_) + to-unsigned-like(-value_)) : to-unsigned-like(bound_) - to-unsigned-like(value_); else return to-unsigned-like(bound_ - value_);
17
#
Remarks: The expression in the requires-clause is equivalent to: (same_as<W, Bound> && advanceable<W>) || (is-integer-like<W> && is-integer-like<Bound>) || sized_sentinel_for<Bound, W>

26.6.4.3 Class iota_view​::​iterator [range.iota.iterator]

namespace std::ranges { template<weakly_incrementable W, semiregular Bound> requires weakly-equality-comparable-with<W, Bound> && copyable<W> struct iota_view<W, Bound>::iterator { private: W value_ = W(); // exposition only public: using iterator_concept = see below; using iterator_category = input_iterator_tag; // present only if W models incrementable and // IOTA-DIFF-T(W) is an integral type using value_type = W; using difference_type = IOTA-DIFF-T(W); iterator() requires default_initializable<W> = 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 auto 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>; }; }
1
#
iterator​::​iterator_concept is defined as follows:
  • (1.1)
    If W models advanceable, then iterator_concept is random_access_iterator_tag.
  • (1.2)
    Otherwise, if W models decrementable, then iterator_concept is bidirectional_iterator_tag.
  • (1.3)
    Otherwise, if W models incrementable, then iterator_concept is forward_iterator_tag.
  • (1.4)
    Otherwise, iterator_concept is input_iterator_tag.
2
#
[Note 1: 
Overloads for iter_move and iter_swap are omitted intentionally.
— end note]
🔗
constexpr explicit iterator(W value);
3
#
Effects: Initializes value_ with value.
🔗
constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);
4
#
Effects: Equivalent to: return value_;
5
#
[Note 2: 
The noexcept clause is needed by the default iter_move implementation.
— end note]
🔗
constexpr iterator& operator++();
6
#
Effects: Equivalent to: ++value_; return *this;
🔗
constexpr void operator++(int);
7
#
Effects: Equivalent to ++*this.
🔗
constexpr iterator operator++(int) requires incrementable<W>;
8
#
Effects: Equivalent to: auto tmp = *this; ++*this; return tmp;
🔗
constexpr iterator& operator--() requires decrementable<W>;
9
#
Effects: Equivalent to: --value_; return *this;
🔗
constexpr iterator operator--(int) requires decrementable<W>;
10
#
Effects: Equivalent to: auto tmp = *this; --*this; return tmp;
🔗
constexpr iterator& operator+=(difference_type n) requires advanceable<W>;
11
#
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>;
12
#
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>;
13
#
Effects: Equivalent to: return W(value_ + n);
🔗
friend constexpr bool operator==(const iterator& x, const iterator& y) requires equality_comparable<W>;
14
#
Effects: Equivalent to: return x.value_ == y.value_;
🔗
friend constexpr bool operator<(const iterator& x, const iterator& y) requires totally_ordered<W>;
15
#
Effects: Equivalent to: return x.value_ < y.value_;
🔗
friend constexpr bool operator>(const iterator& x, const iterator& y) requires totally_ordered<W>;
16
#
Effects: Equivalent to: return y < x;
🔗
friend constexpr bool operator<=(const iterator& x, const iterator& y) requires totally_ordered<W>;
17
#
Effects: Equivalent to: return !(y < x);
🔗
friend constexpr bool operator>=(const iterator& x, const iterator& y) requires totally_ordered<W>;
18
#
Effects: Equivalent to: return !(x < y);
🔗
friend constexpr auto operator<=>(const iterator& x, const iterator& y) requires totally_ordered<W> && three_way_comparable<W>;
19
#
Effects: Equivalent to: return x.value_ <=> y.value_;
🔗
friend constexpr iterator operator+(iterator i, difference_type n) requires advanceable<W>;
20
#
Effects: Equivalent to: i += n; return i;
🔗
friend constexpr iterator operator+(difference_type n, iterator i) requires advanceable<W>;
21
#
Effects: Equivalent to: return i + n;
🔗
friend constexpr iterator operator-(iterator i, difference_type n) requires advanceable<W>;
22
#
Effects: Equivalent to: i -= n; return i;
🔗
friend constexpr difference_type operator-(const iterator& x, const iterator& y) requires advanceable<W>;
23
#
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_; }

26.6.4.4 Class iota_view​::​sentinel [range.iota.sentinel]

namespace std::ranges { template<weakly_incrementable W, semiregular Bound> requires weakly-equality-comparable-with<W, Bound> && copyable<W> 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);
1
#
Effects: Initializes bound_ with bound.
🔗
friend constexpr bool operator==(const iterator& x, const sentinel& y);
2
#
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>;
3
#
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>;
4
#
Effects: Equivalent to: return -(y - x);

26.6.5 Repeat view [range.repeat]

26.6.5.1 Overview [range.repeat.overview]

1
#
repeat_view generates a sequence of elements by repeatedly producing the same value.
2
#
The name views​::​repeat denotes a customization point object ([customization.point.object]).
Given subexpressions E and F, the expressions views​::​repeat(E) and views​::​repeat(E, F) are expression-equivalent to repeat_view(E) and repeat_view(E, F), respectively.
3
#
[Example 1: for (int i : views::repeat(17, 4)) cout << i << ' '; // prints 17 17 17 17 — end example]

26.6.5.2 Class template repeat_view [range.repeat.view]

namespace std::ranges { template<class T> concept integer-like-with-usable-difference-type = // exposition only is-signed-integer-like<T> || (is-integer-like<T> && weakly_incrementable<T>); template<move_constructible T, semiregular Bound = unreachable_sentinel_t> requires (is_object_v<T> && same_as<T, remove_cv_t<T>> && (integer-like-with-usable-difference-type<Bound> || same_as<Bound, unreachable_sentinel_t>)) class repeat_view : public view_interface<repeat_view<T, Bound>> { private: // [range.repeat.iterator], class repeat_view​::​iterator struct iterator; // exposition only movable-box<T> value_; // exposition only, see [range.move.wrap] Bound bound_ = Bound(); // exposition only public: repeat_view() requires default_initializable<T> = default; constexpr explicit repeat_view(const T& value, Bound bound = Bound()) requires copy_constructible<T>; constexpr explicit repeat_view(T&& value, Bound bound = Bound()); template<class... TArgs, class... BoundArgs> requires constructible_from<T, TArgs...> && constructible_from<Bound, BoundArgs...> constexpr explicit repeat_view(piecewise_construct_t, tuple<TArgs...> value_args, tuple<BoundArgs...> bound_args = tuple<>{}); constexpr iterator begin() const; constexpr iterator end() const requires (!same_as<Bound, unreachable_sentinel_t>); constexpr unreachable_sentinel_t end() const noexcept; constexpr auto size() const requires (!same_as<Bound, unreachable_sentinel_t>); }; template<class T, class Bound> repeat_view(T, Bound) -> repeat_view<T, Bound>; }
🔗
constexpr explicit repeat_view(const T& value, Bound bound = Bound()) requires copy_constructible<T>;
1
#
Preconditions: If Bound is not unreachable_sentinel_t, bound  ≥ 0.
2
#
Effects: Initializes value_ with value and bound_ with bound.
🔗
constexpr explicit repeat_view(T&& value, Bound bound = Bound());
3
#
Preconditions: If Bound is not unreachable_sentinel_t, bound  ≥ 0.
4
#
Effects: Initializes value_ with std​::​move(value) and bound_ with bound.
🔗
template<class... TArgs, class... BoundArgs> requires constructible_from<T, TArgs...> && constructible_from<Bound, BoundArgs...> constexpr explicit repeat_view(piecewise_construct_t, tuple<TArgs...> value_args, tuple<BoundArgs...> bound_args = tuple<>{});
5
#
Effects: Initializes value_ with make_from_tuple<T>(std​::​move(value_args)) and initializes
bound_ with make_from_tuple<Bound>(std​::​move(bound_args)).
The behavior is undefined if Bound is not unreachable_sentinel_t and bound_ is negative.
🔗
constexpr iterator begin() const;
6
#
Effects: Equivalent to: return iterator(addressof(*value_));
🔗
constexpr iterator end() const requires (!same_as<Bound, unreachable_sentinel_t>);
7
#
Effects: Equivalent to: return iterator(addressof(*value_), bound_);
🔗
constexpr unreachable_sentinel_t end() const noexcept;
8
#
Effects: Equivalent to: return unreachable_sentinel;
🔗
constexpr auto size() const requires (!same_as<Bound, unreachable_sentinel_t>);
9
#
Effects: Equivalent to: return to-unsigned-like(bound_);

26.6.5.3 Class repeat_view​::​iterator [range.repeat.iterator]

namespace std::ranges { template<move_constructible T, semiregular Bound> requires (is_object_v<T> && same_as<T, remove_cv_t<T>> && (integer-like-with-usable-difference-type<Bound> || same_as<Bound, unreachable_sentinel_t>)) class repeat_view<T, Bound>::iterator { private: using index-type = // exposition only conditional_t<same_as<Bound, unreachable_sentinel_t>, ptrdiff_t, Bound>; const T* value_ = nullptr; // exposition only index-type current_ = index-type(); // exposition only constexpr explicit iterator(const T* value, index-type b = index-type()); // exposition only public: using iterator_concept = random_access_iterator_tag; using iterator_category = random_access_iterator_tag; using value_type = T; using difference_type = see below; iterator() = default; constexpr const T& operator*() const noexcept; constexpr iterator& operator++(); constexpr iterator operator++(int); constexpr iterator& operator--(); constexpr iterator operator--(int); constexpr iterator& operator+=(difference_type n); constexpr iterator& operator-=(difference_type n); constexpr const T& operator[](difference_type n) const noexcept; friend constexpr bool operator==(const iterator& x, const iterator& y); friend constexpr auto operator<=>(const iterator& x, const iterator& y); friend constexpr iterator operator+(iterator i, difference_type n); friend constexpr iterator operator+(difference_type n, iterator i); friend constexpr iterator operator-(iterator i, difference_type n); friend constexpr difference_type operator-(const iterator& x, const iterator& y); }; }
1
#
If is-signed-integer-like<index-type> is true, the member typedef-name difference_type denotes index-type.
Otherwise, it denotes IOTA-DIFF-T(index-type) ([range.iota.view]).
🔗
constexpr explicit iterator(const T* value, index-type b = index-type());
2
#
Preconditions: If Bound is not unreachable_sentinel_t, b  ≥ 0.
3
#
Effects: Initializes value_ with value and current_ with b.
🔗
constexpr const T& operator*() const noexcept;
4
#
Effects: Equivalent to: return *value_;
🔗
constexpr iterator& operator++();
5
#
Effects: Equivalent to: ++current_; return *this;
🔗
constexpr iterator operator++(int);
6
#
Effects: Equivalent to: auto tmp = *this; ++*this; return tmp;
🔗
constexpr iterator& operator--();
7
#
Preconditions: If Bound is not unreachable_sentinel_t, .
8
#
Effects: Equivalent to: --current_; return *this;
🔗
constexpr iterator operator--(int);
9
#
Effects: Equivalent to: auto tmp = *this; --*this; return tmp;
🔗
constexpr iterator& operator+=(difference_type n);
10
#
Preconditions: If Bound is not unreachable_sentinel_t, .
11
#
Effects: Equivalent to: current_ += n; return *this;
🔗
constexpr iterator& operator-=(difference_type n);
12
#
Preconditions: If Bound is not unreachable_sentinel_t, .
13
#
Effects: Equivalent to: current_ -= n; return *this;
🔗
constexpr const T& operator[](difference_type n) const noexcept;
14
#
Effects: Equivalent to: return *(*this + n);
🔗
friend constexpr bool operator==(const iterator& x, const iterator& y);
15
#
Effects: Equivalent to: return x.current_ == y.current_;
🔗
friend constexpr auto operator<=>(const iterator& x, const iterator& y);
16
#
Effects: Equivalent to: return x.current_ <=> y.current_;
🔗
friend constexpr iterator operator+(iterator i, difference_type n); friend constexpr iterator operator+(difference_type n, iterator i);
17
#
Effects: Equivalent to: i += n; return i;
🔗
friend constexpr iterator operator-(iterator i, difference_type n);
18
#
Effects: Equivalent to: i -= n; return i;
🔗
friend constexpr difference_type operator-(const iterator& x, const iterator& y);
19
#
Effects: Equivalent to: return static_cast<difference_type>(x.current_) - static_cast<difference_type>(y.current_);

26.6.6 Istream view [range.istream]

26.6.6.1 Overview [range.istream.overview]

1
#
basic_istream_view models input_range and reads (using operator>>) successive elements from its corresponding input stream.
2
#
The name views​::​istream<T> denotes a customization point object ([customization.point.object]).
Given a type T and a subexpression E of type U, if U models derived_from<basic_istream<typename U​::​char_type, typename U​::​traits_type>>, then the expression views​::​istream<T>(E) is expression-equivalent to basic_istream_view<T, typename U​::​char_type, typename U​::​traits_type>(E); otherwise, views​::​istream<T>(E) is ill-formed.
3
#
[Example 1: auto ints = istringstream{"0 1 2 3 4"}; ranges::copy(views::istream<int>(ints), ostream_iterator<int>{cout, "-"}); // prints 0-1-2-3-4- — end example]

26.6.6.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 = char_traits<CharT>> requires default_initializable<Val> && stream-extractable<Val, CharT, Traits> class basic_istream_view : public view_interface<basic_istream_view<Val, CharT, Traits>> { public: constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream); constexpr auto begin() { *stream_ >> value_; return iterator{*this}; } constexpr default_sentinel_t end() const noexcept; private: // [range.istream.iterator], class basic_istream_view​::​iterator struct iterator; // exposition only basic_istream<CharT, Traits>* stream_; // exposition only Val value_ = Val(); // exposition only }; }
🔗
constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream);
1
#
Effects: Initializes stream_ with addressof(stream).
🔗
constexpr default_sentinel_t end() const noexcept;
2
#
Effects: Equivalent to: return default_sentinel;

26.6.6.3 Class basic_istream_view​::​iterator [range.istream.iterator]

namespace std::ranges { template<movable Val, class CharT, class Traits> requires default_initializable<Val> && stream-extractable<Val, CharT, Traits> class basic_istream_view<Val, CharT, Traits>::iterator { public: using iterator_concept = input_iterator_tag; using difference_type = ptrdiff_t; using value_type = Val; 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;
1
#
Effects: Initializes parent_ with addressof(parent).
🔗
iterator& operator++();
2
#
Effects: Equivalent to: *parent_->stream_ >> parent_->value_; return *this;
🔗
void operator++(int);
3
#
Effects: Equivalent to ++*this.
🔗
Val& operator*() const;
4
#
Effects: Equivalent to: return parent_->value_;
🔗
friend bool operator==(const iterator& x, default_sentinel_t);
5
#
Effects: Equivalent to: return !*x.parent_->stream_;