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 을 만족하고 그것이 포함하는 모든 개념들이 모델링되었음을 의미하며, 타입 I 의 동등한 객체 a 와 b 가 주어졌을 때:

• 만약 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

• 타입 I 의 객체 a 와 b , 그리고
• 타입 D 의 값 n ,

b 가 a 로부터 n 번의 ++ a 적용 후 도달 가능하도록, 다음 조건들이 모두 충족됩니다:

• ( a + = n ) 는 b 와 같습니다.
• std:: addressof ( a + = n ) 는 std:: addressof ( a ) 와 같습니다.
• I ( a + n ) 는 ( a + = n ) 와 같습니다.
• 타입 D 의 임의의 두 양수 값 x 와 y 에 대해, 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);
}