Wie kann ich über die Wörter einer Zeichenkette iterieren?

Question

Ich versuche, über die Wörter einer Zeichenkette zu iterieren.

Es kann davon ausgegangen werden, dass die Zeichenfolge aus durch Leerzeichen getrennten Wörtern besteht.

Beachten Sie, dass ich nicht in C-String-Funktionen oder diese Art von Zeichenmanipulation / Zugriff interessiert bin. Bitte geben Sie in Ihrer Antwort auch der Eleganz den Vorrang vor der Effizienz.

Die beste Lösung, die ich im Moment habe, ist:

#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);
}

Gibt es eine elegantere Möglichkeit, dies zu tun?

Answer 1

Ich verwende dies, um eine Zeichenkette durch ein Begrenzungszeichen zu trennen. Die erste setzt die Ergebnisse in einen vordefinierten Vektor, die zweite gibt einen neuen Vektor zurück.

#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;
}

---

Beachten Sie, dass diese Lösung keine leeren Token überspringt, so dass im Folgenden 4 Einträge gefunden werden, von denen einer leer ist:

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

Answer 2

Hier ist eine weitere Möglichkeit, Token aus einer Eingabezeichenkette zu extrahieren, die nur auf Standardbibliotheksfunktionen zurückgreift. Dies ist ein Beispiel für die Leistungsfähigkeit und Eleganz, die hinter dem Design der STL steckt.

#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"));
}

Anstatt die extrahierten Token in einen Ausgabestrom zu kopieren, könnte man sie in einen Container einfügen, indem man die gleiche generische copy Algorithmus.

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

... oder erstellen Sie die vector direkt:

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

Answer 3

Eine mögliche Lösung mit Boost könnte sein:

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

Dieser Ansatz könnte sogar schneller sein als die stringstream Ansatz. Da es sich um eine generische Vorlagenfunktion handelt, können auch andere Zeichenkettentypen (wchar usw. oder UTF-8) mit allen möglichen Begrenzungszeichen aufgeteilt werden.

Siehe die Dokumentation für Details.

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

Für diejenigen, die es nicht gut finden, alle Effizienz für die Codegröße zu opfern und "effizient" als eine Art von Eleganz zu sehen, sollte das Folgende einen guten Punkt treffen (und ich denke, die Template-Container-Klasse ist eine unglaublich elegante Ergänzung):

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;
   }
}

Ich verwende normalerweise std::vector<std::string> Typen als zweiten Parameter ( ContainerT )... aber list<> ist viel schneller als vector<> für den Fall, dass ein direkter Zugriff nicht erforderlich ist, und Sie können sogar Ihre eigene String-Klasse erstellen und etwas verwenden wie std::list<subString> wobei subString macht keine Kopien für unglaubliche Geschwindigkeitssteigerungen.

Es ist mehr als doppelt so schnell wie das schnellste Tokenize auf dieser Seite und fast fünfmal so schnell wie einige andere. Mit den perfekten Parametertypen können Sie auch alle String- und Listenkopien eliminieren, was die Geschwindigkeit zusätzlich erhöht.

Außerdem erfolgt keine (äußerst ineffiziente) Rückgabe des Ergebnisses, sondern die Token werden als Verweis übergeben, so dass Sie auch Token über mehrere Aufrufe aufbauen können, wenn Sie dies wünschen.

Schließlich können Sie über einen letzten optionalen Parameter angeben, ob leere Token aus den Ergebnissen entfernt werden sollen.

Alles was es braucht ist std::string ... der Rest ist optional. Es verwendet keine Streams oder die Boost-Bibliothek, ist aber flexibel genug, um einige dieser fremden Typen natürlich zu akzeptieren.