Namespaces
Variants

std::ranges:: lazy_split_view<V, Pattern>:: inner_iterator

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::lazy_split_view
template < bool Const >
struct /*inner_iterator*/ ;
(C++20 이후)
( 설명 전용* )

lazy_split_view:: outer_iterator :: value_type :: begin ( ) 의 반환 타입.

Const 는 outer_iterator 의 템플릿 인자와 일치합니다.

목차

멤버 타입

멤버 정의
Base maybe-const  < Const, V >
( 설명 전용 멤버 타입* )
iterator_concept
iterator_category
(조건부 존재)

다음 경우에만 존재: Base 가 forward_range 를 모델로 하는 경우.

value_type ranges:: range_value_t < Base >
difference_type ranges:: range_difference_t < Base >

데이터 멤버

멤버 설명
outer_iterator < Const > i_ (private) 부모 객체 lazy_split_view 의 기반 view 를 가리키는 반복자
( 설명 전용 멤버 객체* )
bool incremented_ (private) 이 객체에 대해 operator ++ 가 최소 한 번 이상 호출되었는지 나타내는 플래그
( 설명 전용 멤버 객체* )

멤버 함수

(constructor)
(C++20)
반복자를 생성함
(public member function)
base
(C++20)
기반 반복자를 반환함
(public member function)
operator*
(C++20)
현재 요소를 반환함
(public member function)
operator++ operator++ (int)
(C++20)
반복자를 전진시킴
(public member function)

멤버 함수

std::ranges::lazy_split_view:: inner_iterator :: inner_iterator

/*inner_iterator*/ ( ) = default ;
(1) (C++20 이후)
constexpr explicit /*inner_iterator*/ ( /*outer_iterator*/ < Const > i ) ;
(2) (C++20 이후)
1) 데이터 멤버 i_ 를 기본 멤버 초기화자(= /*outer_iterator*/ < Const > ( ) )를 통해 값 초기화합니다.
2) i_ 를 std :: move ( i ) 로 초기화합니다.

데이터 멤버 incremented_ 는 기본 멤버 초기화자에 의해 false 로 초기화됩니다.

std::ranges::lazy_split_view:: inner_iterator :: base

constexpr const ranges:: iterator_t < Base > & base ( ) const & noexcept ;
(1) (C++20 이후)
constexpr ranges:: iterator_t < Base > base ( ) &&
requires ranges:: forward_range < V > ;
(2) (C++20 이후)

기본 반복자의 복사본을 반환합니다.

1) 기본 반복자로부터 결과를 복사 생성합니다. return i_. /*cur*/ ( ) ; 와 동등합니다.
2) 기본 반복자로부터 결과를 이동 생성합니다. return std :: move ( i_. /*cur*/ ( ) ) ; 와 동등합니다.

std::ranges::lazy_split_view:: inner_iterator :: operator*

constexpr decltype ( auto ) operator * ( ) const ;
(C++20 이후)

기본 반복자가 가리키는 요소를 반환합니다.

다음 코드와 동등합니다: return * i_. /*cur*/ ( ) ; .

std::ranges::lazy_split_view:: inner_iterator :: operator++

constexpr /*inner_iterator*/ & operator ++ ( ) ;
(1) (C++20 이후)
constexpr decltype ( auto ) operator ++ ( int ) ;
(2) (C++20 이후)
1) 함수 본문은 다음과 동일함
incremented_ = true ;

if constexpr ( ! ranges:: forward_range < Base > )
{
if constexpr ( Pattern :: size ( ) == 0 )
return * this ;
}
++ i_. /*cur*/ ( ) ;

return * this ;
2) 다음과 동일함
if constexpr ( ranges:: forward_range < Base > )

{
auto tmp = * this ;
++* this ;
return tmp ;
}
else
++* this ; // 반환문 없음

비멤버 함수

operator==
(C++20)
반복자들 또는 반복자와 std::default_sentinel 을 비교합니다
(함수)
iter_move
(C++20)
기본 반복자를 역참조한 결과를 해당 rvalue 참조 타입으로 캐스팅합니다
(함수)
iter_swap
(C++20)
두 기본 반복자가 가리키는 객체들을 교환합니다
(함수)

operator== (std::ranges::split_view:: inner_iterator )

friend constexpr bool operator == ( const /*inner_iterator*/ & x,

const /*inner_iterator*/ & y )

requires forward_range < Base > ;
(1) (since C++20)
friend constexpr bool operator == ( const /*inner_iterator*/ & x,
std:: default_sentinel_t ) ;
(2) (since C++20)
1) 다음 코드와 동등함: return x. i_ . /*cur*/ ( ) == y. i_ . /*cur*/ ( ) ; .
2) 함수 본문은 다음 코드와 동등함: 
auto [pcur, pend] = ranges::subrange{x.i_.parent_->pattern_};
auto end = ranges::end(x.i_.parent_->base_);
if constexpr (/*tiny_range*/<Pattern>)
{
    const auto& cur = x.i_./*cur*/();
    if (cur == end)
        return true;
    if (pcur == pend)
        return x.incremented_;
    return *cur == *pcur;
}
else
{
    auto cur = x.i_./*cur*/();
    if (cur == end)
        return true;
    if (pcur == pend)
        return x.incremented_;
    do
    {
        if (*cur != *pcur)
            return false;
        if (++pcur == pend)
            return true;
    }
    while (++cur != end);
    return false;
}

!= 연산자는 합성된 연산자로, operator== 로부터 생성됨.

이 함수들은 일반적인 비한정 또는 한정 이름 검색으로는 보이지 않으며, std::ranges::split_view:: inner_iterator 가 인자들의 연관 클래스일 때만 인자 종속 검색 에 의해 발견될 수 있음.

iter_move (std::ranges::split_view:: inner_iterator )

friend constexpr decltype ( auto ) iter_move ( const /*inner_iterator*/ & i )
noexcept ( noexcept ( ranges:: iter_move ( i. i_ . /*cur*/ ( ) ) ) ) ;
(C++20 이후)

다음 코드와 동등합니다: return ranges:: iter_move ( i. i_ . /*cur*/ ( ) ) ; .

이 함수는 일반적인 비한정 조회 또는 한정 조회 에는 보이지 않으며, std::ranges::split_view:: inner_iterator 가 인자들의 연관 클래스일 때만 인자 의존 조회 를 통해서만 찾을 수 있습니다.

iter_swap (std::ranges::split_view:: inner_iterator )

friend constexpr void iter_swap ( const /*inner_iterator*/ & x,

const /*inner_iterator*/ & y )
noexcept ( noexcept ( ranges:: iter_swap ( x. i_ . current , y. i_ . current ) ) )

requires std:: indirectly_swappable < ranges:: iterator_t < Base >> ;
(C++20 이후)

다음 표현식과 동등합니다: ranges:: iter_swap ( x. i_ . /*cur*/ ( ) , y. i_ . /*cur*/ ( ) ) .

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

결함 보고서

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

DR 적용 대상 게시된 동작 수정된 동작
LWG 3591 C++20 base 의 && 오버로드가 외부 반복자를 무효화할 수 있음 제약 조건 추가됨
LWG 3593 C++20 base 의 const & 오버로드가 참조를 반환하지만 noexcept가 아닐 수 있음 noexcept로 변경됨