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

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 de différence pour les types d'itérateurs et les types de type entier .

• Si I n'est pas un type entier, ou s'il s'agit d'un type entier 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 à celle de I si un tel type existe.
• Sinon, I est l'un des types entiers les plus larges, et /*iota-diff-t*/ < I > est un type de type entier signé non spécifié de largeur non inférieure à celle 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 les opérateurs pré- et post- operator -- pour ce 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 - entre le type et ses différents types 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);
}