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

1) ranges:: iota_view < W, Bound > :: iterator es el tipo de los iteradores devueltos por begin() y end() de ranges:: iota_view < W, Bound > .

2) Calcula el tipo de diferencia para ambos tipos de iterador y tipos similares a enteros .

• Si I no es un tipo integral, o si es un tipo integral y sizeof ( std:: iter_difference_t < I > ) es mayor que sizeof ( I ) , entonces /*iota-diff-t*/ < I > es std:: iter_difference_t < I > .
• De lo contrario, /*iota-diff-t*/ < I > es un tipo entero con signo de ancho mayor que el ancho de I si tal tipo existe.
• De lo contrario, I es uno de los tipos integrales más anchos, y /*iota-diff-t*/ < I > es un tipo similar a entero con signo no especificado de ancho no menor que el ancho de I . No está especificado si /*iota-diff-t*/ < I > modela weakly_incrementable en este caso.

3) Especifica que un tipo es incrementable , y los operadores de pre- y post- operator -- para el tipo tienen el significado común.

4) Especifica que un tipo es tanto decrementable como totally_ordered , y que operator + = , operator - = , operator + , y operator - entre el tipo y sus diferentes tipos tienen significado común.

3) El tipo I modela decrementable solo si I satisface decrementable y todos los conceptos que subsume están modelados, y dados objetos iguales a y b de tipo I :

• Si a y b están en el dominio tanto del pre- como del post- operator -- (es decir, son decrementables), entonces todas las siguientes son true :
  • std:: addressof ( -- a ) == std:: addressof ( a ) ,
  • bool ( a -- == b ) ,
  • bool ( ( ( void ) a -- , a ) == -- b ) ,
  • bool ( ++ ( -- a ) == b ) .
• Si a y b están en el dominio tanto del pre- como del post- operator ++ (es decir, son incrementables), entonces bool ( -- ( ++ a ) == b ) es 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

• objetos a y b de tipo I y
• valor n de tipo D ,

tal que b es alcanzable desde a después de n aplicaciones de ++ a , se satisfacen todas las siguientes condiciones:

• ( a + = n ) es igual a b .
• std:: addressof ( a + = n ) es igual a std:: addressof ( a ) .
• I ( a + n ) es igual a ( a + = n ) .
• Para cualesquiera dos valores positivos x y y de tipo D , si I ( a + D ( x + y ) ) está bien definido, entonces I ( a + D ( x + y ) ) es igual a I ( I ( a + x ) + y ) .
• I ( a + D ( 0 ) ) es igual a a .
• Si I ( a + D ( n - 1 ) ) está bien definido, entonces I ( a + n ) es igual a [ ] ( I c ) { return ++ c ; } ( I ( a + D ( n - 1 ) ) ) .
• ( b + = - n ) es igual a a .
• ( b - = n ) es igual a a .
• std:: addressof ( b - = n ) es igual a std:: addressof ( b ) .
• I ( b - n ) es igual a ( b - = n ) .
• D ( b - a ) es igual a n .
• D ( a - b ) es igual a D ( - n ) .
• bool ( a <= b ) es true .

#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6, 9).begin()};
    const int& r = *it; // se enlaza con temporal
    assert(*it == 6 and r == 6);
    ++it;
    assert(*it == 7 and r == 6);
}

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

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

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

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

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