Datei zeilenweise lesen

Den Inhalt file.txt sind:

Wo 5 3 ist ein Koordinaten-paar.
Wie kann ich diese Daten Zeile für Zeile in C++?

Ich bin in der Lage zu Holen Sie sich die erste Zeile, aber wie bekomme ich die nächste Zeile der Datei?

ofstream myfile;
myfile.open ("text.txt");

InformationsquelleAutor der Frage dukevin | 2011-10-23

c++file-io ofstream

686

Erste, machen eine ifstream:
```
#include <fstream>
std::ifstream infile("thefile.txt");
```
Den zwei standard-Methoden:
1. Davon ausgehen, dass jede Zeile besteht aus zwei zahlen und Lesen von token durch den token:
```
int a, b;
while (infile >> a >> b)
{
    //process pair (a,b)
}
```
2. Line-basierte Parsen mit string-streams:
```
#include <sstream>
#include <string>

std::string line;
while (std::getline(infile, line))
{
    std::istringstream iss(line);
    int a, b;
    if (!(iss >> a >> b)) { break; } //error

    //process pair (a,b)
}
```
Sollte man nicht mischen (1) und (2), da die token-basierte Analyse nicht verschlingen-Zeilenumbrüche enthalten, so können Sie am Ende mit fadenscheinigen leere Zeilen, wenn Sie getline() nach token-basierte Extraktion bekam Sie am Ende einer Zeile bereits.

InformationsquelleAutor der Antwort Kerrek SB
139

Verwenden ifstream um Daten aus einer Datei Lesen:
```
std::ifstream input( "filename.ext" );
```
Wenn Sie wirklich brauchen, zu Lesen, Zeile für Zeile, dann tun Sie dies:
```
for( std::string line; getline( input, line ); )
{
    ...for each line in input...
}
```
Aber Sie brauchen wahrscheinlich nur zum extrahieren von koordinatenpaaren:
```
int x, y;
input >> x >> y;
```
Update:

In Ihrem code, den Sie verwenden ofstream myfile; jedoch die o im ofstream steht für output. Wenn Sie möchten, die Datei zu Lesen (input) verwenden ifstream. Wenn Sie möchten, Lesen und schreiben verwenden fstream.

InformationsquelleAutor der Antwort K-ballo

Da Ihre Koordinaten gehören zusammen wie die Paare, warum nicht schreiben Sie eine struct für Sie?

struct CoordinatePair
{
    int x;
    int y;
};

Dann schreiben Sie eine überladene Extraktion Betreiber für istreams:

std::istream& operator>>(std::istream& is, CoordinatePair& coordinates)
{
    is >> coordinates.x >> coordinates.y;

    return is;
}

Dann können Sie eine Datei Lesen von Koordinaten direkt in einen Vektor so:

#include <fstream>
#include <iterator>
#include <vector>

int main()
{
    char filename[] = "coordinates.txt";
    std::vector<CoordinatePair> v;
    std::ifstream ifs(filename);
    if (ifs) {
        std::copy(std::istream_iterator<CoordinatePair>(ifs), 
                std::istream_iterator<CoordinatePair>(),
                std::back_inserter(v));
    }
    else {
        std::cerr << "Couldn't open " << filename << " for reading\n";
    }
    //Now you can work with the contents of v
}

InformationsquelleAutor der Antwort Martin Broadhurst

Erweiterung auf die Antwort akzeptiert, wenn die Eingabe:

1,NYC
2,ABQ
...

werden Sie noch in der Lage sein, um die gleichen Logik, wie diese:

#include <fstream>

std::ifstream infile("thefile.txt");
if (infile.is_open()) {
    int number;
    std::string str;
    char c;
    while (infile >> number >> c >> str && c == ',')
        std::cout << number << " " << str << "\n";
}
infile.close();

InformationsquelleAutor der Antwort gsamaras

Zwar gibt es keine Notwendigkeit, die Datei zu schließen manuell aber es ist eine gute Idee dies zu tun, wenn der Umfang der Datei variable ist größer:

    ifstream infile(szFilePath);

    for (string line = ""; getline(infile, line); )
    {
        //do something with the line
    }

    if(infile.is_open())
        infile.close();

InformationsquelleAutor der Antwort Vijay Bansal

Liest eine Datei Zeile für Zeile in C++ kann man in einige verschiedene Möglichkeiten.

[Schnell] Schleife mit std::getline()

Die einfachste Methode ist das öffnen std::ifstream und Schleife mit std::getline () - Aufrufe. Der code ist sauber und einfach zu verstehen.

#include <fstream>

std::ifstream file(FILENAME);
if (file.is_open()) {
    std::string line;
    while (getline(file, line)) {
        std::cout << line << '\n';
    }
    file.close();
}

[Schnell] die Verwendung von Boost ist file_description_source

Andere Möglichkeit ist die Verwendung der Boost-library, aber der code wird ein wenig Ausführlicher. Die Leistung ist sehr ähnlich zu den obigen code (Schleife mit std::getline()).

#include <boost/iostreams/device/file_descriptor.hpp>
#include <boost/iostreams/stream.hpp>
#include <fcntl.h>

namespace io = boost::iostreams;

void readLineByLineBoost() {
    int fdr = open(FILENAME, O_RDONLY);
    if (fdr >= 0) {
        io::file_descriptor_source fdDevice(fdr, io::file_descriptor_flags::close_handle);
        io::stream <io::file_descriptor_source> in(fdDevice);
        if (fdDevice.is_open()) {
            std::string line;
            while (std::getline(in, line)) {
                std::cout << line << '\n';
            }
            fdDevice.close();
        }
    }
}

[Schnellste] der Einsatz von C-code

Wenn die Leistung ist entscheidend für Ihre software, können Sie erwägen, die Verwendung der C-Sprache. Dieser code kann 4-5 mal schneller als die C++ - Versionen vor, siehe benchmark unten

FILE* fp = fopen(FILENAME, "r");
if (fp == NULL)
    exit(EXIT_FAILURE);

char* line = NULL;
size_t len = 0;
while ((getline(&line, &len, fp)) != -1) {
    printf("%s", line);
}
fclose(fp);
if (line)
    free(line);

Benchmark -- Was ist schneller?

Habe ich getan einige performance-benchmarks mit dem code oben und die Ergebnisse sind interessant. Ich habe getestet, der code mit ASCII-Dateien mit jeweils 100.000 Zeilen, 1,000,000 Linien und von 10.000.000 Zeilen text. Jede Textzeile enthält 10 Wörter im Durchschnitt. Die Ergebnisse zeigen die Zeit (in ms), dass jedes Stück code, das nahm, die files zu Lesen.

Den Unterschied in der Leistung zwischen den beiden C++ - Ansätze ist minimal und sollte nicht machen einen Unterschied in der Praxis. Die Leistung der C-code ist, was macht die benchmark beeindruckend und kann ein Spiel-wechsler in Bezug auf die Geschwindigkeit.

                             10K lines     100K lines     1000K lines
Loop with std::getline()         105ms          894ms          9773ms
Boost code                       106ms          968ms          9561ms
C code                            23ms          243ms          2397ms

Datei zeilenweise lesen

InformationsquelleAutor der Antwort HugoTeixeira

-3

mit dem command-line arguments:

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include "print.h"

using namespace std;

int main (int argc, char *argv[]) 
{
    vector<string> list;
    ifstream in_stream;
    string line;
    in_stream.open(argv[1]);

    while(!in_stream.eof())
    {
        in_stream >> line;
        list.push_back(line);
    }
    in_stream.close();
    print(list);
    sort(list.begin(), list.end());
    print(list);
}

InformationsquelleAutor der Antwort Alex Spencer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.