Práce se soubory znamená čtení a zápis do souborů (jako .txt .csv atd.) pomocí tříd poskytovaných standardní knihovnou C++.

• Programy běží v RAM, což znamená, že data existují pouze během běhu programu, když program skončí, všechna data v RAM jsou automaticky ztracena.
• Manipulace se soubory umožňuje ukládat data do sekundární paměti (jako je HDD nebo SSD), takže je lze trvale uchovat a lze je ukládat a přistupovat k nim i po ukončení programu.
• Pro operace se soubory C++ poskytuje třídy proudů souborů v záhlaví, jako je ofstream ifstream fstream.

Otevření souboru

Před čtením nebo zápisem do souboru jej musíme nejprve otevřít. Otevřením souboru se tento soubor načte do paměti RAM. V C++ otevíráme soubor tak, že k němu vytvoříme proud pomocí fstream třídy, které představují datový proud souboru, tj. proud pro vstup a výstup do souboru.

   fstream     str  (  'filename.ext'       mode  );   

kde

• str: Název daný streamu
• název souboru: Název souboru
• režimu : Představuje způsob, jakým budeme pracovat se souborem.

Režimy otevírání souborů

Režim otevírání souboru označuje, že soubor je otevřen pro čtení, zápis nebo připojení. Níže je uveden seznam všech režimů souborů v C++:

Například pokud chceme soubor otevřít pro čtení, použijeme následující režim otevírání:

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

Podobně, pokud chceme otevřít soubor pro zápis, použijeme následující:

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

Tyto režimy lze také kombinovat pomocí operátoru OR (|). Můžete například otevřít proud souborů v režimu čtení i zápisu, jak je znázorněno:

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

Pokud soubor otevřený v režimu zápisu neexistuje, vytvoří se nový soubor. Pokud však soubor otevřený v režimu čtení neexistuje, nevytvoří se žádný nový soubor a je vyvolána výjimka

Jiné datové proudy souborů

fstream není jediným souborovým tokem poskytovaným C++. Existují ještě dva specializované streamy:

• ifstream : Znamená proud vstupního souboru. Je to ekvivalentní otevřenému fstream in ios::in režimu.
• ofstream : Znamená proud výstupního souboru. Je to ekvivalentní otevření fstream in ios::out režimu.

Výše uvedené režimy jsou výchozí režimy pro tyto streamy. Tyto režimy nelze změnit, ale lze je spojit s jinými režimy. Nyní pro vstup můžeme také použít ifstream, jak je znázorněno:

   ifstream     filein  (  'file.txt'  );   

Podobně pro výstup:

   ofstream     fileout  (  'file.txt'  );   

Zápis dat do souboru

Jakmile je soubor otevřen v režimu zápisu pomocí buď fstream nebo ofstream operaci zápisu můžeme provést obdobným způsobem jako pomocí 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  ;   }   

Číst data ze souboru

Jakmile je soubor otevřen v režimu čtení pomocí buď fstream nebo ifstream, můžeme provést operaci zápisu podobným způsobem jako u cin pomocí >> operátor.

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

Výstup

 Read String: Welcome  
 Má to stejný problém jako cin. Vstup je převzat pouze do prvního prázdného znaku. Abychom tomu zabránili, můžeme použít     getline()    funkce podle obrázku:  
 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  ;   }   
   
  
    Výstup    
 
 Read String: Welcome to GeeksforGeeks.  
 Zavření souboru  
 
 Zavření souboru znamená uzavření souvisejícího streamu a uvolnění zdrojů, které používáme. Je důležité zavřít soubor poté, co s ním skončíte, zejména v dlouho běžících programech, aby se zabránilo úniku dat z paměti atd.  
 
 V C++ jsou soubory uzavřeny pomocí     blízko()    členská funkce, která je přítomna ve všech proudech souborů.  
 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  ;   }   
   
  
    Výstup    
 
 Read String: Welcome to GeeksforGeeks.  
 Chyby při práci se soubory  
 
 Při manipulaci se soubory se může vyskytnout mnoho různých typů chyb, např. soubor nebyl nalezen plný disk atd. Naše programy by měly očekávat běžné chyby a měly by být schopny je správně zpracovat. Níže jsou uvedeny některé běžné chyby, které se mohou vyskytnout během zpracování souborů:  
 
 Selhání otevření souboru  
 
 Mohou nastat případy, kdy se soubor neotevře z různých důvodů, například neexistuje nebo program nemá oprávnění jej otevřít atd. V tomto případě můžeme použít     is_open()    členská funkce tříd proudů souborů pro kontrolu, zda je soubor otevřen úspěšně nebo ne.  
 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  ;   }   
   
  
    Výstup    
 
 Error: Unable to open file!  
 Selhání čtení/zápisu dat  
 
 Další častou chybou je selhání čtení nebo zápisu dat z důvodů, jako je nesprávný režim atd. V tomto případě můžeme operace validovat po každém pokusu o čtení/zápis. Například čtení pomocí getline() lze ověřit takto:  
 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  ;   }   
   
  
    Výstup    
 
 Error: Failed to read data  
 Chyba konce souboru (EOF).  
 
 Pokus o čtení za konec souboru může způsobit chybu EOF. To se může stát, když před čtením nezkontrolujete konec souboru. Můžeme zkontrolovat použití EOF     eof()    členská funkce.  
 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  ;   }   
   
  
    Výstup    
 
 Reached end of file.  
 Všimněte si, že jsme také ověřili operaci čtení před kontrolou EOF as     getline()    se jen vrátí     nullptr    i když se čtení z jakéhokoli důvodu nezdaří.  
 
 Práce s binárními soubory  
 
 V C++ si také poradíme     binární soubory    které ukládají data v nezpracovaném formátu. Chcete-li číst a zapisovat binární data, musíte použít     ios::binární    příznak při vytváření/otevření binárního souboru.  
 
 Zápis do binárního souboru  
 
 Abychom mohli zapsat data do binárního souboru, musíme soubor nejprve otevřít nebo vytvořit     ios::binární    režimu.  
 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  ;   }   
   
  
    Výstup    
  Binární soubor 
 Čtení z binárního souboru  
 
 Stejně jako otevíráme soubor v binárním režimu pro zápis dat pro čtení dat z binárního souboru, musíme soubor otevřít v režimu čtení pomocí     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  ;   }   
   
  
    Výstup    
 
 File Data: Welcome to GeeksForGeeks  
 Jiné operace se soubory  
 
 Můžeme také provádět více operací pro manipulaci se souborem z našeho programu C++. některé z běžných operací se soubory jsou:  
 
 
 
      C++ Program pro odstranění souboru      
 
      Připojte řetězec do existujícího souboru      
 
      Zkopírujte jeden soubor do jiného souboru      
 
 
         Vytvořit kvíz