>> Spreker: So ver, is dit waarskynlik dat die meeste van jou programme
het 'n bietjie efemere nie.
Jy hardloop 'n program soos Mario of Greedy.
Dit doen iets, dit dalk vra die gebruiker vir 'n paar inligting,
druk sommige uitset na die skerm, maar dan wanneer jou program verby is,
daar is regtig geen bewyse is daar dit ooit loop in die eerste plek.
Ek bedoel, seker, jy kan verlaat dit oop in die terminale venster,
maar as jy jou skerm skoon te maak, is daar ' werklik geen bewyse dat dit bestaan.
Ons het nie 'n middel van die stoor het aanhoudende inligting, inligting
wat bestaan ​​nadat ons program het opgehou hardloop,
of ons het nie tot op hierdie punt.
Gelukkig maar, c doen voorsien ons met die vermoë
om dit te doen deur die implementering van iets genoem
'n lêer, 'n struktuur wat basies verteenwoordig 'n lêer wat jy sou verdubbel
Klik op jou rekenaar, as jy gebruik om 'n grafiese gebruikerskoppelvlak omgewing.
Algemeen by die werk met c, ons is eintlik
gaan om te werk met verwysings na lêer files-- stars--
behalwe vir 'n bietjie wanneer ons praat oor 'n paar
van die funksies wat werk met lêer verwysings.
Jy hoef nie regtig gegrawe te diep in begrip pointers
hulself.
Daar is 'n bietjie Teeny bietjie waar ons sal praat oor hulle,
maar oor die algemeen te dien wysers en wysers, terwyl onderling,
is nie presies dieselfde ding.
>> Nou wat moet ek bedoel wanneer Ek sê aanhoudende data?
Wat is 'n aanhoudende data?
Hoekom moet ons omgee?
Sê, byvoorbeeld, dat jy 'n program
of jy herskryf n program wat is 'n spel,
en jy wil om tred te hou van alle beweeg die gebruiker se
sodat miskien as iets verkeerd gaan, kan jy die lêer na die wedstryd te hersien.
Dit is wat ons bedoel wanneer ons praat oor hardnekkige data.
>> In die loop van die bestuur van jou program, is 'n lêer geskep.
En wanneer jou program gestop hardloop,
die lêer bestaan ​​steeds op jou stelsel.
En ons kan kyk na dit en dit ondersoek.
En sodat program sal ingestel word om het 'n paar hardnekkige data geskep,
data bestaan ​​na die program klaar hardloop.
>> Nou al hierdie funksies wat werk met die skep van lêers en manipuleer
hulle op verskeie maniere lewe in die standaard io.h,
wat is 'n kop-lêer wat jy waarskynlik gewees het pond
insluitende by die top van die mooi veel van al jou programme
omdat dit een van die bevat mees nuttige funksies vir ons,
printf, wat ook kan woon in die standaard io.h.
Sodat jy nie nodig het om te skut sluit enige bykomende lêers waarskynlik
om te werk met lêer verwysings.
>> Nou is elke enkele lêer wyser funksie, of elke enkele lêer I / O, insette uitset
funksie, aanvaar as een van sy parameters of insette
'n lêer pointer-- behalwe vir een, fopen, wat
is wat jy gebruik om die lêer te kry wyser in die eerste plek.
Maar nadat jy het die lêer en jy kry lêer verwysings,
kan jy hulle dan slaag as argumente om die verskillende funksies
ons gaan om te praat oor vandag, asook vele ander
sodat jy kan werk met lêers.
>> So is daar ses mooi algemene basiese kinders
dat ons gaan om te praat oor vandag.
fopen en sy metgesel funksie fclose, fgetc
en sy metgesel funksie fputc, en fread en sy metgesel funksie,
fwrite.
So laat ons kry reg in dit.
>> fopen-- wat doen dit?
Wel, dit maak 'n lêer en dit gee jou 'n lêer wyser om dit,
sodat jy dan kan gebruik wat lêer wyser as 'n argument
aan enige van die ander lêer I / O funksies.
Die belangrikste ding om te onthou met fopen
is dat nadat jy oopgemaak het die lêer of 'n oproep gemaak soos die een hier,
wat jy nodig het om te kyk om seker te maak dat die wyser wat jou terug gekry
is nie gelyk aan null.
As jy die video op nie gekyk wysers, is dit dalk nie sin maak nie.
Maar as jy probeer en dereference 'n null pointer onthou,
Jou program sal waarskynlik ly 'n segmentering [onhoorbaar].
Ons wil seker maak dat ons het 'n wettige wyser terug.
Die oorgrote meerderheid van die tyd wat ons sal het 'n wettige wyser terug gekry
en dit sal 'n probleem te wees nie.
>> So hoe maak ons ​​'n oproep om fopen?
Dit lyk pretty much soos hierdie.
Lêer star ptr-- PTR 'n generiese naam vir die lêer pointer-- fopen
en ons slaag in twee dinge, 'n lêer naam en 'n operasie wil ons onderneem.
So kan ons 'n oproep wat lyk soos het lêer star ptr this-- 1 gelyk fopen
file1.txt.
En die operasie het ek gekies het is r.
>> So wat dink jy r is hier?
Wat is die aard van die dinge wat ons dalk in staat wees om te doen om lêers?
So r is die operasie dat ons kies wanneer ons wil 'n lêer te lees.
So sou ons basies wanneer Ons maak 'n oproep soos hierdie
kry ons 'n lêer wyser so dat ons dan kon lees inligting
van file1.txt.
>> Net so, kan ons lêer 2.txt oop vir die skryf en sodat ons kan slaag ptr2,
die lêer wyser Ek het hier geskep is, as 'n argument om enige funksie wat
skryf inligting na 'n lêer.
En soortgelyk aan die skryf, daar is ook die opsie om by te voeg, 'n.
Die verskil tussen skryf en die aanbring
is dat wanneer jy skryf 'n lêer, as jy 'n oproep om fopen vir skryf te maak
en dat die lêer bestaan ​​reeds, dit is gaan die hele lêer te vervang.
Dit gaan om te begin aan die begin,
al die inligting te verwyder dit is reeds daar.
>> Terwyl as jy dit vir die aanbring van oop, dit sal gaan tot die einde van die lêer
As daar reeds teks dit of inligting in dit,
en dit sal dan begin skryf van daar af.
So sal jy nie enige van die verloor inligting wat jy voorheen gedoen het nie.
Of jy nou wil om te skryf of voeg soort hang af van die situasie.
Maar jy sal waarskynlik weet wat die regte operasie is wanneer die tyd kom.
So dit is fopen.
>> Wat van fclose?
Wel, mooi eenvoudig, fclose net aanvaar die lêer wyser.
En as jy kan verwag, dit sluit die lêer.
En sodra ons 'n lêer het gesluit, kan ons nie voer meer lêer I / O funksies,
lees of skryf, op die lêer.
Ons het om te her-open die lêer 'n ander tyd in orde
om voort te gaan werk met dit met behulp van die I / O funksies.
So fclose beteken ons is gedoen werk met hierdie lêer.
En al wat ons nodig het om te slaag in is die naam van 'n lêer wyser.
So op 'n paar skyfies gelede, het ons fopened lêer 1 dot teks vir die lees
en ons dat opgedra lêer wyser na ptr1.
Nou het ons besluit ons gedoen lees van die lêer.
Ons het nie nodig om meer te doen met dit.
Ons kan net fclose ptr1.
En insgelyks, kan ons fclose die ander kinders.
Alles reg.
So dit is die opening en sluiting.
Dit is die twee basiese begin bedrywighede.
>> Nou wil ons eintlik doen 'n paar interessante dinge,
en die eerste funksie wat ons sal sien dat sal doen wat fgetc--
lêer kry 'n karakter.
Dit is wat algemeen fgetc sou vertaal.
Sy doel in die lewe is om die volgende karakter te lees,
of as dit jou baie eerste oproep om fgetc
vir 'n spesifieke lêer, die eerste karakter.
Maar dan daarna, jy die volgende een te kry,
die volgende karakter van die lêer, en slaan dit in 'n karakter veranderlike.
Soos ons hier gedoen het, char ch gelyk fgetc,
slaag in die naam van 'n lêer wyser.
Weereens, dit is baie belangrik om te onthou hier
dat dit in orde om hierdie aksie slaag nie,
die lêer wyser self het seker geopen vir die lees.
Ons kan 'n karakter nie lees van 'n lêer wyser dat ons vir skryf oop.
So dit is een van die beperkinge van fopen, reg?
Ons het om te beperk onsself net presteer
een operasie met 'n lêer wyser.
As ons wou om te lees en skryf van die dieselfde lêer,
sou ons oop twee afsonderlike het lêer verwysings na dieselfde file--
een vir die lees, een vir skryf.
>> So weer, die enigste rede Ek bring dat tot nou
want as ons gaan om 'n oproep te maak om fgetc, die lêer wyser het seker
geopen vir die lees.
En dan mooi eenvoudig, Al wat ons moet doen
is verby in die naam van die lêer wyser.
So char ch gelyk fgetc ptr1.
>> Dit gaan om ons te kry die volgende character--
of weer, as dit is die eerste tyd wat ons het hierdie oproep gemaak het,
die eerste character-- van watter lêer daarop om deur ptr1.
Onthou dat dit was lêer 1 dot teks.
Dit sal die eerste karakter van daardie te kry en ons sal dit op te slaan in die veranderlike ch.
Redelik eenvoudig.
Dus het ons net kyk na drie funksies en reeds ons
kan iets mooi netjies te doen.
>> So as ons hierdie vermoë om 'n karakter
en ons lus it-- sodat ons voortgaan om karakters te kry
uit 'n lêer oor en nou verby en ons over--
kan lees elke enkele karakter van 'n lêer.
En as ons elke karakter te druk onmiddellik nadat ons dit lees,
ons het nou gelees van 'n lêer en gedruk die inhoud op die skerm.
Ons het effektief saamgevoeg dat 'n lêer op die skerm.
En dit is wat die Linux command kat doen.
>> As jy die kat tik in die naam van die lêer, is dit sal die hele inhoud druk
van die lêer in jou terminale venster.
En so hierdie klein lus hier slegs drie reëls van die kode,
maar dit effektief duplikate die Linux command kat.
So hierdie sintaksis dalk kyk 'n bietjie vreemd,
maar hier is wat hier gebeur.
Terwyl ch gelyk fgetc, ptr is nie gelyk aan EOF-- dit is 'n hele mondvol,
maar laat breek dit net af so dit is duidelik oor die sintaksis.
Ek het dit gekonsolideer ter wille van die ruimte,
hoewel dit 'n bietjie sintakties lastig.
>> So hierdie deel in die groen regte Nou, wat is om dit te doen?
Wel, dit is net ons fgetc oproep, reg?
Ons het gesien dat voor.
Dit is die verkryging van 'n karakter van die lêer.
Dan vergelyk ons ​​dat karakter teen EOF.
EOF is 'n spesiale waarde wat gedefinieer in die standaard io.h, wat
is die einde van die lêer karakter.
So basies wat gaan gebeur is hierdie lus sal 'n karakter te lees,
dit vergelyk met eof, die einde van die lêer karakter.
As hulle nie pas nie, so ons het nie aan die einde van die lêer,
ons sal daardie karakter uit te druk.
Dan sal ons terug te gaan na die begin van die lus weer.
Ons sal 'n karakter te kry, gaan teen EOF, druk dit uit, en so aan
en so aan en so aan, deur herhaling op dié manier
totdat ons die einde van die lêer bereik het.
En dan deur daardie punt, Ons sal gedruk
uit die hele inhoud van die lêer.
So weer, het ons net gesien fopen, fclose en fgetc
en al kan ons dupliseer 'n Linux terminale opdrag.
>> Soos ek gesê het aan die begin, ons het fgetc en fputc,
en fputc was die metgesel funksie van fgetc.
En so, as jy dalk dink, dit is die skrif ekwivalent.
Dit stel ons in staat om 'n skrywe enkele karakter na 'n lêer.
>> Weereens, die caveat dat, net soos dit was met fgetc, die lêer
dat ons skryf aan het seker al oop vir skryf of vir die aanbring.
As ons probeer en gebruik fputc op 'n lêer dat ons vir die lees oopgemaak het,
ons gaan ly 'n bietjie van 'n fout.
Maar die oproep is redelik eenvoudig.
fputc kapitaal A ptr2, al wat gaan doen, is dit
gaan die brief te skryf in 'n lêer in 2 dot
teks, wat die naam van die was lêer dat ons oopgemaak en opgedra
die wyser na ptr2.
So ons gaan 'n skrywe kapitaal A tot 2 dot tekslêer.
En ons sal 'n uitroep skryf wys 3 dot lêer
teks, wat wys na die ptr3.
So weer, hier redelik eenvoudig.
>> Maar nou kan ons nog 'n ding te doen.
Ons het hierdie voorbeeld ons net gaan oor
oor die vermoë om die kat te herhaal Linux opdrag, die een wat druk uit
na die skerm.
Wel, nou dat ons die vermoë om die karakters van lêers te lees
en skryf karakters lêers, Daarom het ons nie vervang net dat
bel om printf met 'n oproep om fputc.
>> En nou het ons gedupliseer CP, 'n baie basiese Linux command
dat ons gepraat oor 'n lang pad gelede in die Linux instruksies video.
Ons het effektief gedupliseer dat hier.
Ons lees van 'n karakter en dan is ons skryf dat karakter na 'n ander lêer.
Lees van 'n lêer, skryf na 'n ander, oor en oor
en oor weer totdat ons getref EOF.
Ons het tot die einde van die lêer ons probeer om te kopieer van.
En dat ons sal al geskryf het van die karakters wat ons nodig het om die lêer
dat ons skriftelik aan.
So dit is CP, die Linux kopie opdrag.
>> Aan die begin van hierdie video het ek die caveat
dat ons 'n wil praat bietjie oor wenke.
Hier is spesifiek waar ons gaan om te praat oor pointers
bykomend tot lêer verwysings.
So hierdie funksie lyk soort van scary.
Dit het 'n hele paar parameters.
Daar is 'n baie gaan op hier.
Daar is 'n baie verskillende kleure en tekste.
Maar regtig, dit is net die generiese weergawe van fgetc
wat ons toelaat om enige te kry hoeveelheid inligting.
Dit kan 'n bietjie ondoeltreffende as ons kry karakters op 'n tyd,
iterating deur die lêer een karakter op 'n tyd.
Sou dit nie mooier te kry 100 op 'n slag of 500 op 'n slag?
>> Wel, fread en sy metgesel funksie fwrite, wat ons sal praat oor
in 'n tweede, ons toelaat om dit te doen.
Ons kan nie 'n arbitrêre bedrag gelees inligting van 'n lêer
en ons bêre dit iewers tydelik.
In plaas van om te kan net pas dit in 'n enkele veranderlike,
ons dalk nodig om dit te stoor in 'n skikking.
En so het ons slaag in vier argumente om 'n wyser fread--
om die ligging waar ons gaan om inligting te stoor,
hoe groot elke eenheid van inligting sal wees, hoeveel eenhede van inligting
ons wil bekom, en van watter lêer ons wil om dit te kry.
Waarskynlik die beste geïllustreer met 'n voorbeeld hier.
So kom ons sê dat ons verklaar 'n verskeidenheid van 10 heelgetalle.
Ons het nou net verklaar word op die stapel arbitrêr int arr 10.
So dit is redelik eenvoudig.
Nou wat ons al te doen, is die frecall is ons lees grootte van int
keer 10 grepe van inligting.
Grootte van int wese four-- dis die grootte van 'n heelgetal in c.
>> So wat ons doen is ons lees 40 grepe waarde van inligting
uit die lêer verwys na deur ptr.
En ons stoor diegene 40 grepe iewers
waar ons opsygesit 40 grepe waarde van die geheue.
Gelukkig het ons reeds gedoen deur verklaar arr dat array reg daar.
Dit is in staat om van hou 10 vier-byte eenhede.
So in totaal, kan dit hou 40 grepe werd van inligting.
En ons is nou lees 40 grepe van inligting uit die lêer,
en ons is dit stoor in arr.
>> Onthou uit die video op pointers wat die naam van 'n skikking, soos arr,
is eintlik net 'n wyser om sy eerste element.
So wanneer ons slaag in arr daar, het ons is, in werklikheid, verby in 'n wyser.
>> Net so kan ons this-- doen ons doen nie noodwendig
moet ons buffer bespaar op die stapel.
Ons kan ook dinamiese toewys 'n buffer soos hierdie, met behulp van malloc.
Onthou, wanneer ons dinamiese toewys geheue,
ons spaar dit op die hoop, nie die stapel.
Maar dit is nog steeds 'n buffer.
>> Dit nog steeds, in hierdie geval, is hou 640 grepe inligting
omdat 'n dubbele neem agt grepe.
En ons vra vir 80 van hulle.
Ons wil ruimte 80 dubbelspel te hou.
So 80 keer 8 is 640 grepe inligting.
En dat oproep om fread is invordering 640 grepe inligting
uit die lêer verwys na deur PTR en stoor dit nou in arr2.
>> Nou kan ons ook fread behandel net soos 'n oproep om fgetc.
In hierdie geval, ons net probeer om kry een karakter uit die lêer.
En ons het nie 'n moet skikking om 'n karakter te hou.
Ons kan net stoor dit in 'n karakter veranderlike.
>> Die vangs, al is, is dat wanneer ons net 'n veranderlike,
ons nodig het om te slaag in die adres van daardie veranderlike
want onthou dat die eerste argument fread
is 'n verwysing na die plek en geheue waar ons wil die inligting te stoor.
Weereens, die naam van 'n skikking is 'n wyser.
Sodat ons nie nodig het om te ampersand verskeidenheid te doen.
Maar c, die karakter c hier is, is nie 'n skikking.
Dit is net 'n veranderlike.
En so het ons nodig het om te slaag 'n ampersand c om aan te dui
dat dit is die adres waar ons wil hierdie een byte van inligting te stoor,
hierdie een karakter wat ons insamel ptr.
Fwrite-- Ek sal deurgaan dit 'n bietjie meer
quickly-- is pretty much die presiese ekwivalent van fread
behalwe dit is vir skryf in plaas van die lees, net
soos die other-- ons oop gehad het en sluit, kry 'n karakter,
skryf 'n karakter.
Nou is dit te kry arbitrêre hoeveelheid inligting,
reg arbitrêre hoeveelheid inligting.
So net soos voorheen, kan ons het 'n verskeidenheid van 10 heelgetalle
waar ons reeds ' inligting gestoor, miskien.
>> Dit was waarskynlik 'n paar reëls van die kode wat moet gaan tussen hierdie twee
waar ek vul skik met iets betekenisvol.
Ek vul dit met 10 verskillende heelgetalle.
En in plaas daarvan, wat ek doen, is skryf van arr
en die invordering van die inligting uit arr.
En ek neem dat die inligting en sit dit in die lêer.
>> So in plaas van dit wat uit die lêer om die buffer,
ons gaan nou uit die buffer om die lêer.
So dit is net die omgekeerde.
So weer, net soos voorheen, kan ons het ook 'n hoop stuk van die geheue
wat ons het dinamies toegeken en lees van daardie
en skryf dit op die lêer.
>> En ons het ook 'n enkele veranderlike staat van die hou van 'n byte
van inligting, soos 'n karakter.
Maar weereens, moet ons in slaag die adres van daardie veranderlike
wanneer ons wil om te lees van dit.
So kan ons die inligting skryf vind ons by daardie adres
om die lêer pointer, ptr.
>> Daar is baie van die ander groot lêer I / O funksies
doen verskeie dinge behalwe die wat ons het gepraat oor vandag.
'N Paar van die kinders jy dalk nuttig vind
is fgets en fputs, wat die ekwivalent
van fgetc en fputc maar vir die lees 'n enkele string van 'n lêer.
In plaas van 'n enkele karakter, dit sal 'n hele string lees.
fprintf, wat basies kan jy printf gebruik om te skryf na lêer.
So net soos jy die kan doen veranderlike vervanging met behulp
die plekhouers persent i en persent d, en so aan, met printf
jy kan insgelyks neem printf string en druk iets
soos dit na 'n lêer.
>> fseek-- as jy 'n DVD-speler is die analogie Ek gebruik gewoonlik here--
is 'n soort van soos die gebruik van jou rewind en vinnig vorentoe
knoppies om rond te beweeg die film.
Net so, kan jy beweeg om die lêer.
Een van die dinge in dat lêerstruktuur
dat c skep vir jou 'n aanduiding van waar jy is in die lêer.
Is jy op die heel begin op byte nul?
Is jy op byte 100, byte 1000, en so aan?
Jy kan gebruik om fseek arbitrêr beweeg dat aanwyser vorentoe of agtertoe.
>> En ftell weer soortgelyk aan 'n DVD-speler,
is soos 'n klein klok wat vertel jy hoeveel minute en sekondes
is in 'n bepaalde film.
Net so, ftell vertel hoe jy baie grepe jy in die lêer.
feof is 'n ander weergawe van die opsporing of jy het
aan die einde van die lêer.
En ferror is 'n funksie wat jy kan gebruik
op te spoor of iets gegaan verkeerde werk met 'n lêer.
Weereens, dit is net krap die oppervlak.
Daar is nog baie meer lêer I / O funksies in die standaard io.h.
Maar dit sal jy waarskynlik kry begin werk met lêer verwysings.
Ek is Doug Lloyd.
Dit is cs50.