Namespaces
Variants

std::ranges::filter_view<V,Pred>:: iterator

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::filter_view
class /*iterator*/ ;
(depuis C++20)
( exposition uniquement* )

Le type de retour de filter_view::begin .

Ceci est un bidirectional_iterator si V modélise bidirectional_range , un forward_iterator si V modélise forward_range , et input_iterator sinon.

La modification de l'élément désigné par cet itérateur est autorisée, mais entraîne un comportement indéfini si la valeur résultante ne satisfait pas au prédicat du filtre.

Table des matières

Types membres

Type Définition
iterator_concept
iterator_category
(présent uniquement si V modélise
forward_range )

Soit C le type std:: iterator_traits < ranges:: iterator_t < V >> :: iterator_category .

value_type ranges:: range_value_t < V >
difference_type ranges:: range_difference_t < V >

Membres de données

Membre Description
ranges:: iterator_t < V > current_ (privé) un itérateur vers la view sous-jacente
( objet membre d'exposition uniquement* )
ranges:: filter_view < V, Pred > * parent_ (privé) un pointeur vers l'objet filter_view parent
( objet membre d'exposition uniquement* )

Fonctions membres

construit un itérateur
(fonction membre publique)
retourne l'itérateur sous-jacent
(fonction membre publique)
transmet à l'itérateur sous-jacent
(fonction membre publique)
avance l'itérateur
(fonction membre publique)
décrémente l'itérateur
(fonction membre publique)

std::ranges::filter_view:: iterator :: iterator

/*iterator*/ ( )
requires std:: default_initializable < ranges:: iterator_t < V >> = default ;
(1) (since C++20)
constexpr /*iterator*/ ( filter_view & parent,
ranges:: iterator_t < V > current ) ;
(2) (since C++20)
1) Initialise current_ et parent_ avec leurs initialiseurs de membre par défaut, qui sont = ranges:: iterator_t < V > ( ) et = nullptr respectivement.
2) Initialise current_ avec std :: move ( current ) et parent_ avec std:: addressof ( parent ) .

std::ranges::filter_view:: iterator :: base

constexpr const ranges:: iterator_t < V > & base ( ) const & noexcept ;
(1) (depuis C++20)
constexpr ranges:: iterator_t < V > base ( ) && ;
(2) (depuis C++20)
1) Équivalent à return current_ ; .
2) Équivalent à return std :: move ( current_ ) ; .

std::ranges::filter_view:: iterator :: operator*,->

constexpr ranges:: range_reference_t < V > operator * ( ) const ;
(1) (depuis C++20)
constexpr ranges:: iterator_t < V > operator - > ( ) const

requires /*has-arrow*/ < ranges:: iterator_t < V >> &&

std:: copyable < ranges:: iterator_t < V >> ;
(2) (depuis C++20)
1) Équivalent à return * current_ ; .
2) Équivalent à return current_ ; .

Pour un type I , /*has-arrow*/ < I > est modélisé ou satisfait, si et seulement si I modélise ou satisfait input_iterator respectivement, et soit I est un type pointeur, soit requires ( I i ) { i. operator - > ( ) ; } est true .

std::ranges::filter_view:: iterator :: operator++

constexpr /*iterator*/ & operator ++ ( ) ;
(1) (depuis C++20)
constexpr void operator ++ ( int ) ;
(2) (depuis C++20)
constexpr /*iterator*/ operator ++ ( int )
requires ranges:: forward_range < V > ;
(3) (depuis C++20)
1) Équivalent à
current_ = ranges:: find_if ( std :: move ( ++ current_ ) , ranges:: end ( parent_ - > base_ ) ,
std:: ref ( * parent_ - > pred_ ) ) ;
return * this ; .
2) Équivalent à ++* this ; .
3) Équivalent à auto tmp = * this ; ++* this ; return tmp ; .

std::ranges::filter_view:: iterator :: operator--

constexpr /*iterator*/ & operator -- ( )
requires ranges:: bidirectional_range < V > ;
(1) (since C++20)
constexpr /*iterator*/ operator -- ( int )
requires ranges:: bidirectional_range < V > ;
(2) (since C++20)
1) Équivalent à
do
-- current_ ;
while ( ! std:: invoke ( * parent_ - > pred_, * current_ ) ) ;
return * this ; .
2) Équivalent à auto tmp = * this ; --* this ; return tmp ; .

Fonctions non membres

(C++20)
compare les itérateurs sous-jacents
(fonction)
(C++20)
convertit le résultat du déréférencement de l'itérateur sous-jacent en son type de référence rvalue associé
(fonction)
(C++20)
échange les objets pointés par deux itérateurs sous-jacents
(fonction)

operator== (std::ranges::filter_view:: iterator )

friend constexpr bool operator == ( const /*iterator*/ & x, const /*iterator*/ & y )
requires std:: equality_comparable < ranges:: iterator_t < V >> ;
(depuis C++20)

Équivalent à return x. current_ == y. current_ ; .

L'opérateur != est synthétisé à partir de operator== .

Cette fonction n'est pas visible par la recherche non qualifiée ordinaire ou la recherche qualifiée , et ne peut être trouvée que par la recherche dépendante des arguments lorsque std::ranges::filter_view:: iterator est une classe associée des arguments.

iter_move (std::ranges::filter_view:: iterator )

friend constexpr ranges:: range_rvalue_reference_t < V >

iter_move ( const /*iterator*/ & i )

noexcept ( noexcept ( ranges:: iter_move ( i. current_ ) ) ) ;
(depuis C++20)

Équivalent à return ranges:: iter_move ( i. current_ ) ; .

Cette fonction n'est pas visible par la recherche non qualifiée ordinaire ou la recherche qualifiée , et ne peut être trouvée que par la recherche dépendante des arguments lorsque std::ranges::filter_view:: iterator est une classe associée des arguments.

iter_swap (std::ranges::filter_view:: iterator )

friend constexpr void iter_swap ( const /*iterator*/ & x, const /*iterator*/ & y )

noexcept ( noexcept ( ranges:: iter_swap ( x. current_ , y. current_ ) ) )

requires std:: indirectly_swappable < ranges:: iterator_t < V >> ;
(depuis C++20)

Équivalent à ranges:: iter_swap ( x. current_ , y. current_ ) .

Cette fonction n'est pas visible par la recherche non qualifiée ou recherche qualifiée ordinaire, et ne peut être trouvée que par la recherche dépendante des arguments lorsque std::ranges::filter_view:: iterator est une classe associée des arguments.

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 correct
P2259R1 C++20 le type membre iterator_category était toujours défini défini uniquement si V est un forward_range
LWG 3533 C++20 la surcharge const & de base copiait l'itérateur sous-jacent retourne une référence vers celui-ci
LWG 3593 C++20 la surcharge const & de base pouvait ne pas être noexcept rendue noexcept