1. Werken met bestanden in C (werkt ook in C++)..

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 doe je door de functie fclose ( fsluiten(bestand);).

Werken met bestanden met behulp van MFC (klassen CFile, CStdioFile, ...) en de standaard MFC-klasse CFileDialog.

Klasse CF-ile

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:

• CFile::modeCreate - Maakt een nieuw bestand. Als het opgegeven bestand bestaat, wordt de inhoud ervan gewist en wordt de bestandslengte op nul gezet.
• CFile::modeNoTruncate - Dit bestand is bedoeld om te worden gebruikt in combinatie met het bestand CFile::modeCreate. Als een bestaand bestand wordt aangemaakt, wordt de inhoud ervan niet verwijderd.

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.

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.

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.

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, wordt er door de methoden een beroep gedaan op de afhandeling van uitzonderingen.

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.

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.

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.

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.

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.

)

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:

Tekenreeks_1 123 Tekenreeks_11, 456
Tekenreeks_2
Tekenreeks_3

Sla het bestand op.

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 #define LEN 50 int main(void) ( puts("Tekstbestandsbewerkingen"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( puts("Problemen"); return EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile);

Om een ​​tekstbestand in C te openen, gebruik je de fopen-functie:

BESTAND *pTextFile = fopen("C:\\TextFile.txt", "r");

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 int main(void) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "Dit is een string"; char cNewLine = "\n"; int nVal = 123 ; if(pTextFile == NULL) ( puts("Problemen"); return EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine);

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 gemakkelijke toegang wordt informatie op opslagapparaten opgeslagen in de vorm van bestanden.

Een bestand is een benoemd gebied van extern geheugen dat is toegewezen voor het opslaan van een reeks gegevens. De gegevens in de bestanden zijn van zeer uiteenlopende aard: programma's in algoritmische of machinetaal; initiële gegevens voor programmawerking of programma-uitvoeringsresultaten; vrije teksten; grafische afbeeldingen, enz.

Directory (map, map) - een benoemde verzameling bytes op een opslagmedium met de namen van submappen en bestanden, gebruikt in het bestandssysteem om de organisatie van bestanden te vereenvoudigen.

Bestandssysteem het functionele deel van het besturingssysteem genoemd dat bewerkingen op bestanden uitvoert. Voorbeelden van bestandssystemen zijn FAT (FAT – File Allocation Table), NTFS, UDF (gebruikt op cd's).

Er zijn drie hoofdversies van FAT: FAT12, FAT16 en FAT32. Ze verschillen in de bitdiepte van records in de schijfstructuur, d.w.z. het aantal bits dat is toegewezen om het clusternummer op te slaan. FAT12 wordt voornamelijk gebruikt voor diskettes (tot 4 KB), FAT16 – voor schijven met een kleine capaciteit, FAT32 – voor FLASH-drives met hoge capaciteit (tot 32 GB).

Laten we eens kijken naar de structuur van het bestandssysteem met FAT32 als voorbeeld.

FAT32-bestandsstructuur

Externe geheugenapparaten in het FAT32-systeem hebben blokadressering in plaats van byte-adressering. Informatie wordt in blokken of sectoren naar een extern geheugenapparaat geschreven.

Een sector is de minimaal adresseerbare eenheid voor informatieopslag op externe opslagapparaten. Normaal gesproken is de sectorgrootte vastgesteld op 512 bytes. Om de adresruimte van externe geheugenapparaten te vergroten, worden sectoren gecombineerd in groepen die clusters worden genoemd.

Een cluster is een vereniging van meerdere sectoren, die als een zelfstandige eenheid met bepaalde eigenschappen kan worden beschouwd. De belangrijkste eigenschap van een cluster is de grootte ervan, gemeten in het aantal sectoren of aantal bytes.

Het FAT32-bestandssysteem heeft de volgende structuur.

De clusters die worden gebruikt voor het schrijven van bestanden zijn genummerd vanaf 2. In de regel wordt cluster nr. 2 gebruikt door de hoofdmap, en vanaf cluster nr. 3 wordt de data-array opgeslagen. Sectoren die worden gebruikt om informatie boven de hoofdmap op te slaan, zijn niet geclusterd.
De minimaal vereiste bestandsgrootte op schijf komt overeen met 1 cluster.

De opstartsector begint met de volgende informatie:

• EB 58 90 – onvoorwaardelijke sprong en handtekening;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
• 00 02 – aantal bytes in de sector (meestal 512);
• 1 byte – aantal sectoren in het cluster;
• 2 bytes – aantal reservesectoren.

Bovendien bevat de opstartsector de volgende belangrijke informatie:

• 0x10 (1 byte) – aantal FAT-tabellen (meestal 2);
• 0x20 (4 bytes) – aantal sectoren op de schijf;
• 0x2С (4 bytes) – clusternummer van de hoofdmap;
• 0x47 (11 bytes) – volumelabel;
• 0x1FE (2 bytes) – handtekening van de opstartsector (55 AA).

De bestandssysteeminformatiesector bevat:

• 0x00 (4 bytes) – handtekening (52 52 61 41);
• 0x1E4 (4 bytes) – handtekening (72 72 41 61);
• 0x1E8 (4 bytes) – aantal vrije clusters, -1 indien onbekend;
• 0x1EC (4 bytes) – nummer van het laatst opgenomen cluster;
• 0x1FE (2 bytes) – handtekening (55 AA).

De FAT-tabel bevat informatie over de status van elk cluster op de schijf. De onderste 2 bytes van de FAT-tabel slaan F8 FF FF 0F FF FF FF FF op (wat overeenkomt met de status van clusters 0 en 1, die fysiek afwezig zijn). Vervolgens bevat de status van elk cluster het nummer van het cluster waarin het huidige bestand verdergaat of de volgende informatie:

• 00 00 00 00 – cluster is gratis;
• FF FF FF 0F – einde van het huidige bestand.

• 8 bytes – bestandsnaam;
• 3 bytes – bestandsextensie;

De hoofdmap bevat een reeks 32-bits informatierecords over elk bestand, met de volgende informatie:

Wanneer u met lange bestandsnamen werkt (inclusief Russische namen), wordt de bestandsnaam gecodeerd met behulp van het UTF-16-coderingssysteem. In dit geval worden 2 bytes toegewezen voor het coderen van elk teken. In dit geval wordt de bestandsnaam in de volgende structuur geschreven:

• 1 sequentiebyte;
• 10 bytes bevatten de onderste 5 tekens van de bestandsnaam;
• 1 byte attribuut;
• 1 byte gereserveerd;
• 1 byte – DOS-naamcontrolesom;
• 12 bytes bevatten de onderste 3 tekens van de bestandsnaam;
• 2 bytes – nummer van het eerste cluster;
• de resterende tekens van de lange naam.

Werken met bestanden in C-taal

Voor de programmeur wordt een geopend 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 FILE-structuur die kan worden gebruikt voor daaropvolgende bewerkingen op het bestand.

BESTAND *fopen(naam, type);

• "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, dan wordt het gemaakt.

De retourwaarde is een verwijzing naar de open stream. Als er een fout optreedt, 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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#erbij betrekken
int hoofd() (
BESTAND *fp;
char naam = "mijn.txt";
if ((fp = fopen(naam, "r" )) == NULL )
{
printf( "Kan bestand niet openen");
getchar();
retour 0;
}
// slaagde erin het bestand te openen
... // vereiste acties op gegevens
fsluiten(fp);
getchar();
retour 0;
}

Een teken uit een bestand lezen:

char fgetc(stroom);

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, "InputFormat", argumenten);

Het I/O-mechanisme dat is ontwikkeld door , voldoet niet aan de algemeen aanvaarde stijl van objectgeoriënteerd programmeren van vandaag. Bovendien maakt het intensief gebruik van pointer-operaties, die als potentieel onveilig worden beschouwd in moderne, veilige code-uitvoeringsomgevingen. Een alternatief bij het ontwikkelen van applicatieapplicaties is het mechanisme van standaard I/O-klassen dat wordt geboden door de taalstandaard C++.

Bestanden openen

De meest gebruikte klassen zijn ifstream voor lezen, ofstream voor schrijven en fstream voor het wijzigen van bestanden.

Alle threaded I/O-klassen zijn indirect afgeleid van de gemeenschappelijke voorloper ios en nemen de functionaliteit ervan volledig over. De bestandsopeningsmodus wordt dus gespecificeerd door het gegevenslid van het opgesomde type open_mode, dat als volgt is gedefinieerd:

Enum open_mode (app, binair, in, uit, trunc, at);

Hieronder staan ​​de mogelijke waarden van de vlaggen en hun doel.

Als u bijvoorbeeld een bestand met de naam test.txt wilt openen om gegevens in binaire vorm te lezen, schrijft u het volgende:

ifstream-bestand; file.open("test.txt", ios::in | ios::binair);

Met de logische OR-operator (|) kunt u een modus creëren met elke combinatie van vlaggen. Om ervoor te zorgen dat u bij het openen van een bestand door invoer niet per ongeluk een bestaand bestand met dezelfde naam overschrijft, moet u het volgende formulier gebruiken:

Ofstream-bestand; file.open("test.txt", ios::out | ios::app);

Er wordt aangenomen dat het bijbehorende headerbestand in het project is opgenomen:

#erbij betrekken

Om te controleren of het bestand succesvol is geopend, kunt u de constructie gebruiken

If (!file) ( //Afhandeling bij het openen van bestanden)

Inclusie- en extractieoperatoren

Overschreven in bestandsverwerkingsklassen inclusie-operator (<<) записывает данные в файловый поток. Как только вы открыли файл для записи, можно записывать в него текстовую строку целиком:

Bestand<< "Это строка текста";

U kunt een tekstreeks ook in delen schrijven:

Bestand<< "Это " << "строка " << "текста";

De endl-instructie beëindigt de regelinvoer met een harde return:

Bestand<< "Это строка текста" << endl;

Met behulp van de include-operator is het eenvoudig om de waarden van variabelen of array-elementen naar een bestand te schrijven:

Ofstream-bestand("Temp.txt"); char buff = "Tekstmatrix bevat variabelen"; int vx = 100; vlotter pi = 3,14159; bestand<< buff << endl << vx << endl << pi << endl;

Als resultaat van het uitvoeren van de code worden drie regels van het tekstbestand Temp.txt gevormd:

De tekstarray bevat variabelen 100 3.14159

Houd er rekening mee dat numerieke waarden naar het bestand worden geschreven als tekstreeksen in plaats van als binaire waarden.

Ophaaloperator(>>) levert het tegenovergestelde effect op. Het lijkt erop dat als je tekens uit het eerder geschreven Temp.txt-bestand wilt extraheren, je code als de volgende schrijft:

Ifstream-bestand("Temp.txt"); char buff; int vx; zwevende pi; bestand >> buff >> vx >> pi;

De extractieoperator stopt echter bij het eerste scheidingsteken dat hij tegenkomt (spatie, tab of nieuwe regel). Dus bij het parseren van de zin “Tekstarray bevat variabelen”, wordt alleen het woord “Tekst” naar de buff-array geschreven, de spatie wordt genegeerd en het woord “array” wordt de waarde van de gehele vx-variabele, en code de uitvoering zal “mislopen” met onvermijdelijke schending van de datastructuur. Vervolgens zullen we bij het bespreken van de ifstream-klasse laten zien hoe u het lezen van het bestand uit het vorige voorbeeld op de juiste manier kunt organiseren.

ifstream-klasse: bestanden lezen

Zoals de naam al doet vermoeden, is de ifstream-klasse ontworpen om een ​​bestandsstroom in te voeren. De belangrijkste methoden van de klasse worden hieronder vermeld. De meeste zijn overgenomen van de istream-klasse en overbelast om de bovenliggende functionaliteit uit te breiden. De get-functie kan bijvoorbeeld, afhankelijk van de aanroepparameter, niet alleen een enkel teken lezen, maar ook een blok tekens.

Nu is het duidelijk hoe het vorige voorbeeld moet worden aangepast, zodat het gebruik van de data-extractieoperator het verwachte resultaat oplevert:

Ifstream-bestand("Temp.txt"); char buff; int vx; zwevende pi; file.getline(buff, sizeof(buff)); bestand >> vx >> pi:

De getline-methode leest de eerste regel van het bestand tot het einde, en de >>-operator wijst waarden toe aan de variabelen.

In het volgende voorbeeld ziet u hoe u gegevens toevoegt aan een tekstbestand en vervolgens het hele bestand leest. Er wordt een while(1)-lus gebruikt in plaats van while(!file2.eof()) om redenen die worden besproken in .

#erbij betrekken #erbij betrekken naamruimte std gebruiken; int main() ( ofstream bestand; file.open("test.txt",ios::out|ios::app); if (!file) ( cout<< "File error - can"t open to write data!"; cin.sync(); cin.get(); return 1; } for (int i=0; i<10; i++) file << i << endl; file.close(); ifstream file2; file2.open("test.txt", ios::in); if (!file2) { cout << "File error - can"t open to read data!"; cin.sync(); cin.get(); return 2; } int a,k=0; while (1) { file2 >> een;<< a << " "; k++; } cout << endl << "K=" << k << endl; file2.close(); cin.sync(); cin.get(); return 0; }

als (bestand2.eof()) kapot gaat;

#erbij betrekken #erbij betrekken uit<< str << endl; // вывод прочитанной строки на экран cin.sync(); cin.get(); return 0; }

In het volgende voorbeeld ziet u een lus die regels uit het bestand test.txt leest en op de console weergeeft.

naamruimte std gebruiken; int main() ( ifstream bestand; // maak een streamobjectbestand file.open("test.txt"); // open het bestand om te lezen if (!file) return 1; // return on opening error char str; // statische lijnbuffer // Lees en toon regels in een lus totdat eof while (!file.getline(str, sizeof(str)).eof()) cout<< str << endl; }

Deze code onder Windows OS is ook afhankelijk van de aanwezigheid van een newline-teken in de laatste regel van het bestand; het zou betrouwbaarder zijn om dit te doen:

While (1) ( if (file.eof()) break; file.getline(str, sizeof(str)); cout

Expliciete aanroepen van de open- en close-methoden zijn niet vereist. Door de constructor met een argument aan te roepen, kunt u het bestand onmiddellijk openen, op het moment dat u het threaded file-object maakt:

Ifstream-bestand("test.txt");

In plaats van de close-methode kunt u de delete-operator gebruiken, die automatisch de destructor van het bestandsobject aanroept en het bestand sluit. De while-luscode zorgt voor goede controles aan het einde van het bestand.

ofstream klasse: bestanden schrijven

De klasse ofstream is ontworpen om gegevens uit een bestandsstroom uit te voeren. Hieronder worden de belangrijkste methoden van deze klasse vermeld.<=3; i++) file << "Строка " << i << endl; file.close();

De eerder beschreven insluitingsoperator is handig voor het organiseren van schrijven naar een tekstbestand:

In principe worden binaire gegevens behandeld als tekstgegevens. Het verschil is dat als binaire gegevens in een specifieke logische structuur worden geschreven, deze uit een bestand moeten worden gelezen in een variabele van hetzelfde structuurtype.

De eerste parameter van de schrijf- en leesmethoden (het adres van het schrijf-/leesblok) moet van het karakter pointertype char * zijn, dus het is noodzakelijk om een ​​expliciete conversie uit te voeren van het adrestype van de void *-structuur. De tweede parameter specificeert dat de binaire blokken van het bestand een constante bytegrootte hebben, ongeacht de werkelijke recordlengte. De volgende toepassing biedt een voorbeeld van het maken en weergeven van gegevens in een eenvoudig notitieblok. De bestandsitems worden vervolgens opeenvolgend gelezen en weergegeven op de console.

#erbij betrekken #erbij betrekken #erbij betrekken naamruimte std gebruiken; struct Notes ( // notebook datastructuur char Naam; // volledige naam char Telefoon; // phone int Leeftijd; // leeftijd ); int main() ( setlocale(LC_ALL, "Russisch"); Notes Note1= ("De verschrikkelijke Ioann Vasilyevich", "niet geïnstalleerd", 60 ); Notes Note2= ("Godoenov Boris Fedorovich", "095-111-2233" , 30 ); Notes Note3= ("Romanov Petr Mikhailovich", "812-333-2211", 20 ); sizeof (Notities)); // 1e blok van bestand.write((char*)&Note2, sizeof(Notes)); // 2e blok van bestand.write((char*)&Note3, 3e blok van bestand .close(); // sluit het opgenomen bestand ifstream ifile("Notebook.dat", ios::binary); // gestructureerde variabele char str; // statische stringbuffer // Lees en toon regels in een lus tot eof while (!ifile.read((char*)&Note, sizeof(Notes)).eof()) ( sprintf(str, "%s\tPhone: %s\tAge: %d" , Note.Name, Note.Phone, Opmerking.Leeftijd);<< str << endl; } ifile.close(); // закрыть прочитанный файл cin.sync(); cin.get(); return 0; }

Als gevolg van het uitvoeren van deze code wordt een binair bestand Notebook.dat gevormd uit drie blokken van elk 80 bytes (ervan uitgaande dat de tekens uit één byte bestaan). Uiteraard kunt u andere threading-methoden gebruiken en bewerkingen uitvoeren op de velden van een specifieke gegevensstructuur.

fstream-klasse: willekeurige bestandstoegang

Laten we aannemen dat we 100 vermeldingen in ons notitieboekje hebben, en we willen de 50e tellen. Natuurlijk kunt u een lus organiseren en alle records lezen, van de eerste tot de gegeven. Het is duidelijk dat een meer gerichte oplossing is om de pos-bestandspositieaanwijzer rechtstreeks op item 50 te zetten en daaruit te lezen:

Ifstream ifile("Notebook.dat", ios::binary); int pos = 49 * sizeof(Opmerkingen); ifile.seekg(pos); // zoek naar de 50e Notes Note-invoer;

//Notes – de hierboven beschreven “record”-structuur ifile.read((char*)&Note, sizeof(Notes));

Dergelijke zoekbewerkingen zijn effectief als het bestand bestaat uit records met een bekende en constante grootte. Om de inhoud van een willekeurig record te vervangen, moet u de uitvoerstroom openen in de wijzigingsmodus:

Ofstream ofile ("Notebook.dat", ios::binary | ios::ate); int pos = 49 * sizeof(Opmerkingen); ofile seekp(pos); // zoek naar de 50e noot Notes Note50 = ("Jeltsin Boris Nikolajevitsj", "095-222-3322", 64); ofile.write((char*)&Notitie, groottevan(Notities)); // vervanging

Als u de vlag ios::ate (of ios::app) niet opgeeft, wordt de vorige inhoud gewist wanneer u het binaire bestand Notebook.dat opent!

Ten slotte is het mogelijk om tegelijkertijd een bestand te openen om te lezen/schrijven, met behulp van de methoden die de fstream-streamingklasse heeft geërfd van zijn voorgangers. Omdat de fstream-klasse is afgeleid van istream en ostream (respectievelijk de ouders van ifstream en ofstream), worden alle eerder genoemde methoden beschikbaar in de applicatie.

#erbij betrekken #erbij betrekken #erbij betrekken In het volgende voorbeeld ziet u de herschikking van de eerste en derde vermeldingen in het bestand Notebook.dat.<== Note3 file.write((char*)&Note3, sizeof(Notes)); file.seekg(2 * sizeof(Notes)); // Note3 <== Note1 file.write((char*)&Note1, sizeof(Notes)); char str; // Считывать и отображать записи в цикле, пока не eof file.seekg(0); // вернуться к началу файла while (!file.read((char*)&Note1, sizeof(Notes)).eof()) { sprintf(str, "%s\tТел: %s\tВозраст: %d", Note1.Name, Note1.Phone, Note1.Age); cout << str << endl; } file.close(); cin.sync(); cin.get(); return 0; }

naamruimte std gebruiken; struct Opmerkingen (char Naam; char Telefoon; int Leeftijd; ); int main() ( setlocale(LC_ALL, "Russisch"); Notes Note1, Note3; // Open het bestand om tegelijkertijd te lezen/schrijven fstream file("Notebook.dat", ios::binary | ios::in | ios: : out); file.seekg(2 * sizeof(Notes)); // vind en lees Note3 file.read((char*)&Note3, sizeof(Notes) // vind en lees Note1 file.read((char *)&Opmerking1, groottevan(Notities)); bestand.seekg(0);

In de constructor van het bestandsobject moet u de vlaggen ios::in en ios::out opgeven, waardoor gelijktijdige lees- en schrijfbewerkingen mogelijk zijn. Als gevolg van het uitvoeren van deze code worden de eerste en derde vermeldingen in het binaire bestand Notebook.dat verwisseld.