std::ranges::views::filter, std::ranges::filter_view
De fr.cppreference.net
| 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 /* unspecified */ filter = /* unspecified */;
}
|
(2) | (depuis C++20) |
| Signature d'appel |
||
template< ranges::viewable_range R, class Pred >
requires /* see below */
constexpr ranges::view auto filter( R&& r, Pred&& pred );
|
(depuis C++20) | |
template< class Pred >
constexpr /* range adaptor closure */ filter( Pred&& pred );
|
(depuis C++20) | |
1) Un adaptateur de plage qui représente une vue d'une séquence sous-jacente sans les éléments qui ne satisfont pas un prédicat.
2) RangeAdaptorObject. L'expression
views::filter(e, p) est expression-équivalente à 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 vue V sous-jacente modélise les concepts respectifs.
Membres de données
| Membre | Description | ||||
V base_ (privé)
|
la vue sous-jacente (objet membre d'exposition uniquement*) | ||||
pred_ (privé)
|
encapsule le prédicat utilisé pour filtrer les éléments debase_(objet membre d'exposition uniquement*) | ||||
non-propagating-cache<ranges::iterator_t<V>> begin_ (privé) (présent uniquement 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ée de ranges::view_interface | |
| renvoie si la vue dérivée est vide, fournie seulement si elle satisfait sized_range ou forward_range (fonction membre publique de std::ranges::view_interface<D>)
| |
(C++23) |
renvoie un itérateur constant au début de la plage (fonction membre publique de std::ranges::view_interface<D>)
|
(C++23) |
renvoie un sentinelle pour l'itérateur constant de la plage (fonction membre publique de std::ranges::view_interface<D>)
|
| renvoie si la vue dérivée n'est pas vide, fournie seulement si ranges::empty lui est applicable (fonction membre publique de std::ranges::view_interface<D>)
| |
| renvoie le premier élément de la vue dérivée, fournie si elle satisfait forward_range (fonction membre publique de std::ranges::view_interface<D>)
| |
| renvoie le dernier élément de la vue dérivée, fournie seulement 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
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) |