Wie kann ich eine Zeichenkette in C++ tokenisieren?

Question

Java verfügt über eine praktische Split-Methode:

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

Gibt es eine einfache Möglichkeit, dies in C++ zu tun?

Answer 1

Viele übermäßig komplizierte Vorschläge hier. Versuchen Sie diese einfache std::string Lösung:

using namespace std;

string someText = ...

string::size_type tokenOff = 0, sepOff = tokenOff;
while (sepOff != string::npos)
{
    sepOff = someText.find(' ', sepOff);
    string::size_type tokenLen = (sepOff == string::npos) ? sepOff : sepOff++ - tokenOff;
    string token = someText.substr(tokenOff, tokenLen);
    if (!token.empty())
        /* do something with token */;
    tokenOff = sepOff;
}

Answer 2

Wenn Sie bereit sind, C zu verwenden, können Sie die strtok Funktion. Bei der Verwendung dieser Funktion sollten Sie das Thema Multithreading beachten.

Answer 3

Ich weiß, dass diese Frage bereits beantwortet wurde, aber ich möchte einen Beitrag leisten. Vielleicht ist meine Lösung ein bisschen einfach, aber das ist, was ich mir ausgedacht habe:

vector<string> get_words(string const& text, string const& separator)
{
    vector<string> result;
    string tmp = text;

    size_t first_pos = 0;
    size_t second_pos = tmp.find(separator);

    while (second_pos != string::npos)
    {
        if (first_pos != second_pos)
        {
            string word = tmp.substr(first_pos, second_pos - first_pos);
            result.push_back(word);
        }
        tmp = tmp.substr(second_pos + separator.length());
        second_pos = tmp.find(separator);
    }

    result.push_back(tmp);

    return result;
}

Bitte kommentieren Sie, wenn es einen besseren Ansatz für etwas in meinem Code gibt oder wenn etwas falsch ist.

UPDATE: Generisches Trennzeichen hinzugefügt

Answer 4

Ich dachte, das wäre das, was die >> Operator auf String-Streams war für:

string word; sin >> word;

Answer 5

Hier ist ein Ansatz, mit dem Sie steuern können, ob leere Token eingeschlossen (wie strsep) oder ausgeschlossen (wie strtok) werden.

#include <string.h> // for strchr and strlen

/*
 * want_empty_tokens==true  : include empty tokens, like strsep()
 * want_empty_tokens==false : exclude empty tokens, like strtok()
 */
std::vector<std::string> tokenize(const char* src,
                                  char delim,
                                  bool want_empty_tokens)
{
  std::vector<std::string> tokens;

  if (src and *src != '\0') // defensive
    while( true )  {
      const char* d = strchr(src, delim);
      size_t len = (d)? d-src : strlen(src);

      if (len or want_empty_tokens)
        tokens.push_back( std::string(src, len) ); // capture token

      if (d) src += len+1; else break;
    }

  return tokens;
}