1
00:00:00,000 --> 00:00:05,330

2
00:00:05,330 --> 00:00:07,870
>> SPEAKER: Hidtil, er det sandsynligt
at de fleste af dine programmer

3
00:00:07,870 --> 00:00:10,170
har været lidt flygtig.

4
00:00:10,170 --> 00:00:13,310
Du kører et program som Mario eller grådige.

5
00:00:13,310 --> 00:00:17,350
Det gør noget, er det måske beder
brugeren om nogle oplysninger,

6
00:00:17,350 --> 00:00:20,400
udskrive nogle output til skærmen,
men så når dit program er slut,

7
00:00:20,400 --> 00:00:23,252
der er virkelig ingen beviser der
Det blev aldrig køre i første omgang.

8
00:00:23,252 --> 00:00:25,960
Jeg mener, sikker, du måske har forladt
det åbne i terminalvinduet,

9
00:00:25,960 --> 00:00:29,770
men hvis du rydde skærmen, er der
virkelig ingen beviser for, at det eksisterede.

10
00:00:29,770 --> 00:00:33,720
Vi har ikke et middel til lagring
vedvarende information, information

11
00:00:33,720 --> 00:00:36,890
der eksisterer efter vores
Programmet er stoppet,

12
00:00:36,890 --> 00:00:39,241
eller vi ikke op til dette punkt.

13
00:00:39,241 --> 00:00:41,490
Heldigvis dog, c gør
give os mulighed

14
00:00:41,490 --> 00:00:44,220
at gøre dette ved at gennemføre
noget, der hedder

15
00:00:44,220 --> 00:00:48,330
en fil, en struktur, som stort set
repræsenterer en fil, som du ville fordoble

16
00:00:48,330 --> 00:00:53,826
klik på din computer, hvis du er
anvendes til en grafisk brugermiljø.

17
00:00:53,826 --> 00:00:55,700
Generelt når der arbejdes
med C, men vi er faktisk

18
00:00:55,700 --> 00:00:59,965
kommer til at arbejde med
henvisninger til files-- fil stars--

19
00:00:59,965 --> 00:01:02,090
bortset fra en lille smule
når vi taler om et par

20
00:01:02,090 --> 00:01:04,560
af de funktioner,
arbejde med fil pointere.

21
00:01:04,560 --> 00:01:08,990
Du behøver ikke at have virkelig gravet
for dybt ind i forståelse pointers

22
00:01:08,990 --> 00:01:09,730
selv.

23
00:01:09,730 --> 00:01:12,870
Der er en lille teeny smule
hvor vi vil tale om dem,

24
00:01:12,870 --> 00:01:18,090
men generelt fil pointers og
pointere, mens indbyrdes forbundne,

25
00:01:18,090 --> 00:01:20,290
er ikke nøjagtigt det samme.

26
00:01:20,290 --> 00:01:22,440
>> Nu hvad mener jeg, når
Jeg siger vedholdende data?

27
00:01:22,440 --> 00:01:23,650
Hvad er vedvarende data?

28
00:01:23,650 --> 00:01:25,232
Hvorfor har vi bekymrer sig om det?

29
00:01:25,232 --> 00:01:27,190
Sige, for eksempel, at
du kører et program

30
00:01:27,190 --> 00:01:29,850
eller du har omskrevet en
program, der er et spil,

31
00:01:29,850 --> 00:01:32,960
og du ønsker at holde styr
af alle brugerens bevægelser

32
00:01:32,960 --> 00:01:36,620
så måske hvis noget går galt,
du kan gennemgå filen efter kampen.

33
00:01:36,620 --> 00:01:39,970
Det er, hvad vi mener, når vi
tale om persistente data.

34
00:01:39,970 --> 00:01:43,930
>> I løbet af at køre din
program, er en fil oprettet.

35
00:01:43,930 --> 00:01:45,680
Og når dit program
er stoppet,

36
00:01:45,680 --> 00:01:48,689
at filen stadig findes på dit system.

37
00:01:48,689 --> 00:01:50,230
Og vi kan se på det og undersøge det.

38
00:01:50,230 --> 00:01:53,670
Og så programmet vil blive indstillet til
har skabt nogle vedholdende data,

39
00:01:53,670 --> 00:01:57,390
Der findes data, efter at programmet
er færdig med at køre.

40
00:01:57,390 --> 00:02:02,320
>> Nu er alle disse funktioner, der arbejder
med at skabe filer og manipulere

41
00:02:02,320 --> 00:02:04,940
dem på forskellige måder
bor i standard io.h,

42
00:02:04,940 --> 00:02:08,210
som er en header fil,
du sandsynligvis har været pund

43
00:02:08,210 --> 00:02:10,910
herunder i toppen af ​​smukke
meget alle dine programmer

44
00:02:10,910 --> 00:02:14,130
fordi den indeholder en af ​​de
mest nyttige funktioner for os,

45
00:02:14,130 --> 00:02:16,130
printf, som også lader
bor i standard io.h.

46
00:02:16,130 --> 00:02:20,400
Så du behøver ikke at pund omfatter
yderligere filer formentlig

47
00:02:20,400 --> 00:02:23,540
med henblik på at arbejde med fil pointers.

48
00:02:23,540 --> 00:02:29,980
>> Nu hver enkelt fil pointer-funktion,
eller hver enkelt fil I / O, input output

49
00:02:29,980 --> 00:02:33,310
funktion, accepterer som en
af dens parametre eller input

50
00:02:33,310 --> 00:02:35,822
en fil pointer-- bortset
for én, fopen, som

51
00:02:35,822 --> 00:02:38,280
er, hvad du bruger til at få filen
pointer i første omgang.

52
00:02:38,280 --> 00:02:41,010
Men når du har åbnet
fil, og du får fil pointere,

53
00:02:41,010 --> 00:02:43,510
du kan derefter passere dem som
argumenter til de forskellige funktioner

54
00:02:43,510 --> 00:02:46,720
vi kommer til at tale om
dag, samt mange andre

55
00:02:46,720 --> 00:02:48,520
så du kan arbejde med filer.

56
00:02:48,520 --> 00:02:50,980
>> Så der er seks temmelig
fælles grundlæggende dem

57
00:02:50,980 --> 00:02:52,870
at vi kommer til at tale om i dag.

58
00:02:52,870 --> 00:02:57,160
fopen og dens følgesvend
funktion fclose, fgetc

59
00:02:57,160 --> 00:03:02,670
og dens følgesvend funktion fputc,
og fread og dens følgesvend funktion,

60
00:03:02,670 --> 00:03:03,820
fwrite.

61
00:03:03,820 --> 00:03:05,180
Så lad os få ret i det.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- hvad gør det?

63
00:03:07,050 --> 00:03:10,050
Tja, det åbner en fil, og det
giver dig en fil pegepind til det,

64
00:03:10,050 --> 00:03:14,000
så du derefter kan bruge det
fil pointer som et argument

65
00:03:14,000 --> 00:03:16,730
ethvert af den anden fil I / O-funktioner.

66
00:03:16,730 --> 00:03:19,100
Det vigtigste
at huske med fopen

67
00:03:19,100 --> 00:03:24,222
er, at efter du har åbnet
fil eller foretaget et opkald som den her,

68
00:03:24,222 --> 00:03:26,930
du nødt til at tjekke for at sikre
at markøren at du fik tilbage

69
00:03:26,930 --> 00:03:28,320
er ikke lig med nul.

70
00:03:28,320 --> 00:03:31,320
Hvis du ikke har set videoen på
pointere, kan dette ikke mening.

71
00:03:31,320 --> 00:03:35,639
Men hvis du prøver og dereference
en null pointer tilbagekaldelse,

72
00:03:35,639 --> 00:03:38,180
dit program vil formentlig lide
en segmentering [uhørligt].

73
00:03:38,180 --> 00:03:40,540
Vi ønsker at sikre, at vi
fik en legitim pointer tilbage.

74
00:03:40,540 --> 00:03:43,665
Langt størstedelen af ​​den tid, vi vil
har fået en legitim pointer tilbage

75
00:03:43,665 --> 00:03:45,280
og det vil ikke være et problem.

76
00:03:45,280 --> 00:03:46,760
>> Så hvordan kan vi foretage et opkald til fopen?

77
00:03:46,760 --> 00:03:48,051
Det ser temmelig meget som denne.

78
00:03:48,051 --> 00:03:52,690
Fil stjerne ptr-- PTR være en generisk
navn til filen pointer-- fopen

79
00:03:52,690 --> 00:03:57,300
og vi passerer i to ting, et filnavn
og en operation, vi ønsker at foretage.

80
00:03:57,300 --> 00:04:01,690
Så vi har måske et opkald, der ligner
denne-- fil stjerne PTR 1 er lig med fopen

81
00:04:01,690 --> 00:04:04,040
file1.txt.

82
00:04:04,040 --> 00:04:07,020
Og operationen, jeg har valgt, er r.

83
00:04:07,020 --> 00:04:08,639
>> Så hvad tror du r er her?

84
00:04:08,639 --> 00:04:11,180
Hvad er den slags ting, vi
kan være i stand til at gøre for at filer?

85
00:04:11,180 --> 00:04:13,760

86
00:04:13,760 --> 00:04:17,500
Så r er operation, som vi
vælge, når vi ønsker at læse en fil.

87
00:04:17,500 --> 00:04:20,260
Så vi ville dybest set, når
Vi foretager et opkald som denne

88
00:04:20,260 --> 00:04:25,440
være at få os en fil pointer
sådan, at vi så kunne læse oplysninger

89
00:04:25,440 --> 00:04:27,770
fra file1.txt.

90
00:04:27,770 --> 00:04:34,190
>> Tilsvarende kunne vi åbne filen 2.txt
til at skrive og så vi kan passere ptr2,

91
00:04:34,190 --> 00:04:38,210
filen pointer jeg har oprettet her,
som et argument for enhver funktion,

92
00:04:38,210 --> 00:04:40,080
skriver information til en fil.

93
00:04:40,080 --> 00:04:43,767
Og ligner skriftligt, er der
også mulighed for at tilføje en.

94
00:04:43,767 --> 00:04:45,600
Forskellen mellem
skrive og tilføje

95
00:04:45,600 --> 00:04:50,920
er, at når du skriver til en fil,
hvis du foretage et opkald til fopen til skrivning

96
00:04:50,920 --> 00:04:54,761
og at filen findes allerede, er det
kommer til at overskrive hele filen.

97
00:04:54,761 --> 00:04:56,510
Det kommer til at starte
i begyndelsen,

98
00:04:56,510 --> 00:04:58,820
slette alle de oplysninger,
Det er der allerede.

99
00:04:58,820 --> 00:05:02,210
>> Hvorimod hvis du åbner den for at tilføje,
det vil gå til slutningen af ​​filen

100
00:05:02,210 --> 00:05:04,340
hvis der er allerede tekst i
det eller oplysninger i det,

101
00:05:04,340 --> 00:05:06,040
og det vil derefter begynde
skriver derfra.

102
00:05:06,040 --> 00:05:08,570
Så vil du ikke miste nogen af ​​de
oplysninger, du har gjort før.

103
00:05:08,570 --> 00:05:12,110
Uanset om du ønsker at skrive eller tilføje
slags afhænger af situationen.

104
00:05:12,110 --> 00:05:16,840
Men du vil sikkert vide, hvad
rigtige betjening er, når den tid kommer.

105
00:05:16,840 --> 00:05:18,020
Så det er fopen.

106
00:05:18,020 --> 00:05:18,930
>> Hvad med fclose?

107
00:05:18,930 --> 00:05:21,600
Nå, temmelig enkelt, fclose
bare accepterer filen pointer.

108
00:05:21,600 --> 00:05:24,000
Og som man kunne forvente,
det lukker filen.

109
00:05:24,000 --> 00:05:29,270
Og når vi har lukket en fil, kan vi ikke
udføre mere fil I / O-funktioner,

110
00:05:29,270 --> 00:05:31,420
læse eller skrive, på den pågældende fil.

111
00:05:31,420 --> 00:05:36,444
Vi er nødt til at genåbne
indgive en anden gang med henblik på

112
00:05:36,444 --> 00:05:38,610
at arbejde videre med
den ved hjælp af I / O-funktioner.

113
00:05:38,610 --> 00:05:41,520
Så fclose midler vi er færdige
arbejde med denne fil.

114
00:05:41,520 --> 00:05:44,690
Og alle vi nødt til at passere i, er
navnet på en fil pointer.

115
00:05:44,690 --> 00:05:50,010
Så på et par glider siden, vi
fopened fil 1 dot tekst til læsning

116
00:05:50,010 --> 00:05:52,854
og vi tildelt, at
fil pointer til ptr1.

117
00:05:52,854 --> 00:05:55,020
Nu har vi besluttet vi er
færdig med at læse fra filen.

118
00:05:55,020 --> 00:05:56,561
Vi behøver ikke at gøre mere med det.

119
00:05:56,561 --> 00:05:58,890
Vi kan bare fclose ptr1.

120
00:05:58,890 --> 00:06:01,950
Og på samme måde, kunne vi
fclose de andre.

121
00:06:01,950 --> 00:06:02,450
Okay.

122
00:06:02,450 --> 00:06:03,700
Så der er åbning og lukning.

123
00:06:03,700 --> 00:06:05,780
Det er de to grundlæggende
igangsætning.

124
00:06:05,780 --> 00:06:08,050
>> Nu vil vi faktisk
gøre nogle interessante ting,

125
00:06:08,050 --> 00:06:11,940
og den første funktion, som vi vil
se, der vil gøre det er fgetc--

126
00:06:11,940 --> 00:06:14,110
fil får et tegn.

127
00:06:14,110 --> 00:06:17,350
Det er, hvad fgetc generelt
ville oversætte til.

128
00:06:17,350 --> 00:06:20,190
Dens mål i livet er at
læse næste tegn,

129
00:06:20,190 --> 00:06:22,079
eller hvis dette er din helt
første opkald til fgetc

130
00:06:22,079 --> 00:06:23,870
til en bestemt fil,
det første tegn.

131
00:06:23,870 --> 00:06:26,210
Men så efter det,
du får den næste,

132
00:06:26,210 --> 00:06:31,500
meget næste karakter af denne fil,
og gemmer det i en variabel karakter.

133
00:06:31,500 --> 00:06:34,490
Som vi har gjort her,
char ch lig fgetc,

134
00:06:34,490 --> 00:06:36,389
passere i navnet på en fil pointer.

135
00:06:36,389 --> 00:06:38,180
Igen, det er meget
her vigtigt at huske

136
00:06:38,180 --> 00:06:41,430
at for at få
denne operation lykkes,

137
00:06:41,430 --> 00:06:45,690
filen pointer selv mĺ have
blevet åbnet for læsning.

138
00:06:45,690 --> 00:06:50,589
Vi kan ikke læse et tegn fra en fil
pointer, som vi åbnede for skrivning.

139
00:06:50,589 --> 00:06:52,630
Så det er en af ​​de
begrænsninger af fopen, ikke?

140
00:06:52,630 --> 00:06:55,470
Vi er nødt til at begrænse
os selv til kun at udføre

141
00:06:55,470 --> 00:06:57,710
en operation med én fil pointer.

142
00:06:57,710 --> 00:07:00,220
Hvis vi ønskede at læse og
skrive fra den samme fil,

143
00:07:00,220 --> 00:07:03,840
ville vi have åbent to separate
fil henvisninger til samme file--

144
00:07:03,840 --> 00:07:05,670
én for læsning, én for skrivning.

145
00:07:05,670 --> 00:07:08,400
>> Så igen, den eneste grund
Jeg bringer det op nu, er

146
00:07:08,400 --> 00:07:11,920
for hvis vi kommer til at foretage et opkald
til fgetc, at filen pointer må have

147
00:07:11,920 --> 00:07:14,172
blevet åbnet for læsning.

148
00:07:14,172 --> 00:07:15,880
Og så temmelig enkelt,
alt, hvad vi behøver at gøre

149
00:07:15,880 --> 00:07:17,546
er passere i navnet på filen pointer.

150
00:07:17,546 --> 00:07:21,060
Så char ch lig fgetc ptr1.

151
00:07:21,060 --> 00:07:23,200
>> Det kommer til at få os
næste character--

152
00:07:23,200 --> 00:07:25,575
eller igen, hvis dette er den første
gang vi har lavet denne indkaldelse,

153
00:07:25,575 --> 00:07:29,750
den første character-- uanset
fil er peget på af ptr1.

154
00:07:29,750 --> 00:07:32,210
Husk på, at det var fil 1 dot tekst.

155
00:07:32,210 --> 00:07:36,490
Det får det første tegn i det
og vi vil gemme det i variablen lm.

156
00:07:36,490 --> 00:07:37,941
Temmelig ligetil.

157
00:07:37,941 --> 00:07:40,190
Så vi har kun set på tre
funktioner og allerede vi

158
00:07:40,190 --> 00:07:43,070
kan gøre noget temmelig pæn.

159
00:07:43,070 --> 00:07:46,320
>> Så hvis vi tager denne evne
for at få en karakter

160
00:07:46,320 --> 00:07:48,943
og vi loop it-- så vi
fortsætte med at få tegn

161
00:07:48,943 --> 00:07:51,390
fra en fil over og
igen og over-- nu er vi

162
00:07:51,390 --> 00:07:54,500
kan læse hver eneste
karakter af en fil.

163
00:07:54,500 --> 00:07:58,670
Og hvis vi udskriver hvert tegn
umiddelbart efter, at vi læser det,

164
00:07:58,670 --> 00:08:01,960
Vi har nu læst fra en fil og
trykt dens indhold til skærmen.

165
00:08:01,960 --> 00:08:05,610
Vi har effektivt sammenkædet
filen på skærmen.

166
00:08:05,610 --> 00:08:09,670
Og det er, hvad det
Linux kommando kat gør.

167
00:08:09,670 --> 00:08:13,250
>> Hvis du skriver kat i filnavnet, det
vil udskrive hele indholdet

168
00:08:13,250 --> 00:08:15,160
af filen i dit terminalvindue.

169
00:08:15,160 --> 00:08:19,010
Og så denne lille løkke her,
kun tre linjer kode,

170
00:08:19,010 --> 00:08:23,270
men det effektivt dubletter
Linux-kommandoen kat.

171
00:08:23,270 --> 00:08:25,210
Så denne syntaks måske
ser lidt underligt,

172
00:08:25,210 --> 00:08:26,670
men her er, hvad der sker her.

173
00:08:26,670 --> 00:08:31,460
Mens lm lig fgetc, ptr er ikke
svarende til EOF-- det er en hel mundfuld,

174
00:08:31,460 --> 00:08:34,669
men lad os bryde det ned lige
så det er klar på syntaksen.

175
00:08:34,669 --> 00:08:37,169
Jeg har konsolideret det
af hensyn til plads,

176
00:08:37,169 --> 00:08:39,049
selv om det er lidt
syntaktisk tricky.

177
00:08:39,049 --> 00:08:41,194
>> Så denne del i grøn højre
nu, hvad det gør?

178
00:08:41,194 --> 00:08:42,860
Tja, det er bare vores fgetc opkald, ikke?

179
00:08:42,860 --> 00:08:44,530
Vi har set det før.

180
00:08:44,530 --> 00:08:49,500
Det er at få en
karakter fra filen.

181
00:08:49,500 --> 00:08:53,220
Så vi sammenligner, at
karakter mod EOF.

182
00:08:53,220 --> 00:08:57,470
EOF er en særlig værdi, der er
defineret i standard io.h, som

183
00:08:57,470 --> 00:08:59,390
er slutningen af ​​filen karakter.

184
00:08:59,390 --> 00:09:03,450
Så dybest set, hvad der vil ske
er denne løkke vil læse et tegn,

185
00:09:03,450 --> 00:09:07,445
sammenligne det med eof, den
slutningen af ​​filen karakter.

186
00:09:07,445 --> 00:09:10,070
Hvis de ikke stemmer overens, så vi ikke har
nået enden af ​​filen,

187
00:09:10,070 --> 00:09:11,490
vi vil printe denne karakter ud.

188
00:09:11,490 --> 00:09:13,740
Så vil vi gå tilbage til
begyndelsen af ​​sløjfen igen.

189
00:09:13,740 --> 00:09:18,310
Vi får en karakter, skal du kontrollere
mod EOF, printe den ud, og så videre

190
00:09:18,310 --> 00:09:21,094
og så videre og så videre,
looping igennem på den måde

191
00:09:21,094 --> 00:09:22,760
indtil vi har nået slutningen af ​​filen.

192
00:09:22,760 --> 00:09:24,593
Og derefter ved dette punkt,
Vi vil have udskrevet

193
00:09:24,593 --> 00:09:26,210
ud hele indholdet af filen.

194
00:09:26,210 --> 00:09:29,450
Så igen, har vi kun set
fopen, fclose, og fgetc

195
00:09:29,450 --> 00:09:34,950
og allerede kan vi kopiere
en Linux terminal kommando.

196
00:09:34,950 --> 00:09:38,850
>> Som jeg sagde i begyndelsen,
vi havde fgetc og fputc,

197
00:09:38,850 --> 00:09:41,860
og fputc var følgesvend
funktion fgetc.

198
00:09:41,860 --> 00:09:44,880
Og så, som du måske forestiller dig,
Det er skriften tilsvarende.

199
00:09:44,880 --> 00:09:49,440
Det giver os mulighed for at skrive en
enkelt tegn i en fil.

200
00:09:49,440 --> 00:09:53,290
>> Igen, det forbehold er, lige
ligesom det var med fgetc, filen

201
00:09:53,290 --> 00:09:56,660
at vi skriver til skal har været
åbnet for skriftligt eller til at tilføje.

202
00:09:56,660 --> 00:10:00,820
Hvis vi forsøge at benytte fputc på en fil
at vi har åbnet for læsning,

203
00:10:00,820 --> 00:10:02,760
vi kommer til at lide
lidt af en fejltagelse.

204
00:10:02,760 --> 00:10:04,440
Men opkaldet er ret enkel.

205
00:10:04,440 --> 00:10:08,000
fputc kapital En ptr2, alle
der kommer til at gøre, er at det er

206
00:10:08,000 --> 00:10:12,040
vil skrive brevet
i A i fil 2 prik

207
00:10:12,040 --> 00:10:14,760
tekst, som var navnet på den
fil, at vi åbnede og tildeles

208
00:10:14,760 --> 00:10:17,280
markøren til ptr2.

209
00:10:17,280 --> 00:10:20,430
Så vi kommer til at skrive en
kapital A til fil 2 dot tekst.

210
00:10:20,430 --> 00:10:24,592
Og vi vil skrive et udråbstegn
pege på filen 3 prik

211
00:10:24,592 --> 00:10:27,330
tekst, der blev peget på af ptr3.

212
00:10:27,330 --> 00:10:29,730
Så igen, temmelig ligetil her.

213
00:10:29,730 --> 00:10:32,727
>> Men nu kan vi gøre en anden ting.

214
00:10:32,727 --> 00:10:34,560
Vi har dette eksempel
vi var bare at gå over

215
00:10:34,560 --> 00:10:38,950
om at være i stand til at replikere katten
Linux kommando, den ene, der udskriver

216
00:10:38,950 --> 00:10:40,500
på skærmen.

217
00:10:40,500 --> 00:10:43,510
Nå, nu hvor vi har mulighed for
at læse tegn fra filer

218
00:10:43,510 --> 00:10:46,590
og skrive tegn til filer,
hvorfor vi ikke bare erstatte, at

219
00:10:46,590 --> 00:10:50,720
ringe til printf med en opfordring til fputc.

220
00:10:50,720 --> 00:10:54,090
>> Og nu har vi duplikeret cp,
en meget grundlæggende Linux kommando

221
00:10:54,090 --> 00:10:59,100
at vi talte om vejen lang
siden i linux kommandoer video.

222
00:10:59,100 --> 00:11:01,070
Vi har effektivt
duplikeres, at lige her.

223
00:11:01,070 --> 00:11:04,790
Vi læser en karakter og så er vi
skrive denne karakter til en anden fil.

224
00:11:04,790 --> 00:11:07,660
Læsning fra en fil, skrivning
til en anden, igen og igen

225
00:11:07,660 --> 00:11:11,350
og igen, indtil vi ramte EOF.

226
00:11:11,350 --> 00:11:14,250
Vi har fået til slutningen af ​​den
fil vi forsøger at kopiere fra.

227
00:11:14,250 --> 00:11:18,500
Og ved at vi vil have skrevet alle
af de tegn, vi har brug for til filen

228
00:11:18,500 --> 00:11:19,500
at vi skriver til.

229
00:11:19,500 --> 00:11:24,270
Så dette er cp, Linux kopi kommando.

230
00:11:24,270 --> 00:11:26,550
>> I begyndelsen af
denne video, jeg havde det forbehold

231
00:11:26,550 --> 00:11:29,840
at vi ville tale et
lidt om pointere.

232
00:11:29,840 --> 00:11:32,480
Her er specifikt, hvor vi er
vil tale om pejlemærker

233
00:11:32,480 --> 00:11:34,800
Ud over at indgive pointere.

234
00:11:34,800 --> 00:11:37,870
Så denne funktion ser lidt skræmmende.

235
00:11:37,870 --> 00:11:39,120
Det har fået flere parametre.

236
00:11:39,120 --> 00:11:40,430
Der er en masse foregår her.

237
00:11:40,430 --> 00:11:42,760
Der er en masse forskellige
farver og tekster.

238
00:11:42,760 --> 00:11:47,100
Men virkelig, det er bare den
generisk version af fgetc

239
00:11:47,100 --> 00:11:50,110
der giver os mulighed for at få nogen
mængde information.

240
00:11:50,110 --> 00:11:53,560
Det kan være en smule ineffektivt, hvis vi er
få tegn en ad gangen,

241
00:11:53,560 --> 00:11:55,770
iteration gennem filen
et tegn ad gangen.

242
00:11:55,770 --> 00:12:00,230
Ville det ikke være pænere at få
100 ad gangen eller 500 ad gangen?

243
00:12:00,230 --> 00:12:03,250
>> Nå, fread og dens følgesvend funktion
fwrite, som vi taler om

244
00:12:03,250 --> 00:12:05,490
i en anden, giver os mulighed for at gøre netop dette.

245
00:12:05,490 --> 00:12:08,480
Vi kan læse en vilkårlig mængde
af oplysninger fra en fil

246
00:12:08,480 --> 00:12:10,290
og vi gemmer det et sted midlertidigt.

247
00:12:10,290 --> 00:12:12,980
I stedet for at være i stand til blot
passer det i en enkelt variabel,

248
00:12:12,980 --> 00:12:15,790
vi måske nødt til at gemme det i et array.

249
00:12:15,790 --> 00:12:19,980
Og så, vi passerer i fire
argumenter for at fread-- en pegepind

250
00:12:19,980 --> 00:12:23,940
til det sted, hvor vi er
kommer til at gemme oplysninger,

251
00:12:23,940 --> 00:12:29,180
hvor stor hver informationsenhed
vil være, hvor mange enheder af information

252
00:12:29,180 --> 00:12:35,192
vi ønsker at erhverve, og fra
hvilken fil, vi ønsker at få dem.

253
00:12:35,192 --> 00:12:37,150
Sandsynligvis bedst illustreret
med et eksempel her.

254
00:12:37,150 --> 00:12:41,640
Så lad os sige, at vi erklærer
et array af 10 heltal.

255
00:12:41,640 --> 00:12:45,080
Vi har netop erklæret på
stable vilkårligt int arr 10.

256
00:12:45,080 --> 00:12:46,970
Så det er temmelig ligetil.

257
00:12:46,970 --> 00:12:51,970
Nu, hvad vi gør imidlertid den
frecall er vi læser størrelse int

258
00:12:51,970 --> 00:12:54,180
gange 10 bytes af information.

259
00:12:54,180 --> 00:12:59,040
Størrelse af int væsen four-- det er
størrelsen af ​​et heltal i c.

260
00:12:59,040 --> 00:13:02,790
>> Så det, vi gør, er at vi læser
40 bytes værd af oplysninger

261
00:13:02,790 --> 00:13:05,850
fra filen peget på af PTR.

262
00:13:05,850 --> 00:13:08,600
Og vi opbevare dem
40 bytes eller andet sted

263
00:13:08,600 --> 00:13:12,080
hvor vi har afsat
40 byte værd af hukommelse.

264
00:13:12,080 --> 00:13:15,970
Heldigvis har vi allerede gjort, at ved
erklære arr, at vifte lige der.

265
00:13:15,970 --> 00:13:19,770
Der er i stand bedrift
10 fire-byte enheder.

266
00:13:19,770 --> 00:13:22,860
Så i alt kan det holde 40
byte værd af oplysninger.

267
00:13:22,860 --> 00:13:26,540
Og vi er nu læser 40 bytes
af oplysninger fra filen,

268
00:13:26,540 --> 00:13:30,330
og vi opbevare det i arr.

269
00:13:30,330 --> 00:13:35,470
>> Recall fra videoen på pejlemærker, som
navnet på et array, såsom arr,

270
00:13:35,470 --> 00:13:38,370
er egentlig bare en pointer
til sin første element.

271
00:13:38,370 --> 00:13:43,680
Så når vi passere i arr der, vi
er faktisk, passerer en pointer.

272
00:13:43,680 --> 00:13:46,120
>> Ligeledes kan vi gøre denne--
vi ikke nødvendigvis

273
00:13:46,120 --> 00:13:51,200
har brug for at redde vores buffer på stakken.

274
00:13:51,200 --> 00:13:54,990
Vi kunne også dynamisk allokere
en buffer som dette, ved hjælp af malloc.

275
00:13:54,990 --> 00:13:57,340
Husk, når vi
dynamisk allokere hukommelse,

276
00:13:57,340 --> 00:14:00,550
Vi gemmer det på
bunke, ikke stakken.

277
00:14:00,550 --> 00:14:02,110
Men det er stadig en buffer.

278
00:14:02,110 --> 00:14:06,810
>> Det er stadig, i dette tilfælde, er
holder 640 bytes information

279
00:14:06,810 --> 00:14:09,230
fordi en dobbelt fylder otte bytes.

280
00:14:09,230 --> 00:14:11,570
Og vi beder om 80 af dem.

281
00:14:11,570 --> 00:14:13,770
Vi ønsker at have plads
til at holde 80 dobbeltværelser.

282
00:14:13,770 --> 00:14:17,210
Så 80 gange 8 er 640 bytes information.

283
00:14:17,210 --> 00:14:21,880
Og at opkald til fread er
indsamle 640 bytes information

284
00:14:21,880 --> 00:14:27,770
fra filen pegede på ved
PTR og lagring nu arr2.

285
00:14:27,770 --> 00:14:32,770
>> Nu kan vi også behandle fread
ligesom en opfordring til fgetc.

286
00:14:32,770 --> 00:14:37,140
I dette tilfælde, vi prøver bare at
få en karakter fra filen.

287
00:14:37,140 --> 00:14:40,070
Og vi har ikke brug for en
matrix til at holde et tegn.

288
00:14:40,070 --> 00:14:43,170
Vi kan bare gemme det i
et tegn variabel.

289
00:14:43,170 --> 00:14:46,390
>> Fangsten er dog, at
når vi bare have en variabel,

290
00:14:46,390 --> 00:14:50,290
vi nødt til at passere i
adressen på denne variabel

291
00:14:50,290 --> 00:14:52,550
fordi minde om, at
første argument til fread

292
00:14:52,550 --> 00:14:59,210
er en pointer til det sted og hukommelse
hvor vi ønsker at gemme oplysningerne.

293
00:14:59,210 --> 00:15:01,550
Igen, navnet på en
array er en pointer.

294
00:15:01,550 --> 00:15:04,200
Så vi ikke behøver at gøre tegnet array.

295
00:15:04,200 --> 00:15:07,270
Men C, tegnet c
Her er ikke et array.

296
00:15:07,270 --> 00:15:08,390
Det er bare en variabel.

297
00:15:08,390 --> 00:15:11,840
Og så er vi nødt til at bestå en
tegnet c at angive

298
00:15:11,840 --> 00:15:15,350
at det er den adresse, hvor vi ønsker
at gemme denne én byte af information,

299
00:15:15,350 --> 00:15:20,479
denne ene figur,
vi indsamler fra PTR.

300
00:15:20,479 --> 00:15:22,270
Fwrite-- jeg vil gå igennem
det lidt mere

301
00:15:22,270 --> 00:15:25,440
quickly-- er stort set den
nøjagtige ækvivalent fread

302
00:15:25,440 --> 00:15:27,720
undtagen det er for at skrive
i stedet for læsning, bare

303
00:15:27,720 --> 00:15:31,610
ligesom other-- vi har haft åben
og tæt, får en karakter,

304
00:15:31,610 --> 00:15:32,530
skrive et tegn.

305
00:15:32,530 --> 00:15:35,040
Nu er det få vilkårlig
mængden af ​​information,

306
00:15:35,040 --> 00:15:37,170
ret vilkårlig mængde information.

307
00:15:37,170 --> 00:15:39,790
Så ligesom før, vi kan
har et array af 10 heltal

308
00:15:39,790 --> 00:15:43,210
hvor vi allerede har
lagrede oplysninger, måske.

309
00:15:43,210 --> 00:15:46,580
>> Det var sandsynligvis nogle linjer kode
der bør gå mellem disse to

310
00:15:46,580 --> 00:15:49,990
hvor jeg fylder arr med
noget meningsfuldt.

311
00:15:49,990 --> 00:15:51,880
Jeg fylder den med 10 forskellige heltal.

312
00:15:51,880 --> 00:15:54,920
Og i stedet, hvad jeg er
gør skriver fra arr

313
00:15:54,920 --> 00:15:58,600
og indsamling af oplysningerne fra arr.

314
00:15:58,600 --> 00:16:02,390
Og jeg tager, at oplysninger
og lagde den ind i filen.

315
00:16:02,390 --> 00:16:05,410
>> Så i stedet for at det er fra
filen til bufferen,

316
00:16:05,410 --> 00:16:08,790
vi nu går fra
bufferen til filen.

317
00:16:08,790 --> 00:16:10,580
Så det er lige omvendt.

318
00:16:10,580 --> 00:16:16,680
Så igen, ligesom før, vi kan
også have en bunke chunk hukommelse

319
00:16:16,680 --> 00:16:19,600
at vi har dynamisk
tildelt og læses fra, at

320
00:16:19,600 --> 00:16:21,570
og skrive det til filen.

321
00:16:21,570 --> 00:16:24,900
>> Og vi har også en enkelt variabel
stand til at holde en byte

322
00:16:24,900 --> 00:16:27,200
af information, såsom en karakter.

323
00:16:27,200 --> 00:16:29,830
Men igen, vi er nødt til at passere i
adressen på denne variabel

324
00:16:29,830 --> 00:16:31,840
når vi ønsker at læse fra den.

325
00:16:31,840 --> 00:16:35,280
Så vi kan skrive de oplysninger,
vi finder på denne adresse

326
00:16:35,280 --> 00:16:39,050
til filen pointer, PTR.

327
00:16:39,050 --> 00:16:41,630
>> Der er masser af andre
stor fil I / O-funktioner

328
00:16:41,630 --> 00:16:44,650
at gøre forskellige ting udover
dem vi har talt om i dag.

329
00:16:44,650 --> 00:16:46,450
Et par af dem
du måske finde nyttige

330
00:16:46,450 --> 00:16:50,840
er fgets og fputs,
der andrager

331
00:16:50,840 --> 00:16:56,190
af fgetc og fputc men for læsning
en enkelt streng fra en fil.

332
00:16:56,190 --> 00:16:59,020
I stedet for et enkelt tegn,
det vil læse en hel streng.

333
00:16:59,020 --> 00:17:02,940
fprintf, som dybest set giver
dig at bruge printf til at skrive til filen.

334
00:17:02,940 --> 00:17:05,619
Så ligesom du kan gøre det
variabel substitution hjælp

335
00:17:05,619 --> 00:17:09,900
den pladsholdere procent i og
procent d, og så videre, med printf

336
00:17:09,900 --> 00:17:14,690
du kan ligeledes tage
printf snor og udskrive noget

337
00:17:14,690 --> 00:17:16,800
ligesom til en fil.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- hvis du har en dvd-afspiller
er den analogi, jeg plejer at bruge her--

339
00:17:20,720 --> 00:17:23,109
er lidt ligesom at bruge din
spole tilbage og spole frem

340
00:17:23,109 --> 00:17:25,819
knapperne til at bevæge sig rundt i filmen.

341
00:17:25,819 --> 00:17:28,369
På samme måde kan du flytte rundt på filen.

342
00:17:28,369 --> 00:17:30,250
En af de ting inde
at filstrukturen

343
00:17:30,250 --> 00:17:34,270
at C skaber for dig, er en indikator
af, hvor du er i filen.

344
00:17:34,270 --> 00:17:36,420
Er du i det
begynder ved byte nul?

345
00:17:36,420 --> 00:17:39,290
Er du på byte 100,
byte 1.000, og så videre?

346
00:17:39,290 --> 00:17:44,340
Du kan bruge fseek til vilkårligt at flytte
at indikator frem eller tilbage.

347
00:17:44,340 --> 00:17:46,744
>> Og ftell igen
ligner en dvd-afspiller,

348
00:17:46,744 --> 00:17:49,660
er ligesom en lille ur, der fortæller
dig, hvor mange minutter og sekunder du

349
00:17:49,660 --> 00:17:52,480
er i en bestemt film.

350
00:17:52,480 --> 00:17:56,990
Ligeledes ftell fortæller dig, hvordan
mange bytes du er i filen.

351
00:17:56,990 --> 00:18:00,210
feof er en anden version
detektere, om du har

352
00:18:00,210 --> 00:18:01,700
nået enden af ​​filen.

353
00:18:01,700 --> 00:18:03,600
Og ferror er en funktion
som du kan bruge

354
00:18:03,600 --> 00:18:06,959
at afsløre, om noget har
gået galt arbejdsmiljø med en fil.

355
00:18:06,959 --> 00:18:08,750
Igen, dette er bare
ridse overfladen.

356
00:18:08,750 --> 00:18:12,730
Der er stadig masser mere fil I / O
funktioner i standard io.h.

357
00:18:12,730 --> 00:18:16,620
Men det vil sandsynligvis få dig
begyndte at arbejde med fil pointere.

358
00:18:16,620 --> 00:18:17,640
Jeg er Doug Lloyd.

359
00:18:17,640 --> 00:18:19,750
Det er CS50.

360
00:18:19,750 --> 00:18:21,669