>> SPEAKER: Tot nu toe, is het waarschijnlijk dat de meeste van uw programma's
hebben een beetje vluchtig geweest.
U voert een programma als Mario of Greedy.
Het doet iets, het misschien gevraagd de gebruiker voor wat informatie,
afdrukken enkele output naar het scherm, maar dan als je programma is voorbij,
er is echt geen bewijs is er Het werd steeds uitgevoerd in de eerste plaats.
Ik bedoel, zeker, je zou hebben verlaten het te openen in het terminal-venster,
maar als u uw scherm te wissen, is er echt geen bewijs dat het bestond.
We hebben niet een middel van het opslaan van hebben persistent, informatie
dat bestaat na onze programma is gestopt,
of moeten we niet tot op dit punt.
Gelukkig maar, c doet geven ons de mogelijkheid
om dit te doen door de uitvoering iets genaamd
een bestand, een structuur die in wezen vertegenwoordigt een bestand dat u zou verdubbelen
Klik op uw computer, als je gebruikt om een ​​grafische gebruikersomgeving.
Over het algemeen bij het werken met c, we zijn eigenlijk
gaat werken met pointers bestand files-- stars--
behalve voor een beetje als we praten over een paar
van de functies die werken met file pointers.
U hoeft niet echt te hebben gegraven te diep in kennis pointers
zelf.
Er is een klein piepklein beetje waar we zullen praten over hen,
maar over het algemeen bestand pointers en pointers, terwijl met elkaar verbonden,
zijn niet precies hetzelfde.
>> Nu, wat ik bedoel als Ik zeg persistente data?
Wat is persistente data?
Waarom hebben we de zorg over het?
Zeg, bijvoorbeeld, dat je draait een programma
of je hebt een herschreven programma dat is een spel,
en u wilt bijhouden van alle bewegingen van de gebruiker
dus dat misschien als er iets misgaat, kunt u het bestand na de wedstrijd te bekijken.
Dat is wat we bedoelen als we praten over persistente data.
>> In de loop van het runnen van uw programma, wordt een bestand gemaakt.
En wanneer je programma heeft gestopt,
dat bestand bestaat nog steeds op uw systeem.
En we kunnen kijken en onderzoeken.
En dat programma worden ingesteld hebben een aantal hardnekkige data gecreëerd,
gegevens bestaan ​​nadat het programma is voltooid loopt.
>> Nu al deze functies werken met het maken van bestanden en manipuleren
ze op verschillende manieren wonen in standaard io.h,
dat is een header bestand dat u waarschijnlijk geweest pond
waaronder bovenaan mooie veel van al uw programma's
omdat het een van de bevat meest nuttige functies voor ons,
printf, die ook laat woont in standaard io.h.
Dus je hoeft niet te pond omvatten extra bestanden waarschijnlijk
om te werken met file pointers.
>> Nu elk bestand pointer functie, of elk bestand I / O, input output
functie accepteert als een van de parameters of inputs
een bestand pointer-- behalve één, fopen die
is wat u gebruikt om het bestand te krijgen aanwijzer in de eerste plaats.
Maar nadat je hebt opende de bestand en je krijgt file pointers,
je kunt ze vervolgens doorgeven als argumenten om de verschillende functies
We gaan om te praten over Vandaag, evenals vele anderen
zodat u kunt werken met bestanden.
>> Zo zijn er zes vrij gemeenschappelijke basismaatregelen
dat we gaan om te praten over vandaag.
fopen en zijn metgezel functie fclose, fgetc
en zijn metgezel functie fputc, en fread en zijn metgezel functie,
fwrite.
Dus laten we recht in het.
>> fopen-- wat doet het?
Nou, het opent een bestand en het geeft u een bestand pointer naar het,
zodat u vervolgens kunt gebruiken file pointer als argument
voor één van de andere file I / O-functies.
Het allerbelangrijkste om te onthouden met fopen
is dat nadat je hebt opende de bestand of een oproep zoals hier,
je nodig hebt om te controleren om ervoor te zorgen dat de pointer die je terug kreeg
niet gelijk is aan nul.
Als je de video op niet hebben bekeken pointers, dit misschien niet zinvol.
Maar als je probeert en dereferentie een null pointer recall,
Uw programma zal waarschijnlijk lijden een segmentering [onverstaanbaar].
Wij willen ervoor zorgen dat we kreeg een legitieme pointer terug.
De overgrote meerderheid van de tijd zullen we hebben een legitieme pointer terug gekregen
en het zal geen probleem zijn.
>> Dus hoe maken we een oproep om fopen?
Het ziet er vrij veel als dit.
File ster ptr-- ptr als een generieke naam voor file pointer-- fopen
en passeren we in twee dingen, een bestandsnaam en een operatie willen we ondernemen.
Zo kunnen we een telefoontje dat eruit ziet bestand ster ptr dit-- 1 gelijk fopen
file1.txt.
En de operatie ik heb gekozen is r.
>> Dus wat denk je r is hier?
Wat zijn de dingen die we zou kunnen doen om bestanden?
Dus r de operatie die we kiezen wanneer we willen een bestand te lezen.
Dus we zouden eigenlijk bij maken we een oproep als deze
krijgen ons een bestands pointer zodanig dat we dan konden lezen informatie
van file1.txt.
>> Ook konden we bestand 2.txt openen voor het schrijven en dus kunnen we passeren ptr2,
de file pointer die ik heb hier gemaakt, als argument voor een functie die
schrijft informatie naar een bestand.
En vergelijkbaar met het schrijven, is er ook de optie om te voegen, een.
Het verschil tussen schrijven en voegen
is dat als je schrijft naar een bestand, als u een oproep om fopen voor het schrijven te maken
en dat het bestand al bestaat, het is gaat om het hele bestand te overschrijven.
Het gaat om te beginnen aan het begin,
alle gegevens wissen dat er al is.
>> Terwijl als je het voor het toevoegen te openen, zal naar het einde van het bestand
Als er al tekst in het of gegevens in,
en het zal dan beginnen het schrijven van daar.
Dus zal je niet een van de verliezen informatie die je eerder hebt gedaan.
Of u nu wilt schrijven of toevoegen soort afhankelijk van de situatie.
Maar u zult waarschijnlijk weten wat de juiste werking is wanneer de tijd komt.
Dus dat is fopen.
>> Hoe zit het met fclose?
Nou, vrij eenvoudig, fclose gewoon aanvaardt de file pointer.
En zoals je zou verwachten, sluit dat bestand.
En als we eenmaal een bestand hebt gesloten, kunnen we niet voeren meer file I / O-functies,
lezen of schrijven, op dat bestand.
We moeten opnieuw openen bestand een andere tijd in orde
om te blijven werken met met behulp van de I / O-functies.
Dus fclose middelen we klaar het werken met dit bestand.
En alles wat we nodig hebben om in voorbij is de naam van een bestand pointer.
Dus over een paar slides geleden, we fopened bestand 1 dot tekst voor te lezen
en wij toegewezen file pointer naar ptr1.
Nu hebben we besloten dat we gedaan lezen van dat bestand.
We hoeven niet meer doen.
We kunnen gewoon fclose ptr1.
En evenzo, kunnen we FSluit de andere.
Prima.
Dus dat is het openen en sluiten.
Dit zijn de twee fundamentele beginnen operaties.
>> Nu willen we eigenlijk doe wat interessante dingen,
en de eerste functie die we zullen dat zal doen, dat is fgetc--
bestand krijgen een personage.
Dat is wat fgetc algemeen zou vertalen naar.
Het doel in het leven is het volgende teken te lezen,
of als dit je zeer eerste oproep om fgetc
voor een bepaald bestand, het eerste teken.
Maar dan na dat, u het volgende te krijgen,
de volgende karakter van dat bestand, en opgeslagen in een variabele aard.
Zoals we hier hebben gedaan, char ch gelijk fgetc,
pas in de naam van een bestand pointer.
Nogmaals, het is heel hier belangrijk om te onthouden
dat om zijn deze operatie slaagt,
het bestand pointer zelf moest hebben geopend voor lezen.
We kunnen een personage niet lezen uit een bestand pointer die wij voor schrijven geopend.
Dus dat is een van de beperkingen van fopen, toch?
We moeten beperken onszelf alleen uitvoeren
een bedrijf met een bestand pointer.
Als we wilden te lezen en schrijven vanuit hetzelfde bestand,
we zouden openen twee afzonderlijke hebben bestand verwijzingen naar dezelfde file--
één voor het lezen, voor schrijven.
>> Dus nogmaals, de enige reden Ik breng dat tot nu
want als we gaan om te bellen om fgetc, dat bestand pointer was vast
geopend voor lezen.
En dan vrij eenvoudig, alles wat we moeten doen
is pas in de naam van het bestand pointer.
Dus char ch gelijk fgetc ptr1.
>> Dat gaat ons de volgende character--
of ook, indien dit de eerste keer dat we deze oproep,
de eerste character-- ongeacht bestand wordt gewezen door ptr1.
Bedenk dat dat was bestand 1 dot tekst.
Het zal het eerste teken van die krijgen en we zullen het op te slaan in de variabele l.
Vrij eenvoudig.
Dus we hebben alleen gekeken naar drie functies en al we
kan iets behoorlijk netjes te doen.
>> Dus als we dit vermogen het krijgen van een karakter
en we lus het-- dus we blijven personages
uit een bestand over en nu voorbij en we over--
kan lezen elke karakter van een bestand.
En als we elk karakter afdrukken onmiddellijk nadat we het lezen,
hebben we nu lezen uit een bestand en gedrukte de inhoud naar het scherm.
We hebben effectief samengevoegd dat bestand op het scherm.
En dat is wat de Linux commando cat doet.
>> Als je kat typt in de bestandsnaam, maar zal de gehele inhoud uitprinten
van het bestand in het terminal-venster.
En dus deze kleine lus hier slechts drie regels code,
maar het effectief dupliceert de Linux commando cat.
Dus dit zou syntaxis ziet er een beetje raar,
maar hier is wat er hier gebeurt.
Terwijl ch gelijk fgetc, ptr niet gelijk aan EOF-- het is een hele mondvol,
maar laten we breken het gewoon neer dus het is duidelijk over de syntaxis.
Ik heb het geconsolideerd omwille van de ruimte,
hoewel het een beetje syntactisch lastig.
>> Dus dit deel in het groen rechts Nu, wat doet het?
Nou, dat is gewoon onze fgetc oproep, toch?
We hebben gezien dat vóór.
Het verkrijgen van een personage uit het bestand.
Vervolgens vergelijken we dat karakter tegen EOF.
EOF is een bijzondere waarde die gedefinieerd in standaard io.h, die
is het einde van het bestand karakter.
Dus eigenlijk wat er gaat gebeuren wordt deze lus zal een teken te lezen,
vergelijk het met EOF, de einde van het bestand karakter.
Als ze niet overeenkomen, dus we hebben niet aan het einde van het bestand
zullen we dat karakter uit te printen.
Dan zullen we terug naar de begin van de lus weer.
We zullen een karakter te krijgen, check tegen EOF, print het uit, en ga zo maar door
enzovoort, enzovoort, doorlussen op die manier
we tot het einde van het bestand heeft bereikt.
En dan door dat punt, we zullen hebben gedrukt
de volledige inhoud van het bestand.
Dus nogmaals, we hebben alleen gezien fopen, fclose en fgetc
en nu al kunnen we dupliceren een Linux terminal commando.
>> Zoals ik al zei aan het begin, we hadden fgetc en fputc,
en fputc was de metgezel functie van fgetc.
En dus, als je zou denken, is het schrijven equivalent.
Het stelt ons in staat om te schrijven enkel teken naar een bestand.
>> Nogmaals, het voorbehoud dat, net zoals het was met fgetc, het bestand
dat we schrijven naar moet heb geopend voor het schrijven of het toevoegen.
Als we proberen en gebruik fputc op een bestand dat we voor het lezen hebt geopend,
we gaan lijden een beetje een vergissing.
Maar het nummer is vrij eenvoudig.
fputc hoofdletter A ptr2, alle dat gaat doen, is het
naar de brief te schrijven in A in bestand 2 dot
tekst, die de naam van de was bestand dat we geopend en toegewezen
de aanwijzer naar ptr2.
Dus we gaan naar een schrijven hoofdletter A tot en met 2 dot tekstbestand.
En we zullen een uitroepteken schrijven wijzen op 3 dot bestand
tekst, die werd aangewezen door ptr3.
Dus nogmaals, hier vrij eenvoudig.
>> Maar nu kunnen we nog iets doen.
We hebben dit voorbeeld we waren gewoon gaan over
over de mogelijkheid om de kat te repliceren Linux commando, degene die wordt afgedrukt
naar het scherm.
Nou, nu dat we de mogelijkheid hebben tekens uit bestanden gelezen
en schrijf personages om bestanden, waarom doen we niet in de plaats alleen dat
bellen om printf met een oproep tot fputc.
>> En nu hebben we gedupliceerd cp, een zeer fundamentele Linux command
dat hebben we gesproken over de lange weg geleden in de Linux-commando's video.
We hebben effectief gedupliceerd dat hier.
We lezen van een karakter en dan zijn we schrijft dat karakter naar een ander bestand.
Lezen van een bestand, het schrijven een andere, telkens
en weer totdat we raken EOF.
We hebben tot het einde van het file we proberen te kopiëren.
En dat we allemaal hebben geschreven van de personages die we nodig hebben om het bestand
dat we schrijven naar.
Dus dit is cp, de Linux kopie commando.
>> Aan het begin van Deze video, had ik de waarschuwing
dat we zouden praten beetje over pointers.
Hier is met name waar we zijn gaan praten over pointers
Naast bestand pointers.
Dus deze functie ziet er een beetje eng.
Het heeft een aantal parameters.
Er is veel aan de hand.
Er is een heleboel verschillende kleuren en teksten.
Maar echt, het is gewoon de generieke versie van fgetc
dat ons toelaat om elke krijgen hoeveelheid informatie.
Het kan een beetje inefficiënt als we krijgen tekens één voor één,
itereren door het bestand één karakter per keer.
Zou het niet leuker om te krijgen 100 tegelijk of 500 tegelijk?
>> Nou, fread en zijn metgezel functie fwrite, die we praten over
in een tweede, laat ons om dat te doen.
We kunnen een willekeurige hoeveelheid gelezen van informatie uit een bestand
en slaan we het ergens tijdelijk.
In plaats van te kunnen gewoon past het in een enkele variabele,
we nodig zou kunnen hebben om het op te slaan in een array.
En ja, we passeren in vier argumenten om een ​​pointer fread--
naar de locatie waar we zijn naar informatie op te slaan,
hoe groot elke informatie-eenheid zal zijn, hoeveel eenheden van informatie
we willen verwerven, en uit welk bestand we willen hen te krijgen.
Waarschijnlijk best geïllustreerd een voorbeeld hiervan.
Dus laten we zeggen dat we verklaren een array van 10 integers.
We hebben net verklaard op de stack willekeurig int arr 10.
Dus dat is vrij eenvoudig.
Nu wat we wel doen is de frecall is dat we lezen grootte van int
tijden 10 bytes van gegevens.
Grootte van int wezen four-- dat is de grootte van een integer in c.
>> Dus wat we doen is dat we lezen 40 bytes waarde van informatie
uit het bestand naar wijst ptr.
En we zijn het opslaan van die 40 bytes ergens
waar we vernietiging 40 bytes waarde van het geheugen.
Gelukkig hebben we al gedaan door verklaren arr, die array daar.
Dat kan voor 10 vier-byte-eenheden.
Dus in totaal, kan het te houden 40 bytes waarde van informatie.
En we zijn nu leest 40 bytes van informatie uit het dossier,
en we deze opslaan in arr.
>> Herinneren van de video op aanwijzingen die de naam van een array, zoals arr,
is eigenlijk gewoon een pointer zijn eerste element.
Dus als we passeren arr daar, we in feite, passeren in een pointer.
>> Op dezelfde manier kunnen we dit-- doen we doen niet per se
moeten onze buffer op te slaan op de stapel.
We konden ook dynamisch toewijzen een buffer als deze, met behulp van malloc.
Vergeet niet, als we dynamisch geheugen toewijzen,
we slaan op de heap, niet de stapel.
Maar het is nog steeds een buffer.
>> Nog steeds, in dit geval is met 640 bytes aan informatie
omdat een dubbel neemt acht bytes.
En we vragen voor 80 van hen.
Wij willen ruimte 80 tweepersoonskamers houden.
Dus 80 maal 8 is 640 bytes informatie.
En dat de oproep tot fread is het verzamelen van 640 bytes informatie
uit het bestand waarnaar wordt verwezen door ptr en slaan nu in arr2.
>> Nu kunnen we ook fread behandelen net als een oproep tot fgetc.
In dit geval zijn we gewoon proberen te krijgen een personage uit het bestand.
En we hebben geen behoefte array om een ​​personage te houden.
We kunnen gewoon opslaan in een teken variabele.
>> De vangst is echter dat als we gewoon een variabele,
moeten we pas in de adres van die variabele
omdat herinneren dat de eerste argument om fread
is een aanwijzer naar de locatie en het geheugen waar we willen de informatie op te slaan.
Nogmaals, de naam van een array is een pointer.
Dus we hoeven niet te ampersand serie te doen.
Maar c, het karakter c Hier is geen matrix.
Het is gewoon een variabele.
En dus moeten we een pas c teken aangeven
dat is het adres waar we willen dit ene byte informatie op te slaan,
dit een teken dat we verzamelen van ptr.
Fwrite-- Ik zal gaan door dit een beetje meer
quickly-- is vrijwel exacte equivalent van fread
behalve dat het voor het schrijven in plaats van het lezen, net
zoals de other-- we geopend hebben gehad en in de buurt, krijgen een karakter,
brief karakter.
Nu is het te arbitrair hoeveelheid informatie,
recht arbitraire hoeveelheid informatie.
Dus net als voorheen, we can een reeks van 10 getallen
waar we al opgeslagen, misschien.
>> Het was waarschijnlijk een aantal regels code die moet gaan tussen deze twee
waar ik vullen arr met iets zinvols.
Ik vul het met 10 verschillende getallen.
En in plaats daarvan, wat ik ben doen is het schrijven van arr
en het verzamelen van de informatie van arr.
En ik ben het nemen van die informatie en schoot het bestand.
>> Dus in plaats van dat het uit het bestand naar de buffer,
we gaan nu uit de buffer naar het bestand.
Dus het is gewoon het omgekeerde.
Dus nogmaals, net als voorheen, we can hebben ook een hoop brok van geheugen
dat we hebben dynamisch toegewezen en gelezen van die
en schrijf dat voor het bestand.
>> En we hebben ook een enkele variabele staat die één byte
informatie, zoals een karakter.
Maar nogmaals, we moeten in passeren het adres van die variabele
wanneer we willen lezen van het.
Dus we kunnen het schrijven vinden we op dat adres
om het bestand pointer, ptr.
>> Er zijn tal van andere grote file I / O-functies
dat doen verschillende dingen naast degenen die we hebben gesproken over vandaag.
Enkele degenen u misschien nuttig vindt
zijn fgets en fputs, die het equivalent
van fgetc en fputc maar voor het lezen een snaar van een bestand.
In plaats van een enkel teken, het zal een hele reeks lezen.
fprintf, die in principe mogelijk maakt u printf gebruiken om te schrijven naar bestand.
Dus net zoals je het kunt doen variabele substitutie met behulp
de placeholders procent i en procent d, enzovoort, met printf
U kunt op dezelfde manier neemt u de printf string en druk iets
als dat een bestand.
>> fseek-- als u een dvd-speler is de analogie gebruik ik meestal hier--
is een beetje als het gebruik van uw terugspoelen en vooruitspoelen
knoppen om te bewegen rond de film.
Ook kunt u bewegen het bestand.
Een van de dingen binnen dat bestandsstructuur
dat c creëert voor u is een indicator van waar je bent in het bestand.
Bent u aan het beginnend bij byte nul?
Bent u op byte 100, byte 1000, enzovoorts?
U kunt fseek gebruiken om willekeurig te bewegen dat indicator vooruit of achteruit.
>> En ftell, opnieuw vergelijkbaar met een DVD-speler,
is als een kleine klok die vertelt je hoeveel minuten en seconden u
zijn in een bepaalde film.
Ook ftell vertelt u hoe vele bytes u in het bestand.
feof is een andere versie detecteren of je hebt
aan het einde van het bestand.
En ferror is een functie die u kunt gebruiken
om te detecteren of er iets misgegaan werken met een bestand.
Nogmaals, dit is gewoon krassen op het oppervlak.
Er is nog veel meer file I / O functies in de standaard io.h.
Maar dit zal u waarschijnlijk begon te werken met file pointers.
Ik ben Doug Lloyd.
Dit is CS50.