it-swarm.com.de

Wie kann ich CSV-Dateien in C++ lesen und analysieren?

Ich muss CSV-Dateidaten in C++ laden und verwenden. An diesem Punkt kann es sich wirklich nur um einen durch Kommas getrennten Parser handeln (dh Sie müssen sich keine Sorgen machen, dass Sie neue Zeilen und Kommas umgehen müssen). Das Hauptbedürfnis ist ein zeilenweiser Parser, der bei jedem Aufruf der Methode einen Vektor für die nächste Zeile zurückgibt.

Ich fand diesen Artikel sehr vielversprechend: http://www.boost.org/doc/libs/1_35_0/libs/spirit/example/fundamental/list_parser.cpp

Ich habe nie Boosts Geist benutzt, bin aber bereit, es zu versuchen. Aber nur, wenn es keine einfachere Lösung gibt, werde ich übersehen.

217
User1

Wenn Sie kein Komma oder Newline brauchen,
UND Sie können Kommas und Zeilenumbrüche nicht in Anführungszeichen einbetten (Wenn Sie nicht entkommen können, dann ...)
dann sind es nur etwa drei Zeilen Code (OK 14 -> Aber es sind nur 15, um die gesamte Datei zu lesen).

std::vector<std::string> getNextLineAndSplitIntoTokens(std::istream& str)
{
    std::vector<std::string>   result;
    std::string                line;
    std::getline(str,line);

    std::stringstream          lineStream(line);
    std::string                cell;

    while(std::getline(lineStream,cell, ','))
    {
        result.Push_back(cell);
    }
    // This checks for a trailing comma with no data after it.
    if (!lineStream && cell.empty())
    {
        // If there was a trailing comma then add an empty element.
        result.Push_back("");
    }
    return result;
}

Ich würde einfach eine Klasse erstellen, die eine Reihe darstellt.
Dann streamen Sie in dieses Objekt:

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

class CSVRow
{
    public:
        std::string const& operator[](std::size_t index) const
        {
            return m_data[index];
        }
        std::size_t size() const
        {
            return m_data.size();
        }
        void readNextRow(std::istream& str)
        {
            std::string         line;
            std::getline(str, line);

            std::stringstream   lineStream(line);
            std::string         cell;

            m_data.clear();
            while(std::getline(lineStream, cell, ','))
            {
                m_data.Push_back(cell);
            }
            // This checks for a trailing comma with no data after it.
            if (!lineStream && cell.empty())
            {
                // If there was a trailing comma then add an empty element.
                m_data.Push_back("");
            }
        }
    private:
        std::vector<std::string>    m_data;
};

std::istream& operator>>(std::istream& str, CSVRow& data)
{
    data.readNextRow(str);
    return str;
}   
int main()
{
    std::ifstream       file("plop.csv");

    CSVRow              row;
    while(file >> row)
    {
        std::cout << "4th Element(" << row[3] << ")\n";
    }
}

Aber mit ein bisschen Arbeit könnten wir technisch einen Iterator erstellen:

class CSVIterator
{   
    public:
        typedef std::input_iterator_tag     iterator_category;
        typedef CSVRow                      value_type;
        typedef std::size_t                 difference_type;
        typedef CSVRow*                     pointer;
        typedef CSVRow&                     reference;

        CSVIterator(std::istream& str)  :m_str(str.good()?&str:NULL) { ++(*this); }
        CSVIterator()                   :m_str(NULL) {}

        // Pre Increment
        CSVIterator& operator++()               {if (m_str) { if (!((*m_str) >> m_row)){m_str = NULL;}}return *this;}
        // Post increment
        CSVIterator operator++(int)             {CSVIterator    tmp(*this);++(*this);return tmp;}
        CSVRow const& operator*()   const       {return m_row;}
        CSVRow const* operator->()  const       {return &m_row;}

        bool operator==(CSVIterator const& rhs) {return ((this == &rhs) || ((this->m_str == NULL) && (rhs.m_str == NULL)));}
        bool operator!=(CSVIterator const& rhs) {return !((*this) == rhs);}
    private:
        std::istream*       m_str;
        CSVRow              m_row;
};


int main()
{
    std::ifstream       file("plop.csv");

    for(CSVIterator loop(file); loop != CSVIterator(); ++loop)
    {
        std::cout << "4th Element(" << (*loop)[3] << ")\n";
    }
}
254
Martin York

Lösung mit Boost Tokenizer:

std::vector<std::string> vec;
using namespace boost;
tokenizer<escaped_list_separator<char> > tk(
   line, escaped_list_separator<char>('\\', ',', '\"'));
for (tokenizer<escaped_list_separator<char> >::iterator i(tk.begin());
   i!=tk.end();++i) 
{
   vec.Push_back(*i);
}
44
dtw

Meine Version verwendet nur die Standard-C++ 11-Bibliothek. Es kommt gut mit dem Excel CSV-Angebot zurecht:

spam eggs,"foo,bar","""fizz buzz"""
1.23,4.567,-8.00E+09

Der Code wird als eine endliche Maschine geschrieben und verbraucht jeweils ein Zeichen. Ich denke, es ist einfacher, darüber nachzudenken.

#include <istream>
#include <string>
#include <vector>

enum class CSVState {
    UnquotedField,
    QuotedField,
    QuotedQuote
};

std::vector<std::string> readCSVRow(const std::string &row) {
    CSVState state = CSVState::UnquotedField;
    std::vector<std::string> fields {""};
    size_t i = 0; // index of the current field
    for (char c : row) {
        switch (state) {
            case CSVState::UnquotedField:
                switch (c) {
                    case ',': // end of field
                              fields.Push_back(""); i++;
                              break;
                    case '"': state = CSVState::QuotedField;
                              break;
                    default:  fields[i].Push_back(c);
                              break; }
                break;
            case CSVState::QuotedField:
                switch (c) {
                    case '"': state = CSVState::QuotedQuote;
                              break;
                    default:  fields[i].Push_back(c);
                              break; }
                break;
            case CSVState::QuotedQuote:
                switch (c) {
                    case ',': // , after closing quote
                              fields.Push_back(""); i++;
                              state = CSVState::UnquotedField;
                              break;
                    case '"': // "" -> "
                              fields[i].Push_back('"');
                              state = CSVState::QuotedField;
                              break;
                    default:  // end of quote
                              state = CSVState::UnquotedField;
                              break; }
                break;
        }
    }
    return fields;
}

/// Read CSV file, Excel dialect. Accept "quoted fields ""with quotes"""
std::vector<std::vector<std::string>> readCSV(std::istream &in) {
    std::vector<std::vector<std::string>> table;
    std::string row;
    while (!in.eof()) {
        std::getline(in, row);
        if (in.bad() || in.fail()) {
            break;
        }
        auto fields = readCSVRow(row);
        table.Push_back(fields);
    }
    return table;
}
33
sastanin

Die C++ String Toolkit Library (StrTk) verfügt über eine Token-Grid-Klasse, mit der Sie Daten entweder laden können textdateien, Zeichenfolgen oder Zeichenpufferund sie in einer Reihenspalte zu analysieren/verarbeiten.

Sie können die Zeilenbegrenzer und Spaltenbegrenzer angeben oder einfach die Standardwerte verwenden.

void foo()
{
   std::string data = "1,2,3,4,5\n"
                      "0,2,4,6,8\n"
                      "1,3,5,7,9\n";

   strtk::token_grid grid(data,data.size(),",");

   for(std::size_t i = 0; i < grid.row_count(); ++i)
   {
      strtk::token_grid::row_type r = grid.row(i);
      for(std::size_t j = 0; j < r.size(); ++j)
      {
         std::cout << r.get<int>(j) << "\t";
      }
      std::cout << std::endl;
   }
   std::cout << std::endl;
}

Weitere Beispiele finden Sie hier Here

31
Matthieu N.

Es ist nicht übertrieben, Spirit für das Parsen von CSVs zu verwenden. Spirit eignet sich gut für Mikro-Parsing-Aufgaben. Zum Beispiel ist es mit Spirit 2.1 so einfach wie:

bool r = phrase_parse(first, last,

    //  Begin grammar
    (
        double_ % ','
    )
    ,
    //  End grammar

    space, v);

Der Vektor v wird mit den Werten gefüllt. Es gibt eine Reihe von Tutorials , die in den neuen Spirit 2.1-Dokumenten, die gerade mit Boost 1.41 veröffentlicht wurden, berührt werden.

Das Tutorial geht von einfach bis komplex weiter. Die CSV-Parser werden irgendwo in der Mitte präsentiert und berühren verschiedene Techniken bei der Verwendung von Spirit. Der generierte Code ist so eng wie handgeschriebener Code. Schauen Sie sich den Assembler an!

29
Joel de Guzman

Sie können Boost Tokenizer mit escaped_list_separator verwenden.

escaped_list_separator analysiert eine Obermenge der csv. Boost :: tokenizer

Hierbei werden nur Boost-Tokenizer-Header-Dateien verwendet. Es sind keine Verknüpfungen zu Boost-Bibliotheken erforderlich.

Hier ein Beispiel (siehe Parse CSV-Datei mit Boost-Tokenizer in C++ für Details oder Boost::tokenizer):

#include <iostream>     // cout, endl
#include <fstream>      // fstream
#include <vector>
#include <string>
#include <algorithm>    // copy
#include <iterator>     // ostream_operator
#include <boost/tokenizer.hpp>

int main()
{
    using namespace std;
    using namespace boost;
    string data("data.csv");

    ifstream in(data.c_str());
    if (!in.is_open()) return 1;

    typedef tokenizer< escaped_list_separator<char> > Tokenizer;
    vector< string > vec;
    string line;

    while (getline(in,line))
    {
        Tokenizer tok(line);
        vec.assign(tok.begin(),tok.end());

        // vector now contains strings from one row, output to cout here
        copy(vec.begin(), vec.end(), ostream_iterator<string>(cout, "|"));

        cout << "\n----------------------" << endl;
    }
}
28
stefanB

Wenn Sie DO darauf achten, CSV korrekt zu analysieren, wird dies erledigt ... relativ langsam, da es chargenweise funktioniert.

 void ParseCSV(const string& csvSource, vector<vector<string> >& lines)
    {
       bool inQuote(false);
       bool newLine(false);
       string field;
       lines.clear();
       vector<string> line;

       string::const_iterator aChar = csvSource.begin();
       while (aChar != csvSource.end())
       {
          switch (*aChar)
          {
          case '"':
             newLine = false;
             inQuote = !inQuote;
             break;

          case ',':
             newLine = false;
             if (inQuote == true)
             {
                field += *aChar;
             }
             else
             {
                line.Push_back(field);
                field.clear();
             }
             break;

          case '\n':
          case '\r':
             if (inQuote == true)
             {
                field += *aChar;
             }
             else
             {
                if (newLine == false)
                {
                   line.Push_back(field);
                   lines.Push_back(line);
                   field.clear();
                   line.clear();
                   newLine = true;
                }
             }
             break;

          default:
             newLine = false;
             field.Push_back(*aChar);
             break;
          }

          aChar++;
       }

       if (field.size())
          line.Push_back(field);

       if (line.size())
          lines.Push_back(line);
    }
17
Michael

Wenn Sie den Boost Tokenizer escaped_list_separator für CSV-Dateien verwenden, sollten Sie Folgendes beachten:

  1. Es erfordert ein Escape-Zeichen (Standard-Schrägstrich - \)
  2. Es erfordert ein Splitter/Separator-Zeichen (Standardkomma -,)
  3. Es erfordert ein Anführungszeichen (Standard-Anführungszeichen - ")

Das von Wiki angegebene CSV-Format besagt, dass Datenfelder Trennzeichen in Anführungszeichen enthalten können (unterstützt):

1997 Ford, E350, "Super, luxuriöser LKW"

Das von Wiki angegebene CSV-Format gibt an, dass einfache Anführungszeichen mit doppelten Anführungszeichen behandelt werden sollten (escaped_list_separator entfernt alle Anführungszeichen):

1997 Ford, E350, "Super" "luxuriös" "LKW"

Das CSV-Format gibt nicht an, dass alle Back-Slash-Zeichen entfernt werden sollen (escaped_list_separator entfernt alle Escape-Zeichen).

Eine mögliche Problemumgehung, um das Standardverhalten des boost escaped_list_separator zu beheben:

  1. Ersetzen Sie zunächst alle Back-Slash-Zeichen (\) durch zwei Back-Slash-Zeichen (\\), damit sie nicht entfernt werden.
  2. Ersetzen Sie zweitens alle Anführungszeichen ("") durch einen einzelnen Schrägstrich und ein Zitat (\ ").

Diese Problemumgehung hat den Nebeneffekt, dass leere Datenfelder, die durch ein Anführungszeichen dargestellt werden, in ein Anführungszeichen-Token umgewandelt werden. Beim Durchlaufen der Token muss geprüft werden, ob das Token ein einfaches Anführungszeichen ist, und es wie eine leere Zeichenfolge behandeln.

Nicht schön, aber es funktioniert, solange in den Anführungszeichen keine Zeilenumbrüche vorhanden sind.

14
Rolf Kristensen

Vielleicht möchten Sie sich mein FOSS-Projekt CSVfix ( aktualisierte Verknüpfung ) ansehen, das ein in C++ geschriebener CSV-Stream-Editor ist. Der CSV-Parser ist kein Preis, aber die Aufgabe und das gesamte Paket kann das tun, was Sie brauchen, ohne dass Sie Code schreiben müssen.

Siehe alib/src/a_csv.cpp für den CSV-Parser und csvlib/src/csved_ioman.cpp (IOManager::ReadCSV) für ein Anwendungsbeispiel.

7
anon

Da alle CSV-Fragen hier scheinbar umgeleitet werden, dachte ich, ich würde meine Antwort hier posten. Diese Antwort bezieht sich nicht direkt auf die Frage des Fragestellers. Ich wollte in der Lage sein, einen Stream einzulesen, der bekanntermaßen im CSV-Format vorliegt, und auch die Typen der einzelnen Felder waren bereits bekannt. Natürlich kann die folgende Methode verwendet werden, um jedes Feld als String-Typ zu behandeln.

Als Beispiel, wie ich einen CSV-Eingabestrom verwenden wollte, betrachten Sie die folgende Eingabe (entnommen aus Wikipedia auf CSV ):

const char input[] =
"Year,Make,Model,Description,Price\n"
"1997,Ford,E350,\"ac, abs, moon\",3000.00\n"
"1999,Chevy,\"Venture \"\"Extended Edition\"\"\",\"\",4900.00\n"
"1999,Chevy,\"Venture \"\"Extended Edition, Very Large\"\"\",\"\",5000.00\n"
"1996,Jeep,Grand Cherokee,\"MUST SELL!\n\
air, moon roof, loaded\",4799.00\n"
;

Dann wollte ich die Daten so einlesen können:

std::istringstream ss(input);
std::string title[5];
int year;
std::string make, model, desc;
float price;
csv_istream(ss)
    >> title[0] >> title[1] >> title[2] >> title[3] >> title[4];
while (csv_istream(ss)
       >> year >> make >> model >> desc >> price) {
    //...do something with the record...
}

Dies war die Lösung, mit der ich endete.

struct csv_istream {
    std::istream &is_;
    csv_istream (std::istream &is) : is_(is) {}
    void scan_ws () const {
        while (is_.good()) {
            int c = is_.peek();
            if (c != ' ' && c != '\t') break;
            is_.get();
        }
    }
    void scan (std::string *s = 0) const {
        std::string ws;
        int c = is_.get();
        if (is_.good()) {
            do {
                if (c == ',' || c == '\n') break;
                if (s) {
                    ws += c;
                    if (c != ' ' && c != '\t') {
                        *s += ws;
                        ws.clear();
                    }
                }
                c = is_.get();
            } while (is_.good());
            if (is_.eof()) is_.clear();
        }
    }
    template <typename T, bool> struct set_value {
        void operator () (std::string in, T &v) const {
            std::istringstream(in) >> v;
        }
    };
    template <typename T> struct set_value<T, true> {
        template <bool SIGNED> void convert (std::string in, T &v) const {
            if (SIGNED) v = ::strtoll(in.c_str(), 0, 0);
            else v = ::strtoull(in.c_str(), 0, 0);
        }
        void operator () (std::string in, T &v) const {
            convert<is_signed_int<T>::val>(in, v);
        }
    };
    template <typename T> const csv_istream & operator >> (T &v) const {
        std::string tmp;
        scan(&tmp);
        set_value<T, is_int<T>::val>()(tmp, v);
        return *this;
    }
    const csv_istream & operator >> (std::string &v) const {
        v.clear();
        scan_ws();
        if (is_.peek() != '"') scan(&v);
        else {
            std::string tmp;
            is_.get();
            std::getline(is_, tmp, '"');
            while (is_.peek() == '"') {
                v += tmp;
                v += is_.get();
                std::getline(is_, tmp, '"');
            }
            v += tmp;
            scan();
        }
        return *this;
    }
    template <typename T>
    const csv_istream & operator >> (T &(*manip)(T &)) const {
        is_ >> manip;
        return *this;
    }
    operator bool () const { return !is_.fail(); }
};

Mit den folgenden Helfern, die durch die neuen Vorlagen für integrierte Merkmale in C++ 11 vereinfacht werden können:

template <typename T> struct is_signed_int { enum { val = false }; };
template <> struct is_signed_int<short> { enum { val = true}; };
template <> struct is_signed_int<int> { enum { val = true}; };
template <> struct is_signed_int<long> { enum { val = true}; };
template <> struct is_signed_int<long long> { enum { val = true}; };

template <typename T> struct is_unsigned_int { enum { val = false }; };
template <> struct is_unsigned_int<unsigned short> { enum { val = true}; };
template <> struct is_unsigned_int<unsigned int> { enum { val = true}; };
template <> struct is_unsigned_int<unsigned long> { enum { val = true}; };
template <> struct is_unsigned_int<unsigned long long> { enum { val = true}; };

template <typename T> struct is_int {
    enum { val = (is_signed_int<T>::val || is_unsigned_int<T>::val) };
};
6
jxh

Eine andere Lösung ähnelt der Antwort von Loki Astari in C++ 11. Zeilen sind hier std::Tuples eines bestimmten Typs. Der Code scannt eine Zeile, scannt dann bis zu jedem Trennzeichen und konvertiert und speichert den Wert direkt in das Tuple (mit etwas Vorlagencode).

for (auto row : csv<std::string, int, float>(file, ',')) {
    std::cout << "first col: " << std::get<0>(row) << std::endl;
}

Advanges:

  • recht sauber und einfach zu bedienen, nur C++ 11.
  • automatische Typumwandlung in std::Tuple<t1, ...> über operator>>.

Was fehlt:

  • flucht und Zitieren
  • keine Fehlerbehandlung bei fehlerhafter CSV.

Der Hauptcode:

#include <iterator>
#include <sstream>
#include <string>

namespace csvtools {
    /// Read the last element of the Tuple without calling recursively
    template <std::size_t idx, class... fields>
    typename std::enable_if<idx >= std::Tuple_size<std::Tuple<fields...>>::value - 1>::type
    read_Tuple(std::istream &in, std::Tuple<fields...> &out, const char delimiter) {
        std::string cell;
        std::getline(in, cell, delimiter);
        std::stringstream cell_stream(cell);
        cell_stream >> std::get<idx>(out);
    }

    /// Read the @p idx-th element of the Tuple and then calls itself with @p idx + 1 to
    /// read the next element of the Tuple. Automatically falls in the previous case when
    /// reaches the last element of the Tuple thanks to enable_if
    template <std::size_t idx, class... fields>
    typename std::enable_if<idx < std::Tuple_size<std::Tuple<fields...>>::value - 1>::type
    read_Tuple(std::istream &in, std::Tuple<fields...> &out, const char delimiter) {
        std::string cell;
        std::getline(in, cell, delimiter);
        std::stringstream cell_stream(cell);
        cell_stream >> std::get<idx>(out);
        read_Tuple<idx + 1, fields...>(in, out, delimiter);
    }
}

/// Iterable csv wrapper around a stream. @p fields the list of types that form up a row.
template <class... fields>
class csv {
    std::istream &_in;
    const char _delim;
public:
    typedef std::Tuple<fields...> value_type;
    class iterator;

    /// Construct from a stream.
    inline csv(std::istream &in, const char delim) : _in(in), _delim(delim) {}

    /// Status of the underlying stream
    /// @{
    inline bool good() const {
        return _in.good();
    }
    inline const std::istream &underlying_stream() const {
        return _in;
    }
    /// @}

    inline iterator begin();
    inline iterator end();
private:

    /// Reads a line into a stringstream, and then reads the line into a Tuple, that is returned
    inline value_type read_row() {
        std::string line;
        std::getline(_in, line);
        std::stringstream line_stream(line);
        std::Tuple<fields...> retval;
        csvtools::read_Tuple<0, fields...>(line_stream, retval, _delim);
        return retval;
    }
};

/// Iterator; just calls recursively @ref csv::read_row and stores the result.
template <class... fields>
class csv<fields...>::iterator {
    csv::value_type _row;
    csv *_parent;
public:
    typedef std::input_iterator_tag iterator_category;
    typedef csv::value_type         value_type;
    typedef std::size_t             difference_type;
    typedef csv::value_type *       pointer;
    typedef csv::value_type &       reference;

    /// Construct an empty/end iterator
    inline iterator() : _parent(nullptr) {}
    /// Construct an iterator at the beginning of the @p parent csv object.
    inline iterator(csv &parent) : _parent(parent.good() ? &parent : nullptr) {
        ++(*this);
    }

    /// Read one row, if possible. Set to end if parent is not good anymore.
    inline iterator &operator++() {
        if (_parent != nullptr) {
            _row = _parent->read_row();
            if (!_parent->good()) {
                _parent = nullptr;
            }
        }
        return *this;
    }

    inline iterator operator++(int) {
        iterator copy = *this;
        ++(*this);
        return copy;
    }

    inline csv::value_type const &operator*() const {
        return _row;
    }

    inline csv::value_type const *operator->() const {
        return &_row;
    }

    bool operator==(iterator const &other) {
        return (this == &other) or (_parent == nullptr and other._parent == nullptr);
    }
    bool operator!=(iterator const &other) {
        return not (*this == other);
    }
};

template <class... fields>
typename csv<fields...>::iterator csv<fields...>::begin() {
    return iterator(*this);
}

template <class... fields>
typename csv<fields...>::iterator csv<fields...>::end() {
    return iterator();
}

Ich habe ein kleines Arbeitsbeispiel auf GitHub gelegt; Ich habe es zum Analysieren einiger numerischer Daten verwendet und es hat seinen Zweck erfüllt.

5
Pietro Saccardi

Eine weitere CSV-E/A-Bibliothek finden Sie hier:

http://code.google.com/p/fast-cpp-csv-parser/

#include "csv.h"

int main(){
  io::CSVReader<3> in("ram.csv");
  in.read_header(io::ignore_extra_column, "vendor", "size", "speed");
  std::string vendor; int size; double speed;
  while(in.read_row(vendor, size, speed)){
    // do stuff with the data
  }
}
5
Heygard Flisch

Ich habe einen Header geschrieben, nur C++ 11 CSV-Parser . Es ist gut getestet, schnell, unterstützt die gesamte CSV-Spezifikation (zitierte Felder, Trennzeichen/Abschlusszeichen in Anführungszeichen, Anführungszeichen usw.) und kann so konfiguriert werden, dass CSVs berücksichtigt werden, die nicht der Spezifikation entsprechen.

Die Konfiguration erfolgt über eine fließende Schnittstelle:

// constructor accepts any input stream
CsvParser parser = CsvParser(std::cin)
  .delimiter(';')    // delimited by ; instead of ,
  .quote('\'')       // quoted fields use ' instead of "
  .terminator('\0'); // terminated by \0 instead of by \r\n, \n, or \r

Parsing ist nur ein Bereich für die Schleife:

#include <iostream>
#include "../parser.hpp"

using namespace aria::csv;

int main() {
  std::ifstream f("some_file.csv");
  CsvParser parser(f);

  for (auto& row : parser) {
    for (auto& field : row) {
      std::cout << field << " | ";
    }
    std::cout << std::endl;
  }
}
4
m0meni

Als Erstes müssen Sie sicherstellen, dass die Datei vorhanden ist. Um dies zu erreichen, müssen Sie nur versuchen, den Dateistream im Pfad zu öffnen. Nachdem Sie Den Dateistream geöffnet haben, verwenden Sie stream.fail (), um zu sehen, ob es wie erwartet funktioniert Oder nicht.

bool fileExists(string fileName)
{

ifstream test;

test.open(fileName.c_str());

if (test.fail())
{
    test.close();
    return false;
}
else
{
    test.close();
    return true;
}
}

Sie müssen außerdem sicherstellen, dass die bereitgestellte Datei der richtige Dateityp ist .. Um dies zu erreichen, müssen Sie den angegebenen Dateipfad durchsehen, bis die Dateiendung. Sobald Sie die Dateierweiterung haben, stellen Sie sicher, dass es sich um eine CSV-Datei handelt.

bool verifyExtension(string filename)
{
int period = 0;

for (unsigned int i = 0; i < filename.length(); i++)
{
    if (filename[i] == '.')
        period = i;
}

string extension;

for (unsigned int i = period; i < filename.length(); i++)
    extension += filename[i];

if (extension == ".csv")
    return true;
else
    return false;
}

Diese Funktion gibt die Dateierweiterung zurück, die später in einer Fehlermeldung verwendet wird.

string getExtension(string filename)
{
int period = 0;

for (unsigned int i = 0; i < filename.length(); i++)
{
    if (filename[i] == '.')
        period = i;
}

string extension;

if (period != 0)
{
    for (unsigned int i = period; i < filename.length(); i++)
        extension += filename[i];
}
else
    extension = "NO FILE";

return extension;
}

Diese Funktion ruft die oben erstellten Fehlerprüfungen auf und analysiert sie dann durch die Datei.

void parseFile(string fileName)
{
    if (fileExists(fileName) && verifyExtension(fileName))
    {
        ifstream fs;
        fs.open(fileName.c_str());
        string fileCommand;

        while (fs.good())
        {
            string temp;

            getline(fs, fileCommand, '\n');

            for (unsigned int i = 0; i < fileCommand.length(); i++)
            {
                if (fileCommand[i] != ',')
                    temp += fileCommand[i];
                else
                    temp += " ";
            }

            if (temp != "\0")
            {
                // Place your code here to run the file.
            }
        }
        fs.close();
    }
    else if (!fileExists(fileName))
    {
        cout << "Error: The provided file does not exist: " << fileName << endl;

        if (!verifyExtension(fileName))
        {
            if (getExtension(fileName) != "NO FILE")
                cout << "\tCheck the file extension." << endl;
            else
                cout << "\tThere is no file in the provided path." << endl;
        }
    }
    else if (!verifyExtension(fileName)) 
    {
        if (getExtension(fileName) != "NO FILE")
            cout << "Incorrect file extension provided: " << getExtension(fileName) << endl;
        else
            cout << "There is no file in the following path: " << fileName << endl;
    }
}
3
Elizabeth Card

Hier ist eine weitere Implementierung eines Unicode-CSV-Parsers (funktioniert mit wchar_t). Ich habe einen Teil davon geschrieben, während Jonathan Leffler den Rest schrieb.

Hinweis: Dieser Parser zielt darauf ab, das Verhalten von Excel so genau wie möglich zu replizieren, insbesondere beim Importieren von broken- oder fehlerhaften CSV-Dateien.

Dies ist die ursprüngliche Frage - Analysieren einer CSV-Datei mit mehrzeiligen Feldern und doppelten Anführungszeichen

Dies ist der Code als SSCCE (kurzes, in sich geschlossenes, korrektes Beispiel).

#include <stdbool.h>
#include <wchar.h>
#include <wctype.h>

extern const wchar_t *nextCsvField(const wchar_t *p, wchar_t sep, bool *newline);

// Returns a pointer to the start of the next field,
// or zero if this is the last field in the CSV
// p is the start position of the field
// sep is the separator used, i.e. comma or semicolon
// newline says whether the field ends with a newline or with a comma
const wchar_t *nextCsvField(const wchar_t *p, wchar_t sep, bool *newline)
{
    // Parse quoted sequences
    if ('"' == p[0]) {
        p++;
        while (1) {
            // Find next double-quote
            p = wcschr(p, L'"');
            // If we don't find it or it's the last symbol
            // then this is the last field
            if (!p || !p[1])
                return 0;
            // Check for "", it is an escaped double-quote
            if (p[1] != '"')
                break;
            // Skip the escaped double-quote
            p += 2;
        }
    }

    // Find next newline or comma.
    wchar_t newline_or_sep[4] = L"\n\r ";
    newline_or_sep[2] = sep;
    p = wcspbrk(p, newline_or_sep);

    // If no newline or separator, this is the last field.
    if (!p)
        return 0;

    // Check if we had newline.
    *newline = (p[0] == '\r' || p[0] == '\n');

    // Handle "\r\n", otherwise just increment
    if (p[0] == '\r' && p[1] == '\n')
        p += 2;
    else
        p++;

    return p;
}

static wchar_t *csvFieldData(const wchar_t *fld_s, const wchar_t *fld_e, wchar_t *buffer, size_t buflen)
{
    wchar_t *dst = buffer;
    wchar_t *end = buffer + buflen - 1;
    const wchar_t *src = fld_s;

    if (*src == L'"')
    {
        const wchar_t *p = src + 1;
        while (p < fld_e && dst < end)
        {
            if (p[0] == L'"' && p+1 < fld_s && p[1] == L'"')
            {
                *dst++ = p[0];
                p += 2;
            }
            else if (p[0] == L'"')
            {
                p++;
                break;
            }
            else
                *dst++ = *p++;
        }
        src = p;
    }
    while (src < fld_e && dst < end)
        *dst++ = *src++;
    if (dst >= end)
        return 0;
    *dst = L'\0';
    return(buffer);
}

static void dissect(const wchar_t *line)
{
    const wchar_t *start = line;
    const wchar_t *next;
    bool     eol;
    wprintf(L"Input %3zd: [%.*ls]\n", wcslen(line), wcslen(line)-1, line);
    while ((next = nextCsvField(start, L',', &eol)) != 0)
    {
        wchar_t buffer[1024];
        wprintf(L"Raw Field: [%.*ls] (eol = %d)\n", (next - start - eol), start, eol);
        if (csvFieldData(start, next-1, buffer, sizeof(buffer)/sizeof(buffer[0])) != 0)
            wprintf(L"Field %3zd: [%ls]\n", wcslen(buffer), buffer);
        start = next;
    }
}

static const wchar_t multiline[] =
   L"First field of first row,\"This field is multiline\n"
    "\n"
    "but that's OK because it's enclosed in double quotes, and this\n"
    "is an escaped \"\" double quote\" but this one \"\" is not\n"
    "   \"This is second field of second row, but it is not multiline\n"
    "   because it doesn't start \n"
    "   with an immediate double quote\"\n"
    ;

int main(void)
{
    wchar_t line[1024];

    while (fgetws(line, sizeof(line)/sizeof(line[0]), stdin))
        dissect(line);
    dissect(multiline);

    return 0;
}
3
sashoalm

Sie müssen stolz sein, wenn Sie etwas so Schönes wie boost::spirit verwenden

Hier mein Versuch eines Parsers (fast), der die CSV-Spezifikationen auf diesem Link erfüllt CSV-Spezifikationen (Ich habe keine Zeilenumbrüche in Feldern benötigt. Auch die Leerzeichen um die Kommas werden verworfen).

Nachdem Sie die schockierende Erfahrung des Wartens von 10 Sekunden auf das Kompilieren dieses Codes überwunden haben :), können Sie sich zurücklehnen und genießen.

// csvparser.cpp
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>

#include <iostream>
#include <string>

namespace qi = boost::spirit::qi;
namespace bascii = boost::spirit::ascii;

template <typename Iterator>
struct csv_parser : qi::grammar<Iterator, std::vector<std::string>(), 
    bascii::space_type>
{
    qi::rule<Iterator, char()                                           > COMMA;
    qi::rule<Iterator, char()                                           > DDQUOTE;
    qi::rule<Iterator, std::string(),               bascii::space_type  > non_escaped;
    qi::rule<Iterator, std::string(),               bascii::space_type  > escaped;
    qi::rule<Iterator, std::string(),               bascii::space_type  > field;
    qi::rule<Iterator, std::vector<std::string>(),  bascii::space_type  > start;

    csv_parser() : csv_parser::base_type(start)
    {
        using namespace qi;
        using qi::lit;
        using qi::lexeme;
        using bascii::char_;

        start       = field % ',';
        field       = escaped | non_escaped;
        escaped     = lexeme['"' >> *( char_ -(char_('"') | ',') | COMMA | DDQUOTE)  >> '"'];
        non_escaped = lexeme[       *( char_ -(char_('"') | ',')                  )        ];
        DDQUOTE     = lit("\"\"")       [_val = '"'];
        COMMA       = lit(",")          [_val = ','];
    }

};

int main()
{
    std::cout << "Enter CSV lines [empty] to quit\n";

    using bascii::space;
    typedef std::string::const_iterator iterator_type;
    typedef csv_parser<iterator_type> csv_parser;

    csv_parser grammar;
    std::string str;
    int fid;
    while (getline(std::cin, str))
    {
        fid = 0;

        if (str.empty())
            break;

        std::vector<std::string> csv;
        std::string::const_iterator it_beg = str.begin();
        std::string::const_iterator it_end = str.end();
        bool r = phrase_parse(it_beg, it_end, grammar, space, csv);

        if (r && it_beg == it_end)
        {
            std::cout << "Parsing succeeded\n";
            for (auto& field: csv)
            {
                std::cout << "field " << ++fid << ": " << field << std::endl;
            }
        }
        else
        {
            std::cout << "Parsing failed\n";
        }
    }

    return 0;
}

Kompilieren:

make csvparser

Test (Beispiel aus Wikipedia ) gestohlen:

./csvparser
Enter CSV lines [empty] to quit

1999,Chevy,"Venture ""Extended Edition, Very Large""",,5000.00
Parsing succeeded
field 1: 1999
field 2: Chevy
field 3: Venture "Extended Edition, Very Large"
field 4: 
field 5: 5000.00

1999,Chevy,"Venture ""Extended Edition, Very Large""",,5000.00"
Parsing failed
2
jav

Hier ist der Code zum Lesen einer Matrix. Beachten Sie, dass Sie auch eine csvwrite-Funktion in matlab haben

void loadFromCSV( const std::string& filename )
{
    std::ifstream       file( filename.c_str() );
    std::vector< std::vector<std::string> >   matrix;
    std::vector<std::string>   row;
    std::string                line;
    std::string                cell;

    while( file )
    {
        std::getline(file,line);
        std::stringstream lineStream(line);
        row.clear();

        while( std::getline( lineStream, cell, ',' ) )
            row.Push_back( cell );

        if( !row.empty() )
            matrix.Push_back( row );
    }

    for( int i=0; i<int(matrix.size()); i++ )
    {
        for( int j=0; j<int(matrix[i].size()); j++ )
            std::cout << matrix[i][j] << " ";

        std::cout << std::endl;
    }
}
2
Jim M.

Diese Lösung erkennt diese 4 Fälle

komplette Klasse ist um

https://github.com/pedro-vicente/csv-parser

1,field 2,field 3,
1,field 2,"field 3 quoted, with separator",
1,field 2,"field 3
with newline",
1,field 2,"field 3
with newline and separator,",

Er liest die Datei Zeichen für Zeichen ein und liest jeweils eine Zeile in einen Vektor (aus Zeichenfolgen), der für sehr große Dateien geeignet ist.

Verwendung ist

Iterieren, bis eine leere Zeile zurückgegeben wird (Dateiende). Eine Zeile ist ein Vektor, bei dem jeder Eintrag eine CSV-Spalte ist.

read_csv_t csv;
csv.open("../test.csv");
std::vector<std::string> row;
while (true)
{
  row = csv.read_row();
  if (row.size() == 0)
  {
    break;
  }
}

die Klassendeklaration

class read_csv_t
{
public:
  read_csv_t();
  int open(const std::string &file_name);
  std::vector<std::string> read_row();
private:
  std::ifstream m_ifs;
};

die Umsetzung

std::vector<std::string> read_csv_t::read_row()
{
  bool quote_mode = false;
  std::vector<std::string> row;
  std::string column;
  char c;
  while (m_ifs.get(c))
  {
    switch (c)
    {
      /////////////////////////////////////////////////////////////////////////////////////////////////////
      //separator ',' detected. 
      //in quote mode add character to column
      //Push column if not in quote mode
      /////////////////////////////////////////////////////////////////////////////////////////////////////

    case ',':
      if (quote_mode == true)
      {
        column += c;
      }
      else
      {
        row.Push_back(column);
        column.clear();
      }
      break;

      /////////////////////////////////////////////////////////////////////////////////////////////////////
      //quote '"' detected. 
      //toggle quote mode
      /////////////////////////////////////////////////////////////////////////////////////////////////////

    case '"':
      quote_mode = !quote_mode;
      break;

      /////////////////////////////////////////////////////////////////////////////////////////////////////
      //line end detected
      //in quote mode add character to column
      //return row if not in quote mode
      /////////////////////////////////////////////////////////////////////////////////////////////////////

    case '\n':
    case '\r':
      if (quote_mode == true)
      {
        column += c;
      }
      else
      {
        return row;
      }
      break;

      /////////////////////////////////////////////////////////////////////////////////////////////////////
      //default, add character to column
      /////////////////////////////////////////////////////////////////////////////////////////////////////

    default:
      column += c;
      break;
    }
  }

  //return empty vector if end of file detected 
  m_ifs.close();
  std::vector<std::string> v;
  return v;
}
2
Pedro Vicente

Sie können die .csv-Datei mit den Funktionen fopen und fscanf öffnen und lesen. Wichtig ist jedoch, die Daten zu parsen.

Angenommen, Ihre Datei "data1.csv" lautet wie folgt: 

A,45,76,01
B,77,67,02
C,63,76,03
D,65,44,04

sie können Daten kennzeichnen und in char-Arrays speichern und später die Funktion atoi () usw. für entsprechende Konvertierungen verwenden 

FILE *fp;
char str1[10], str2[10], str3[10], str4[10];

fp = fopen("G:\\data1.csv", "r");
if(NULL == fp)
{
    printf("\nError in opening file.");
    return 0;
}
while(EOF != fscanf(fp, " %[^,], %[^,], %[^,], %s, %s, %s, %s ", str1, str2, str3, str4))
{
    printf("\n%s %s %s %s", str1, str2, str3, str4);
}
fclose(fp);

[^,], ^ -it invertiert die Logik, bedeutet Übereinstimmung mit jeder Zeichenfolge, die kein letztes Komma enthält. 

2
Amruta Ghodke

Entschuldigen Sie bitte, aber das alles scheint eine Menge durchdachter Syntax zu sein, um ein paar Zeilen Code zu verbergen.

Warum nicht das:

/**

  Read line from a CSV file

  @param[in] fp file pointer to open file
  @param[in] vls reference to vector of strings to hold next line

  */
void readCSV( FILE *fp, std::vector<std::string>& vls )
{
    vls.clear();
    if( ! fp )
        return;
    char buf[10000];
    if( ! fgets( buf,999,fp) )
        return;
    std::string s = buf;
    int p,q;
    q = -1;
    // loop over columns
    while( 1 ) {
        p = q;
        q = s.find_first_of(",\n",p+1);
        if( q == -1 ) 
            break;
        vls.Push_back( s.substr(p+1,q-p-1) );
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    std::vector<std::string> vls;
    FILE * fp = fopen( argv[1], "r" );
    if( ! fp )
        return 1;
    readCSV( fp, vls );
    readCSV( fp, vls );
    readCSV( fp, vls );
    std::cout << "row 3, col 4 is " << vls[3].c_str() << "\n";

    return 0;
}
2
ravenspoint

Ich habe eine nette Methode zum Analysieren von CSV-Dateien geschrieben und wollte diese als Antwort hinzufügen:

#include <algorithm>
#include <fstream>
#include <iostream>
#include <stdlib.h>
#include <stdio.h>

struct CSVDict
{
  std::vector< std::string > inputImages;
  std::vector< double > inputLabels;
};

/**
\brief Splits the string

\param str String to split
\param delim Delimiter on the basis of which splitting is to be done
\return results Output in the form of vector of strings
*/
std::vector<std::string> stringSplit( const std::string &str, const std::string &delim )
{
  std::vector<std::string> results;

  for (size_t i = 0; i < str.length(); i++)
  {
    std::string tempString = "";
    while ((str[i] != *delim.c_str()) && (i < str.length()))
    {
      tempString += str[i];
      i++;
    }
    results.Push_back(tempString);
  }

  return results;
}

/**
\brief Parse the supplied CSV File and obtain Row and Column information. 

Assumptions:
1. Header information is in first row
2. Delimiters are only used to differentiate cell members

\param csvFileName The full path of the file to parse
\param inputColumns The string of input columns which contain the data to be used for further processing
\param inputLabels The string of input labels based on which further processing is to be done
\param delim The delimiters used in inputColumns and inputLabels
\return Vector of Vector of strings: Collection of rows and columns
*/
std::vector< CSVDict > parseCSVFile( const std::string &csvFileName, const std::string &inputColumns, const std::string &inputLabels, const std::string &delim )
{
  std::vector< CSVDict > return_CSVDict;
  std::vector< std::string > inputColumnsVec = stringSplit(inputColumns, delim), inputLabelsVec = stringSplit(inputLabels, delim);
  std::vector< std::vector< std::string > > returnVector;
  std::ifstream inFile(csvFileName.c_str());
  int row = 0;
  std::vector< size_t > inputColumnIndeces, inputLabelIndeces;
  for (std::string line; std::getline(inFile, line, '\n');)
  {
    CSVDict tempDict;
    std::vector< std::string > rowVec;
    line.erase(std::remove(line.begin(), line.end(), '"'), line.end());
    rowVec = stringSplit(line, delim);

    // for the first row, record the indeces of the inputColumns and inputLabels
    if (row == 0)
    {
      for (size_t i = 0; i < rowVec.size(); i++)
      {
        for (size_t j = 0; j < inputColumnsVec.size(); j++)
        {
          if (rowVec[i] == inputColumnsVec[j])
          {
            inputColumnIndeces.Push_back(i);
          }
        }
        for (size_t j = 0; j < inputLabelsVec.size(); j++)
        {
          if (rowVec[i] == inputLabelsVec[j])
          {
            inputLabelIndeces.Push_back(i);
          }
        }
      }
    }
    else
    {
      for (size_t i = 0; i < inputColumnIndeces.size(); i++)
      {
        tempDict.inputImages.Push_back(rowVec[inputColumnIndeces[i]]);
      }
      for (size_t i = 0; i < inputLabelIndeces.size(); i++)
      {
        double test = std::atof(rowVec[inputLabelIndeces[i]].c_str());
        tempDict.inputLabels.Push_back(std::atof(rowVec[inputLabelIndeces[i]].c_str()));
      }
      return_CSVDict.Push_back(tempDict);
    }
    row++;
  }

  return return_CSVDict;
}
1
scap3y

Für was es wert ist, hier ist meine Implementierung. Es befasst sich mit der Eingabe von wstring, könnte aber leicht angepasst werden. Es behandelt keine Zeilenumbrüche in Feldern (da meine Anwendung dies auch nicht tut, aber das Hinzufügen der Unterstützung nicht allzu schwierig ist), und es entspricht nicht dem Zeilenende "\ r\n" gemäß RFC (vorausgesetzt Sie verwenden std getline), kann jedoch mit Leerzeichen und doppelten Anführungszeichen korrekt umgehen (hoffentlich).

using namespace std;

// trim whitespaces around field or double-quotes, remove double-quotes and replace escaped double-quotes (double double-quotes)
wstring trimquote(const wstring& str, const wstring& whitespace, const wchar_t quotChar)
{
    wstring ws;
    wstring::size_type strBegin = str.find_first_not_of(whitespace);
    if (strBegin == wstring::npos)
        return L"";

    wstring::size_type strEnd = str.find_last_not_of(whitespace);
    wstring::size_type strRange = strEnd - strBegin + 1;

    if((str[strBegin] == quotChar) && (str[strEnd] == quotChar))
    {
        ws = str.substr(strBegin+1, strRange-2);
        strBegin = 0;
        while((strEnd = ws.find(quotChar, strBegin)) != wstring::npos)
        {
            ws.erase(strEnd, 1);
            strBegin = strEnd+1;
        }

    }
    else
        ws = str.substr(strBegin, strRange);
    return ws;
}

pair<unsigned, unsigned> nextCSVQuotePair(const wstring& line, const wchar_t quotChar, unsigned ofs = 0)
{
    pair<unsigned, unsigned> r;
    r.first = line.find(quotChar, ofs);
    r.second = wstring::npos;
    if(r.first != wstring::npos)
    {
        r.second = r.first;
        while(((r.second = line.find(quotChar, r.second+1)) != wstring::npos)
            && (line[r.second+1] == quotChar)) // WARNING: assumes null-terminated string such that line[r.second+1] always exist
            r.second++;

    }
    return r;
}

unsigned parseLine(vector<wstring>& fields, const wstring& line)
{
    unsigned ofs, ofs0, np;
    const wchar_t delim = L',';
    const wstring whitespace = L" \t\xa0\x3000\x2000\x2001\x2002\x2003\x2004\x2005\x2006\x2007\x2008\x2009\x200a\x202f\x205f";
    const wchar_t quotChar = L'\"';
    pair<unsigned, unsigned> quot;

    fields.clear();

    ofs = ofs0 = 0;
    quot = nextCSVQuotePair(line, quotChar);
    while((np = line.find(delim, ofs)) != wstring::npos)
    {
        if((np > quot.first) && (np < quot.second))
        { // skip delimiter inside quoted field
            ofs = quot.second+1;
            quot = nextCSVQuotePair(line, quotChar, ofs);
            continue;
        }
        fields.Push_back( trimquote(line.substr(ofs0, np-ofs0), whitespace, quotChar) );
        ofs = ofs0 = np+1;
    }
    fields.Push_back( trimquote(line.substr(ofs0), whitespace, quotChar) );

    return fields.size();
}
1
Fabien

Da ich momentan nicht daran gewöhnt bin, zu steigern, werde ich eine einfachere Lösung vorschlagen. Nehmen wir an, Ihre .csv-Datei hat 100 Zeilen mit 10 Zahlen in jeder Zeile, die durch ein ',' getrennt sind. Sie können diese Daten in Form eines Arrays mit folgendem Code laden:

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
using namespace std;

int main()
{
    int A[100][10];
    ifstream ifs;
    ifs.open("name_of_file.csv");
    string s1;
    char c;
    for(int k=0; k<100; k++)
    {
        getline(ifs,s1);
        stringstream stream(s1);
        int j=0;
        while(1)
        {
            stream >>A[k][j];
            stream >> c;
            j++;
            if(!stream) {break;}
        }
    }


}
1
nikos_k

Sie können diese Bibliothek verwenden: https://github.com/vadamsky/csvworker

Code zum Beispiel:

#include <iostream>
#include "csvworker.h"

using namespace std;

int main()
{
    //
    CsvWorker csv;
    csv.loadFromFile("example.csv");
    cout << csv.getRowsNumber() << "  " << csv.getColumnsNumber() << endl;

    csv.getFieldRef(0, 2) = "0";
    csv.getFieldRef(1, 1) = "0";
    csv.getFieldRef(1, 3) = "0";
    csv.getFieldRef(2, 0) = "0";
    csv.getFieldRef(2, 4) = "0";
    csv.getFieldRef(3, 1) = "0";
    csv.getFieldRef(3, 3) = "0";
    csv.getFieldRef(4, 2) = "0";

    for(unsigned int i=0;i<csv.getRowsNumber();++i)
    {
        //cout << csv.getRow(i) << endl;
        for(unsigned int j=0;j<csv.getColumnsNumber();++j)
        {
            cout << csv.getField(i, j) << ".";
        }
        cout << endl;
    }

    csv.saveToFile("test.csv");

    //
    CsvWorker csv2(4,4);

    csv2.getFieldRef(0, 0) = "a";
    csv2.getFieldRef(0, 1) = "b";
    csv2.getFieldRef(0, 2) = "r";
    csv2.getFieldRef(0, 3) = "a";
    csv2.getFieldRef(1, 0) = "c";
    csv2.getFieldRef(1, 1) = "a";
    csv2.getFieldRef(1, 2) = "d";
    csv2.getFieldRef(2, 0) = "a";
    csv2.getFieldRef(2, 1) = "b";
    csv2.getFieldRef(2, 2) = "r";
    csv2.getFieldRef(2, 3) = "a";

    csv2.saveToFile("test2.csv");

    return 0;
}
1
vadamsky

Wenn Sie Boost nicht in Ihr Projekt einbeziehen möchten (es ist beträchtlich, wenn Sie es nur für CSV-Analyse verwenden ...)

Ich hatte Glück beim CSV-Parsen hier:

http://www.zedwood.com/article/112/cpp-csv-parser

Es behandelt in Anführungszeichen stehende Felder, jedoch keine Inline-Zeichen (was für die meisten Zwecke in Ordnung ist).

1
NPike

Eine weitere schnelle und einfache Möglichkeit ist die Verwendung von Boost.Fusion I/O :

#include <iostream>
#include <sstream>

#include <boost/fusion/adapted/boost_Tuple.hpp>
#include <boost/fusion/sequence/io.hpp>

namespace fusion = boost::fusion;

struct CsvString
{
    std::string value;

    // Stop reading a string once a CSV delimeter is encountered.
    friend std::istream& operator>>(std::istream& s, CsvString& v) {
        v.value.clear();
        for(;;) {
            auto c = s.peek();
            if(std::istream::traits_type::eof() == c || ',' == c || '\n' == c)
                break;
            v.value.Push_back(c);
            s.get();
        }
        return s;
    }

    friend std::ostream& operator<<(std::ostream& s, CsvString const& v) {
        return s << v.value;
    }
};

int main() {
    std::stringstream input("abc,123,true,3.14\n"
                            "def,456,false,2.718\n");

    typedef boost::Tuple<CsvString, int, bool, double> CsvRow;

    using fusion::operator<<;
    std::cout << std::boolalpha;

    using fusion::operator>>;
    input >> std::boolalpha;
    input >> fusion::Tuple_open("") >> fusion::Tuple_close("\n") >> fusion::Tuple_delimiter(',');

    for(CsvRow row; input >> row;)
        std::cout << row << '\n';
}

Ausgänge:

(abc 123 true 3.14)
(def 456 false 2.718)
1

Sie können sich auch die Funktionen der Bibliothek Qt ansehen.

Es hat Unterstützung für reguläre Ausdrücke und die QString-Klasse verfügt über Nice-Methoden, z. split() gibt QStringList zurück, eine Liste von Strings, die durch Aufteilen des ursprünglichen Strings mit einem angegebenen Trennzeichen erhalten werden. Sollte für csv-Datei ausreichen .. 

Um eine Spalte mit einem gegebenen Headernamen zu erhalten, verwende ich Folgendes: c ++ - Vererbung Qt-Problem qstring

1
MadH

Ich brauchte eine einfach zu bedienende C++ - Bibliothek zum Analysieren von CSV-Dateien, konnte aber keine verfügbaren Dateien finden. Daher baute ich eine Rapidcsv ist eine reine C++ 11-Kopfbibliothek, die direkt gibt Zugriff auf geparste Spalten (oder Zeilen) als Vektoren im Datentyp Ihrer Wahl. Zum Beispiel:

#include <iostream>
#include <vector>
#include <rapidcsv.h>

int main()
{
  rapidcsv::Document doc("../tests/msft.csv");

  std::vector<float> close = doc.GetColumn<float>("Close");
  std::cout << "Read " << close.size() << " values." << std::endl;
}
1
d99kris

Hier ist eine gebrauchsfertige Funktion, wenn Sie lediglich eine Datendatei (keine Ganzzahlen, keinen Text) laden müssen.

#include <sstream>
#include <fstream>
#include <iterator>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

/**
 * Parse a CSV data file and fill the 2d STL vector "data".
 * Limits: only "pure datas" of doubles, not encapsulated by " and without \n inside.
 * Further no formatting in the data (e.g. scientific notation)
 * It however handles both dots and commas as decimal separators and removes thousand separator.
 * 
 * returnCodes[0]: file access 0-> ok 1-> not able to read; 2-> decimal separator equal to comma separator
 * returnCodes[1]: number of records
 * returnCodes[2]: number of fields. -1 If rows have different field size
 * 
 */
vector<int>
readCsvData (vector <vector <double>>& data, const string& filename, const string& delimiter, const string& decseparator){

 int vv[3] = { 0,0,0 };
 vector<int> returnCodes(&vv[0], &vv[0]+3);

 string rowstring, stringtoken;
 double doubletoken;
 int rowcount=0;
 int fieldcount=0;
 data.clear();

 ifstream iFile(filename, ios_base::in);
 if (!iFile.is_open()){
   returnCodes[0] = 1;
   return returnCodes;
 }
 while (getline(iFile, rowstring)) {
    if (rowstring=="") continue; // empty line
    rowcount ++; //let's start with 1
    if(delimiter == decseparator){
      returnCodes[0] = 2;
      return returnCodes;
    }
    if(decseparator != "."){
     // remove dots (used as thousand separators)
     string::iterator end_pos = remove(rowstring.begin(), rowstring.end(), '.');
     rowstring.erase(end_pos, rowstring.end());
     // replace decimal separator with dots.
     replace(rowstring.begin(), rowstring.end(),decseparator.c_str()[0], '.'); 
    } else {
     // remove commas (used as thousand separators)
     string::iterator end_pos = remove(rowstring.begin(), rowstring.end(), ',');
     rowstring.erase(end_pos, rowstring.end());
    }
    // tokenize..
    vector<double> tokens;
    // Skip delimiters at beginning.
    string::size_type lastPos = rowstring.find_first_not_of(delimiter, 0);
    // Find first "non-delimiter".
    string::size_type pos     = rowstring.find_first_of(delimiter, lastPos);
    while (string::npos != pos || string::npos != lastPos){
        // Found a token, convert it to double add it to the vector.
        stringtoken = rowstring.substr(lastPos, pos - lastPos);
        if (stringtoken == "") {
      tokens.Push_back(0.0);
    } else {
          istringstream totalSString(stringtoken);
      totalSString >> doubletoken;
      tokens.Push_back(doubletoken);
    }     
        // Skip delimiters.  Note the "not_of"
        lastPos = rowstring.find_first_not_of(delimiter, pos);
        // Find next "non-delimiter"
        pos = rowstring.find_first_of(delimiter, lastPos);
    }
    if(rowcount == 1){
      fieldcount = tokens.size();
      returnCodes[2] = tokens.size();
    } else {
      if ( tokens.size() != fieldcount){
    returnCodes[2] = -1;
      }
    }
    data.Push_back(tokens);
 }
 iFile.close();
 returnCodes[1] = rowcount;
 return returnCodes;
}
1
Antonello

Es ist möglich, std::regex zu verwenden. 

Abhängig von der Größe Ihrer Datei und dem für Sie verfügbaren Speicher können Sie sie entweder Zeile für Zeile oder vollständig in einem std::string lesen. 

Zum Lesen der Datei kann man verwenden: 

std::ifstream t("file.txt");
std::string sin((std::istreambuf_iterator<char>(t)),
                 std::istreambuf_iterator<char>());

dann können Sie mit diesem übereinstimmen, das tatsächlich an Ihre Bedürfnisse angepasst werden kann.

std::regex Word_regex(",\\s]+");
auto what = 
    std::sregex_iterator(sin.begin(), sin.end(), Word_regex);
auto wend = std::sregex_iterator();

std::vector<std::string> v;
for (;what!=wend ; wend) {
    std::smatch match = *what;
    v.Push_back(match.str());
}
1
g24l

Dies ist ein alter Thread, aber es steht immer noch ganz oben in den Suchergebnissen. Daher füge ich meine Lösung mit std :: stringstream und einer einfachen String-Ersatzmethode von Yves Baumes hinzu, die ich hier gefunden habe. 

Das folgende Beispiel liest eine Datei Zeile für Zeile, ignoriert Kommentarzeilen, die mit // beginnen, und analysiert die anderen Zeilen in eine Kombination aus Strings, Ints und Doubles. Stringstream führt das Parsing durch, erwartet jedoch, dass Felder durch Leerzeichen begrenzt werden. Daher verwende ich stringreplace, um Kommas zuerst in Leerzeichen umzuwandeln. Es behandelt Tabs in Ordnung, behandelt aber keine Strings in Anführungszeichen.

Schlechte oder fehlende Eingaben werden einfach ignoriert, was je nach Ihren Umständen möglicherweise gut ist.

#include <string>
#include <sstream>
#include <fstream>

void StringReplace(std::string& str, const std::string& oldStr, const std::string& newStr)
// code by  Yves Baumes
// http://stackoverflow.com/questions/1494399/how-do-i-search-find-and-replace-in-a-standard-string
{
  size_t pos = 0;
  while((pos = str.find(oldStr, pos)) != std::string::npos)
  {
     str.replace(pos, oldStr.length(), newStr);
     pos += newStr.length();
  }
}

void LoadCSV(std::string &filename) {
   std::ifstream stream(filename);
   std::string in_line;
   std::string Field;
   std::string Chan;
   int ChanType;
   double Scale;
   int Import;
   while (std::getline(stream, in_line)) {
      StringReplace(in_line, ",", " ");
      std::stringstream line(in_line);
      line >> Field >> Chan >> ChanType >> Scale >> Import;
      if (Field.substr(0,2)!="//") {
         // do your stuff 
         // this is CBuilder code for demonstration, sorry
         ShowMessage((String)Field.c_str() + "\n" + Chan.c_str() + "\n" + IntToStr(ChanType) + "\n" +FloatToStr(Scale) + "\n" +IntToStr(Import));
      }
   }
}
1
marcp

Ich habe eine schnellere Lösung gefunden, war ursprünglich für diese Frage gedacht:

Wie ziehe ich einen bestimmten Teil der verschiedenen Saiten?

Aber es war offensichtlich geschlossen. Ich werde das allerdings nicht wegwerfen:

#include <iostream>
#include <string>
#include <regex>

std::string text = "\"4,\"\"3\"\",\"\"Mon May 11 03:17:40 UTC 2009\"\",\"\"Kindle2\"\",\"\"tpryan\"\",\"\"TEXT HERE\"\"\";;;;";

int main()
{
    std::regex r("(\".*\")(\".*\")(\".*\")(\".*\")(\".*\")(\".*\")(\".*\")(\".*\")(\".*\")(\".*\")");
    std::smatch m;
    std::regex_search(text, m, r);
    std::cout<<"FOUND: "<<m[9]<<std::endl;

    return 0;
}

Wählen Sie einfach aus der Smatch-Sammlung den gewünschten Treffer aus.

0
Jack Of Blades

Wenn Sie Visual Studio/MFC verwenden, kann Ihnen die folgende Lösung das Leben erleichtern. Es unterstützt sowohl Unicode als auch MBCS, hat Kommentare, hat keine anderen Abhängigkeiten als CString und funktioniert für mich gut genug. Zeilenumbrüche, die in eine Anführungszeichenfolge eingebettet sind, werden nicht unterstützt. Es ist mir aber egal, wenn es in diesem Fall nicht zum Absturz kommt.

Die übergeordnete Strategie besteht darin, zitierte und leere Zeichenfolgen als Sonderfälle zu behandeln und für den Rest Tokenize zu verwenden. Bei Strings in Anführungszeichen lautet die Strategie, den tatsächlichen Schlusskurs zu finden und zu verfolgen, ob Paare aufeinanderfolgender Anführungszeichen gefunden wurden. Wenn ja, verwenden Sie Replace, um die Paare in Singles zu konvertieren. Zweifellos gibt es effizientere Methoden, aber die Leistung war in meinem Fall nicht ausreichend kritisch, um eine weitere Optimierung zu rechtfertigen.

class CParseCSV {
public:
// Construction
    CParseCSV(const CString& sLine);

// Attributes
    bool    GetString(CString& sDest);

protected:
    CString m_sLine;    // line to extract tokens from
    int     m_nLen;     // line length in characters
    int     m_iPos;     // index of current position
};

CParseCSV::CParseCSV(const CString& sLine) : m_sLine(sLine)
{
    m_nLen = m_sLine.GetLength();
    m_iPos = 0;
}

bool CParseCSV::GetString(CString& sDest)
{
    if (m_iPos < 0 || m_iPos > m_nLen)  // if position out of range
        return false;
    if (m_iPos == m_nLen) { // if at end of string
        sDest.Empty();  // return empty token
        m_iPos = -1;    // really done now
        return true;
    }
    if (m_sLine[m_iPos] == '\"') {  // if current char is double quote
        m_iPos++;   // advance to next char
        int iTokenStart = m_iPos;
        bool    bHasEmbeddedQuotes = false;
        while (m_iPos < m_nLen) {   // while more chars to parse
            if (m_sLine[m_iPos] == '\"') {  // if current char is double quote
                // if next char exists and is also double quote
                if (m_iPos < m_nLen - 1 && m_sLine[m_iPos + 1] == '\"') {
                    // found pair of consecutive double quotes
                    bHasEmbeddedQuotes = true;  // request conversion
                    m_iPos++;   // skip first quote in pair
                } else  // next char doesn't exist or is normal
                    break;  // found closing quote; exit loop
            }
            m_iPos++;   // advance to next char
        }
        sDest = m_sLine.Mid(iTokenStart, m_iPos - iTokenStart);
        if (bHasEmbeddedQuotes) // if string contains embedded quote pairs
            sDest.Replace(_T("\"\""), _T("\""));    // convert pairs to singles
        m_iPos += 2;    // skip closing quote and trailing delimiter if any
    } else if (m_sLine[m_iPos] == ',') {    // else if char is comma
        sDest.Empty();  // return empty token
        m_iPos++;   // advance to next char
    } else {    // else get next comma-delimited token
        sDest = m_sLine.Tokenize(_T(","), m_iPos);
    }
    return true;
}

// calling code should look something like this:

    CStdioFile  fIn(pszPath, CFile::modeRead);
    CString sLine, sToken;
    while (fIn.ReadString(sLine)) { // for each line of input file
        if (!sLine.IsEmpty()) { // ignore blank lines
            CParseCSV   csv(sLine);
            while (csv.GetString(sToken)) {
                // do something with sToken here
            }
        }
    }
0
victimofleisure