1. Werken met bestanden in C (werkt ook in C++)..
#erbij betrekken
#erbij betrekken
Leegte belangrijkste (leegte)
{
BESTAND *bestand;
char* bestandsnaam = "bestand.txt";
char load_string = "geen";
Bestand = fopen(bestandsnaam, "w");
Fputs("tekenreeks", bestand);
Bestand = fopen(bestandsnaam, "r");
als(bestand != 0)
{
fgets(laad_string, 50, bestand);
schelden)
anders
{
schelden)
fsluiten(bestand);
) Beschrijvingen van functies voor het werken met bestanden bevinden zich in de bibliotheek stdio.h
Eerst moet u een verwijzing maken naar een variabele van het type FILE ( BESTAND* bestand;).
Het openen van een bestand gebeurt door het aanroepen van de fopen-functie ( bestand = fopen(bestandsnaam, "w");)
De eerste parameter van deze functie is de bestandsnaam, de tweede geeft aan in welke modus het bestand geopend moet worden. "w"- geopend voor opname, "R"- geopend om te lezen, "A"- bestandstoevoeging (dit zijn de meest gebruikte modi, hoewel er andere zijn). Het schrijven en lezen van gegevens uit een bestand wordt uitgevoerd door de volgende functies: fputc, fputs, fgetc, fgets, fprintf, fscanf(voor een beschrijving van deze functies, zie stdio.h).
Het sluiten van een bestand gebeurt door het aanroepen van de functie fclose ( fsluiten(bestand);).
De MFC-bibliotheek bevat verschillende klassen voor het werken met bestanden. De hieronder besproken klassen erven van de basisklasseWerken met bestanden met behulp van MFC (klassen CFile, CStdioFile, ...) en de standaard MFC-klasse CFileDialog.
Klasse CF-ile
CBestandontworpen om met bestanden te werken. Het maakt bestanden eenvoudiger te gebruiken door een bestand voor te stellen als een object dat kan worden gemaakt, gelezen, geschreven, enz.Om toegang te krijgen tot een bestand, moet u eerst een object van de klasse CFile maken. Met de klasseconstructor kunt u een bestand onmiddellijk openen nadat u een dergelijk object hebt gemaakt. Maar u kunt het bestand later openen met behulp van de methode
Open.Bestanden openen en maken
Na het maken van het klasseobject CBestandu kunt een bestand openen door de methode aan te roepenOpen. De methode moet het pad naar het te openen bestand en de gebruiksmodus specificeren. Methode prototypeOpenheeft de volgende vorm:
Virtuele BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError=NULL); Als parameter lpszFileName moet u de naam opgeven van het bestand dat u wilt openen. U kunt alleen de bestandsnaam opgeven of de volledige bestandsnaam, inclusief het volledige pad ernaartoe. De tweede parameter, nOpenFlags, specificeert de actie die de Open-methode op het bestand uitvoert, evenals de kenmerken van het bestand. Hieronder staan enkele mogelijke waarden voor de parameter nOpenFlags:
Optionele parameter pError, die een verwijzing is naar een klasseobject CFileException, wordt alleen gebruikt als het uitvoeren van een bewerking op het bestand een fout zou veroorzaken. In dit geval wordt aanvullende informatie naar het object geschreven waarnaar pError verwijst.
Methode Openretourneert niet-nul als het bestand open is en nul bij een fout. Er kan een fout optreden bij het openen van een bestand, bijvoorbeeld als de Open-methode is opgegeven om een niet-bestaand bestand te lezen.
Bestands-ID openen
De klasse CFile bevat een data-element m_hFile van het type UINT. Het slaat de identificatie van het geopende bestand op. Als er al een object van de klasse CFile is gemaakt, maar het bestand nog niet is geopend, wordt de constante hFileNull in de variabele m_hFile geschreven.
Normaal gesproken wordt de open bestands-ID niet rechtstreeks gebruikt. Klasse methoden CBestandkunt u vrijwel elke bewerking met bestanden uitvoeren en hoeft u geen bestands-ID op te geven. Omdat m_hFile een klasse-element is, heeft de implementatie van zijn methoden er altijd vrije toegang toe.
Bestanden sluiten
Nadat u klaar bent met het werken met het bestand, moet het worden gesloten. Klas CBestandheeft hiervoor een speciale Sluitingsmethode. Opgemerkt moet worden dat als een object van de klasse CFile is gemaakt en een bestand is geopend en het object vervolgens wordt verwijderd, het bijbehorende bestand automatisch wordt gesloten met behulp van een destructor.
Bestanden lezen en schrijven
Er zijn verschillende klassenmethoden voor toegang tot bestanden. CBestand: Lezen, lezengroot, schrijven, schrijvengroot, doorspoelen. Methoden Lezen en lezenGroot zijn ontworpen om gegevens uit een eerder geopend bestand te lezen. Op 32-bits besturingssystemen kunnen beide methoden tegelijkertijd meer dan 65535 bytes uit een bestand lezen. De ReadHuge-specificatie wordt als verouderd beschouwd en wordt alleen behouden voor compatibiliteit met 16-bits besturingssystemen.
Gegevens die uit het bestand worden gelezen, worden naar de lpBuf-buffer geschreven. De parameter nCount specificeert het aantal bytes dat uit het bestand moet worden gelezen. In feite kunnen er minder bytes uit het bestand worden gelezen dan gevraagd door de parameter nCount. Dit gebeurt als het einde van het bestand tijdens het lezen wordt bereikt. De methoden retourneren het aantal bytes dat uit het bestand is gelezen.
De methoden Write en WriteHuge zijn bedoeld voor het schrijven naar een bestand. Op 32-bits besturingssystemen kunnen beide methoden tegelijkertijd meer dan 65535 bytes naar een bestand schrijven. Methods schrijft bytes uit de lpBuf-buffer naar het geopende bestand nCount. Als er een schrijffout optreedt, zoals een schijf die vol is, vragen de methoden om uitzonderingsafhandeling.
Spoelmethode
Wanneer de Write- of WriteHuge-methode wordt gebruikt om gegevens naar schijf te schrijven, kan deze enige tijd in een tijdelijke buffer blijven. Om ervoor te zorgen dat de noodzakelijke wijzigingen in het bestand op schijf worden aangebracht, moet u de Flush-methode gebruiken.
Bestandsbewerkingen
De klasse bevat methoden waarmee u verschillende bewerkingen op bestanden kunt uitvoeren, zoals kopiëren, hernoemen, verwijderen en attributen wijzigen.
Om de bestandsnaam te wijzigen, bevat de klasse CFile een statische methode Hernoemen, die de functies van deze opdracht uitvoert. De methode kan niet worden gebruikt om mappen te hernoemen. Als er een fout optreedt, genereert de methode een uitzondering.
In de klasse CFile is een statische methode opgenomen om bestanden te verwijderen Verwijderen, waarmee u het opgegeven bestand kunt verwijderen. Met deze methode kunt u geen mappen verwijderen. Als het bestand niet kan worden verwijderd, genereert de methode een uitzondering.
Om de datum en tijd van het aanmaken van bestanden, de lengte en attributen ervan te bepalen, wordt een statische methode gebruikt GetStatus. Er zijn twee varianten van de methode: de eerste wordt gedefinieerd als een virtuele methode en de tweede wordt gedefinieerd als een statische methode.
Virtuele versie van de methode GetStatusbepaalt de open status van het bestand dat aan dit CFile-klasseobject is gekoppeld. Deze methode wordt alleen aangeroepen wanneer een CFile-klasseobject wordt gemaakt en het bestand wordt geopend.
Statische versie van de methode GetStatusHiermee kunt u de kenmerken bepalen van een bestand dat niet is gekoppeld aan een object van de CFile-klasse. Om deze methode te gebruiken, is het niet nodig om eerst het bestand te openen.
Blokkeren
De klasse bevat methoden Vergrendelbereik En Bereik ontgrendelen, waarmee een of meer bestandsgegevens kunnen worden vergrendeld voor toegang door andere processen. Als een toepassing probeert gegevens die eerder door deze of een andere toepassing zijn vergrendeld, opnieuw te vergrendelen, wordt er een uitzondering gegenereerd. Vergrendeling is een van de mechanismen waarmee verschillende applicaties of processen tegelijkertijd aan hetzelfde bestand kunnen werken zonder elkaar te hinderen.
U kunt een vergrendeling instellen met behulp van de methode Vergrendelbereik. Om geïnstalleerde sloten te verwijderen, moet u de methode gebruikenBereik ontgrendelen. Als er meerdere vergrendelingen in één bestand zijn ingesteld, moet elk ervan worden vrijgegeven door een afzonderlijke methodeaanroepBereik ontgrendelen.
Positionering
Om de huidige bestandspositieaanwijzer naar een nieuwe positie te verplaatsen, kunt u een van de volgende klassenmethoden gebruiken CBestand - Zoeken, zoeken naar begin, zoeken naar einde. Naar de klas CBestandbevat ook methoden waarmee u de bestandslengte kunt instellen en wijzigen, -GetLengte, SetLengte.
Wanneer u een bestand opent, bevindt de huidige bestandspositie-indicator zich helemaal aan het begin van het bestand. Wanneer een stukje gegevens wordt gelezen of geschreven, beweegt de huidige positieaanwijzer naar het einde van het bestand en wijst naar de gegevens die zullen worden gelezen of geschreven door de volgende lees- of schrijfbewerking naar het bestand.
Om de huidige bestandspositieaanwijzer naar een willekeurige locatie te verplaatsen, kunt u de universele methode gebruiken
Zoeken. Hiermee kunt u de aanwijzer een bepaald aantal bytes verplaatsen ten opzichte van de begin-, eind- of huidige aanwijzerpositie.Om de aanwijzer naar het begin of einde van een bestand te verplaatsen, is het het handigst om speciale methoden te gebruiken. Methode
ZoekToBeginverplaatst de aanwijzer naar het begin van het bestand en de methodeZoekToEnd- tot het einde.Maar om de lengte van een geopend bestand te bepalen, is het niet nodig om de aanwijzer te verplaatsen. Je kunt de methode gebruiken
Lengte ophalen. Deze methode retourneert ook de lengte van het geopende bestand in bytes. MethodeLengte instellenHiermee kunt u de lengte van het geopende bestand wijzigen. Als deze methode de bestandsgrootte vergroot, is de waarde van de laatste bytes ongedefinieerd.De huidige positie van de bestandsaanwijzer kan met behulp van de methode worden bepaald
GetPositie. Geretourneerd per methodeGetPositieDe 32-bits waarde specificeert de pointer-offset vanaf het begin van het bestand.Bestandskenmerken openen
Om de locatie van een geopend bestand op schijf te bepalen, moet u de methode aanroepen GetFilePath. Deze methode retourneert een object van de klasseCString, dat het volledige pad van het bestand bevat, inclusief de stationsnaam, mappen, bestandsnaam en bestandsextensie.
Als u alleen de naam en extensie van een geopend bestand hoeft te bepalen, kunt u de methode gebruiken GetFileName. Het retourneert een CString-object dat de bestandsnaam bevat. In het geval dat u alleen de naam van een geopend bestand zonder extensie wilt weten, gebruikt u de methodeGetFileTitel.
Met de volgende methode van de klasse CFile kunt u het bestandspad instellen. Deze methode maakt, kopieert of wijzigt de bestandsnaam niet; het vult alleen het overeenkomstige gegevenselement in het klasseobject CFile in.
Klasse C
MembestandDe MFC-bibliotheek bevat de klasse
CMemBestand, geërfd van de basisklasseCBestand. Klas CMemBestandvertegenwoordigt een bestand dat zich in het RAM bevindt. Met klasseobjectenCMemBestandhetzelfde als bij klasseobjectenCBestand. Het verschil is dat het bestand aan het object is gekoppeldCMemBestand, bevindt zich niet op de schijf, maar in het RAM van de computer. Hierdoor zijn de bewerkingen met een dergelijk bestand veel sneller dan met gewone bestanden.Werken met klasseobjecten
CMemBestand, kun je bijna alle methoden van de klasse gebruikenCBestanddie hierboven werden beschreven. U kunt gegevens naar een dergelijk bestand schrijven of lezen. Naast deze methoden bevat de klasseCMemBestandaanvullende methoden inbegrepen.Er zijn twee verschillende constructors voor het maken van objecten van de klasse CMemFile. De eerste CMemFile-constructor heeft slechts één optionele parameter nGrowBytes:
CMemFile(UINT nGrowBytes=1024);Deze constructor maakt een leeg bestand in RAM. Eenmaal gemaakt, wordt het bestand automatisch geopend (het is niet nodig om de Ope-methode aan te roepen
N).Wanneer het schrijven naar een dergelijk bestand begint, wordt er automatisch een geheugenblok toegewezen. Om geheugenklassemethoden te verkrijgen
CMemBestandstandaardfuncties oproepenmalloc, realloc En vrij. Als het toegewezen geheugenblok niet voldoende is, wordt de omvang ervan vergroot. Het geheugenblok van het bestand wordt vergroot met delen van nGrowBytes-bytes. Na het verwijderen van een klasseobjectCMemBestandgebruikt geheugen wordt automatisch teruggestuurd naar het systeem.De tweede constructor van de klasse CMemFile heeft een complexer prototype. Deze constructor wordt gebruikt in gevallen waarin de programmeur zelf geheugen voor het bestand toewijst:
CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes=0);De parameter lpBuffer specificeert de buffer die voor het bestand moet worden gebruikt. De buffergrootte wordt bepaald door de parameter nBufferSize.
De optionele parameter nGrowBytes wordt uitgebreider gebruikt dan in de eersteklas constructor. Als nGrowBytes nul bevat, bevat het gegenereerde bestand de gegevens uit de lpBuffer. De lengte van zo'n bestand is gelijk aan nBufferSize.
Als nGrowBytes groter is dan nul, wordt de inhoud van lpBuffer genegeerd. Als er bovendien meer gegevens naar een dergelijk bestand worden geschreven dan er in de toegewezen buffer passen, neemt de omvang ervan automatisch toe. Het geheugenblok van het bestand wordt vergroot met delen van nGrowBytes-bytes.
CMemBestandHiermee kunt u een verwijzing krijgen naar het geheugengebied dat door het bestand wordt gebruikt. Via deze pointer kunt u direct met de inhoud van het bestand werken, zonder u te beperken tot klassenmethodenCBestand. Om een verwijzing naar een bestandsbuffer te verkrijgen, kunt u de methode Detach gebruiken. Voordat u dit doet, is het handig om de lengte van het bestand (en dus de grootte van de geheugenbuffer) te bepalen door de methode aan te roepenLengte ophalen. Losmakensluit het gegeven bestand en retourneert een verwijzing naar het geheugenblok dat het gebruikt. Als u het bestand opnieuw moet openen en er een RAM-blok aan moet koppelen, moet u de methode aanroepenBijvoegen.Opgemerkt moet worden dat om de bestandsbuffer te beheren, de class
CMemBestandroept standaardfuncties opmalloc, realloc En vrij. Om het geheugenbeheermechanisme niet te verbreken, moet daarom de lpBuffer-buffer door de functies worden gemaaktmalloc of calloc.CStdioFile-klasse
Degenen die gewend zijn aan het gebruik van de stream I/O-functies uit de standaardbibliotheek C en C++ moeten op de klasse letten
CStdioBestand, geërfd van de basisklasseCBestand. Met deze klasse kunt u gebufferde I/O uitvoeren in tekst- en binaire modus. Voor klasseobjectenCStdioBestandJe kunt bijna alle methoden van de klasse CFile aanroepen.CStdioBestandbevat het gegevenselement m_pStream, dat een verwijzing naar het geopende bestand bevat. Als een klasseobjectCStdioBestandgemaakt, maar het bestand is nog niet geopend of gesloten, dan bevat m_pStream de constante NULL.CStdioBestandheeft drie verschillende constructeurs. De eerste constructor van de klasse CStdioFile heeft geen parameters. Deze constructor maakt alleen een klasseobject, maar opent geen bestanden. Om een bestand te openen, moet u de methode aanroepenOpenbasisklasseCBestand.Constructeur van de tweede klasse
CStdioBestandkan worden aangeroepen als het bestand al geopend is en u een nieuw object van de klasse CStdioFile moet maken en het geopende bestand eraan moet koppelen. Deze constructor kan worden gebruikt als het bestand met een standaardfunctie is geopendfopen. De methodeparameter moet een verwijzing bevatten naar het bestand dat wordt verkregen door het aanroepen van de standaardfunctiefopen.De derde constructor kan worden gebruikt als u een klasseobject moet maken
CStdioBestand, open een nieuw bestand en koppel het aan het nieuw gemaakte object.Voor het lezen van en schrijven naar een tekstbestand bevat de klasse CStdioFile twee nieuwe methoden:
LeesString En Schrijfreeks. Met de eerste methode kunt u een reeks tekens uit een bestand lezen, en met de tweede methode kunt u deze schrijven.Voorbeelden van schrijven en lezen vanuit een bestand
Hier volgen codefragmenten die het gebruik van standaarddialoogvensters voor bestandsselectie demonstreren en de procedure voor het lezen van en schrijven naar een bestand.
Een bestand openen en daaruit lezen
CString m_Text; ……// een standaard bestandsselectiepaneel maken Open CFileDialog DlgOpen(TRUE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY,(LPCSTR)" Tekstbestanden (*.txt) |*.txt||");// geef het standaardbestandsselectiepaneel weer Open if(DlgOpen.DoModal()==IDOK) (// maak een object en open het bestand om te lezen CStdioFile-bestand(DlgOpen.GetPathName(),CFile::modeRead|CFile::typeBinary);// tekenreeksen uit bestand lezen CString& ref=m_Text; File.ReadString(ref); // er wordt een verwijzing naar een string doorgegeven
CString m_Text; m_Tekst) Openen en schrijven vanuit een bestand // een standaard SaveAs-bestandsselectiepaneel maken CFileDialog DlgSaveAs(FALSE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, (LPCSTR)" Tekstbestanden (*.txt) |*.txt||"); // geef het standaard SaveAs-bestandsselectiepaneel weer if(DlgSaveAs.DoModal()==IDOK) ( // maak een object en open een bestand om te schrijven CStdioFile-bestand(DlgSaveAs.GetPathName(), CFile::modeCreate|CFile::modeWrite|CFile::typeBinary);- // schrijf naar een stringbestand
File.WriteString((LPCTSTR)m_Text);
)
bevat de werkende code van het programma, ontworpen voor eenvoud als consoletoepassing onder MFC. Om het programma te laten werken, vergeet niet het volgende te doen:
Voer het programma uit - Alles bouwen / opnieuw opbouwen (er zullen fouten zijn), selecteer Build / Set actieve configuratie - Win 32 Realise, selecteer het menu-item "Project", vervolgens "Instellingen...", het tabblad "C/C++", Categorie - Code genereren en selecteer in het item "Runtimebibliotheek gebruiken" "Multithreaded". Voer daarna Build / Rebuild all opnieuw uit en het programma zal werken.
Tekstbestanden
Laten we eens kijken naar het werken met een tekstbestand in C aan de hand van een voorbeeld. Maak een tekstbestand op station C met de naam TextFile.txt. Typ de volgende regels in dit bestand:
Tekenreeks_1 123 Tekenreeks_11, 456
Tekenreeks_2
Tekenreeks_3
En dit is de code voor een C-programma dat ons bestand opent en er regels uit leest:
/* *Auteur: @author Subbotin B.P.h> #include
Het eerste argument voor de fopen-functie verwijst naar een bestand, en het tweede zegt dat het bestand openstaat om daaruit te lezen.
We lezen de regels met behulp van de fgets-functie:
fgets(cArray, LEN, pTextFile);
Het eerste argument van de functie fgets verwijst naar een karakterarray waarin de ontvangen strings worden opgeslagen, het tweede argument is het maximale aantal te lezen karakters en het derde is ons bestand.
Nadat u klaar bent met het werken met het bestand, moet u het sluiten:
fclose(pTextBestand);
Wij krijgen:
In de regels verschijnen ook Russische letters.
Ik heb dit programma trouwens in Eclipse gemaakt. Hoe u met C/C++ kunt werken, ziet u in Eclipse.
Dus hebben we gegevens uit een tekstbestand geopend en gelezen.
Nu zullen we leren hoe we programmatisch een tekstbestand kunnen maken en er gegevens naartoe kunnen schrijven.
/* Auteur: @author Subbotin B.P..h> #include
Maak een tekstbestand om gegevens naar te schrijven:
BESTAND *pTextFile = fopen("C:\\TextFileW.txt", "w");
als het bestand al bestaat, wordt het geopend en worden alle gegevens ervan verwijderd.
De C-string cString en het getal nVal worden door het programma naar een tekstbestand geschreven. cNewLine is gewoon een nieuwe lijn.
We schrijven gegevens naar een tekstbestand met behulp van de fprintf-functie:
fprintf(pTextFile, "%s%c", cString, cNewLine);
het eerste argument hier is ons bestand, het tweede is de formatstring, het derde of meer is het aantal argumenten dat nodig is voor dit formaat.
Voor de programmeur wordt een open bestand weergegeven als een reeks gegevens die worden gelezen of geschreven. Wanneer een bestand wordt geopend, wordt het gekoppeld aan I/O-stroom . Uitvoerinformatie wordt naar de stream geschreven, invoerinformatie wordt uit de stream gelezen.
Wanneer een stream wordt geopend voor I/O, wordt deze geassocieerd met een standaard FILE-structuur, die is gedefinieerd in stdio.h. De FILE-structuur bevat de benodigde informatie over het bestand.
Het openen van een bestand gebeurt met behulp van de functie fopen(), die een verwijzing retourneert naar een structuur van het type FILE die kan worden gebruikt voor daaropvolgende bewerkingen op het bestand.
BESTAND *fopen(naam, type);
naam – naam van het bestand dat moet worden geopend (inclusief pad),
type - verwijzing naar een reeks tekens die definiëren hoe het bestand wordt geopend:
· "r" - open het bestand om te lezen (het bestand moet bestaan);
· "w" - open een leeg bestand om te schrijven; als het bestand bestaat, gaat de inhoud ervan verloren;
· "a" - open het bestand om naar het einde te schrijven (om toe te voegen); het bestand wordt aangemaakt als het niet bestaat;
· "r+" - open het bestand voor lezen en schrijven (het bestand moet bestaan);
· "w+" - open een leeg bestand om te lezen en te schrijven; als het bestand bestaat, gaat de inhoud ervan verloren;
· "a+" - open het bestand om te lezen en toe te voegen; het bestand bestaat niet, het is gemaakt.
De geretourneerde waarde is een verwijzing naar de open stream. Als er een fout wordt gedetecteerd, wordt NULL geretourneerd.
De functie fclose() sluit de stream of streams die zijn gekoppeld aan bestanden die zijn geopend met de functie fopen(). De te sluiten stream wordt bepaald door het argument van de functie fclose().
Retourwaarde: waarde 0 als de stream succesvol is afgesloten; constante EOF als er een fout is opgetreden.
#erbij betrekken
int hoofd()
char naam = "mijn.txt";
if(fp = fopen(naam, "r")!=NULL)
// was het mogelijk om het bestand te openen?
... // vereiste acties op gegevens
else printf("Kan bestand niet openen");
Een teken uit een bestand lezen:
char fgetc(stroom);
Het functieargument is een verwijzing naar een stroom van het type FILE. De functie retourneert de code van het gelezen teken. Als het einde van het bestand wordt bereikt of als er een fout optreedt, wordt de constante EOF geretourneerd.
Een symbool naar een bestand schrijven:
fputc(char, stroom);
De argumenten van de functie zijn een teken en een verwijzing naar een stroom van het type FILE. De functie retourneert de code van het gelezen teken.
De functies fscanf() en fprintf() zijn vergelijkbaar met de functies scanf() en printf(), maar werken met gegevensbestanden en hebben een verwijzing naar het bestand als eerste argument.
fscanf(stream, "Invoerformaat", argumenten);
fprintf(stream, "Uitvoerformaat", argumenten);
De functies fgets() en fputs() zijn ontworpen voor invoer/uitvoer van tekenreeksen; ze zijn analoog aan de functies get() en puts() voor het werken met bestanden.
fgets(aanwijzer naar regel, aantal tekens, stream);
Tekens worden uit de stream gelezen totdat een nieuweregelteken "\n" wordt gelezen, dat is opgenomen in de string, of totdat de stream EOF beëindigt of het maximale aantal tekens is gelezen. Het resultaat wordt in een stringpointer geplaatst en eindigt met het nulteken "\0". De functie retourneert het adres van de string.
fputs(aanwijzer naar string, stream);
Kopieert een string vanaf de huidige positie naar de stream. Het afsluitende nulteken wordt niet gekopieerd.
Voorbeeld
Voer het nummer in en sla het op in het bestand s1.txt. Lees het getal uit het bestand s1.txt, verhoog het met 3 en sla het op in het bestand s2.txt.
Werken met tekstbestanden in C++.
Er zijn twee hoofdtypen bestanden: tekst en binair. Met bestanden kan de gebruiker grote hoeveelheden gegevens rechtstreeks van de schijf lezen zonder deze via het toetsenbord in te voeren.
Tekst bestanden die uit willekeurige tekens bestaan, worden aangeroepen. Ze zijn georganiseerd in regels, die elk eindigen met een regeleindeteken. Het einde van het bestand zelf wordt aangegeven door het symbool "einde van bestand". Wanneer u informatie naar een tekstbestand schrijft, dat met elke teksteditor kan worden bekeken, worden alle gegevens geconverteerd naar een tekentype en in tekenvorm opgeslagen.
IN binair In bestanden wordt informatie gelezen en geschreven in de vorm van blokken van een bepaalde grootte, waarin gegevens van elk type en structuur kunnen worden opgeslagen.
Om met bestanden te werken, speciaal gegevenstypen, genaamd stromen. Stroom alsstroom wordt gebruikt om met bestanden te werken in de leesmodus, en vanstroom in opnamemodus. Om zowel in de schrijf- als in de leesmodus met bestanden te werken, wordt een stream gebruikt fstroom.
In C++-programma's moet u bij het werken met tekstbestanden de iostream- en fstream-bibliotheken opnemen.
Om te dossier gegevens naar een tekstbestand, hebt u nodig:
beschrijf een variabele van het type stroom.
informatie naar een bestand uitvoeren.
zorg ervoor dat u het bestand sluit.
Voor lezing gegevens uit een tekstbestand heeft u nodig:
beschrijf een variabele van het type ifstream.
open een bestand met de open-functie.
sluit het bestand.
Dossier informatie naar een tekstbestand
Zoals eerder vermeld, moet u, om met een tekstbestand te kunnen werken, een variabele van het type stream definiëren. Bijvoorbeeld zoals dit:
Er wordt een variabele F gemaakt om informatie naar het bestand te schrijven.
In de volgende fase moet het bestand worden geopend om te worden geschreven. Over het algemeen ziet de operator voor het openen van de stream er als volgt uit:
F.open("bestand", modus);
Hier is F een variabele die wordt beschreven als ofstream,
bestand - volledige naam van het bestand op schijf,
modus - modus van werken met het bestand dat wordt geopend.
Houd er rekening mee dat u bij het opgeven van de volledige bestandsnaam een dubbele schuine streep moet gebruiken. De volledige naam van het bestand noobs.txt, dat zich in de gamemap op station D: bevindt, moet bijvoorbeeld als volgt worden geschreven:
D:\\game\\noobs.txt.
Het bestand kan in een van de volgende modi worden geopend:
ios::in - open het bestand in de gegevensleesmodus, deze modus is de standaardmodus voor ifstreams;
ios::out - open een bestand in de gegevensschrijfmodus (in dit geval wordt informatie over het bestaande bestand vernietigd), deze modus is de standaardmodus voor ofstreams;
ios::app - open het bestand in de modus voor het schrijven van gegevens naar het einde van het bestand;
ios::ate - ga naar het einde van een reeds geopend bestand;
ios::trunc - wis het bestand, dit gebeurt ook in de ios::out-modus;
ios::nocreate - open geen bestand als het niet bestaat;
ios::noreplace - open geen bestaand bestand.
De modusparameter ontbreekt mogelijk. In dat geval wordt het bestand geopend in de standaardmodus voor deze stream.
Na het succesvol openen van het bestand (in welke modus dan ook), zal de variabele F waar opslaan, anders onwaar. Hiermee kunt u de juistheid van de bestandsopening controleren.
Je kunt een bestand (laten we het bestand D:\\game\\noobs.txt als voorbeeld nemen) in de opnamemodus op een van de volgende manieren openen:
// Eerst manier
stroomafwaarts F;
F.open("D:\\game\\noobs.txt", ios::out);
//tweede methode, ios::out-modus is de standaardmodus
// Voor stroomvanstroom
stroomafwaarts F;
//de derde methode combineert de beschrijving van de variabele en het streamtype
//en het bestand in één instructie openen
ofstream F("D:\\game\\noobs.txt", ios::out);
Nadat u het bestand in de schrijfmodus hebt geopend, wordt er een leeg bestand aangemaakt waarin u informatie kunt schrijven.
Als u een bestaand bestand in de modus voor schrijven eerst wilt openen, moet u ios::app als modus gebruiken.
Nadat u een bestand in de opnamemodus hebt geopend, kunt u er op dezelfde manier naar schrijven als naar het scherm, alleen in plaats van het standaard uitvoerapparaatuitu moet de naam van het geopende bestand opgeven.
Als u bijvoorbeeld variabele a naar stroom F wilt schrijven, ziet de uitvoerinstructie er als volgt uit:
Voor sequentiële uitvoer om G van variabelen b, c, d te streamen, ziet de uitvoeroperator er als volgt uit:
G< Het sluiten van een stream gebeurt met behulp van de operator: VOORBEELD: Maak een tekstbestand D:\\game\\noobs.txt en schrijf er n reële getallen in. #include "stdafx.h" #erbij betrekken #erbij betrekken #erbij betrekken naamruimte std gebruiken; int hoofd() setlocale(LC_ALL, "RUS"); int ik, n; dubbele een; // beschrijft een stream voor het schrijven van gegevens naar een bestand vanstroom
F;
//open het bestand in schrijfmodus, // modusios::
uitstandaard geïnstalleerd f.open("D:\\game\\noobs.txt", ios::out); //voer het aantal reële getallen in uit<<"
N=";
cin>>
N;
//loop voor het invoeren van reële getallen //en schrijf ze naar een bestand voor (i=0; ik uit<<"a=";
//voer een getal in cin>>a; F< //de stroom sluiten f.sluiten(); systeem("pauze"); retour 0; _______________________________________________________________ Om informatie uit een tekstbestand te kunnen lezen, moet je een variabele beschrijven, zoals alsstroom. Hierna moet u het bestand openen om te lezen met behulp van de operator open. Als de variabele F heet, zullen de eerste twee uitspraken er als volgt uitzien: F.open("D:\\game\\noobs.txt", ios::in); Nadat u een bestand in de leesmodus hebt geopend, kunt u er op dezelfde manier informatie uit lezen als via het toetsenbord, alleen in plaats vancingeef de naam op van de stream waaruit gegevens worden gelezen. Om bijvoorbeeld van stroom F naar variabele a te lezen, zou de invoerinstructie er als volgt uitzien: Twee cijfers in een teksteditor worden als gescheiden beschouwd als er minstens één van de tekens tussen zit: spatie, tab, einde van de regel. Het is goed als de programmeur van tevoren weet hoeveel en welke waarden hij in het tekstbestand moet opslaan. Vaak is het type waarden dat in het bestand is opgeslagen echter eenvoudigweg bekend, maar het aantal kan variëren. Om dit probleem op te lossen, moet u de waarden één voor één uit het bestand lezen en vóór elke lezing controleren of het einde van het bestand is bereikt. Hier bestaat een functie voor F.
eof().
Hier is F de naam van de thread, de functie retourneert een Booleaanse waarde: waar of onwaar, afhankelijk van of het einde van het bestand is bereikt. Daarom kan een lus om de inhoud van het hele bestand te lezen als volgt worden geschreven: //organize voor het lezen van waarden uit een bestand, uitvoering //de lus zal breken wanneer we het einde van het bestand bereiken, // in dit geval zal F.eof() waar retourneren terwijl (!F.eof()) VOORBEELD: Het tekstbestand D:\\game\\noobs.txt slaat reële getallen op, geeft ze op het scherm weer en berekent hun getal. #include "stdafx.h" #erbij betrekken #erbij betrekken #erbij betrekken #erbij betrekken naamruimte std gebruiken; int hoofd() setlocale(LC_ALL, "RUS"); int n=0; zweven een; fstream F; //open het bestand in leesmodus F.open("D:\\game\\noobs.txt"); //als het bestand correct is geopend, dan //loop voor het lezen van waarden uit een bestand; de uitvoering van de lus wordt onderbroken, //wanneer we het einde van het bestand bereiken, zal F.eof() in dit geval waar retourneren. terwijl (!F.eof()) //lezen van de volgende waarde uit stroom F in variabele a F >>a; // voer de waarde van variabele a uit naar het scherm uit< //verhoog het aantal gelezen getallen //de stroom sluiten F.sluiten(); // voer op het scherm het aantal gelezen cijfers in uit<<"n="< //Als het openen van het bestand onjuist was, dan wordt de uitvoer // berichten over de afwezigheid van een dergelijk bestand anders kuif<<" Файл не существует"< systeem("pauze"); retour 0; C++. Binaire bestandsverwerking Wanneer u informatie naar een binair bestand schrijft, worden tekens en cijfers geschreven als een reeks bytes. Om te schrijf op gegevens naar een binair bestand, hebt u het volgende nodig: beschrijf een bestandsvariabele van het type FAIL * met behulp van de FILE *filename-operator; Hier is bestandsnaam de naam van de variabele waarin de verwijzing naar het bestand wordt opgeslagen. schrijf informatie naar een bestand met behulp van de fwrite-functie Om te overwegen b-gegevens uit een binair bestand heeft u nodig: beschrijf een variabele van het type FILE * open een bestand met de fopen-functie sluit een bestand met de functie fclose Basisfuncties die nodig zijn om met binaire bestanden te werken. Voor openingen Het bestand is bedoeld voor de fopen-functie. BESTAND *fopen(const *bestandsnaam, const char *modus) Hier is bestandsnaam een string die de volledige naam opslaat van het bestand dat wordt geopend, mode is een string die de modus bepaalt voor het werken met het bestand; de volgende waarden zijn mogelijk: “rb” - open het binaire bestand in leesmodus; "wb" - maak een binair bestand voor opname; als het bestaat, wordt de inhoud ervan gewist; “ab” - maak of open een binair bestand om aan het einde van het bestand toe te voegen; “rb+” - open een bestaand binair bestand in lees-schrijfmodus; “wb+” - open het binaire bestand in de lees-schrijfmodus, het bestaande bestand wordt gewist; "ab+" - een binair bestand wordt geopend of gemaakt om bestaande informatie te corrigeren en nieuwe informatie aan het einde van het bestand toe te voegen. De functie retourneert de NULL-waarde in de bestandsvariabele f als het openen van het bestand mislukt. Na het openen van een bestand is de 0e byte beschikbaar, de bestandsaanwijzer is 0, waarvan de waarde, wanneer deze wordt gelezen of geschreven, wordt verschoven met het aantal gelezen (geschreven) bytes. De huidige waarde van de bestandsaanwijzer is het bytenummer vanaf waar de lees- of schrijfbewerking zal plaatsvinden. Voor sluiten het bestand is bedoeld voor de fclose-functie int fclose(BESTAND *bestandsnaam); Retourneert 0 als het bestand succesvol is gesloten, anders NULL. De verwijderfunctie is voor verwijdering bestanden. int remove(const char *bestandsnaam); Deze functie verwijdert een bestand met de naam filenema van schijf. Het te verwijderen bestand moet worden gesloten. De functie retourneert een waarde die niet nul is als het bestand niet kan worden verwijderd. Voor hernoemen bestanden is de hernoemingsfunctie bedoeld: int rename(const char *oudebestandsnaam, const char *nieuwebestandsnaam); De eerste parameter is de oude bestandsnaam, de tweede is de nieuwe. Geeft 0 terug als het programma succesvol wordt beëindigd. Lezing vanuit een binair bestand wordt gedaan met behulp van de fread-functie: fread(void *ptr, grootte, n, BESTAND *bestandsnaam); De fread-functie leest n elementen van groottegrootte uit de bestandsnaam naar een array ptr. De functie retourneert het aantal gelezen elementen. Na het lezen uit een bestand wordt de aanwijzer ervan verschoven met n*size bytes. Dossier naar een binair bestand wordt gedaan met behulp van de fwrite-functie: fwrite(const void *ptr, grootte, n, BESTAND *bestandsnaam); De fwrite-functie schrijft naar de bestandsnaam vanuit een array ptr van n elementen van grootte. De functie retourneert het aantal geschreven elementen. Nadat informatie naar het bestand is geschreven, wordt de aanwijzer met n*size bytes verschoven. Voor controle op het einde van het bestand er is een functie feof: int feof(BESTAND *bestandsnaam); Het retourneert een waarde die niet nul is als het einde van het bestand wordt bereikt. VOORBEELD: Maak een binair bestand D:\\game\\noobs.dat en schrijf n gehele getallen en n reële getallen daarin. #include "stdafx.h" #erbij betrekken naamruimte std gebruiken; int hoofd() setlocale(LC_ALL, "RUS"); int n, ik; dubbele een; //maak een binair bestand in de schrijfmodus f=fopen("D:\\game\\noobs.dat", "wb"); //
invoer
cijfersN uit<<"n=";
cin>>n; fwrite(&n, groottevan(int), 1, f); //loop om n reële getallen in te voeren voor (i=0; ik //voer het volgende reële getal in uit<<"a=";
cin>>a; //een reëel getal naar een binair bestand schrijven fwrite(&a, groottevan(dubbel), 1, f); //
dichtbij
bestand fsluiten(f); systeem("pauze"); retour 0; VOORBEELD: Geef de inhoud weer van het binaire bestand D:\\game\\noobs.dat dat in de vorige taak is gemaakt #include "stdafx.h" #erbij betrekken naamruimte std gebruiken; int hoofd() setlocale(LC_ALL, "RUS"); int n, ik; dubbel *a; BESTAND *f; //beschrijf de bestandsvariabele //open bestaand binair bestand in leesmodus //lees één geheel getal uit het bestand in variabele n // uitvoer n naar scherm uit<<"n="< // geheugen toewijzen voor een array van n getallen a=nieuw dubbel[n]; //lees n reële getallen uit bestand in array a // voer de array uit naar het scherm voor (i=0; ik uit< uit< //
dichtbij
bestand fsluiten(f); systeem("pauze"); retour 0; Binair bestand- sequentiële datastructuur, na het openen van een bestand is de eerste daarin opgeslagen byte beschikbaar. U kunt gegevens opeenvolgend uit een bestand schrijven of lezen. Laten we zeggen dat je het vijftiende getal moet tellen, en dan het eerste. Met behulp van sequentiële toegang kan dit op de volgende manier: int n, ik; dubbele een; BESTAND *f; f=fopen("D:\\game\\noobs.dat", "rb"); voor (i=0; ik<15; i++)
fsluiten(f); f=fopen("D:\\game\\noobs.dat", "rb"); fread(&a, groottevan(dubbel), 1, f); fsluiten(f); Zoals u kunt zien, is het lezen van getallen uit een bestand en het vervolgens opnieuw openen van het bestand niet de handigste manier. Het zal veel handiger zijn om de fseek-functie te gebruiken om de bestandsaanwijzer naar een bepaalde byte te verplaatsen. int fseek(BESTAND *bestandsnaam, lange int offset, int oorsprong); De functie stelt de huidige bestandspositiewijzer F in in overeenstemming met de oorsprong- en offsetwaarden. De offsetparameter is gelijk aan het aantal bytes waarmee de bestandsaanwijzer wordt verschoven ten opzichte van de oorsprong die is opgegeven door de originparameter. De waarde voor de origin-parameter moet een van de volgende offsetwaarden zijn die zijn gedefinieerd in de stdio.h-header: SEEK_SET - vanaf het begin van het bestand; SEEK_CUR - vanaf de huidige positie; SEEK_END - vanaf het einde van het bestand. De functie retourneert een nulwaarde als de bewerking succesvol was, en niet-nul als er een fout is opgetreden tijdens de uitvoering van de offset De fseek-functie implementeert feitelijk directe toegang tot elke waarde in een bestand. U hoeft alleen de locatie (bytenummer) van de waarde in het bestand te weten. Laten we eens kijken naar het gebruik van directe toegang in binaire bestanden, waarbij we het volgende probleem als voorbeeld gebruiken. VOORBEELD In het eerder gemaakte binaire bestand D:\\game\\noobs.dat wissel je de grootste en kleinste reële getallen om. Het algoritme voor het oplossen van het probleem bestaat uit de volgende fasen: Reals uit een bestand lezen in array a. zoek in array a naar de maximale (max) en minimale (min) waarden en hun aantallen (imax, imin). het verplaatsen van de bestandsaanwijzer naar de maximale waarde en het schrijven van min. de bestandsaanwijzer naar de minimumwaarde verplaatsen en max. Hieronder vindt u de tekst van het programma voor het oplossen van het probleem met opmerkingen. #include "stdafx.h" #erbij betrekken naamruimte std gebruiken; int hoofd() setlocale(LC_ALL, "RUS"); int n, ik, imax, imin; dubbel *a, max, min; BESTAND *f; //open een bestand in lees-schrijfmodus f=fopen("D:\\game\\noobs.dat", "rb+"); //lees nummer uit bestand in variabele n //reële getallen in het bestand fread(&n, groottevan(int), 1, f); uit<<"n="< // wijs geheugen toe voor het opslaan van reële getallen, //die wordt opgeslagen in array a a=nieuw dubbel[n]; //lees van bestand naar array en reële getallen fread(a, groottevan(dubbel), n, f); //zoek naar maximale en minimale elementen //in de array a en hun indices voor (imax=imin=0, max=min=a, i=1; i als (a[i]>max) max=a[i]; als (een[ik] min=a[ik]; //
bewegen
wijzer
Naar
maximaal
element fseek(f, groottevan(int)+imax*groottevan(dubbel), SEEK_SET); //schrijf min in plaats van maximum bestandselement fwrite(&min, groottevan(dubbel), 1, f); //
bewegen
wijzer
Naar
minimum
element fseek(f, groottevan(int)+imin*groottevan(dubbel), SEEK_SET); //record max in plaats van het minimum bestandselement fwrite(&max, groottevan(dubbel), 1, f); //het bestand sluiten fsluiten(f); //vrij geheugen verwijderen [
]A; systeem("pauze"); De meeste computerprogramma's werken met bestanden en daarom is het nodig om bestanden te maken, verwijderen, schrijven, lezen en openen. Wat is een bestand? Een bestand is een benoemde set bytes die op een bepaald opslagapparaat kan worden opgeslagen. Welnu, nu is het duidelijk dat een bestand een bepaalde reeks bytes betekent die zijn eigen unieke naam heeft, bijvoorbeeld file.txt. Bestanden met dezelfde naam kunnen niet in dezelfde map worden geplaatst. De bestandsnaam verwijst niet alleen naar de naam, maar ook naar de extensie, bijvoorbeeld: file.txt en file.dat —
verschillende bestanden, ook al hebben ze dezelfde naam. Er bestaat zoiets als een volledige bestandsnaam - dit is het volledige adres van de bestandsmap die de bestandsnaam aangeeft, bijvoorbeeld: D:\docs\file.txt. Het is belangrijk om deze basisconcepten te begrijpen, anders wordt het lastig om met bestanden te werken. Om met bestanden te werken, moet u een headerbestand toevoegen Bestands-I/O is vergelijkbaar met standaard-I/O, het enige verschil is dat de I/O wordt uitgevoerd naar een bestand in plaats van naar het scherm. Als I/O naar standaardapparaten wordt uitgevoerd met behulp van de cin- en cout-objecten, dan is het voor het organiseren van bestands-I/O voldoende om uw eigen objecten te maken die op dezelfde manier kunnen worden gebruikt als de cin- en cout-operatoren. U moet bijvoorbeeld een tekstbestand maken en daarin de regel Werken met bestanden in C++ schrijven. Om dit te doen moet u de volgende stappen ondernemen: Waarom is het nodig om een ofstream-object te maken in plaats van een ifstream-object? Omdat u naar een bestand moet schrijven en als u gegevens uit een bestand moet lezen, wordt er een ifstream-klasseobject gemaakt. // maak een object om naar het bestand ofstream /*objectnaam*/ te schrijven; // object van de klasse ofstream Laten we het object fout noemen. Dit is wat we krijgen: Offstream-fout; Waarom hebben we een voorwerp nodig? Het object is vereist om naar een bestand te kunnen schrijven. Het object is al gemaakt, maar is niet gekoppeld aan het bestand waarin de string moet worden geschreven. Fout.open("cppstudio.txt"); // koppel het object aan het bestand Via de puntbewerking krijgen we toegang tot de klassemethode open(), waarin we de bestandsnaam tussen haakjes aangeven. Het opgegeven bestand wordt met het programma in de huidige map gemaakt. Als er een bestand met dezelfde naam bestaat, wordt het bestaande bestand vervangen door het nieuwe. Het bestand is dus geopend, het enige dat overblijft is om de vereiste regel erin te schrijven. Dit wordt als volgt gedaan: Fout<< "Работа с файлами в С++"; // запись строки в файл
Door gebruik te maken van de stream-bewerking in combinatie met het vierde object, wordt de string Werken met bestanden in C++ naar een bestand geschreven. Omdat het niet langer nodig is om de inhoud van het bestand te wijzigen, moet het worden gesloten, dat wil zeggen dat het object moet worden gescheiden van het bestand. Fout.close(); // sluit het bestand Resultaat - er is een bestand gemaakt met de regel Werken met bestanden in C++. Stappen 1 en 2 kunnen worden gecombineerd, dat wil zeggen: op één regel een object maken en dit aan een bestand koppelen. Dit wordt als volgt gedaan: Ofstream fout("cppstudio.txt"); // maak een object van de klasse ofstream en koppel het aan het bestand cppstudio.txt Laten we alle code combineren en het volgende programma krijgen. // file.cpp: Definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include Het blijft nodig om te controleren of het programma correct werkt, en om dit te doen, opent u het bestand cppstudio.txt en kijk naar de inhoud, het zou moeten zijn - Werken met bestanden in C++. Het programma laat twee manieren zien om uit een bestand te lezen: de eerste gebruikt de overdrachtsbewerking naar een stream, de tweede gebruikt de functie getline() . In het eerste geval wordt alleen het eerste woord gelezen en in het tweede geval wordt een reeks van 50 tekens gelezen. Maar omdat er minder dan 50 tekens in het bestand staan, worden de tekens tot en met de laatste gelezen. Houd er rekening mee dat het lezen van de tweede keer (lijn 17) ging verder na het eerste woord, en niet vanaf het begin, aangezien het eerste woord was ingelezenlijn 14. Het resultaat van het programma wordt weergegeven in Figuur 1. Werken met bestanden in C++ Druk op een willekeurige toets om door te gaan. . . Figuur 1 - Werken met bestanden in C++ Het programma werkte correct, maar dit gebeurt niet altijd, ook al is alles in orde met de code. De naam van een niet-bestaand bestand is bijvoorbeeld aan het programma doorgegeven of er zit een fout in de naam. Wat dan? In dit geval zal er helemaal niets gebeuren. Het bestand wordt niet gevonden en kan dus niet worden gelezen. Daarom negeert de compiler regels waar aan het bestand wordt gewerkt. Als gevolg hiervan wordt het programma correct afgesloten, maar wordt er niets op het scherm weergegeven. Het lijkt erop dat dit een volkomen normale reactie op een dergelijke situatie is. Maar een eenvoudige gebruiker zal niet begrijpen wat er aan de hand is en waarom de regel uit het bestand niet op het scherm verscheen. Om alles heel duidelijk te maken, biedt C++ zo'n functie - is_open(), die gehele waarden retourneert: 1 - als het bestand succesvol is geopend, 0 - als het bestand niet is geopend. Laten we het programma aanpassen door een bestand te openen, zodat als het bestand niet geopend is, een bijbehorend bericht wordt weergegeven. // file_read.cpp: Definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include Het resultaat van het programma wordt getoond in Figuur 2. Het bestand kan niet worden geopend! Druk op een willekeurige toets om door te gaan. . . Figuur 2 - Werken met bestanden in C++ Zoals te zien is in Figuur 2, rapporteerde het programma dat het onmogelijk was om het bestand te openen. Als het programma met bestanden werkt, wordt het daarom aanbevolen om deze functie is_open() te gebruiken, zelfs als u zeker weet dat het bestand bestaat. Bestandsopeningsmodi bepalen hoe bestanden worden gebruikt. Om de modus in te stellen, biedt de klasse ios_base constanten die de openingsmodus van het bestand bepalen (zie Tabel 1). Bestandsopeningsmodi kunnen rechtstreeks worden ingesteld bij het maken van een object of bij het aanroepen van de functie open(). .
Ofstream fout("cppstudio.txt", ios_base::app); // open het bestand om informatie toe te voegen aan het einde van het bestand fout.open("cppstudio.txt", ios_base::app); // open het bestand om informatie aan het einde van het bestand toe te voegen Bestandsopeningsmodi kunnen worden gecombineerd met behulp van een bitsgewijze logische bewerking of| , bijvoorbeeld: ios_base::out | ios_base::trunc - opent een bestand om te schrijven nadat het is gewist. Objecten van de klasse ofstream bevatten, wanneer ze aan bestanden zijn gekoppeld, standaard de bestandsopeningsmodi ios_base::out | ios_base::trunc .
Dat wil zeggen dat het bestand wordt aangemaakt als het niet bestaat. Als het bestand bestaat, wordt de inhoud ervan verwijderd en is het bestand zelf klaar om te worden geschreven. Objecten van de ifstream-klasse hebben, wanneer ze aan een bestand zijn gekoppeld, de standaard bestandsopeningsmodus ios_base::in - het bestand is alleen-lezen geopend. De bestandsopeningsmodus wordt ook wel een vlag genoemd voor de leesbaarheid, deze term zullen we in de toekomst gebruiken. Tabel 1 vermeldt niet alle vlaggen, maar deze zouden voldoende moeten zijn om u op weg te helpen. Merk op dat de ate- en app-vlaggen qua beschrijving erg op elkaar lijken, ze verplaatsen allebei de aanwijzer naar het einde van het bestand, maar de app-vlag staat alleen schrijven naar het einde van het bestand toe, en de ate-vlag verplaatst de vlag eenvoudigweg naar het einde van het bestand en beperkt niet waar te schrijven. Laten we een programma ontwikkelen dat, met behulp van de bewerking sizeof(), de kenmerken van de belangrijkste gegevenstypen in C++ berekent en deze naar een bestand schrijft. Specificaties: Het bestand moet in het volgende formaat worden geschreven: /* gegevenstype byte maximale waarde bool = 1 255.00 char = 1 255.00 short int = 2 32767.00 unsigned short int = 2 65535.00 int = 4 2147483647.00 unsigned int = 4 4294967295.00 long int = 4 .00 unsigned long int = 4 4294967295.00 vlotter = 4 2147483647.00 lang vlotter = 8 9223372036854775800.00 dubbel = 8 9223372036854775800.00 */ Een dergelijk programma is al eerder in de sectie ontwikkeld, maar daar werd alle informatie over gegevenstypen uitgevoerd naar het standaarduitvoerapparaat, en we moeten het programma opnieuw maken zodat de informatie naar een bestand wordt geschreven. Om dit te doen, moet u het bestand in de schrijfmodus openen, met voorlopige afkapping van de huidige bestandsinformatie ( lijn 14). Zodra het bestand is gemaakt en met succes is geopend (regels 16 - 20), wordt in plaats van de cout-instructie in lijn 22 we gebruiken het fout-object. dus in plaats van naar het scherm wordt de gegevenstype-informatie naar een bestand geschreven. // write_file.cpp: Definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include Het is onmogelijk om niet op te merken dat de veranderingen in het programma minimaal zijn, en dat allemaal dankzij het feit dat standaardinvoer/uitvoer en bestandsinvoer/uitvoer op precies dezelfde manier worden gebruikt. Aan het einde van het programma, omlijn 45We hebben het bestand expliciet gesloten, hoewel dit niet noodzakelijk is, maar het wordt beschouwd als een goede programmeerpraktijk. Het is vermeldenswaard dat alle functies en manipulatoren die worden gebruikt om standaardinvoer/uitvoer te formatteren ook relevant zijn voor bestandsinvoer/uitvoer. Daarom zijn er geen fouten opgetreden bij het uitvoeren van de instructie uit werd vervangen door een voorwerp fout.
// file_read.cpp: Definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include Modi voor het openen van bestanden
