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

2
00:00:05,330 --> 00:00:07,870
>> SPEAKER: Så langt er det sannsynlig
at de fleste av programmene dine

3
00:00:07,870 --> 00:00:10,170
har vært litt flyktig.

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

5
00:00:13,310 --> 00:00:17,350
Det gjør noe, det kanskje ber
brukeren for litt informasjon,

6
00:00:17,350 --> 00:00:20,400
skrive ut noen utgang til skjermen,
men så når programmet er over,

7
00:00:20,400 --> 00:00:23,252
det er egentlig ingen bevis der
det ble noen gang kjørt i første omgang.

8
00:00:23,252 --> 00:00:25,960
Jeg mener, sikkert, kanskje du har igjen
det åpner i terminalvinduet,

9
00:00:25,960 --> 00:00:29,770
men hvis du tømme skjermen din, er det
egentlig ingen bevis for at det eksisterte.

10
00:00:29,770 --> 00:00:33,720
Vi har ikke en måte å lagre
vedvarende, informasjon

11
00:00:33,720 --> 00:00:36,890
som eksisterer etter vår
Programmet har stoppet,

12
00:00:36,890 --> 00:00:39,241
eller vi ikke ha opp til dette punktet.

13
00:00:39,241 --> 00:00:41,490
Heldigvis skjønt, gjør c
gi oss muligheten

14
00:00:41,490 --> 00:00:44,220
å gjøre dette ved å implementere
noe som kalles

15
00:00:44,220 --> 00:00:48,330
en fil, en struktur som i utgangspunktet
representerer en fil som du ville doble

16
00:00:48,330 --> 00:00:53,826
klikk på datamaskinen din, hvis du er
vant til et grafisk brukergrensesnitt-miljø.

17
00:00:53,826 --> 00:00:55,700
Vanligvis når du arbeider
med c, er vi faktisk

18
00:00:55,700 --> 00:00:59,965
kommer til å jobbe med
pekere til files-- fil stars--

19
00:00:59,965 --> 00:01:02,090
med unntak av en liten bit
når vi snakker om et par

20
00:01:02,090 --> 00:01:04,560
av funksjonene som
arbeide med filen pekere.

21
00:01:04,560 --> 00:01:08,990
Du trenger ikke å ha virkelig gravd
for dypt inn i forståelse pekere

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

23
00:01:09,730 --> 00:01:12,870
Det er en liten teeny bit
hvor vi vil snakke om dem,

24
00:01:12,870 --> 00:01:18,090
men generelt fil pekere og
pekere, mens henger sammen,

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

26
00:01:20,290 --> 00:01:22,440
>> Nå hva mener jeg da
Jeg sier vedvarende data?

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

28
00:01:23,650 --> 00:01:25,232
Hvorfor bryr vi oss om det?

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

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

31
00:01:29,850 --> 00:01:32,960
og du ønsker å holde styr
av alle brukerens bevegelser

32
00:01:32,960 --> 00:01:36,620
slik at kanskje hvis noe går galt,
du kan lese filen etter kampen.

33
00:01:36,620 --> 00:01:39,970
Det er hva vi mener når vi
snakke om vedvarende data.

34
00:01:39,970 --> 00:01:43,930
>> I løpet av publiseringen
Programmet er en fil laget.

35
00:01:43,930 --> 00:01:45,680
Og når programmet
har stoppet,

36
00:01:45,680 --> 00:01:48,689
at filen finnes fortsatt på systemet.

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

38
00:01:50,230 --> 00:01:53,670
Og slik at programmet ville være satt til
har laget noen vedvarende data,

39
00:01:53,670 --> 00:01:57,390
data finnes etter at programmet
har kjørt ferdig.

40
00:01:57,390 --> 00:02:02,320
>> Nå er alle disse funksjonene som fungerer
med å opprette filer og manipulere

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

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

43
00:02:08,210 --> 00:02:10,910
inkludert på toppen av ganske
sett alle programmene dine

44
00:02:10,910 --> 00:02:14,130
fordi den inneholder en av
de fleste nyttige funksjoner for oss,

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

46
00:02:16,130 --> 00:02:20,400
Så du trenger ikke å hamre inkludere
noen ekstra filer trolig

47
00:02:20,400 --> 00:02:23,540
for å jobbe med arkiv pekere.

48
00:02:23,540 --> 00:02:29,980
>> Nå hver enkelt fil pekeren funksjon,
eller hver enkelt fil I / O, input output

49
00:02:29,980 --> 00:02:33,310
funksjon, godtar som en
av sine parametere eller innganger

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

51
00:02:35,822 --> 00:02:38,280
er det du bruker for å hente fila
pekeren i første omgang.

52
00:02:38,280 --> 00:02:41,010
Men etter at du har åpnet
fil og du får fil pekere,

53
00:02:41,010 --> 00:02:43,510
du kan deretter sende dem som
argumenter til de ulike funksjonene

54
00:02:43,510 --> 00:02:46,720
vi kommer til å snakke om
dag, så vel som mange andre,

55
00:02:46,720 --> 00:02:48,520
slik at du kan arbeide med filer.

56
00:02:48,520 --> 00:02:50,980
>> Så det er seks pen
felles grunnleggende seg

57
00:02:50,980 --> 00:02:52,870
at vi skal snakke om i dag.

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

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

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

61
00:03:03,820 --> 00:03:05,180
Så la oss komme rett inn i den.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- hva gjør den?

63
00:03:07,050 --> 00:03:10,050
Vel, det åpner en fil, og det
gir deg en fil peker til den,

64
00:03:10,050 --> 00:03:14,000
slik at du kan deretter bruke den
filpeker som et argument

65
00:03:14,000 --> 00:03:16,730
til noen av de andre filen I / O funksjoner.

66
00:03:16,730 --> 00:03:19,100
Den viktigste tingen
å huske med fopen

67
00:03:19,100 --> 00:03:24,222
er at etter at du har åpnet
fil eller gjort en samtale som den her,

68
00:03:24,222 --> 00:03:26,930
du må sjekke for å være sikker
at pekeren at du kom tilbake

69
00:03:26,930 --> 00:03:28,320
ikke er lik til null.

70
00:03:28,320 --> 00:03:31,320
Hvis du ikke har sett videoen på
pekere, dette kan ikke være fornuftig.

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

72
00:03:35,639 --> 00:03:38,180
programmet vil trolig lide
en segmentering [uhørbart].

73
00:03:38,180 --> 00:03:40,540
Vi ønsker å sørge for at vi
fikk en legitim peker tilbake.

74
00:03:40,540 --> 00:03:43,665
Det store flertallet av tiden vi vil
har fått en legitim peker tilbake

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 gjør vi en oppfordring til fopen?

77
00:03:46,760 --> 00:03:48,051
Det ser ganske mye som dette.

78
00:03:48,051 --> 00:03:52,690
File stjerners ptr-- PTR være en generisk
navn på filen pointer-- fopen

79
00:03:52,690 --> 00:03:57,300
og vi passerer i to ting, et filnavn
og en operasjon vi ønsker å gjennomføre.

80
00:03:57,300 --> 00:04:01,690
Så vi kan ha en samtale som ser ut som
dette-- fil stjerners ptr en lik fopen

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

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

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

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

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

86
00:04:13,760 --> 00:04:17,500
Så r er driften som vi
velge når vi vil lese en fil.

87
00:04:17,500 --> 00:04:20,260
Så ville vi i utgangspunktet når
vi ringe som dette

88
00:04:20,260 --> 00:04:25,440
være å få oss en filpeker
slik at vi da kunne lese informasjon

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

90
00:04:27,770 --> 00:04:34,190
>> På samme måte kan vi åpne filen 2.txt
for skriving og slik at vi kan passere ptr2,

91
00:04:34,190 --> 00:04:38,210
filpekeren jeg har laget her,
som et argument til en funksjon som

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

93
00:04:40,080 --> 00:04:43,767
Og lignende til å skrive, det er
også muligheten til å legge til, en.

94
00:04:43,767 --> 00:04:45,600
Forskjellen mellom
skriving og tilføye

95
00:04:45,600 --> 00:04:50,920
er at når du skriver til en fil,
Hvis du vil ringe til fopen for skriving

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

97
00:04:54,761 --> 00:04:56,510
Det kommer til å starte
helt i begynnelsen,

98
00:04:56,510 --> 00:04:58,820
slette all informasjon
som allerede er der.

99
00:04:58,820 --> 00:05:02,210
>> Mens hvis du åpner den for å føye til,
det vil gå til slutten av filen

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

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

102
00:05:06,040 --> 00:05:08,570
Så du vil ikke miste noen av
informasjon du har gjort før.

103
00:05:08,570 --> 00:05:12,110
Enten du ønsker å skrive eller legge
slags avhenger av situasjonen.

104
00:05:12,110 --> 00:05:16,840
Men du vil sikkert vet hva
riktig drift 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
>> Hva om fclose?

107
00:05:18,930 --> 00:05:21,600
Vel, ganske enkelt, fclose
bare godtar filen pekeren.

108
00:05:21,600 --> 00:05:24,000
Og som du kanskje forventer,
det stenger denne filen.

109
00:05:24,000 --> 00:05:29,270
Og når vi har stengt en fil, kan vi ikke
utføre noe mer fil I / O-funksjoner,

110
00:05:29,270 --> 00:05:31,420
leser eller skriver, på denne filen.

111
00:05:31,420 --> 00:05:36,444
Vi må re-åpne
fil en annen gang i rekkefølge

112
00:05:36,444 --> 00:05:38,610
å fortsette å arbeide med
den ved hjelp av I / O funksjoner.

113
00:05:38,610 --> 00:05:41,520
Så fclose midler vi er ferdige
arbeider med denne filen.

114
00:05:41,520 --> 00:05:44,690
Og alt vi trenger å passere i er
navnet på en fil pekeren.

115
00:05:44,690 --> 00:05:50,010
Så på et par glir siden, vi
fopened fil en prikk tekst for lesing

116
00:05:50,010 --> 00:05:52,854
og vi tildelt som
filpeker til ptr1.

117
00:05:52,854 --> 00:05:55,020
Nå har vi bestemt oss vi er
ferdig med å lese fra filen.

118
00:05:55,020 --> 00:05:56,561
Vi trenger ikke å gjøre noe mer 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åte, kunne vi
fclose de andre.

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

122
00:06:02,450 --> 00:06:03,700
Så det er åpning og lukking.

123
00:06:03,700 --> 00:06:05,780
De er de to grunnleggende
starter operasjoner.

124
00:06:05,780 --> 00:06:08,050
>> Nå ønsker vi å faktisk
gjøre noen interessante ting,

125
00:06:08,050 --> 00:06:11,940
og den første funksjonen som vi vil
se som vil gjøre det på er fgetc--

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

127
00:06:14,110 --> 00:06:17,350
Det er det fgetc generelt
ville oversette til.

128
00:06:17,350 --> 00:06:20,190
Sitt mål i livet er å
lese neste tegn,

129
00:06:20,190 --> 00:06:22,079
eller om dette er din aller
første samtalen til fgetc

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

131
00:06:23,870 --> 00:06:26,210
Men så etter det,
du får den neste,

132
00:06:26,210 --> 00:06:31,500
allerede neste karakter av denne filen,
og lagrer den i en karakter variabel.

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

134
00:06:34,490 --> 00:06:36,389
pass i navnet til en fil pekeren.

135
00:06:36,389 --> 00:06:38,180
Igjen, det er veldig
viktig her å huske

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

137
00:06:41,430 --> 00:06:45,690
filpekeren selv må har
blitt åpnet for lesing.

138
00:06:45,690 --> 00:06:50,589
Vi kan ikke lese en karakter fra en fil
peker på at vi åpnet for skriving.

139
00:06:50,589 --> 00:06:52,630
Så det er en av de
begrensninger av fopen, ikke sant?

140
00:06:52,630 --> 00:06:55,470
Vi må begrense
oss til kun å utføre

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

142
00:06:57,710 --> 00:07:00,220
Hvis vi ønsket å lese og
skrive fra den samme filen,

143
00:07:00,220 --> 00:07:03,840
vi ville ha åpent to separate
fil pekere til samme file--

144
00:07:03,840 --> 00:07:05,670
en for lesing, en for skriving.

145
00:07:05,670 --> 00:07:08,400
>> Så igjen, den eneste grunnen
Jeg tar det opp nå er

146
00:07:08,400 --> 00:07:11,920
fordi hvis vi kommer til å ringe
til fgetc at filpeker må har

147
00:07:11,920 --> 00:07:14,172
blitt åpnet for lesing.

148
00:07:14,172 --> 00:07:15,880
Og så ganske enkelt,
alt vi trenger å gjøre

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

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

151
00:07:21,060 --> 00:07:23,200
>> Det kommer til å få oss
neste character--

152
00:07:23,200 --> 00:07:25,575
eller igjen, hvis dette er den første
gang vi har gjort denne samtalen,

153
00:07:25,575 --> 00:07:29,750
den første character-- av hva
filen er pekt på av ptr1.

154
00:07:29,750 --> 00:07:32,210
Husker at det var fil en prikk tekst.

155
00:07:32,210 --> 00:07:36,490
Det vil bli det første tegnet på at
og vi vil lagre den i variabelen lm.

156
00:07:36,490 --> 00:07:37,941
Ganske grei.

157
00:07:37,941 --> 00:07:40,190
Så vi har bare sett på tre
funksjoner og allerede vi

158
00:07:40,190 --> 00:07:43,070
kan gjøre noe ganske ryddig.

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

160
00:07:46,320 --> 00:07:48,943
og vi sløyfe it-- så vi
fortsette å få karakterer

161
00:07:48,943 --> 00:07:51,390
fra en fil over og
over og over-- nå vi

162
00:07:51,390 --> 00:07:54,500
kan lese hver eneste
karakter av en fil.

163
00:07:54,500 --> 00:07:58,670
Og hvis vi skriver ut hver karakter
umiddelbart etter at vi leser det,

164
00:07:58,670 --> 00:08:01,960
Vi har nå lest fra en fil og
trykt innholdet til skjermen.

165
00:08:01,960 --> 00:08:05,610
Vi har effektivt sammenkjedet
at filen på skjermen.

166
00:08:05,610 --> 00:08:09,670
Og det er hva
Linux-kommandoen katt gjør.

167
00:08:09,670 --> 00:08:13,250
>> Hvis du skriver katt i filnavnet, det
vil skrive ut hele innholdet

168
00:08:13,250 --> 00:08:15,160
av filen i terminalvinduet.

169
00:08:15,160 --> 00:08:19,010
Og så denne lille sløyfen her,
bare tre linjer med kode,

170
00:08:19,010 --> 00:08:23,270
men det effektivt dupliserer
Linux-kommando katt.

171
00:08:23,270 --> 00:08:25,210
Så dette syntaks kanskje
ser litt rart,

172
00:08:25,210 --> 00:08:26,670
men her er hva som skjer her.

173
00:08:26,670 --> 00:08:31,460
Mens ch lik fgetc, er ikke ptr
lik EOF-- det er en hel munnfull,

174
00:08:31,460 --> 00:08:34,669
men la oss bryte det ned bare
så det er tydelig på syntaksen.

175
00:08:34,669 --> 00:08:37,169
Jeg har konsolidert det
av hensyn til plass,

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

177
00:08:39,049 --> 00:08:41,194
>> Så denne delen i grønt til høyre
nå, hva er det du gjør?

178
00:08:41,194 --> 00:08:42,860
Vel, det er bare vår fgetc samtale, ikke sant?

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

180
00:08:44,530 --> 00:08:49,500
Det er å skaffe én
tegn fra filen.

181
00:08:49,500 --> 00:08:53,220
Da vi sammenligner det
karakter mot EOF.

182
00:08:53,220 --> 00:08:57,470
EOF er en spesiell verdi som er
definert i standarden io.h, som

183
00:08:57,470 --> 00:08:59,390
er enden av fil karakter.

184
00:08:59,390 --> 00:09:03,450
Så i utgangspunktet hva som kommer til å skje
er denne sløyfen vil lese en karakter,

185
00:09:03,450 --> 00:09:07,445
sammenligne det å EOF, den
slutten av filen karakter.

186
00:09:07,445 --> 00:09:10,070
Hvis de ikke samsvarer, slik at vi ikke har
kommet til slutten av filen,

187
00:09:10,070 --> 00:09:11,490
vi trykker det tegnet ut.

188
00:09:11,490 --> 00:09:13,740
Deretter vil vi gå tilbake til
begynnelsen av sløyfen på nytt.

189
00:09:13,740 --> 00:09:18,310
Vi vil få en karakter, sjekk
mot EOF, skrive det ut, og så videre

190
00:09:18,310 --> 00:09:21,094
og så videre og så videre,
viderekobling på den måten

191
00:09:21,094 --> 00:09:22,760
før vi har nådd slutten av filen.

192
00:09:22,760 --> 00:09:24,593
Og så etter det punktet,
vil vi ha trykt

193
00:09:24,593 --> 00:09:26,210
ut hele innholdet av filen.

194
00:09:26,210 --> 00:09:29,450
Så igjen, vi har bare sett
fopen, fclose, og fgetc

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

196
00:09:34,950 --> 00:09:38,850
>> Som jeg sa i begynnelsen,
vi hadde fgetc og fputc,

197
00:09:38,850 --> 00:09:41,860
og fputc var ledsager
funksjon av fgetc.

198
00:09:41,860 --> 00:09:44,880
Og så, som du kan forestille deg,
det er skrivetilsvarende.

199
00:09:44,880 --> 00:09:49,440
Det tillater oss å skrive en
enkelt tegn i en fil.

200
00:09:49,440 --> 00:09:53,290
>> Igjen, det forbeholdet er, bare
som det var med fgetc, filen

201
00:09:53,290 --> 00:09:56,660
at vi skriver til må har vært
åpnet for skriving eller for å legge til.

202
00:09:56,660 --> 00:10:00,820
Hvis vi prøver og bruke fputc på en fil
at vi har åpnet for lesing,

203
00:10:00,820 --> 00:10:02,760
vi kommer til å lide
litt av en feil.

204
00:10:02,760 --> 00:10:04,440
Men samtalen er ganske enkel.

205
00:10:04,440 --> 00:10:08,000
fputc kapital A ptr2, alle
som kommer til å gjøre, er det

206
00:10:08,000 --> 00:10:12,040
kommer til å skrive brevet
inn i A til fil 2 dot

207
00:10:12,040 --> 00:10:14,760
tekst, som var navn
fil som vi åpnet og tildelt

208
00:10:14,760 --> 00:10:17,280
pekeren til ptr2.

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

210
00:10:20,430 --> 00:10:24,592
Og vi skal skrive et utrops
peke til fil 3 dot

211
00:10:24,592 --> 00:10:27,330
tekst, som ble pekt på av ptr3.

212
00:10:27,330 --> 00:10:29,730
Så igjen, ganske grei her.

213
00:10:29,730 --> 00:10:32,727
>> Men nå kan vi gjøre en annen ting.

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

215
00:10:34,560 --> 00:10:38,950
om å være i stand til å gjenskape katten
Linux-kommandoen, den som skriver ut

216
00:10:38,950 --> 00:10:40,500
til skjermen.

217
00:10:40,500 --> 00:10:43,510
Vel, nå som vi har muligheten
å lese tegn fra filer

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

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

220
00:10:50,720 --> 00:10:54,090
>> Og nå har vi duplisert cp,
en svært grunnleggende Linux-kommandoen

221
00:10:54,090 --> 00:10:59,100
som vi snakket om veien lang
siden i linux kommandoer video.

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

223
00:11:01,070 --> 00:11:04,790
Vi leser en karakter og da er vi
skriver det tegnet til en annen fil.

224
00:11:04,790 --> 00:11:07,660
Lesing fra én fil, skriving
til en annen, om og om igjen

225
00:11:07,660 --> 00:11:11,350
og om igjen til vi treffer EOF.

226
00:11:11,350 --> 00:11:14,250
Vi har fått til slutten av
fil vi prøver å kopiere fra.

227
00:11:14,250 --> 00:11:18,500
Og etter at vi har skrevet alle
av karakterene vi trenger 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
>> Helt i begynnelsen av
denne videoen, hadde jeg det forbeholdet

231
00:11:26,550 --> 00:11:29,840
at vi ville snakke
Litt om pekere.

232
00:11:29,840 --> 00:11:32,480
Her er spesifikt hvor vi er
skal snakke om pekere

233
00:11:32,480 --> 00:11:34,800
i tillegg til å sende inn tips.

234
00:11:34,800 --> 00:11:37,870
Så denne funksjonen ser litt skummelt.

235
00:11:37,870 --> 00:11:39,120
Det har flere parametere.

236
00:11:39,120 --> 00:11:40,430
Det er mye som skjer her.

237
00:11:40,430 --> 00:11:42,760
Det er mye forskjellig
farger og tekster.

238
00:11:42,760 --> 00:11:47,100
Men egentlig, det er bare det
generisk versjon av fgetc

239
00:11:47,100 --> 00:11:50,110
som tillater oss å få noen
mengde informasjon.

240
00:11:50,110 --> 00:11:53,560
Det kan være litt ineffektiv hvis vi er
få tegn ett om gangen,

241
00:11:53,560 --> 00:11:55,770
itera gjennom filen
ett tegn om gangen.

242
00:11:55,770 --> 00:12:00,230
Ville det ikke være bedre å få
100 på en gang, eller 500 om gangen?

243
00:12:00,230 --> 00:12:03,250
>> Vel, fread og dens følges funksjon
fwrite, som vi vil snakke om

244
00:12:03,250 --> 00:12:05,490
i et sekund, tillate oss å gjøre nettopp det.

245
00:12:05,490 --> 00:12:08,480
Vi kan lese en vilkårlig mengde
av informasjon fra en fil

246
00:12:08,480 --> 00:12:10,290
og vi lagrer den et sted midlertidig.

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

248
00:12:12,980 --> 00:12:15,790
vi trenger å lagre den i en matrise.

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

250
00:12:19,980 --> 00:12:23,940
til stedet der vi er
kommer til å lagre informasjon,

251
00:12:23,940 --> 00:12:29,180
hvor stor hver informasjonsenhet
vil være, hvor mange enheter av informasjon

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

253
00:12:35,192 --> 00:12:37,150
Trolig best illustrert
med et eksempel her.

254
00:12:37,150 --> 00:12:41,640
Så la oss si at vi erklærer
en rekke 10 heltall.

255
00:12:41,640 --> 00:12:45,080
Vi har nettopp erklært på
stable vilkårlig int arr 10.

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

257
00:12:46,970 --> 00:12:51,970
Nå hva vi gjør skjønt er
frecall er vi leser størrelsen på int

258
00:12:51,970 --> 00:12:54,180
times 10 byte med informasjon.

259
00:12:54,180 --> 00:12:59,040
Størrelsen på int vesen four-- det er
størrelsen av et heltall i c.

260
00:12:59,040 --> 00:13:02,790
>> Så det vi gjør er at vi leser
40 bytes verdt av informasjon

261
00:13:02,790 --> 00:13:05,850
fra filen peker til ptr.

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

263
00:13:08,600 --> 00:13:12,080
hvor vi har satt til side
40 bytes verdt minne.

264
00:13:12,080 --> 00:13:15,970
Heldigvis har vi allerede gjort det etter
erklære arr, som matrise der.

265
00:13:15,970 --> 00:13:19,770
Som er i stand holde
10 fire-byte enheter.

266
00:13:19,770 --> 00:13:22,860
Så totalt, kan det holde 40
bytes verdt av informasjon.

267
00:13:22,860 --> 00:13:26,540
Og vi nå leser 40 bytes
av informasjon fra filen,

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

269
00:13:30,330 --> 00:13:35,470
>> Husker fra videoen på pekere som
navnet på en matrise, som for eksempel arr,

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

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

272
00:13:43,680 --> 00:13:46,120
>> Tilsvarende kan vi gjøre dette--
vi gjør ikke nødvendigvis

273
00:13:46,120 --> 00:13:51,200
trenger å redde vår buffer på stakken.

274
00:13:51,200 --> 00:13:54,990
Vi kunne også dynamisk tildele
en buffer som dette, bruker malloc.

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

276
00:13:57,340 --> 00:14:00,550
vi sparer den på
haug, ikke bunken.

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

278
00:14:02,110 --> 00:14:06,810
>> Det fortsatt, i dette tilfellet, er
holder 640 byte med informasjon

279
00:14:06,810 --> 00:14:09,230
fordi en dobbel tar opp åtte byte.

280
00:14:09,230 --> 00:14:11,570
Og vi ber for 80 av dem.

281
00:14:11,570 --> 00:14:13,770
Vi ønsker å ha plass
å holde 80 dobles.

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

283
00:14:17,210 --> 00:14:21,880
Og at samtalen til fread er
samle 640 byte med informasjon

284
00:14:21,880 --> 00:14:27,770
fra filen peker til
PTR og lagre det nå i arr2.

285
00:14:27,770 --> 00:14:32,770
>> Nå kan vi også behandle fread
akkurat som en oppfordring til fgetc.

286
00:14:32,770 --> 00:14:37,140
I dette tilfellet, vi bare prøver å
får ett tegn fra filen.

287
00:14:37,140 --> 00:14:40,070
Og vi trenger ikke en
matrise for å holde et tegn.

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

289
00:14:43,170 --> 00:14:46,390
>> Fangsten, skjønt, er at
når vi bare har en variabel,

290
00:14:46,390 --> 00:14:50,290
vi trenger å passere i
Adressen til den variable

291
00:14:50,290 --> 00:14:52,550
fordi tilbakekalling at
første argumentet til fread

292
00:14:52,550 --> 00:14:59,210
er en peker til plasseringen og minne
hvor vi ønsker å lagre informasjonen.

293
00:14:59,210 --> 00:15:01,550
Igjen, navnet på en
matrise er en peker.

294
00:15:01,550 --> 00:15:04,200
Så vi trenger ikke å gjøre tegnet array.

295
00:15:04,200 --> 00:15:07,270
Men c, tegnet c
her, er ikke en matrise.

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å må vi passere en
tegnet c for å indikere

298
00:15:11,840 --> 00:15:15,350
at det er den adressen der vi ønsker
lagre dette en byte av informasjon,

299
00:15:15,350 --> 00:15:20,479
dette ett tegn på at
vi samler fra ptr.

300
00:15:20,479 --> 00:15:22,270
Fwrite-- Jeg vil gå gjennom
dette litt mer

301
00:15:22,270 --> 00:15:25,440
quickly-- er ganske mye
eksakt tilsvarer fread

302
00:15:25,440 --> 00:15:27,720
bortsett fra det er for skriving
i stedet for å lese, bare

303
00:15:27,720 --> 00:15:31,610
som other-- vi har hatt åpent
og tett, få en karakter,

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

305
00:15:32,530 --> 00:15:35,040
Nå er det få vilkårlig
Mengden av informasjon,

306
00:15:35,040 --> 00:15:37,170
rett vilkårlig mengde informasjon.

307
00:15:37,170 --> 00:15:39,790
Så akkurat som før, kan vi
har en rekke 10 heltall

308
00:15:39,790 --> 00:15:43,210
hvor vi allerede har
informasjon som er lagret, kanskje.

309
00:15:43,210 --> 00:15:46,580
>> Det var trolig noen linjer med kode
som skal gå mellom disse to

310
00:15:46,580 --> 00:15:49,990
hvor jeg fyller arr med
noe meningsfylt.

311
00:15:49,990 --> 00:15:51,880
Jeg fyller den med 10 forskjellige heltall.

312
00:15:51,880 --> 00:15:54,920
Og i stedet, hva jeg er
gjør er å skrive fra arr

313
00:15:54,920 --> 00:15:58,600
og samle informasjon fra arr.

314
00:15:58,600 --> 00:16:02,390
Og jeg tar denne informasjonen
og la ballen inn i filen.

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

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

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

318
00:16:10,580 --> 00:16:16,680
Så igjen, akkurat som før, kan vi
har også en haug mengde minne

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

320
00:16:19,600 --> 00:16:21,570
og skriver at til filen.

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

322
00:16:24,900 --> 00:16:27,200
av informasjon, slik som et tegn.

323
00:16:27,200 --> 00:16:29,830
Men igjen, vi trenger å passere i
adressen til den variable

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

325
00:16:31,840 --> 00:16:35,280
Så vi kan skrive ned informasjonen
finner vi på denne adressen

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

327
00:16:39,050 --> 00:16:41,630
>> Det finnes massevis av andre
stor fil I / O-funksjoner

328
00:16:41,630 --> 00:16:44,650
som gjør ulike ting i tillegg
de vi har snakket om i dag.

329
00:16:44,650 --> 00:16:46,450
Et par av de
du kan finne nyttig

330
00:16:46,450 --> 00:16:50,840
er fgets og fputs,
som er tilsvar

331
00:16:50,840 --> 00:16:56,190
av fgetc og fputc men for lesing
en enkelt streng fra en fil.

332
00:16:56,190 --> 00:16:59,020
I stedet for en enkelt karakter,
det vil lese en hel streng.

333
00:16:59,020 --> 00:17:02,940
fprintf, som i utgangspunktet gjør
deg å bruke printf å skrive til fil.

334
00:17:02,940 --> 00:17:05,619
Så akkurat som du kan gjøre
variabel substitusjon hjelp

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

336
00:17:09,900 --> 00:17:14,690
du kan tilsvarende ta
printf streng og print noe

337
00:17:14,690 --> 00:17:16,800
sånn til en fil.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- hvis du har en DVD-spiller
er analogien jeg vanligvis bruker her--

339
00:17:20,720 --> 00:17:23,109
er liksom som bruker
spole tilbake og spole fremover

340
00:17:23,109 --> 00:17:25,819
knappene for å flytte rundt filmen.

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

342
00:17:28,369 --> 00:17:30,250
En av de tingene inne
at filstrukturen

343
00:17:30,250 --> 00:17:34,270
at c skaper for deg er en indikator
av hvor du er i filen.

344
00:17:34,270 --> 00:17:36,420
Er du helt på
begynner, i byte null?

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

346
00:17:39,290 --> 00:17:44,340
Du kan bruke fseek å vilkårlig flytte
som indikator fremover eller bakover.

347
00:17:44,340 --> 00:17:46,744
>> Og ftell, igjen
ligner på en DVD-spiller,

348
00:17:46,744 --> 00:17:49,660
er som en liten klokke som forteller
deg hvor mange minutter og sekunder

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

350
00:17:52,480 --> 00:17:56,990
Tilsvarende forteller ftell deg hvordan
mange bytes du er i filen.

351
00:17:56,990 --> 00:18:00,210
feof er en annen versjon
til å oppdage om du har

352
00:18:00,210 --> 00:18:01,700
kommet til slutten av filen.

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

354
00:18:03,600 --> 00:18:06,959
å oppdage om noe har
gått galt arbeidsmiljø med en fil.

355
00:18:06,959 --> 00:18:08,750
Igjen, dette er bare
skrape overflaten.

356
00:18:08,750 --> 00:18:12,730
Det er fremdeles mye mer fil I / O
funksjoner i standard io.h.

357
00:18:12,730 --> 00:18:16,620
Men dette vil trolig få deg
begynte å jobbe med arkiv pekere.

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

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

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