Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::lazy_split_view
template < bool Const >
struct /*outer_iterator*/ ;
(seit C++20)
( nur zur Darstellung* )

Der Rückgabetyp von lazy_split_view::begin , und von lazy_split_view::end wenn die zugrunde liegende View ein common_range und ein forward_range ist.

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

Inhaltsverzeichnis

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 Konzept forward_range 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 Element 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 } ; .

**Übersetzungsdetails:** - "Equivalent to" → "Entspricht" (professionelle technische Übersetzung) - "(since C++20)" → "(seit C++20)" (Standardübersetzung für C++-Versionen) - HTML-Tags, Attribute und Code-Blöcke wurden unverändert beibehalten - C++-spezifische Begriffe wie `std::ranges::lazy_split_view`, `outer_iterator`, `value_type` etc. wurden nicht übersetzt - Die Formatierung und Struktur der ursprünglichen HTML wurde vollständig erhalten

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; // Das Muster wurde gefunden; überspringe es
        }
    } while (++/*cur*/() != end);
}
return *this;
2) Äquivalent zu 
if constexpr (ranges::forward_range<Base>)
{
    auto tmp = *this;
    ++*this;
    return tmp;
}
else
{
    ++*this; // keine return-Anweisung
}

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

constexpr auto & /*cur*/ ( ) noexcept ;
(1) (seit C++20)
( nur zur Darstellung* )
constexpr auto & /*cur*/ ( ) const noexcept ;
(2) (seit C++20)
( nur zur Darstellung* )

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

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