25 Ranges library [ranges]

25.6 Range factories [range.factories]

25.6.4 Iota view [range.iota]

25.6.4.1 Overview [range.iota.overview]

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

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<decay_t<decltype((E))>>(E) and iota_view(E, F), respectively.

[Example 1: for (int i : views::iota(1, 10)) cout << i << ' '; // prints 1 2 3 4 5 6 7 8 9 — end example]

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

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]

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

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

Let a and b be equal objects of type I.

I models decrementable only if

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

The exposition-only advanceable concept is equivalent to:

🔗

template<class I>
  concept advanceable =                 // 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);

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

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

Effects: Initializes value_ with value.

🔗

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

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

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

Effects: Initializes value_ with value and bound_ with bound.

🔗

constexpr explicit iota_view(iterator first, see below last);

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

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;

Effects: Equivalent to: return iterator{value_};

🔗

constexpr auto end() const;

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

🔗

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

Effects: Equivalent to: return iterator{bound_};

🔗

constexpr bool empty() const;

Effects: Equivalent to: return value_ == bound_;

🔗

constexpr auto size() const requires see below;

Effects: Equivalent to: if constexpr (is-integer-like<W> && is-integer-like<Bound>) return (value_ < 0) ? ((bound_ < 0) ? 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_);

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>

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

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.

[Note 1:

Overloads for iter_move and iter_swap are omitted intentionally.

— end note]

🔗

constexpr explicit iterator(W value);

Effects: Initializes value_ with value.

🔗

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

Effects: Equivalent to: return value_;

[Note 2:

The noexcept clause is needed by the default iter_move implementation.

— end note]

🔗

constexpr iterator& operator++();

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

🔗

constexpr void operator++(int);

Effects: Equivalent to ++*this.

🔗

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

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

🔗

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

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

🔗

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

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

🔗

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

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

🔗

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

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

🔗

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

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

🔗

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

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

🔗

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

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

🔗

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

Effects: Equivalent to: return y < x;

🔗

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

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

🔗

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

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

🔗

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

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

🔗

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

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

🔗

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

Effects: Equivalent to: return i + n;

🔗

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

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

🔗

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

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

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

Effects: Initializes bound_ with bound.

🔗

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

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

🔗

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

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

🔗

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

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