Filhåndtering betyr å lese fra og skrive til filer (som .txt .csv osv.) ved å bruke klasser levert av C++ standardbiblioteket.

• Programmer som kjøres i RAM betyr at data bare eksisterer mens programmet kjører når et program avslutter alle data i RAM går tapt automatisk.
• Filhåndtering gjør det mulig å lagre data i sekundært minne (som HDD eller SSD), slik at de kan bevares permanent og kan lagres og åpnes selv etter at programmet avsluttes.
• For filoperasjoner gir C++ filstrømklasser i header som ofstream ifstream fstream.

Åpne en fil

Før vi leser fra eller skriver til en fil, må vi først åpne den. Åpning av en fil laster den filen i RAM. I C++ åpner vi en fil ved å lage en strøm til den ved å bruke fstream klasse som representerer filstrømmen, dvs. strøm for inndata og utdata til filen.

   fstream     str  (  'filename.ext'       mode  );   

hvor

• str: Navn gitt til strømmen
• filnavn: Navnet på filen
• modus : Representerer måten vi skal samhandle med filen på.

Filåpningsmoduser

Filåpningsmodus indikerer at filen er åpnet for lesing eller vedlegg. Nedenfor er listen over alle filmoduser i C++:

For eksempel hvis vi vil åpne filen for lesing, bruker vi følgende åpningsmodus:

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

På samme måte hvis vi ønsker å åpne filen for skriving, bruker vi følgende:

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

Disse modusene kan også kombineres med OR-operatoren (|). For eksempel kan du åpne filstrømmen i både lese- og skrivemodus som vist:

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

Hvis filen åpnet i skrivemodus ikke eksisterer, opprettes en ny fil. Men hvis filen åpnet i lesemodus ikke eksisterer, opprettes ingen ny fil og et unntak blir kastet

Andre filstrømmer

fstream er ikke den eneste filstrømmen levert av C++. Det er to mer spesialiserte strømmer:

• ifstream : Står for inndatafilstrøm. Det tilsvarer å åpne fstream i ios::in modus.
• av strømmen : Står for utdatafilstrøm. Det tilsvarer å åpne fstream inn ios::ut modus.

Modiene ovenfor er standardmoduser for disse strømmene. Disse modusene kan ikke endres, men kan klubbes sammen med andre moduser. Nå for input kan vi også bruke ifstream som vist:

   ifstream     filein  (  'file.txt'  );   

Tilsvarende for utgang:

   ofstream     fileout  (  'file.txt'  );   

Skriv data til fil

Når filen er åpnet i skrivemodus med enten fstream eller av strømmen vi kan utføre skriveoperasjonen på samme måte som ved bruk av 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  ;   }   

Les data fra fil

Når filen er åpnet i lesemodus med enten fstream eller ifstream, kan vi utføre skriveoperasjonen på samme måte som med cin ved å bruke >> operatør.

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

Produksjon

 Read String: Welcome  
 Dette har samme problem som cin. Inndata tas kun til det første mellomromstegn. For å unngå dette kan vi bruke     getline()    fungerer som vist:  
 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  ;   }   
   
  
    Produksjon    
 
 Read String: Welcome to GeeksforGeeks.  
 Lukking av filen  
 
 Å lukke filen betyr å lukke den tilknyttede strømmen og frigjøre ressursene vi blir brukt. Det er viktig å lukke filen etter at du er ferdig med den, spesielt i de langvarige programmene for å unngå minnelekkasjer tap av data osv.  
 
 I C++ lukkes filene ved hjelp av     lukke()    medlemsfunksjon som finnes i alle filstrømmer.  
 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  ;   }   
   
  
    Produksjon    
 
 Read String: Welcome to GeeksforGeeks.  
 Feil i filhåndtering  
 
 Mange forskjellige typer feil kan oppstå i filhåndtering som fil ikke funnet disken full osv. Våre programmer bør forvente vanlige feil og skal kunne håndtere dem riktig. Følgende er noen vanlige feil som kan oppstå under filhåndtering:  
 
 Feil ved åpning av fil  
 
 Det kan være tilfeller der filen ikke åpnes på grunn av ulike årsaker, for eksempel at den ikke eksisterer eller programmet ikke har tillatelse til å åpne den osv. I dette tilfellet kan vi bruke     is_open()    medlemsfunksjonen til filstrømklassene for å sjekke om filen er vellykket åpnet eller ikke.  
 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  ;   }   
   
  
    Produksjon    
 
 Error: Unable to open file!  
 Feil å lese/skrive data  
 
 En annen vanlig feil er unnlatelse av å lese eller skrive data av årsaker som feil modus osv. I dette tilfellet kan vi validere operasjoner etter hvert lese-/skriveforsøk. For eksempel kan lesing med getline() valideres som viser:  
 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  ;   }   
   
  
    Produksjon    
 
 Error: Failed to read data  
 End-of-File (EOF)-feil  
 
 Å prøve å lese utover slutten av filen kan forårsake en EOF-feil. Dette kan skje når du ikke ser etter slutten av filen før du leser. Vi kan se etter EOF ved å bruke     eof()    medlemsfunksjon.  
 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  ;   }   
   
  
    Produksjon    
 
 Reached end of file.  
 Legg merke til at vi også har validert leseoperasjonen før vi sjekker EOF som     getline()    kommer bare tilbake     nullptr    selv om lesingen mislykkes av en eller annen grunn.  
 
 Håndtering av binære filer  
 
 I C++ kan vi også håndtere     binære filer    som lagrer data i råformat. For å lese og skrive binære data må du bruke     ios::binær    flagg når du oppretter/åpner en binær fil.  
 
 Skriv inn i binærfil  
 
 For å skrive data til en binær fil må vi først åpne eller opprette filen i     ios::binær    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  ;   }   
   
  
    Produksjon    
  Binær fil 
 Leser fra binær fil  
 
 Akkurat som vi åpner en fil i binær modus for å skrive data for å lese data fra en binær fil, må vi åpne filen i lesemodus ved å bruke     ios::in    .  
 
    Syntaks:    
 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  ;   }   
   
  
    Produksjon    
 
 File Data: Welcome to GeeksForGeeks  
 Andre filoperasjoner  
 
 Vi kan også gjøre flere operasjoner for å manipulere en fil fra vårt C++-program. noen av de vanlige filoperasjonene er:  
 
 
 
      C++-program for å slette en fil      
 
      Legg til en streng i en eksisterende fil      
 
      Kopier en fil til en annen fil      
 
 
         Lag quiz