>> Speak: Hittills ÃĊr det troligt att de flesta av dina program
har varit lite kortlivad.
Du kÃ¶r ett program som Mario eller giriga.
Det gÃ¶r nÃċgot, det kanske uppmanas anvÃĊndaren om viss information,
skriva ut vissa utdata till skÃĊrmen, men sedan nÃĊr programmet ÃĊr Ã¶ver,
det finns egentligen inga bevis finns det nÃċgonsin kÃ¶r i fÃ¶rsta hand.
Jag menar, visst, du kanske har lÃĊmnat Det Ã¶ppnas i terminalfÃ¶nstret,
men om du rensar din skÃĊrm, det finns egentligen inga bevis fÃ¶r att det fanns.
Vi har inte ett sÃĊtt att lagra ihÃċllande, information
som existerar efter vÃċr Programmet har stannat,
eller sÃċ har vi inte upp till denna punkt.
Lyckligtvis gÃ¶r c ge oss mÃ¶jlighet
att gÃ¶ra detta genom att implementera nÃċgot som kallas
en fil, en struktur som i grund och botten representerar en fil som du skulle fÃ¶rdubbla
klicka pÃċ din dator, om du ÃĊr van vid ett grafiskt anvÃĊndarmiljÃ¶.
Generellt vid arbete med c, vi ÃĊr faktiskt
kommer att arbeta med pekare till files-- fil stars--
med undantag fÃ¶r lite nÃĊr vi talar om ett par
av de funktioner som arbeta med fil pekare.
Du behÃ¶ver inte ha riktigt grÃĊvt fÃ¶r djupt fÃ¶r att Ã¶ka kunskapen pekare
sjÃĊlva.
Det finns en liten pyttelitet bit dÃĊr vi kommer att prata om dem,
men i allmÃĊnhet fil pekare och pekare, medan varandra,
ÃĊr inte exakt samma sak.
>> Nu vad jag menar nÃĊr Jag sÃĊger ihÃċllande data?
Vad ÃĊr bestÃĊndiga data?
VarfÃ¶r vi bryr oss om det?
SÃĊg till exempel att du kÃ¶r ett program
eller om du har skrivit om en program som ÃĊr ett spel,
och du vill hÃċlla koll av alla anvÃĊndarens rÃ¶relser
sÃċ att kanske om nÃċgot gÃċr fel, du kan granska filen efter matchen.
Det ÃĊr vad vi menar nÃĊr vi prata om bestÃĊndiga data.
>> Under kÃ¶ra din program, skapas en fil.
Och nÃĊr ditt program har stannat,
att filen finns fortfarande pÃċ ditt system.
Och vi kan titta pÃċ det och undersÃ¶ka det.
Och sÃċ det programmet skulle stÃĊllas in pÃċ har skapat nÃċgra bestÃĊndiga data,
Det finns uppgifter efter programmet har kÃ¶rts.
>> Nu har alla dessa funktioner som fungerar med att skapa filer och manipulera
dem pÃċ olika sÃĊtt bor i standard io.h,
vilket ÃĊr en header-fil som du har fÃ¶rmodligen varit pund
inbegripet pÃċ toppen av vackra mycket alla dina program
eftersom den innehÃċller en av de mest anvÃĊndbara funktioner fÃ¶r oss,
printf, som ocksÃċ lÃċter bor i standard io.h.
SÃċ du behÃ¶ver inte pund inkluderar eventuella ytterligare filer fÃ¶rmodligen
fÃ¶r att arbeta med fil pekare.
>> Nu varenda filpekaren funktion, eller varje enskild fil I / O, Input Output
funktionen accepterar som en av dess parametrar eller insatsvaror
en fil pointer-- utom fÃ¶r en, fopen, vilket
ÃĊr vad du anvÃĊnder fÃ¶r att hÃĊmta filen pekaren i fÃ¶rsta hand.
Men efter att du har Ã¶ppnat fil och du fÃċr filen pekare,
Du kan sedan skicka dem som argument till de olika funktionerna
vi kommer att prata om idag, liksom mÃċnga andra
sÃċ att du kan arbeta med filer.
>> SÃċ det finns sex ganska gemensamma grundlÃĊggande ettor
att vi kommer att prata om idag.
fopen och dess fÃ¶ljeslagare funktion fclose, fgetc
och dess fÃ¶ljeslagare funktion fputc, och fread och dess fÃ¶ljeslagare funktion,
fwrite.
SÃċ lÃċt oss fÃċ rÃĊtt till det.
>> fopen-- vad gÃ¶r det?
Tja, Ã¶ppnar det en fil och det ger dig en fil pekare till det,
sÃċ att du sedan kan anvÃĊnda det fil pekare som ett argument
till nÃċgon av de andra fil-I / O-funktioner.
Det viktigaste att minnas med fopen
ÃĊr att nÃĊr du har Ã¶ppnat fil eller gjorde ett samtal som den hÃĊr,
du behÃ¶ver fÃ¶r att kontrollera att att pekaren att du kommer tillbaka
ÃĊr inte lika med noll.
Om du inte har sett videon pÃċ pekare, vilket kanske inte vettigt.
Men om du fÃ¶rsÃ¶ker och dereference en null-pekare Ãċterkallelse,
ditt program kommer sannolikt att bli lidande en segmente [OHÃRBAR].
Vi vill se till att vi fick en legitim pekare tillbaka.
Den stora majoriteten av den tid som vi kommer har fÃċtt en legitim pekare tillbaka
och det kommer inte att vara ett problem.
>> SÃċ hur gÃ¶r vi ett anrop till fopen?
Det ser ut ungefÃĊr som den hÃĊr.
Fil stjÃĊrna ptr-- PTR vara en generisk namn fÃ¶r fil pointer-- fopen
och vi passera i tvÃċ saker, ett filnamn och en operation som vi vill utfÃ¶ra.
SÃċ vi kan ha ett samtal som ser ut this-- fil stjÃĊrn ptr en lika fopen
fil1.txt.
Och operationen jag har valt r.
>> SÃċ vad tror du r ÃĊr hÃĊr?
Vad ÃĊr den typ av saker som vi skulle kunna gÃ¶ra fÃ¶r att filer?
SÃċ r ÃĊr den verksamhet som vi vÃĊlja nÃĊr vi vill lÃĊsa en fil.
SÃċ skulle vi i princip nÃĊr Vi gÃ¶r ett samtal sÃċ hÃĊr
att fÃċ oss en filpekare sÃċ att vi sedan kan lÃĊsa information
frÃċn fil1.txt.
>> PÃċ samma sÃĊtt kan vi Ã¶ppna filen 2.txt fÃ¶r att skriva och sÃċ att vi kan passera ptr2,
filpekaren jag har skapat hÃĊr, som ett argument till en funktion som
skriver information till en fil.
Och liknande till skrivande, det finns ocksÃċ mÃ¶jlighet att lÃĊgga till en.
Skillnaden mellan skriva och lÃĊgga
ÃĊr att nÃĊr du skriver till en fil, om du gÃ¶r ett samtal till fopen fÃ¶r att skriva
och att filen redan existerar, det ÃĊr kommer att skriva Ã¶ver hela filen.
Det kommer att bÃ¶rja i bÃ¶rjan,
radera all information det ÃĊr redan dÃĊr.
>> Medan om du Ã¶ppnar det fÃ¶r att lÃĊgga, det kommer att gÃċ till slutet av filen
Om det redan finns text i det eller informationen i den,
och det kommer dÃċ att bÃ¶rja skriver dÃĊrifrÃċn.
SÃċ du kommer inte att fÃ¶rlora nÃċgon av de information som du har gjort fÃ¶rut.
Oavsett om du vill skriva eller lÃĊgga sorts beror pÃċ situationen.
Men du kommer fÃ¶rmodligen vet vad rÃĊtt verksamhet ÃĊr nÃĊr det ÃĊr dags.
SÃċ det ÃĊr fopen.
>> Vad sÃĊgs om fclose?
Tja, ganska enkelt, fclose bara accepterar filpekaren.
Och som man kan fÃ¶rvÃĊnta sig, det stÃĊnger den filen.
Och nÃĊr vi har stÃĊngt en fil, vi kan inte utfÃ¶ra mer fil-I / O-funktioner,
lÃĊser eller skriver pÃċ den filen.
Vi mÃċste Ãċter Ã¶ppna fil en annan tid fÃ¶r
att fortsÃĊtta arbeta med den med hjÃĊlp av I / O-funktioner.
SÃċ fclose sÃĊtt vi gjort arbeta med denna fil.
Och allt vi behÃ¶ver skicka in ÃĊr namnet pÃċ en fil pekare.
SÃċ pÃċ ett par glider sedan, vi fopened fil 1 dot text fÃ¶r lÃĊsning
och vi tilldelade att fil pekare till ptr1.
Nu har vi beslutat att vi ÃĊr gjort lÃĊsning frÃċn den filen.
Vi behÃ¶ver inte gÃ¶ra nÃċgot mer med det.
Vi kan bara fclose ptr1.
Och pÃċ samma sÃĊtt, kunde vi fclose de andra.
Okej.
SÃċ det ÃĊr att Ã¶ppna och stÃĊnga.
De ÃĊr de tvÃċ grundlÃĊggande startoperationer.
>> Nu vill vi faktiskt gÃ¶ra nÃċgra intressanta saker,
och fÃ¶rsta funktion som vi ska se som kommer att gÃ¶ra det ÃĊr fgetc--
fil fÃċr en karaktÃĊr.
Det ÃĊr vad fgetc allmÃĊnhet skulle Ã¶versÃĊtta till.
Dess mÃċl i livet ÃĊr att LÃĊs nÃĊsta tecken,
eller om detta ÃĊr din mycket fÃ¶rsta samtalet till fgetc
fÃ¶r en viss fil, det fÃ¶rsta tecknet.
Men sedan efter det, du fÃċr nÃĊsta,
redan nÃĊsta karaktÃĊr filen, och lagrar det i ett tecken variabel.
Som vi har gjort hÃĊr, char ch lika fgetc,
passera i namnet pÃċ en fil pekare.
Ã terigen, det ÃĊr mycket viktigt hÃĊr att komma ihÃċg
att fÃ¶r att ha denna operation lyckas,
filpekaren sjÃĊlv mÃċste har Ã¶ppnats fÃ¶r lÃĊsning.
Vi kan inte lÃĊsa en karaktÃĊr frÃċn en fil pekare som vi Ã¶ppnade fÃ¶r skrivning.
SÃċ det ÃĊr en av de begrÃĊnsningar av fopen, eller hur?
Vi mÃċste begrÃĊnsa oss endast utfÃ¶r
en operation med en fil pekare.
Om vi ââville lÃĊsa och skriva frÃċn samma fil,
vi skulle ha Ã¶ppet tvÃċ separata fil pekare till samma file--
ett fÃ¶r lÃĊsning, en fÃ¶r att skriva.
>> SÃċ Ãċterigen, det enda skÃĊlet Jag tar upp det nu ÃĊr
fÃ¶r om vi ska ringa till fgetc, den filen pekare mÃċste har
Ã¶ppnats fÃ¶r lÃĊsning.
Och sedan ganska enkelt, allt vi behÃ¶ver gÃ¶ra
ÃĊr passera i namnet pÃċ filen pekaren.
SÃċ rÃ¶ding lm lika fgetc ptr1.
>> Det kommer att fÃċ oss nÃĊsta character--
eller Ãċterigen, om detta ÃĊr den fÃ¶rsta NÃĊr vi har gjort det hÃĊr samtalet,
den fÃ¶rsta character-- oavsett fil pekas pÃċ av ptr1.
Minns att det var fil 1 dot text.
Det fÃċr det fÃ¶rsta tecknet i det och vi kommer att lagra det i variabeln ch.
Ganska enkelt.
SÃċ vi har bara tittat pÃċ tre funktioner och redan vi
kan gÃ¶ra nÃċgot ganska snyggt.
>> SÃċ om vi tar denna fÃ¶rmÃċga fÃ¶r att fÃċ ett tecken
och vi slinga det-- sÃċ vi fortsÃĊtter att fÃċ tecken
frÃċn en fil Ã¶ver och Ã¶ver och over-- nu vi
kan lÃĊsa varenda karaktÃĊren av en fil.
Och om vi trycker varje tecken omedelbart efter att vi lÃĊst det,
Vi har nu lÃĊsa frÃċn en fil och tryckta innehÃċllet till skÃĊrmen.
Vi har faktiskt sammanlÃĊnkade den filen pÃċ bildskÃĊrmen.
Och det ÃĊr vad Linux kommandot cat gÃ¶r.
>> Om du skriver katt i filnamnet, det kommer att skriva ut hela innehÃċllet
av filen i din terminalfÃ¶nster.
Och sÃċ denna lilla slinga hÃĊr, bara tre rader kod,
men det effektivt duplicerar Linux kommandot cat.
SÃċ hÃĊr syntaxen kanske ser lite konstigt,
men hÃĊr ÃĊr vad som hÃĊnder hÃĊr.
Medan ch lika fgetc, inte ptr lika med EOF-- det ÃĊr en hel munsbit,
men lÃċt oss bryta ner det bara sÃċ det ÃĊr klart pÃċ syntax.
Jag har konsoliderat det fÃ¶r tydlighets utrymme,
ÃĊven om det ÃĊr lite syntaktiskt knepigt.
>> SÃċ hÃĊr delen i grÃ¶nt till hÃ¶ger nu, vad gÃ¶r det?
Tja, det ÃĊr bara vÃċr fgetc samtal, eller hur?
Vi har sett det fÃ¶rut.
Det ÃĊr fÃċ en tecken frÃċn filen.
Sedan jÃĊmfÃ¶ra vi att karaktÃĊr mot EOF.
EOF ÃĊr ett speciellt vÃĊrde som ÃĊr definieras i standarden io.h, vilket
ÃĊr slutet pÃċ filen karaktÃĊr.
SÃċ i princip vad som kommer att hÃĊnda ÃĊr denna slinga kommer att lÃĊsa ett tecken,
jÃĊmfÃ¶ra det med EOF, den filslut karaktÃĊr.
Om de inte stÃĊmmer Ã¶verens, sÃċ vi har inte nÃċtt slutet av filen,
Vi kommer att skriva tecknet ut.
Sedan ska vi gÃċ tillbaka till slingans bÃ¶rjan igen.
Vi fÃċr en karaktÃĊr, kontrollera mot EOF, skriva ut, och sÃċ vidare
och sÃċ vidare och sÃċ vidare, looping igenom pÃċ det sÃĊttet
tills vi har nÃċtt slutet av filen.
Och sedan vid den tidpunkten, Vi kommer att ha tryckt
ut hela innehÃċllet i filen.
SÃċ Ãċterigen, har vi bara sett fopen, fclose och fgetc
och redan kan vi duplicera en linux terminal kommando.
>> Som jag sade i bÃ¶rjan, Vi hade fgetc och fputc,
och fputc var fÃ¶ljeslagare funktion av fgetc.
Och sÃċ, som ni kanske fÃ¶rstÃċr, det ÃĊr skriv motsvarande.
Det ger oss mÃ¶jlighet att skriva en enstaka tecken till en fil.
>> Ã terigen, det fÃ¶rbehÃċllet att, precis som det var med fgetc, filen
att vi skriver till mÃċste har varit Ã¶ppnat fÃ¶r att skriva eller lÃĊgga till.
Om vi ââfÃ¶rsÃ¶ker anvÃĊnda fputc pÃċ en fil att vi har Ã¶ppnat fÃ¶r lÃĊsning,
vi kommer att lida en bit av ett misstag.
Men samtalet ÃĊr ganska enkel.
fputc huvudstad En ptr2, alla det kommer att gÃ¶ra ÃĊr att det ÃĊr
kommer att skriva brev i A i fil 2 dot
text, som var namnet pÃċ den filen som vi Ã¶ppnade och tilldelas
pekaren till ptr2.
SÃċ vi kommer att skriva ett kapital A till fil 2 dot text.
Och vi kommer att skriva ett utropstecken peka pÃċ fil 3 dot
text, som utpekas av ptr3.
SÃċ Ãċterigen, ganska enkelt hÃĊr.
>> Men nu kan vi gÃ¶ra en annan sak.
Vi har detta exempel vi bara gÃċ Ã¶ver
om att kunna replikera katten Linux kommando, den som skriver ut
till skÃĊrmen.
NÃċvÃĊl, nu nÃĊr vi har fÃ¶rmÃċgan att lÃĊsa tecken frÃċn filer
och skriva tecken till filer, varfÃ¶r inte vi bara ersÃĊtta det
ringa fÃ¶r att printf med en uppmaning till fputc.
>> Och nu har vi dupliceras cp, en mycket grundlÃĊggande linux kommando
att vi pratade om hur lÃĊnge sedan i linux kommandon videon.
Vi har pÃċ ett effektivt sÃĊtt dupliceras denna rÃĊtt hÃĊr.
Vi lÃĊser en karaktÃĊr och dÃċ ÃĊr vi skriftligen tecken till en annan fil.
LÃĊsning frÃċn en fil, skriva till en annan, om och om igen
och om igen tills vi hit EOF.
Vi har kommit till slutet av fil vi fÃ¶rsÃ¶ker kopiera frÃċn.
Och genom att vi har skrivit alla av karaktÃĊrerna mÃċste vi filen
att vi skriver till.
SÃċ det hÃĊr ÃĊr cp, kopiera kommandot Linux.
>> Alldeles i bÃ¶rjan av den hÃĊr videon hade jag varning
att vi skulle prata lite om pekare.
HÃĊr ÃĊr sÃĊrskilt dÃĊr vi ÃĊr kommer att tala om pekare
fÃ¶rutom till fil pekare.
SÃċ hÃĊr funktionen ser lite skrÃĊmmande.
Det har fÃċtt flera parametrar.
Det ÃĊr mycket som hÃĊnder hÃĊr.
Det finns en massa olika fÃĊrger och texter.
Men egentligen, det ÃĊr bara generisk version av fgetc
som tillÃċter oss att fÃċ nÃċgon mÃĊngd information.
Det kan vara lite ineffektivt om vi ÃĊr fÃċ tecken ett i taget,
iterera igenom filen ett tecken i taget.
Skulle det inte vara trevligare att fÃċ 100 Ãċt gÃċngen eller 500 pÃċ en gÃċng?
>> Tja, fread och dess fÃ¶ljeslagare funktion fwrite, som vi kommer att prata om
i en andra, tillÃċter oss att gÃ¶ra just detta.
Vi kan lÃĊsa ett godtyckligt belopp av information frÃċn en fil
och vi fÃ¶rvara den nÃċgonstans tillfÃĊlligt.
I stÃĊllet fÃ¶r att kunna precis montera den i en enda variabel,
Vi kanske behÃ¶ver fÃ¶rvara den i en array.
Och sÃċ, vi passerar i fyra argument att fread-- en pekare
till den plats dÃĊr vi ÃĊr kommer att lagra information,
hur stor varje informationsenhet kommer att bli, hur mÃċnga enheter av informations
Vi vill att fÃ¶rvÃĊrva, och frÃċn vilken fil vi vill fÃċ dem.
Illustreras fÃ¶rmodligen bÃĊst med ett exempel hÃĊr.
SÃċ lÃċt oss sÃĊga att vi deklarerar en array av 10 heltal.
Vi har just fÃ¶rklarat pÃċ stapla godtyckligt int arr 10.
SÃċ det ÃĊr ganska enkelt.
Nu vad vi gÃ¶r men ÃĊr frecall ÃĊr vi lÃĊser storleken pÃċ int
gÃċnger 10 byte med information.
Storlek pÃċ int vara four-- det ÃĊr storleken pÃċ ett heltal i c.
>> SÃċ vad vi gÃ¶r ÃĊr att vi lÃĊser 40 byte till ett vÃĊrde av uppgifter
frÃċn filen som utpekas av PTR.
Och vi lagrar dem 40 bytes nÃċgonstans
dÃĊr vi har avsatt 40 byte vÃĊrde av minne.
Lyckligtvis har vi redan gjort det genom att fÃ¶rklara arr att array dÃĊr.
Som har fÃ¶rmÃċga att innehav 10 fyra-byte enheter.
SÃċ totalt, kan det hÃċlla 40 bytes vÃĊrde av information.
Och vi nu lÃĊser 40 byte information frÃċn filen,
och vi lagra den i arr.
>> Minns frÃċn videon pÃċ pekare som namnet pÃċ en array, sÃċsom arr,
ÃĊr egentligen bara en pekare till dess fÃ¶rsta elementet.
SÃċ nÃĊr vi passerar i arr dÃĊr, vi ÃĊr i sjÃĊlva verket, som passerar i en pekare.
>> PÃċ samma sÃĊtt kan vi gÃ¶ra this-- Vi gÃ¶r inte nÃ¶dvÃĊndigtvis
mÃċste rÃĊdda vÃċr buffert pÃċ stacken.
Vi kunde ocksÃċ dynamiskt allokera en buffert sÃċ hÃĊr, med hjÃĊlp av malloc.
Kom ihÃċg att nÃĊr vi dynamiskt allokera minne,
vi sparar det pÃċ hÃ¶g, inte bunten.
Men det ÃĊr fortfarande en buffert.
>> Det fortfarande, i det hÃĊr fallet, ÃĊr hÃċlla 640 byte med information
eftersom en dubbel tar upp Ãċtta byte.
Och vi ber fÃ¶r 80 av dem.
Vi vill ha utrymme att hÃċlla 80 dubbel.
SÃċ 80 gÃċnger 8 ÃĊr 640 bytes information.
Och denna uppmaning till fread ÃĊr samla 640 byte med information
frÃċn filen som pekas pÃċ av PTR och lagra den nu arr2.
>> Nu kan vi ocksÃċ behandla fread precis som ett samtal till fgetc.
I det hÃĊr fallet, vi fÃ¶rsÃ¶ker bara fÃċ ett tecken frÃċn filen.
Och vi behÃ¶ver inte ett array fÃ¶r att hÃċlla ett tecken.
Vi kan bara fÃ¶rvara den i en teckenvariabel.
>> FÃċngsten ÃĊr dock att nÃĊr vi har bara en variabel,
Vi behÃ¶ver skicka i adressen till den variabel
eftersom minns att fÃ¶rsta argumentet till fread
ÃĊr en pekare till platsen och minne dÃĊr vi vill lagra informationen.
Ã terigen, namnet pÃċ en matris ÃĊr en pekare.
SÃċ vi behÃ¶ver inte gÃ¶ra-tecken array.
Men c, karaktÃĊren c hÃĊr ÃĊr inte en matris.
Det ÃĊr bara en variabel.
Och sÃċ vi behÃ¶ver fÃ¶r att klara ett et-c fÃ¶r att indikera
att det ÃĊr den adress dÃĊr vi vill att lagra denna en byte med information,
detta ett tecken som vi samla frÃċn PTR.
Fwrite-- jag ska gÃċ igenom detta lite mer
quickly-- ÃĊr ganska mycket exakt motsvarighet till fread
fÃ¶rutom att det ÃĊr fÃ¶r att skriva istÃĊllet fÃ¶r att lÃĊsa, bara
som other-- vi har haft Ã¶ppna och nÃĊra, fÃċ en karaktÃĊr,
skriva ett tecken.
Nu ÃĊr det fÃċ godtycklig mÃĊngd information,
rÃĊtt godtycklig mÃĊngd information.
SÃċ precis som fÃ¶rut, vi kan har en matris med 10 heltal
dÃĊr vi redan har information som lagras, kanske.
>> Det var fÃ¶rmodligen nÃċgra rader kod som bÃ¶r gÃċ mellan dessa tvÃċ
dÃĊr jag fyller arr med nÃċgot meningsfullt.
Jag fyller den med 10 olika heltal.
Och i stÃĊllet, vad jag gÃ¶r skriver frÃċn arr
och samla in information frÃċn arr.
Och jag tar denna information och sÃĊtta in den i filen.
>> SÃċ i stÃĊllet fÃ¶r att det ÃĊr frÃċn filen till bufferten,
vi nu gÃċr frÃċn bufferten till filen.
SÃċ det ÃĊr bara det omvÃĊnda.
SÃċ Ãċterigen, precis som tidigare, kan vi har ocksÃċ en heap bit av minne
att vi har dynamiskt fÃ¶rdelas och lÃĊsa frÃċn den
och skriver att till filen.
>> Och vi har ocksÃċ en enda variabel fÃ¶rmÃċga att hÃċlla en bitgrupp
av information, sÃċsom ett tecken.
Men Ãċterigen, vi mÃċste passera adressen fÃ¶r den variabeln
nÃĊr vi vill lÃĊsa frÃċn den.
SÃċ vi kan skriva ner informationen Vi hittar pÃċ denna adress
till filpekaren, PTR.
>> Det finns massor av andra stor fil I / O-funktioner
att gÃ¶ra olika saker fÃ¶rutom de vi har pratat om i dag.
Ett par av dem du kan ha nytta av
ÃĊr fgets och fputs, vilka ÃĊr ekvivalenta
av fgetc och fputc men fÃ¶r lÃĊsning en enda strÃĊng frÃċn en fil.
I stÃĊllet fÃ¶r ett enda tecken, Det kommer att lÃĊsa en hel strÃĊng.
fprintf, som i princip gÃ¶r det mÃ¶jligt du kan anvÃĊnda printf att skriva till filen.
SÃċ precis som du kan gÃ¶ra variabelsubstitution med hjÃĊlp av
den platshÃċllarna procent i och procent d, och sÃċ vidare, med printf
kan pÃċ liknande sÃĊtt ta printf strÃĊng och skriva ut nÃċgot
sÃċ dÃĊr till en fil.
>> fseek-- om du har en DVD-spelare ÃĊr analogin jag brukar anvÃĊnda hÃĊr--
ÃĊr ungefÃĊr som att anvÃĊnda din spola tillbaka och snabbspola framÃċt
knapparna fÃ¶r att flytta runt pÃċ filmen.
PÃċ samma sÃĊtt kan du flytta runt filen.
En av de saker inuti att filstrukturen
att c skapar fÃ¶r dig ÃĊr en indikator av var du befinner dig i filen.
Ãr du pÃċ mycket bÃ¶rjan, vid byte noll?
Ãr du pÃċ byte 100, byte 1000, och sÃċ vidare?
Du kan anvÃĊnda fseek godtyckligt flytta denna indikator framÃċt eller bakÃċt.
>> Och ftell, Ãċterigen liknar en DVD-spelare,
ÃĊr som en liten klocka som berÃĊttar hur mÃċnga minuter och sekunder dig
ÃĊr i en viss film.
PÃċ liknande sÃĊtt, berÃĊttar ftell hur mÃċnga bytes du ÃĊr i filen.
feof ÃĊr en annan version detektera om du har
nÃċtt slutet av filen.
Och ferror ÃĊr en funktion som du kan anvÃĊnda
att upptÃĊcka om nÃċgot har gÃċtt fel arbetsdag med en fil.
Ã terigen, detta ÃĊr bara skrapa pÃċ ytan.
Det finns fortfarande mycket mer fil-I / O funktioner i standard io.h.
Men det kommer fÃ¶rmodligen att fÃċ dig bÃ¶rjade arbeta med fil pekare.
Jag ÃĊr Doug Lloyd.
Detta ÃĊr CS50.