texto - manejo de archivos en c++ fstream

¿Cómo leo un archivo de texto desde la segunda línea usando fstream?

Question

¿Cómo puedo hacer que mi objeto std::fstream comience a leer un archivo de texto de la segunda línea?

Answer 1

Use getline () para leer la primera línea, luego comience a leer el resto de la secuencia.

ifstream stream("filename.txt");
string dummyLine;
getline(stream, dummyLine);
// Begin reading your stream here
while (stream)
...

(Cambiado a std :: getline (gracias dalle.myopenid.com))

Answer 2

#include <fstream>
#include <iostream>
using namespace std;
int main ()
{
char buffer[256];
ifstream myfile ("test.txt");
// first line
myfile.getline (buffer,100);
// the rest
while (! myfile.eof() )
{
myfile.getline (buffer,100);
cout << buffer << endl;
}
return 0;
}

Answer 3

Llame a getline () una vez para tirar la primera línea

Existen otros métodos, pero el problema es que no sabes cuánto tiempo durará la primera línea, ¿verdad? Entonces no puedes omitirlo hasta que sepas dónde está esa primera ''/ n''. Sin embargo, si supiera cuánto tiempo va a durar la primera línea, simplemente puede buscar más allá, luego comenzar a leer, esto sería más rápido.

Entonces, hacerlo de la primera manera sería algo así como:

#include <fstream>
#include <iostream>
using namespace std;
int main ()
{
// Open your file
ifstream someStream( "textFile.txt" );
// Set up a place to store our data read from the file
string line;
// Read and throw away the first line simply by doing
// nothing with it and reading again
getline( someStream, line );
// Now begin your useful code
while( !someStream.eof() ) {
// This will just over write the first line read
getline( someStream, line );
cout << line << endl;
}
return 0;
}

Answer 4

Puede usar la función de ignorar de la transmisión:

ifstream stream("filename.txt");
// Get and drop a line
stream.ignore ( std::numeric_limits<std::streamsize>::max(), ''/n'' );
// Get and store a line for processing.
// std::getline() has a third parameter the defaults to ''/n'' as the line
// delimiter.
std::string line;
std::getline(stream,line);
std::string word;
stream >> word; // Reads one space separated word from the stream.

Un error común para leer un archivo:

while( someStream.good() ) // !someStream.eof()
{
getline( someStream, line );
cout << line << endl;
}

Esto falla porque: Al leer la última línea, no lee el marcador EOF. Entonces, la transmisión sigue siendo buena, pero ya no quedan más datos en la transmisión para leer. Entonces, el ciclo se vuelve a ingresar. std :: getline () luego intenta leer otra línea de someStream y falla, pero aún escribe una línea para std :: cout.

Solución simple:

while( someStream ) // Same as someStream.good() { getline( someStream, line ); if (someStream) // streams when used in a boolean context are converted to a type that is usable in that context. If the stream is in a good state the object returned can be used as true { // Only write to cout if the getline did not fail. cout << line << endl; } } Solución correcta:

while(getline( someStream, line ))
{
// Loop only entered if reading a line from somestream is OK.
// Note: getline() returns a stream reference. This is automatically cast
// to boolean for the test. streams have a cast to bool operator that checks
// good()
cout << line << endl;
}

Answer 5

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main()
{
string textString;
string anotherString;
ifstream textFile;
textFile.open("TextFile.txt");
if (textFile.is_open()) {
while (getline(textFile, textString)){
anotherString = anotherString + textString;
}
}
std::cout << anotherString;
textFile.close();
return 0;
}

Answer 6

La forma más eficiente es ignorar cadenas con std :: istream :: ignorar

for (int currLineNumber = 0; currLineNumber < startLineNumber; ++currLineNumber){
if (addressesFile.ignore(numeric_limits<streamsize>::max(), addressesFile.widen(''/n''))){
//just skipping the line
} else
return HandleReadingLineError(addressesFile, currLineNumber);
}

HandleReadingLineError no es estándar sino hecho a mano , por supuesto. El primer parámetro es la cantidad máxima de caracteres para extraer. Si esto es exactamente numeric_limits :: max (), no hay límite: Enlace en cplusplus.com: std :: istream :: ignore

Si va a omitir muchas líneas, definitivamente debería usarla en lugar de getline: cuando necesité omitir 100000 líneas en mi archivo, tardó aproximadamente un segundo, en lugar de 22 segundos, con getline.