Namespaces
Variants

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

    cppreference.net에서 가져옴
     
    C++
     
    Ranges 라이브러리
    Range 어댑터
     
    std::ranges::lazy_split_view
     
    template< bool Const >
struct /*outer_iterator*/;
    		(C++20부터)
    (설명 전용*)

    lazy_split_view::begin의 반환 타입, 그리고 기본 뷰가 lazy_split_view::endcommon_range 및 forward_range인 경우 의 반환 타입.

    V 또는 Pattern이 simple view가 아닌 경우 (예: ranges::iterator_t<const V>이 유효하지 않거나 ranges::iterator_t<V>과 다른 경우), Const은 const 오버로드에서 반환된 반복자에 대해 true이고, 그 외의 경우 false입니다. V이 simple view인 경우, Const은 true가 Vforward_range인 경우에만 입니다.

    멤버 타입

    멤버 정의
    Parent maybe-const  < Const, ranges:: lazy_split_view >
    ( 설명 전용 멤버 타입* )
    Base maybe-const  < Const, V >
    ( 설명 전용 멤버 타입* )
    iterator_concept
    iterator_category
    (존재하는 경우는 Base 가 forward_range 를 모델링할 때만)     		std::input_iterator_tag
    		outer_iterator 의 값 타입
    (공개 멤버 클래스)
    difference_type ranges:: range_difference_t < Base >

    데이터 멤버

    멤버 설명
    Parent * parent_ (private) 부모 객체에 대한 포인터 lazy_split_view
    ( 설명 전용 멤버 객체* )
    ranges:: iterator_t < Base > current_ (private)
    ( V 가 forward_range 를 모델링할 때만 존재함)     		기본 view 의 반복자
    ( 설명 전용 멤버 객체* )
    bool trailing_empty_ (private) 빈 후행 하위 범위(있는 경우)에 도달했는지 여부를 나타내는 플래그
    ( 설명 전용 멤버 객체* )

    멤버 함수

    (constructor)
    		반복자를 생성함
    (public member function)
    operator*
    		현재 서브레인지를 반환함
    (public member function)
    operator++ operator++ (int)
    		반복자를 전진시킴
    (public member function)
    cur
    		조건부로 current_ 에 대한 참조(존재하는 경우) 또는 * parent_ - > current_ 에 대한 참조를 반환함
    ( 설명 전용 멤버 함수* )

    멤버 함수

    std::ranges::lazy_split_view::outer_iterator ::outer_iterator

    /*outer_iterator*/() = default;
    		(1) (C++20부터) 
    constexpr explicit /*outer_iterator*/( Parent& parent )
    requires (!ranges::forward_range<Base>);
    		(2) (C++20부터) 
    constexpr /*outer_iterator*/( Parent& parent,
                              ranges::iterator_t<Base> current )
    requires ranges::forward_range<Base>;
    		(3) (C++20부터) 
    constexpr /*outer_iterator*/( /*outer_iterator*/<!Const> i )
    requires Const && std::convertible_to<ranges::iterator_t<V>,
                                          ranges::iterator_t<Base>>;
    		(4) (C++20부터)
    1) 기본 멤버 초기화자로 비정적 데이터 멤버를 값 초기화합니다. 즉:
    • parent_ = nullptr;,
    • current_ = iterator_t<Base>(); (V이 forward_range 모델링하는 경우에만 존재)
    2) parent_을 std::addressof(parent)로 초기화합니다.
    3) parent_을 std::addressof(parent)으로, current_을 std::move(current)로 초기화합니다.
    4) parent_을 i.parent_로, current_을 std::move(i.current_)로, trailing_empty_를 t.trailing_empty_으로 초기화합니다.

    trailing_empty_은 기본 멤버 초기화자로 false로 초기화됩니다.

    std::ranges::lazy_split_view::outer_iterator ::operator*

    constexpr value_type operator*() const;
    		(C++20부터)

    return value_type{*this};과 동일합니다.

    std::ranges::lazy_split_view::outer_iterator ::operator++

    constexpr /*outer_iterator*/& operator++();
    		(1) (C++20부터) 
    constexpr decltype(auto) operator++(int);
    		(2) (C++20부터)
    1) 함수 본체는 다음과 동일합니다. 
    const auto end = ranges::end(parent_->base_);
if (/*cur*/() == end)
{
    trailing_empty_ = false;
    return *this;
}
const auto [pbegin, pend] = ranges::subrange{parent_->pattern_};
if (pbegin == pend)
    ++/*cur*/();
else if constexpr (/*tiny_range*/<Pattern>)
{
    /*cur*/() = ranges::find(std::move(/*cur*/()), end, *pbegin);
    if (/*cur*/() != end)
    {
        ++/*cur*/();
        if (/*cur*/() == end)
            trailing_empty_ = true;
    }
}
else
{
    do
    {
        auto [b, p] = ranges::mismatch(/*cur*/(), end, pbegin, pend);
        if (p == pend)
        {
            /*cur*/() = b;
            if (/*cur*/() == end)
                trailing_empty_ = true;
            break; // The pattern matched; skip it
        }
    } while (++/*cur*/() != end);
}
return *this;
    2) 다음과 동일합니다. 
    if constexpr (ranges::forward_range<Base>)
{
    auto tmp = *this;
    ++*this;
    return tmp;
}
else
{
    ++*this; // no return statement
}

    std::ranges::lazy_split_view::outer_iterator ::cur () 

    constexpr auto& /*cur*/() noexcept;
    		(1) (C++20부터)
    (설명 전용*)    		 
    constexpr auto& /*cur*/() const noexcept;
    		(2) (C++20부터)
    (설명 전용*)

    이 편의 멤버 함수는 /*outer_iterator*/::operator++(), 비멤버 operator==(const /*outer_iterator*/&, std::default_sentinel_t), 그리고 inner_iterator의 가능한 구현의 일부 멤버 함수에서 참조됩니다.

    1,2) 다음과 동일합니다: 
    if constexpr (ranges::forward_range<V>)
    return current_;
else
    return *parent->current_;

    비멤버 함수

    operator==
    (C++20)
    		기본 반복자 또는 기본 반복자와 std::default_sentinel 을 비교합니다
    (함수)

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

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

    const /*outer_iterator*/ & y )

    requires forward_range < Base > ;
    		(1) (since C++20)
    friend constexpr bool operator == ( const /*outer_iterator*/ & x,
    std:: default_sentinel_t ) ;
    		(2) (since C++20)
    1) 다음 코드와 동등함: return x. current_ == y. current_ and x. trailing_empty_ == y. trailing_empty_ ; .
    2) 다음 코드와 동등함: return x. /*cur*/ ( ) == ranges:: end ( x. parent_ - > base_ ) and ! x. trailing_empty_ ; .

    != 연산자는 합성됨 ( operator== 로부터).

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

    결함 보고서

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

    DR 적용 대상 게시된 동작 올바른 동작
    LWG 3904 C++20 trailing_empty_ 가 생성자 ( 4 )에서 초기화되지 않음 초기화됨