cppdraft_translate/cppdraft/range/factories.md

[range.factories]

25 Ranges library [ranges]

25.6 Range factories [range.factories]

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

25.6.2 Empty view [range.empty]

25.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;static_assert(ranges::empty(e));static_assert(0 == e.size()); — end example]

25.6.2.2 Class template empty_view [range.empty.view]

🔗

namespace std::ranges {templaterequires is_object_vclass empty_view : public view_interface<empty_view> {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; }};}

25.6.3 Single view [range.single]

25.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 expressionviews​::​single(E) is expression-equivalent tosingle_view<decay_t<decltype((E))>>(E).

3

#

[Example 1: for (int i : views::single(4)) cout << i; // prints 4 — end example]

25.6.3.2 Class template single_view [range.single.view]

🔗

namespace std::ranges {template<move_constructible T>requires is_object_vclass single_view : public view_interface<single_view> {private:movable-box value_; // exposition only (see [range.move.wrap])public: single_view() requires default_initializable = default; constexpr explicit single_view(const T& t) requires copy_constructible; 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 bool empty() noexcept; static constexpr size_t size() noexcept; constexpr T* data() noexcept; constexpr const T* data() const noexcept; }; template single_view(T) -> single_view;}

🔗

constexpr explicit single_view(const T& t) requires [copy_constructible](concept.copyconstructible#concept:copy_constructible "18.4.14 Concept copy_­constructible [concept.copyconstructible]")<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](concept.constructible#concept:constructible_from "18.4.11 Concept constructible_­from [concept.constructible]")<T, Args...> constexpr explicit single_view(in_place_t, Args&&... args);

3

#

Effects: Initializes value_ as if byvalue_{in_place, std​::​forward(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 bool empty() noexcept;

6

#

Effects: Equivalent to: return false;

🔗

static constexpr size_t size() noexcept;

7

#

Effects: Equivalent to: return 1;

🔗

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

8

#

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

25.6.4 Iota view [range.iota]

25.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 expressionsviews​::​iota(E) and views​::​iota(E, F) are expression-equivalent toiota_view<decay_t<decltype((E))>>(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]

4

#

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

Given subexpression E, let T be remove_cvref_t<decltype((E))>.

views​::​indices(E) is expression-equivalent toviews​::​iota(T(0), E) if is-integer-like is true, and ill-formed otherwise.

25.6.4.2 Class template iota_view [range.iota.view]

🔗

namespace std::ranges {templateconcept decrementable = see below; // exposition onlytemplateconcept advanceable = see below; // exposition onlytemplate<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>requires weakly-equality-comparable-with<W, Bound> && copyableclass iota_view : public view_interface<iota_view<W, Bound>> {private:// [range.iota.iterator], class iota_view​::​iteratorstruct iterator; // exposition only// [range.iota.sentinel], class iota_view​::​sentinelstruct sentinel; // exposition only W value_ = W(); // exposition only Bound bound_ = Bound(); // exposition onlypublic: iota_view() requires default_initializable = default; constexpr explicit iota_view(W value); constexpr explicit iota_view(type_identity_t value, type_identity_t 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 || !is-integer-like ||(is-signed-integer-like == is-signed-integer-like)) 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) is greater than sizeof(W), then IOTA-DIFF-T(W) denotes iter_difference_t.

• (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](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]") = // exposition only [incrementable](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]")<I> && requires(I i) { { --i } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>; { i-- } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<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.1.1)

addressof(--a) == addressof(a)

• (4.1.2)

bool(a-- == b)

• (4.1.3)

bool(((void)a--, a) == --b)

• (4.1.4)

bool(++(--a) == b).

• (4.2)

  If a and b are incrementable, then bool(--(++a) == b).

5

#

The exposition-only advanceable concept is equivalent to:

🔗

template<class I> concept [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]") = // exposition only [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<I> && [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<I> && requires(I i, const I j, const IOTA-DIFF-T(I) n) { { i += n } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>; { i -= n } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>; I(j + n); I(n + j); I(j - n); { j - j } -> [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<IOTA-DIFF-T(I)>; };

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

Let a and b be objects of type I such thatb 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 orBound() 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 orbound is reachable from value.

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

9

#

Effects: Initializes value_ with value andbound_ 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:

• (11.1)

  If same_as<W, Bound> is true, iterator.

• (11.2)

  Otherwise, if Bound denotes unreachable_sentinel_t,Bound.

• (11.3)

  Otherwise, sentinel.

🔗

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;elsereturn sentinel{bound_};

🔗

constexpr iterator end() const requires [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<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 && is-integer-like)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_);elsereturn to-unsigned-like(bound_ - value_);

17

#

Remarks: The expression in the requires-clause is equivalent to:(same_as<W, Bound> && advanceable) || (is-integer-like && is-integer-like) ||sized_sentinel_for<Bound, W>

25.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> && copyablestruct iota_view<W, Bound>::iterator {private: W value_ = W(); // exposition onlypublic: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 typeusing value_type = W; using difference_type = IOTA-DIFF-T(W); iterator() requires default_initializable = default; constexpr explicit iterator(W value); constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v); constexpr iterator& operator++(); constexpr void operator++(int); constexpr iterator operator++(int) requires incrementable; constexpr iterator& operator--() requires decrementable; constexpr iterator operator--(int) requires decrementable; constexpr iterator& operator+=(difference_type n)requires advanceable; constexpr iterator& operator-=(difference_type n)requires advanceable; constexpr W operator[](difference_type n) constrequires advanceable; friend constexpr bool operator==(const iterator& x, const iterator& y)requires equality_comparable; friend constexpr bool operator<(const iterator& x, const iterator& y)requires totally_ordered; friend constexpr bool operator>(const iterator& x, const iterator& y)requires totally_ordered; friend constexpr bool operator<=(const iterator& x, const iterator& y)requires totally_ordered; friend constexpr bool operator>=(const iterator& x, const iterator& y)requires totally_ordered; friend constexpr auto operator<=>(const iterator& x, const iterator& y)requires totally_ordered && three_way_comparable; friend constexpr iterator operator+(iterator i, difference_type n)requires advanceable; friend constexpr iterator operator+(difference_type n, iterator i)requires advanceable; friend constexpr iterator operator-(iterator i, difference_type n)requires advanceable; friend constexpr difference_type operator-(const iterator& x, const iterator& y)requires advanceable; };}

1

#

iterator​::​iterator_concept is defined as follows:

• (1.1)

  If W models advanceable, theniterator_concept is random_access_iterator_tag.

• (1.2)

  Otherwise, if W models decrementable, theniterator_concept is bidirectional_iterator_tag.

• (1.3)

  Otherwise, if W models incrementable, theniterator_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](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]")<W>;

8

#

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

🔗

constexpr iterator& operator--() requires [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;

9

#

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

🔗

constexpr iterator operator--(int) requires [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;

10

#

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

🔗

constexpr iterator& operator+=(difference_type n) requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;

11

#

Effects: Equivalent to:if constexpr (is-integer-like && !is-signed-integer-like) {if (n >= difference_type(0))value_ += static_cast(n); elsevalue_ -= static_cast(-n);} else {value_ += n;}return *this;

🔗

constexpr iterator& operator-=(difference_type n) requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;

12

#

Effects: Equivalent to:if constexpr (is-integer-like && !is-signed-integer-like) {if (n >= difference_type(0))value_ -= static_cast(n); elsevalue_ += static_cast(-n);} else {value_ -= n;}return *this;

🔗

constexpr W operator[](difference_type n) const requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;

13

#

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

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y) requires [equality_comparable](concept.equalitycomparable#concept:equality_comparable "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")<W>;

14

#

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

🔗

friend constexpr bool operator<(const iterator& x, const iterator& y) requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;

15

#

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

🔗

friend constexpr bool operator>(const iterator& x, const iterator& y) requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;

16

#

Effects: Equivalent to: return y < x;

🔗

friend constexpr bool operator<=(const iterator& x, const iterator& y) requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;

17

#

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

🔗

friend constexpr bool operator>=(const iterator& x, const iterator& y) requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;

18

#

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

🔗

friend constexpr auto operator<=>(const iterator& x, const iterator& y) requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W> && [three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<W>;

19

#

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

🔗

friend constexpr iterator operator+(iterator i, difference_type n) requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;

20

#

Effects: Equivalent to:i += n;return i;

🔗

friend constexpr iterator operator+(difference_type n, iterator i) requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;

21

#

Effects: Equivalent to: return i + n;

🔗

friend constexpr iterator operator-(iterator i, difference_type n) requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;

22

#

Effects: Equivalent to:i -= n;return i;

🔗

friend constexpr difference_type operator-(const iterator& x, const iterator& y) requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;

23

#

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

25.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> && copyablestruct iota_view<W, Bound>::sentinel {private: Bound bound_ = Bound(); // exposition onlypublic:sentinel() = default; constexpr explicit sentinel(Bound bound); friend constexpr bool operator==(const iterator& x, const sentinel& y); friend constexpr iter_difference_t operator-(const iterator& x, const sentinel& y)requires sized_sentinel_for<Bound, W>; friend constexpr iter_difference_t 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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>;

4

#

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

25.6.5 Repeat view [range.repeat]

25.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 torepeat_view<decay_t<decltype((E))>>(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]

25.6.5.2 Class template repeat_view [range.repeat.view]

namespace std::ranges {templateconcept integer-like-with-usable-difference-type = // exposition only**is-signed-integer-like || (is-integer-like && weakly_incrementable); template<move_constructible T, semiregular Bound = unreachable_sentinel_t>requires (is_object_v && same_as<T, remove_cv_t> &&(integer-like-with-usable-difference-type ||same_as<Bound, unreachable_sentinel_t>))class repeat_view : public view_interface<repeat_view<T, Bound>> {private:// [range.repeat.iterator], class repeat_view​::​iteratorstruct iterator; // exposition only**movable-box value_; // exposition only, see [range.move.wrap] Bound bound_ = Bound(); // exposition onlypublic: repeat_view() requires default_initializable = default; constexpr explicit repeat_view(const T& value, Bound bound = Bound())requires copy_constructible; 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 (<Bound, unreachable_sentinel_t>); constexpr unreachable_sentinel_t end() const noexcept; constexpr auto size() const requires (<Bound, unreachable_sentinel_t>); }; template<class T, class Bound = unreachable_sentinel_t> repeat_view(T, Bound = Bound()) -> repeat_view<T, Bound>;}

🔗

constexpr explicit repeat_view(const T& value, Bound bound = Bound()) requires [copy_constructible](concept.copyconstructible#concept:copy_constructible "18.4.14 Concept copy_­constructible [concept.copyconstructible]")<T>;

1

#

Preconditions: If Bound is not unreachable_sentinel_t,bound ≥ 0.

2

#

Effects: Initializes value_ with value andbound_ 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) andbound_ with bound.

🔗

template<class... TArgs, class... BoundArgs> requires [constructible_from](concept.constructible#concept:constructible_from "18.4.11 Concept constructible_­from [concept.constructible]")<T, TArgs...> && [constructible_from](concept.constructible#concept:constructible_from "18.4.11 Concept constructible_­from [concept.constructible]")<Bound, BoundArgs...> constexpr explicit repeat_view(piecewise_construct_t, tuple<TArgs...> value_args, tuple<BoundArgs...> bound_args = tuple<>{});

5

#

Effects: Initializes value_ withmake_from_tuple(std​::​move(value_args)) and initializes bound_ withmake_from_tuple(std​::​move(bound_args)).

The behavior is undefined ifBound is not unreachable_sentinel_t andbound_ is negative.

🔗

constexpr iterator begin() const;

6

#

Effects: Equivalent to: return iterator(addressof(**value_*));

🔗

constexpr iterator end() const requires (![same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<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](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<Bound, unreachable_sentinel_t>);

9

#

Effects: Equivalent to: return to-unsigned-like(bound_);

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

🔗

namespace std::ranges {template<move_constructible T, semiregular Bound>requires (is_object_v && same_as<T, remove_cv_t> &&(integer-like-with-usable-difference-type ||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 onlyconstexpr explicit iterator(const T* value, index-type b = index-type()); // exposition onlypublic: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 andcurrent_ 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,current_>0.

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,current_+n≥0.

11

#

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

🔗

constexpr iterator& operator-=(difference_type n);

12

#

Preconditions: If Bound is not unreachable_sentinel_t,current_−n≥0.

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

25.6.6 Istream view [range.istream]

25.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 denotes a customization point object ([customization.point.object]).

Given a type T and a subexpression E of type U, if U modelsderived_from<basic_istream<typename U​::​char_type,typename U​::​traits_type>>, then the expression views​::​istream(E) is expression-equivalent tobasic_istream_view<T, typename U​::​char_type,typename U​::​traits_type>(E); otherwise, views​::​istream(E) is ill-formed.

3

#

[Example 1: auto ints = istringstream{"0 1 2 3 4"}; ranges::copy(views::istream(ints), ostream_iterator{cout, "-"});// prints 0-1-2-3-4- — end example]

25.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 onlyrequires(basic_istream<CharT, Traits>& is, Val& t) { is >> t; }; template<movable Val, class CharT, class Traits = char_traits>requires default_initializable &&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​::​iteratorstruct 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;

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

🔗

namespace std::ranges {template<movable Val, class CharT, class Traits>requires default_initializable &&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_;