C++ Filhantering: Hur man öppnar, skriver, läser, stänger filer i C++

fstream-biblioteket

Fstream-biblioteket tillhandahåller C++ programmerare med tre klasser för att arbeta med filer. Dessa klasser inkluderar:

• ofstream– Den här klassen representerar en utström. Den används för att skapa filer och skriva information till filer.
• ifstream– Den här klassen representerar en ingångsström. Den används för att läsa information från datafiler.
• fstream– Den här klassen representerar vanligtvis en filström. Den kommer med ofstream/ifstream-funktioner. Detta betyder att den kan skapa filer, skriva till filer, läsa från datafiler.

Följande bild gör det enkelt att förstå:

För att använda ovanstående klasser i fstream-biblioteket måste du inkludera det i ditt program som en rubrikfil. Naturligtvis kommer du att använda #include preprocessor-direktivet. Du måste också inkludera iostream-huvudfilen.

Hur man öppnar filer

Innan du utför någon åtgärd på en fil måste du först öppna den. Om du behöver skriva till filen, öppna den med fstream- eller ofstream-objekt. Om du bara behöver läsa från filen, öppna den med ifstream-objektet.

De tre objekten, det vill säga fstream, ofstream och ifstream, har funktionen open() definierad i sig. Funktionen tar denna syntax:

open (file_name, mode);

• Parametern file_name anger namnet på filen som ska öppnas.
• Modeparametern är valfri. Det kan ta något av följande värden:

Värderar	BESKRIVNING
ios:: app	Append-läget. Utdata som skickas till filen läggs till den.
ios::ät	Den öppnar filen för utdata och flyttar sedan läs- och skrivkontrollen till filens slut.
ios::in	Den öppnar filen för läsning.
ios::ut	Det öppnar filen för en skrivning.
ios::trunc	Om det finns en fil bör filelementen trunkeras innan den öppnas.

Det är möjligt att använda två lägen samtidigt. Du kombinerar dem med hjälp av | (ELLER) operatör.

Exempel 1:

#include <iostream>
#include <fstream>
using namespace std;
int main() {
	fstream my_file;
	my_file.open("my_file", ios::out);
	if (!my_file) {
		cout << "File not created!";
	}
	else {
		cout << "File created successfully!";
		my_file.close(); 
	}
	return 0;
}

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i programmet för att använda dess funktioner.
2. Inkludera fstream-huvudfilen i programmet för att använda dess klasser.
3. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
4. Anropa main()-funktionen. Programlogiken bör gå in i dess kropp.
5. Skapa ett objekt av klassen fstream och ge det namnet my_file.
6. Använd funktionen open() på objektet ovan för att skapa en ny fil. Utläget låter oss skriva in i filen.
7. Använd if-satsen för att kontrollera om filskapandet misslyckades.
8. Meddelande att skriva ut på konsolen om filen inte skapades.
9. Slutet på brödtexten i if-utlåtandet.
10. Använd en else-sats för att ange vad du ska göra om filen skapades.
11. Meddelande att skriva ut på konsolen om filen skapades.
12. Använd close()-funktionen på objektet för att stänga filen.
13. Slutet på brödtexten i else-påståendet.
14. Programmet måste returnera värde om det slutförs framgångsrikt.
15. Slutet på huvuddelen () funktion.

Hur man stänger filer

En gång C++ program avslutas, det automatiskt

• spolar bäckarna
• frigör det tilldelade minnet
• stänger öppnade filer.

Men som programmerare bör du lära dig att stänga öppna filer innan programmet avslutas.

Objekten fstream, ofstream och ifstream har close()-funktionen för att stänga filer. Funktionen tar denna syntax:

void close();

Hur man skriver till filer

Du kan skriva till filen direkt från din C++ programmera. Du använder ströminsättningsoperator (<<) för detta. Texten som ska skrivas till filen ska omges av dubbla citattecken.

Låt oss visa detta.

Exempel 2:

#include <iostream>
#include <fstream>
using namespace std;
int main() {
	fstream my_file;
	my_file.open("my_file.txt", ios::out);
	if (!my_file) {
		cout << "File not created!";
	}
	else {
		cout << "File created successfully!";
		my_file << "Guru99";
		my_file.close();
	}
	return 0;
}

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i programmet för att använda dess funktioner.
2. Inkludera fstream-huvudfilen i programmet för att använda dess klasser.
3. Inkludera std-namnområdet i programmet för att använda dess klasser utan att anropa det.
4. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
5. Skapa en instans av klassen fstream och ge den namnet my_file.
6. Använd funktionen open() för att skapa en ny fil med namnet my_file.txt. Filen kommer att öppnas i ut-läge för att skriva in i den.
7. Använd en if-sats för att kontrollera om filen inte har öppnats.
8. Text att skriva ut på konsolen om filen inte öppnas.
9. Slutet på brödtexten i if-satsen.
10. Använd en else-sats för att ange vad du ska göra om filen skapades.
11. Text att skriva ut på konsolen om filen skapades.
12. Skriv lite text till den skapade filen.
13. Använd funktionen close() för att stänga filen.
14. Slutet på brödtexten i else-påståendet.
15. Programmet måste returnera värde efter framgångsrikt slutförande.
16. Slutet på huvuddelen av funktionen main().

Hur man läser från filer

Du kan läsa information från filer i din C++ programmera. Detta är möjligt med strömextraktionsoperatör (>>). Du använder operatören på samma sätt som du använder den för att läsa användarinmatning från tangentbordet. Men istället för att använda cin-objektet använder du ifstream/fstream-objektet.

Exempel 3:

#include <iostream>
#include <fstream>
using namespace std;
int main() {
	fstream my_file;
	my_file.open("my_file.txt", ios::in);
	if (!my_file) {
		cout << "No such file";
	}
	else {
		char ch;

		while (1) {
			my_file >> ch;
			if (my_file.eof())
				break;

			cout << ch;
		}

	}
	my_file.close();
	return 0;
}

Produktion:

Ingen sådan fil

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i programmet för att använda dess funktioner.
2. Inkludera fstream-huvudfilen i programmet för att använda dess klasser.
3. Inkludera std-namnområdet i programmet för att använda dess klasser utan att anropa det.
4. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
5. Skapa en instans av klassen fstream och ge den namnet my_file.
6. Använd funktionen open() för att skapa en ny fil med namnet my_file.txt. Filen kommer att öppnas i in-läget för läsning från den.
7. Använd en if-sats för att kontrollera om filen inte finns.
8. Text att skriva ut på konsolen om filen inte hittas.
9. Slutet på brödtexten i if-satsen.
10. Använd en else-sats för att ange vad du ska göra om filen hittas.
11. Skapa en char variabel benämnd 2 kap.
12. Skapa en medan slingan för att iterera över filinnehållet.
13. Skriv/lagra innehållet i filen i variabeln kap.
14. Använd en if condition och eof() funktion, det vill säga slutet av filen, för att säkerställa att kompilatorn fortsätter att läsa från filen om slutet inte nås.
15. Använd en break-sats för att sluta läsa från filen när slutet är nått.
16. Skriv ut innehållet i variabel ch på konsolen.
17. Slutet på medan kroppen.
18. Slutet på brödtexten i else-påståendet.
19. Anropa close()-funktionen för att stänga filen.
20. Programmet måste returnera värde efter framgångsrikt slutförande.
21. Slutet på huvuddelen av funktionen main().

Sammanfattning

• Med filhantering kan utdata från ett program skickas och lagras i en fil.
• Ett antal operationer kan sedan tillämpas på data medan de finns i filen.
• En ström är en abstraktion som representerar en enhet där in-/utmatningsoperationer utförs.
• En ström kan representeras som antingen destination eller källa för tecken av obestämd längd.
• Fstream-biblioteket tillhandahåller C++ programmerare med metoder för filhantering.
• För att använda biblioteket måste du inkludera det i ditt program med #include preprocessor-direktivet.