Gestionarea fișierelor înseamnă citirea și scrierea în fișiere (cum ar fi .txt .csv etc.) folosind clasele furnizate de biblioteca standard C++.

• Programele rulează în RAM, ceea ce înseamnă că datele există numai în timp ce programul rulează, când un program se termină, toate datele din RAM se pierd automat.
• Gestionarea fișierelor permite stocarea datelor în memoria secundară (cum ar fi HDD sau SSD), astfel încât acestea să poată fi păstrate permanent și să poată fi salvate și accesate chiar și după terminarea programului.
• Pentru operațiuni cu fișiere, C++ oferă clase de flux de fișiere în antet, cum ar fi ofstream ifstream fstream.

Deschiderea unui fișier

Înainte de a citi sau de a scrie într-un fișier, trebuie mai întâi să îl deschidem. Deschiderea unui fișier încarcă acel fișier în RAM. În C++ deschidem un fișier prin crearea unui flux către acesta folosind fstream clasă care reprezintă fluxul de fișiere, adică fluxul pentru intrare și ieșire în fișier.

   fstream     str  (  'filename.ext'       mode  );   

unde

• str: Numele dat fluxului
• nume de fișier: Numele fișierului
• modul : Reprezintă modul în care vom interacționa cu fișierul.

Moduri de deschidere a fișierelor

Modul de deschidere a fișierului indică faptul că fișierul este deschis pentru citire, scriere sau adăugare. Mai jos este lista tuturor modurilor de fișiere în C++:

De exemplu dacă dorim să deschidem fișierul pentru citire, folosim următorul mod de deschidere:

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

În mod similar, dacă vrem să deschidem fișierul pentru scriere, folosim următoarele:

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

Aceste moduri pot fi, de asemenea, combinate folosind operatorul SAU (|). De exemplu, puteți deschide fluxul de fișiere atât în ​​modul de citire, cât și în modul de scriere, după cum se arată:

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

Dacă fișierul deschis în modul de scriere nu există, se creează un fișier nou. Dar dacă fișierul deschis în modul de citire nu există, atunci nu este creat niciun fișier nou și se aruncă o excepție

Alte fluxuri de fișiere

fstream nu este singurul flux de fișiere furnizat de C++. Mai există două fluxuri specializate:

• ifstream : reprezintă fluxul de fișiere de intrare. Este echivalent cu deschiderea fstream în ios::in modul.
• ofstream : reprezintă fluxul de fișiere de ieșire. Este echivalent cu deschiderea fstream în ios::out modul.

Modurile de mai sus sunt moduri implicite pentru aceste fluxuri. Aceste moduri nu pot fi schimbate, dar pot fi asociate cu alte moduri. Acum, pentru intrare, putem folosi și ifstream așa cum se arată:

   ifstream     filein  (  'file.txt'  );   

La fel pentru ieșire:

   ofstream     fileout  (  'file.txt'  );   

Scrieți datele în fișier

Odată ce fișierul este deschis în modul de scriere folosind oricare fstream sau ofstream putem efectua operația de scriere în mod similar cu utilizarea 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  ;   }   

Citiți date din fișier

Odată ce fișierul este deschis în modul citire folosind fie fstream, fie ifstream, putem efectua operația de scriere în mod similar cu cin folosind >> operator.

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

Ieșire

 Read String: Welcome  
 Aceasta are aceeași problemă ca și cin. Introducerea este luată numai până la primul caracter de spațiu alb. Pentru a evita acest lucru putem folosi     getline()    functioneaza asa cum se arata:  
 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  ;   }   
   
  
    Ieșire    
 
 Read String: Welcome to GeeksforGeeks.  
 Închiderea Fișierului  
 
 Închiderea fișierului înseamnă închiderea fluxului asociat și eliberarea resurselor pe care le folosim. Este important să închideți fișierul după ce ați terminat cu el, mai ales în programele care rulează lung pentru a evita pierderile de memorie, pierderea datelor etc.  
 
 În C++ fișierele sunt închise folosind     aproape()    funcția membru care este prezentă în toate fluxurile de fișiere.  
 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  ;   }   
   
  
    Ieșire    
 
 Read String: Welcome to GeeksforGeeks.  
 Erori în manipularea fișierelor  
 
 Pot apărea multe tipuri diferite de erori în gestionarea fișierelor, cum ar fi fișierul nu a fost găsit pe disc plin etc. Programele noastre ar trebui să se aștepte la erori comune și ar trebui să le poată gestiona corect. Următoarele sunt câteva erori comune care pot apărea în timpul manipulării fișierelor:  
 
 Eșec la deschiderea fișierului  
 
 Pot exista cazuri în care fișierul nu este deschis din diverse motive, cum ar fi nu există sau programul nu are permisiunea de a-l deschide etc. În acest caz, putem folosi     este_deschis()    funcția membru al claselor de flux de fișiere pentru a verifica dacă fișierul este deschis cu succes sau nu.  
 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  ;   }   
   
  
    Ieșire    
 
 Error: Unable to open file!  
 Eșecul citirii/scrierii datelor  
 
 O altă eroare comună este eșecul citirii sau scrierii datelor din motive precum modul incorect etc. În acest caz, putem valida operațiile după fiecare încercare de citire/scriere. De exemplu, citirea folosind getline() poate fi validată după cum arată:  
 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  ;   }   
   
  
    Ieșire    
 
 Error: Failed to read data  
 Eroare la sfârșitul fișierului (EOF).  
 
 Încercarea de a citi dincolo de sfârșitul fișierului poate provoca o eroare EOF. Acest lucru se poate întâmpla atunci când nu verificați sfârșitul fișierului înainte de a citi. Putem verifica EOF folosind     eof()    funcția de membru.  
 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  ;   }   
   
  
    Ieșire    
 
 Reached end of file.  
 Observați că am validat și operația de citire înainte de a verifica EOF ca     getline()    se va întoarce doar     nullptr    chiar dacă citirea eșuează din orice motiv.  
 
 Gestionarea fișierelor binare  
 
 În C++ ne putem descurca și     fișiere binare    care stochează date în format brut. Pentru a citi și scrie date binare trebuie să utilizați     ios::binar    flag la crearea/deschiderea unui fișier binar.  
 
 Scrieți în fișierul binar  
 
 Pentru a scrie date într-un fișier binar, trebuie mai întâi să deschidem sau să creăm fișierul în     ios::binar    modul.  
 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  ;   }   
   
  
    Ieșire    
  Fișier binar 
 Citirea din fișierul binar  
 
 Așa cum deschidem un fișier în modul binar pentru a scrie date pentru a citi date dintr-un fișier binar, trebuie să deschidem fișierul în modul de citire folosind     ios::in    .  
 
    Sintaxă:    
 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  ;   }   
   
  
    Ieșire    
 
 File Data: Welcome to GeeksForGeeks  
 Alte operațiuni cu fișiere  
 
 De asemenea, putem face mai multe operațiuni pentru a manipula un fișier din programul nostru C++. unele dintre operațiunile comune cu fișierele sunt:  
 
 
 
      Program C++ pentru a șterge un fișier      
 
      Adăugați un șir într-un fișier existent      
 
      Copiați un fișier într-un alt fișier      
 
 
         Creați un test