In dit artikel laten we u aan de hand van verschillende voorbeelden zien hoe u een bestand kunt lezen en schrijven in de programmeertaal C++. Om C++-bestandsbewerkingen zoals lezen en schrijven te begrijpen, moeten we eerst het concept van een stream in C++ begrijpen.
Wat is een stroom?
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, d.w.z. ios.
Hier is de hiërarchie van de streamklassen van de programmeertaal C++:
De cin- en cout-objecten 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 ofstroom, wat staat voor uitvoerbestandsstroom, wordt gebruikt om een gegevensstroom naar een bestand te schrijven.
Het bestand iostram.h 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 de 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 aan te maken en de functie close() om het bestand te sluiten.
#erbij betrekkengebruik makend van naamruimteuur;
inthoofd()
{
ofstream myFile_Handler;
// Bestand openen
mijnFile_Handler.open('Bestand_1.txt');
// Bestand sluiten
mijnFile_Handler.dichtbij();
opbrengst 0;
}
Nu gaan we het programma compileren en de uitvoer onderzoeken. Zoals je kunt zien in het onderstaande uitvoervenster, is het bestand File_1.txt 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, d.w.z.<<. 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.
#erbij betrekkengebruik makend van naamruimteuur;
inthoofd()
{
ofstream myFile_Handler;
// Bestand openen
mijnFile_Handler.open('Bestand_1.txt');
// Schrijf naar het bestand
mijnFile_Handler<< 'Dit is een voorbeeldtestbestand. ' <<eindel;
mijnFile_Handler<< 'Dit is de tweede regel van het dossier. ' <<eindel;
// Bestand sluiten
mijnFile_Handler.dichtbij();
opbrengst 0;
}
Nu zullen we het bovenstaande programma compileren en uitvoeren. Zoals je hieronder kunt zien, hebben we met succes naar het bestand File_1.txt geschreven.
Voorbeeld 3: Lezen uit een bestand
In de vorige voorbeelden hebben we u laten zien hoe u inhoud naar een bestand schrijft. Laten we nu de inhoud lezen van het bestand dat we in Voorbeeld-2 hebben gemaakt en de inhoud weergeven op het standaard uitvoerapparaat, d.w.z. de monitor.
We gebruiken de functie getline() om de volledige regel uit het bestand te lezen en vervolgens om de regel op de monitor af te drukken.
#erbij betrekken#erbij betrekken
#erbij betrekken
gebruik makend van naamruimteuur;
inthoofd()
{
ifstream mijnFile_Handler;
tekenreeks myLine;
// Bestand openen in de leesmodus
mijnFile_Handler.open('Bestand_1.txt');
indien(mijnFile_Handler.is geopend())
{
// Blijf het bestand lezen
terwijl(getline(myFile_Handler, myLine))
{
// print de regel op de standaarduitvoer
kosten <<mijn zin<<eindel;
}
// Bestand sluiten
mijnFile_Handler.dichtbij();
}
anders
{
kosten << 'Kan het bestand niet openen!';
}
opbrengst 0;
}
Nu gaan we de inhoud van File_1.txt afdrukken met het volgende commando: cat File_1.txt. Nadat 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 een bestand zowel te lezen als te schrijven, moeten we een fstream-object ophalen en het bestand openen in ios::in en ios::out-modus.
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.
#erbij betrekken#erbij betrekken
#erbij betrekken
gebruik makend van naamruimteuur;
inthoofd()
{
fstream mijnFile_Handler;
tekenreeks myLine;
// Bestand openen
mijnFile_Handler.open('Bestand_1.txt', ios::in |ios::uit);
// Controleer of het bestand is geopend
indien(!mijnFile_Handler)
{
kosten << 'Bestand niet geopend!';
Uitgang(1);
}
// Schrijf naar het bestand
mijnFile_Handler<< '1. Dit is nog een voorbeeldtestbestand. ' <<eindel;
mijnFile_Handler<< '2. Dit is de tweede regel van het bestand. ' <<eindel;
mijnFile_Handler.zoeken(ios::bedelen);
// Lees het bestand
indien(mijnFile_Handler.is geopend())
{
// Blijf het bestand lezen
terwijl(getline(myFile_Handler, myLine))
{
// print de regel op de standaarduitvoer
kosten <<mijn zin<<eindel;
}
// Bestand sluiten
mijnFile_Handler.dichtbij();
}
anders
{
kosten << 'Kan het bestand niet openen!';
}
mijnFile_Handler.dichtbij();
opbrengst 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.
#erbij betrekken#erbij betrekken
gebruik makend van naamruimteuur;
klasMedewerker
{
openbaar:
intemp_id;
};
inthoofd()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Werknemer empObj_W, empObj_R;
// Bestand openen
binOutFile_Handler.open('Employee.dat', ios::uit |ios::binair);
// Controleer of het bestand is geopend
indien(!binOutFile_Handler)
{
kosten << 'Bestand niet geopend!';
Uitgang(1);
}
// Initialiseer empObj_W
empObj_W.emp_id = 1512;
// Schrijf naar het bestand
binOutFile_Handler.schrijven((char *) &empObj_W,De grootte van(Medewerker));
binOutFile_Handler.dichtbij();
indien(!binOutFile_Handler.Goed())
{
kosten << 'Er is een fout opgetreden tijdens het schrijven van het binaire bestand!' <<eindel;
Uitgang(2);
}
// Laten we nu het bestand employee.dat lezen
binInFile_Handler.open('Employee.dat', ios::in |ios::binair);
// Controleer of het bestand is geopend
indien(!binInFile_Handler)
{
kosten << 'Bestand niet geopend!';
Uitgang(3);
}
// Lees de inhoud van het binaire bestand
binInFile_Handler.lezen((char *) &empObj_R,De grootte van(Medewerker));
binInFile_Handler.dichtbij();
indien(!binInFile_Handler.Goed())
{
kosten << 'Er is een fout opgetreden tijdens het lezen van het binaire bestand!' <<eindel;
Uitgang(4);
}
// Print de uitvoer van empObj_R
kosten << 'Gegevens van de werknemer :' <<eindel;
kosten << 'Werknemer-ID:' <<empObj_R.emp_id <<eindel;
opbrengst 0;
}
Conclusie
Bestanden worden voornamelijk gebruikt om de gegevens op te slaan en 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 programmeertaal C++ aan de hand van verschillende voorbeelden. Verder hebben we u laten zien hoe u gegevens kunt lezen en schrijven in zowel tekstbestanden als binaire bestanden.