Phenquestions
In dit artikel laten we u aan de hand van verschillende voorbeelden zien hoe u een bestand in de programmeertaal C++ kunt lezen en schrijven. Om C++-bestandsbewerkingen zoals lezen en schrijven te begrijpen, moeten we eerst het concept van een stream in C . begrijpen++.
Wat is een stream?
Een stream is gewoon een stroom van gegevens of tekens. Er zijn twee soorten stromen: invoerstromen en uitvoerstromen. Een invoerstroom wordt gebruikt om de gegevens van een extern invoerapparaat zoals een toetsenbord te lezen, terwijl een uitvoerstroom wordt gebruikt om gegevens naar het externe uitvoerapparaat zoals een monitor te schrijven. Een bestand kan zowel als invoer- als uitvoerbron worden beschouwd.
In C++ gebruiken we een stream om gegevens naar of van een externe bron te verzenden of te ontvangen.
We kunnen ingebouwde klassen gebruiken om toegang te krijgen tot een invoer/uitvoerstroom, i.e., "ios".
Hier is de hiërarchie van de streamklassen van de programmeertaal C++:
De objecten "cin" en "cout" worden gebruikt om respectievelijk de gegevens van het toetsenbord te lezen en de uitvoer op de monitor weer te geven. Bovendien wordt "ifstream", wat staat voor "invoerbestandsstroom", gebruikt om een gegevensstroom uit een bestand te lezen, en "ofstream", wat staat voor "uitvoerbestandsstroom", wordt gebruikt om een gegevensstroom te schrijven naar een bestand.
de "iostram".h”-bestand bevat alle vereiste standaard invoer-/uitvoerstroomklassen in de programmeertaal C++.
Voorbeelden
Nu u de basisprincipes van streams begrijpt, zullen we de volgende voorbeelden bespreken om u te helpen bestandsbewerkingen in C++ beter te begrijpen:
- Voorbeeld 1: Een bestand openen en sluiten
- Voorbeeld 2: Naar een bestand schrijven
- Voorbeeld 3: Lezen uit een bestand
- Voorbeeld 4: Lezen en schrijven naar een bestand
- Voorbeeld 5: Lezen en schrijven naar een binair bestand
Voorbeeld 1: Een bestand openen en sluiten
In dit voorbeeldprogramma laten we zien hoe u een bestand opent/maakt en hoe u het bestand sluit in C++. Zoals u in het onderstaande programma kunt zien, hebben we de bibliotheek opgenomen die nodig is voor bestandsbewerkingen.
Om een bestand te openen en te sluiten, hebben we een object van ofstream nodig. Om vervolgens een bestand te lezen of te schrijven, moeten we het bestand openen. We hebben het fstream-headerbestand op regel nummer 1 opgenomen, zodat we toegang hebben tot ofstream-klasse.
We hebben een myFile_Handler gedeclareerd als een object van ofstream in de hoofdfunctie. We kunnen dan de functie open() gebruiken om een leeg bestand te maken en de functie close() om het bestand te sluiten close.
#includenamespace std; gebruiken;
int hoofd()
ofstream mijnFile_Handler;
// Bestand openen
mijnFile_Handler.open("File_1.tekst");
// Bestand sluiten
mijnFile_Handler.dichtbij();
retourneer 0;
Nu zullen we het programma compileren en de uitvoer onderzoeken. Zoals je kunt zien in het onderstaande uitvoervenster, is de "File_1".txt"-bestand is gemaakt na het uitvoeren van het programma. De grootte van het bestand is nul omdat we geen inhoud in het bestand hebben geschreven.
Voorbeeld 2: Naar een bestand schrijven
In het vorige voorbeeldprogramma hebben we u laten zien hoe u een bestand opent en hoe u het bestand sluit. Nu laten we u zien hoe u iets in een bestand schrijft.
We kunnen naar een bestand schrijven met behulp van de stream-invoegoperator, i.e., “<<”. In this program, we have used the file handler and insertion operator to write two lines in the file. The insertion operator (“<<”) indicates that we are inserting the string into the output file stream object.
#includenamespace std; gebruiken;
int hoofd()
ofstream mijnFile_Handler;
// Bestand openen
mijnFile_Handler.open("File_1.tekst");
// Schrijf naar het bestand
mijnFile_Handler << "This is a sample test File. " << endl;
mijnFile_Handler << "This is the second line of the file. " << endl;
// Bestand sluiten
mijnFile_Handler.dichtbij();
retourneer 0;
Nu zullen we het bovenstaande programma compileren en uitvoeren. Zoals je hieronder kunt zien, hebben we met succes naar het bestand File_1 . geschreven.tekst.
Voorbeeld 3: Lezen uit een bestand
In de vorige voorbeelden hebben we u laten zien hoe u inhoud naar een bestand kunt schrijven. Laten we nu de inhoud lezen van het bestand dat we in Voorbeeld-2 hebben gemaakt en de inhoud weergeven op het standaard uitvoerapparaat, i.e., De monitor.
We gebruiken de functie getline() om de volledige regel uit het bestand te lezen en vervolgens "cout" om de regel op de monitor af te drukken.
#include#include
#include
namespace std; gebruiken;
int hoofd()
ifstream mijnFile_Handler;
tekenreeks myLine;
// Bestand openen in de leesmodus
mijnFile_Handler.open("File_1.tekst");
if(myFile_Handler).is geopend())
// Blijf het bestand lezen
while(getline(myFile_Handler, myLine))
// print de regel op de standaarduitvoer
cout << myLine << endl;
// Bestand sluiten
mijnFile_Handler.dichtbij();
anders
cout << "Unable to open the file!";
retourneer 0;
Nu gaan we de inhoud van File_1 . afdrukken.txt met de volgende opdracht: cat File_1.tekst. Zodra we het programma hebben gecompileerd en uitgevoerd, is het duidelijk dat de uitvoer overeenkomt met de inhoud van het bestand. Daarom hebben we het bestand met succes gelezen en de inhoud van het bestand naar de monitor afgedrukt.
Voorbeeld 4: Lezen en schrijven naar een bestand
Tot nu toe hebben we u laten zien hoe u een bestand opent, leest, schrijft en sluit. In C++ kunnen we ook tegelijkertijd lezen en schrijven naar een bestand. Om zowel naar een bestand te lezen als naar een bestand te schrijven, moeten we een fstream-object ophalen en het bestand openen in de modus "ios::in" en "ios::out".
In dit voorbeeld schrijven we eerst wat inhoud naar het bestand. Vervolgens lezen we de gegevens uit het bestand en printen het naar de monitor.
#include#include
#include
namespace std; gebruiken;
int hoofd()
fstream mijnFile_Handler;
tekenreeks myLine;
// Bestand openen
mijnFile_Handler.open("File_1.txt", ios::in | ios::out);
// Controleer of het bestand is geopend
als(!mijnFile_Handler)
cout << "File did not open!";
uitgang(1);
// Schrijf naar het bestand
mijnFile_Handler << "1. This is another sample test File. " << endl;
mijnFile_Handler << "2. This is the second line of the file. " << endl;
mijnFile_Handler.seekg(ios::beg);
// Lees het bestand
if(myFile_Handler).is geopend())
// Blijf het bestand lezen
while( getline(myFile_Handler, myLine))
// print de regel op de standaarduitvoer
cout << myLine << endl;
// Bestand sluiten
mijnFile_Handler.dichtbij();
anders
cout << "Unable to open the file!";
mijnFile_Handler.dichtbij();
retourneer 0;
Nu gaan we het programma compileren en uitvoeren.
Voorbeeld 5: Lezen en schrijven naar een binair bestand
In dit voorbeeld gaan we een klasse declareren en vervolgens het object naar een binair bestand schrijven. Om dit voorbeeld te vereenvoudigen, hebben we de klasse Employee gedeclareerd met een openbare variabele emp_id. Vervolgens zullen we het binaire bestand lezen en de uitvoer naar de monitor afdrukken.
#include#include
namespace std; gebruiken;
klasse Medewerker
openbaar:
int emp_id;
;
int hoofd()
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Werknemer empObj_W, empObj_R;
// Bestand openen
binOutFile_Handler.open("Werknemer.dat", ios::out | ios::binary);
// Controleer of het bestand is geopend
als(!binOutFile_Handler)
cout << "File did not open!";
uitgang(1);
// Initialiseer empObj_W
empObj_W.emp_id = 1512;
// Schrijf naar het bestand
binOutFile_Handler.write((char *) &empObj_W, sizeof(Werknemer));
binOutFile_Handler.dichtbij();
als(!binOutFile_Handler.is goed())
cout << "Error occured during writing the binary file!" << endl;
uitgang(2);
// Laten we nu de werknemer lezen.dat-bestand
binInFile_Handler.open("Werknemer.dat", ios::in | ios::binary);
// Controleer of het bestand is geopend
als(!binInFile_Handler)
cout << "File did not open!";
uitgang (3);
// Lees de inhoud van het binaire bestand
binInFile_Handler.read((char *) &empObj_R, sizeof(Werknemer));
binInFile_Handler.dichtbij();
als(!binInFile_Handler.is goed())
cout << "Error occured during reading the binary file!" << endl;
uitgang(4);
// Print de uitvoer van empObj_R
cout << "Details of the Employee : " << endl;
cout << "Employee ID : " << empObj_R.emp_id << endl;
retourneer 0;
Conclusie
Bestanden worden voornamelijk gebruikt om de gegevens op te slaan en ze spelen een belangrijke rol bij het programmeren in de echte wereld. In dit artikel hebben we u laten zien hoe u verschillende bestandsbewerkingen kunt gebruiken met de C++-programmeertaal door verschillende voorbeelden te doorlopen. Verder hebben we u laten zien hoe u gegevens kunt lezen en schrijven in zowel tekstbestanden als binaire bestanden.
