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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bereichsbibliothek

Bereichszugriff begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata reserve_hint (C++26)   empty

Range-Konvertierungen std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Behandlung von hängenden Iteratoren dangling borrowed_iterator_t borrowed_subrange_t

Range-Primitive
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Range-Konzepte
range borrowed_range    common_range	sized_range viewable_range    view	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	approximately_sized_range (C++26) constant_range (C++23)

Ansichten
view_interface	subrange

Range-Fabriken
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Range-Adaptoren
views::all_tviews::all as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while common_viewviews::common views::counted to_input_viewviews::to_input (C++26)(C++26)	ref_view drop_viewviews::drop drop_while_viewviews::drop_while lazy_split_viewviews::lazy_split split_viewviews::split join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   concat_viewviews::concat (C++26)(C++26) cache_latest_viewviews::cache_latest (C++26)(C++26)	owning_view reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Range generators std::generator (C++23)

Range-Adaptor-Closure-Objekte range_adaptor_closure (C++23)

Range-Adaptor-Objekte

Hilfselemente
copyable-box movable-box (bis C++23)  (C++23)	simple-view non-propagating-cache

 

std::ranges::filter_view

Memberfunktionen

filter_view::filter_view

filter_view::base

filter_view::pred

filter_view::begin

filter_view::end

Deduction Guides

Iterator

filter_view::iterator::iterator

filter_view::iterator::base

filter_view::iterator::operator*filter_view::iterator::operator->

filter_view::iterator::operator++ filter_view::iterator::operator++(int)

filter_view::iterator::operator-- filter_view::iterator::operator--(int)

operator==(filter_view::iterator)

iter_move(filter_view::iterator)

iter_swap(filter_view::iterator)

Sentinel

filter_view::sentinel::sentinel

filter_view::sentinel::base

operator==(filter_view::iterator, filter_view::sentinel)

 

class /*iterator*/;		(seit C++20) (nur Exposition*)

Der Rückgabetyp von filter_view::begin.

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

Eine Modifikation des Elements, auf das dieser Iterator zeigt, ist erlaubt, führt jedoch zu undefiniertem Verhalten, wenn der resultierende Wert nicht die Bedingung des Filters erfüllt.

Member types

Typ	Definition
iterator_concept	std::bidirectional_iterator_tag, wenn V bidirectional_range modelliert, std::forward_iterator_tag, wenn V forward_range modelliert, std::input_iterator_tag andernfalls.
iterator_category (nur vorhanden, wenn V modelliert forward_range)	Sei C der Typ std::iterator_traits<ranges::iterator_t<V>>::iterator_category. std::bidirectional_iterator_tag, wenn C std::derived_from<std::bidirectional_iterator_tag> modelliert, std::forward_iterator_tag, wenn C std::derived_from<std::forward_iterator_tag> modelliert, C andernfalls.
value_type	ranges::range_value_t<V>
difference_type	ranges::range_difference_t<V>

Data members

Mitglied	Beschreibung
ranges::iterator_t<V> current_ (private)	ein Iterator in der zugrundeliegenden view ((exposition-only member object*)
ranges::filter_view<V, Pred>* parent_ (private)	ein Zeiger auf das Elternobjekt filter_view ((exposition-only member object*)

Member functions

(Konstruktor)	Konstruiert einen Iterator (öffentliche Memberfunktion)
base	gibt den zugrundeliegenden Iterator zurück (öffentliche Memberfunktion)
operator*operator->	leitet an den zugrundeliegenden Iterator weiter (öffentliche Memberfunktion)
operator++operator++(int)	bewegt den Iterator vorwärts (öffentliche Memberfunktion)
operator--operator--(int)	dekrementiert den Iterator (öffentliche Memberfunktion)

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

/*iterator*/()     requires std::default_initializable<ranges::iterator_t<V>> = default;	(1)	(seit C++20)
constexpr /*iterator*/( filter_view& parent,                         ranges::iterator_t<V> current );	(2)	(seit C++20)

1) Initialisiert current_ und parent_ mit ihren Standard-Member-Initialisierern, welche = ranges::iterator_t<V>() und = 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) Äquivalent zu return current_;.

2) Äquivalent zu 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) Äquivalent zu return *current_;.

2) Äquivalent zu return current_;.

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

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) Äquivalent zu
current_ = ranges::find_if(std::move(++current_), ranges::end(parent_->base_),
                           std::ref(*parent_->pred_));
return *this;.

2) Äquivalent zu ++*this;.

3) Äquivalent zu auto tmp = *this; ++*this; return tmp;.

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

constexpr /*Iterator*/& operator--()     requires ranges::bidirectional_range<V>;	(1)	(seit C++20)
constexpr /*Iterator*/ operator--( int )     requires ranges::bidirectional_range<V>;	(2)	(seit C++20)

1) Äquivalent zu
do
    --current_;
while (!std::invoke(*parent_->pred_, *current_));
return *this;.

2) Äquivalent zu auto tmp = *this; --*this; return tmp;.

Non-member functions

operator== (C++20)	vergleicht die zugrundeliegenden Iteratoren (Funktion)
iter_move (C++20)	castet das Ergebnis der Dereferenzierung des zugrundeliegenden Iterators in seinen zugehörigen rvalue-Referenztyp (Funktion)
iter_swap (C++20)	tauscht 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)

Äquivalent zu return x.current_ == y.current_;.

Der Operator != wird aus operator== synthetisiert.

Diese Funktion ist nicht für die normale unqualifizierte oder qualifizierte Suche sichtbar und kann nur durch Argument-abhängige Suche gefunden werden, wenn std::ranges::filter_view::iterator eine zugehörige 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)

Äquivalent zu return ranges::iter_move(i.current_);.

Diese Funktion ist nicht für die normale unqualifizierte oder qualifizierte Suche sichtbar und kann nur durch Argument-abhängige Suche gefunden werden, wenn std::ranges::filter_view::iterator eine zugehörige 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)

Äquivalent zu ranges::iter_swap(x.current_, y.current_).

Diese Funktion ist nicht für die normale unqualifizierte oder qualifizierte Suche sichtbar und kann nur durch Argument-abhängige Suche gefunden werden, wenn std::ranges::filter_view::iterator eine zugehörige Klasse der Argumente ist.

Defect reports

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

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
P2259R1	C++20	Der Member-Typ iterator_category war immer definiert	nur definiert, wenn V ein forward_range ist
LWG 3533	C++20	die base-Überladung für const& kopierte den zugrundeliegenden Iterator	liefert eine Referenz darauf
LWG 3593	C++20	die base-Überladung für const& war möglicherweise nicht noexcept	wurde zu `noexcept` gemacht