1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Fájl I / O]

2
00:00:02,000 --> 00:00:04,000
[Jason Hirschhorn, Harvard University]

3
00:00:04,000 --> 00:00:07,000
[Ez CS50, CS50.TV]

4
00:00:07,000 --> 00:00:11,000
Amikor azt gondoljuk, egy fájl, ami eszembe jut egy Microsoft Word dokumentumot,

5
00:00:11,000 --> 00:00:14,000
JPEG kép, vagy egy MP3 dal,

6
00:00:14,000 --> 00:00:17,000
és mi kölcsönhatásban vannak az ilyen típusú fájlokat különböző módon.

7
00:00:17,000 --> 00:00:20,000
Például a Word dokumentumban szöveget

8
00:00:20,000 --> 00:00:24,000
míg egy JPEG képet talán vágnod a szélek vagy retusálni a színeket.

9
00:00:24,000 --> 00:00:28,000
Mégis, a motorháztető alatt az összes fájlt a mi számítógép nem több

10
00:00:28,000 --> 00:00:31,000
mint egy hosszú sorozatot nullákkal és egyesekkel.

11
00:00:31,000 --> 00:00:33,000
Rajtunk múlik, hogy az adott alkalmazás, amely együttműködik a fájl

12
00:00:33,000 --> 00:00:38,000
dönti el, hogyan feldolgozni ezt a hosszú sorozatot, és azt bemutatja a felhasználónak.

13
00:00:38,000 --> 00:00:41,000
Egyrészt, a dokumentum nézd csak egy byte,

14
00:00:41,000 --> 00:00:45,000
vagy 8 nullákkal és egyesekkel, és megjelenik egy ASCII karaktert a képernyőn.

15
00:00:45,000 --> 00:00:48,000
Másrészt, a bitmap kép megismerkedni 3 byte,

16
00:00:48,000 --> 00:00:50,000
vagy 24 nullák,

17
00:00:50,000 --> 00:00:53,000
és értelmezheti őket 3 hexadecimális számok

18
00:00:53,000 --> 00:00:56,000
, hogy képviselje a értéket a vörös, zöld, és kék

19
00:00:56,000 --> 00:00:58,000
egy pixel a kép.

20
00:00:58,000 --> 00:01:01,000
Bármit is néz ki, mint a képernyőn, saját mag,

21
00:01:01,000 --> 00:01:05,000
fájlok nem más, mint a sorozat nullákkal és egyesekkel.

22
00:01:05,000 --> 00:01:08,000
Szóval merüljön, és nézd meg, hogyan tudjuk valójában manipulálják ezeket nullákkal és egyesekkel

23
00:01:08,000 --> 00:01:12,000
amikor az írás és az olvasás egy fájlból.

24
00:01:12,000 --> 00:01:15,000
>> Majd kezdeni jellemzői le egy egyszerű 3-részes folyamat.

25
00:01:15,000 --> 00:01:19,000
Ezután fogok merülni két kód példák azt mutatják, a három részből áll.

26
00:01:19,000 --> 00:01:23,000
Végül, én át a folyamatot, és néhány legfontosabb részletek.

27
00:01:23,000 --> 00:01:25,000
Mint minden fájlt, hogy ül az asztalon,

28
00:01:25,000 --> 00:01:28,000
Az első dolog az, hogy nyissa meg.

29
00:01:28,000 --> 00:01:31,000
A C-ben tesszük ezt nyilvánító mutató előre megadott struct

30
00:01:31,000 --> 00:01:33,000
, amely egy fájl a lemezen.

31
00:01:33,000 --> 00:01:38,460
Ebben a függvényhívás azt is eldönti, hogy akarunk írni vagy olvasni a fájlból.

32
00:01:38,460 --> 00:01:41,660
Továbbá, mi a tényleges olvasás és írás.

33
00:01:41,660 --> 00:01:44,800
Van számos speciális függvények tudjuk használni az e részben,

34
00:01:44,800 --> 00:01:48,790
és majdnem mindegyikük kezdődik az F betűvel, amely áll a fájlt.

35
00:01:48,790 --> 00:01:53,560
Végül hasonlít a kis piros X a felső sarokban a fájlok megnyitásához a számítógépen,

36
00:01:53,560 --> 00:01:56,680
zárjuk a fájlt a végleges függvényhívás.

37
00:01:56,680 --> 00:01:59,540
Most, hogy van egy általános képet, hogy mit fogunk csinálni,

38
00:01:59,540 --> 00:02:02,000
nézzük belevetik magukat a kódot.

39
00:02:02,000 --> 00:02:06,100
>> Ebben a könyvtárban van két C fájlokat, és a hozzájuk tartozó végrehajtható fájlokat.

40
00:02:06,100 --> 00:02:09,710
Az írógép programban vesz egy parancssori argumentum,

41
00:02:09,710 --> 00:02:12,060
a dokumentum nevét szeretnénk létrehozni.

42
00:02:12,060 --> 00:02:16,160
Ebben az esetben fogjuk hívni doc.txt.

43
00:02:16,160 --> 00:02:19,080
Fussunk a programot, és adja meg a pár sort.

44
00:02:19,080 --> 00:02:23,660
Szia. A nevem Jason.

45
00:02:23,660 --> 00:02:26,710
Végül, akkor írja be a "kilépés".

46
00:02:26,710 --> 00:02:29,720
Ha most felsorolni az összes fájlt ebbe a könyvtárba,

47
00:02:29,720 --> 00:02:33,770
azt látjuk, hogy egy új dokumentum létezik az úgynevezett doc.txt.

48
00:02:34,190 --> 00:02:36,110
Ez a fájl a program csak létre.

49
00:02:36,110 --> 00:02:40,520
És persze, ez is nem más, mint egy hosszú sorozatot nullákkal és egyesekkel.

50
00:02:41,100 --> 00:02:43,260
Ha megnyitja ezt az új fájlt,

51
00:02:43,260 --> 00:02:45,870
látjuk a 3 sornyi kódot, lépett a program -

52
00:02:46,060 --> 00:02:49,060
Szia. May neve Jason.

53
00:02:49,580 --> 00:02:52,090
De mi valójában folyik, amikor typewriter.c fut?

54
00:02:52,810 --> 00:02:55,520
Az első sor érdekes számunkra sor 24.

55
00:02:55,560 --> 00:02:58,490
Ebben a sorban, akkor állapítsa meg a fájl mutatót.

56
00:02:59,080 --> 00:03:03,140
A függvény, ami visszaadja ezt a mutatót, fopen, úgy két érveket.

57
00:03:03,140 --> 00:03:07,440
Az első a fájl neve, beleértve a fájl kiterjesztését, amennyiben szükséges.

58
00:03:07,440 --> 00:03:10,980
Emlékezzünk vissza, hogy a fájl kiterjesztése nem befolyásolja a fájl a legalacsonyabb szinten.

59
00:03:10,980 --> 00:03:14,640
Mindig foglalkozik a hosszú sorozata nullákkal és egyesekkel.

60
00:03:14,640 --> 00:03:19,630
De ez nem befolyásolja, hogy hogyan értelmezik a fájlok és milyen alkalmazásokat használnak, hogy nyissa ki nekik.

61
00:03:19,630 --> 00:03:22,290
A második érv, hogy fopen egyetlen betű

62
00:03:22,290 --> 00:03:25,300
hogy áll, amit kívánunk tenni, miután a fájl megnyitásakor.

63
00:03:25,300 --> 00:03:30,630
Három lehetőség ez az érv - W, R, és A.

64
00:03:30,630 --> 00:03:34,900
Már választott w ebben az esetben, mert azt akarjuk, hogy írjon a fájlt.

65
00:03:34,900 --> 00:03:38,820
R, akkor valószínűleg hiszem, nem az olvasás a fájl.

66
00:03:38,820 --> 00:03:41,760
És a kiegészítő hozzáfűzése a fájlhoz.

67
00:03:41,760 --> 00:03:44,960
Bár mind a W és lehet használni írásban fájlokat,

68
00:03:44,960 --> 00:03:47,460
w indul írás elejétől a fájl

69
00:03:47,460 --> 00:03:50,810
és potenciálisan felülírja olyan adatokat, amelyeket korábban már tárolva.

70
00:03:50,810 --> 00:03:54,070
Alapértelmezésben a fájlt nyitunk, ha az még nem létezik,

71
00:03:54,070 --> 00:03:57,180
jön létre a jelenlegi munkakönyvtárba.

72
00:03:57,180 --> 00:04:00,540
Azonban, ha azt akarjuk elérni, vagy készítsen egy fájlt egy másik helyre,

73
00:04:00,540 --> 00:04:02,650
Az első érv az fopen,

74
00:04:02,650 --> 00:04:05,840
mi is adja meg a fájl elérési útját mellett a fájl nevét.

75
00:04:05,840 --> 00:04:09,490
Míg az első része a folyamat csak az egyik sor kód hosszú,

76
00:04:09,490 --> 00:04:12,350
ez mindig helyes gyakorlat egy másik sor

77
00:04:12,350 --> 00:04:15,930
hogy ellenőrizze, hogy a fájl sikeresen megnyitott vagy létrehozott.

78
00:04:15,930 --> 00:04:20,300
Ha az fopen függvény null, akkor nem akar haladjanak előre a mi program,

79
00:04:20,300 --> 00:04:23,270
és ez történik, ha az operációs rendszer a memória

80
00:04:23,270 --> 00:04:27,940
vagy ha megpróbál megnyitni egy fájlt egy könyvtárba, amelyhez nem rendelkezik a megfelelő engedélyekkel.

81
00:04:27,940 --> 00:04:31,780
>> A második rész a folyamat zajlik typewriter a while ciklus.

82
00:04:31,780 --> 00:04:35,000
Az általunk használt CS50 könyvtári funkciót kap bemenetet a felhasználó,

83
00:04:35,000 --> 00:04:37,190
és feltételezve, hogy nem akarják, hogy kilép a program,

84
00:04:37,190 --> 00:04:41,940
használjuk a funkciót fputs, hogy a húr, és írd meg a fájlt.

85
00:04:41,940 --> 00:04:46,700
fputs csak egy a sok funkció tudtuk használni, hogy írni a fájlt.

86
00:04:46,700 --> 00:04:51,920
Mások is fwrite, fputc, sőt fprintf.

87
00:04:51,920 --> 00:04:54,840
Függetlenül attól, hogy az adott funkció a végén használatával, bár,

88
00:04:54,840 --> 00:04:57,480
mindegyiket ismerniük kell, keresztül érveket,

89
00:04:57,480 --> 00:04:59,670
legalább két dolgot -

90
00:04:59,670 --> 00:05:03,140
mit kell írni, és ahol meg kell írni.

91
00:05:03,140 --> 00:05:07,240
A mi esetünkben az a bemeneti karakterlánc, amelyet meg kell írásbeli

92
00:05:07,240 --> 00:05:11,290
és fp a mutatót, hogy irányítja minket, ahol írunk.

93
00:05:11,290 --> 00:05:15,330
Ebben a programban, a második rész a folyamat meglehetősen egyszerű.

94
00:05:15,330 --> 00:05:17,360
Mi egyszerűen vesz egy stringet a felhasználó

95
00:05:17,360 --> 00:05:22,120
és a hozzá közvetlenül a mi kis fájl-to-nincs beviteli ellenőrzés vagy biztonsági ellenőrzéseket.

96
00:05:22,120 --> 00:05:26,160
Gyakran azonban a második rész felveszi a nagy részét a kódot.

97
00:05:26,160 --> 00:05:30,580
Végül a harmadik rész az on-line 58, hol zárja be a fájlt.

98
00:05:30,580 --> 00:05:34,860
Itt hívjuk fclose, és adja át az eredeti fájl mutatót.

99
00:05:34,860 --> 00:05:39,500
Az ezt követő sorban visszatérünk nulla, jelezve a végén a program.

100
00:05:39,500 --> 00:05:42,630
És igen, a harmadik részben olyan egyszerű, mint ezt.

101
00:05:42,630 --> 00:05:45,260
>> Menjünk tovább olvasása fájlokat.

102
00:05:45,260 --> 00:05:48,220
Vissza a könyvtárba, hogy van egy nevű fájlt printer.c.

103
00:05:48,220 --> 00:05:50,910
Fussunk, hogy a fájl már csak létre -

104
00:05:50,910 --> 00:05:53,350
doc.txt.

105
00:05:53,350 --> 00:05:58,150
Ez a program, mint a neve is sugallja, egyszerűen kinyomtatja a fájl tartalmát át hozzá.

106
00:05:58,150 --> 00:06:00,230
És ott van ez.

107
00:06:00,230 --> 00:06:03,780
A sornyi kódot mi volt korábban beírt és mentett doc.txt.

108
00:06:03,780 --> 00:06:06,980
Szia. A nevem Jason.

109
00:06:06,980 --> 00:06:09,120
Ha belevetik magukat printer.c,

110
00:06:09,120 --> 00:06:13,570
azt látjuk, hogy sok a kód hasonlít ahhoz, amit mi csak átsétált a typewriter.c.

111
00:06:13,570 --> 00:06:16,720
Valójában a 22, ahol megnyitotta a fájlt,

112
00:06:16,720 --> 00:06:19,220
és 39. sor, ahol lezárta a fájlt,

113
00:06:19,220 --> 00:06:23,890
egyaránt csaknem azonos typewriter.c, kivéve fopen második argumentum.

114
00:06:23,890 --> 00:06:26,510
Ezúttal olvasott egy fájlt,

115
00:06:26,510 --> 00:06:29,040
ezért úgy döntöttünk, r helyett w.

116
00:06:29,040 --> 00:06:31,950
Tehát, hadd összpontosítani a második része a folyamatnak.

117
00:06:31,950 --> 00:06:36,060
A vonal 35, a második feltétel a 4 hurok,

118
00:06:36,060 --> 00:06:38,590
teszünk hívás fgets,

119
00:06:38,590 --> 00:06:42,190
a társ funkció fputs előtti.

120
00:06:42,190 --> 00:06:44,660
Ezúttal három érveket.

121
00:06:44,660 --> 00:06:48,810
Az első mutató a tömb a karakterek, ha a string lesz mentve.

122
00:06:48,810 --> 00:06:52,670
A második a karakterek maximális számát kell olvasni.

123
00:06:52,670 --> 00:06:56,010
És a harmadik pedig a mutatót a fájl, amellyel dolgozunk.

124
00:06:56,010 --> 00:07:00,780
Észre fogod venni, hogy a for ciklus ér véget, amikor fgets visszatér null.

125
00:07:00,780 --> 00:07:02,940
Két oka annak, hogy ez történt.

126
00:07:02,940 --> 00:07:05,380
Először is, hiba is történt.

127
00:07:05,380 --> 00:07:10,740
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.

128
00:07:10,740 --> 00:07:14,040
Ha kíváncsi, két funkciót léteznek, amelyek lehetővé teszik számunkra, hogy elmondja

129
00:07:14,040 --> 00:07:17,160
ami miatt az oka e konkrét null pointer.

130
00:07:17,160 --> 00:07:21,090
És nem meglepő, mert köze dolgozni fájlokat,

131
00:07:21,090 --> 00:07:26,940
mind a fError funkció és a funkció feof kezdődik a levél f.

132
00:07:26,940 --> 00:07:32,130
>> Végül, mielőtt arra a következtetésre jutunk, egy gyors megjegyzés a végére fájl funkció,

133
00:07:32,130 --> 00:07:36,690
amely, mint már említettük, van írva, mint feof.

134
00:07:36,690 --> 00:07:41,550
Gyakran találja magát a while és a hurkok fokozatosan olvassa végig fájlokat.

135
00:07:41,550 --> 00:07:45,790
Í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.

136
00:07:45,790 --> 00:07:50,510
Hívása feof a fájl pointer, és ellenőrzi, hogy ha ez igaz,

137
00:07:50,510 --> 00:07:52,310
akkor nem csak ezt.

138
00:07:52,310 --> 00:07:59,820
Így, egy darabig hurok feltétel (! Feof (fp)) tűnhet, mint egy tökéletesen megfelelő megoldás.

139
00:07:59,820 --> 00:08:03,770
Ugyanakkor azt mondom, van egy sor maradt a mi szöveges fájl.

140
00:08:03,770 --> 00:08:07,130
Majd adja meg a while ciklus, és minden működni fog a tervek szerint.

141
00:08:07,130 --> 00:08:12,750
A következő forduló során, a program ellenőrzi, hogy a feof fp igaz,

142
00:08:12,750 --> 00:08:15,430
de - és ez a lényeg, hogy megértsék itt -

143
00:08:15,430 --> 00:08:17,770
ez nem lesz igaz, csak még.

144
00:08:17,770 --> 00:08:21,110
Ez azért van, mert a célja feof nem ellenőrzi

145
00:08:21,110 --> 00:08:24,400
ha a következő hívás a read függvény majd nyomja meg a végén a fájl,

146
00:08:24,400 --> 00:08:28,190
hanem az, hogy ellenőrizze-e vagy sem a végén a fájl már elérték.

147
00:08:28,190 --> 00:08:30,140
Abban az esetben, a példa,

148
00:08:30,140 --> 00:08:32,780
olvasó az utolsó sorban a mi fájl megy tökéletesen simán,

149
00:08:32,780 --> 00:08:36,210
de a program még nem tudja, hogy már megüt a végén a fájl.

150
00:08:36,210 --> 00:08:40,549
Ez nem csak ez egy további olvasásra, hogy szembeszáll a végén a fájl.

151
00:08:40,549 --> 00:08:43,210
Így, a helyes feltétel lenne a következők:

152
00:08:43,210 --> 00:08:49,330
fgets és három érvek - kimenet mérete kimenet és fp -

153
00:08:49,330 --> 00:08:52,570
és minden ami nem egyenlő null.

154
00:08:52,570 --> 00:08:55,260
Ez a megközelítés azt vette printer.c,

155
00:08:55,260 --> 00:08:57,890
és ebben az esetben, miután a hurok kilép,

156
00:08:57,890 --> 00:09:04,290
tudna hívni feof vagy fError tájékoztatja a felhasználót, hogy az adott indokolta kilépés a hurok.

157
00:09:04,290 --> 00:09:08,100
>> Írás és olvasás a fájl, annak legalapvetőbb,

158
00:09:08,100 --> 00:09:10,150
egy egyszerű 3 részből álló folyamat.

159
00:09:10,150 --> 00:09:12,530
Először is nyissa meg a fájlt.

160
00:09:12,530 --> 00:09:16,740
Másodszor, egy kis dolog, a mi fájlba vagy tegyen néhány dolgot belőle.

161
00:09:16,740 --> 00:09:19,200
Harmadszor, zárja be a fájlt.

162
00:09:19,200 --> 00:09:21,170
Az első és az utolsó alkatrészek egyszerű.

163
00:09:21,170 --> 00:09:23,920
A középső rész, ahol a trükkös dolog rejlik.

164
00:09:23,920 --> 00:09:27,760
És bár a motorháztető alatt mi mindig foglalkozik a hosszú sorozata nullák,

165
00:09:27,760 --> 00:09:30,710
ez nem segít, ha kódolás, hogy adjunk egy réteg absztrakció

166
00:09:30,710 --> 00:09:35,350
amely bekapcsolja a sorozat valami, hogy jobban hasonlít, amit mi szokta látni.

167
00:09:35,350 --> 00:09:39,570
Például, ha dolgozunk egy 24-bites bitmap fájlt,

168
00:09:39,570 --> 00:09:43,290
akkor valószínűleg írása vagy olvasása három byte egy időben.

169
00:09:43,290 --> 00:09:46,450
Abban az esetben lenne értelme, hogy meghatározza és megfelelő nevet

170
00:09:46,450 --> 00:09:48,980
Egy struct vagyis 3 byte nagy.

171
00:09:48,980 --> 00:09:51,410
>> Bár a munka fájlok tűnhet bonyolult,

172
00:09:51,410 --> 00:09:54,530
használó őket lehetővé teszi számunkra, hogy tegyünk valamit igazán figyelemre méltó.

173
00:09:54,530 --> 00:09:58,880
Meg tudjuk változtatni az állapotát a külvilág a program,

174
00:09:58,880 --> 00:10:01,730
tudunk létrehozni valamit, ami él túl életében program,

175
00:10:01,730 --> 00:10:07,190
vagy mi is változtatni valamit, amit azért hoztak létre, mielőtt a program indulásakor fut.

176
00:10:07,190 --> 00:10:11,210
Együttműködés fájlok valóban hatékony része programozás C.

177
00:10:11,210 --> 00:10:15,300
és izgatott vagyok, hogy mit fogsz létrehozni vele a kódot, hogy jöjjön.

178
00:10:15,300 --> 00:10:19,770
A nevem Jason Hirschhorn. Ez CS50.

179
00:10:19,770 --> 00:10:21,770
[CS50.TV]

180
00:10:21,770 --> 00:10:25,940
>> [Nevetés]

181
00:10:25,940 --> 00:10:29,330
Oké. Egy venni. Itt vagyunk.

182
00:10:49,000 --> 00:10:52,140
Amikor azt gondoljuk, egy fájl - >> Oh, várj. Bocsánat.

183
00:10:52,140 --> 00:10:56,800
[Nevetés] Oké.

184
00:11:06,620 --> 00:11:09,970
Hey there.

185
00:11:13,670 --> 00:11:16,310
Amikor azt gondoljuk, a file -

186
00:11:17,610 --> 00:11:20,710
Ha úgy gondolja, egy fájl - Oké. Szólj, ha készen állsz.

187
00:11:20,710 --> 00:11:22,520
Ó, remek.

188
00:11:22,520 --> 00:11:26,180
Bár olvasás a súgógép tűnhet - nem. Az én hibám.