Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::filter_view
Défini dans l'en-tête <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) (depuis C++20)
namespace views {

inline constexpr /* non spécifié */ filter = /* non spécifié */ ;

}
(2) (depuis C++20)
Signature d'appel
template < ranges:: viewable_range R, class Pred >

requires /* voir ci-dessous */

constexpr ranges:: view auto filter ( R && r, Pred && pred ) ;
(depuis C++20)
template < class Pred >
constexpr /* adaptateur de gamme de fermeture */ filter ( Pred && pred ) ;
(depuis C++20)
1) Un adaptateur de gamme qui représente une view d'une séquence sous-jacente avec uniquement les éléments qui satisfont le prédicat.
2) RangeAdaptorObject . L'expression views :: filter ( e, p ) est équivalente en expression à filter_view ( e, p ) pour toutes sous-expressions appropriées e et p .

filter_view modélise les concepts bidirectional_range , forward_range , input_range , et common_range lorsque la view sous-jacente V modélise les concepts respectifs.

Table des matières

Membres de données

Membre Description
V base_ la vue sous-jacente
( objet membre d'exposition uniquement* )
copyable-box <Pred> (until C++23) movable-box <Pred> (since C++23) pred_ encapsule le prédicat utilisé pour filtrer les éléments de base_
( objet membre d'exposition uniquement* )
non-propagating-cache < ranges:: iterator_t < V >> begin_
(présent seulement si V satisfait forward_range ) 		un objet qui met en cache un itérateur vers le premier élément de base_ qui satisfait le pred_
( objet membre d'exposition uniquement* )

Fonctions membres

construit un filter_view
(fonction membre publique)
retourne la vue sous-jacente V
(fonction membre publique)
retourne une référence au prédicat stocké dans filter_view
(fonction membre publique)
retourne l'itérateur de début du filter_view
(fonction membre publique)
retourne le sentinelle du filter_view
(fonction membre publique)
Hérité de std::ranges::view_interface
indique si la vue dérivée est vide, fourni uniquement si elle satisfait sized_range ou forward_range
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un itérateur constant vers le début de la plage
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un sentinelle pour l'itérateur constant de la plage
(fonction membre publique de std::ranges::view_interface<D> )
indique si la vue dérivée n'est pas vide, fourni uniquement si ranges::empty lui est applicable
(fonction membre publique de std::ranges::view_interface<D> )
retourne le premier élément de la vue dérivée, fourni si elle satisfait forward_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le dernier élément de la vue dérivée, fourni uniquement si elle satisfait bidirectional_range et common_range
(fonction membre publique de std::ranges::view_interface<D> )

std::ranges::filter_view:: filter_view

filter_view ( ) requires std:: default_initializable < V > &&
std:: default_initializable < Pred > = default ;
(1) (depuis C++20)
constexpr explicit filter_view ( V base, Pred pred ) ;
(2) (depuis C++20)
1) Initialise par valeur base_ via son initialiseur de membre par défaut ( = V ( ) ) et initialise par défaut pred_ (ce qui initialise par valeur le Pred contenu).
2) Initialise base_ avec std :: move ( base ) et initialise pred_ avec std :: move ( pred ) .

Paramètres

base - plage à filtrer
pred - prédicat pour filtrer les éléments

std::ranges::filter_view:: base

constexpr V base ( ) const & requires std:: copy_constructible < V > ;
(1) (depuis C++20)
constexpr V base ( ) && ;
(2) (depuis C++20)
1) Équivalent à return base_ ; .
2) Équivalent à return std :: move ( base_ ) ; .

std::ranges::filter_view:: pred

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

Retourne une référence à l'objet Pred contenu. Le comportement est indéfini si pred_ ne contient pas de valeur.

std::ranges::filter_view:: begin

constexpr /*iterator*/ begin ( ) ;
( exposition uniquement* )

Afin de fournir la complexité temporelle amortie constante requise par le concept range , cette fonction met en cache le résultat dans l'objet filter_view pour une utilisation lors des appels ultérieurs. Équivalent à 

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())};
}

Le comportement est indéfini si pred_ ne contient pas de valeur.

std::ranges::filter_view:: end

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

Retourne un itérateur vers la fin. Équivalent à 

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

Guides de déduction

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

Classes imbriquées

le type d'itérateur de filter_view
( classe membre d'exposition uniquement* )
le type de sentinelle de filter_view lorsque la vue sous-jacente n'est pas une common_range
( classe membre d'exposition uniquement* )

Exemple

Exécuter ce code 
#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';
}

Sortie : 

0 4 16

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3714
( P2711R1 ) 		C++20 le constructeur multi-paramètres n'était pas explicite rendu explicite
P2325R3 C++20 si Pred n'est pas default_initializable , le constructeur par défaut
construit un filter_view qui ne contient pas de Pred 		le filter_view n'est également
pas default_initializable

Voir aussi

(C++20)
une view constituée des éléments initiaux d'une autre view , jusqu'au premier élément pour lequel un prédicat retourne false
(modèle de classe) (objet adaptateur de gamme)