[Powered by Google Translate] [Fájl I / O]
[Jason Hirschhorn, Harvard University]
[Ez CS50, CS50.TV]
Amikor azt gondoljuk, egy fájl, ami eszembe jut egy Microsoft Word dokumentumot,
JPEG kép, vagy egy MP3 dal,
és mi kölcsönhatásban vannak az ilyen típusú fájlokat különböző módon.
Például a Word dokumentumban szöveget
míg egy JPEG képet talán vágnod a szélek vagy retusálni a színeket.
Mégis, a motorháztető alatt az összes fájlt a mi számítógép nem több
mint egy hosszú sorozatot nullákkal és egyesekkel.
Rajtunk múlik, hogy az adott alkalmazás, amely együttműködik a fájl
dönti el, hogyan feldolgozni ezt a hosszú sorozatot, és azt bemutatja a felhasználónak.
Egyrészt, a dokumentum nézd csak egy byte,
vagy 8 nullákkal és egyesekkel, és megjelenik egy ASCII karaktert a képernyőn.
Másrészt, a bitmap kép megismerkedni 3 byte,
vagy 24 nullák,
és értelmezheti őket 3 hexadecimális számok
, hogy képviselje a értéket a vörös, zöld, és kék
egy pixel a kép.
Bármit is néz ki, mint a képernyőn, saját mag,
fájlok nem más, mint a sorozat nullákkal és egyesekkel.
Szóval merüljön, és nézd meg, hogyan tudjuk valójában manipulálják ezeket nullákkal és egyesekkel
amikor az írás és az olvasás egy fájlból.
>> Majd kezdeni jellemzői le egy egyszerű 3-részes folyamat.
Ezután fogok merülni két kód példák azt mutatják, a három részből áll.
Végül, én át a folyamatot, és néhány legfontosabb részletek.
Mint minden fájlt, hogy ül az asztalon,
Az első dolog az, hogy nyissa meg.
A C-ben tesszük ezt nyilvánító mutató előre megadott struct
, amely egy fájl a lemezen.
Ebben a függvényhívás azt is eldönti, hogy akarunk írni vagy olvasni a fájlból.
Továbbá, mi a tényleges olvasás és írás.
Van számos speciális függvények tudjuk használni az e részben,
és majdnem mindegyikük kezdődik az F betűvel, amely áll a fájlt.
Végül hasonlít a kis piros X a felső sarokban a fájlok megnyitásához a számítógépen,
zárjuk a fájlt a végleges függvényhívás.
Most, hogy van egy általános képet, hogy mit fogunk csinálni,
nézzük belevetik magukat a kódot.
>> Ebben a könyvtárban van két C fájlokat, és a hozzájuk tartozó végrehajtható fájlokat.
Az írógép programban vesz egy parancssori argumentum,
a dokumentum nevét szeretnénk létrehozni.
Ebben az esetben fogjuk hívni doc.txt.
Fussunk a programot, és adja meg a pár sort.
Szia. A nevem Jason.
Végül, akkor írja be a "kilépés".
Ha most felsorolni az összes fájlt ebbe a könyvtárba,
azt látjuk, hogy egy új dokumentum létezik az úgynevezett doc.txt.
Ez a fájl a program csak létre.
És persze, ez is nem más, mint egy hosszú sorozatot nullákkal és egyesekkel.
Ha megnyitja ezt az új fájlt,
látjuk a 3 sornyi kódot, lépett a program -
Szia. May neve Jason.
De mi valójában folyik, amikor typewriter.c fut?
Az első sor érdekes számunkra sor 24.
Ebben a sorban, akkor állapítsa meg a fájl mutatót.
A függvény, ami visszaadja ezt a mutatót, fopen, úgy két érveket.
Az első a fájl neve, beleértve a fájl kiterjesztését, amennyiben szükséges.
Emlékezzünk vissza, hogy a fájl kiterjesztése nem befolyásolja a fájl a legalacsonyabb szinten.
Mindig foglalkozik a hosszú sorozata nullákkal és egyesekkel.
De ez nem befolyásolja, hogy hogyan értelmezik a fájlok és milyen alkalmazásokat használnak, hogy nyissa ki nekik.
A második érv, hogy fopen egyetlen betű
hogy áll, amit kívánunk tenni, miután a fájl megnyitásakor.
Három lehetőség ez az érv - W, R, és A.
Már választott w ebben az esetben, mert azt akarjuk, hogy írjon a fájlt.
R, akkor valószínűleg hiszem, nem az olvasás a fájl.
És a kiegészítő hozzáfűzése a fájlhoz.
Bár mind a W és lehet használni írásban fájlokat,
w indul írás elejétől a fájl
és potenciálisan felülírja olyan adatokat, amelyeket korábban már tárolva.
Alapértelmezésben a fájlt nyitunk, ha az még nem létezik,
jön létre a jelenlegi munkakönyvtárba.
Azonban, ha azt akarjuk elérni, vagy készítsen egy fájlt egy másik helyre,
Az első érv az fopen,
mi is adja meg a fájl elérési útját mellett a fájl nevét.
Míg az első része a folyamat csak az egyik sor kód hosszú,
ez mindig helyes gyakorlat egy másik sor
hogy ellenőrizze, hogy a fájl sikeresen megnyitott vagy létrehozott.
Ha az fopen függvény null, akkor nem akar haladjanak előre a mi program,
és ez történik, ha az operációs rendszer a memória
vagy ha megpróbál megnyitni egy fájlt egy könyvtárba, amelyhez nem rendelkezik a megfelelő engedélyekkel.
>> A második rész a folyamat zajlik typewriter a while ciklus.
Az általunk használt CS50 könyvtári funkciót kap bemenetet a felhasználó,
és feltételezve, hogy nem akarják, hogy kilép a program,
használjuk a funkciót fputs, hogy a húr, és írd meg a fájlt.
fputs csak egy a sok funkció tudtuk használni, hogy írni a fájlt.
Mások is fwrite, fputc, sőt fprintf.
Függetlenül attól, hogy az adott funkció a végén használatával, bár,
mindegyiket ismerniük kell, keresztül érveket,
legalább két dolgot -
mit kell írni, és ahol meg kell írni.
A mi esetünkben az a bemeneti karakterlánc, amelyet meg kell írásbeli
és fp a mutatót, hogy irányítja minket, ahol írunk.
Ebben a programban, a második rész a folyamat meglehetősen egyszerű.
Mi egyszerűen vesz egy stringet a felhasználó
és a hozzá közvetlenül a mi kis fájl-to-nincs beviteli ellenőrzés vagy biztonsági ellenőrzéseket.
Gyakran azonban a második rész felveszi a nagy részét a kódot.
Végül a harmadik rész az on-line 58, hol zárja be a fájlt.
Itt hívjuk fclose, és adja át az eredeti fájl mutatót.
Az ezt követő sorban visszatérünk nulla, jelezve a végén a program.
És igen, a harmadik részben olyan egyszerű, mint ezt.
>> Menjünk tovább olvasása fájlokat.
Vissza a könyvtárba, hogy van egy nevű fájlt printer.c.
Fussunk, hogy a fájl már csak létre -
doc.txt.
Ez a program, mint a neve is sugallja, egyszerűen kinyomtatja a fájl tartalmát át hozzá.
És ott van ez.
A sornyi kódot mi volt korábban beírt és mentett doc.txt.
Szia. A nevem Jason.
Ha belevetik magukat printer.c,
azt látjuk, hogy sok a kód hasonlít ahhoz, amit mi csak átsétált a typewriter.c.
Valójában a 22, ahol megnyitotta a fájlt,
és 39. sor, ahol lezárta a fájlt,
egyaránt csaknem azonos typewriter.c, kivéve fopen második argumentum.
Ezúttal olvasott egy fájlt,
ezért úgy döntöttünk, r helyett w.
Tehát, hadd összpontosítani a második része a folyamatnak.
A vonal 35, a második feltétel a 4 hurok,
teszünk hívás fgets,
a társ funkció fputs előtti.
Ezúttal három érveket.
Az első mutató a tömb a karakterek, ha a string lesz mentve.
A második a karakterek maximális számát kell olvasni.
És a harmadik pedig a mutatót a fájl, amellyel dolgozunk.
Észre fogod venni, hogy a for ciklus ér véget, amikor fgets visszatér null.
Két oka annak, hogy ez történt.
Először is, hiba is történt.
Másodszor, és nagyobb valószínűséggel, a végén a fájl született, és nem több karaktert is olvasni.
Ha kíváncsi, két funkciót léteznek, amelyek lehetővé teszik számunkra, hogy elmondja
ami miatt az oka e konkrét null pointer.
És nem meglepő, mert köze dolgozni fájlokat,
mind a fError funkció és a funkció feof kezdődik a levél f.
>> Végül, mielőtt arra a következtetésre jutunk, egy gyors megjegyzés a végére fájl funkció,
amely, mint már említettük, van írva, mint feof.
Gyakran találja magát a while és a hurkok fokozatosan olvassa végig fájlokat.
Így, szükséged lesz egy módja annak, hogy véget vet e hurkok után elérjük a végét ezeket a fájlokat.
Hívása feof a fájl pointer, és ellenőrzi, hogy ha ez igaz,
akkor nem csak ezt.
Így, egy darabig hurok feltétel (! Feof (fp)) tűnhet, mint egy tökéletesen megfelelő megoldás.
Ugyanakkor azt mondom, van egy sor maradt a mi szöveges fájl.
Majd adja meg a while ciklus, és minden működni fog a tervek szerint.
A következő forduló során, a program ellenőrzi, hogy a feof fp igaz,
de - és ez a lényeg, hogy megértsék itt -
ez nem lesz igaz, csak még.
Ez azért van, mert a célja feof nem ellenőrzi
ha a következő hívás a read függvény majd nyomja meg a végén a fájl,
hanem az, hogy ellenőrizze-e vagy sem a végén a fájl már elérték.
Abban az esetben, a példa,
olvasó az utolsó sorban a mi fájl megy tökéletesen simán,
de a program még nem tudja, hogy már megüt a végén a fájl.
Ez nem csak ez egy további olvasásra, hogy szembeszáll a végén a fájl.
Így, a helyes feltétel lenne a következők:
fgets és három érvek - kimenet mérete kimenet és fp -
és minden ami nem egyenlő null.
Ez a megközelítés azt vette printer.c,
és ebben az esetben, miután a hurok kilép,
tudna hívni feof vagy fError tájékoztatja a felhasználót, hogy az adott indokolta kilépés a hurok.
>> Írás és olvasás a fájl, annak legalapvetőbb,
egy egyszerű 3 részből álló folyamat.
Először is nyissa meg a fájlt.
Másodszor, egy kis dolog, a mi fájlba vagy tegyen néhány dolgot belőle.
Harmadszor, zárja be a fájlt.
Az első és az utolsó alkatrészek egyszerű.
A középső rész, ahol a trükkös dolog rejlik.
És bár a motorháztető alatt mi mindig foglalkozik a hosszú sorozata nullák,
ez nem segít, ha kódolás, hogy adjunk egy réteg absztrakció
amely bekapcsolja a sorozat valami, hogy jobban hasonlít, amit mi szokta látni.
Például, ha dolgozunk egy 24-bites bitmap fájlt,
akkor valószínűleg írása vagy olvasása három byte egy időben.
Abban az esetben lenne értelme, hogy meghatározza és megfelelő nevet
Egy struct vagyis 3 byte nagy.
>> Bár a munka fájlok tűnhet bonyolult,
használó őket lehetővé teszi számunkra, hogy tegyünk valamit igazán figyelemre méltó.
Meg tudjuk változtatni az állapotát a külvilág a program,
tudunk létrehozni valamit, ami él túl életében program,
vagy mi is változtatni valamit, amit azért hoztak létre, mielőtt a program indulásakor fut.
Együttműködés fájlok valóban hatékony része programozás C.
és izgatott vagyok, hogy mit fogsz létrehozni vele a kódot, hogy jöjjön.
A nevem Jason Hirschhorn. Ez CS50.
[CS50.TV]
>> [Nevetés]
Oké. Egy venni. Itt vagyunk.
Amikor azt gondoljuk, egy fájl - >> Oh, várj. Bocsánat.
[Nevetés] Oké.
Hey there.
Amikor azt gondoljuk, a file -
Ha úgy gondolja, egy fájl - Oké. Szólj, ha készen állsz.
Ó, remek.
Bár olvasás a súgógép tűnhet - nem. Az én hibám.