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

Y a-t-il plus que des progrès à prendre avant des chiffres négatifs?

std::advance

  • modifie son argument
  • ne retourne rien
  • fonctionne sur des iterators d’entrée ou mieux (ou des iterators bidirectionnels si une distance négative est donnée)

std::next

  • laisse son argument non modifié
  • renvoie une copie de l’argument, avancé du montant spécifié
  • fonctionne sur des iterators avant ou mieux (ou des iterators bidirectionnels si une distance négative est donnée))

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

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

Et puis il y a les valeurs de retour:

  • std::advance() : (none) (l’iterator transmis est modifié)
  • std::next() : Le n- ième successeur.

std::next() prend des nombres négatifs comme std::advance , et dans ce cas, l’iterator doit être bidirectionnel. std::prev() serait plus lisible lorsque l’intention est précisément de reculer.

std :: avancer

La fonction advance () incrémente la position d’un iterator passé en argument. Ainsi, la fonction permet à l’iterator d’avancer (ou de reculer) plus d’un élément:

 #include  void advance (InputIterator& pos, Dist n) 
  • Permet à l’iterator d’entrée de placer l’étape n en avant ( ou en arrière ).
  • Pour les iterators bidirectionnels et à access aléatoire, n peut être négatif pour revenir en arrière.
  • Dist est un type de modèle. Normalement, il doit s’agir d’un type intégral car les opérations telles que <, ++, - et les comparaisons avec 0 sont appelées.
  • Notez que advance () ne vérifie pas s’il traverse la fin () d’une séquence (il ne peut pas vérifier car les iterators 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’opérateur d’appel ++ pour la fin d’une séquence n’est pas défini.

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

 #include  ForwardIterator next (ForwardIterator pos) ForwardIterator next (ForwardIterator pos, Dist n) 
  • Donne la position qu’aurait l’iterator avant s’il était avancé de 1 ou n positions.
  • Pour les iterators bidirectionnels et à access aléatoire, n peut être négatif pour générer des ositions précédentes.
  • Dist est le type std :: iterator_traits :: difference_type.
  • Appelle l’avance (pos, n) pour un object temporaire interne.
  • Notez que next () ne vérifie pas s’il traverse la fin () d’une séquence. Il appartient donc à l’appelant de s’assurer que le résultat est valide.

Citer de la The C++ Standard Library Second Edition

Ils sont à peu près les mêmes, sauf que std::next retourne une copie et std::advance modifie son argument. Notez que le standard nécessite std::next pour se comporter comme std::advance :

24.4.4 Opérations d’iterator [Opérations d’iterator]

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

2. Nécessite: n doit être négatif uniquement pour les iterators bidirectionnels et à access aléatoire
3. Effets: Incrémente (ou décrémente pour n négatif) la référence de l’iterator i par n.
[…]

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

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

Notez que les deux prennent en charge les valeurs négatives si l’iterator est un iterator en entrée. Notez également que std::next requirejs que l’iterator remplisse les conditions d’un ForwardIterator, alors que std::advance n’a besoin que d’un iterator en entrée (si vous n’utilisez pas de distances négatives).