std::ranges::views::filter, std::ranges::filter_view

 

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)

 

Definiert in der Header-Datei <ranges>
template< ranges::input_range V,           std::indirect_unary_predicate<ranges::iterator_t<V>> Pred >     requires ranges::view<V> && std::is_object_v<Pred> class filter_view     : public ranges::view_interface<filter_view<V, Pred>>	(1)	(seit C++20)
namespace views {     inline constexpr /* nicht spezifiziert */ filter = /* nicht spezifiziert */; }	(2)	(seit C++20)
Aufruf-Signatur
template< ranges::viewable_range R, class Pred >     requires /* siehe unten */ constexpr ranges::view auto filter( R&& r, Pred&& pred );		(seit C++20)
template< class Pred > constexpr /* Range-Adaptor-Closure */ filter( Pred&& pred );		(seit C++20)

1) Ein Range-Adaptor, der eine view einer zugrundeliegenden Sequenz ohne die Elemente darstellt, die ein Prädikat nicht erfüllen.

2) RangeAdaptorObject. Der Ausdruck views::filter(e, p) ist ausdrucksäquivalent zu filter_view(e, p) für beliebige geeignete Unterausdrücke e und p.

filter_view modelliert die Konzepte bidirectional_range, forward_range, input_range und common_range, wenn die zugrundeliegende view V die entsprechenden Konzepte modelliert.

Datenmember

Mitglied	Beschreibung
V base_ (private)	die zugrunde liegende Ansicht ((exposition-only member object*)
copyable-box<Pred>(bis C++23)movable-box<Pred>(seit C++23) pred_ (private)	verpackt das Prädikat, das zum Filtern von Elementen von base_ verwendet wird ((exposition-only member object*)
non-propagating-cache<ranges::iterator_t<V>> begin_ (private) (nur vorhanden, wenn V forward_range erfüllt)	ein Objekt, das einen Iterator zum ersten Element von base_ zwischenspeichert, das pred_ erfüllt ((exposition-only member object*)

Member-Funktionen

(Konstruktor)	konstruiert eine filter_view (öffentliche Memberfunktion)
base	gibt die zugrunde liegende Ansicht V zurück (öffentliche Memberfunktion)
pred	gibt eine Referenz auf das in filter_view gespeicherte Prädikat zurück (öffentliche Memberfunktion)
begin	gibt den Anfangs-Iterator der filter_view zurück (öffentliche Memberfunktion)
end	gibt das Sentinel der filter_view zurück (öffentliche Memberfunktion)
Geerbt von std::ranges::view_interface
empty	gibt zurück, ob die abgeleitete Ansicht leer ist, bereitgestellt nur, wenn sie sized_range oder forward_range erfüllt (public member function of std::ranges::view_interface<D>)
cbegin (C++23)	gibt einen konstanten Iterator zum Anfang des Bereichs zurück (public member function of std::ranges::view_interface<D>)
cend (C++23)	gibt ein Sentinel für den konstanten Iterator des Bereichs zurück (public member function of std::ranges::view_interface<D>)
operator bool	gibt zurück, ob die abgeleitete Ansicht nicht leer ist, bereitgestellt nur, wenn ranges::empty darauf anwendbar ist (public member function of std::ranges::view_interface<D>)
front	gibt das erste Element in der abgeleiteten View zurück, bereitgestellt, wenn sie forward_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
back	gibt das letzte Element in der abgeleiteten View zurück, nur bereitgestellt, wenn sie bidirectional_range und common_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)

std::ranges::filter_view::filter_view

filter_view() requires std::default_initializable<V> &&                        std::default_initializable<Pred> = default;	(1)	(seit C++20)
constexpr explicit filter_view( V base, Pred pred );	(2)	(seit C++20)

1) Wertinitialisiert base_ über seinen Standard-Member-Initialisierer (= V()) und initialisiert pred_ standardmäßig (was das enthaltene Pred wertinitialisiert).

2) Initialisiert base_ mit std::move(base) und initialisiert pred_ mit std::move(pred).

Parameter

base	-	zu filternde Range
pred	-	zu filterndes Prädikat

std::ranges::filter_view::base

constexpr V base() const& requires std::copy_constructible<V>;	(1)	(seit C++20)
constexpr V base() &&;	(2)	(seit C++20)

1) Äquivalent zu return base_;.

2) Äquivalent zu return std::move(base_);.

std::ranges::filter_view::pred

constexpr const Pred& pred() const;		(seit C++20)

Gibt eine Referenz auf das enthaltene Pred-Objekt zurück. Das Verhalten ist undefiniert, wenn pred_ keinen Wert enthält.

std::ranges::filter_view::begin

constexpr /*iterator*/ begin();		(nur Exposition*)

Um die für das range-Konzept erforderliche amortisierte konstante Zeit zu bieten, speichert diese Funktion das Ergebnis im filter_view-Objekt für nachfolgende Aufrufe. Äquivalent zu

if constexpr (!ranges::forward_range<V>)
    return /*iterator*/{*this, ranges::find_if(base_, std::ref(*pred_))};
else
{
    if (!begin_.has_value())
        begin_ = ranges::find_if(base_, std::ref(*pred_)); // caching
    return /*iterator*/{*this, begin_.value())};
}

Das Verhalten ist undefiniert, wenn pred_ keinen Wert enthält.

std::ranges::filter_view::end

constexpr auto end();		(seit C++20)

Gibt einen Iterator zum Ende zurück. Äquivalent zu

if constexpr (ranges::common_range<V>)
    return /*iterator*/{*this, ranges::end(base_)};
else
    return /*sentinel*/{*this};

Deduktionshilfen

template< class R, class Pred > filter_view( R&&, Pred ) -> filter_view<views::all_t<R>, Pred>;		(seit C++20)

Verschachtelte Klassen

iterator	der Iteratortyp von filter_view ((nur zur Veranschaulichung)*)
sentinel	der Sentinel-Typ von filter_view, wenn die zugrundeliegende View keine common_range ist ((nur zur Veranschaulichung)*)

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <ranges>
 
int main()
{
    auto even = [](int i) { return 0 == i % 2; };
    auto square = [](int i) { return i * i; };
 
    for (int i : std::views::iota(0, 6)
               | std::views::filter(even)
               | std::views::transform(square))
        std::cout << i << ' ';
    std::cout << '\n';
}

Ausgabe

0 4 16

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
LWG 3714 (P2711R1)	C++20	der Multi-Parameter-Konstruktor war nicht explizit	explizit gemacht
P2325R3	C++20	wenn Pred nicht default_initializable ist, der Standardkonstruktor konstruiert eine filter_view, die kein Pred enthält	die filter_view ist ebenfalls nicht default_initializable

Siehe auch

ranges::take_while_viewviews::take_while (C++20)

ein view, der aus den anfänglichen Elementen eines anderen view besteht, bis zum ersten Element, für das ein Prädikat false zurückgibt (Klassen-Template) (Range-Adaptor-Objekt)