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

struct /*iterator*/;

template< class I >
using /*iota-diff-t*/ = /* see below */;

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

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

1) ranges::iota_view<W, Bound>::iterator est le type des itérateurs retournés par begin() et end() de ranges::iota_view<W, Bound>.

2) Calcule le type différence pour les deux types d'itérateurs et les integer-like types.

• Si I n'est pas un type intégral, ou si c'est un type intégral et que sizeof(std::iter_difference_t<I>) est supérieur à sizeof(I), alors /*iota-diff-t*/<I> est std::iter_difference_t<I>.
• Sinon, /*iota-diff-t*/<I> est un type entier signé de largeur supérieure à la largeur de I si un tel type existe.
• Sinon, I est l'un des types intégraux les plus larges, et /*iota-diff-t*/<I> est un type signed-integer-like type non spécifié de largeur au moins égale à la largeur de I. Il n'est pas spécifié si /*iota-diff-t*/<I> modélise weakly_incrementable dans ce cas.

3) Spécifie qu'un type est incrementable, et que pré- et post- operator-- pour le type ont une signification commune.

4) Spécifie qu'un type est à la fois decrementable et totally_ordered, et que operator+=, operator-=, operator+ et operator- parmi le type et son type différent ont une signification commune.

3) Le type I modélise decrementable seulement si I satisfait decrementable et tous les concepts qu'il subsume sont modélisés, et étant donné des objets égaux a et b de type I :

• Si a et b sont dans le domaine des opérateurs pré- et post- operator -- (c'est-à-dire qu'ils sont décrémentables), alors toutes les expressions suivantes sont true :
  • std:: addressof ( -- a ) == std:: addressof ( a ) ,
  • bool ( a -- == b ) ,
  • bool ( ( ( void ) a -- , a ) == -- b ) ,
  • bool ( ++ ( -- a ) == b ) .
• Si a et b sont dans le domaine des opérateurs pré- et post- operator ++ (c'est-à-dire qu'ils sont incrémentables), alors bool ( -- ( ++ a ) == b ) est 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

• objets a et b de type I et
• valeur n de type D ,

tel que b soit accessible depuis a après n applications de ++ a , toutes les conditions suivantes sont satisfaites :

• ( a + = n ) est égal à b .
• std:: addressof ( a + = n ) est égal à std:: addressof ( a ) .
• I ( a + n ) est égal à ( a + = n ) .
• Pour deux valeurs positives quelconques x et y de type D , si I ( a + D ( x + y ) ) est bien défini, alors I ( a + D ( x + y ) ) est égal à I ( I ( a + x ) + y ) .
• I ( a + D ( 0 ) ) est égal à a .
• Si I ( a + D ( n - 1 ) ) est bien défini, alors I ( a + n ) est égal à [ ] ( I c ) { return ++ c ; } ( I ( a + D ( n - 1 ) ) ) .
• ( b + = - n ) est égal à a .
• ( b - = n ) est égal à a .
• std:: addressof ( b - = n ) est égal à std:: addressof ( b ) .
• I ( b - n ) est égal à ( b - = n ) .
• D ( b - a ) est égal à n .
• D ( a - b ) est égal à D ( - n ) .
• bool ( a <= b ) est true .

#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6, 9).begin()};
    const int& r = *it; // se lie avec un temporaire
    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);
}