std:: remove avec vector:: erase et comportement indéfini

Partout sur le web, Je vois des gens utiliser l'idiome erase / remove pour les vecteurs C++ comme ceci:

#include <vector> // the general-purpose vector container
#include <iostream>
#include <algorithm> // remove and remove_if
int main()
{
  // initialises a vector that holds the numbers from 0-9.
  std::vector<int> v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

  // removes all elements with the value 5
  v.erase( std::remove( v.begin(), v.end(), 5 ), v.end() );

  return 0;
}

C'est-à-dire, si je veux effacer tous les éléments correspondant à certains critères (par exemple le nombre 5 d'un vecteur de int s), alors j'utilise std::remove ou std::remove_if en conjonction avec vector.erase comme ceci:

vector.erase( std::remove( vector.begin(), vector.end(), <some_value>), vector.end());

Cela fonctionne bien en général; std::remove (et remove_if) copie (ou l'utilisation d'une sémantique de déplacement dans C++11) les éléments qui doivent être supprimés à la fin du vecteur, le vecteur de notre l'exemple précédent ressemblera maintenant à ceci:

{ 0, 1, 2, 3, 4, 6, 7, 8, 9, 5 };

Avec l'élément 5 en gras parce qu'il a été déplacé à la fin.

Maintenant, std::remove retourne un itérateur pour elle, que nous utilisons ensuite dans erase pour effacer les éléments. Beau.

Mais qu'en est-il de l'exemple suivant?

int main()
{
  // initialises an empty vector.
  std::vector<int> v = {};

  // removes all elements with the value 5
  v.erase( std::remove( v.begin(), v.end(), 5 ), v.end() );

  return 0;
}

Cela semble fonctionner comme prévu (ne rien effacer, ne pas segmenter, etc.) sur toutes les plates-formes, Je l'exécute sur, mais je sais que juste parce que quelque chose fonctionne, ne signifie pas que ce n'est pas un comportement indéfini.

Rapide référence pour vector.erase, dit ceci (l'emphase est mienne):

iterator erase (const_iterator first, const_iterator last);

first, last sont

Itérateurs spécifiant une plage dans le vecteur] à supprimer: [first,last). c'est-à-dire que la plage comprend tous les éléments compris entre first et last, y compris l'élément pointé par le premier mais pas celui pointé par last. Les types de membres iterator et const_iterator sont aléatoires accédez aux types d'itérateurs qui pointent vers des éléments.

Est Donc vector.erase(vector.end(),vector.end()) comportement indéfini?

Voici ce que dit la référence rapide sur la sécurité des exceptions:

Si les éléments supprimés incluent le dernier élément dans le conteneur, aucune exception n'est lancée (garantie de non-lancer). Sinon, le conteneur est garanti pour se terminer dans un état valide (garantie de base). Un position ou range invalide provoque un comportement indéfini.

Donc, la réponse, au moins pour moi semble être "oui", et cette réponse StackOverflow semble le soutenir.

Par conséquent, l'idiome commun est-il faux?

En supposant que c'est un comportement indéfini, alors tout appel à {[25] } pourrait renvoyer un itérateur à {[26] } qui devrait être vérifié avant d'appeler vector.erase, et appeler remove sur un vecteur vide semble revenir vector.end: (IDEOne pour le code ci-dessous )

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main() {
   vector<int> myInts;
   auto anIter = std::remove(myInts.begin(),myInts.end(),5);
   if (anIter == myInts.end())
      std::cout << "iterator = myInts.end()";
}

Enfin, ma question:

L'idiome supprimer/effacer réel devrait-il être cette?

auto endOfRangeIterator = std::remove(vector.begin(), vector.end(), <value>);
if (endOfRangeIterator != vector.end())
   vector.erase(endOfRangeIterator, vector.end())