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 habe meine eigenen mit strtok gerollt und verwendet Boost, um eine Zeichenfolge zu teilen. Die beste Methode, die ich gefunden habe, ist die C++ String Toolkit Bibliothek . Es ist unglaublich flexibel und schnell.

#include <iostream>
#include <vector>
#include <string>
#include <strtk.hpp>

const char *whitespace  = " \t\r\n\f";
const char *whitespace_and_punctuation  = " \t\r\n\f;,=";

int main()
{
    {   // normal parsing of a string into a vector of strings
        std::string s("Somewhere down the road");
        std::vector<std::string> result;
        if( strtk::parse( s, whitespace, result ) )
        {
            for(size_t i = 0; i < result.size(); ++i )
                std::cout << result[i] << std::endl;
        }
    }

    {  // parsing a string into a vector of floats with other separators
        // besides spaces

        std::string s("3.0, 3.14; 4.0");
        std::vector<float> values;
        if( strtk::parse( s, whitespace_and_punctuation, values ) )
        {
            for(size_t i = 0; i < values.size(); ++i )
                std::cout << values[i] << std::endl;
        }
    }

    {  // parsing a string into specific variables

        std::string s("angle = 45; radius = 9.9");
        std::string w1, w2;
        float v1, v2;
        if( strtk::parse( s, whitespace_and_punctuation, w1, v1, w2, v2) )
        {
            std::cout << "word " << w1 << ", value " << v1 << std::endl;
            std::cout << "word " << w2 << ", value " << v2 << std::endl;
        }
    }

    return 0;
}

Das Toolkit ist viel flexibler als dieses einfache Beispiel zeigt, aber sein Nutzen beim Parsen einer Zeichenkette in nützliche Elemente ist unglaublich.

Answer 2

Ich kann nicht glauben, wie übermäßig kompliziert die meisten dieser Antworten waren. Warum hat nicht jemand etwas so Einfaches vorgeschlagen?

#include <iostream>
#include <sstream>

std::string input = "This is a sentence to read";
std::istringstream ss(input);
std::string token;

while(std::getline(ss, token, ' ')) {
    std::cout << token << endl;
}

Answer 3

Wie wäre es damit:

#include <string>
#include <vector>

using namespace std;

vector<string> split(string str, const char delim) {
    vector<string> v;
    string tmp;

    for(string::const_iterator i; i = str.begin(); i <= str.end(); ++i) {
        if(*i != delim && i != str.end()) {
            tmp += *i; 
        } else {
            v.push_back(tmp);
            tmp = ""; 
        }   
    }   

    return v;
}

Answer 4

Kürzlich musste ich ein Wort in Unterwörter aufteilen, das in Großbuchstaben geschrieben war. Es gibt keine Begrenzungszeichen, nur Großbuchstaben.

#include <string>
#include <list>
#include <locale> // std::isupper

template<class String>
const std::list<String> split_camel_case_string(const String &s)
{
    std::list<String> R;
    String w;

    for (String::const_iterator i = s.begin(); i < s.end(); ++i) {  {
        if (std::isupper(*i)) {
            if (w.length()) {
                R.push_back(w);
                w.clear();
            }
        }
        w += *i;
    }

    if (w.length())
        R.push_back(w);
    return R;
}

So wird zum Beispiel "AQueryTrades" in "A", "Query" und "Trades" aufgeteilt. Die Funktion arbeitet mit schmalen und breiten Zeichenketten. Da sie das aktuelle Gebietsschema berücksichtigt, zerlegt sie "RaumfahrtÜberwachungsVerordnung" in "Raumfahrt", "Überwachung" und "Verordnung".

Hinweis std::upper sollte wirklich als Funktionsvorlagenargument übergeben werden. Dann kann die verallgemeinerte Version dieser Funktion an Begrenzungszeichen wie "," , ";" o " " también.

Answer 5

Hier ist eine andere Möglichkeit, es zu tun.

void split_string(string text,vector<string>& words)
{
  int i=0;
  char ch;
  string word;

  while(ch=text[i++])
  {
    if (isspace(ch))
    {
      if (!word.empty())
      {
        words.push_back(word);
      }
      word = "";
    }
    else
    {
      word += ch;
    }
  }
  if (!word.empty())
  {
    words.push_back(word);
  }
}