Failų tvarkymas reiškia skaitymą ir rašymą į failus (pvz., .txt .csv ir kt.), naudojant C++ standartinės bibliotekos teikiamas klases.

• Programos veikia RAM, tai reiškia, kad duomenys egzistuoja tik programai veikiant, kai programa baigiasi, visi RAM duomenys prarandami automatiškai.
• Failų tvarkymas leidžia saugoti duomenis antrinėje atmintyje (pvz., HDD arba SSD), todėl juos galima išsaugoti visam laikui ir išsaugoti bei pasiekti net pasibaigus programai.
• Failų operacijoms C++ pateikia failų srauto klases antraštė, pvz., ofstream ifstream fstream.

Failo atidarymas

Prieš skaitydami iš failo arba į jį rašydami, pirmiausia turime jį atidaryti. Atidarius failą, jis įkeliamas į RAM. C++ atidarome failą sukurdami srautą į jį naudodami fstream klasė, kuri atstovauja failo srautą, ty srautą, skirtą įvesties ir išvesties į failą.

   fstream     str  (  'filename.ext'       mode  );   

kur

• str: Srautui suteiktas pavadinimas
• failo pavadinimas: Failo pavadinimas
• režimu : nurodo būdą, kuriuo ketiname sąveikauti su failu.

Failų atidarymo režimai

Failo atidarymo režimas rodo, kad failas atidarytas skaityti, rašyti arba pridėti. Žemiau pateikiamas visų C++ failų režimų sąrašas:

Pavyzdžiui jei norime atidaryti failą skaitymui, naudojame šį atidarymo režimą:

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

Panašiai, jei norime atidaryti failą rašymui, naudojame šiuos:

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

Šiuos režimus taip pat galima derinti naudojant OR operatorių (|). Pavyzdžiui, galite atidaryti failų srautą skaitymo ir rašymo režimu, kaip parodyta:

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

Jei failas, atidarytas rašymo režimu, neegzistuoja, sukuriamas naujas failas. Bet jei failas, atidarytas skaitymo režimu, neegzistuoja, naujas failas nesukuriamas ir daroma išimtis

Kiti failų srautai

fstream nėra vienintelis failų srautas, kurį teikia C++. Yra dar du specializuoti srautai:

• ifstream : reiškia įvesties failo srautą. Tai prilygsta atidaryti fstream in ios::in režimu.
• už srauto : reiškia išvesties failo srautą. Tai prilygsta „fstream in“ atidarymui ios::out režimu.

Pirmiau nurodyti režimai yra numatytieji šių srautų režimai. Šių režimų pakeisti negalima, tačiau juos galima sujungti su kitais režimais. Dabar įvedimui taip pat galime naudoti ifstream, kaip parodyta:

   ifstream     filein  (  'file.txt'  );   

Panašiai ir išėjimui:

   ofstream     fileout  (  'file.txt'  );   

Įrašykite duomenis į failą

Kai failas atidaromas rašymo režimu, naudojant bet kurį iš fstream arba už srauto rašymo operaciją galime atlikti panašiai kaip naudojant 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  ;   }   

Skaityti duomenis iš failo

Kai failas atidaromas skaitymo režimu naudojant fstream arba ifstream, galime atlikti rašymo operaciją panašiai kaip su cin naudojant >> operatorius.

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

Išvestis

 Read String: Welcome  
 Tai turi tą pačią problemą kaip ir cin. Įvestis įvedama tik iki pirmojo tarpo simbolio. Norėdami to išvengti, galime naudoti     getline ()    veikia kaip parodyta:  
 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  ;   }   
   
  
    Išvestis    
 
 Read String: Welcome to GeeksforGeeks.  
 Failo uždarymas  
 
 Failo uždarymas reiškia susieto srauto uždarymą ir naudojamų išteklių atlaisvinimą. Baigę failą, ypač ilgai veikiančiose programose, svarbu uždaryti failą, kad išvengtumėte duomenų praradimo ir pan.  
 
 C++ failai uždaromi naudojant     uždaryti ()    nario funkcija, kuri yra visuose failų srautuose.  
 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  ;   }   
   
  
    Išvestis    
 
 Read String: Welcome to GeeksforGeeks.  
 Failų tvarkymo klaidos  
 
 Apdorojant failus gali atsirasti įvairių tipų klaidų, pvz., failas nerastas pilnas diskas ir pan. Mūsų programos turėtų tikėtis dažnų klaidų ir turėtų sugebėti jas tinkamai tvarkyti. Toliau pateikiamos kelios dažniausiai pasitaikančios klaidos, kurios gali atsirasti tvarkant failus:  
 
 Failo atidarymo nesėkmė  
 
 Gali būti atvejų, kai failas neatidaromas dėl įvairių priežasčių, pavyzdžiui, jo nėra arba programa neturi leidimo jo atidaryti ir pan. Tokiu atveju galime naudoti     is_open()    Failų srauto klasių nario funkcija, kad patikrintų, ar failas atidarytas sėkmingai, ar 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  ;   }   
   
  
    Išvestis    
 
 Error: Unable to open file!  
 Duomenų nuskaitymo/rašymo nebuvimas  
 
 Kita dažna klaida – nepavyksta nuskaityti arba įrašyti duomenų dėl tokių priežasčių kaip netinkamas režimas ir pan. Tokiu atveju galime patvirtinti operacijas po kiekvieno skaitymo/rašymo bandymo. Pavyzdžiui, skaitymas naudojant getline() gali būti patvirtintas taip, kaip parodyta:  
 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  ;   }   
   
  
    Išvestis    
 
 Error: Failed to read data  
 Failo pabaigos (EOF) klaida  
 
 Bandymas perskaityti po failo pabaigos gali sukelti EOF klaidą. Taip gali nutikti, kai prieš skaitydami netikrinate, ar nėra failo pabaigos. Mes galime patikrinti EOF naudodami     eof()    nario funkcija.  
 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  ;   }   
   
  
    Išvestis    
 
 Reached end of file.  
 Atkreipkite dėmesį, kad mes taip pat patvirtinome skaitymo operaciją prieš tikrindami EOF as     getline ()    tik grįš     nullptr    net jei skaityti nepavyksta dėl kokios nors priežasties.  
 
 Dvejetainių failų tvarkymas  
 
 C++ mes taip pat galime tvarkyti     dvejetainiai failai    kurie saugo duomenis neapdorotu formatu. Norėdami skaityti ir rašyti dvejetainius duomenis, turite naudoti     ios:: dvejetainis    vėliavėlė kuriant / atidarant dvejetainį failą.  
 
 Įrašykite į dvejetainį failą  
 
 Norėdami įrašyti duomenis į dvejetainį failą, pirmiausia turime atidaryti arba sukurti failą     ios:: dvejetainis    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  ;   }   
   
  
    Išvestis    
  Dvejetainis failas 
 Skaitymas iš dvejetainio failo  
 
 Kaip mes atidarome failą dvejetainiu režimu, norėdami įrašyti duomenis ir skaityti duomenis iš dvejetainio failo, turime atidaryti failą skaitymo režimu naudodami     ios::in    .  
 
    Sintaksė:    
 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  ;   }   
   
  
    Išvestis    
 
 File Data: Welcome to GeeksForGeeks  
 Kitos failų operacijos  
 
 Taip pat galime atlikti daugiau operacijų, kad galėtume valdyti failą iš mūsų C++ programos. kai kurios įprastos failų operacijos yra šios:  
 
 
 
      C++ programa, skirta failams ištrinti      
 
      Pridėti eilutę esamame faile      
 
      Nukopijuokite vieną failą į kitą failą      
 
 
         Sukurti viktoriną