web-dev-qa-db-fra.com

Quelle est la différence entre std :: advance et std :: next?

Y a-t-il plus que l'avance prend des nombres négatifs?

c++c++11std
56
Tavison

std::advance

  • modifie son argument
  • ne renvoie rien
  • fonctionne sur les itérateurs d'entrée ou mieux (ou sur les itérateurs bidirectionnels si une distance négative est donnée)

std::next

  • laisse son argument inchangé
  • renvoie une copie de l'argument, avancé du montant spécifié
  • fonctionne sur les itérateurs avancés ou mieux (ou sur les itérateurs bidirectionnels si une distance négative est donnée))
87
Benjamin Lindley

La plus grande différence pratique est peut-être que std::next() n'est disponible qu'en C++ 11.

std::next() avancera de un par défaut, alors que std::advance() nécessite une distance.

Et puis il y a les valeurs de retour:

std::next() prend des nombres négatifs comme std::advance, et dans ce cas, il faut que l'itérateur soit bidirectionnel. std::prev() serait plus lisible lorsque l'intention est spécifiquement de reculer.

15
Johnsyweb

std :: avance

La fonction Advance () incrémente la position d'un itérateur passé en argument. Ainsi, la fonction permet à l'itérateur d'avancer (ou de reculer) plus d'un élément:

#include <iterator>
void advance (InputIterator& pos, Dist n)
  • Permet à l'itérateur d'entrée de positionner les éléments de l'étape n vers l'avant (ou vers l'arrière).
  • Pour les itérateurs bidirectionnels et à accès aléatoire, n peut être négatif pour reculer.
  • Dist est un type de modèle. Normalement, il doit être de type intégral car des opérations telles que <, ++, - et des comparaisons avec 0 sont appelées.
  • Notez que Advance () ne vérifie pas si elle traverse la fin () d'une séquence (elle ne peut pas le vérifier car les itérateurs en général ne connaissent pas les conteneurs sur lesquels ils opèrent). Ainsi, l'appel de cette fonction peut entraîner un comportement indéfini car l'appel de l'opérateur ++ pour la fin d'une séquence n'est pas défini.

std :: next (et std::prev nouveau en C++ 11)

#include <iterator>
ForwardIterator next (ForwardIterator pos)
ForwardIterator next (ForwardIterator pos, Dist n)
  • Donne la position qu'aurait l'itérateur avant si elle était avancée de 1 ou n positions.
  • Pour les itérateurs bidirectionnels et à accès aléatoire, n peut être négatif pour donner les ositions précédentes.
  • Dist est de type std :: iterator_traits :: difference_type.
  • Appelle l'avance (pos, n) pour un objet temporaire interne.
  • Notez que next () ne vérifie pas s'il croise la fin () d'une séquence. Il appartient donc à l'appelant de s'assurer que le résultat est valide.

citer de The C++ Standard Library Second Edition

6
billz

Ils sont à peu près les mêmes, sauf que std::next Renvoie une copie et std::advance Modifie son argument. Notez que la norme requiert que std::next Se comporte comme std::advance:

24.4.4 Opérations d'itérateur [iterator.operations]

template <class InputIterator, class Distance>
void advance(InputIterator& i [remark: reference], Distance n);

2. Requiert: n doit être négatif uniquement pour les itérateurs à accès bidirectionnel et aléatoire
3. Effets: Incrémente (ou diminue pour n négatif) la référence de l'itérateur i de n.
[...]

template <class ForwardIterator>
ForwardIterator next(ForwardIterator x, [remark: copy]
     typename std::iterator_traits<ForwardIterator>::difference_type n = 1);

6. Effets: équivalent à advance(x, n); return x;

Notez que les deux prennent en charge les valeurs négatives si l'itérateur est un itérateur d'entrée. Notez également que std::next Requiert que l'itérateur réponde aux conditions d'un ForwardIterator, tandis que std::advance N'a besoin que d'un itérateur d'entrée (si vous n'utilisez pas de distances négatives).

3
Zeta