Namespaces
Variants

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

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Indépendant et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support linguistique
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostic
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et heure
    Bibliothèque d'entrée/sortie
    Bibliothèque de système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque de plages
    Adaptateurs de plage
     
    std::ranges::lazy_split_view
     
    template< bool Const >
struct /*outer_iterator*/;
    		(depuis C++20)
    (exposé seulement*)

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

    Si V ou Pattern n'est pas une simple view (par exemple, si ranges::iterator_t<const V> est invalide ou différent de ranges::iterator_t<V>), Const est true pour les itérateurs renvoyés par les surcharges const, et false sinon. Si V est une simple view, Const est true si et seulement si V est un forward_range.

    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 par valeur les membres de données non statiques avec leur initialiseur 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 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; // The pattern matched; skip it
        }
    } while (++/*cur*/() != end);
}
return *this;
    2) Équivalent à 
    if constexpr (ranges::forward_range<Base>)
{
    auto tmp = *this;
    ++*this;
    return tmp;
}
else
{
    ++*this; // no return statement
}

    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 à partir de /*outer_iterator*/::operator++(), de l'élément non membre operator==(const /*outer_iterator*/&, std::default_sentinel_t), et de 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é