Namespaces
Variants

std::ranges:: lazy_split_view<V, Pattern>:: inner_iterator

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::lazy_split_view
template < bool Const >
struct /*inner_iterator*/ ;
(depuis C++20)
( exposition uniquement* )

Le type de retour de lazy_split_view:: outer_iterator :: value_type :: begin ( ) .

Const correspond à l'argument template de outer_iterator .

Table des matières

Types membres

Membre Définition
Base maybe-const  < Const, V >
( type de membre d'exposition uniquement* )
iterator_concept
iterator_category
(conditionnellement présent)

Présent uniquement si Base modélise forward_range .

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

Membres de données

Membre Description
outer_iterator < Const > i_ (privé) un itérateur vers la view sous-jacente de l'objet parent lazy_split_view
( objet membre d'exposition uniquement* )
bool incremented_ (privé) un indicateur qui signale si l' operator ++ a été invoqué sur cet objet au moins une fois
( objet membre d'exposition uniquement* )

Fonctions membres

(constructor)
(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 l'élément courant
(fonction membre publique)
operator++ operator++ (int)
(C++20)
incrémente l'itérateur
(fonction membre publique)

Fonctions membres

std::ranges::lazy_split_view:: inner_iterator :: inner_iterator

/*inner_iterator*/ ( ) = default ;
(1) (depuis C++20)
constexpr explicit /*inner_iterator*/ ( /*outer_iterator*/ < Const > i ) ;
(2) (depuis C++20)
1) Initialise par défaut le membre de données i_ via son initialiseur de membre par défaut (= /*outer_iterator*/ < Const > ( ) ).
2) Initialise i_ avec std :: move ( i ) .

Le membre de données incremented_ est initialisé avec son initialiseur de membre par défaut à false .

std::ranges::lazy_split_view:: inner_iterator :: base

constexpr const ranges:: iterator_t < Base > & base ( ) const & noexcept ;
(1) (depuis C++20)
constexpr ranges:: iterator_t < Base > base ( ) &&
requires ranges:: forward_range < V > ;
(2) (depuis C++20)

Retourne une copie de l'itérateur sous-jacent.

1) Construit par copie le résultat à partir de l'itérateur sous-jacent. Équivalent à return i_. /*cur*/ ( ) ; .
2) Construit par déplacement le résultat à partir de l'itérateur sous-jacent. Équivalent à return std :: move ( i_. /*cur*/ ( ) ) ; .

std::ranges::lazy_split_view:: inner_iterator :: operator*

constexpr decltype ( auto ) operator * ( ) const ;
(depuis C++20)

Retourne l'élément pointé par l'itérateur sous-jacent.

Équivalent à return * i_. /*cur*/ ( ) ; .

std::ranges::lazy_split_view:: inner_iterator :: operator++

constexpr /*inner_iterator*/ & operator ++ ( ) ;
(1) (depuis C++20)
constexpr decltype ( auto ) operator ++ ( int ) ;
(2) (depuis C++20)
1) Le corps de la fonction est équivalent à
incremented_ = true ;

if constexpr ( ! ranges:: forward_range < Base > )
{
if constexpr ( Pattern :: size ( ) == 0 )
return * this ;
}
++ i_. /*cur*/ ( ) ;

return * this ;
2) Équivalent à
if constexpr ( ranges:: forward_range < Base > )

{
auto tmp = * this ;
++* this ;
return tmp ;
}
else
++* this ; // aucune instruction return

Fonctions non membres

operator==
(C++20)
compare les itérateurs ou l'itérateur et std::default_sentinel
(fonction)
iter_move
(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)
iter_swap
(C++20)
échange les objets pointés par deux itérateurs sous-jacents
(fonction)

operator== (std::ranges::split_view:: inner_iterator )

friend constexpr bool operator == ( const /*inner_iterator*/ & x,

const /*inner_iterator*/ & y )

requires forward_range < Base > ;
(1) (depuis C++20)
friend constexpr bool operator == ( const /*inner_iterator*/ & x,
std:: default_sentinel_t ) ;
(2) (depuis C++20)
1) Équivalent à return x. i_ . /*cur*/ ( ) == y. i_ . /*cur*/ ( ) ; .
2) Le corps de la fonction est équivalent à 
auto [pcur, pend] = ranges::subrange{x.i_.parent_->pattern_};
auto end = ranges::end(x.i_.parent_->base_);
if constexpr (/*tiny_range*/<Pattern>)
{
    const auto& cur = x.i_./*cur*/();
    if (cur == end)
        return true;
    if (pcur == pend)
        return x.incremented_;
    return *cur == *pcur;
}
else
{
    auto cur = x.i_./*cur*/();
    if (cur == end)
        return true;
    if (pcur == pend)
        return x.incremented_;
    do
    {
        if (*cur != *pcur)
            return false;
        if (++pcur == pend)
            return true;
    }
    while (++cur != end);
    return false;
}

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

Ces fonctions ne sont pas visibles par la recherche non qualifiée ordinaire ou la recherche qualifiée , et ne peuvent être trouvées que par la recherche dépendante des arguments lorsque std::ranges::split_view:: inner_iterator est une classe associée des arguments.

iter_move (std::ranges::split_view:: inner_iterator )

friend constexpr decltype ( auto ) iter_move ( const /*inner_iterator*/ & i )
noexcept ( noexcept ( ranges:: iter_move ( i. i_ . /*cur*/ ( ) ) ) ) ;
(depuis C++20)

Équivalent à return ranges:: iter_move ( i. i_ . /*cur*/ ( ) ) ; .

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

iter_swap (std::ranges::split_view:: inner_iterator )

friend constexpr void iter_swap ( const /*inner_iterator*/ & x,

const /*inner_iterator*/ & y )
noexcept ( noexcept ( ranges:: iter_swap ( x. i_ . current , y. i_ . current ) ) )

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

Équivalent à ranges:: iter_swap ( x. i_ . /*cur*/ ( ) , y. i_ . /*cur*/ ( ) ) .

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::split_view:: inner_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 S'applique à Comportement publié Comportement corrigé
LWG 3591 C++20 la surcharge && de base pourrait invalider les itérateurs externes contraintes ajoutées
LWG 3593 C++20 la surcharge const & de base retourne une référence mais pourrait ne pas être noexcept rendue noexcept