Namespaces
Variants

std::ranges::filter_view<V,Pred>:: iterator

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::filter_view
class /*iterator*/ ;
(seit C++20)
( nur zur Darstellung* )

Der Rückgabetyp von filter_view::begin .

Dies ist ein bidirectional_iterator , wenn V ein bidirectional_range modelliert, ein forward_iterator , wenn V ein forward_range modelliert, und andernfalls ein input_iterator .

Die Modifikation des Elements, auf das dieser Iterator zeigt, ist erlaubt, führt jedoch zu undefiniertem Verhalten, wenn der resultierende Wert das Prädikat des Filters nicht erfüllt.

Inhaltsverzeichnis

Mitgliedertypen

Typ Definition
iterator_concept
iterator_category
(nur vorhanden, falls V das Konzept
forward_range modelliert)

Sei C der Typ std:: iterator_traits < ranges:: iterator_t < V >> :: iterator_category .

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

Datenmitglieder

Mitglied Beschreibung
ranges:: iterator_t < V > current_ (privat) ein Iterator in die zugrundeliegende view
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
ranges:: filter_view < V, Pred > * parent_ (privat) ein Zeiger auf das übergeordnete filter_view -Objekt
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )

Memberfunktionen

Konstruiert einen Iterator
(öffentliche Elementfunktion)
gibt den zugrundeliegenden Iterator zurück
(öffentliche Elementfunktion)
leitet an den zugrundeliegenden Iterator weiter
(öffentliche Elementfunktion)
erhöht den Iterator
(öffentliche Elementfunktion)
verringert den Iterator
(öffentliche Elementfunktion)

std::ranges::filter_view:: iterator :: iterator

/*iterator*/ ( )
requires std:: default_initializable < ranges:: iterator_t < V >> = default ;
(1) (since C++20)
constexpr /*iterator*/ ( filter_view & parent,
ranges:: iterator_t < V > current ) ;
(2) (since C++20)
1) Initialisiert current_ und parent_ mit ihren Standard-Member-Initialisierern, welche = ranges:: iterator_t < V > ( ) bzw. = nullptr sind.
2) Initialisiert current_ mit std :: move ( current ) und parent_ mit std:: addressof ( parent ) .

std::ranges::filter_view:: iterator :: base

constexpr const ranges:: iterator_t < V > & base ( ) const & noexcept ;
(1) (seit C++20)
constexpr ranges:: iterator_t < V > base ( ) && ;
(2) (seit C++20)
1) Entspricht return current_ ; .
2) Entspricht return std :: move ( current_ ) ; .

std::ranges::filter_view:: iterator :: operator*,->

constexpr ranges:: range_reference_t < V > operator * ( ) const ;
(1) (seit C++20)
constexpr ranges:: iterator_t < V > operator - > ( ) const

requires /*has-arrow*/ < ranges:: iterator_t < V >> &&

std:: copyable < ranges:: iterator_t < V >> ;
(2) (seit C++20)
1) Entspricht return * current_ ; .
2) Entspricht return current_ ; .

Für einen Typ I wird /*has-arrow*/ < I > modelliert oder erfüllt, genau dann wenn I input_iterator modelliert oder erfüllt, und entweder I ein Pointer-Typ ist oder requires ( I i ) { i. operator - > ( ) ; } true ergibt.

std::ranges::filter_view:: iterator :: operator++

constexpr /*iterator*/ & operator ++ ( ) ;
(1) (seit C++20)
constexpr void operator ++ ( int ) ;
(2) (seit C++20)
constexpr /*iterator*/ operator ++ ( int )
requires ranges:: forward_range < V > ;
(3) (seit C++20)
1) Entspricht
current_ = ranges:: find_if ( std :: move ( ++ current_ ) , ranges:: end ( parent_ - > base_ ) ,
std:: ref ( * parent_ - > pred_ ) ) ;
return * this ; .
2) Entspricht ++* this ; .
3) Entspricht auto tmp = * this ; ++* this ; return tmp ; .

std::ranges::filter_view:: iterator :: operator--

constexpr /*iterator*/ & operator -- ( )
requires ranges:: bidirectional_range < V > ;
(1) (since C++20)
constexpr /*iterator*/ operator -- ( int )
requires ranges:: bidirectional_range < V > ;
(2) (since C++20)
1) Entspricht
do
-- current_ ;
while ( ! std:: invoke ( * parent_ - > pred_, * current_ ) ) ;
return * this ; .
2) Entspricht auto tmp = * this ; --* this ; return tmp ; .

Nicht-Member-Funktionen

(C++20)
vergleicht die zugrundeliegenden Iteratoren
(Funktion)
(C++20)
konvertiert das Ergebnis der Dereferenzierung des zugrundeliegenden Iterators in seinen zugehörigen Rvalue-Referenztyp
(Funktion)
(C++20)
vertauscht die Objekte, auf die zwei zugrundeliegende Iteratoren zeigen
(Funktion)

operator== (std::ranges::filter_view:: iterator )

friend constexpr bool operator == ( const /*iterator*/ & x, const /*iterator*/ & y )
requires std:: equality_comparable < ranges:: iterator_t < V >> ;
(seit C++20)

Entspricht return x. current_ == y. current_ ; .

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

Diese Funktion ist für gewöhnliche unqualifizierte oder qualifizierte Suche nicht sichtbar und kann nur durch argumentabhängige Suche gefunden werden, wenn std::ranges::filter_view:: iterator eine assoziierte Klasse der Argumente ist.

iter_move (std::ranges::filter_view:: iterator )

friend constexpr ranges:: range_rvalue_reference_t < V >

iter_move ( const /*iterator*/ & i )

noexcept ( noexcept ( ranges:: iter_move ( i. current_ ) ) ) ;
(seit C++20)

Entspricht return ranges:: iter_move ( i. current_ ) ; .

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

iter_swap (std::ranges::filter_view:: iterator )

friend constexpr void iter_swap ( const /*iterator*/ & x, const /*iterator*/ & y )

noexcept ( noexcept ( ranges:: iter_swap ( x. current_ , y. current_ ) ) )

requires std:: indirectly_swappable < ranges:: iterator_t < V >> ;
(seit C++20)

Entspricht ranges:: iter_swap ( x. current_ , y. current_ ) .

Diese Funktion ist für gewöhnliches unqualifiziertes oder qualifiziertes Lookup nicht sichtbar und kann nur durch argumentabhängige Suche gefunden werden, wenn std::ranges::filter_view:: 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
P2259R1 C++20 Member-Typ iterator_category war immer definiert nur definiert wenn V ein forward_range ist
LWG 3533 C++20 die const & Überladung von base kopierte den zugrundeliegenden Iterator gibt eine Referenz darauf zurück
LWG 3593 C++20 die const & Überladung von base war möglicherweise nicht noexcept als noexcept markiert