std::ranges::iota_view<W, Bound>::iterator

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

Ranges library

Range access
begin cbegin end cend	rbegin crbegin rend crend	size ssize data cdata	empty
Range conversions
to (C++23)
Range primitives
range_size_trange_difference_t range_value_t	range_reference_trange_const_reference_trange_rvalue_reference_t   (C++23)	iterator_tconst_iterator_tsentinel_t (C++23)
Dangling iterator handling
dangling	borrowed_iterator_t	borrowed_subrange_t
Range concepts
range borrowed_range    sized_range constant_range (C++23)	common_range view viewable_range	input_range output_range forward_range	bidirectional_range random_access_range contiguous_range
Views
view_interface	subrange
Factories
empty_viewviews::empty iota_viewviews::iota	single_viewviews::single basic_istream_viewviews::istream	repeat_viewviews::repeat (C++23)(C++23)
Adaptors
ref_view views::all_tviews::all common_viewviews::common owning_view views::counted reverse_viewviews::reverse zip_viewviews::zip (C++23)(C++23) as_const_viewviews::as_const (C++23)(C++23) as_rvalue_viewviews::as_rvalue (C++23)(C++23)	take_viewviews::take take_while_viewviews::take_while drop_viewviews::drop drop_while_viewviews::drop_while zip_transform_viewviews::zip_transform (C++23)(C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23)   cartesian_product_viewviews::cartesian_product (C++23)(C++23)	elements_viewviews::elements keys_viewviews::keys values_viewviews::values transform_viewviews::transform adjacent_viewviews::adjacent (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) stride_viewviews::stride (C++23)(C++23)	filter_viewviews::filter join_viewviews::join split_viewviews::split lazy_split_viewviews::lazy_split join_with_viewviews::join_with (C++23)(C++23) chunk_viewviews::chunk (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23)
Range adaptor objects
Range adaptor closure objects
Helper items
copyable-box	simple-view

 

std::ranges::iota_view

Member functions

iota_view::iota_view (C++20)

iota_view::begin (C++20)

iota_view::end (C++20)

iota_view::size (C++20)

Deduction guides (C++20)

Helper concepts

decrementable (C++20)

advanceable (C++20)

Iterator

iota_view::iterator::iterator (C++20)

iota_view::iterator::operator* (C++20)

iota_view::iterator::operator[] (C++20)

iota_view::iterator::operator++ iota_view::iterator::operator++(int) (C++20)(C++20)

iota_view::iterator::operator-- iota_view::iterator::operator--(int) (C++20)(C++20)

iota_view::iterator::operator+= (C++20)

iota_view::iterator::operator-= (C++20)

operator==(iota_view::iterator) operator<(iota_view::iterator) operator>(iota_view::iterator) operator<=(iota_view::iterator) operator>=(iota_view::iterator) operator<=>(iota_view::iterator) (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

operator+(iota_view::iterator) (C++20)

operator-(iota_view::iterator) (C++20)

Sentinel

iota_view::sentinel::sentinel (C++20)

operator==(iota_view::iterator,iota_view::sentinel) (C++20)

operator-(iota_view::iterator,iota_view::sentinel) (C++20)

 

struct /*iterator*/;	(1)	(since C++20)
Helper alias templates
template< class I > using /*iota-diff-t*/ = /* see below */;  // exposition only	(2)	(since C++20)
Helper concepts
template< class I > concept /*decrementable*/ =               // exposition only   std::incrementable<I> && requires(I i) {     { --i } -> std::same_as<I&>;     { i-- } -> std::same_as<I>;   };	(3)	(since C++20)
template< class I > concept /*advanceable*/ =                 // exposition only   /*decrementable*/<I> && std::totally_ordered<I> &&   requires(I i, const I j, const /*iota-diff-t*/<I> n) {     { i += n } -> std::same_as<I&>;     { i -= n } -> std::same_as<I&>;     I(j + n);     I(n + j);     I(j - n);     { j - j } -> std::convertible_to</*iota-diff-t*/<I>>;   };	(4)	(since C++20)

1) The return type of iota_view::begin. The name of this class (shown here as /*iterator*/) is unspecified.

2) The exposition-only alias template iota-diff-t calculates the difference type for both iterator types and integer-like types.

• If W 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.

3) The exposition-only concept decrementable specifies that a type is incrementable, and pre- and post- operator-- for the type have common meaning.

4) The exposition-only concept advanceable specifies that a type is both decrementable and totally_ordered, and operator+=, operator-=, operator+, and operator- among the type and its different type have common meaning.

Semantic requirements

3) 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 are in the domain of both pre- and post- operator++ (i.e. they are incrementable), then bool(--(++a) == b) is true.

4) Let D denote /*iota-diff-t*/<I>. Type I models advanceable only if I satisfies 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.

Member types

Member type	Definition
iterator_concept	std::random_access_iterator_tag if W models advanceable. Otherwise, std::bidirectional_iterator_tag if W models decrementable. Otherise, std::forward_iterator_tag if W models incrementable. Otherwise, std::input_iterator_tag.
iterator_category	std::input_iterator_tag if W models incrementable. Otherwise, there is no member type iterator_category.
value_type	W
difference_type	/*iota-diff-t*/<W>

Notes: /*iterator*/ is

• a random_access_iterator if W models advanceable,
• a bidirectional_iterator if W models decrementable,
• a forward_iterator if W models incrementable, and
• an input_iterator otherwise.

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

Data members

Typical implementation of this iterator type holds one data member of type W (shown here as value_): the value used for dereferencing.

Member functions

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

/*iterator*/() requires std::default_initializable<W> = default;	(1)	(since C++20)
constexpr explicit /*iterator*/( W value );	(2)	(since C++20)

1) Value initializes the exposition-only data member value_ via its default member initializer (= W()).

2) Initializes the exposition-only data member value_ with value. This value will be returned by operator* and incremented by operator++.

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

constexpr W operator*() const     noexcept(std::is_nothrow_copy_constructible_v<W>);		(since C++20)

Returns the current value, by value (in other words, this is a read-only view).

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

constexpr /*iterator*/& operator++()	(1)	(since C++20)
constexpr void operator++(int)	(2)	(since C++20)
constexpr /*iterator*/ operator++(int) requires std::incrementable<W>;	(3)	(since C++20)

1) Equivalent to ++value_; return *this;.

2) Equivalent to ++value_;.

3) Equivalent to auto tmp = *this; ++value_; return tmp;.

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

constexpr /*iterator*/& operator--() requires /*decrementable*/<W>;	(1)	(since C++20)
constexpr /*iterator*/operator--(int) requires /*decrementable*/<W>;	(2)	(since C++20)

1) Equivalent to --value_; return *this;.

2) Equivalent to auto tmp = *this; --value_; return tmp;.

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

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

If W is unsigned-integer-like, performs value_ += static_cast<W>(n) if n is non-negative, value -= static_cast<W>(-n) otherwise, and then returns *this.

Otherwise, equivalent to value_ += n; return *this;.

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

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

If W is unsigned-integer-like, performs value_ -= static_cast<W>(n) if n is non-negative, or value += static_cast<W>(-n) otherwise, and then returns *this.

Otherwise, equivalent to value_ -= n; return *this;.

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

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

Equivalent to return W(value_ + n);.

Non-member functions

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

friend constexpr bool operator== (const /*iterator*/& x, const /*iterator*/& y)     requires std::equality_comparable<W>;	(1)	(since C++20)
friend constexpr bool operator<  (const /*iterator*/& x, const /*iterator*/& y)     requires std::totally_ordered<W>;	(2)	(since C++20)
friend constexpr bool operator>  (const /*iterator*/& x, const /*iterator*/& y)     requires std::totally_ordered<W>;	(3)	(since C++20)
friend constexpr bool operator<= (const /*iterator*/& x, const /*iterator*/& y)     requires std::totally_ordered<W>;	(4)	(since C++20)
friend constexpr bool operator>= (const /*iterator*/& x, const /*iterator*/& y)     requires std::totally_ordered<W>;	(5)	(since C++20)
friend constexpr bool operator<=>(const /*iterator*/& x, const /*iterator*/& y)     requires std::totally_ordered<W> && std::three_way_comparable<W>;	(6)	(since C++20)

1) Equivalent to return x.value_ == y.value_;.

2) Equivalent to return x.value_ < y.value_;.

3) Equivalent to return y < x;.

4) Equivalent to return !(y < x);.

5) Equivalent to return !(x < y);.

6) Equivalent to return x.value_ <=> y.value_;.

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)

friend constexpr /*iterator*/ operator+( /*iterator*/ i, difference_type n )     requires /*advanceable*/<W>;	(1)	(since C++20)
friend constexpr /*iterator*/ operator+( difference_type n, /*iterator*/ i )     requires /*advanceable*/<W>;	(2)	(since C++20)

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)

friend constexpr /*iterator*/ operator-( /*iterator*/ i, difference_type n )     requires /*advanceable*/<W>;	(1)	(since C++20)
friend constexpr difference_type operator-( const /*iterator*/& x,                                             const /*iterator*/& y )     requires /*advanceable*/<W>;	(2)	(since C++20)

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

2) Let D be difference_type.

• If W is signed-integer-like, equivalent to return D(D(x.value_) - D(y.value_));.
• Otherwise, if W is unsigned-integer-like, equivalent to return y.value_ > x.value_ ? D(-D(y.value_ - x.value_)) : D(x.value_ - y.value_);.
• Otherwise, equivalent to return x.value_ - y.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.

Defect reports

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

DR	Applied to	Behavior as published	Correct behavior
P2259R1	C++20	member iterator_category is always defined	defined only if W satisfies incrementable
LWG 3580	C++20	bodies of operator+ and operator- rule out implicit move	made suitable for implicit move