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

Question

Quiero abrir un archivo para leerlo, al estilo C++.Necesito poder hacerlo para:

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

• archivos binarios, que proporcionarían una forma de leer datos sin procesar en un char* buffer.

Answer 1

Hay tres formas de hacer esto, según sus necesidades.Podrías usar el modo C de la vieja escuela y llamar a fopen/fread/fclose, o podrías usar las funciones fstream de C++ (ifstream/ofstream), o si estás usando MFC, usar la clase CFile, que proporciona funciones para lograr resultados reales. operaciones de archivos.

Todos ellos son adecuados tanto para texto como para binario, aunque ninguno tiene una funcionalidad de lectura de línea específica.Lo que probablemente harías en ese caso es usar las clases fstream (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 está utilizando Visual Studio 2005 o superior, es posible que el fstream tradicional no esté disponible (hay una nueva implementación de Microsoft, que es ligeramente diferente, pero logra lo mismo).

Answer 2

Necesitas usar un ifstream si solo quieres leer (usa un ofstream escribir, o un 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, sólo necesita agregar la bandera "binario".

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

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

Answer 3

Para abrir y leer un archivo de texto línea 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, debe 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 utilizando la función miembro del flujo. 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ás #include el encabezado: <iostream>

Answer 4

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

int main () {
  ofstream file;
  file.open ("codebind.txt");
  file << "Please writr this text to a file.\n this text is written using C++\n";
  file.close();
  return 0;
}

Answer 5

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

Sigue los pasos,

1. Incluya archivos de encabezado o espacio de nombres para acceder a la clase de archivo.
2. Haga un objeto de clase de archivo dependiendo de su plataforma IDE (es decir, CFILE, QFile, fstream).
3. Ahora puede encontrar fácilmente los métodos de esa clase para abrir/leer/cerrar/obtener línea o cualquier archivo.

CFile/QFile/ifstream m_file;
m_file.Open(path,Other parameter/mood to open file);

Para leer el archivo, debe crear un búfer o una cadena para guardar los datos y puede pasar esa variable en el método read().

Answer 7

**#include<fstream> //to use file
#include<string>  //to use getline
using namespace std;
int main(){
ifstream file;
string str;
file.open("path the file" , ios::binary | ios::in);
while(true){
   getline(file , str);
   if(file.fail())
       break;
   cout<<str;
}
}**

Answer 8

#include <fstream>

ifstream infile;
infile.open(**file path**);
while(!infile.eof())
{
   getline(infile,data);
}
infile.close();

Answer 9

fstream son geniales, pero profundizaré un poco más y les contaré sobre RAII.

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

Actualizar:Parece que std::fstream ya implementa RAII, por lo que el siguiente código es inútil.Lo guardaré aquí para la posteridad y como 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 puedes usar esta clase en tu 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 gestión de la memoria.