[Powered by Google Translate] [Lêer I / O]
[Jason Hirschhorn, Harvard Universiteit]
[Dit is CS50, CS50.TV]
Wanneer ons dink van 'n lêer, wat kom na gedagte is 'n Microsoft Word-dokument,
'n JPEG beeld, of 'n MP3 song,
en ons interaksie met elk van hierdie tipes van lêers op verskillende maniere.
Byvoorbeeld, in 'n Word-dokument voeg ons teks
terwyl hy met 'n JPEG beeld ons kan sny uit die kante of die kleure aanraak.
Maar onder die kap al die lêers in ons rekenaar is niks meer
as 'n lang reeks van nulle en ene.
Dit is aan die spesifieke toepassing wat in wisselwerking met die lêer
om te besluit hoe om hierdie lang reeks te verwerk en aan te bied aan die gebruiker.
Aan die een kant, kan 'n dokument kyk na net een byte,
of 8 nulle en ene, en 'n ASCII-karakter op die skerm vertoon.
Aan die ander kant, kan 'n bitmap image kyk na 3 bytes,
of 24 nulle en ene,
en interpreteer dit as 3 heksadesimale getalle
wat verteenwoordig die waardes vir rooi, groen en blou
in een pixel van 'n beeld.
Wat hulle ook al mag lyk op jou skerm, op hul kern,
lêers is niks meer as 'n reeks van nulle en ene.
So laat ons duik in en kyk na hoe ons eintlik manipuleer hierdie nulle en ene
wanneer dit kom by die skryf en lees van 'n lêer.
>> Ek sal begin deur te breek dit af in 'n eenvoudige 3-deel.
Volgende, sal ek duik in twee code voorbeelde wat hierdie drie dele te demonstreer.
Ten slotte, ek sal die proses te hersien en sommige van sy mees belangrike besonderhede.
Soos met enige lêer wat sit op jou lessenaar,
die eerste ding om te doen is om dit oop te maak.
In C doen ons dit deur te verklaar 'n wyser na 'n vooraf gedefinieerde struct
wat 'n lêer op die hardeskyf.
In hierdie funksie oproep, het ons ook besluit of ons wil skryf of lees van die lêer.
Volgende, ons doen die werklike lees en skryf.
Daar is 'n aantal van gespesialiseerde funksies wat ons kan gebruik in hierdie deel,
en byna almal van hulle begin met die letter F, wat staan ​​vir die lêer.
Laaste, wat verwant is aan die klein rooi X in die boonste hoek van die lêers op jou rekenaar oopmaak,
ons maak die lêer met 'n finale funksie oproep.
Nou dat ons 'n algemene idee van wat ons gaan doen,
laat ons duik in die kode.
>> In hierdie gids, het ons twee C-lêers en hul ooreenstemmende uitvoerbare lêers.
Die tikmasjien program neem 'n command line argument,
die naam van die dokument wat ons wil skep.
In hierdie geval is, sal ons 'n beroep dit doc.txt.
Kom ons voer die program uit en voer 'n paar lyne.
Hi. My naam is Jason.
Ten slotte, sal ons tik "ophou."
As ons nou n lys van al die lêers in hierdie gids,
sien ons dat 'n nuwe dokument bestaan ​​genoem doc.txt.
Dit is die lêer hierdie program nou net gemaak het.
En natuurlik, dit is ook niks meer as 'n lang reeks van nulle en ene.
As ons hierdie nuwe lêer oopmaak,
sien ons die 3 reëls van die kode wat ons het in ons program -
Hi. Mei naam is Jason.
Maar wat eintlik gaan wanneer typewriter.c loop?
Die eerste reël van belang vir ons is in lyn 24.
In hierdie lyn, ons verklaar ons lêer wyser.
Die funksie wat gee hierdie pointer, fopen, neem twee argumente.
Die eerste is die lêernaam insluitend die lêeruitbreiding indien toepaslik.
Onthou dat 'n lêer uitbreiding nie die lêer op sy laagste vlak beïnvloed.
Ons is altyd op die hantering van 'n lang reeks van nulle en ene.
Maar dit is nie invloed hoe lêers geïnterpreteer word en wat aansoeke word gebruik om hulle oop te maak.
Die tweede argument te fopen is 'n enkele brief
wat staan ​​vir wat ons beplan om te doen nadat ons die lêer oopmaak.
Daar is drie opsies vir hierdie argument - W, R, en A.
Ons het gekies om w in hierdie geval, want ons wil om te skryf na die lêer.
R, soos jy kan dink, is vir die lees van die lêer.
En 'n is vir die aanbring na die lêer.
Terwyl beide w en 'n kan gebruik word vir die skryf van tot lêers,
w vanaf die begin van die lêer sal begin skryf
en potensieel oorskryf enige data wat voorheen gestoor.
By verstek, die lêer oopmaak, indien dit nie reeds bestaan ​​nie,
geskep word in ons huidige werk gids.
Maar as ons wil om toegang te kry of skep 'n lêer in 'n ander plek,
in die eerste argument van fopen,
kan ons 'n pad van die lêer in bykomend tot die lêernaam spesifiseer.
Terwyl die eerste deel van hierdie proses is slegs een lyn van kode lank,
dit is altyd goeie praktyk om 'n ander stel reëls in te sluit
wat gaan om te verseker dat die lêer is suksesvol oopgemaak of geskep.
As fopen terugkeer null, sou ons nie wil voortgaan met ons program,
en dit kan gebeur as die bedryfstelsel is uit die geheue
of as ons probeer om 'n lêer oop te maak in 'n gids waarvoor ons nie die behoorlike regte het.
>> Deel twee van die proses plaasvind in die tikmasjien se while lus.
Ons maak gebruik van 'n CS50 biblioteek funksie om insette te kry van die gebruiker,
en deur aan te neem dat hulle nie wil hê om die program af te sluit,
ons gebruik die funksie fputs die tou te neem en skryf dit na die lêer.
fputs is slegs een van die vele funksies wat ons kan gebruik om te skryf na die lêer.
Ander sluit fwrite, fputc, en selfs fprintf.
Ongeag van die betrokke funksie het ons uiteindelik gebruik, al is,
almal van hulle nodig het om te weet, deur middel van hul argumente,
ten minste twee dinge -
wat gedoen moet word geskryf en waar dit geskryf moet word.
In ons geval, die insette is die string wat geskryf moet word
en fp is die wyser wat lei ons na die plek waar ons skryf.
In hierdie program, deel twee van die proses is redelik eenvoudig.
Ons is eenvoudig die neem van 'n string van die gebruiker
en voeg dit direk aan ons lêer met min-tot-geen insette validering of sekuriteit kontrole.
Dikwels, egter, sal deel twee neem die grootste deel van jou kode.
Ten slotte, deel drie is on line 58, waar ons die lêer te sluit.
Hier noem ons fclose en dit slaag ons oorspronklike lêer wyser.
In die daaropvolgende reël, keer ons terug nul, 'n teken van die einde van ons program.
En ja, deel drie is so eenvoudig soos dit.
>> Kom ons beweeg op die lees van lêers.
Terug in ons gids het n lêer genaamd printer.c.
Kom ons loop dit met die lêer wat ons nou net gemaak het -
doc.txt.
Hierdie program, soos die naam aandui, sal eenvoudig druk die inhoud van die lêer geslaag het om dit te.
En daar het ons dit.
Die reëls van die kode wat ons vroeër getik en gestoor in doc.txt.
Hi. My naam is Jason.
As ons duik in printer.c
sien ons dat 'n baie van die kode lyk soortgelyk aan wat ons net deurwandel het in typewriter.c.
Inderdaad line 22, waar ons die lêer oopgemaak,
en lyn 39, waar ons die lêer gesluit,
is albei byna identies aan typewriter.c, behalwe vir fopen tweede argument.
Hierdie keer het ons van 'n lêer te lees,
sodat ons gekies het om r in plaas van w.
So, laat se fokus op die tweede deel van die proses.
In lyn 35, as die tweede toestand in ons 4 lus,
maak ons ​​'n oproep tot fgets,
die metgesel funksie te fputs voor.
Hierdie keer het ons drie argumente.
Die eerste is die wyser na die verskeidenheid van karakters waar string gestoor word.
Die tweede is die maksimum aantal van karakters om gelees te word.
En die derde is die wyser na die lêer waarmee ons werk.
Jy sal sien dat die loop eindig wanneer fgets terugkeer null.
Daar is twee rede dat dit gebeur het.
Eerstens, kan 'n fout plaasgevind het.
Tweede, en meer waarskynlik, is die einde van die lêer bereik en nie meer karakters is gelees.
In geval jy wonder, bestaan ​​twee funksies wat ons toelaat om te vertel
watter rede is die oorsaak vir hierdie spesifieke null pointer.
En, nie verrassend nie, omdat hulle te doen het met die werk met lêers,
beide die ferror funksie en die feof funksie begin met die letter f.
>> Ten slotte, voordat ons tot die gevolgtrekking, 'n vinnige nota oor die einde van die lêer funksie,
wat, as net genoem het, is geskryf as feof.
Dikwels sal jy vind jouself ruk en vir loops gebruik om progressief te lees jou pad deur lêers.
So, sal jy 'n manier om hierdie loops te beëindig nadat jy aan die einde van hierdie lêers.
Oproep feof op jou lêer wyser en om te kyk of dit waar is
sal doen net dat.
Dus, kan 'n rukkie loop met die voorwaarde (feof (GF)!) Lyk soos 'n perfek geskikte oplossing.
Egter sê dat ons een lyn links in ons teks lêer.
Ons sal ons while lus betree en alles sal uitwerk soos beplan.
Op die volgende ronde deur, sal ons program te kyk om te sien of feof van fp is waar,
maar - en dit is die belangrike punt om hier te verstaan ​​-
dit sal nie waar wees nie net nog nie.
Dit is omdat die doel van feof is nie om te kyk
indien die volgende oproep tot 'n lees funksie sal die einde van die lêer te tref,
maar eerder om te kyk of die einde van die lêer is reeds bereik.
In die geval van hierdie voorbeeld,
die lees van die laaste lyn van ons lêer gaan perfek glad,
maar die program nog nie weet dat ons die einde van ons lêer het getref.
Dit is nie totdat dit een addisionele lees dat dit tellers die einde van die lêer.
Dus, sou 'n korrekte toestand die volgende wees:
fgets en sy drie argumente - uitset, grootte van die uitset, en fp -
en al van daardie nie gelyk aan nul.
Dit is die benadering wat ons het in printer.c,
en in hierdie geval, na die lus uitgange,
jy kan noem feof of ferror die gebruiker in te lig met betrekking tot die spesifieke redenasie vir die verlaat van hierdie lus.
>> Skriftelik aan en lees van 'n lêer is, op sy mees basiese,
'n eenvoudige 3-deel.
Eerstens, het ons die lêer oopmaak.
Tweedens, ons het 'n paar dinge in ons lêer of neem 'n paar dinge uit dit uit.
Derdens, ons maak die lêer.
Die eerste en laaste dele is maklik.
Die middelste gedeelte is waar die moeilike dinge lê.
En al onder die kap ons altyd die hantering van 'n lang reeks van nulle en ene,
dit nie help wanneer die kodering van 'n laag van abstraksie te voeg
wat verander die volgorde in iets wat meer lyk wat ons gebruik om te sien.
Byvoorbeeld, as ons werk met 'n 24-bis bitmap lêer,
ons sal waarskynlik lees of skryf drie grepe op 'n slag.
In welke geval, sou dit sin maak om te definieer en toepaslik noem
'n struct 3 bytes groot is.
>> Hoewel die werk met lêers mag lyk ingewikkeld,
gebruik te maak van hulle kan ons iets werklik merkwaardige te doen.
Ons kan verander die toestand van die wêreld buite ons program,
ons kan skep iets wat buite die lewe van ons program woon,
of ons kan selfs die verandering van iets wat geskep is voordat ons program begin hardloop.
Interaksie met lêers is 'n werklik kragtige deel van programmering in C.
en ek is opgewonde om te sien wat jy gaan om te skep met dit in die kode om te kom.
My naam is Jason Hirschhorn. Dit is CS50.
[CS50.TV]
>> [Lag]
Okay. Een neem. Hier gaan ons.
Wanneer ons dink van 'n lêer - >> O, wag. Jammer.
[Gelag] Goed.
Hey daar.
Wanneer ons dink van 'n lêer -
Wanneer jy dink van 'n lêer - Okay. Vertel my wanneer jy klaar is.
Ag, geweldig.
Hoewel die lees van 'n teleprompter mag lyk - nie. My slegte.