Comment itérer sur les mots d'une chaîne de caractères ?

Question

J'essaie d'itérer sur les mots d'une chaîne.

On peut supposer que la chaîne de caractères est composée de mots séparés par des espaces.

Notez que je ne suis pas intéressé par les fonctions de chaîne de caractères en C ou ce genre de manipulation/accès aux caractères. Par ailleurs, veuillez privilégier l'élégance à l'efficacité dans votre réponse.

La meilleure solution que j'ai pour le moment est :

#include <iostream>
#include <sstream>
#include <string>

using namespace std;

int main()
{
    string s = "Somewhere down the road";
    istringstream iss(s);

    do
    {
        string subs;
        iss >> subs;
        cout << "Substring: " << subs << endl;
    } while (iss);
}

Existe-t-il une manière plus élégante de procéder ?

Answer 1

Je l'utilise pour séparer une chaîne de caractères par un délimiteur. La première met les résultats dans un vecteur pré-construit, la seconde retourne un nouveau vecteur.

#include <string>
#include <sstream>
#include <vector>
#include <iterator>

template <typename Out>
void split(const std::string &s, char delim, Out result) {
    std::istringstream iss(s);
    std::string item;
    while (std::getline(iss, item, delim)) {
        *result++ = item;
    }
}

std::vector<std::string> split(const std::string &s, char delim) {
    std::vector<std::string> elems;
    split(s, delim, std::back_inserter(elems));
    return elems;
}

---

Notez que cette solution ne saute pas les jetons vides, de sorte que ce qui suit trouvera 4 éléments, dont l'un est vide :

std::vector<std::string> x = split("one:two::three", ':');

Answer 2

Pour ce que cela vaut, voici une autre façon d'extraire les mots d'une chaîne de caractères en entrée, en s'appuyant uniquement sur les fonctionnalités de la bibliothèque standard. C'est un exemple de la puissance et de l'élégance de la conception de la STL.

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <iterator>

int main() {
    using namespace std;
    string sentence = "And I feel fine...";
    istringstream iss(sentence);
    copy(istream_iterator<string>(iss),
         istream_iterator<string>(),
         ostream_iterator<string>(cout, "\n"));
}

Au lieu de copier les jetons extraits vers un flux de sortie, on pourrait les insérer dans un conteneur, en utilisant la même méthode générique copy algorithme.

vector<string> tokens;
copy(istream_iterator<string>(iss),
     istream_iterator<string>(),
     back_inserter(tokens));

... ou créer le vector directement :

vector<string> tokens{istream_iterator<string>{iss},
                      istream_iterator<string>{}};

Answer 3

Une solution possible utilisant Boost pourrait être :

#include <boost/algorithm/string.hpp>
std::vector<std::string> strs;
boost::split(strs, "string to split", boost::is_any_of("\t "));

Cette approche pourrait être encore plus rapide que la stringstream l'approche. Et comme il s'agit d'une fonction de modèle générique, elle peut être utilisée pour diviser d'autres types de chaînes (wchar, etc. ou UTF-8) en utilisant toutes sortes de délimiteurs.

Voir le documentation pour les détails.

Answer 4

#include <vector>
#include <string>
#include <sstream>

int main()
{
    std::string str("Split me by whitespaces");
    std::string buf;                 // Have a buffer string
    std::stringstream ss(str);       // Insert the string into a stream

    std::vector<std::string> tokens; // Create vector to hold our words

    while (ss >> buf)
        tokens.push_back(buf);

    return 0;
}

Answer 5

Pour ceux qui n'aiment pas sacrifier l'efficacité au profit de la taille du code et qui considèrent l'efficacité comme une forme d'élégance, ce qui suit devrait faire l'affaire (et je pense que la classe de conteneurs de modèles est un ajout extrêmement élégant) :

template < class ContainerT >
void tokenize(const std::string& str, ContainerT& tokens,
              const std::string& delimiters = " ", bool trimEmpty = false)
{
   std::string::size_type pos, lastPos = 0, length = str.length();

   using value_type = typename ContainerT::value_type;
   using size_type  = typename ContainerT::size_type;

   while(lastPos < length + 1)
   {
      pos = str.find_first_of(delimiters, lastPos);
      if(pos == std::string::npos)
      {
         pos = length;
      }

      if(pos != lastPos || !trimEmpty)
         tokens.push_back(value_type(str.data()+lastPos,
               (size_type)pos-lastPos ));

      lastPos = pos + 1;
   }
}

Je choisis généralement d'utiliser std::vector<std::string> comme deuxième paramètre ( ContainerT )... mais list<> est bien plus rapide que vector<> pour les cas où l'accès direct n'est pas nécessaire, et vous pouvez même créer votre propre classe de chaîne et utiliser quelque chose comme std::list<subString> où subString ne fait pas de copies pour des augmentations de vitesse incroyables.

Il est plus de deux fois plus rapide que le tokenize le plus rapide de cette page et presque 5 fois plus rapide que certains autres. De plus, avec les types de paramètres parfaits, vous pouvez éliminer toutes les copies de chaînes et de listes pour augmenter encore la vitesse.

De plus, il ne renvoie pas le résultat (extrêmement inefficace), mais transmet plutôt les jetons comme une référence, ce qui vous permet également d'accumuler des jetons en utilisant plusieurs appels si vous le souhaitez.

Enfin, il vous permet de spécifier s'il faut couper les tokens vides des résultats via un dernier paramètre facultatif.

Tout ce dont il a besoin est std::string ... le reste est optionnel. Il n'utilise pas les flux ou la bibliothèque boost, mais est suffisamment flexible pour pouvoir accepter certains de ces types étrangers naturellement.