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

1) ranges:: iota_view < W, Bound > :: iterator является типом итераторов, возвращаемых begin() и end() для ranges:: iota_view < W, Bound > .

2) Вычисляет тип разности для обоих типов итераторов и integer-like types .

• Если 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 > является неуказанным signed-integer-like type с шириной не меньше ширины 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);
}