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 gaan werken, beschrijven type variabele vanstroom. 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 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. Bijvoorbeeld de volledige naam van het bestand noobs.txt dat zich in spelmap op schijf D: moet je dit schrijven:
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 - niet openen 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"); Naarmate uw programma's complexer worden, zullen ze informatie opslaan en ophalen met behulp van bestanden. Als u bekend bent met bestandsmanipulatie in C, kunt u vergelijkbare technieken gebruiken in C++. Bovendien biedt C++, zoals u in deze zelfstudie zult leren, een reeks bestandsstreamklassen waarmee u heel eenvoudig invoer- en uitvoerbewerkingen (I/O) op bestanden kunt uitvoeren. Aan het einde van deze les beheerst u de volgende kernconcepten: Veel programma's die u in de toekomst gaat maken, zullen intensief gebruik maken van bestanden. Kies een tijdstip om te experimenteren met de programma's die in deze les worden gepresenteerd. En u zult merken dat het uitvoeren van bestandsbewerkingen in C++ heel eenvoudig is. In les 33 heb je geleerd dat cout een object van het type ostream is. Met behulp van de ostream-klasse kunnen uw programma's worden uitgevoerd naar cout met behulp van de insert-operator of verschillende klassenmethoden zoals cout.put. Het headerbestand iostream.h definieert de uitvoerstroomcout. Op dezelfde manier definieert het headerbestand f stream.h een uitvoerbestandstreamklasse met de naam ofstream. Met behulp van objecten van de klasse ofstream kunnen uw programma's naar een bestand worden uitgevoerd. Om te beginnen moet u een object van het type stream declareren, waarbij u de naam van het gewenste uitvoerbestand opgeeft als een tekenreeks, zoals hieronder weergegeven: ofstream file_object("BESTANDSNAAM.EXT"); Als u een bestandsnaam opgeeft bij het declareren van een object van het type stream, zal C++ een nieuw bestand op uw schijf maken met de opgegeven naam, of een bestand met dezelfde naam overschrijven als het al op uw schijf bestaat. Het volgende programma OUT_FILE.CPP maakt een object van het type stream en gebruikt vervolgens de operator inserts om meerdere regels tekst naar het BOOKINFO.DAT-bestand uit te voeren: #erbij betrekken { In dit geval opent het programma het bestand BOOKINFO.DAT en schrijft vervolgens drie regels naar het bestand met behulp van de insert-instructie. Compileer en voer dit programma uit. Als u onder MS-DOS werkt, kunt u de opdracht TYPE gebruiken om de inhoud van dit bestand op het scherm weer te geven: C:\>TYPE BOEKINFO.DAT Leren programmeren in C++, tweede editie Zoals u kunt zien, is het in C++ vrij eenvoudig om een uitvoerbewerking naar een bestand uit te voeren. U heeft zojuist geleerd dat uw programma's, door de klasse ofstream te gebruiken, snel uitvoerbewerkingen op een bestand kunnen uitvoeren. Op dezelfde manier kunnen uw programma's invoerbewerkingen uitvoeren vanuit een bestand met behulp van ifstream-objecten. Nogmaals, u maakt eenvoudigweg het object en geeft het de vereiste bestandsnaam door als parameter: ifstream input_file("bestandsnaam.EXT"); Het volgende FILE_IN.CPP-programma opent het BOOKINFO.DAT-bestand dat u met het vorige programma hebt gemaakt, leest de eerste drie elementen van het bestand en geeft deze vervolgens weer: #erbij betrekken #erbij betrekken { Als je dit programma compileert en uitvoert, zou je waarschijnlijk verwachten dat het de eerste drie regels van het bestand weergeeft. Net als cin gebruiken invoerbestandsstromen echter null-tekens om te bepalen waar de ene waarde eindigt en de andere begint. Als gevolg hiervan verschijnt de volgende uitvoer op het display wanneer u het vorige programma uitvoert: C:\>FILE_IN programma In les 33 heb je geleerd dat je programma's cin.getline kunnen gebruiken om een hele regel van het toetsenbord te lezen. Op dezelfde manier kunnen objecten van het type ifstream getline gebruiken om een regel met bestandsinvoer te lezen. Het volgende programma FILELINE.CPP gebruikt de getline-functie om alle drie de regels van het BOOKINFO.DAT-bestand te lezen: #erbij betrekken #erbij betrekken { In dit geval leest het programma de inhoud van het bestand met succes, omdat het weet dat het bestand drie regels bevat. In veel gevallen weet uw programma echter niet hoeveel regels het bestand bevat. In dergelijke gevallen zullen uw programma's gewoon doorgaan met het lezen van de inhoud van het bestand totdat ze het einde van het bestand tegenkomen. Een gebruikelijke bestandsbewerking in uw programma's is het lezen van de inhoud van een bestand totdat het einde van het bestand wordt aangetroffen. Om het einde van een bestand te bepalen, kunnen uw programma's de eof-functie van het stream-object gebruiken. Deze functie retourneert 0 als het einde van het bestand nog niet is aangetroffen, en 1 als het einde van het bestand is aangetroffen. Met behulp van een while-lus kunnen uw programma's continu de inhoud van een bestand lezen totdat ze het einde van het bestand vinden, zoals hieronder weergegeven: terwijl (! input_file.eof()) { In dit geval blijft het programma herhalen zolang de functie eof false (0) retourneert. Het volgende programma, TEST_EOF.CPP, gebruikt de eof-functie om de inhoud van het BOOKINFO.DAT-bestand te lezen totdat het het einde van het bestand bereikt: #erbij betrekken #erbij betrekken leegte hoofd(leegte) { { Op dezelfde manier leest het volgende programma WORD_EOF.CPP de inhoud van het bestand woord voor woord totdat het einde van het bestand wordt aangetroffen: #erbij betrekken #erbij betrekken { { Ten slotte leest het volgende programma CHAR_EOF.CPP de inhoud van het bestand teken voor teken, met behulp van de get-functie, totdat het het einde van het bestand tegenkomt: #erbij betrekken #erbij betrekken { { De tot nu toe gepresenteerde programma's zijn ervan uitgegaan dat er geen fouten optreden tijdens I/O-bewerkingen van bestanden. Helaas komt dit niet altijd uit. Als u bijvoorbeeld een bestand opent voor invoer, moeten uw programma's controleren of het bestand bestaat. Op dezelfde manier moet u, als uw programma gegevens naar een bestand schrijft, ervoor zorgen dat de bewerking succesvol is (een gebrek aan schijfruimte zal bijvoorbeeld waarschijnlijk voorkomen dat de gegevens worden geschreven). Om uw programma's te helpen fouten op te sporen, kunt u de fail-functie van het bestandsobject gebruiken. Als er geen fouten zijn opgetreden tijdens de bestandsbewerking, retourneert de functie false (0). Als er echter een fout optreedt, retourneert de fail-functie waar. Als een programma bijvoorbeeld een bestand opent, moet het de fail-functie gebruiken om te bepalen of er een fout is opgetreden, zoals hieronder weergegeven: ifstream input_file("BESTANDSNAAM.DAT"); { Daarom moeten programma's ervoor zorgen dat lees- en schrijfbewerkingen succesvol zijn. Het volgende programma TEST_ALL.CPP gebruikt de fail-functie om te testen op verschillende foutsituaties: #erbij betrekken #erbij betrekken { { { Wanneer uw programma wordt beëindigd, sluit het besturingssysteem de geopende bestanden. Als algemene regel geldt echter dat als uw programma een bestand niet langer nodig heeft, het dit moet sluiten. Om een bestand te sluiten, moet uw programma de sluitfunctie gebruiken, zoals hieronder weergegeven: Wanneer u een bestand sluit, worden alle gegevens die uw programma naar dat bestand heeft geschreven, naar de schijf gewist en wordt de directory-invoer voor dat bestand bijgewerkt. In de voorbeeldprogramma's die in deze les worden gepresenteerd, werden bestandsinvoer- en uitvoerbewerkingen uitgevoerd vanaf het begin van het bestand. Wanneer u echter gegevens naar een uitvoerbestand schrijft, wilt u waarschijnlijk dat het programma de informatie aan het einde van het bestaande bestand toevoegt. Om een bestand in de toevoegmodus te openen, moet u bij het openen een tweede parameter opgeven, zoals hieronder weergegeven: ifstream output_file("BESTANDSNAAM.EXT", ios::app); In dit geval specificeert de parameter ios::app de openingsmodus van het bestand. Naarmate uw programma's complexer worden, zullen ze een combinatie van waarden gebruiken voor de bestandsopeningsmodus die in de tabel worden vermeld. 34. Tabel 34. Waarden van de openingsmodus. De volgende bestandsbewerking opent het bestand voor uitvoer in de ios::noreplace-modus om te voorkomen dat een bestaand bestand wordt overschreven: ifstream output_file("Bestandsnaam.EXT", ios::out | ios::noreplace); Alle programma's die in deze les worden gepresenteerd, voerden bestandsbewerkingen uit op tekenreeksen. Naarmate uw programma's complexer worden, moet u mogelijk arrays en structuren lezen en schrijven. Om dit te doen, kunnen uw programma's de lees- en schrijffuncties gebruiken. Wanneer u de lees- en schrijffuncties gebruikt, moet u de gegevensbuffer opgeven waarin gegevens worden gelezen of geschreven, evenals de lengte van de buffer in bytes, zoals hieronder weergegeven: input_file.read(buffer, groottevan(buffer)) ; Het volgende programma STRU_OUT.CPP gebruikt bijvoorbeeld de schrijffunctie om de inhoud van een structuur naar het bestand EMPLOYEE.DAT uit te voeren: #erbij betrekken #erbij betrekken { { ofstream emp_file("WERKNEMER.DAT"); De schrijffunctie ontvangt doorgaans een verwijzing naar een tekenreeks. De tekens (char *) zijn een type cast-operator die de compiler informeert dat u een pointer naar een ander type doorgeeft. Op dezelfde manier gebruikt het volgende programma STRU_IN.CPP de leesmethode om werknemersinformatie uit een bestand te lezen: #erbij betrekken #erbij betrekken { { ifstream emp_file("WERKNEMER.DAT"); Naarmate uw programma's complexer worden, zult u regelmatig bestandsbewerkingen gebruiken. Kies een tijdstip om te experimenteren met de programma's die in deze les worden gepresenteerd. In les 35 leert u hoe u de prestaties van uw programma's kunt verbeteren door ingebouwde functies te gebruiken. Voordat u doorgaat naar les 35, moet u ervoor zorgen dat u het volgende heeft gedaan: Werken met streams in C++ vanstroom En alsstroom. Het voorbeeld toont een programma dat genereert HTML een bestand met gegevens in een tabel die we in het programma invoeren. Wij maken gebruik van streaming I/O. Threads voor het werken met bestanden worden gemaakt als objecten van de volgende klassen: Om deze klassen te gebruiken, moet u een extra headerbestand in de programmatekst opnemen fstream.h. Hierna kan het programma specifieke bestandsstromen van de overeenkomstige typen definiëren (objecten van klassen ofstream, ifstream, fstream), bijvoorbeeld als volgt: Het maken van een bestandsstream (een object van de juiste klasse) associeert de streamnaam met de buffer die ervoor is toegewezen en initialiseert de statusvariabelen van de stream. Omdat de vermelde bestandsstroomklassen de eigenschappen van de klasse overnemen ios, dan worden de statusvariabelen van elke bestandsstroom overgenomen van deze basisklasse. Omdat bestandsklassen zijn afgeleid van klassen ostroom(Klas vanstroom), istream(Klas alsstroom), stroom(Klas fstroom), dan ondersteunen ze geformatteerde en formaatloze bestandsuitwisseling zoals beschreven in de voorgaande stappen. Voordat u de uitwisseling uitvoert, moet u dit echter wel doen open het overeenkomstige bestand en koppel het aan de bestandsstroom
. Het openen van een bestand betekent in de meest algemene zin een procedure die het systeem informeert over de acties die met het bestand moeten worden uitgevoerd. Er zijn MET om bestanden te openen fopen(), open(). Maar werken met bestandsstromen van de taal-I/O-bibliotheek C++, is het handiger om componentfuncties van de overeenkomstige klassen te gebruiken. Nadat u een bestandsstream heeft gemaakt, kunt u deze aan een specifiek bestand 'bijvoegen' met behulp van componentfunctie open(). Functie open() overgenomen door elk van de bestandsklassen ofstream, ifsream, fstream uit de klas fstreambasis. Met zijn hulp kunt u niet alleen een bestand openen, maar het ook koppelen aan een reeds gedefinieerde stream. Functie Formaat: #erbij betrekken teken k; Doen 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 het construct If (!file) ( //Afhandeling bij het openen van bestanden) Inclusie- en extractieoperatoren Overschreven in bestandsverwerkingsklassen inclusie-operator (<<) записывает данные в файловый поток. Как только вы открыли файл для записи, можно записывать в него текстовую строку целиком: Bestand<< "Это строка текста";
U kunt een tekststring 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 als (bestand2.eof()) kapot gaat; #erbij betrekken 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: Ofstream-bestand("temp.txt"); if (!bestand) retourneert; voor (int i=1; ik Binaire bestanden 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. 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 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. In het volgende voorbeeld ziet u de herschikking van de eerste en derde vermeldingen in het bestand Notebook.dat. 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. 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. Er zijn nog meer voorbeelden over dit onderwerp. Op termijn vergelijkingsoperator het woord "vergelijking" verwijst naar de waarden van de operanden. Op termijn logische exploitant het woord ‘logisch’ verwijst naar de manier waarop deze relaties tot stand komen. Omdat vergelijkingsoperatoren en logische operatoren nauw verwant zijn, zullen we ze samen bekijken. Vergelijkingsoperatoren en logische operatoren worden weergegeven in Tabel 4. Vergelijkingsoperatoren en logische operatoren zijn gebaseerd op de concepten 'waar' en 'onwaar'. In C wordt elke waarde die niet gelijk is aan nul als waar beschouwd. De false-waarde is altijd 0 als het resultaat false is, en 1 als het resultaat true is. In C++ worden ware en valse waarden op dezelfde manier onderscheiden, maar daarnaast is er een speciaal datatype bool en Booleaanse constanten WAAR En vals. Tabel 4. Vergelijkingsoperatoren en logische operatoren Vergelijkingsoperatoren en logische operatoren hebben een lagere prioriteit dan rekenkundige operatoren. De uitdrukking 10 > 1+12 wordt dus geëvalueerd alsof deze als volgt is geschreven: 10 > (1+12). Bitwise-operatoren In tegenstelling tot veel programmeertalen bevat C/C++ een volledige set bitsgewijze operatoren. Omdat C is ontworpen als vervanging voor assembleertaal, biedt het veel bewerkingen op laag niveau, zoals bitsgewijze bewerkingen ontworpen om de bits waaruit de bytes en machinewoorden bestaan die variabelen van het type char of int vormen, te controleren, in te stellen en te verschuiven. Bitsgewijze operatoren worden weergegeven in Tabel 5. Tabel 5. Bitwise-operatoren Beveiligingsvragen 1. Leg uit wat met programmeren wordt bedoeld. 2. Wat zijn de fasen van de softwarelevenscyclus? 3. Welke softwareontwerpmethoden ken je? 4. Lijst met bewerkingen voor het maken van een *.cpp-bestand? 5. Samenstelling van de taal in C++. 6. Wat is de algemene structuur van een C++-programma? 7. Welke datatypen ken je in C++? 8. Variabelen. Variabelen declareren in C++. 9. Is er vanuit het perspectief van de C++-taal een verschil tussen de cijfers: 11. Geef de belangrijkste operatoren in C++? Laboratoriumwerk nr. 2 Ontwikkeling van een programma met behulp van basis C++-operatoren Doel van het werk: 1. Het bestuderen van de basisoperatoren van de C++-taal; 2. Vaardigheden verwerven om te werken met Microsoft Visual C++ 5.0-software. Gebruikte apparatuur: Personal computer compatibel met IBM PC. Gebruikte software: Windows-besturingssysteem; Geïntegreerde programmeeromgeving Microsoft Visual C++ 5.0. Werkopdracht 1.1. ISP Microsoft Visual C++ 5.0 downloaden; 1.2. Bestudeer de basisgegevenstypen, ISP Microsoft Visual C++ 5.0; 1.3. Voltooi de opdracht van de leraar; 1.4. Leg een protocol vast voor het werken met de geïntegreerde omgeving. Werkorder 2.1. Maak een algoritmediagram (volgens instructies van de docent); 2.2. Start Microsoft Visual C++ 5.0; 2.3. Maak een *.cpp-bestand in de werkmap; 2.5. Noteer het algoritmediagram en de programmatekst in het protocol voor het werken met de geïntegreerde omgeving; 2.6. Voltooi Microsoft Visual C++ 5.0 en voer het programma uit. 3.1. Naam laboratoriumwerk. 3.2. Doel van het werk. 3.3. Het theoretische gedeelte. 3.4. Programma-algoritme. 3.5. Programma tekst. 3.6. Conclusie. Korte beschrijving Een operator is een onderdeel van een programma dat afzonderlijk kan worden uitgevoerd, met andere woorden: een operator definieert een bepaalde actie. C- en C++-taaloperatoren zijn onderverdeeld in de volgende categorieën: Ø voorwaardelijke uitspraken
(indien voorwaardeverklaring en schakelaarselectieverklaring); Ø lus-instructies
(voor, terwijl, terwijl); Ø sprongoperatoren
(pauze, doorgaan, terugkeren, ga naar); Ø andere exploitanten
(operator " uitdrukking
", leeg
exploitant). Verklaringen in een programma kunnen worden gecombineerd tot samengestelde operatoren
gebruik van accolades. Elke instructie in een programma kan worden gemarkeerd met een label dat bestaat uit een naam gevolgd door een dubbele punt. Alle C/C++-taalinstructies, behalve samengestelde instructies, eindigen met een puntkomma ";". Operator-expressie Elke uitdrukking die eindigt met een puntkomma is een verklaring. De uitvoering van de expressieoperator bestaat uit het evalueren van de expressie. Voorbeelden: Deze operator vertegenwoordigt een uitdrukking die de waarde van variabele i met één verhoogt. a=cos(b*5); Deze operator vertegenwoordigt een expressie die toewijzings-, vermenigvuldigings- en functieaanroepbewerkingen omvat. Leuk(x,y); Deze operator vertegenwoordigt een uitdrukking die bestaat uit een functieaanroep. Lege operator Een lege instructie bestaat alleen uit een puntkomma ";". Er gebeurt niets wanneer deze instructie wordt uitgevoerd. Samengestelde operator Een samengestelde verklaring bestaat uit meerdere verklaringen en verklaringen tussen accolades. Er staat geen puntkomma aan het einde van een samengestelde instructie. De uitvoering van een samengestelde operator bestaat uit de opeenvolgende uitvoering van de samenstellende operatoren. Voorwaardelijke uitspraken als verklaring Operatorformaat: if (expressie) instructie1 ;
Anders verklaring 2 ;
Verklaring uitvoering als begint met het evalueren van een uitdrukking. Verdere uitvoering wordt uitgevoerd volgens het volgende schema: Als de expressie waar is (d.w.z. verschillend van 0), wordt statement1 uitgevoerd; Als de expressie onwaar is (d.w.z. gelijk aan 0), wordt statement2 uitgevoerd; Als de expressie onwaar is en operator2 ontbreekt (een optionele constructie staat tussen vierkante haken), dan wordt het volgende uitgevoerd: als exploitant. Het volgende fragment illustreert geneste instructies als: Char-teken; Intx,y,z; als (teken == '-') x = y - z; anders als (teken == '+') x = y + z; anders als (teken == '*') x = y * z; anders als (ZNAC == '/') x = y/z; Genest telefoniste genoemd als, die in een andere verklaring staat als of anders. Geneste uitspraken als komen vrij vaak voor. in een geneste sectie met voorwaardelijke instructies anders altijd gekoppeld aan de dichtstbijzijnde operator als, bevindt zich in hetzelfde blok en is niet gekoppeld aan een andere operator anders. if(j) verklaring 1; if(k)-operator2; /* gegeven als */ anders operator3; /* geassocieerd met deze else-instructie */ anders operator4; /* geassocieerd met de if (i)-instructie */ Laatste sectie anders niet gekoppeld aan de exploitant als(j), dat zich in een ander blok bevindt, en bij de operator als(ik). Interne sectie anders verbonden aan de exploitant als(k), omdat deze operator als is het dichtst bij. schakel verklaring Exploitant schakelaar ontworpen om een keuze uit veel verschillende opties te organiseren. Het operatorformaat is als volgt: Schakelaar (expressie) ( [aankondiging ]
[case constante-expressie1]: [statement-lijst1 ]
[case constante-expressie2]: [statement-lijst2 ]
[ standaard: [lijst met operators ]]
De expressie die volgt op het sleutelwoord switch tussen haakjes kan elke expressie zijn die is toegestaan in C/C++ en waarvan de waarde een geheel getal moet zijn. Omdat een constante expressie tijdens de uitzending wordt geëvalueerd, kan deze geen variabelen of functieaanroepen bevatten. Normaal gesproken worden gehele getallen of tekenconstanten gebruikt als constante-expressie. Alle constante expressies in de instructie schakelaar moet uniek zijn. Behalve voor operators die zijn gemarkeerd met het trefwoord geval, misschien, maar zeker één, fragment gemarkeerd met het standaard trefwoord. De operatorlijst kan leeg zijn of een of meer operators bevatten. Bovendien is het in de switch-instructie niet nodig om de reeks operatoren tussen accolades te plaatsen. Het uitvoeringsschema van de switch-instructie is als volgt: De uitdrukking tussen haakjes wordt geëvalueerd; De berekende waarden worden opeenvolgend vergeleken met constante expressies na de trefwoorden geval; Als een van de constante expressies overeenkomt met de waarde van de expressie, wordt de besturing overgedragen aan de operator die is gemarkeerd met het overeenkomstige trefwoord geval; Als geen van de constante expressies gelijk is aan de expressie, wordt de besturing overgedragen aan de operator die is gemarkeerd met het standaardsleutelwoord, en als deze afwezig is, wordt de besturing overgedragen naar de volgende operator. schakelaar exploitant. Om dezelfde acties uit te voeren voor verschillende waarden van een uitdrukking, kunt u dezelfde verklaring taggen met meerdere trefwoorden geval. Voorbeeld: int i=2; Schakelaar(ik) geval 1: ik += 2; geval 2: ik *= 3; geval 0: ik /= 2; geval 4: ik -= 5; standaard: ; Exploitanten schakelaar kan worden genest, zelfs als sectieconstanten geval externe en interne operators schakelaar overeenkomen, ontstaan er geen problemen. Jump-operators verklaring breken Exploitant pauze zorgt voor de beëindiging van de uitvoering van de binnenste van de operators die het combineren schakelaar, Doen, voor, terwijl. Na het uitvoeren van de verklaring pauze de controle wordt overgedragen aan de operator na de onderbroken versie. Functie Uitgang() is geen besturingsoperator, het is tijd om het te leren. Een standaard bibliotheekfunctie aanroepen Uitgang() leidt tot beëindiging van het programma en overdracht van de controle naar het besturingssysteem. Functie Uitgang() ziet er zo uit. lege uitgang(int return_code); Variabele waarde return_code doorgegeven aan het aanroepproces, meestal het besturingssysteem. Ga door met exploitant Exploitant doorgaan, zoals de exploitant pauze, wordt alleen binnen lus-instructies gebruikt, maar in tegenstelling hiermee gaat de programma-uitvoering niet verder vanaf de instructie die volgt op de onderbroken instructie, maar vanaf het begin van de onderbroken instructie. Voorbeeld: Int hoofd() Int a,b; voor (a=1,b=0; een<100; b+=a,a++)
als (b%2) doorgaat; ... /* even bedragen verwerken */ Retour 0; Wanneer de som van de getallen van 1 tot a oneven wordt, wordt de operator doorgaan draagt de controle over aan de volgende iteratie van de lus voor, zonder even som-operatoren uit te voeren. De continue-operator is als de operator pauze, onderbreekt de binnenste van de omhullende cycli. verklaring terug Exploitant opbrengst beëindigt de uitvoering van de functie waarin deze is gespecificeerd en geeft de controle terug aan de aanroepende functie op het punt onmiddellijk na de aanroep. De hoofdfunctie draagt de controle over aan het besturingssysteem. Operatorformaat: return [uitdrukking]; De waarde van de uitdrukking, indien gegeven, wordt teruggestuurd naar de aanroepende functie als de waarde van de aangeroepen functie. Als de expressie wordt weggelaten, is de geretourneerde waarde niet gedefinieerd. Als er een functie ontbreekt, de operator opbrengst, waarna de besturing wordt overgedragen aan de aanroepende functie nadat de laatste instructie van de aangeroepen functie is uitgevoerd. In dit geval is de retourwaarde niet gedefinieerd. Als een functie geen retourwaarde mag hebben, moet deze ongeldig worden verklaard. Het gebruik van de return-instructie is dus noodzakelijk om de functie onmiddellijk af te sluiten of om de retourwaarde door te geven. Voorbeeld: Int som (int a, int b) retour (a+b); De somfunctie heeft twee formele parameters a en b van het type int, en retourneert een waarde van het type int, zoals aangegeven door de declarator die voorafgaat aan de functienaam. De waarde die door de return-instructie wordt geretourneerd, is gelijk aan de som van de werkelijke parameters. Voorbeeld: Gerelateerde informatie.UITVOER NAAR BESTANDSTREAM
ofstream book_file("BOEKINFO.DAT");
boek_bestand<< «Учимся программировать на языке C++, » << «Вторая редакция» << endl;
boek_bestand<< «Jamsa Press» << endl;
boek_bestand<< «22.95» << endl;
}LEZEN VAN INVOERBESTANDSSTREAM
teken één, twee, drie;
input_file >> één;
input_file >> twee;
input_file >> drie;
uit<< one << endl;
uit<< two << endl;
uit<< three << endl;
}Een hele regel bestandsinvoer lezen
teken één, twee, drie;
input_file.getline(één, groottevan(één)) ;
input_file.get regel(twee, sizeof(twee));
input_file.getline(drie, groottevan(drie)) ;
uit<< one << endl;
uit<< two << endl;
uit<< three << endl;
}HET EINDE VAN HET BESTAND BEPALEN
// Exploitanten
}
ifstream input_file("BOEKINFO.DAT");
verkoolde lijn;
terwijl (! input_file.eof())
input_file.getline(regel, groottevan(regel));
uit<< line << endl;
}
}
ifstream input_file("BOEKINFO.DAT");
char woord;
terwijl (! input_file.eof())
invoerbestand >> woord;
uit<< word << endl;
}
}
ifstream input_file("BOEKINFO.DAT");
tekenbrief;
terwijl (! input_file.eof())
letter = invoer_bestand.get();
uit<< letter;
}
}CONTROLEREN OP FOUTEN BIJ HET UITVOEREN VAN BESTANDSBEWERKINGEN
als (invoerbestand.fail())
cerr<< «Ошибка открытия FILENAME.EXT» << endl;
uitgang(1);
}
char lijn;
ifstream input_file("BOEKINFO.DAT");
if (input_file.fail()) cerr<< «Ошибка открытия BOOKINFO.DAT» << endl;
anders
terwijl ((! input_file.eof()) && (! input_file.fail()))
input_file.getline(regel, groottevan(regel)) ;
if (! input_file.fail()) cout<< line << endl;
}
}
}EEN BESTAND SLUITEN ALS HET NIET LANGER NODIG IS
BESTAND OPEN CONTROLE
Openingsmodus
Doel
ios::app
Opent een bestand in de toevoegmodus, waarbij de bestandsaanwijzer aan het einde van het bestand wordt geplaatst.
ios:: gegeten
Plaatst de bestandsaanwijzer aan het einde van het bestand.
ios::in
Specificeert of een bestand voor invoer moet worden geopend.
ios::nocreate
Als het opgegeven bestand niet bestaat, maak het bestand dan niet aan en retourneer een foutmelding.
ios::noreplace
Als het bestand bestaat, moet de openbewerking worden afgebroken en moet er een fout worden geretourneerd.
ios::uit
Specificeert of een bestand moet worden geopend voor uitvoer.
ios::trunc
Reset (overschrijft) de inhoud van een bestaand bestand.
UITVOEREN VAN LEES- EN SCHRIJFHANDELINGEN
output_file.write(buffer, groottevan(buffer));
struct medewerker
tekennaam;
int leeftijd;
zwevend salaris
emp_file.write((char *) &worker, sizeof(werknemer));
}
struct medewerker
tekennaam;
int leeftijd;
zwevend salaris
) werknemer = ( "John Doy", 33, 25000.0);
emp_file.read((char *) &worker, sizeof(werknemer));
uit<< worker.name << endl;
uit<< worker.age << endl;
uit<< worker.salary << endl;
}WAT U MOET WETEN
#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
tekennaam;
tekenbeschrijving;
verkoolde god;
char kolvo;
voornaamst()
{
als ((toegang("index.html",2))==-1)
{
knuppel<<""<"<
"<"<
Naam "<Beschrijving "<Aantal delen "<Jaar "<
}
{
clrscr();
uit<<" !!! Вместо пробелов используйте \"_\" !!! "<
cin>>naam;
uit<<"\nОписане диска: ";
cin>>opisanie;
uit<<"\nКоличество томов: ";
cin>>kolvo;
uit<<"\nГод выпуска: ";
cin>>god;
ofstream bat("index.html",ios::app);
knuppel<<""< "<"< "<"< "<" <
uit<<"\n\tВыход (для выхода Y)? ";
cin>>k;
}
terwijl (k! = "y" || k! = "Y" || k! = "f" || k! = "?");
}
Wij raden aan
Wat is Windows-bitdiepte?
