std::ranges::iota_view<W, Bound>::iterator - cppreference.com (original) (raw)

1. Calculates the difference type for both iterator types and integer-like types.

• If I is not an integral type, or if it is an integral type and sizeof(std::iter_difference_t<I>) is greater than sizeof(I), then /*iota-diff-t*/<I> is std::iter_difference_t<I>.
• Otherwise, /*iota-diff-t*/<I> is a signed integer type of width greater than the width of I if such a type exists.
• Otherwise, I is one of the widest integral types, and /*iota-diff-t*/<I> is an unspecified signed-integer-like type of width not less than the width of I. It is unspecified whether /*iota-diff-t*/<I> models weakly_incrementable in this case.

1. Specifies that a type is incrementable, and pre- and post- operator-- for the type have common meaning.

2. Specifies that a type is both _[decrementable](iterator.html#decrementable)_ and totally_ordered, and operator+=, operator-=, operator+, and operator- among the type and its different type have common meaning.

/*iterator*/ models

• random_access_iterator if W models _[advanceable](iterator.html#advanceable)_ (4),
• bidirectional_iterator if W models _[decrementable](iterator.html#decrementable)_ (3),
• forward_iterator if W models incrementable, and
• input_iterator otherwise.

However, it only satisfies LegacyInputIterator if W models incrementable, and does not satisfy LegacyInputIterator otherwise.

Contents

• 1 Semantic requirements
• 2 Nested types
  • 2.1 Determining the iterator concept
• 3 Data members
• 4 Member functions
• 5 std::ranges::iota_view::iterator::iterator
• 6 std::ranges::iota_view::iterator::operator*
  • 6.1 Example
• 7 std::ranges::iota_view::iterator::operator++
  • 7.1 Example
• 8 std::ranges::iota_view::iterator::operator--
  • 8.1 Example
• 9 std::ranges::iota_view::iterator::operator+=
  • 9.1 Example
• 10 std::ranges::iota_view::iterator::operator-=
  • 10.1 Example
• 11 std::ranges::iota_view::iterator::operator[]
  • 11.1 Example
  • 11.2 Non-member functions
• 12 operator==, <, >, <=, >=, <=>(std::ranges::iota_view::iterator)
• 13 operator+(std::ranges::iota_view::iterator)
• 14 operator-(std::ranges::iota_view::iterator)
  • 14.1 Defect reports

[edit] Semantic requirements

1. Type I models _decrementable_ only if I satisfies _decrementable_ and all concepts it subsumes are modeled, and given equal objects a and b of type I:

• If a and b are in the domain of both pre- and post- operator-- (i.e. they are decrementable), then the following are all true:
  • std::addressof(--a) == std::addressof(a),
  • bool(a-- == b),
  • bool(((void)a--, a) == --b),
  • bool(++(--a) == b).
• If a and b are in the domain of both pre- and post- operator++ (i.e. they are incrementable), then bool(--(++a) == b) is true.

1. Let D denote /*iota-diff-t*/<I>. Type I models _[advanceable](iterator.html#advanceable)_ only if I satisfies _[advanceable](iterator.html#advanceable)_ and all concepts it subsumes are modeled, and given

• objects a and b of type I and
• value n of type D,

such that b is reachable from a after n applications of ++a, all following conditions are satisfied:

• (a += n) is equal to b.
• std::addressof(a += n) is equal to std::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.
• std::addressof(b -= n) is equal to std::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.

[edit] Nested types

[edit] Determining the iterator concept

iterator_concept is defined as follows:

• If W models _[advanceable](iterator.html#advanceable)_, iterator_concept denotes std::random_access_iterator_tag.
• Otherwise, if W models _[decrementable](iterator.html#decrementable)_, iterator_concept denotes std::bidirectional_iterator_tag.
• Otherwise, if W models incrementable, iterator_concept denotes std::forward_iterator_tag.
• Otherwise, iterator_concept denotes std::input_iterator_tag.

[edit] Data members

[edit] Member functions

std::ranges::iota_view::iterator::iterator

| | (1) | (since C++20) | | | --------------------------------------------- | ------------- | ------------- | | constexpr explicit /*iterator*/( W value ); | (2) | (since C++20) |

1. Value initializes _[value](iterator.html#value)_.

2. Initializes _[value](iterator.html#value)_ with value.

std::ranges::iota_view::iterator::operator*

Returns _[value](iterator.html#value)_.

Example

#include #include   int main() { auto it{std::views::iota(6, 9).begin()}; const int& r = *it; // binds with temporary assert(*it == 6 and r == 6); ++it; assert(*it == 7 and r == 6); }

std::ranges::iota_view::iterator::operator++

1. Equivalent to ++_[value](iterator.html#value)_ ; return *this;.

2. Equivalent to ++_[value](iterator.html#value)_ ;.

3. Equivalent to auto tmp = *this; ++_[value](iterator.html#value)_ ; return tmp;.

Example

std::ranges::iota_view::iterator::operator--

1. Equivalent to --_[value](iterator.html#value)_ ; return *this;.

2. Equivalent to auto tmp = *this; --_[value](iterator.html#value)_ ; return tmp;.

Example

std::ranges::iota_view::iterator::operator+=

| constexpr /*iterator*/& operator+=( difference_type n ) requires /*advanceable*/<W>; | | (since C++20) | | ------------------------------------------------------------------------------------------- | | ------------- |

Updates _[value](iterator.html#value)_ and returns *this:

• If W is an unsigned-integer-like type:
  • If n is non-negative, performs _[value](iterator.html#value)_ += static_cast<W>(n).
  • Otherwise, performs _[value](iterator.html#value)_ -= static_cast<W>(-n).
• Otherwise, performs _[value](iterator.html#value)_ += n.

Example

#include #include   int main() { auto it{std::views::iota(5).begin()}; assert(it == 5); assert((it += 3) == 8); }

std::ranges::iota_view::iterator::operator-=

| constexpr /*iterator*/& operator-=( difference_type n ) requires /*advanceable*/<W>; | | (since C++20) | | -------------------------------------------------------------------------------------------- | | ------------- |

Updates _[value](iterator.html#value)_ and returns *this:

• If W is an unsigned-integer-like type:
  • If n is non-negative, performs _[value](iterator.html#value)_ -= static_cast<W>(n).
  • Otherwise, performs _[value](iterator.html#value)_ += static_cast<W>(-n).
• Otherwise, performs _[value](iterator.html#value)_ -= n.

Example

#include #include   int main() { auto it{std::views::iota(6).begin()}; assert(it == 6); assert((it -= -3) == 9); }

std::ranges::iota_view::iterator::operator[]

| constexpr W operator[]( difference_type n ) const requires /*advanceable*/<W>; | | (since C++20) | | ------------------------------------------------------------------------------------ | | ------------- |

Returns W(_[value](iterator.html#value)_ + n).

Example

#include #include   int main() { auto it{std::views::iota(6).begin()}; assert(it == 6); assert((it + 3) == 9); }

[edit] Non-member functions

operator==, <, >, <=, >=, <=>(std::ranges::iota_view::iterator)

1. Returns y < x.

2. Returns !(y < x).

3. Returns !(x < y).

The != operator is synthesized from operator==.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when iterator is an associated class of the arguments.

operator+(std::ranges::iota_view::iterator)

Equivalent to i += n; return i;.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when iterator is an associated class of the arguments.

operator-(std::ranges::iota_view::iterator)

1. Equivalent to i -= n; return i;.

2. Let D be difference_type:

• If W is an integer-like type:
  • If W is signed-integer-like, returns D(D(x._[value](iterator.html#value)_ ) - D(y._[value](iterator.html#value)_ )).
  • Otherwise, returns y._[value](iterator.html#value)_ > x._[value](iterator.html#value)_ ? D(-D(y._[value](iterator.html#value)_ - x._[value](iterator.html#value)_ )) : D(x._[value](iterator.html#value)_ - y._[value](iterator.html#value)_ ).
• Otherwise, returns x._[value](iterator.html#value)_ - y._[value](iterator.html#value)_.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when iterator is an associated class of the arguments.

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.