Bei der Dateiverarbeitung handelt es sich um das Lesen und Schreiben von Dateien (wie .txt, .csv usw.) mithilfe von Klassen, die von der C++-Standardbibliothek bereitgestellt werden.

• Programme werden im RAM ausgeführt, was bedeutet, dass Daten nur während der Ausführung des Programms vorhanden sind. Wenn ein Programm endet, gehen alle Daten im RAM automatisch verloren.
• Durch die Dateiverwaltung können Daten im Sekundärspeicher (z. B. Festplatte oder SSD) gespeichert werden, sodass sie dauerhaft erhalten bleiben und auch nach Beendigung des Programms gespeichert und abgerufen werden können.
• Für Dateioperationen stellt C++ Dateistreamklassen im bereit Header wie ofstream ifstream fstream.

Eine Datei öffnen

Bevor wir aus einer Datei lesen oder in sie schreiben können, müssen wir sie zunächst öffnen. Beim Öffnen einer Datei wird diese Datei in den RAM geladen. In C++ öffnen wir eine Datei, indem wir mithilfe von einen Stream dazu erstellen fstream Klasse, die den Dateistream darstellt, d. h. Stream für die Eingabe und Ausgabe in die Datei.

   fstream     str  (  'filename.ext'       mode  );   

Wo

• str: Name des Streams
• Dateiname: Name der Datei
• Modus : Stellt die Art und Weise dar, wie wir mit der Datei interagieren werden.

Dateiöffnungsmodi

Der Dateiöffnungsmodus zeigt an, dass die Datei zum Lesen, Schreiben oder Anhängen geöffnet ist. Nachfolgend finden Sie die Liste aller Dateimodi in C++:

Zum Beispiel Wenn wir die Datei zum Lesen öffnen möchten, verwenden wir den folgenden Öffnungsmodus:

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

Ebenso verwenden wir Folgendes, wenn wir die Datei zum Schreiben öffnen möchten:

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

Diese Modi können auch mit dem ODER-Operator (|) kombiniert werden. Sie können den Dateistream beispielsweise wie gezeigt sowohl im Lese- als auch im Schreibmodus öffnen:

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

Wenn die im Schreibmodus geöffnete Datei nicht existiert, wird eine neue Datei erstellt. Wenn die im Lesemodus geöffnete Datei jedoch nicht existiert, wird keine neue Datei erstellt und eine Ausnahme ausgelöst

Andere Dateistreams

fstream ist nicht der einzige von C++ bereitgestellte Dateistream. Es gibt zwei weitere spezialisierte Streams:

• ifstream : Steht für Eingabedatei-Stream. Es entspricht dem Öffnen von fstream in ios::in Modus.
• ofstream : Steht für Ausgabedateistream. Dies entspricht dem Öffnen von fstream in ios::out Modus.

Die oben genannten Modi sind Standardmodi für diese Streams. Diese Modi können nicht geändert werden, können aber mit anderen Modi kombiniert werden. Jetzt können wir zur Eingabe auch ifstream verwenden, wie gezeigt:

   ifstream     filein  (  'file.txt'  );   

Ebenso für die Ausgabe:

   ofstream     fileout  (  'file.txt'  );   

Daten in Datei schreiben

Sobald die Datei im Schreibmodus geöffnet wird, verwenden Sie entweder fstream oder ofstream Wir können den Schreibvorgang auf ähnliche Weise wie bei cout using durchführen < < 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  ;   }   

Daten aus Datei lesen

Sobald die Datei im Lesemodus mit fstream oder ifstream geöffnet ist, können wir den Schreibvorgang auf ähnliche Weise wie mit cin using durchführen >> Betreiber.

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

Ausgabe

 Read String: Welcome  
 Dies hat das gleiche Problem wie Cin. Die Eingabe erfolgt nur bis zum ersten Leerzeichen. Um dies zu vermeiden, können wir die verwenden     getline()    Funktion wie abgebildet:  
 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  ;   }   
   
  
    Ausgabe    
 
 Read String: Welcome to GeeksforGeeks.  
 Schließen der Datei  
 
 Das Schließen der Datei bedeutet, den zugehörigen Stream zu schließen und die von uns verwendeten Ressourcen freizugeben. Es ist wichtig, die Datei zu schließen, nachdem Sie mit ihr fertig sind, insbesondere bei Programmen mit langer Laufzeit, um Speicherverluste, Datenverlust usw. zu vermeiden.  
 
 In C++ werden die Dateien mit geschlossen     schließen()    Memberfunktion, die in allen Dateistreams vorhanden ist.  
 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  ;   }   
   
  
    Ausgabe    
 
 Read String: Welcome to GeeksforGeeks.  
 Fehler bei der Dateiverwaltung  
 
 Bei der Dateiverwaltung können viele verschiedene Arten von Fehlern auftreten, z. B. Datei wurde nicht gefunden, der Datenträger ist voll usw. Unsere Programme sollten mit häufigen Fehlern rechnen und in der Lage sein, diese ordnungsgemäß zu verarbeiten. Im Folgenden sind einige häufige Fehler aufgeführt, die bei der Dateiverarbeitung auftreten können:  
 
 Fehler beim Öffnen der Datei  
 
 Es kann Fälle geben, in denen die Datei aus verschiedenen Gründen nicht geöffnet wird, z. B. weil sie nicht existiert oder das Programm keine Berechtigung zum Öffnen hat usw. In diesem Fall können wir die verwenden     is_open()    Mitgliedsfunktion der Datei-Stream-Klassen, um zu überprüfen, ob die Datei erfolgreich geöffnet wurde oder nicht.  
 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  ;   }   
   
  
    Ausgabe    
 
 Error: Unable to open file!  
 Fehler beim Lesen/Schreiben von Daten  
 
 Ein weiterer häufiger Fehler besteht darin, dass Daten aufgrund eines falschen Modus usw. nicht gelesen oder geschrieben werden können. In diesem Fall können wir Vorgänge nach jedem Lese-/Schreibversuch validieren. Beispielsweise kann das Lesen mit getline() wie folgt validiert werden:  
 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  ;   }   
   
  
    Ausgabe    
 
 Error: Failed to read data  
 End-of-File-Fehler (EOF).  
 
 Der Versuch, über das Ende der Datei hinaus zu lesen, kann einen EOF-Fehler verursachen. Dies kann passieren, wenn Sie vor dem Lesen nicht das Ende der Datei prüfen. Wir können mithilfe von EOF prüfen     eof()    Mitgliedsfunktion.  
 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  ;   }   
   
  
    Ausgabe    
 
 Reached end of file.  
 Beachten Sie, dass wir auch den Lesevorgang validiert haben, bevor wir EOF als überprüft haben     getline()    werde nur wiederkommen     nullptr    auch wenn der Lesevorgang aus irgendeinem Grund fehlschlägt.  
 
 Umgang mit Binärdateien  
 
 In C++ können wir auch damit umgehen     Binärdateien    die Daten im Rohformat speichern. Zum Lesen und Schreiben von Binärdaten muss das verwendet werden     ios::binary    Flag beim Erstellen/Öffnen einer Binärdatei.  
 
 In Binärdatei schreiben  
 
 Um Daten in eine Binärdatei zu schreiben, müssen wir die Datei zunächst öffnen oder erstellen     ios::binary    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  ;   }   
   
  
    Ausgabe    
  Binärdatei 
 Aus Binärdatei lesen  
 
 So wie wir eine Datei im Binärmodus öffnen, um Daten zu schreiben und Daten aus einer Binärdatei zu lesen, müssen wir die Datei im Lesemodus mit öffnen     ios::in    .  
 
    Syntax:    
 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  ;   }   
   
  
    Ausgabe    
 
 File Data: Welcome to GeeksForGeeks  
 Andere Dateioperationen  
 
 Wir können auch weitere Operationen ausführen, um eine Datei von unserem C++-Programm aus zu bearbeiten. Einige der häufigsten Dateioperationen sind:  
 
 
 
      C++-Programm zum Löschen einer Datei      
 
      Hängen Sie eine Zeichenfolge an eine vorhandene Datei an      
 
      Kopieren Sie eine Datei in eine andere Datei      
 
 
         Quiz erstellen