Hallo, en welkom terug.
In deze lezing wil ik graag om te
praten over hoe we tekst uit een bestand kunnen lezen.
Voor nu gaan we concentreren op het lezen van tekstbestanden.
Dus als we karakter willen lezen uit een tekstbestand gaan we
een aantal functies gebruiken.
De eerste wordt fgetc.
Dit leest een karakter uit een tekst bestand dat is geopend om te lezen.
Denk eraan, we moeten altijd open het bestand op voordat we er bestandsbewerkingen
op kunnen uitvoeren, tenzij: het is een hernoeming of een verwijdering en
dan kan het bestand niet worden geopend.
Maar als je wilt lezen en schrijven of toevoegen,
moeten we dat bestand openen.
We weten dat we open kunnen bestanden met verschillende modi.
In dit geval om te lezen, zouden we hebben: om te openen met een r of een
r plus, en dan kunnen we fgetc gaan bellen.
De functie fgetc duurt de bestandsaanwijzer als zijn enige
argument, en het zal terugkeren het teken gelezen als typ int.
Dus hier een voorbeeld, we maken een mchar typ int, en we zeggen fgetc pfile.
Het gaat een karakter lezen in de mchar-variabele met
pfile als bestandsaanwijzer.
Denk aan pfile al geweest geopend terugkeer naar bestandsaanwijzer.
De mchar is van het type in omdat waarvan ons speciale teken ons
einde van het bestand is, dat wordt geretourneerd als het einde van het bestand is bereikt.
Zodat we dat altijd kunnen controleren integer om te zien of het eof is.
En als dat zo is, willen we niet om
meer te lezen, we willen geen fgetc meer bellen.
De functie fgetc, dat is equivalent aan fgetc is ook beschikbaar.
Dus getc is bijna hetzelfde als fgetc, je wilt gewoon fgetc gebruiken.
ik denk dat het wat heeft meer bescherming erin.
Met getc is een argument vereist of type file star en retourneert en
retourneert het teken rood als type int.
Het is vrijwel identiek aan fgetc.
Het enige verschil tussen hen is dat getc kan worden geïmplementeerd als een
macro, en wij niet eens weet wat een macro nu is.
Dus we blijven bij fgetc gebruiken als onze functie om karakters
te lezen.
U kunt de inhoud van een bestand lezen.
Nogmaals, indien nodig, kunt u gebruik maken van deze terugspoelfunctie die het bestand positioneert dat door
het bestand is gespecificeerd aanwijzer naar het begin van het bestand.
U kunt dus terugspoelen gebruiken als je wilt nog een keer lezen.
Zeg gewoon terugspoelen en dan de bestandsaanwijzer, vrij eenvoudig.
Dus hier is een voorbeeld.
Je moet de standaard io-header wanneer
we bestandsbewerkingen uitvoeren.
In onze hoofdfunctie zijn we: we gaan onze bestandsaanwijzer maken.
Als ik dit wil initialiseren naar null en we gaan een geheel getal maken.
Het eerste wat we gaan doen is dat we we gaan het
bestand openen met de f open-oproep, en we gaan specificeren: de naam van het bestand en we gaan specificeren dat
het om te lezen is.
Dat zal onze bestandsaanwijzer retourneren.
Dus nu is onze fp-aanwijzer verwijzend naar een geldig bestand.
Als het bestand niet kon openen. tekst dat is niet op de
goede weg of wat dan ook, het zal nul opleveren.
Dus je wilt controleren op null, zorg ervoor dat fp niet null is.
Als het null is, verlaat u het programma.
Anders, wanneer u gewoonlijk lees karakters, je zult ze in
een lus hebben.
Dus hier zeggen we terwijl c is gelijk aan fgetc fp, dit is het lezen van
een karakter uit ons bestand, de bestandsaanwijzer doorgeven aan fgetc, wat een
geheel getal retourneert.
Onthoud dat we uit de lus kunnen springen als dat geretourneerde gehele getal het einde van het bestand is
omdat we niet willen om voorbij het einde van het bestand te lezen.
Anders kunnen we gewoon uitprinten ons karakter met behulp van procent c en c.
Het laatste wat we willen is dat we het bestand willen sluiten, willen
we dan onze bestandsaanwijzer instellen naar nul, en we kunnen terugkeren.
Laten we proberen dit te gebruiken, creëren deze binnenkant van codeblokken.
Hier is ons programma in codeblokken.
Er staat: dit programma gaat niet werken, tenzij we een bestand op schijf hebben, waar
het programma ook draait.
Dus eerst als we dit bouwen, het zou goed moeten bouwen, het
zou een uitvoerbaar bestand moeten maken ergens op je harde schijf.
Ik heb al mijn projecten gezet in mijn dot-leningen-directory.
Dus als ik naar mijn downloads ga directory en ik
ga naar de projectnaam, dit is slechts een test project, dus waar u uw projecten ook opslaat,
de mijne wordt getest.
Als ik ga testen, zul je het zien dat in de bin-map, in
debug je uitvoerbare bestand is.
Hier maakt u uw bestand als u een familielid had.
Pad dus hier zou ik gewoon een . kunnen maken nieuw bestand en we kunnen het als een tekstbestand hebben,
dus ik kan het gewoon als een tekst maken document, en het moet bestand worden genoemd.
En dan ga ik zetten wat informatie erin.
Ik ga gewoon wat gegevens invoeren zoals hallo dit is Jason line feed.
Oké, nee, enzovoort, en ik ga het redden.
Dit bestand moet bestaan in om dit programma te laten werken.
Dus ik heb het bestand gemaakt.
Als ik het nu run, hopelijk het zal lezen wat ik er net
aan heb toegevoegd en het zal uitprinten.
Er staat fout en bestand openen file niet zo'n
bestandsdirectory, en dat komt waarschijnlijk omdat ik heb het in de debug-map.
En dit draait niet in debug.
Dus laten we proberen het in debug uit te voeren, en Ik denk dat het nu wel zou lukken.
We kunnen zeggen: debuggen, starten.
Dit zal naar het uitvoerbare bestand zoeken hopelijk in de debug-map.
We willen zeker weten dat het draait.
Nog steeds niet daar, dus je moet maken zeker dat u weet waar het uitvoerbare bestand is.
Laten we het ergens anders proberen of beter nog, ik zou het uitvoerbare bestand gewoon in de debug
kunnen uitvoeren directory en zou het daar moeten vinden.
Dus als ik hier dubbelklik, het pauzeert eigenlijk niet.
Het springt eruit.
Dus wat je daarvoor kunt doen is
in plaats van terug te gaan, kun je systeempauze zeggen en het zal niet afsluiten het programma totdat u het hebt uitgevoerd.
Dus laten we het nu proberen.
Dus nu gepauzeerd, niet gedaan het programma uitvoeren.
En wat je zag was, hallo dit is Jason.
Het was in staat om het bestand te vinden, uitgeprint oke,
uitgeprint nee en toen pauzeerde het.
Anders, wanneer u uitvoert het programma, het drukt de gegevens zo snel
af en verlaat de programma waarmee u klaar bent.
Dus zo kun je het testen.
Het moet worden opgeslagen waar het uitvoerbare bestand wordt opgeslagen waar het vandaan komt.
Het moet ergens vandaan komen anders in uw projectmap.
Ik weet niet zeker waar het vandaan komt.
We kunnen proberen het bestand te verplaatsen naar waar de broncode is.
Het kan zijn dat het vanaf hier wordt uitgevoerd.
Dus hier plaatsen we het hier.
En nu zullen we proberen het uit te voeren vanaf de ID en misschien zal het werken.
Wij bouwen niet.
We hebben het gerund, en het was in staat om het te vinden.
Dus het lijkt erop dat we hebben om het bestand in de
broncode te plaatsen.
Dus zolang we dat bestand maar plaatsen het dossier. tekst in het
projectbestand, kunt u deze zien.
Zo snel voorbeeld van hoe het kan open een bestand en lees enkele tekens,
niet de meest efficiënte manier om uit een bestand te lezen, omdat
je meestal strings wilt lezen.
Maar dit zal het openen.
Je ziet de f open call, en je merkt de while-lus op.
Dat is belangrijk.
Laten we teruggaan en praten over hoe we kunnen strings uit een bestand lezen,
wat veel efficiënter is.
Dus dat is het lezen van een enkel karakter.
Hoe zit het met het lezen van een string?
U kunt de fgets-functie gebruiken om uit een bestand of stream te lezen.
Dit zal een string lezen.
Er is een tekenreeks voor nodig heeft de eerste parameter.
Het aantal tekens dat u wilt lezen en vervolgens de daadwerkelijke bestandsaanwijzer.
Dus deze functie gaat lees een string in het geheugengebied waarnaar
wordt verwezen door de str.
Dus je moet eigenlijk passeren in de buffer
waar de gegevens worden opgeslagen.
En dat is een aanwijzing, dus je zou moet er geheugen voor toewijzen.
En dan gaat het lezen van het bestand dat is opgegeven als de
derde parameter die de bestandsaanwijzer is.
En dan gaat de nchar om te zeggen hoeveel gegevens moeten worden gelezen.
Dus als je nchars als 10 zet, het leest in 10 tekens, tenzij
het eerst een regelinvoer raakt.
Dus het gaat ofwel lezen an hele regel of het gaat het aantal
tekens lezen dat u specificeer in de tweede parameter.
Het einde van de regel wordt gespecificeerd door de backslash n wat zich het eerst voordoet.
Als een teken van een nieuwe regel rood is, het wordt vastgehouden
in de string en een null-terminator zal zijn toegevoegd aan het einde van de string.
Dus als je echt hebt opgegeven meer tekens, het zou lezen tot aan de
regelinvoer, en dan spring eruit en dan krijgt het
dat nieuwe lijnkarakter en zet a null-teken aan het einde ervan.
Als er geen fout is, is fgets gaat de aanwijzer retourneren,
wat de eerste parameter is.
Het gaat een aanwijzer retourneren die wordt geretourneerd uit de functie.
En dan gaat het ook om de str-aanwijzer als de eerste
parameter in te vullen.
Als er een fout is, wordt null geretourneerd.
En dan het einde van het bestand lezen zorgt ervoor dat null wordt geretourneerd, wat betekent
dat u al uw tekenreeksen leest.
Laten we dus naar een voorbeeld kijken.
Hier hebben we onze belangrijkste, en we maken onze bestandsaanwijzer en
maken een tekenreeks.
Dit is een aanwijzing die we niet hebben gedaan alle gegevens ervoor malloceren, we
maken gewoon een tekenreeks.
We openen het bestand om te lezen, alleen lezen omdat het r is.
We zeiden dat als het nul is, eruit springen.
Anders zeggen we gewoon fgets, we lezen in 60 karakters.
Of als de regelinvoer eerder is dat, een regelinvoer zal
verschijnen en dan zal het deze uitprinten en wat er ooit in de str-buffer zit.
Dus str is dat eerst karakter dat is doorgegeven.
En dan sluiten we de bestandsaanwijzer, stel het in op null en retourneer nul.
Dus laten we, nogmaals, een kijkje nemen op deze binnenkant van onze code blokkeert IDE.
Het enige dat hierin is veranderd programma is eigenlijk regel 14 t/m 17.
We gebruiken fgets om onze string te lezen in, en dan hebben we een str-buffer.
We moeten dus ook een maken tekenreeks
hier boven, wat onze str is, en we willen dat dit 60 bevat.
We lezen in 60.
We voegen een regelfeed toe, dus dat is 59 gaan inlezen en dan een regelinvoer toevoegen aan
het einde ervan.
Dus we zouden kunnen zeggen 61.
En dan komen de fgets binnen een if-statement, en het leest
in elke string totdat het ofwel raakt 60 tekens of een nieuwe regel, en het gaat
die string afdrukken.
Je zult merken dat dat niet zo is een while-lus, dus we lezen
niet tot het einde van het bestand.
We lezen het einde van bestand, krijgen we een null.
Dus als we dit bouwen, willen we maken zeker dat we onze offertes correct hebben.
Telkens wanneer u kopieert vanuit powerpoint het verpest de aanhalingstekens.
En we willen er zeker van zijn we hebben onze variabele gemaakt c wordt niet gebruikt,
dat is oké.
Dus laten we doorgaan en dit uitvoeren.
En zie je, hallo, dit is Jason.
Dus eigenlijk in zijn geheel lezen regel tekst uit het bestand.
Er stond in de eerste regel.
Dus je zou het nog een keer noemen en lees in de tweede regel.
Als u het aantal bytes wijzigt lezen, laten we zeggen dat we gewoon
10 willen lezen, het zou lezen in 10 en dan is het zou die 10
teruggeven in plaats van de hele regel te lezen.
Dus hier hebben we het gewoon hallo deze ik.
Dus het wordt in getal gelezen van tekens
uw tweede parameter of totdat het een regel krijgt feed en het slaat dat op in str.
Str is een tekenreeks.
We printen het fgets uit.
Fgets is veel meer efficiënt om te lezen.
Omdat we niet lezen een karakter en tegelijk
lezen we meer gegevens in.
Een karakter lezen in a tijd is niet zo efficiënt.
Dus nu weten we hoe we in single moeten lezen karakters, we
weten hoe we strings moeten lezen totdat ze een nieuwe lezen regel of een aantal tekens.
Maar je kunt ook inlezen geformatteerde invoer uit een bestand.
Dus we hebben getc, fgetc, fgets.
En nu hebben we er nog een functie genaamd fscanf.
Dit is geformatteerde invoer.
Geformatteerde invoer is gespecificeerde gegevens door zoals heeft een scheidingsteken of heeft een specifiek
formaat dat eraan is gekoppeld.
Deze fscanf-functie heeft een bestand nodig van stream en vervolgens een formaat.
Het formaat is net als de printf formaatspecificaties die u gebruikt.
Dus als je in gehele getallen wilt lezen of verdubbelt, kunt u gegevens specificeren
in het bestand dat wordt geïntroduceerd in het
dubbel en het zal dat lezen totdat het ziet, net als de scanf totdat het een witruimte-teken ziet.
Dus het eerste argument voor de fscanf functie is een verwijzing naar een
bestandsobject dat de stream identificeert.
We moeten weten wat bestand waaruit we lezen.
Het tweede argument tegen de functie is het formaat.
Dit is een c-tekenreeks die bevat een of meer van de volgende items.
Witruimteteken, niet-witruimte karakter, formaatspecificaties.
Het gebruik is hetzelfde als de scanf en de in de printf, maar in plaats
daarvan komt het uit een bestand.
Dus tussen de dubbele aanhalingstekens kun je tekst invoegen, u kunt witruimte-
of niet-witruimtetekens plaatsen, maar de formaatspecificaties zijn echt hoe
je de gegevens gaat lezen.
En dan specificeer je variabelen waarin u het wilt lezen.
Dus de functie keert terug het aantal
invoeritems dat met succes is afgestemd en toegewezen.
Dus hier is hoe het eruit ziet.
Je zult merken dat de belangrijkste is: het creëren van drie karakterarrays, str1, str2
en str3, elk slechts tien bytes.
We creëren een geheel getal genaamd jaar raken we een bestandsaanwijzer.
Het eerste wat we doen we openen het bestand.
In dit geval gaan we open het voor lezen en schrijven.
Maar we gaan niet echt schrijven wat dan ook, we gaan gewoon laten
zien wat we ervan lezen.
We controleren of het bestand aanwijzer is niet gelijk aan null.
En dan zijn we hier eigenlijk iets in het bestand fputs.
Daar hebben we het nog niet over gehad, maar dit is iets schrijven.
Focus hier op de fscanf.
De fscanf gaat lezen in geformatteerde gegevens.
En dus wat het gaat doen is het gaat
lezen in drie strings gescheiden door spaties.
En zo zie je het percentage als ruimtepercentage als
ruimtepercentage s ruimtepercentage d.
Dan zeggen we waar we zijn ga ze lezen in onze
array van drie karakters en dan onze jaar, en we moeten de
adresoperator voor ons jaar specificeren.
Maar de gegevens zijn geformatteerd als specifieke manier wanneer het is geschreven.
En als je iets leest dat is geformatteerd, moet u het formaat van
het bestand begrijpen hoe het is geschreven.
Hier weten we dat het bestand is geschreven door strings te scheiden door witruimte.
Dus zo zijn we ga het inlezen.
En zo kunnen we het lezen in met een oproep fscanf.
We kunnen ons formulier gebruiken als specificeerders als ons tweede argument en vervolgens een
variabel aantal argumenten voor elk gescheiden van elke komma om de gegevens op te geven
waarin we het willen lezen.
En dan printen we dat gewoon uit data, de drie strings in het jaar en
dan sluiten we het bestand weer.
En dit zijn dus de drie manieren u kunt gegevens uit een bestand inlezen.
U kunt ofwel in karakters lezen, u kunt strings inlezen of u
kunt geformatteerde gegevens lezen.
En je zult de geformatteerde manier opmerken om het te doen lijkt erg op scanf.
Je gebruikt formaatspecificaties, variabelen om in te lezen.
We hebben een uitdaging op het lezen van gegevens waardoor u hier
meer vertrouwd mee raakt.
Het is vrij eenvoudig.
Je gaat je open doen oproepen, je gaat
je bestandsaanwijzers gebruiken en je gaat om die drie functies te gebruiken.
Dank u.