MANEJO DE ARCHIVOS EN C++

El manejo de archivos significa leer y escribir en archivos (como .txt, .csv, etc.) utilizando clases proporcionadas por la biblioteca estándar de C++.

Los programas se ejecutan en RAM, lo que significa que los datos existen solo mientras el programa se está ejecutando, cuando un programa finaliza, todos los datos en la RAM se pierden automáticamente.
El manejo de archivos permite almacenar datos en la memoria secundaria (como HDD o SSD) para que se puedan conservar permanentemente y se puedan guardar y acceder a ellos incluso después de que finalice el programa.
Para operaciones con archivos, C++ proporciona clases de secuencias de archivos en el encabezado como ofstream ifstream fstream.

Abrir un archivo

Antes de leer o escribir en un archivo, primero debemos abrirlo. Al abrir un archivo, se carga ese archivo en la RAM. En C++ abrimos un archivo creando una secuencia usando el fstream clase que representa la secuencia del archivo, es decir, la secuencia de entrada y salida del archivo.

C++

    fstream     str  (  'filename.ext'       mode  );

dónde

cadena: Nombre dado a la corriente
Nombre del archivo: Nombre del archivo
modo : Representa la forma en la que vamos a interactuar con el archivo.

Modos de apertura de archivos

El modo de apertura de archivo indica que el archivo está abierto para leerlo, escribirlo o agregarlo. A continuación se muestra la lista de todos los modos de archivo en C++:

Modo	Descripción
ios::en	Archivo abierto para lectura. Si el archivo no existe, la operación de apertura falla.
ios::fuera	Archivo abierto para escritura: el búfer de flujo interno admite operaciones de salida.
ios::binario	Las operaciones se realizan en modo binario en lugar de texto.
ios::comió	La posición de salida comienza al final del archivo.
ios::aplicación	Todas las operaciones de salida ocurren al final del archivo adjunto a su contenido existente.
ios::troncal	Se descarta cualquier contenido que existiera en el archivo antes de abrirlo.

Por ejemplo si queremos abrir el archivo para leer utilizamos el siguiente modo de apertura:

C++

    fstream     filein  (  'file.txt'       ios  ::  in  );

De manera similar si queremos abrir el archivo para escribir usamos lo siguiente:

C++

    fstream     fileout  (  'file.txt'       ios  ::  out  );

Estos modos también se pueden combinar usando el operador OR (|). Por ejemplo, puede abrir la secuencia de archivos en modo lectura y escritura como se muestra:

C++

    fstream     str  (  'file.txt'       ios  ::  in     |     ios  ::  out  );

Si el archivo abierto en modo de escritura no existe, se crea un archivo nuevo. Pero si el archivo abierto en modo lectura no existe, entonces no se crea ningún archivo nuevo y se genera una excepción.

Otras secuencias de archivos

fstream no es el único flujo de archivos proporcionado por C++. Hay dos corrientes más especializadas:

si corriente : Significa flujo de archivos de entrada. Es equivalente a abrir fstream en ios::en modo.
ofstream : Significa flujo de archivos de salida. Es equivalente a abrir fstream en ios::fuera modo.

Los modos anteriores son modos predeterminados para estas transmisiones. Estos modos no se pueden cambiar, pero se pueden combinar con otros modos. Ahora, como entrada, también podemos usar ifstream como se muestra:

C++

    ifstream     filein  (  'file.txt'  );

De manera similar para la salida:

C++

    ofstream     fileout  (  'file.txt'  );

Escribir datos en un archivo

Una vez que el archivo se abre en el modo de escritura usando cualquiera de los dos fstream o ofstream podemos realizar la operación de escritura de manera similar a cout usando < < operator.

C++

    #include          using     namespace     std  ;   int     main  ()     {      // Open a file      ofstream     file  (  'GFG.txt'  );          // Write the string to the file      file      < <     'Welcome to GeeksforGeeks.'  ;      return     0  ;   }

GFG.texto

Leer datos del archivo

Una vez que el archivo se abre en modo lectura usando fstream o ifstream, podemos realizar la operación de escritura de manera similar a cin usando >> operador.

C++

    #include          using     namespace     std  ;   int     main  ()   {      // Open a file in read mode      ifstream     file  (  'GFG.txt'  );      string     s  ;      // Read string from the file      file     >>     s  ;      cout      < <     'Read String: '      < <     s  ;      return     0  ;   }

Producción

 Read String: Welcome   Esto tiene el mismo problema que cin. La entrada solo se realiza hasta el primer carácter de espacio en blanco. Para evitar esto podemos utilizar el     obtener línea()    funcionar como se muestra:  
 C++      #include          using     namespace     std  ;   int     main  ()   {      // Open a file in read mode      ifstream     file  (  'GFG.txt'  );      string     s  ;      // Read string from the file      getline  (  file       s  );      cout      < <     'Read String: '      < <     s  ;      return     0  ;   }   
     
    Producción    
  Read String: Welcome to GeeksforGeeks.   Cerrando el archivo  
  Cerrar el archivo significa cerrar el flujo asociado y liberar los recursos que estamos utilizando. Es importante cerrar el archivo una vez que haya terminado, especialmente en los programas de ejecución prolongada para evitar pérdidas de memoria, pérdida de datos, etc.  
  En C++ los archivos se cierran usando el     cerca()    función miembro que está presente en todas las secuencias de archivos.  
 C++      #include          using     namespace     std  ;   int     main  ()   {      // Open a file in read mode      ifstream     file  (  'GFG.txt'  );      string     s  ;      // Read string from the file      getline  (  file       s  );      cout      < <     'Read String: '      < <     s  ;      // Close the file      file  .  close  ();      return     0  ;   }   
     
    Producción    
  Read String: Welcome to GeeksforGeeks.   Errores en el manejo de archivos  
  Pueden ocurrir muchos tipos diferentes de errores en el manejo de archivos, como archivo no encontrado, disco lleno, etc. Nuestros programas deberían esperar errores comunes y deberían poder manejarlos adecuadamente. A continuación se detallan algunos errores comunes que pueden ocurrir durante el manejo de archivos:  
  Error al abrir archivo  
  Puede haber casos en los que el archivo no se abre por diversos motivos, como que no existe o que el programa no tiene permiso para abrirlo, etc. En este caso podemos usar el     está_abierto()    Función miembro de las clases de flujo de archivos para comprobar si el archivo se abre correctamente o no.  
 C++      #include          using     namespace     std  ;   int     main  ()     {      fstream     file  (  'nonexistent_file.txt'       ios  ::  in  );      // Check if the file is opened      if     (  !  file  .  is_open  ())     {      cerr      < <     'Error: Unable to open file!'      < <     endl  ;      return     1  ;      }      file  .  close  ();      return     0  ;   }   
     
    Producción    
  Error: Unable to open file!   No leer/escribir datos  
  Otro error común es no leer o escribir datos por motivos como modo incorrecto, etc. En este caso podemos validar las operaciones después de cada intento de lectura/escritura. Por ejemplo, la lectura usando getline() se puede validar como se muestra:  
 C++      #include          using     namespace     std  ;   int     main  ()     {      fstream     file  (  'GFG.txt'       ios  ::  out  );      if     (  !  file  .  is_open  ())     {      cerr      < <     'Error: Unable to open file!'      < <     endl  ;      return     1  ;      }      string     line  ;          // Checking if getline() read successfully or not      if     (  !  getline  (  file       line  ))      cerr      < <     'Error: Failed to read data'      < <     endl  ;      file  .  close  ();      return     0  ;   }   
     
    Producción    
  Error: Failed to read data   Error de fin de archivo (EOF)  
  Intentar leer más allá del final del archivo puede provocar un error EOF. Esto puede suceder cuando no verifica el final del archivo antes de leerlo. Podemos verificar EOF usando     eof()    función miembro.  
 C++      #include          using     namespace     std  ;   int     main  ()   {      ifstream     file  (  'GFG.txt'  );      if     (  !  file  .  is_open  ())      {      cerr      < <     'Error: Unable to open file!'      < <     endl  ;      return     1  ;      }      string     line  ;      while     (  getline  (  file       line  ))      cout      < <     line      < <     endl  ;      // Check for eof      if     (  file  .  eof  ())      cout      < <     'Reached end of file.'      < <     endl  ;      else      cerr      < <     'Error: File reading failed!'      < <     endl  ;      file  .  close  ();      return     0  ;   }   
     
    Producción    
  Reached end of file.   Observe que también hemos validado la operación de lectura antes de verificar EOF como     obtener línea()    sólo regresará     nulo    incluso si la lectura falla por algún motivo.  
  Manejo de archivos binarios  
  En C++ también podemos manejar     archivos binarios    que almacenan datos en formato sin procesar. Para leer y escribir datos binarios se debe utilizar el     ios::binario    bandera al crear/abrir un archivo binario.  
  Escribir en un archivo binario  
  Para escribir datos en un archivo binario, primero debemos abrir o crear el archivo en     ios::binario    modo.  
 C++      #include         #include         #include          using     namespace     std  ;   int     main  ()   {      string     str     =     'Welcome to GeeksForGeeks'  ;      // Open a binary file for writing      ofstream     file  (  'fileBin.bin'       ios  ::  binary  );      // Check if the file is open      if     (  !  file  )      {      cerr      < <     'Error opening the file for writing.'  ;      return     1  ;      }      // Write the length of the string (size) to file first      size_t     strLength     =     str  .  length  ();      file  .  write  (  reinterpret_cast   <  const     char     *>  (  &  strLength  )     sizeof  (  strLength  ));      // Write the string to the binary file      file  .  write  (  str  .  c_str  ()     strLength  );      // Close the file      file  .  close  ();      return     0  ;   }   
     
    Producción    
  Archivo binario  Lectura de un archivo binario  
  Así como abrimos un archivo en modo binario para escribir datos y leer datos de un archivo binario, debemos abrir el archivo en modo lectura usando     ios::en    .  
     Sintaxis:    
 C++      fstream     fileInstance  (  'fileName.bin'       ios  ::  in  |     ios  ::  binary  );   
  C++      #include         #include         #include          using     namespace     std  ;   int     main  ()   {      string     str  ;      // Open the binary file for reading      fstream     file  (  'fileBin.bin'       ios  ::  in     |     ios  ::  binary  );      // Check if the file is open      if     (  !  file  )      {      cerr      < <     'Error opening the file for reading.'  ;      return     1  ;      }      // Read the length of the string (size) from the file      size_t     strLength  ;      file  .  read  (  reinterpret_cast   <  char     *>  (  &  strLength  )     sizeof  (  strLength  ));      // Allocate memory for the string and read the data      char     *  buffer     =     new     char  [  strLength     +     1  ];     // +1 for the null-terminator      file  .  read  (  buffer       strLength  );      // Null-terminate the string      buffer  [  strLength  ]     =     ''  ;      // Convert the buffer to a string      str     =     buffer  ;      // Print file data      cout      < <     'File Data: '      < <     str  ;      delete  []     buffer  ;      file  .  close  ();      return     0  ;   }   
     
    Producción    
  File Data: Welcome to GeeksForGeeks   Otras operaciones de archivos  
  También podemos realizar más operaciones para manipular un archivo desde nuestro programa C++. Algunas de las operaciones de archivos comunes son:  
         Programa C++ para eliminar un archivo      
       Agregar una cadena en un archivo existente      
       Copiar un archivo en otro archivo      
 
 
         Crear cuestionario