Pourquoi `std :: string :: find ()` ne retourne pas l'itérateur de fin en cas d'échec?

Je trouve que le comportement de std::string::findn'est pas cohérent avec les conteneurs C ++ standard.

Par exemple

std::map<int, int> myMap = {{1, 2}};
auto it = myMap.find(10);  // it == myMap.end()

Mais pour une chaîne,

std::string myStr = "hello";
auto it = myStr.find('!');  // it == std::string::npos

Pourquoi le myStr.find('!')retour échoué ne devrait-il pas myStr.end()plutôt std::string::npos?

Étant donné que le std::stringest quelque peu spécial par rapport à d'autres conteneurs, je me demande s'il y a une vraie raison derrière cela. (Étonnamment, je n'ai trouvé personne qui remette cela en question).

c++ stdstring c++-standard-library

— Sumudu
source

Je pense que seule une réponse raisonnable est proche de la réponse à la question: «Pourquoi les hot-dogs sont-ils emballés en 4 et les petits pains en 6?» Eh bien, c'est comme ça que le monde est

— arrivé

Vérifiez ceci

— NutCracker

À mon humble avis, une raison de ce comportement serait que, en std::stringinterne, se compose de caractères qui sont des éléments peu coûteux (en ce qui concerne la mémoire). Et, en outre, le caractère est le seul type std::stringpouvant contenir. D'autre part, se std::mapcompose d'éléments plus complexes. De plus, la spécification de std::map::finddit qu'il est censé trouver un élément, et la spécification de std::string::finddit que sa tâche est de trouver la position.

— NutCracker

Pour la carte, vous ne pouvez pas avoir d'itérateur npos, donc l'itérateur de fin est utilisé. Pour la chaîne, nous pouvons utiliser npos, alors pourquoi pas :)

— LF

Réponses:

Pour commencer, l' std::stringinterface est bien connue pour être gonflée et incohérente, voir Gotw84 de Herb Sutter sur ce sujet. Mais néanmoins, il y a un raisonnement derrière le std::string::findretour d' un indice: std::string::substr. Cette fonction de membre de commodité fonctionne sur des indices, par exemple

const std::string src = "abcdefghijk";

std::cout << src.substr(2, 5) << "\n";

Vous pouvez implémenter de substrtelle sorte qu'il accepte les itérateurs dans la chaîne, mais nous n'aurions pas besoin d'attendre longtemps pour les plaintes bruyantes std::stringinutilisables et contre-intuitives. Donc, étant donné que cela std::string::substraccepte les indices, comment trouveriez-vous l'indice de la première occurrence de 'd'dans la chaîne d'entrée ci-dessus afin d'imprimer tout à partir de cette sous-chaîne?

const auto it = src.find('d'); // imagine this returns an iterator

std::cout << src.substr(std::distance(src.cbegin(), it));

Ce n'est peut-être pas non plus ce que vous voulez. On peut donc laisser std::string::findretourner un indice, et nous voici:

const std::string extracted = src.substr(src.find('d'));

Si vous souhaitez travailler avec des itérateurs, utilisez <algorithm>. Ils vous permettent de ce qui précède comme

auto it = std::find(src.cbegin(), src.cend(), 'd');

std::copy(it, src.cend(), std::ostream_iterator<char>(std::cout));

— lubgr
source

Bon point. Cependant, au lieu de renvoyer un itérateur, std::string::findpourrait toujours retourner size(), au lieu de npos, conserver la compatibilité avec substr, tout en évitant plusieurs brances supplémentaires.

— erenon

@erenon Peut-être, mais std::string::substrcouvre déjà le cas "commencer ici jusqu'à la fin" avec un paramètre par défaut pour le deuxième index ( npos). Je suppose que revenir size()serait aussi déroutant et avoir une sentinelle littérale comme npospourrait être le meilleur choix?!

— lubgr

@lubgr Mais si std::string::findrenvoie un itérateur, std::string::substraccepterait probablement aussi un itérateur pour la position de départ. Votre exemple avec find serait le même dans les deux cas dans ce monde alternatif.

— Mattias Wallin

@MattiasWallin Bon point. Mais std::string::substravec un argument itérateur, cela ouvre la porte à un autre cas UB (en plus du scénario de fin de cycle qui peut tout aussi bien se produire avec des indices ou des itérateurs): passer un itérateur qui fait référence à une autre chaîne.

— lubgr

En effet, std::stringavoir deux interfaces:

L' interface générale basée sur un itérateur trouvée sur tous les conteneurs
L' interface basée sur un indexstd::string spécifique

std::string::findfait partie de l' interface basée sur un index et renvoie donc des indices.

Utilisez std::findpour utiliser l'interface générale basée sur un itérateur.

À utiliser std::vector<char>si vous ne voulez pas l'interface basée sur l'index (ne faites pas cela).

— Mattias Wallin
source