Comment tokeniser une chaîne de caractères en C++ ?

Question

Java dispose d'une méthode de fractionnement pratique :

String str = "The quick brown fox";
String[] results = str.split(" ");

Existe-t-il un moyen simple de faire cela en C++ ?

Answer 1

El Boost tokenizer peut rendre ce genre de chose assez simple :

#include <iostream>
#include <string>
#include <boost/foreach.hpp>
#include <boost/tokenizer.hpp>

using namespace std;
using namespace boost;

int main(int, char**)
{
    string text = "token, test   string";

    char_separator<char> sep(", ");
    tokenizer< char_separator<char> > tokens(text, sep);
    BOOST_FOREACH (const string& t, tokens) {
        cout << t << "." << endl;
    }
}

Mise à jour pour C++11 :

#include <iostream>
#include <string>
#include <boost/tokenizer.hpp>

using namespace std;
using namespace boost;

int main(int, char**)
{
    string text = "token, test   string";

    char_separator<char> sep(", ");
    tokenizer<char_separator<char>> tokens(text, sep);
    for (const auto& t : tokens) {
        cout << t << "." << endl;
    }
}

Answer 2

Les algorithmes de la bibliothèque standard C++ sont presque universellement basés sur des itérateurs plutôt que sur des conteneurs concrets. Malheureusement, cela rend difficile la mise à disposition d'une fonction de type Java split dans la bibliothèque standard C++, même si personne ne soutient que cela serait pratique. Mais quel serait son type de retour ? std::vector<std::basic_string<…>> ? Peut-être, mais alors nous sommes obligés d'effectuer des allocations (potentiellement redondantes et coûteuses).

Au lieu de cela, le C++ offre une pléthore de moyens de diviser les chaînes de caractères en fonction de délimiteurs arbitrairement complexes, mais aucun d'entre eux n'est encapsulé aussi bien que dans d'autres langages. Les nombreux moyens remplir des articles de blog entiers .

Dans sa forme la plus simple, vous pourriez itérer en utilisant std::string::find jusqu'à ce que tu atteignes std::string::npos et extraire le contenu en utilisant std::string::substr .

Une version plus fluide (et idiomatique, mais basique) pour le fractionnement sur les espaces blancs utiliserait une balise std::istringstream :

auto iss = std::istringstream{"The quick brown fox"};
auto str = std::string{};

while (iss >> str) {
    process(str);
}

Utilisation de std::istream_iterator s En outre, le contenu du flux de chaînes de caractères peut également être copié dans un vecteur à l'aide de son constructeur de plage d'itérateurs.

Plusieurs bibliothèques (telles que Boost.Tokenizer ) proposent des tokénisateurs spécifiques.

Un fractionnement plus avancé nécessite des expressions régulières. Le C++ fournit les std::regex_token_iterator à cette fin en particulier :

auto const str = "The quick brown fox"s;
auto const re = std::regex{R"(\s+)"};
auto const vec = std::vector<std::string>(
    std::sregex_token_iterator{begin(str), end(str), re, -1},
    std::sregex_token_iterator{}
);

Answer 3

Un autre moyen rapide est d'utiliser getline . Quelque chose comme :

stringstream ss("bla bla");
string s;

while (getline(ss, s, ' ')) {
 cout << s << endl;
}

Si vous voulez, vous pouvez faire un simple split() retournant un vector<string> qui est vraiment utile.

Answer 4

Utilisez strtok. À mon avis, il n'y a pas besoin de construire une classe autour de la tokenisation, à moins que strtok ne vous fournisse pas ce dont vous avez besoin. Ce n'est peut-être pas le cas, mais en plus de 15 ans d'écriture de divers codes d'analyse syntaxique en C et C++, j'ai toujours utilisé strtok. Voici un exemple

char myString[] = "The quick brown fox";
char *p = strtok(myString, " ");
while (p) {
    printf ("Token: %s\n", p);
    p = strtok(NULL, " ");
}

Quelques mises en garde (qui pourraient ne pas répondre à vos besoins). La chaîne est "détruite" dans le processus, ce qui signifie que les caractères EOS sont placés en ligne dans les emplacements de délimitation. Pour une utilisation correcte, vous devrez peut-être créer une version non-const de la chaîne. Vous pouvez également modifier la liste des délimiteurs à mi-parcours.

À mon avis, le code ci-dessus est beaucoup plus simple et facile à utiliser que l'écriture d'une classe séparée pour cela. Pour moi, c'est une de ces fonctions que le langage fournit et il le fait bien et proprement. Il s'agit simplement d'une solution "basée sur le C". C'est approprié, c'est facile, et vous n'avez pas à écrire beaucoup de code supplémentaire :-)

Answer 5

Vous pouvez utiliser les flux, les itérateurs et l'algorithme de copie pour faire cela assez directement.

#include <string>
#include <vector>
#include <iostream>
#include <istream>
#include <ostream>
#include <iterator>
#include <sstream>
#include <algorithm>

int main()
{
  std::string str = "The quick brown fox";

  // construct a stream from the string
  std::stringstream strstr(str);

  // use stream iterators to copy the stream to the vector as whitespace separated strings
  std::istream_iterator<std::string> it(strstr);
  std::istream_iterator<std::string> end;
  std::vector<std::string> results(it, end);

  // send the vector to stdout.
  std::ostream_iterator<std::string> oit(std::cout);
  std::copy(results.begin(), results.end(), oit);
}