Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Bereichsbibliothek
    Bereichsadaptoren
     
    std::ranges::lazy_split_view
     
    template< bool Const >
struct /*outer_iterator*/;
    		(seit C++20)
    (nur zur Veranschaulichung*)

    Der Rückgabetyp von lazy_split_view::begin und von lazy_split_view::end, wenn der zugrundeliegende View ein common_range und ein forward_range ist.

    Wenn entweder V oder Pattern kein simple view ist (z. B. wenn ranges::iterator_t<const V> ungültig oder anders als ranges::iterator_t<V> ist), dann ist Const true für Iteratoren, die von den const-Überladungen zurückgegeben werden, andernfalls false. Wenn V ein simple view ist, dann ist Const genau dann true, wenn V ein forward_range ist.

    Mitgliedertypen

    Mitglied Definition
    Parent maybe-const  < Const, ranges:: lazy_split_view >
    ( Nur zur Darstellung verwendeter Mitgliedstyp* )
    Base maybe-const  < Const, V >
    ( Nur zur Darstellung verwendeter Mitgliedstyp* )
    iterator_concept
    iterator_category
    (nur vorhanden, falls Base das Konzept forward_range modelliert)     		std::input_iterator_tag
    		Der Werttyp des outer_iterator
    (Öffentlicher Mitgliedsklasse)
    difference_type ranges:: range_difference_t < Base >

    Datenmitglieder

    Member Beschreibung
    Parent * parent_ (private) ein Zeiger auf das Elternobjekt lazy_split_view
    ( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
    ranges:: iterator_t < Base > current_ (private)
    (nur vorhanden, wenn V das Konzept forward_range modelliert)     		ein Iterator in die zugrundeliegende view
    ( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
    bool trailing_empty_ (private) ein Flag, das angibt, ob ein leerer nachfolgender Subbereich (falls vorhanden) erreicht wurde
    ( Nur zur Darstellung verwendetes Mitgliedsobjekt* )

    Memberfunktionen

    (constructor)
    		Konstruiert einen Iterator
    (public member function)
    operator*
    		gibt den aktuellen Subbereich zurück
    (public member function)
    operator++ operator++ (int)
    		erhöht den Iterator
    (public member function)
    cur
    		gibt bedingt eine Referenz auf current_ zurück (falls vorhanden) oder auf * parent_ - > current_
    ( exposition-only member function* )

    Memberfunktionen

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

    /*outer_iterator*/() = default;
    		(1) (seit C++20) 
    constexpr explicit /*outer_iterator*/( Parent& parent )
    requires (!ranges::forward_range<Base>);
    		(2) (seit C++20) 
    constexpr /*outer_iterator*/( Parent& parent,
                              ranges::iterator_t<Base> current )
    requires ranges::forward_range<Base>;
    		(3) (seit C++20) 
    constexpr /*outer_iterator*/( /*outer_iterator*/<!Const> i )
    requires Const && std::convertible_to<ranges::iterator_t<V>,
                                          ranges::iterator_t<Base>>;
    		(4) (seit C++20)
    1) Wertinitialisiert die nicht-statischen Datenelemente mit ihren Standard-Member-Initialisierern, das heißt:
    • parent_ = nullptr;,
    • current_ = iterator_t<Base>(); (nur vorhanden, wenn V das forward_range-Konzept modelliert),
    2) Initialisiert parent_ mit std::addressof(parent).
    3) Initialisiert parent_ mit std::addressof(parent) und current_ mit std::move(current).
    4) Initialisiert parent_ mit i.parent_, current_ mit std::move(i.current_) und trailing_empty_ mit t.trailing_empty_.

    Das trailing_empty_ wird mit seinem Standard-Member-Initialisierer auf false initialisiert.

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

    constexpr value_type operator*() const;
    		(seit C++20)

    Entspricht return value_type{*this};.

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

    constexpr /*outer_iterator*/& operator++();
    		(1) (seit C++20) 
    constexpr decltype(auto) operator++(int);
    		(2) (seit C++20)
    1) Der Funktionsrumpf ist äquivalent zu 
    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) Äquivalent zu 
    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) (seit C++20)
    (nur zur Veranschaulichung*)    		 
    constexpr auto& /*cur*/() const noexcept;
    		(2) (seit C++20)
    (nur zur Veranschaulichung*)

    Diese praktische Memberfunktion wird von /*outer_iterator*/::operator++(), von der Nicht-Member-Funktion operator==(const /*outer_iterator*/&, std::default_sentinel_t) und von einigen Memberfunktionen der möglichen Implementierung von inner_iterator referenziert.

    1,2) Entspricht 
    if constexpr (ranges::forward_range<V>)
    return current_;
else
    return *parent->current_;

    Nicht-Member-Funktionen

    operator==
    (C++20)
    		vergleicht die zugrundeliegenden Iteratoren oder den zugrundeliegenden Iterator und std::default_sentinel
    (Funktion)

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

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

    const /*outer_iterator*/ & y )

    requires forward_range < Base > ;
    		(1) (seit C++20)
    friend constexpr bool operator == ( const /*outer_iterator*/ & x,
    std:: default_sentinel_t ) ;
    		(2) (seit C++20)
    1) Entspricht return x. current_ == y. current_ and x. trailing_empty_ == y. trailing_empty_ ; .
    2) Entspricht return x. /*cur*/ ( ) == ranges:: end ( x. parent_ - > base_ ) and ! x. trailing_empty_ ; .

    Der != -Operator wird aus operator== synthetisiert .

    Diese Funktionen sind für gewöhnliche unqualifizierte oder qualifizierte Suche nicht sichtbar und können nur durch argumentabhängige Suche gefunden werden, wenn std::ranges::split_view:: outer_iterator eine assoziierte Klasse der Argumente ist.

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 3904 C++20 trailing_empty_ wurde im Konstruktor ( 4 ) nicht initialisiert initialisiert