El maneig de fitxers significa llegir i escriure fitxers (com ara .txt .csv, etc.) utilitzant classes proporcionades per la biblioteca estàndard de C++.

• Els programes s'executen a la memòria RAM, el que significa que les dades només existeixen mentre el programa s'executa quan un programa acaba, totes les dades de la memòria RAM es perden automàticament.
• El maneig de fitxers permet emmagatzemar dades a la memòria secundària (com ara HDD o SSD) perquè es puguin conservar permanentment i es pot desar i accedir fins i tot després que el programa finalitzi.
• Per a les operacions de fitxers, C++ proporciona classes de flux de fitxers al fitxer capçalera com ofstream ifstream fstream.

Obrint un fitxer

Abans de llegir o escriure en un fitxer primer hem d'obrir-lo. En obrir un fitxer es carrega aquest fitxer a la memòria RAM. En C++ obrim un fitxer creant-hi un flux mitjançant l' fstream classe que representen el flux del fitxer, és a dir, el flux d'entrada i sortida al fitxer.

   fstream     str  (  'filename.ext'       mode  );   

on

• str: Nom donat al corrent
• nom de fitxer: Nom del fitxer
• mode : Representa la manera com anem a interactuar amb el fitxer.

Modes d'obertura de fitxers

El mode d'obertura del fitxer indica que el fitxer està obert per llegir-lo, escriure o afegir-lo. A continuació es mostra la llista de tots els modes de fitxer en C++:

Per exemple si volem obrir el fitxer per llegir-lo fem servir el següent mode d'obertura:

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

De la mateixa manera, si volem obrir el fitxer per escriure, utilitzem el següent:

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

These modes can also be combined using OR operator (|). Per exemple, podeu obrir el flux de fitxers tant en mode de lectura com d'escriptura tal com es mostra:

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

Si el fitxer obert en mode d'escriptura no existeix, es crea un fitxer nou. Però si el fitxer obert en mode de lectura no existeix, no es crea cap fitxer nou i es llança una excepció

Altres fluxos de fitxers

fstream no és l'únic flux de fitxers proporcionat per C++. Hi ha dos corrents especialitzats més:

• ifstream : Significa el flux de fitxers d'entrada. És equivalent a obrir fstream in ios::in mode.
• de corrent : representa el flux de fitxers de sortida. És equivalent a obrir fstream in ios::fora mode.

Els modes anteriors són modes predeterminats per a aquests fluxos. Aquests modes no es poden canviar, però es poden combinar amb altres modes. Ara per a l'entrada també podem utilitzar ifstream com es mostra:

   ifstream     filein  (  'file.txt'  );   

De la mateixa manera per a la sortida:

   ofstream     fileout  (  'file.txt'  );   

Escriure dades al fitxer

Un cop obert el fitxer en mode d'escriptura, utilitzeu qualsevol fstream o de corrent podem realitzar l'operació d'escriptura de la mateixa manera que amb cout < < operator.

   #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  ;   }   

Llegir dades del fitxer

Un cop obert el fitxer en mode de lectura mitjançant fstream o ifstream, podem realitzar l'operació d'escriptura de la mateixa manera que amb cin utilitzant >> operador.

   #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  ;   }   

Sortida

 Read String: Welcome  
 Això té el mateix problema que cin. L'entrada només es pren fins al primer caràcter d'espai en blanc. Per evitar-ho podem utilitzar el     getline()    funcionen com es mostra:  
 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  ;   }   
   
  
    Sortida    
 
 Read String: Welcome to GeeksforGeeks.  
 Tancant l'Arxiu  
 
 Tancar el fitxer significa tancar el flux associat i alliberar els recursos que estem utilitzant. És important tancar el fitxer després d'haver-hi acabat, especialment en els programes de llarga durada per evitar pèrdues de dades, etc.  
 
 En C++ els fitxers es tanquen utilitzant el     tancar ()    funció membre que està present en tots els fluxos de fitxers.  
 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  ;   }   
   
  
    Sortida    
 
 Read String: Welcome to GeeksforGeeks.  
 Errors en la gestió de fitxers  
 
 Es poden produir molts tipus diferents d'errors en la gestió de fitxers, com ara el fitxer no s'ha trobat el disc ple, etc. Els nostres programes haurien d'esperar errors comuns i haurien de poder gestionar-los correctament. A continuació es mostren alguns errors habituals que es poden produir durant la gestió de fitxers:  
 
 Error d'obertura del fitxer  
 
 Hi pot haver casos en què el fitxer no s'obre per diversos motius, com ara no existeix o el programa no té permís per obrir-lo, etc. En aquest cas podem utilitzar el     is_open()    funció membre de les classes de flux de fitxers per comprovar si el fitxer s'obre amb èxit 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  ;   }   
   
  
    Sortida    
 
 Error: Unable to open file!  
 No es poden llegir/escriure les dades  
 
 Un altre error comú és la falta de lectura o escriptura de dades per motius com el mode incorrecte, etc. En aquest cas podem validar les operacions després de cada intent de lectura/escriptura. Per exemple, la lectura amb getline() es pot validar com es mostra:  
 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  ;   }   
   
  
    Sortida    
 
 Error: Failed to read data  
 Error al final del fitxer (EOF).  
 
 Intentar llegir més enllà del final del fitxer pot provocar un error EOF. Això pot passar quan no comproveu el final del fitxer abans de llegir-lo. Podem comprovar si hi ha EOF utilitzant     eof()    funció de membre.  
 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  ;   }   
   
  
    Sortida    
 
 Reached end of file.  
 Tingueu en compte que també hem validat l'operació de lectura abans de comprovar EOF com     getline()    només tornarà     nullptr    fins i tot si la lectura falla per qualsevol motiu.  
 
 Maneig de fitxers binaris  
 
 En C++ també podem manejar     fitxers binaris    que emmagatzemen dades en format brut. Per llegir i escriure dades binàries cal utilitzar el     ios::binary    marca quan es crea/obre un fitxer binari.  
 
 Escriu al fitxer binari  
 
 Per escriure dades en un fitxer binari primer hem d'obrir o crear el fitxer     ios::binary    mode.  
 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  ;   }   
   
  
    Sortida    
  Fitxer binari 
 Lectura d'un fitxer binari  
 
 De la mateixa manera que obrim un fitxer en mode binari per escriure dades per llegir dades d'un fitxer binari, hem d'obrir el fitxer en mode de lectura utilitzant     ios::in    .  
 
    Sintaxi:    
 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  ;   }   
   
  
    Sortida    
 
 File Data: Welcome to GeeksForGeeks  
 Altres operacions de fitxers  
 
 També podem fer més operacions per manipular un fitxer des del nostre programa C++. algunes de les operacions habituals de fitxers són:  
 
 
 
      Programa C++ per eliminar un fitxer      
 
      Afegiu una cadena a un fitxer existent      
 
      Copieu un fitxer en un altre fitxer      
 
 
         Crea un qüestionari