c++ - Datei-E / a & Aufteilung von separator

Ich habe eine Datei mit Daten, die wie folgt aufgelistet:

0,       2,    10
10,       8,    10
10,       10,   10
10,       16,   10
15,       10,   16
17,       10,   16

Ich möchte in der Lage sein, die Eingabe-Datei und teilen Sie es in drei arrays, die in den Prozess trimmen überschüssigen Leerzeichen und umwandeln jedes element zu zahlen.

Aus irgendeinem Grund kann ich nicht finden eine einfache Möglichkeit in c++. Der einzige Erfolg, den ich habe, ist durch die Eingabe jeder Zeile in ein array, und dann regexing alle Leerzeichen und dann aufteilen es. Dieser gesamte Prozess dauerte gute 20-30 Zeilen code und es ist ein Schmerz zu ändern für sagen anderen Trennzeichen(zB. Raum), etc.

Dies ist das python-äquivalent zu dem, was ich möchte in C++:

f = open('input_hard.dat')
lines =  f.readlines()
f.close()

#declarations
inint, inbase, outbase = [], [], []

#input parsing
for line in lines:
    bits = string.split(line, ',')
    inint.append(int(bits[0].strip()))
    inbase.append(int(bits[1].strip()))
    outbase.append(int(bits[2].strip()))

Den Bedienkomfort tut dies in python ist einer der Gründe, warum ich zog, um es in den ersten Platz. Allerdings, benötige ich zu diesem Zweck in C++ und ich würde es hassen zu müssen, um meine hässlichen 20-30 Zeile code.

Jede Hilfe würde geschätzt, danke!

InformationsquelleAutor darudude | 2008-11-06

c++file-io split

4

Es gibt wirklich nichts falsch mit fscanf, das ist wahrscheinlich die Schnellste Lösung in diesem Fall. Und es ist so kurz und lesbar wie der python-code:
```
FILE *fp = fopen("file.dat", "r");
int x, y, z;
std::vector<int> vx, vy, vz;

while (fscanf(fp, "%d, %d, %d", &x, &y, &z) == 3) {
  vx.push_back(x);
  vy.push_back(y);
  vz.push_back(z);
}
fclose(fp);
```
- Nice job. Leute vergessen scanf ist pattern matching. Die einfachste Lösung ist die beste.
InformationsquelleAutor ididak

Gibt es keine wirkliche brauchen, um boost in diesem Beispiel, wie streams wird der trick sehr schön:

int main(int argc, char* argv[])
{
    ifstream file(argv[1]);

    const unsigned maxIgnore = 10;
    const int delim = ',';
    int x,y,z;

    vector<int> vecx, vecy, vecz;

    while (file)
    {
        file >> x;
        file.ignore(maxIgnore, delim);
        file >> y;
        file.ignore(maxIgnore, delim);
        file >> z;

        vecx.push_back(x);
        vecy.push_back(y);
        vecz.push_back(z);
    }
}

Aber wenn ich gehen, um boost würd ich lieber die Einfachheit von tokenizer zu regex... 🙂

InformationsquelleAutor MattyT

Etwas wie:

vector<int> inint;
vector<int> inbase;
vector<int> outbase;
while (fgets(buf, fh)) {
   char *tok = strtok(buf, ", ");
   inint.push_back(atoi(tok));
   tok = strtok(NULL, ", ");
   inbase.push_back(atoi(tok));
   tok = strtok(NULL, ", ");
   outbase.push_back(atoi(tok));
}

Außer mit der Fehlerüberprüfung.

Ich möchte vermeiden, so ein "C-ähnlichen" Lösung für, na ja, die ästhetik...aber noch wichtiger ist in diesem Fall, da strtok hat einige ernste thread-sicher Probleme. Richtigen code aber!

InformationsquelleAutor MattSmith

1

std::getline können Sie Lesen eine Zeile text, und Sie können einen string-stream zu analysieren, die einzelnen Linien:
```
string buf;
getline(cin, buf); 
stringstream par(buf);

char buf2[512];
par.getline(buf2, 512, ','); /* Reads until the first token. */
```
Sobald Sie die Zeile des Texts in der Zeichenfolge, die Sie tatsächlich nutzen können jeder-parsing-Funktion, die Sie wollen, sogar sscanf(buf.c_str(), "%d,%d'%d", &i1, &i2 &i3), mit Hilfe von atoi auf den Teil mit der Ganzzahl, oder durch irgendeine andere Methode.

Können Sie ignorieren auch unerwünschte Zeichen im input-stream, wenn Sie wissen, Sie sind da:
```
if (cin.peek() == ',')
    cin.ignore(1, ',');
cin >> nextInt;  
```
InformationsquelleAutor Raymond Martineau

Wenn Euch das nichts ausmacht mit dem Boost-Bibliotheken...

#include <string>
#include <vector>
#include <boost/lexical_cast.hpp>
#include <boost/regex.hpp>

std::vector<int> ParseFile(std::istream& in) {
    const boost::regex cItemPattern(" *([0-9]+),?");
    std::vector<int> return_value;

    std::string line;
    while (std::getline(in, line)) {
        string::const_iterator b=line.begin(), e=line.end();
        boost::smatch match;
        while (b!=e && boost::regex_search(b, e, match, cItemPattern)) {
            return_value.push_back(boost::lexical_cast<int>(match[1].str()));
            b=match[0].second;
        };
    };

    return return_value;
}

Zieht die Linien aus dem stream, dann verwendet Boost::RegEx-Bibliothek (mit einer capture-Gruppe) zu extrahieren jede Zahl aus den Leitungen. Es wird automatisch ignoriert, was nicht eine gültige Nummer, aber das kann geändert werden, wenn Sie es wünschen.

Ist es immer noch etwa zwanzig Zeilen mit den #includes, aber Sie können es verwenden, zum extrahieren von im wesentlichen alles aus der Datei Linien. Dies ist ein triviales Beispiel, ich bin mit so ziemlich identischen code zu extrahieren-tags und die optionalen Werte aus einem Datenbankfeld, der einzige große Unterschied ist der reguläre Ausdruck.

EDIT: UPS, du wolltest drei separate Vektoren. Versuchen Sie, diese leichte Modifikation statt:

const boost::regex cItemPattern(" *([0-9]+), *([0-9]+), *([0-9]+)");
std::vector<int> vector1, vector2, vector3;

std::string line;
while (std::getline(in, line)) {
    string::const_iterator b=line.begin(), e=line.end();
    boost::smatch match;
    while (b!=e && boost::regex_search(b, e, match, cItemPattern)) {
        vector1.push_back(boost::lexical_cast<int>(match[1].str()));
        vector2.push_back(boost::lexical_cast<int>(match[2].str()));
        vector3.push_back(boost::lexical_cast<int>(match[3].str()));
        b=match[0].second;
    };
};

InformationsquelleAutor Head Geek

warum nicht den gleichen code wie in python 🙂 ?

std::ifstream file("input_hard.dat");
std::vector<int> inint, inbase, outbase;

while (file.good()){
    int val1, val2, val3;
    char delim;
    file >> val1 >> delim >> val2 >> delim >> val3;

    inint.push_back(val1);
    inbase.push_back(val2);
    outbase.push_back(val3);
}

InformationsquelleAutor da_m_n

0

Wenn Sie wollen in der Lage sein, zu skalieren, zu härteren input-Formate, sollten Sie überlegen, Geist, boost-parser combinator library.

Auf dieser Seite hat ein Beispiel, das fast tun, was Sie brauchen (mit reellen zahlen und ein Vektor wäre)

InformationsquelleAutor David Pierre

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.