Analysieren eines durch Kommas getrennten std::string [duplicate]

Wenn ich einen std::string habe, der eine durch Kommas getrennte Liste von Zahlen enthält, wie kann ich die Zahlen am einfachsten analysieren und in ein Integer-Array einfügen?

Ich möchte dies nicht verallgemeinern, um etwas anderes zu analysieren. Nur eine einfache Zeichenfolge aus durch Kommas getrennten Ganzzahlen wie “1,1,1,1,2,1,1,1,0”.

Geben Sie jeweils eine Zahl ein und prüfen Sie, ob das folgende Zeichen ist ,. Wenn ja, verwerfen Sie es.

#include <vector>
#include <string>
#include <sstream>
#include <iostream>

int main()
{
    std::string str = "1,2,3,4,5,6";
    std::vector<int> vect;

    std::stringstream ss(str);

    for (int i; ss >> i;) {
        vect.push_back(i);    
        if (ss.peek() == ',')
            ss.ignore();
    }

    for (std::size_t i = 0; i < vect.size(); i++)
        std::cout << vect[i] << std::endl;
}

Etwas weniger ausführlich, std und nimmt alles, was durch ein Komma getrennt ist.

stringstream ss( "1,1,1,1, or something else ,1,1,1,0" );
vector<string> result;

while( ss.good() )
{
    string substr;
    getline( ss, substr, ',' );
    result.push_back( substr );
}

Ein weiterer, etwas anderer Ansatz: Verwenden Sie ein spezielles Gebietsschema, das Kommas als Leerzeichen behandelt:

#include <locale>
#include <vector>

struct csv_reader: std::ctype<char> {
    csv_reader(): std::ctype<char>(get_table()) {}
    static std::ctype_base::mask const* get_table() {
        static std::vector<std::ctype_base::mask> rc(table_size, std::ctype_base::mask());

        rc[','] = std::ctype_base::space;
        rc['\n'] = std::ctype_base::space;
        rc[' '] = std::ctype_base::space;
        return &rc[0];
    }
}; 

Um dies zu nutzen, müssen Sie imbue() ein Stream mit einem Gebietsschema, das diese Facette enthält. Sobald Sie das getan haben, können Sie Zahlen lesen, als wären die Kommas überhaupt nicht vorhanden. Nur zum Beispiel lesen wir durch Kommas getrennte Zahlen aus der Eingabe und schreiben dann eine pro Zeile auf die Standardausgabe:

#include <algorithm>
#include <iterator>
#include <iostream>

int main() {
    std::cin.imbue(std::locale(std::locale(), new csv_reader()));
    std::copy(std::istream_iterator<int>(std::cin), 
              std::istream_iterator<int>(),
              std::ostream_iterator<int>(std::cout, "\n"));
    return 0;
}

Die C++-String-Toolkit-Bibliothek (Strtk) hat folgende Lösung für dein Problem:

#include <string>
#include <deque>
#include <vector>
#include "strtk.hpp"
int main()
{ 
   std::string int_string = "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15";
   std::vector<int> int_list;
   strtk::parse(int_string,",",int_list);

   std::string double_string = "123.456|789.012|345.678|901.234|567.890";
   std::deque<double> double_list;
   strtk::parse(double_string,"|",double_list);

   return 0;
}

Weitere Beispiele sind zu finden Hier

Alternative Lösung mit generischen Algorithmen und Boost.Tokenizer:

struct ToInt
{
    int operator()(string const &str) { return atoi(str.c_str()); }
};

string values = "1,2,3,4,5,9,8,7,6";

vector<int> ints;
tokenizer<> tok(values);

transform(tok.begin(), tok.end(), back_inserter(ints), ToInt());

Viele ziemlich schreckliche Antworten hier, also füge ich meine hinzu (einschließlich Testprogramm):

#include <string>
#include <iostream>
#include <cstddef>

template<typename StringFunction>
void splitString(const std::string &str, char delimiter, StringFunction f) {
  std::size_t from = 0;
  for (std::size_t i = 0; i < str.size(); ++i) {
    if (str[i] == delimiter) {
      f(str, from, i);
      from = i + 1;
    }
  }
  if (from <= str.size())
    f(str, from, str.size());
}


int main(int argc, char* argv[]) {
    if (argc != 2)
        return 1;

    splitString(argv[1], ',', [](const std::string &s, std::size_t from, std::size_t to) {
        std::cout << "`" << s.substr(from, to - from) << "`\n";
    });

    return 0;
}

Schöne Eigenschaften:

• Keine Abhängigkeiten (z. B. Boost)
• Kein verrückter Einzeiler
• Leicht verständlich (hoffe ich)
• Behandelt Leerzeichen vollkommen in Ordnung
• Weist keine Splits zu, wenn Sie dies nicht möchten, z. B. können Sie sie wie gezeigt mit einem Lambda verarbeiten.
• Fügt Zeichen nicht einzeln hinzu – sollte schnell sein.
• Wenn Sie C ++ 17 verwenden, können Sie es ändern, um a zu verwenden std::stringview und dann werden keine Zuweisungen vorgenommen und es sollte extrem schnell sein.

Einige Designoptionen, die Sie möglicherweise ändern möchten:

• Leere Einträge werden nicht ignoriert.
• Ein leerer String ruft f() einmal auf.

Beispiel Ein- und Ausgänge:

""      ->   {""}
","     ->   {"", ""}
"1,"    ->   {"1", ""}
"1"     ->   {"1"}
" "     ->   {" "}
"1, 2," ->   {"1", " 2", ""}
" ,, "  ->   {" ", "", " "}

Sie können auch die folgende Funktion verwenden.

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.
    lastPos = str.find_first_not_of(delimiters, pos);

    // Find next non-delimiter.
    pos = str.find_first_of(delimiters, lastPos);
  }
}