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

From cppreference.com
C++
Ranges library
Range adaptors
std::ranges::iota_view
Member functions
Deduction guides
Nested classes
Iterator
Helper concepts
Member types
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
struct /*iterator*/ ;
(1) ( exposition only* )
Helper alias templates
template < class I >
using /*iota-diff-t*/ = /* see below */ ;
(2) ( exposition only* )
Helper concepts
template < class I >

concept /*decrementable*/ =
std:: incrementable < I > && requires ( I i ) {
{ -- i } - > std:: same_as < I & > ;
{ i -- } - > std:: same_as < I > ;

} ;
(3) ( exposition only* )
template < class I >

concept /*advanceable*/ =
/*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) ( exposition only* )
1) ranges:: iota_view < W, Bound > :: iterator is the type of the iterators returned by begin() and end() of ranges:: iota_view < W, Bound > .
2) 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.
3) Specifies that a type is incrementable , and pre- and post- operator -- for the type have common meaning.
4) 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.

/*iterator*/ models

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

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 :
  • 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 .
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 .

Nested types

Type Definition
iterator_concept an iterator tag , see below
iterator_category
(only present if W models incrementable and
/*iota-diff-t*/ < W > is an integral type) 		std::input_iterator_tag
value_type W
difference_type /*iota-diff-t*/ < W >

Determining the iterator concept

iterator_concept is defined as follows:

Data members

Member Definition
W value_ the current value
( exposition-only member object* )

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 value_ .
2) Initializes value_ with value .

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

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

Returns value_ .

Example

Run this code 
#include <cassert>
#include <ranges>
 
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++

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

Example

Run this code 
#include <cassert>
#include <ranges>
 
int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*++it == 9);
    assert(*it++ == 9);
    assert(*it == 10);
}

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

Example

Run this code 
#include <cassert>
#include <ranges>
 
int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*--it == 7);
    assert(*it-- == 7);
    assert(*it == 6);
}

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

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

Updates value_ and returns * this :

Example

Run this code 
#include <cassert>
#include <ranges>
 
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_ and returns * this :

Example

Run this code 
#include <cassert>
#include <ranges>
 
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_ + n ) .

Example

Run this code 
#include <cassert>
#include <ranges>
 
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it + 3) == 9);
}

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) Returns x. value_ == y. value_ .
2) Returns x. value_ < y. value_ .
3) Returns y < x .
4) Returns ! ( y < x ) .
5) Returns ! ( x < y ) .
6) Returns 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 :

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
Retrieved from " https://en.cppreference.com/mwiki/index.php?title=cpp/ranges/iota_view/iterator&oldid=176931 "