Splitting string in einen vector<string> Wörter

Vom Accelerated C++(Buch), fand ich diesen code, das identisch ist mit dem Programm, aber verarbeitet im Programm selbst ist anders, und das verwirrt mich an einigen Teil.

Den code unten gut, natürlich wird es die Ausgabe jedes Wort einzeln(durch Schleifen), basierend auf Benutzereingaben, nachdem der Benutzer das Ende der Datei, dann das Programm beenden.

int main()
{
    string s;
    while (cin >> s)
        cout << s << endl;
    return  0;
}

Im Gegensatz zu den obigen code, dieser speichert jedes Wort in einem vector, dann verwenden Sie einen index i und j zu erkennen, die nicht-whitespace-Zeichen, und die eigentliche Frage ist, ich verstehe nicht, wie es passiert mit dem vector.

Was ist ein Leerraum in vector? Ein element?

Zuerst dachte ich, geht das Programm durch die einzelnen Charakter, weil ich dachte, die whitespace-Zeichen sind Zeichen(die i und j Funktionalität ist), dann das Buch und sagte, es gehen Sie durch die einzelnen Wort, ich weiß nicht, wie um dies zu testen mich, wie ich sehen kann, wie der innere Prozess, in den der compiler selbst bestimmt werden.

vector<string> split(const string& s)
{
    vector<string> ret;
    typedef string::size_type string_size;
    string_size i = 0;

    //invariant: we have processed characters [original value of i, i) 
    while (i != s.size())
    {
        //ignore leading blanks
        //invariant: characters in range [original i, current i) are all spaces
     while (i != s.size() && isspace(s[i]))
         ++i;

     //find end of next word
     string_size j = i;
     //invariant: none of the characters in range [original j, current j)is a space
     while (j != s.size() && !isspace(s[j]))
         j++;
         //if we found some nonwhitespace characters 
         if (i != j) {
             //copy from s starting at i and taking j - i chars
             ret.push_back(s.substr(i, j - i));
             i = j;
         }
    }
    return ret;
}

int main() {
    string s;
    //read and split each line of input 
    while (getline(cin, s)) {
        vector<string> v = split(s);

        //write each word in v
        for (vector<string>::size_type i = 0; i != v.size(); ++i)
             cout << v[i] << endl;
    }
    return 0;
}

Du bist fehlen einige Klammern ({, }) in Ihrem code.
gut, dass ich es einfach kopieren aus dem Buch

InformationsquelleAutor Vastor | 2011-12-08

c++element string vector

3

Den code, den Sie oben gepostet hat nicht teilen Sie eine Linie von text in Wörter, basierend auf Leerzeichen, stattdessen teilt eine Zeile in Zeichen. Aber wenn der code war tatsächlich kompilierbar und nicht fehlen alle notwendigen Klammern ({, }). EDIT: Eigentlich, ob es spaltet Wörter oder einzelne Zeichen hängt davon ab, wo die Klammern gehen, untere Linie ist, dass der code nicht kompilieren.

Hier ist eine korrigierte version des Codes, teilt jede Wort, anstatt jedes Charakter, einfach durch bewegen des letzten if Anweisung in split außerhalb der unmittelbaren while block:
```
#include <iostream>
#include <vector>
using namespace std;

vector<string> split(const string& s)
{
   vector<string> ret;
   typedef string::size_type string_size;
   string_size i = 0;

   //invariant: we have processed characters [original value of i, i) 
   while (i != s.size()) {
      //ignore leading blanks
      //invariant: characters in range [original i, current i) are all spaces
      while (i != s.size() && isspace(s[i]))
         ++i;

      //find end of next word
      string_size j = i;
      //invariant: none of the characters in range [original j, current j)is a space
      while (j != s.size() && !isspace(s[j]))
         j++;

      //if we found some nonwhitespace characters 
      if (i != j) {
         //copy from s starting at i and taking j - i chars
         ret.push_back(s.substr(i, j - i));
         i = j;
      }
   }
   return ret;
}

int main() {
   string s;
   //read and split each line of input 
   while (getline(cin, s)) {
      vector<string> v = split(s);

      //write each word in v
      for (vector<string>::size_type i = 0; i != v.size(); ++i)
      cout << v[i] << endl;
   }
   return 0;
}
```
Was passiert mit den string übergeben split ist:
- Während immer noch Zeichen in der Zeichenfolge (while (i != s.size()))
  - Während wir Lesen ein Leerzeichen von dem string while (i != s.size() && isspace(s[i]))
    
    Erhöht sich der Zähler, bis wir bekommen, um den Anfang eines Worts (++i)
  - Legen Sie das Ende des Wortes als Beginn des Wortes (string_size j = i)
  - Während wir noch innerhalb dieses Wort und nicht bis zu einem Raum (while (j != s.size() && !isspace(s[j])))
    
    Erhöht sich der Zähler, der angibt, das Ende des Wortes (j++)
  - Wenn es einige nicht-whitespace-Zeichen - Ende größer ist als die start (if (i != j))
    
    Erstellen Sie einen sub-string aus der start -, Endpunkt und des Wortes (s.substr(i, j - i)), und fügen Sie das Wort zum vector (ret.push_back(..)).
  - Spülen und wiederholen.
- nicht Sie sind derjenige, Bearbeiten Sie den Titel?, nun, ich sagte in dem Titel "Identische Programm", damit meine ich, Wenn u sehen auf den ersten code, hat es den gleichen Ausgang wie der zweite code, becoz, dass der code aus dem Buch NICHT fehlen Klammern, nur der Abstand in code gegeben lame/unorganisiert, jedenfalls aus deiner Antwort, habe ich noch nicht bekommen die richtige Antwort(noch vage), bcoz, Ich versuche, die Fragen auf ", wie der compiler verarbeitet den input basierend auf der code-gegeben", noch die Erklärung unter deinem code helfen, geben Sie mir irgendeinen Anhaltspunkt...
- Die erste code-Beispiel und die Feste, die ich gepostet habe die gleiche Ausgabe. Und es gibt Klammern fehlt in deinem zweiten code-Beispiel, entweder zählen Sie Sie auf, oder versuchen Sie und kompilieren Sie es und Sie werden sehen.
- also, wenn ich Recht habe, ist der compiler wirklich verarbeitet jedes "Zeichen", gespeichert im element(Vektor), und dann auf das element, um die Ausgabe auf dem Bildschirm. scheint mein Fehler zu übersehen, der die position des push_back(die char/Wort in element), dachte ich, dass der compiler die überprüfung der Wörter und Zeichen in das element selbst...
- btw, die fehlende Klammer in der post ist mein Fehler(Tippfehler),n fest, vielleicht können Sie kopieren und einfügen erneut, um einen compiler zu prüfen, wie der zweite code funktioniert 🙂
- Ja der code ist jetzt richtig. Sie können auch download der code-Beispiele aus dem Accelerated C++ Buch in die homepage: acceleratedcpp.com. Jedes Zeichen ist, abgearbeitet, um zu finden, ein Wort zwischen zwei Leerzeichen. Jedes Wort geschoben wird, ist auf das Ende des vector.
InformationsquelleAutor AusCBloke

Wenn Sie nur aufteilen, basierend auf den Raum, dann brauchen Sie nicht, schreiben Sie eine benutzerdefinierte Methode. STL hat Optionen für Sie.

        std::string line;
        std::vector<std::string> strings;
        while ( std::getline(std::cin, line))
        {
             std::istringstream s ( line);
             strings.insert(strings.end(), 
                 std::istream_iterator<std::string>(s),  
                 std::istream_iterator<std::string>());
        }

     // For simplicity sake using lambda.   
        std::for_each(strings.begin(), strings.end(), [](const std::string& str)
        {
            std::cout << str << "\n";
        });

Oder std::copy(std::istream_iterator<std::string>(s), std::istream_iterator<std::string>(), std::back_inserter(strings)) ähnlich wie display std::copy(strings.begin(), strings.end(), std::ostream_iterator<std::string>(std::cout, std::endl))
Ich bin nicht fragt nach einem code(das die gleiche Arbeit wie die meine) zu kompilieren, bin ich Fragen, wie man einen compiler verarbeitet das Programm, was ich hoffe, jemand kann erklären, wie AusCBloke Tat.
oh, btw, ich bin nicht erfahren STL noch... 🙂

InformationsquelleAutor Jagannath

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.