Filhantering innebär att läsa från och skriva till filer (som .txt .csv etc.) med klasser som tillhandahålls av C++ standardbiblioteket.

• Program som körs i RAM betyder att data endast existerar medan programmet körs när ett program avslutar all data i RAM förloras automatiskt.
• Filhantering tillåter lagring av data i sekundärt minne (som hårddisk eller SSD) så att den kan bevaras permanent och kan sparas och nås även efter att programmet avslutats.
• För filoperationer tillhandahåller C++ filströmsklasser iheader som ofstream ifstream fstream.

Öppna en fil

Innan vi läser från eller skriver till en fil måste vi först öppna den. Om du öppnar en fil laddas den filen i RAM-minnet. I C++ öppnar vi en fil genom att skapa en ström till den med hjälp av fstream klass som representerar filströmmen, dvs. ström för inmatning och utmatning till filen.

fstream str('filename.ext' mode); 

där

• str: Namnet på strömmen
• filnamn: Namn på filen
• läge : Representerar det sätt på vilket vi kommer att interagera med filen.

Filöppningslägen

Filöppningsläge indikerar att filen är öppen för läsning och skrivning eller tillägg. Nedan är listan över alla fillägen i C++:

Till exempel om vi vill öppna filen för läsning använder vi följande öppningsläge:

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

På liknande sätt om vi vill öppna filen för skrivning använder vi följande:

vad är skillnaden mellan en megabyte och en gigabyte

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

Dessa lägen kan också kombineras med OR-operatorn (|). Du kan till exempel öppna filströmmen i både läs- och skrivläge som visas:

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

Om filen som öppnas i skrivläge inte existerar skapas en ny fil. Men om filen som öppnas i läsläge inte existerar skapas ingen ny fil och ett undantag skapas

Andra filströmmar

fstream är inte den enda filströmmen som tillhandahålls av C++. Det finns ytterligare två specialiserade strömmar:

• ifstream : Står för indatafilström. Det motsvarar att öppna fstream in ios::in läge.
• ofstream : Står för utdatafilström. Det motsvarar att öppna fstream in ios::ut läge.

Ovanstående lägen är standardlägen för dessa strömmar. Dessa lägen kan inte ändras men kan klubbas tillsammans med andra lägen. Nu för input kan vi också använda ifstream som visas:

ifstream filein('file.txt'); 

På samma sätt för utdata:

ofstream fileout('file.txt'); 

Skriv data till fil

När filen har öppnats i skrivläge med antingen fstream eller ofstream vi kan utföra skrivoperationen på liknande sätt som med 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; } 

Läs data från fil

När filen väl har öppnats i läsläge med antingen fstream eller ifstream kan vi utföra skrivoperationen på liknande sätt som med cin med >> 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; } 

Produktion

Read String: Welcome

Detta har samma problem som cin. Inmatningen tas bara tills det första blanktecken. För att undvika detta kan vi använda getline() fungerar som visas:

#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.

Stänger filen

Att stänga filen innebär att stänga den associerade strömmen och frigöra resurserna som vi används. Det är viktigt att stänga filen efter att du är klar med den, särskilt i de långvariga programmen för att undvika minnesläckor dataförlust etc.

I C++ stängs filerna med hjälp av nära() medlemsfunktion som finns i alla filströmmar.

#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.

Fel i filhantering

Många olika typer av fel kan uppstå i filhanteringen som fil inte hittas disken full etc. Våra program bör förvänta sig vanliga fel och ska kunna hantera dem på rätt sätt. Följande är några vanliga fel som kan uppstå under filhantering:

Filöppningsfel

Det kan finnas fall där filen inte öppnas på grund av olika anledningar som att den inte finns eller att programmet inte har tillstånd att öppna den etc. I det här fallet kan vi använda is_open() medlemsfunktionen i filströmsklasserna för att kontrollera om filen har öppnats framgångsrikt eller inte.

#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!

Misslyckande att läsa/skriva data

Ett annat vanligt fel är att misslyckas med att läsa eller skriva data av anledningar som felaktigt läge etc. I det här fallet kan vi validera operationer efter varje läs-/skrivförsök. Till exempel kan läsning med getline() valideras enligt följande:

#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)-fel

Att försöka läsa bortom slutet av filen kan orsaka ett EOF-fel. Detta kan hända när du inte letar efter slutet av filen innan du läser. Vi kan kontrollera om EOF använder eof() medlemsfunktion.

#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.

Observera att vi också har validerat läsoperationen innan vi kontrollerar EOF som getline() kommer bara tillbaka nullptr även om läsningen misslyckas av någon anledning.

Hantera binära filer

I C++ kan vi också hantera binära filer som lagrar data i råformat. För att läsa och skriva binära data måste du använda ios::binär flagga när du skapar/öppnar en binär fil.

Skriv till binär fil

För att skriva data till en binär fil måste vi först öppna eller skapa filen i ios::binär läge.

#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

Läser från binär fil

Precis som vi öppnar en fil i binärt läge för att skriva data för att läsa data från en binär fil måste vi öppna filen i läsläge med ios::in .

Syntax:

ställ in java

fstream fileInstance('fileName.bin' ios::in| ios::binary); 

#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

Andra filoperationer

Vi kan också göra fler operationer för att manipulera en fil från vårt C++-program. några av de vanliga filoperationerna är:

• C++-program för att ta bort en fil
• Lägg till en sträng i en befintlig fil
• Kopiera en fil till en annan fil