c++ string ausgeben - Wie kann ich die Wörter einer Zeichenfolge durchlaufen?




15 Answers

Ich benutze dies, um einen String durch ein Trennzeichen zu trennen. Der erste setzt die Ergebnisse in einen vorkonstruierten Vektor, der 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::stringstream ss(s);
    std::string item;
    while (std::getline(ss, 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. Daher werden im Folgenden 4 Elemente gefunden, von denen einer leer ist:

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

Ich versuche, die Wörter einer Zeichenfolge zu durchlaufen.

Es kann angenommen werden, dass die Zeichenfolge aus Wörtern besteht, die durch Leerzeichen getrennt sind.

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

Die beste Lösung, die ich jetzt 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 einen eleganteren Weg, dies zu tun?




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



Hier ist eine andere Lösung. Es ist kompakt und ziemlich effizient:

std::vector<std::string> split(const std::string &text, char sep) {
  std::vector<std::string> tokens;
  std::size_t start = 0, end = 0;
  while ((end = text.find(sep, start)) != std::string::npos) {
    tokens.push_back(text.substr(start, end - start));
    start = end + 1;
  }
  tokens.push_back(text.substr(start));
  return tokens;
}

Es kann leicht für Templatetrenner, breite Strings usw. verwendet werden.

Beachten Sie, dass das Aufteilen von "" zu einer einzelnen leeren Zeichenfolge und das Aufteilen von "," (dh getrennt) zu zwei leeren Zeichenfolgen führt.

Es kann auch leicht erweitert werden, um leere Token zu überspringen:

std::vector<std::string> split(const std::string &text, char sep) {
    std::vector<std::string> tokens;
    std::size_t start = 0, end = 0;
    while ((end = text.find(sep, start)) != std::string::npos) {
        if (end != start) {
          tokens.push_back(text.substr(start, end - start));
        }
        start = end + 1;
    }
    if (end != start) {
       tokens.push_back(text.substr(start));
    }
    return tokens;
}

Wenn Sie eine Zeichenfolge an mehreren Trennzeichen aufteilen und leere Token überspringen möchten, kann diese Version verwendet werden:

std::vector<std::string> split(const std::string& text, const std::string& delims)
{
    std::vector<std::string> tokens;
    std::size_t start = text.find_first_not_of(delims), end = 0;

    while((end = text.find_first_of(delims, start)) != std::string::npos)
    {
        tokens.push_back(text.substr(start, end - start));
        start = text.find_first_not_of(delims, end);
    }
    if(start != std::string::npos)
        tokens.push_back(text.substr(start));

    return tokens;
}



Dies ist ähnlich der -Frage. Wie kann ich eine Zeichenfolge in C ++ tokenieren? .

#include <iostream>
#include <string>
#include <boost/tokenizer.hpp>

using namespace std;
using namespace boost;

int main(int argc, char** argv)
{
    string text = "token  test\tstring";

    char_separator<char> sep(" \t");
    tokenizer<char_separator<char>> tokens(text, sep);
    for (const string& t : tokens)
    {
        cout << t << "." << endl;
    }
}



In der AWL steht eine solche Methode noch nicht zur Verfügung.

Sie können jedoch entweder die strtok() Funktion von C verwenden, strtok() Sie den strtok() std::string::c_str() , oder Sie können Ihre eigene schreiben. Hier ist ein Codebeispiel, das ich nach einer schnellen Google-Suche gefunden habe ( "STL-Zeichenfolge" ):

void Tokenize(const string& str,
              vector<string>& tokens,
              const string& delimiters = " ")
{
    // Skip delimiters at beginning.
    string::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    string::size_type pos     = str.find_first_of(delimiters, lastPos);

    while (string::npos != pos || 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);
    }
}

Entnommen von: http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html

Wenn Sie Fragen zum Codebeispiel haben, hinterlassen Sie einen Kommentar und ich erkläre es Ihnen.

Und nur, weil es kein typedef namens typedef oder Überladung implementiert, typedef der Operator << nicht, dass es sich um fehlerhaften Code handelt. Ich benutze häufig C-Funktionen. Zum Beispiel sind printf und scanf beide schneller als std::cin und std::cout (erheblich), die fopen Syntax ist für binäre Typen viel freundlicher und sie neigen auch dazu, kleinere EXE-Dateien zu erzeugen.

Lassen Sie sich bei diesem "Elegance over Performance" -Deal nicht verkaufen.




Ich habe eine zweizeilige Lösung für dieses Problem:

char sep = ' ';
std::string s="1 This is an example";

for(size_t p=0, q=0; p!=s.npos; p=q)
  std::cout << s.substr(p+(p!=0), (q=s.find(sep, p+1))-p-(p!=0)) << std::endl;

Anstatt zu drucken, können Sie es in einen Vektor setzen.




Hier ist eine einfache Lösung, die nur die Standard-Regex-Bibliothek verwendet

#include <regex>
#include <string>
#include <vector>

std::vector<string> Tokenize( const string str, const std::regex regex )
{
    using namespace std;

    std::vector<string> result;

    sregex_token_iterator it( str.begin(), str.end(), regex, -1 );
    sregex_token_iterator reg_end;

    for ( ; it != reg_end; ++it ) {
        if ( !it->str().empty() ) //token could be empty:check
            result.emplace_back( it->str() );
    }

    return result;
}

Das Regex-Argument ermöglicht die Prüfung auf mehrere Argumente (Leerzeichen, Kommas usw.).

Normalerweise prüfe ich nur, ob Leerzeichen und Kommas getrennt werden, daher habe ich auch diese Standardfunktion:

std::vector<string> TokenizeDefault( const string str )
{
    using namespace std;

    regex re( "[\\s,]+" );

    return Tokenize( str, re );
}

Das "[\\s,]+" sucht nach Leerzeichen ( \\s ) und Kommas ( , ).

Beachten Sie, wenn Sie wstring anstelle von string aufteilen wstring ,

  • Ändern Sie std::regex in std::wregex
  • Ändern Sie alle sregex_token_iterator in wsregex_token_iterator

Beachten Sie, dass Sie das Zeichenfolgenargument je nach Compiler auch als Referenz verwenden möchten.




Die Verwendung von std::stringstream funktioniert einwandfrei und macht genau das, was Sie wollten. Wenn Sie nur nach einer anderen Vorgehensweise suchen, können Sie std::find() / std::find_first_of() und std::string::substr() .

Hier ist ein Beispiel:

#include <iostream>
#include <string>

int main()
{
    std::string s("Somewhere down the road");
    std::string::size_type prev_pos = 0, pos = 0;

    while( (pos = s.find(' ', pos)) != std::string::npos )
    {
        std::string substring( s.substr(prev_pos, pos-prev_pos) );

        std::cout << substring << '\n';

        prev_pos = ++pos;
    }

    std::string substring( s.substr(prev_pos, pos-prev_pos) ); // Last word
    std::cout << substring << '\n';

    return 0;
}



Dies ist eine Regex-Lösung, die nur die Standard-Regex-Bibliothek verwendet. (Ich bin ein bisschen verrostet, daher kann es ein paar Syntaxfehler geben, aber das ist zumindest die allgemeine Idee)

#include <regex.h>
#include <string.h>
#include <vector.h>

using namespace std;

vector<string> split(string s){
    regex r ("\\w+"); //regex matches whole words, (greedy, so no fragment words)
    regex_iterator<string::iterator> rit ( s.begin(), s.end(), r );
    regex_iterator<string::iterator> rend; //iterators to iterate thru words
    vector<string> result<regex_iterator>(rit, rend);
    return result;  //iterates through the matches to fill the vector
}



Bisher habe ich die in Boost , aber ich brauchte etwas, das nicht davon abhängt.

static void Split(std::vector<std::string>& lst, const std::string& input, const std::string& separators, bool remove_empty = true)
{
    std::ostringstream word;
    for (size_t n = 0; n < input.size(); ++n)
    {
        if (std::string::npos == separators.find(input[n]))
            word << input[n];
        else
        {
            if (!word.str().empty() || !remove_empty)
                lst.push_back(word.str());
            word.str("");
        }
    }
    if (!word.str().empty() || !remove_empty)
        lst.push_back(word.str());
}

Ein guter Punkt ist, dass separatorsSie mehr als einen Charakter übergeben können.




Kurz und elegant

#include <vector>
#include <string>
using namespace std;

vector<string> split(string data, string token)
{
    vector<string> output;
    size_t pos = string::npos; // size_t to avoid improbable overflow
    do
    {
        pos = data.find(token);
        output.push_back(data.substr(0, pos));
        if (string::npos != pos)
            data = data.substr(pos + token.size());
    } while (string::npos != pos);
    return output;
}

kann einen beliebigen String als Trennzeichen verwenden, kann auch mit binären Daten verwendet werden (std :: string unterstützt binäre Daten einschließlich Nullen)

mit:

auto a = split("this!!is!!!example!string", "!!");

Ausgabe:

this
is
!example!string



Was ist mit diesem:

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



Ich benutze gerne die Boost / Regex-Methoden für diese Aufgabe, da sie maximale Flexibilität bei der Festlegung der Aufteilungskriterien bieten.

#include <iostream>
#include <string>
#include <boost/regex.hpp>

int main() {
    std::string line("A:::line::to:split");
    const boost::regex re(":+"); // one or more colons

    // -1 means find inverse matches aka split
    boost::sregex_token_iterator tokens(line.begin(),line.end(),re,-1);
    boost::sregex_token_iterator end;

    for (; tokens != end; ++tokens)
        std::cout << *tokens << std::endl;
}



Diese Antwort nimmt den String und setzt ihn in einen Vektor von Strings. Es verwendet die Boost-Bibliothek.

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



Mit dem folgenden Code wird strtok()eine Zeichenfolge in Token aufgeteilt und die Token in einem Vektor gespeichert.

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;


char one_line_string[] = "hello hi how are you nice weather we are having ok then bye";
char seps[]   = " ,\t\n";
char *token;



int main()
{
   vector<string> vec_String_Lines;
   token = strtok( one_line_string, seps );

   cout << "Extracting and storing data in a vector..\n\n\n";

   while( token != NULL )
   {
      vec_String_Lines.push_back(token);
      token = strtok( NULL, seps );
   }
     cout << "Displaying end result in vector line storage..\n\n";

    for ( int i = 0; i < vec_String_Lines.size(); ++i)
    cout << vec_String_Lines[i] << "\n";
    cout << "\n\n\n";


return 0;
}



Related