Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Bereichsbibliothek
    Bereichsadapter
     
    std::ranges::filter_view
     
    Definiert in Header <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 /* unspecified */ filter = /* unspecified */;
}
    		(2) (seit C++20)
    Aufrufsignatur
    		 
    template< ranges::viewable_range R, class Pred >
    requires /* see below */
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 Bereichsadapter, der eine Ansicht einer zugrunde liegenden 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 alle geeigneten Unterausdrücke e und p.

    filter_view modelliert die Konzepte bidirectional_range, forward_range, input_range und common_range, wenn die zugrunde liegende Ansicht V die entsprechenden Konzepte modelliert.

    Datenmember

    Member Beschreibung
    V base_ (privat) die zugrunde liegende Ansicht
    (nur zur Darstellung dienendes Mitgliedsobjekt*)

    copyable-box<Pred>

    		(bis C++23)

    movable-box<Pred>

    		(seit C++23)
     pred_ (privat)     		umhüllt das Prädikat, das zum Herausfiltern von Elementen von base_
    (nur zur Darstellung dienendes Mitgliedsobjekt*)
    non-propagating-cache<ranges::iterator_t<V>>
           begin_ (privat)
    (nur vorhanden, wenn V erfüllt forward_range)     		ein Objekt, das einen Iterator auf das erste Element von base_ zwischenspeichert, das das pred_
    erfüllt(nur zur Darstellung dienendes Mitgliedsobjekt*)

    Memberfunktionen

    		konstruiert einen filter_view
    (öffentliche Elementfunktion)
    		gibt die zugrundeliegende Ansicht V zurück
    (öffentliche Elementfunktion)
    		gibt eine Referenz auf das in filter_view gespeicherte Prädikat zurück
    (öffentliche Elementfunktion)
    		gibt den Beginn-Iterator des filter_view zurück
    (öffentliche Elementfunktion)
    		gibt den Sentinel des filter_view zurück
    (öffentliche Elementfunktion)
    Geerbt von ranges::view_interface
    		gibt zurück, ob die abgeleitete Sicht leer ist, vorausgesetzt, dass sie sized_range oder forward_range
    erfüllt(öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Beginn des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete Sicht nicht leer ist, vorausgesetzt, dass ranges::empty darauf anwendbar ist
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Sicht zurück, vorausgesetzt, dass es forward_range
    erfüllt(öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten Sicht zurück, vorausgesetzt, dass es bidirectional_range und common_range
    erfüllt(öffentliche Elementfunktion 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 standardinitialisiert pred_ (was den enthaltenen Pred wertinitialisiert).
    2) Initialisiert base_ mit std :: move ( base ) und initialisiert pred_ mit std :: move ( pred ) .

    Parameter

    base - zu filternder Bereich
    pred - Prädikat zum Herausfiltern von Elementen

    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) Entspricht return base_ ; .
    2) Entspricht 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 zur Darstellung* )

    Um die vom range -Konzept geforderte amortisierte konstante Zeitkomplexität bereitzustellen, speichert diese Funktion das Ergebnis innerhalb des filter_view -Objekts zwischen, um es bei nachfolgenden Aufrufen zu verwenden. Entspricht: 

    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. Entspricht: 

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

    Deduktionsanleitungen

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

    Geschachtelte Klassen

    		der Iteratortyp von filter_view
    ( Nur zur Darstellung verwendete Memberklasse* )
    		der Sentineltyp von filter_view wenn die zugrunde liegende View kein common_range ist
    ( Nur zur Darstellung verwendete Memberklasse* )

    Beispiel

    Diesen Code ausführen 
    #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

    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 3714
    ( P2711R1 )     		C++20 der Mehrparameter-Konstruktor war nicht explicit als explicit festgelegt
    P2325R3 C++20 wenn Pred nicht default_initializable ist, konstruiert der Standardkonstruktor
    ein filter_view , das kein Pred enthält     		das filter_view ist ebenfalls
    nicht default_initializable

    Siehe auch

    (C++20)
    		eine view , bestehend aus den Anfangselementen einer anderen view , bis zum ersten Element, bei dem ein Prädikat false zurückgibt
    (Klassentemplate) (Range-Adapter-Objekt)