Namespaces
Variants

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

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

Le type de retour de lazy_split_view::begin , et de lazy_split_view::end lorsque la vue sous-jacente est un common_range et un forward_range .

Si l'un des deux, V ou Pattern , n'est pas une vue simple (par exemple, si ranges:: iterator_t < const V > n'est pas valide ou diffère de ranges:: iterator_t < V > ), Const est true pour les itérateurs renvoyés par les surcharges constantes, et false sinon. Si V est une vue simple, Const est true si et seulement si V est un forward_range .

Table des matières

Types membres

Membre Définition
Parent maybe-const  < Const, ranges:: lazy_split_view >
( type membre d'exposition uniquement* )
Base maybe-const  < Const, V >
( type membre d'exposition uniquement* )
iterator_concept
iterator_category
(présent seulement si Base modélise forward_range ) 		std::input_iterator_tag
le type de valeur du outer_iterator
(classe membre publique)
difference_type ranges:: range_difference_t < Base >

Membres de données

Membre Description
Parent * parent_ (privé) un pointeur vers l'objet parent lazy_split_view
( objet membre d'exposition uniquement* )
ranges:: iterator_t < Base > current_ (privé)
(présent uniquement si V modélise forward_range ) 		un itérateur vers la vue sous-jacente
( 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

(constructor)
construit un itérateur
(fonction membre publique)
operator*
retourne le sous-intervalle actuel
(fonction membre publique)
operator++ operator++ (int)
avance l'itérateur
(fonction membre publique)
cur
retourne conditionnellement une référence à current_ (si présent) ou à * parent_ - > current_
( fonction membre d'exposition uniquement* )

Fonctions membres

std::ranges::lazy_split_view:: outer_iterator :: outer_iterator

/*outer_iterator*/ ( ) = default ;
(1) (depuis C++20)
constexpr explicit /*outer_iterator*/ ( Parent & parent )
requires ( ! ranges:: forward_range < Base > ) ;
(2) (depuis C++20)
constexpr /*outer_iterator*/ ( Parent & parent,

ranges:: iterator_t < Base > current )

requires ranges:: forward_range < Base > ;
(3) (depuis C++20)
constexpr /*outer_iterator*/ ( /*outer_iterator*/ < ! Const > i )

requires Const && std:: convertible_to < ranges:: iterator_t < V > ,

ranges:: iterator_t < Base >> ;
(4) (depuis C++20)
1) Initialise les membres de données non statiques avec leur initialiseur de membre par défaut, c'est-à-dire :
  • parent_ = nullptr ; ,
  • current_ = iterator_t < Base > ( ) ; (présent uniquement si V modélise forward_range ),
2) Initialise parent_ avec std:: addressof ( parent ) .
3) Initialise parent_ avec std:: addressof ( parent ) et current_ avec std :: move ( current ) .
4) Initialise parent_ avec i. parent_ , current_ avec std :: move ( i. current_ ) , et trailing_empty_ avec t. trailing_empty_ .

Le trailing_empty_ est initialisé avec son initialiseur de membre par défaut à false .

std::ranges::lazy_split_view:: outer_iterator :: operator*

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

Équivalent à return value_type { * this } ; .

std::ranges::lazy_split_view:: outer_iterator :: operator++

constexpr /*outer_iterator*/ & operator ++ ( ) ;
(1) (depuis C++20)
constexpr decltype ( auto ) operator ++ ( int ) ;
(2) (depuis C++20)
1) Le corps de la fonction est équivalent à 
const auto end = ranges::end(parent_->base_);
if (/*cur*/() == end)
{
    trailing_empty_ = false;
    return *this;
}
const auto [pbegin, pend] = ranges::subrange{parent_->pattern_};
if (pbegin == pend)
    ++/*cur*/();
else if constexpr (/*tiny_range*/<Pattern>)
{
    /*cur*/() = ranges::find(std::move(/*cur*/()), end, *pbegin);
    if (/*cur*/() != end)
    {
        ++/*cur*/();
        if (/*cur*/() == end)
            trailing_empty_ = true;
    }
}
else
{
    do
    {
        auto [b, p] = ranges::mismatch(/*cur*/(), end, pbegin, pend);
        if (p == pend)
        {
            /*cur*/() = b;
            if (/*cur*/() == end)
                trailing_empty_ = true;
            break; // Le motif correspond ; le sauter
        }
    } while (++/*cur*/() != end);
}
return *this;
2) Équivalent à 
if constexpr (ranges::forward_range<Base>)
{
    auto tmp = *this;
    ++*this;
    return tmp;
}
else
{
    ++*this; // aucune instruction return
}

std::ranges::lazy_split_view:: outer_iterator :: cur ()

constexpr auto & /*cur*/ ( ) noexcept ;
(1) (depuis C++20)
( exposition uniquement* )
constexpr auto & /*cur*/ ( ) const noexcept ;
(2) (depuis C++20)
( exposition uniquement* )

Cette fonction membre de commodité est référencée depuis /*outer_iterator*/ :: operator ++ ( ) , depuis la fonction non-membre operator == ( const /*outer_iterator*/ & , std:: default_sentinel_t ) , et depuis certaines fonctions membres de l'implémentation possible de inner_iterator .

1,2) Équivalent à 
if constexpr (ranges::forward_range<V>)
    return current_;
else
    return *parent->current_;

Fonctions non membres

operator==
(C++20)
compare les itérateurs sous-jacents ou l'itérateur sous-jacent et std::default_sentinel
(fonction)

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

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

const /*outer_iterator*/ & y )

requires forward_range < Base > ;
(1) (depuis C++20)
friend constexpr bool operator == ( const /*outer_iterator*/ & x,
std:: default_sentinel_t ) ;
(2) (depuis C++20)
1) Équivalent à return x. current_ == y. current_ and x. trailing_empty_ == y. trailing_empty_ ; .
2) Équivalent à return x. /*cur*/ ( ) == ranges:: end ( x. parent_ - > base_ ) and ! x. trailing_empty_ ; .

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

Ces fonctions ne sont pas visibles par la recherche non qualifiée ou recherche qualifiée ordinaire, et ne peuvent être trouvées que par la recherche dépendante des arguments lorsque std::ranges::split_view:: outer_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
LWG 3904 C++20 trailing_empty_ n'était pas initialisé dans le constructeur ( 4 ) initialisé