string in mehrere strings aufteilen

wie kann ich einen string(z.B. string="dies ist ein test") in mehrere strings aufteilen(z.B. string1="test" string2 ="ist" usw.)? ein string soll nur ein Wort beinhalten.

Danke schon mal im Voraus

akari

Hallo

diese Funktion helfen diur dabei :

string.find(...);
string.substr(...);
string.erase(...);

bis bald
akari

könnte mir das einer bitte etwas genauer erklären, also die funktionen

akari

Hallo

wieso habe ich das erwartet? okay, also

// Bestimmt die nächste Zeile im Text, Trennzeichen ist RowEnd
string GetRow(string &Text, string RowEnd, bool Cut)
{
  TSizeType EndPos = Text.find(RowEnd); // Position des Trennzeichens
  string Result;                        // Rückgabeergebnis

  // Wenn Trennzeichen gefunden, erste Zeile aus Text trennen
  if (EndPos != string::npos)
  {
    Result = Text.substr(0, EndPos);   // erste Zeile aus Text an Ergebnis übergeben
    if (Cut == true) Text.erase(0, EndPos + RowEnd.size()); // Wenn Cut, erste Zeile aus Text löschen
    }

  // Wenn kein Trennzeichen gefunden, gesamten Text an Ergebnis übergeben
  else
  {
    Result = Text;                     // gesamten Text übergeben
    if (Cut == true) Text = "";        // Wenn Cut, Text löschen
    }

  return(Result);
  }

// Einsatz :
string Text = "Dies ist ein langer Text mit vielen Wörtern"; // Ausgangstext
string Word; // Zwischenspeicher für ein Wort

while (Text != "") // Alle Wörter extrahieren, bis Text leer ist
{
  Word = GetRow(Text, " ", true); // nächstes Wort extrahieren
  // mache mit Word etwas
  }

bis bald
akari

CarstenJ

Hallo,

das finde ich recht umständlich. Eleganter gehts mit Stringstreams:
http://www.c-plusplus.net/forum/viewtopic.php?t=66610&highlight=stringstream

@akari

Balrog

Hallo!

Könnte das eine Lösung für Dich sein? Eine Art StringTokenizer-Klasse, wie in Java? Unterschied zu Java: Die Wörter (=Tokens) werden in einem Vector abgelegt
und können über den Index (z. B. mit

std::string aString = tokens[0]

) ausgelesen werden

//---- Snip (main.cpp) -----
#include <iostream>
#include <string>
#include <vector>

#include "StringTokenizer.h"

int main( int argc, char* argv[] ) {	
  std::string str( "dies ist ein test" );
  std::vector<std::string> tokens;

  // Legt jedes Wort von str in ein Feld von tokens.
  // Kein Delimiter-Argument angeben. Das Leerzeichen ist im Default-Satz enthalten.
  StringTokenizer::tokenize( str, tokens );

  // Jedes Wort an Standard-Out ausgeben
  // Ausgabe:
  // dies
  // ist 
  // ein
  // test  
  copy( tokens.begin(), tokens.end(), std::ostream_iterator<std::string>(std::cout, "\n"));
}

// ---- Snip (StringTokenzier.h) -----
#ifndef StringTokenizer
#define StringTokenizer

#include <string>
#include <vector>

/**
* Statische Tokenisierungsklasse für Strings (std::string).
*/
class StringTokenizer {

  private:
    StringTokenizer();
    ~StringTokenizer();	 

  public:    
    static void tokenize( const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters = " \t\n\r\f" );
};
#endif

// ---- Snip (StringTokenizer.cpp) ------
#include "StringTokenizer.h"

StringTokenizer::StringTokenizer() {};
StringTokenizer::~StringTokenizer() {};

/**
* A string tokenizer for the specified std::string str. 
* If not set to other values, the tokenizer uses the default delimiter set,
* which is " \t\n\r\f": the space character, 
* the tab character, the newline character, the carriage-return 
* character, and the form-feed character. 
* Delimiter characters themselves will not be treated as tokens.
* Tokens will be stored in tokens.
* @param str std::string to be tokenized
* @param tokens std::vector<std::string>-Container for the tokens.
* @param delimiter Delimiter for tokens. The default set is " \t\n\r\f".
*/
void StringTokenizer::tokenize( const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters ) {

  // Skip delimiters at beginning.
  std::string::size_type lastPos = str.find_first_not_of( delimiters, 0 );

  // Find first "non-delimiter".
  std::string::size_type pos = str.find_first_of( delimiters, lastPos );
  while ( std::string::npos != pos || std::string::npos != lastPos ) {
    // Found a token, add it to the vector.
    tokens.push_back( str.substr( lastPos, pos - lastPos ) );
    // Skip delimiters.  Note the "not_of"
    lastPos = str.find_first_not_of( delimiters, pos );
    // Find next "non-delimiter"
    pos = str.find_first_of( delimiters, lastPos );
  }
}

Have fun with it...

H.-Gerd

http://www.brainsandbytes.de

CarstenJ

Hallo,

nicht, dass ich andere Lösungen missachten wollte, aber erstens halte ich immer noch die stringstream Lösung für eleganter, und zweitens gibt es boost::tokenizer, was ich aufgrund der Bewährtheit einer eigenen Lösung bevorzugen würde.

Balrog

Klar,

die Boost-Library ist gut...
Aber wenn man auf die Einbindung externer Libraries verzichten
möchte (z. B. aus lizenzrechtlichen Gründen), ist eine eigene
Lösung auch nicht falsch. Vorausgesetzt sie funktioniert...

Gruß

H.-Gerd

http://www.brainsandbytes.de

nman

Balrog schrieb:

die Boost-Library ist gut...
Aber wenn man auf die Einbindung externer Libraries verzichen
möchte (z. B. aus lizenzrechtlichen Gründen)

Verstehe ich nicht, was sollte man den mit der Boost-Lizenz für Probleme haben?

Balrog

An der Boost Licence gibt es auch nichts auszusetzen.
War nur ein genereller Gedanke. Viele Libraries aus
der Open-Source-Gemeinde kann man eben aus
lizenzrechtlichen Gründen schlecht in kommerziellen Projekten
einsetzen.

Gruß

H.-Gerd

http://www.brainsandbytes.de

Balrog, sehr hilfreicher Konstruktor und Destruktor die du hast.

Balrog

Hmpf...

http://www.brainsandbytes.de