Namespaces
Variants

std::ranges::split_view<V,Pattern>:: iterator

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

Le type de retour de split_view::begin . Ceci est un forward_iterator , donc il est attendu que V modélise au moins forward_range .

Table des matières

Types membres

Type de membre Définition
iterator_concept std::forward_iterator_tag
iterator_category std::input_iterator_tag
value_type ranges:: subrange < ranges:: iterator_t < V >>
difference_type ranges:: range_difference_t < V >

Membres de données

Membre Description
ranges:: split_view < V, Pattern > * parent_ (privé) un pointeur vers l'objet parent split_view
( objet membre d'exposition uniquement* )
ranges:: iterator_t < V > cur_ (privé) un itérateur dans la view sous-jacente qui pointe vers le début d'un sous-intervalle actuel
( objet membre d'exposition uniquement* )
ranges:: subrange < ranges:: iterator_t < V >> next_ (privé) un sous-intervalle vers la position du motif suivant le sous-intervalle actuel
( objet membre d'exposition uniquement* )
bool trailing_empty_ (privé) un indicateur qui signale si un sous-intervalle vide final (le cas échéant) a été atteint
( objet membre d'exposition uniquement* )

Fonctions membres

(constructeur)
(C++20)
construit un itérateur
(fonction membre publique)
base
(C++20)
retourne l'itérateur sous-jacent
(fonction membre publique)
operator*
(C++20)
retourne le sous-intervalle actuel
(fonction membre publique)
operator++ operator++ (int)
(C++20)
avance l'itérateur
(fonction membre publique)

std::ranges::split_view:: iterator :: iterator

/*iterator*/ ( ) = default ;
(1) (depuis C++20)
constexpr /*iterator*/ ( split_view & parent, ranges:: iterator_t < V > current,
ranges:: subrange < ranges:: iterator_t < V >> next ) ;
(2) (depuis C++20)
1) Initialise les membres de données non statiques avec leurs initialiseurs de membre par défaut, c'est-à-dire
2) Initialise les membres de données non statiques :

std::ranges::split_view:: iterator :: base

constexpr const ranges:: iterator_t < V > base ( ) const ;
(depuis C++20)

Équivalent à return cur_ ; .

std::ranges::split_view:: iterator :: operator*

constexpr value_type operator * ( ) const ;
(depuis C++20)

Équivalent à return { cur_, next_. begin ( ) } ; .

std::ranges::split_view:: iterator :: opérateur++

constexpr /*iterator*/ & operator ++ ( ) ;
(1) (depuis C++20)
constexpr void operator ++ ( int ) ;
(2) (depuis C++20)
1) Équivalent à
cur_ = next_. begin ( ) ;

if ( cur_ ! = ranges:: end ( parent_ - > base_ ) )
{
if ( cur_ = next_. end ( ) ; cur_ == ranges:: end ( parent_ - > base_ ) )
{
trailing_empty_ = true ;
next_ = { cur_, cur_ } ;
}
else
next_ = parent_ - > find_next ( cur_ ) ;
}
else
trailing_empty_ = false ;

return * this ;
2) Équivalent à auto tmp = * this ; ++* this ; return tmp ; .

Fonctions non membres

operator==
(C++20)
compare les itérateurs sous-jacents
(fonction)

operator== (std::ranges::split_view:: iterator , std::ranges::split_view:: iterator )

friend constexpr bool operator == ( const /*iterator*/ & x, const /*iterator*/ & y ) ;
(depuis C++20)

Équivalent à return x. cur_ == y. cur_ and x. trailing_empty_ == y. trailing_empty_ ; .

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::split_view:: iterator est une classe associée des arguments.