¿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 sin procesar en un buffer char*.

Answer 1

Existen 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 flujo continuo C++ (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 más probable es que haría en su lugar en ese caso es utilizar las clases fstream (fstream.h) y el uso de los operadores de flujo (< < y >>) o la función de lectura para leer bloques de lectura/escritura 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 una versión superior, es posible que el flujo de archivos tradicional no esté disponible (hay una nueva implementación de Microsoft, que es ligeramente diferente, pero logra lo mismo).

Answer 2

Debe usar un ifstream si solo desea leer (use un ofstream para escribir, o un fstream para ambos).

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

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

Para abrir un archivo en modo binario, sólo tiene que añadir la bandera "binario".

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

utilizar 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 3

fstream son geniales pero profundizaré un poco más y les contaré acerca de 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 utilizar esta clase en su código como este:

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 le puede ahorrar algunos dolores de cabeza y algunos de los principales errores de gestión de memoria.

Answer 4

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

Para abrir y leer un archivo línea de texto por línea, puede utilizar el 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 que tienen que declarar explícitamente el formato de lectura en su flujo de entrada a ser binarios, y leer la memoria que no tiene una interpretación explícita utilizando la función de miembro de la corriente 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 tendrá que #include el encabezado: <iostream>