Bestandsverwerking betekent het lezen van en schrijven naar bestanden (zoals .txt .csv enz.) met behulp van klassen die worden aangeboden door de standaard C++-bibliotheek.

• Programma's draaien in RAM, wat betekent dat gegevens alleen bestaan ​​​​terwijl het programma actief is. Wanneer een programma eindigt, gaan alle gegevens in RAM automatisch verloren.
• Bestandsverwerking maakt het mogelijk gegevens op te slaan in het secundaire geheugen (zoals HDD of SSD), zodat deze permanent kunnen worden bewaard en zelfs kunnen worden opgeslagen en geopend nadat het programma is beëindigd.
• Voor bestandsbewerkingen biedt C++ bestandsstroomklassen in de header zoals ofstream ifstream fstream.

Een bestand openen

Voordat we van een bestand kunnen lezen of ernaar kunnen schrijven, moeten we het eerst openen. Als u een bestand opent, wordt dat bestand in het RAM geladen. In C++ openen we een bestand door er een stream van te maken met behulp van de fstroom klasse die de bestandsstroom vertegenwoordigt, d.w.z. stroom voor invoer en uitvoer naar het bestand.

   fstream     str  (  'filename.ext'       mode  );   

waar

• str: Naam gegeven aan de stroom
• bestandsnaam: Naam van het bestand
• modus : vertegenwoordigt de manier waarop we met het bestand gaan omgaan.

Bestandsopeningsmodi

Bestandsopeningsmodus geeft aan dat het bestand is geopend om te lezen, te schrijven of toe te voegen. Hieronder vindt u de lijst met alle bestandsmodi in C++:

Bijvoorbeeld als we het bestand willen openen om te lezen, gebruiken we de volgende openingsmodus:

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

Op dezelfde manier gebruiken we het volgende als we het bestand willen openen om te schrijven:

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

Deze modi kunnen ook worden gecombineerd met de OR-operator (|). U kunt de bestandsstream bijvoorbeeld zowel in de lees- als in de schrijfmodus openen, zoals weergegeven:

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

Als het bestand dat in de schrijfmodus is geopend niet bestaat, wordt er een nieuw bestand gemaakt. Maar als het bestand dat in de leesmodus is geopend niet bestaat, wordt er geen nieuw bestand gemaakt en wordt er een uitzondering gegenereerd

Andere bestandsstromen

fstroom is niet de enige bestandsstroom die door C++ wordt aangeboden. Er zijn nog twee gespecialiseerde stromen:

• alsstroom : Staat voor invoerbestandsstream. Het is gelijk aan het openen van fstream in ios::in modus.
• vanstroom : Staat voor uitvoerbestandsstream. Het is gelijk aan het openen van fstream in ios::uit modus.

De bovenstaande modi zijn standaardmodi voor deze streams. Deze modi kunnen niet worden gewijzigd, maar kunnen samen met andere modi worden samengevoegd. Voor invoer kunnen we nu ook ifstream gebruiken zoals weergegeven:

   ifstream     filein  (  'file.txt'  );   

Hetzelfde geldt voor uitvoer:

   ofstream     fileout  (  'file.txt'  );   

Gegevens naar bestand schrijven

Zodra het bestand is geopend in de schrijfmodus met behulp van een van beide fstroom of vanstroom we kunnen de schrijfbewerking op dezelfde manier uitvoeren als bij gebruik van 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  ;   }   

Gegevens uit bestand lezen

Zodra het bestand in de leesmodus is geopend met behulp van fstream of ifstream, kunnen we de schrijfbewerking op dezelfde manier uitvoeren als met cin met behulp van >> exploitant.

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

Uitvoer

 Read String: Welcome  
 Dit heeft hetzelfde probleem als cin. De invoer wordt alleen gebruikt tot het eerste witruimteteken. Om dit te voorkomen kunnen we gebruik maken van de     getline()    Functie zoals afgebeeld:  
 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  ;   }   
   
  
    Uitvoer    
 
 Read String: Welcome to GeeksforGeeks.  
 Het bestand sluiten  
 
 Het sluiten van het bestand betekent het sluiten van de bijbehorende stream en het vrijmaken van de bronnen die we gebruiken. Het is belangrijk om het bestand te sluiten nadat u er klaar mee bent, vooral bij langlopende programma's om geheugenlekken, gegevensverlies enz. te voorkomen.  
 
 In C++ worden de bestanden gesloten met behulp van de     dichtbij()    member-functie die aanwezig is in alle bestandsstreams.  
 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  ;   }   
   
  
    Uitvoer    
 
 Read String: Welcome to GeeksforGeeks.  
 Fouten bij het verwerken van bestanden  
 
 Er kunnen veel verschillende soorten fouten optreden bij het verwerken van bestanden, zoals het bestand is niet gevonden, schijf vol enz. Onze programma's moeten veelvoorkomende fouten verwachten en moeten deze op de juiste manier kunnen afhandelen. Hieronder volgen enkele veelvoorkomende fouten die kunnen optreden tijdens het verwerken van bestanden:  
 
 Bestand openen mislukt  
 
 Er kunnen gevallen zijn waarin het bestand om verschillende redenen niet wordt geopend, bijvoorbeeld omdat het niet bestaat of het programma geen toestemming heeft om het te openen, enz. In dit geval kunnen we de     is_open()    member-functie van de bestandsstroomklassen om te controleren of het bestand succesvol is geopend of niet.  
 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  ;   }   
   
  
    Uitvoer    
 
 Error: Unable to open file!  
 Kan gegevens niet lezen/schrijven  
 
 Een andere veel voorkomende fout is het niet kunnen lezen of schrijven van gegevens vanwege bijvoorbeeld een onjuiste modus enz. In dit geval kunnen we bewerkingen valideren na elke lees-/schrijfpoging. Lezen met getline() kan bijvoorbeeld als volgt worden gevalideerd:  
 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  ;   }   
   
  
    Uitvoer    
 
 Error: Failed to read data  
 End-of-File (EOF)-fout  
 
 Als u verder dan het einde van het bestand probeert te lezen, kan dit een EOF-fout veroorzaken. Dit kan gebeuren als u niet controleert op het einde van het bestand voordat u het leest. We kunnen controleren op EOF met behulp van     eof()    lid functie.  
 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  ;   }   
   
  
    Uitvoer    
 
 Reached end of file.  
 Merk op dat we ook de leesbewerking hebben gevalideerd voordat we EOF as controleren     getline()    zal alleen terugkeren     nulptr    zelfs als het lezen om welke reden dan ook mislukt.  
 
 Binaire bestanden verwerken  
 
 In C++ kunnen we het ook aan     binaire bestanden    die gegevens in onbewerkt formaat opslaan. Om binaire gegevens te lezen en te schrijven moet u de     ios::binair    vlag bij het maken/openen van een binair bestand.  
 
 Schrijf naar binair bestand  
 
 Om gegevens naar een binair bestand te schrijven, moeten we eerst het bestand openen of aanmaken     ios::binair    modus.  
 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  ;   }   
   
  
    Uitvoer    
  Binair bestand 
 Lezen uit binair bestand  
 
 Net zoals we een bestand in binaire modus openen om gegevens te schrijven om gegevens uit een binair bestand te lezen, moeten we het bestand in leesmodus openen met     ios::in    .  
 
    Syntaxis:    
 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  ;   }   
   
  
    Uitvoer    
 
 File Data: Welcome to GeeksForGeeks  
 Andere bestandsbewerkingen  
 
 We kunnen ook meer bewerkingen uitvoeren om een ​​bestand vanuit ons C++-programma te manipuleren. enkele veel voorkomende bestandsbewerkingen zijn:  
 
 
 
      C++ Programma om een ​​bestand te verwijderen      
 
      Voeg een tekenreeks toe aan een bestaand bestand      
 
      Kopieer het ene bestand naar een ander bestand      
 
 
         Quiz maken