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*/ ;
(seit C++20)
( nur zur Darstellung* )

Der Rückgabetyp von lazy_split_view:: outer_iterator :: value_type :: begin ( ) .

Const entspricht dem Template-Argument von outer_iterator .

Inhaltsverzeichnis

Mitgliedertypen

Mitglied Definition
Base maybe-const  < Const, V >
( Nur-Darstellungs-Mitgliedstyp* )
iterator_concept
iterator_category
(bedingt vorhanden)

Nur vorhanden, falls Base das Konzept forward_range modelliert.

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

Datenmitglieder

Mitglied Beschreibung
outer_iterator < Const > i_ (privat) ein Iterator in das zugrundeliegende view des Elternobjekts lazy_split_view
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
bool incremented_ (privat) ein Flag, das anzeigt, ob der operator ++ mindestens einmal für dieses Objekt aufgerufen wurde
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )

Memberfunktionen

(Konstruktor)
(C++20)
konstruiert einen Iterator
(öffentliche Elementfunktion)
base
(C++20)
gibt den zugrundeliegenden Iterator zurück
(öffentliche Elementfunktion)
operator*
(C++20)
gibt das aktuelle Element zurück
(öffentliche Elementfunktion)
operator++ operator++ (int)
(C++20)
erhöht den Iterator
(öffentliche Elementfunktion)

Memberfunktionen

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

/*inner_iterator*/ ( ) = default ;
(1) (seit C++20)
constexpr explicit /*inner_iterator*/ ( /*outer_iterator*/ < Const > i ) ;
(2) (seit C++20)
1) Wertinitialisiert das Datenmitglied i_ über seinen Standard-Member-Initialisierer (= /*outer_iterator*/ < Const > ( ) ).
2) Initialisiert i_ mit std :: move ( i ) .

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

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

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

Gibt eine Kopie des zugrundeliegenden Iterators zurück.

1) Kopiert das Ergebnis aus dem zugrundeliegenden Iterator. Entspricht return i_. /*cur*/ ( ) ; .
2) Bewegt das Ergebnis aus dem zugrundeliegenden Iterator. Entspricht return std :: move ( i_. /*cur*/ ( ) ) ; .

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

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

Gibt das Element zurück, auf das der zugrunde liegende Iterator zeigt.

Entspricht return * i_. /*cur*/ ( ) ; .

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

constexpr /*inner_iterator*/ & operator ++ ( ) ;
(1) (seit C++20)
constexpr decltype ( auto ) operator ++ ( int ) ;
(2) (seit C++20)
1) Der Funktionsrumpf ist äquivalent zu
incremented_ = true ;

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

return * this ;
2) Äquivalent zu
if constexpr ( ranges:: forward_range < Base > )

{
auto tmp = * this ;
++* this ;
return tmp ;
}
else
++* this ; // keine return-Anweisung

Nicht-Member-Funktionen

operator==
(C++20)
vergleicht die Iteratoren oder den Iterator und std::default_sentinel
(Funktion)
iter_move
(C++20)
konvertiert das Ergebnis der Dereferenzierung des zugrundeliegenden Iterators in seinen zugehörigen Rvalue-Referenztyp
(Funktion)
iter_swap
(C++20)
vertauscht die Objekte, auf die zwei zugrundeliegende Iteratoren zeigen
(Funktion)

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

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

const /*inner_iterator*/ & y )

requires forward_range < Base > ;
(1) (seit C++20)
friend constexpr bool operator == ( const /*inner_iterator*/ & x,
std:: default_sentinel_t ) ;
(2) (seit C++20)
1) Entspricht return x. i_ . /*cur*/ ( ) == y. i_ . /*cur*/ ( ) ; .
2) Der Funktionsrumpf entspricht 
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;
}

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:: inner_iterator eine assoziierte Klasse der Argumente ist.

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*/ ( ) ) ) ) ;
(seit C++20)

Entspricht return ranges:: iter_move ( i. i_ . /*cur*/ ( ) ) ; .

Diese Funktion ist für gewöhnliches unqualifiziertes oder qualifiziertes Nachschlagen nicht sichtbar und kann nur durch argumentabhängiges Nachschlagen gefunden werden, wenn std::ranges::split_view:: inner_iterator eine assoziierte Klasse der Argumente ist.

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 >> ;
(seit C++20)

Entspricht ranges:: iter_swap ( x. i_ . /*cur*/ ( ) , y. i_ . /*cur*/ ( ) ) .

Diese Funktion ist für gewöhnlichen unqualifizierten oder qualifizierten Lookup nicht sichtbar und kann nur durch argumentabhängige Suche gefunden werden, wenn std::ranges::split_view:: inner_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 Korrigiertes Verhalten
LWG 3591 C++20 die && Überladung von base könnte äußere Iteratoren ungültig machen Constraints hinzugefügt
LWG 3593 C++20 die const & Überladung von base gibt eine Referenz zurück, könnte aber nicht noexcept sein noexcept gemacht