manejo - leer archivo txt c++ linea por linea

¿Cómo se abre un archivo en C++?

Question

Quiero abrir un archivo para leer, el modo C ++. Necesito poder hacerlo por:

• archivos de texto, lo que implicaría algún tipo de función de línea de lectura.

• archivos binarios, que proporcionarían una manera de leer datos en bruto en un búfer char* .

Answer 1

Para abrir y leer una línea de archivo de texto por línea, puede usar lo siguiente:

// define your file name
string file_name = "data.txt";

// attach an input stream to the wanted file
ifstream input_stream(file_name);

// check stream status
if (!input_stream) cerr << "Can''t open input file!";

// file contents  
vector<string> text;

// one line
string line;

// extract all the text from the input file
while (getline(input_stream, line)) {

    // store each line in the vector
    text.push_back(line);
}

Para abrir y leer un archivo binario necesita declarar explícitamente que el formato de lectura en su flujo de entrada es binario, y leer la memoria que no tiene una interpretación explícita usando la función de read() miembros read() :

// define your file name
string file_name = "binary_data.bin";

// attach an input stream to the wanted file
ifstream input_stream(file_name, ios::binary);

// check stream status
if (!input_stream) cerr << "Can''t open input file!";

// use function that explicitly specifies the amount of block memory read 
int memory_size = 10;

// allocate 10 bytes of memory on heap
char* dynamic_buffer = new char[memory_size];

// read 10 bytes and store in dynamic_buffer
file_name.read(dynamic_buffer, memory_size);

Al hacer esto, necesitará #include el encabezado: <iostream>

Answer 2

#include <iostream>
#include <fstream>
using namespace std;

void main()
{
    ifstream in_stream; // fstream command to initiate "in_stream" as a command.
    char filename[31]; // variable for "filename".
    cout << "Enter file name to open :: "; // asks user for input for "filename".
    cin.getline(filename, 30); // this gets the line from input for "filename".
    in_stream.open(filename); // this in_stream (fstream) the "filename" to open.
    if (in_stream.fail())
    {
        cout << "Could not open file to read.""/n"; // if the open file fails.
        return;
    }
    //.....the rest of the text goes beneath......
}

Answer 3

Hay tres formas de hacerlo, según sus necesidades. Puede usar el método C de la vieja escuela y llamar a fopen / fread / fclose, o puede usar las instalaciones de C ++ fstream (ifstream / ofstream), o si está utilizando MFC, use la clase CFile, que proporciona funciones para lograr real operaciones de archivo.

Todos estos son adecuados para texto y binario, aunque ninguno tiene una funcionalidad de lectura específica. Lo que probablemente harías en ese caso es usar las clases de flujo (fstream.h) y usar los operadores de flujo (<< y >>) o la función de lectura para leer / escribir bloques de texto:

int nsize = 10;
char *somedata;
ifstream myfile;
myfile.open("<path to file>");
myfile.read(somedata,nsize);
myfile.close();

Tenga en cuenta que, si usa Visual Studio 2005 o superior, es posible que el flujo de datos tradicional no esté disponible (hay una nueva implementación de Microsoft, que es ligeramente diferente, pero logra lo mismo).

Answer 4

Necesitará usar ifstream si solo quiere leer (use un ofstream de escritura o un fstream de fstream para ambos).

Para abrir un archivo en modo texto, haga lo siguiente:

ifstream in("filename.ext", ios_base::in); // the in flag is optional

Para abrir un archivo en modo binario, solo necesita agregar el indicador "binario".

ifstream in2("filename2.ext", ios_base::in | ios_base::binary ); 

Utilice la función ifstream.read() para leer un bloque de caracteres (en modo binario o de texto). Use la función getline() (es global) para leer una línea completa.

Answer 5

fstream son geniales, pero profundizaré un poco y te contaré sobre RAII .

El problema con un ejemplo clásico es que se ve obligado a cerrar el archivo usted mismo, lo que significa que tendrá que doblar su arquitectura a esta necesidad. RAII hace uso de la llamada de destructor automático en C ++ para cerrar el archivo por usted.

Actualización : parece que std :: fstream ya implementa RAII, por lo que el siguiente código es inútil. Lo mantendré aquí para la posteridad y como un ejemplo de RAII.

class FileOpener
{
public:
    FileOpener(std::fstream& file, const char* fileName): m_file(file)
    { 
        m_file.open(fileName); 
    }
    ~FileOpeneer()
    { 
        file.close(); 
    }

private:
    std::fstream& m_file;
};

Ahora puede usar esta clase en su código de esta manera:

int nsize = 10;
char *somedata;
ifstream myfile;
FileOpener opener(myfile, "<path to file>");
myfile.read(somedata,nsize);
// myfile is closed automatically when opener destructor is called

Aprender cómo funciona RAII puede ahorrarle algunos dolores de cabeza y algunos errores importantes en la administración de la memoria.