Namespaces
Variants

std::experimental::ranges:: next

From cppreference.net
Défini dans l'en-tête <experimental/ranges/iterator>
namespace {

constexpr /* non spécifié */ next = /* non spécifié */ ;

}
(ranges TS)
(objet de point de personnalisation)
Signature d'appel
template < Iterator I >
constexpr I next ( I i ) ;
(1)
template < Iterator I >
constexpr I next ( I i, ranges :: difference_type_t < I > n ) ;
(2)
template < Iterator I, Sentinel < I > S >
constexpr I next ( I i, S bound ) ;
(3)
template < Iterator I, Sentinel < I > S >
constexpr I next ( I i, ranges :: difference_type_t < I > n, S bound ) ;
(4)

Avance l'itérateur i n fois, ou jusqu'à ce que bound soit atteint, selon la première éventualité, et retourne l'itérateur avancé.

1) Équivalent à ++ i ; return i ; .
2) Équivalent à ranges:: advance ( i, n ) ; return i ; .
3) Équivalent à ranges:: advance ( i, bound ) ; return i ; .
4) Équivalent à ranges:: advance ( i, n, bound ) ; return i ; .

Table des matières

Objets de point de personnalisation

Le nom ranges::next désigne un objet de point de personnalisation , qui est un objet fonction d'un type de classe littéral Semiregular (désigné, à des fins d'exposition, comme NextT ). Toutes les instances de NextT sont égales. Ainsi, ranges::next peut être copié librement et ses copies peuvent être utilisées de manière interchangeable.

Étant donné un ensemble de types Args... , si std:: declval < Args > ( ) ... satisfont aux exigences pour les arguments de ranges::next ci-dessus, NextT satisfera ranges :: Invocable < const NextT, Args... > . Sinon, aucun opérateur d'appel de fonction de NextT ne participe à la résolution de surcharge.

Dans chaque unité de traduction où ranges::next est défini, il fait référence à la même instance de l'objet de point de personnalisation. (Cela signifie qu'il peut être utilisé librement dans des éléments comme les fonctions inline et les modèles de fonction sans violer la règle de définition unique .)

Valeur de retour

L'itérateur avancé.

Notes

Bien que l'omission de n pour la surcharge (2) se comporte comme si n était 1, l'omission de n pour la surcharge (4) se comporte effectivement comme si n était l'infini (avance toujours jusqu'à bound ).

Exemple

Voir aussi

(C++11)
incrémente un itérateur
(modèle de fonction)
avance un itérateur d'une distance donnée
(modèle de fonction)
décrémente un itérateur
(modèle de fonction)
retourne la distance entre un itérateur et un sentinelle, ou entre le début et la fin d'une plage
(modèle de fonction)