Leer el archivo línea por línea

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 se procesa 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?

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

Primero, ifstream un ifstream :

 #include  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  #include  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 espurias si usa getline() después de que la extracción basada en token lo lleve al fin de una línea ya.

Use ifstream para leer datos de un archivo:

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

Si realmente necesita leer línea por línea, haga esto:

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

Pero probablemente solo necesites extraer pares de coordenadas:

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

Actualizar:

En su código, usa ofstream myfile; Sin embargo, el o de ofstream representa la output . Si quiere leer del archivo (entrada) use ifstream . Si quieres leer y escribir, usa fstream .

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

Ampliando la respuesta aceptada, si la entrada es:

 1,NYC 2,ABQ ... 

aún podrá aplicar la misma lógica, así:

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

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

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

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

 #include  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] Use el archivo_description_source de Boost

Otra posibilidad es usar la biblioteca de 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  #include  #include  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  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] Use el código C

Si el rendimiento es crítico para su software, puede considerar usar el lenguaje C. Este código puede ser 4-5 veces más rápido que las versiones anteriores de C ++, ver 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); 

Punto de referencia – ¿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 progtwig se comstack con la 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 garantizar 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 cambiar las reglas del 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 

enter image description here

Aunque no es necesario cerrar el archivo manualmente, es una buena idea hacerlo si el scope 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(); 

con argumentos de línea de comando:

 #include  #include  #include  #include  #include "print.h" using namespace std; int main (int argc, char *argv[]) { vector 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); }