[Powered by Google Translate] [Fil I / O]
[Jason Hirschhorn, Harvard University]
[Dette er CS50, CS50.TV]
Når vi tænker på en fil, hvad der kommer til at tænke på er en Microsoft Word-dokument,
et JPEG-billede, eller en MP3-sang,
og vi interagerer med hver af disse typer af filer på forskellige måder.
For eksempel har vi i et Word-dokument tilføje tekst
mens med et JPEG-billede, vi muligvis beskære de kanter eller retoucheres farver.
Men under kølerhjelmen alle filer i vores computer er intet mere
end en lang sekvens af nuller og ettaller.
Det er op til den specifikke applikation, der interagerer med filen
at beslutte, hvordan at behandle denne lange sekvens og præsentere det for brugeren.
På den ene side kan et dokument se på én byte,
eller 8 nuller og ettaller, og vise et ASCII-tegn på skærmen.
På den anden side kan en bitmapbillede se på 3 byte,
eller 24 nuller og ettaller,
og fortolke dem som 3 hexadecimale tal
der repræsenterer værdier for rød, grøn og blå
i en pixel i et billede.
Uanset hvad de kan se ud på din skærm, på deres kernekompetencer,
filer er intet mere end en sekvens af nuller og ettaller.
Så lad os dykke ned og se på, hvordan vi rent faktisk manipulere disse nuller og ettaller
når det kommer til at skrive til og læse fra en fil.
>> Jeg vil starte med at bryde det ned i en simpel 3-delt proces.
Dernæst vil jeg dykke i to kodeeksempler, der viser disse tre dele.
Endelig vil jeg gennemgå processen og nogle af de mest vigtige detaljer.
Som med enhver fil, der sidder på skrivebordet,
den første ting at gøre, er at åbne den.
I C gør vi dette ved at erklære en pointer til en foruddefineret struct
der repræsenterer en fil på disken.
I denne funktion opkald, også vi beslutter, om vi vil skrive til eller læse fra filen.
Næste, vi gøre det faktiske læsning og skrivning.
Der er en række specialiserede funktioner, vi kan bruge i denne del,
og næsten alle af dem starter med bogstavet F, som står for fil.
Sidst, beslægtet med de små røde X i øverste hjørne af filerne åbner på din computer,
vi lukker filen med en endelig funktion opkald.
Nu hvor vi har en generel idé om, hvad vi vil gøre,
Lad os dykke ned i koden.
>> I denne mappe har vi to C-filer og deres tilsvarende eksekverbare filer.
Skrivemaskinen program tager et kommandolinje argument,
navnet på det dokument, som vi ønsker at skabe.
I dette tilfælde vil vi kalde det doc.txt.
Lad os køre programmet og indtaste et par linjer.
Hi. Mit navn er Jason.
Endelig vil vi skrive "quit".
Hvis vi nu en liste over alle de filer i denne mappe,
vi se, at et nyt dokument eksisterer kaldet doc.txt.
Det er den fil, dette program netop har oprettet.
Og selvfølgelig er det også er intet mere end en lang sekvens af nuller og ettaller.
Hvis vi åbner denne nye fil,
ser vi de 3 linjer kode vi trådte ind i vores program -
Hi. Maj navn er Jason.
Men hvad der rent faktisk foregår, når typewriter.c kører?
Den første linje af interesse for os er linje 24.
I denne linje, erklærer vi vores fil pointer.
Den funktion, der returnerer denne pointer, fopen tager to argumenter.
Den første er filnavnet, herunder filtypen om nødvendigt.
Husk på, at en fil forlængelse ikke påvirker filen på sit laveste niveau.
Vi er altid at gøre med en lang sekvens af nuller og ettaller.
Men det gør indflydelse hvordan filer fortolkes og hvilke programmer der bruges til at åbne dem.
Det andet argument for fopen er et enkelt bogstav
der står for hvad vi planlægger at gøre efter vi åbner filen.
Der er tre muligheder for dette argument - W, R og A.
Vi har valgt w i dette tilfælde, fordi vi ønsker at skrive til filen.
R, som du nok kan gætte, er til læsning af filen.
Og a er for tilføjelse af filen.
Mens både w og en kan anvendes til at skrive til filer,
w vil begynde at skrive fra begyndelsen af ​​filen
og potentielt overskrive data, der tidligere er blevet gemt.
Som standard, den fil, vi åbner, hvis den ikke allerede findes
er skabt i vores nuværende arbejdsmappe.
Men hvis vi ønsker at få adgang til eller oprette en fil i en anden placering,
i det første argument for fopen,
Vi kan angive en filsti i tillæg til filnavnet.
Mens den første del af denne proces er kun én linje kode lange,
det er altid god praksis at inkludere et andet sæt linjer
at kontrollere, at sikre, at filen med held blev åbnet eller oprettet.
Hvis fopen returnerer null, ville vi ikke ønsker at gå videre med vores program,
og dette kan ske, hvis operativsystemet er løbet tør for hukommelse
eller hvis vi forsøger at åbne en fil i en mappe, som vi ikke har de rette tilladelser.
>> Anden del af processen finder sted i skrivemaskine s medens løkken.
Vi anvender en CS50 biblioteksfunktion at få input fra brugeren,
og under forudsætning af, at de ikke ønsker at forlade programmet,
vi bruger funktionen fputs at tage snoren og skrive det til filen.
fputs er kun én af de mange funktioner, vi kunne bruge til at skrive til filen.
Andre omfatter fwrite, fputc, og selv fprintf.
Uanset den særlige funktion, vi ender med at bruge, selv om,
alle af dem har brug for at vide, via deres argumenter,
mindst to ting -
hvad der skal skrives, og hvor den skal skrives til.
I vores tilfælde er input den streng, der skal skrives
og fp er markøren, der leder os til, hvor vi er ved at skrive.
I dette program, er anden del af processen temmelig ligetil.
Vi blot at tage en snor fra brugeren
og tilføje det direkte til vores fil med lille-til-ingen validering af input eller sikkerhedskontrol.
Men ofte vil anden del tage op størstedelen af ​​din kode.
Endelig behandler del tre er på linie 58, hvor vi lukker filen.
Her kalder vi fclose og videregive det vores oprindelige fil pointer.
I den efterfølgende linie, vender vi nul, signalerer afslutningen på vores program.
Og ja, del tre er så simpelt er det.
>> Lad os gå videre til læsning fra filer.
Tilbage i vores bibliotek har vi en fil kaldet printer.c.
Lad os køre det med den fil, vi lige har oprettet -
doc.txt.
Dette program, som navnet antyder, vil blot udskrive indholdet af filen blev leveret til.
Og der har vi det.
De linjer kode, vi havde skrevet tidligere og gemmes i doc.txt.
Hi. Mit navn er Jason.
Hvis vi dykker ned i printer.c,
vi se, at en masse af koden ligner det, vi bare gik igennem i typewriter.c.
Faktisk linie 22, hvor vi åbnede filen,
og linie 39, hvor vi lukkede filen,
er begge næsten identisk med typewriter.c, bortset fopen andet argument.
Denne gang vi læser fra en fil,
så vi har valgt ri stedet for w.
Således lad os fokusere på den anden del af processen.
På linje 35, som den anden betingelse i vores 4 loop
vi foretage et opkald til fgets,
følgesvend funktionen til fputs fra før.
Denne gang har vi tre argumenter.
Den første er markøren til de mange figurer, hvor strengen skal lagres.
Det andet er den maksimale antal tegn, der skal læses.
Og den tredje er markøren til den fil, som vi arbejder.
Du vil opdage, at for-løkken slutter, når fgets returnerer null.
Der er to grund, at dette kan være sket.
Først kan være sket en fejl.
Sekund, og mere sandsynligt, blev slutningen af ​​filen nået, og ikke flere tegn blev aflæst.
Hvis du undrer dig over, har to funktioner findes, der giver os mulighed for at fortælle
hvorfor er årsagen til denne særlige null pointer.
Og ikke overraskende, da de har at gøre med at arbejde med filer,
både den ferror funktionen og feof funktionen start med bogstavet f.
>> Endelig, før vi slutter, en hurtig bemærkning omkring slutningen af ​​fil-funktionen,
der, som lige nævnt, er skrevet som feof.
Ofte vil du finde dig selv ved hjælp af tid og for-løkker til gradvis læse din vej gennem filer.
Derfor skal du have en måde at afslutte disse sløjfer, når du når til slutningen af ​​disse filer.
Opkald feof på din fil pointer og kontrol for at se, om det er sandt
ville gøre netop det.
Således kan en while-løkke med betingelse (! Feof (fp)) synes som en perfekt passende løsning.
Men siger vi har en linje tilbage i vores tekst-fil.
Vi vil deltage i vores while-løkke og alt vil arbejde som planlagt.
På næste runde igennem, vil vores program tjekke om feof af fp er sandt,
men - og det er det afgørende punkt for at forstå her -
vil det ikke være rigtigt endnu.
Det er fordi formålet med feof ikke er at kontrollere
hvis den næste opkald til en aflæsningsfunktion vil ramme i slutningen af ​​filen,
men at kontrollere, om slutningen af ​​filen er allerede nået.
I forbindelse med dette eksempel,
læst den sidste linje i vores fil går perfekt glat,
men programmet endnu ikke ved, at vi har ramt slutningen af ​​vores fil.
Det er ikke indtil det gør en ekstra læst, at det modvirker slutningen af ​​filen.
Således vil en korrekt tilstand, er følgende:
fgets og dets tre argumenter - output, størrelse af produktion og FP -
og alt dette ikke lig med nul.
Det er den tilgang, vi tog i printer.c,
og i dette tilfælde, efter løkken udgange
man kunne kalde feof eller ferror at informere brugeren om den specifikke begrundelse for spændende denne løkke.
>> Skrivning til og læsning fra en fil er på sit mest basale,
en simpel 3-delt proces.
Først skal vi åbne filen.
For det andet har vi lagt nogle ting ind i vores fil eller tage nogle ting ud af det.
For det tredje, vi lukker filen.
De første og sidste dele er let.
Den midterste del er, hvor tricky ting ligger.
Og skønt under hætten vi altid gøre med en lang sekvens af nuller og ettaller,
det hjælper når kodning at tilføje et lag af abstraktion
der forvandler sekvensen til noget, mere ligner hvad vi er vant til at se.
For eksempel, hvis vi arbejder med en 24-bit bitmap-fil
vi vil sandsynligvis være at læse eller skrive tre bytes ad gangen.
I så fald, ville det være fornuftigt at definere og passende navn
en struct, der er 3 bytes stor.
>> Selvom arbejde med filer kan synes kompliceret,
udnytte dem tillader os at gøre noget virkelig bemærkelsesværdig.
Vi kan ændre verdens tilstand uden for vores program,
kan vi skabe noget, der lever uden for livet for vores program,
eller vi kan endda ændre noget, der blev oprettet før vores program begyndte at løbe.
Samspil med filer er en virkelig kraftfuld del af programmeringen i C.
og jeg er spændt på at se, hvad du vil lave med det i koden til at komme.
Mit navn er Jason Hirschhorn. Det er CS50.
[CS50.TV]
>> [Latter]
Okay. Man tager. Her går vi.
Når vi tænker på en fil - >> Oh, vent. Undskyld.
[Latter] Okay.
Hej der.
Når vi tænker på en fil -
Når du tænker på en fil - Okay. Fortæl mig når du er klar.
Åh, godt.
Selvom læsning fra en teleprompter kan virke - nej. Min dårlige.