Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::filter_view
Definiert im 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 /* nicht spezifiziert */ filter = /* nicht spezifiziert */ ;

}
(2) (seit C++20)
Aufrufsignatur
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 /* Bereichsadapter-Abschluss */ filter ( Pred && pred ) ;
(seit C++20)
1) Ein Bereichsadapter, der eine view einer zugrundeliegenden Sequenz darstellt, mit nur den Elementen, die das Prädikat erfüllen.
2) RangeAdaptorObject . Der Ausdruck views :: filter ( e, p ) ist ausdrucksäquivalent zu filter_view ( e, p ) für beliebige geeignete Teilausdrücke e und p .

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

Inhaltsverzeichnis

Datenmitglieder

Member Beschreibung
V base_ die zugrundeliegende Ansicht
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
copyable-box <Pred> (bis C++23) movable-box <Pred> (seit C++23) pred_ kapselt das Prädikat zum Filtern von Elementen aus base_
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
non-propagating-cache < ranges:: iterator_t < V >> begin_
(nur vorhanden wenn V forward_range erfüllt) 		ein Objekt, das einen Iterator zum ersten Element von base_ zwischenspeichert, das pred_ erfüllt
( Nur zur Darstellung verwendetes 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 std::ranges::view_interface
gibt zurück, ob die abgeleitete Ansicht leer ist, bereitgestellt nur wenn 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 Ansicht nicht leer ist, bereitgestellt nur wenn ranges::empty darauf anwendbar ist
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das erste Element in der abgeleiteten Ansicht zurück, bereitgestellt wenn sie forward_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das letzte Element in der abgeleiteten Ansicht zurück, bereitgestellt nur wenn sie 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)