Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::iota_view
Member functions
Deduction guides
Nested classes
Iterator
Helper concepts
Member types
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
struct /*iterator*/ ;
(1) ( 설명 전용* )
헬퍼 앨리어스 템플릿
template < class I >
using /*iota-diff-t*/ = /* 아래 참조 */ ;
(2) ( 설명 전용* )
헬퍼 개념들
template < class I >

concept /*감소 가능*/ =
std:: incrementable < I > && requires ( I i ) {
{ -- i } - > std:: same_as < I & > ;
{ i -- } - > std:: same_as < I > ;

} ;
(3) ( 설명 전용* )
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 >> ;

} ;
(4) ( 설명 전용* )
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 - 연산자들이 해당 타입과 다른 타입 간에 일반적인 의미를 가짐을 명시합니다.

/*iterator*/ 모델

그러나 이는 LegacyInputIterator 요구 사항을 만족시키는 경우는 W 가 incrementable 개념을 모델링할 때뿐이며, 그렇지 않은 경우에는 LegacyInputIterator 를 만족시키지 않습니다.

목차

의미론적 요구사항

3) 타입 I 가 decrementable 을 모델링한다는 것은 I 가 decrementable 을 만족하고 그것이 포함하는 모든 개념들이 모델링되었음을 의미하며, 타입 I 의 동등한 객체 a 와 b 가 주어졌을 때:
  • 만약 a 와 b 가 전위 및 후위 operator -- 의 정의역 내에 있다면(즉, 감소 가능하다면), 다음은 모두 true 입니다:
  • 만약 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 입니다.

중첩 타입

유형 정의
iterator_concept iterator tag , 아래 참조
iterator_category
( W 가 incrementable 를 모델링하고
/*iota-diff-t*/ < W > 가 정수형인 경우에만 존재) 		std::input_iterator_tag
value_type W
difference_type /*iota-diff-t*/ < W >

반복자 개념 결정

iterator_concept 는 다음과 같이 정의됩니다:

데이터 멤버

멤버 정의
W value_ 현재 값
( 설명 전용 멤버 객체* )

멤버 함수

std::ranges::iota_view:: iterator :: iterator

/*iterator*/ ( ) requires std:: default_initializable < W > = default ;
(1) (since C++20)
constexpr explicit /*iterator*/ ( W value ) ;
(2) (since C++20)
1) value_ 를 값 초기화합니다.
2) value_ 를 value 로 초기화합니다.

std::ranges::iota_view:: iterator :: operator*

constexpr W operator * ( ) const
noexcept ( std:: is_nothrow_copy_constructible_v < W > ) ;
(C++20 이후)

value_ 을 반환합니다.

예제

이 코드 실행 
#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);
}

std::ranges::iota_view:: iterator :: operator++

constexpr /*iterator*/ & operator ++ ( ) ;
(1) (C++20 이후)
constexpr void operator ++ ( int ) ;
(2) (C++20 이후)
constexpr /*iterator*/ operator ++ ( int ) requires std:: incrementable < W > ;
(3) (C++20 이후)
1) 다음 코드와 동등함: ++ value_  ; return * this ; .
2) 다음 코드와 동등함: ++ value_  ; .
3) 다음 코드와 동등함: auto tmp = * this ; ++ value_  ; return tmp ; .

예제

이 코드 실행 
#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);
}

std::ranges::iota_view:: iterator :: operator--

constexpr /*iterator*/ & operator -- ( ) requires /*decrementable*/ < W > ;
(1) (C++20 이후)
constexpr /*iterator*/ operator -- ( int ) requires /*decrementable*/ < W > ;
(2) (C++20 이후)
1) 다음 코드와 동등함: -- value_  ; return * this ; .
2) 다음 코드와 동등함: auto tmp = * this ; -- value_  ; return tmp ; .

예제

이 코드 실행 
#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);
}

std::ranges::iota_view:: iterator :: operator+=

constexpr /*iterator*/ & operator + = ( difference_type n )
requires /*advanceable*/ < W > ;
(C++20 이후)

value_ 를 갱신하고 * this 를 반환합니다:

예제

이 코드 실행 
#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(5).begin()};
    assert(*it == 5);
    assert(*(it += 3) == 8);
}

std::ranges::iota_view:: iterator :: operator-=

constexpr /*iterator*/ & operator - = ( difference_type n )
requires /*advanceable*/ < W > ;
(C++20 이후)

value_ 를 갱신하고 * this 를 반환합니다:

  • W 가 unsigned-integer-like type 인 경우:
    • n 이 음수가 아닌 경우, value_ - = static_cast < W > ( n ) 을 수행합니다.
    • 그렇지 않은 경우, value_ + = static_cast < W > ( - n ) 을 수행합니다.
  • 그렇지 않은 경우, value_ - = n 을 수행합니다.

예제

이 코드 실행 
#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it -= -3) == 9);
}

std::ranges::iota_view:: iterator :: operator[]

constexpr W operator [ ] ( difference_type n ) const
requires /*advanceable*/ < W > ;
(C++20 이후)

W ( value_ + n ) 를 반환합니다.

예제

이 코드 실행 
#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it + 3) == 9);
}

비멤버 함수

operator==, <, >, <=, >=, <=> (std::ranges::iota_view:: iterator )

friend constexpr bool operator ==

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: equality_comparable < W > ;
(1) (C++20부터)
friend constexpr bool operator <

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: totally_ordered < W > ;
(2) (C++20부터)
friend constexpr bool operator >

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: totally_ordered < W > ;
(3) (C++20부터)
friend constexpr bool operator <=

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: totally_ordered < W > ;
(4) (C++20부터)
friend constexpr bool operator >=

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: totally_ordered < W > ;
(5) (C++20부터)
friend constexpr bool operator <=>

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: totally_ordered < W > && std:: three_way_comparable < W > ;
(6) (C++20부터)
1) 반환값 x. value_ == y. value_ .
2) 반환 x. value_ < y. value_ .
3) 반환값 y < x .
4) 반환값 ! ( y < x ) .
5) 반환값 ! ( x < y ) .
6) 반환값 x. value_ <=> y. value_ .

!= 연산자는 합성된 operator== 로부터 생성됩니다.

이 함수들은 일반적인 비한정 이름 탐색 또는 한정 이름 탐색 으로는 보이지 않으며, iterator 가 인자들의 연관 클래스일 때에만 인자 의존 이름 탐색 을 통해서만 찾을 수 있습니다.

operator+ (std::ranges::iota_view:: iterator )

friend constexpr /*iterator*/ operator +

( /*iterator*/ i, difference_type n )

requires /*advanceable*/ < W > ;
(1) (C++20 이후)
friend constexpr /*iterator*/ operator +

( difference_type n, /*iterator*/ i )

requires /*advanceable*/ < W > ;
(2) (C++20 이후)

다음 코드와 동등합니다: i + = n ; return i ; .

이 함수들은 일반적인 비한정 이름 검색 이나 한정 이름 검색 으로는 보이지 않으며, iterator 가 인자들의 연관 클래스일 때에만 인자 종속 이름 검색 에 의해 찾을 수 있습니다.

operator- (std::ranges::iota_view:: iterator )

friend constexpr /*iterator*/ operator -

( /*iterator*/ i, difference_type n )

requires /*advanceable*/ < W > ;
(1) (C++20 이후)
friend constexpr difference_type operator -

( const /*iterator*/ & x, const /*iterator*/ & y )

requires /*advanceable*/ < W > ;
(2) (C++20 이후)
1) i - = n ; return i ; 와 동등합니다.
2) D 를 difference_type 이라고 할 때:

이 함수들은 일반적인 비한정 이름 검색 이나 한정 이름 검색 으로는 보이지 않으며, 인수의 연관 클래스로 iterator 가 있을 때만 인수 종속적 검색 에 의해 찾을 수 있습니다.

결함 보고서

다음 동작 변경 결함 보고서는 이전에 게시된 C++ 표준에 소급 적용되었습니다.

DR 적용 대상 게시된 동작 올바른 동작
P2259R1 C++20 멤버 iterator_category 가 항상 정의됨 W 가 incrementable 를 만족할 때만 정의됨
LWG 3580 C++20 operator + 와 operator - 의 본문이 암시적 이동 을 배제함 암시적 이동에 적합하도록 수정됨