por - libreria de ficheros en c++

Lea el archivo línea por línea usando ifstream en C++

Question

Los contenidos de file.txt son:

5 3
6 4
7 1
10 5
11 6
12 3
12 4

Donde 5 3 es un par de coordenadas. ¿Cómo puedo procesar esta línea de datos por línea en C ++?

Puedo obtener la primera línea, pero ¿cómo obtengo la siguiente línea del archivo?

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

Answer 1

Ampliando la respuesta aceptada, si la entrada es:

1,NYC
2,ABQ
...

Aún podrás aplicar la misma lógica, como esta:

#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();

Answer 2

Aunque no es necesario cerrar el archivo manualmente, es una buena idea hacerlo si el alcance de la variable del archivo es mayor:

    ifstream infile(szFilePath);

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

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

Answer 3

La lectura de un archivo línea por línea en C ++ se puede hacer de diferentes maneras.

[Rápido] Bucle con std :: getline ()

El enfoque más simple es abrir un std :: ifstream y hacer un bucle usando las llamadas std :: getline (). El código es limpio y fácil de entender.

#include <fstream>

std::ifstream file(FILENAME);
if (file.is_open()) {
    std::string line;
    while (getline(file, line)) {
        // using printf() in all tests for consistency
        printf("%s", line.c_str());
    }
    file.close();
}

[Rápido] Utilice file_description_source de Boost

Otra posibilidad es usar la biblioteca Boost, pero el código se vuelve un poco más detallado. El rendimiento es bastante similar al código anterior (Loop con 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)) {
                // using printf() in all tests for consistency
                printf("%s", line.c_str());
            }
            fdDevice.close();
        }
    }
}

[Más rápido] Usa código C

Si el rendimiento es crítico para su software, puede considerar usar el lenguaje C. Este código puede ser de 4 a 5 veces más rápido que las versiones de C ++ anteriores, vea el punto de referencia a continuación

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

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

Benchmark - ¿Cuál es más rápido?

He hecho algunos puntos de referencia de rendimiento con el código anterior y los resultados son interesantes. He probado el código con archivos ASCII que contienen 100,000 líneas, 1,000,000 líneas y 10,000,000 líneas de texto. Cada línea de texto contiene 10 palabras en promedio. El programa se compila con optimización -O3 y su salida se reenvía a /dev/null para eliminar la variable de tiempo de registro de la medición. Por último, pero no menos importante, cada fragmento de código registra cada línea con la printf() para mantener la coherencia.

Los resultados muestran el tiempo (en ms) que tomó cada fragmento de código para leer los archivos.

La diferencia de rendimiento entre los dos enfoques de C ++ es mínima y no debería hacer ninguna diferencia en la práctica. El rendimiento del código C es lo que hace que el punto de referencia sea impresionante y puede ser un cambio de juego en términos de velocidad.

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

Answer 4

Primero, haz un ifstream :

#include <fstream>
std::ifstream infile("thefile.txt");

Los dos métodos estándar son:

1. Supongamos que cada línea consta de dos números y token de lectura por token:

   int a, b;
   while (infile >> a >> b)
   {
       // process pair (a,b)
   }

2. Análisis basado en líneas, utilizando secuencias de cadenas:

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

No debe mezclar (1) y (2), ya que el análisis basado en token no engulle nuevas líneas, por lo que puede terminar con líneas vacías falsas si usa getline() después de que la extracción basada en token lo llevara al final de una línea ya.

Answer 5

Utilice ifstream para leer datos de un archivo:

std::ifstream input( "filename.ext" );

Si realmente necesitas leer línea por línea, haz esto:

for( std::string line; getline( input, line ); )
{
    ...for each line in input...
}

Pero probablemente solo necesitas extraer pares de coordenadas:

int x, y;
input >> x >> y;

Actualizar:

En tu código utilizas ofstream myfile; Sin embargo, la o en ofstream significa output . Si desea leer desde el archivo (entrada) utilice ifstream . Si quieres leer y escribir usa fstream .

Answer 6

Ya que sus coordenadas pertenecen juntas como pares, ¿por qué no escribir una estructura para ellas?

struct CoordinatePair
{
    int x;
    int y;
};

Luego puede escribir un operador de extracción sobrecargado para istreams:

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

    return is;
}

Y luego puedes leer un archivo de coordenadas directamente en un vector como este:

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

Answer 7

con argumentos de línea de comando:

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