FILHÅNDTERING I C++

Filhåndtering betyder læsning fra og skrivning til filer (som .txt .csv osv.) ved hjælp af klasser leveret af C++ standardbiblioteket.

Programmer kører i RAM, hvilket betyder, at data kun eksisterer, mens programmet kører, når et program afslutter, går alle data i RAM automatisk tabt.
Filhåndtering tillader lagring af data i sekundær hukommelse (som HDD eller SSD), så de kan bevares permanent og kan gemmes og tilgås, selv efter programmet er afsluttet.
Til filoperationer giver C++ filstreamklasser i header såsom ofstream ifstream fstream.

Åbning af en fil

Før vi læser fra eller skriver til en fil, skal vi først åbne den. Åbning af en fil indlæser denne fil i RAM. I C++ åbner vi en fil ved at oprette en strøm til den ved hjælp af fstream klasse, der repræsenterer filstrømmen, dvs. stream til input og output til filen.

C++

    fstream     str  (  'filename.ext'       mode  );

hvor

str: Navn givet til strømmen
filnavn: Navnet på filen
mode : Repræsenterer den måde, hvorpå vi vil interagere med filen.

Filåbningstilstande

Filåbningstilstand angiver, at filen er åbnet til at læse skrivning eller tilføjelse. Nedenfor er listen over alle filtilstande i C++:

Mode	Beskrivelse
ios::in	Filen er åben til læsning. Hvis filen ikke findes, mislykkes den åbne operation.
ios::ud	Fil åben til skrivning: den interne stream buffer understøtter output operationer.
ios::binær	Operationer udføres i binær tilstand i stedet for tekst.
ios::at	Outputpositionen starter i slutningen af filen.
ios::app	Alle output-operationer sker i slutningen af filen, der føjes til dets eksisterende indhold.
ios::trunk	Alt indhold, der fandtes i filen, før den åbnes, kasseres.

For eksempel hvis vi vil åbne filen til læsning, bruger vi følgende åbningstilstand:

C++

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

På samme måde, hvis vi ønsker at åbne filen til skrivning, bruger vi følgende:

C++

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

Disse tilstande kan også kombineres med OR-operatoren (|). For eksempel kan du åbne filstrømmen i både læse- og skrivetilstand som vist:

C++

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

Hvis filen åbnet i skrivetilstand ikke eksisterer, oprettes en ny fil. Men hvis filen, der er åbnet i læsetilstand, ikke eksisterer, oprettes der ingen ny fil, og en undtagelse kastes

Andre filstrømme

fstream er ikke den eneste filstrøm leveret af C++. Der er to mere specialiserede strømme:

ifstream : Står for input filstrøm. Det svarer til åben fstream in ios::in mode.
ofstream : Står for output filstrøm. Det svarer til at åbne fstream ind ios::ud mode.

Ovenstående tilstande er standardtilstande for disse streams. Disse tilstande kan ikke ændres, men kan klubbes sammen med andre tilstande. Nu til input kan vi også bruge ifstream som vist:

C++

    ifstream     filein  (  'file.txt'  );

Tilsvarende for output:

C++

    ofstream     fileout  (  'file.txt'  );

Skriv data til fil

Når filen er åbnet i skrivetilstand ved hjælp af enten fstream eller ofstream vi kan udføre skriveoperationen på samme måde som med cout ved hjælp af < < operator.

C++

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

GFG.tekst

Læs data fra fil

Når først filen er åbnet i læsetilstand ved hjælp af enten fstream eller ifstream, kan vi udføre skriveoperationen på samme måde som med cin ved hjælp af >> operatør.

C++

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

Produktion

 Read String: Welcome   Dette har samme problem som cin. Indtastningen tages kun indtil det første mellemrumstegn. For at undgå dette kan vi bruge     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  ;   }   
     
    Produktion    
  Read String: Welcome to GeeksforGeeks.   Lukning af filen  
  At lukke filen betyder at lukke den tilknyttede strøm og frigøre de ressourcer, som vi bliver brugt. Det er vigtigt at lukke filen, når du er færdig med den, især i de langvarige programmer for at undgå hukommelseslækager datatab osv.  
  I C++ lukkes filerne ved hjælp af     tæt()    medlemsfunktion, der er til stede i alle filstrømme.  
 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  ;   }   
     
    Produktion    
  Read String: Welcome to GeeksforGeeks.   Fejl i filhåndtering  
  Der kan opstå mange forskellige typer fejl i filhåndteringen, såsom fil ikke fundet disk fuld osv. Vores programmer bør forvente almindelige fejl og skal kunne håndtere dem korrekt. Følgende er nogle almindelige fejl, der kan opstå under filhåndtering:  
  Fejl ved åbning af fil  
  Der kan være tilfælde, hvor filen ikke åbnes af forskellige årsager, såsom at den ikke eksisterer, eller programmet ikke har tilladelse til at åbne den osv. I dette tilfælde kan vi bruge     er_åben()    medlemsfunktion af filstrømsklasserne for at kontrollere, om filen er åbnet med succes eller ej.  
 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  ;   }   
     
    Produktion    
  Error: Unable to open file!   Manglende læsning/skrivning af data  
  En anden almindelig fejl er manglende læsning eller skrivning af data af årsager såsom forkert tilstand osv. I dette tilfælde kan vi validere operationer efter hvert læse-/skriveforsøg. For eksempel kan læsning ved hjælp af 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  ;   }   
     
    Produktion    
  Error: Failed to read data   End-of-File (EOF)-fejl  
  Forsøg på at læse ud over slutningen af filen kan forårsage en EOF-fejl. Dette kan ske, når du ikke tjekker for slutningen af filen, før du læser. Vi kan tjekke for EOF ved hjælp af     eof()    medlemsfunktion.  
 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  ;   }   
     
    Produktion    
  Reached end of file.   Bemærk, at vi også har valideret læseoperationen, før vi tjekker EOF som     getline()    vil kun vende tilbage     nullptr    selvom læsningen mislykkes af en eller anden grund.  
  Håndtering af binære filer  
  I C++ kan vi også klare     binære filer    som gemmer data i råformat. For at læse og skrive binære data skal du bruge     ios::binær    flag, når du opretter/åbner en binær fil.  
  Skriv i binær fil  
  For at skrive data til en binær fil skal vi først åbne eller oprette filen i     ios::binær    mode.  
 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  ;   }   
     
    Produktion    
  Binær fil  Læsning fra binær fil  
  Ligesom vi åbner en fil i binær tilstand for at skrive data for at læse data fra en binær fil, skal vi åbne filen i læsetilstand vha.     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  ;   }   
     
    Produktion    
  File Data: Welcome to GeeksForGeeks   Andre filhandlinger  
  Vi kan også udføre flere operationer for at manipulere en fil fra vores C++-program. nogle af de almindelige filhandlinger er:  
         C++-program til at slette en fil      
       Tilføj en streng i en eksisterende fil      
       Kopier en fil til en anden fil      
 
 
         Opret Quiz