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 — это тип итераторов, возвращаемых begin() и end() из ranges::iota_view<W, Bound>.

2) Вычисляет тип разности как для типов итераторов, так и для целочисленных типов.

• Если I не является целочисленным типом или является целочисленным типом и sizeof(std::iter_difference_t<I>) больше sizeof(I), то /*iota-diff-t*/<I> — это std::iter_difference_t<I>.
• В противном случае /*iota-diff-t*/<I> — это знаковый целочисленный тип шириной больше, чем ширина I, если такой тип существует.
• В противном случае I — это один из самых широких целочисленных типов, а /*iota-diff-t*/<I> — это неопределённый знакоподобный целочисленный тип шириной не менее ширины I. Не указано, моделирует ли /*iota-diff-t*/<I> условие weakly_incrementable в этом случае.

3) Указывает, что тип является incrementable, а префиксный и постфиксный operator-- для этого типа имеют общепринятый смысл.

4) Указывает, что тип является одновременно decrementable и totally_ordered, а операции operator+=, operator-=, operator+ и operator- для этого типа и его разных типов имеют общепринятый смысл.

3) Тип I моделирует decrementable только если I удовлетворяет decrementable и все подразумеваемые концепты моделируются, и для равных объектов a и b типа I :

• Если a и b находятся в области определения как пре-, так и пост- operator -- (т.е. они декрементируемы), тогда все следующие выражения true :
  • std:: addressof ( -- a ) == std:: addressof ( a ) ,
  • bool ( a -- == b ) ,
  • bool ( ( ( void ) a -- , a ) == -- b ) ,
  • bool ( ++ ( -- a ) == b ) .
• Если a и b находятся в области определения как пре-, так и пост- operator ++ (т.е. они инкрементируемы), тогда bool ( -- ( ++ a ) == b ) является 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

• объекты a и b типа I и
• значение n типа D ,

так что b достижим из a после n применений ++ a , выполняются все следующие условия:

• ( a + = n ) равно b .
• std:: addressof ( a + = n ) равен std:: addressof ( a ) .
• I ( a + n ) равно ( a + = n ) .
• Для любых двух положительных значений x и y типа D , если I ( a + D ( x + y ) ) корректно определено, тогда I ( a + D ( x + y ) ) равно I ( I ( a + x ) + y ) .
• I ( a + D ( 0 ) ) равно a .
• Если I ( a + D ( n - 1 ) ) корректно определено, тогда I ( a + n ) равно [ ] ( I c ) { return ++ c ; } ( I ( a + D ( n - 1 ) ) ) .
• ( b + = - n ) равно a .
• ( b - = n ) равно a .
• std:: addressof ( b - = n ) равен std:: addressof ( b ) .
• I ( b - n ) равно ( b - = n ) .
• D ( b - a ) равно n .
• D ( a - b ) равно D ( - n ) .
• bool ( a <= b ) является true .

#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6, 9).begin()};
    const int& r = *it; // связывается с временным объектом
    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);
}