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

2
00:00:05,330 --> 00:00:07,870
>> Speak: Hittills är det troligt
att de flesta av dina program

3
00:00:07,870 --> 00:00:10,170
har varit lite kortlivad.

4
00:00:10,170 --> 00:00:13,310
Du kör ett program som Mario eller giriga.

5
00:00:13,310 --> 00:00:17,350
Det gör något, det kanske uppmanas
användaren om viss information,

6
00:00:17,350 --> 00:00:20,400
skriva ut vissa utdata till skärmen,
men sedan när programmet är över,

7
00:00:20,400 --> 00:00:23,252
det finns egentligen inga bevis finns
det någonsin kör i första hand.

8
00:00:23,252 --> 00:00:25,960
Jag menar, visst, du kanske har lämnat
Det öppnas i terminalfönstret,

9
00:00:25,960 --> 00:00:29,770
men om du rensar din skärm, det finns
egentligen inga bevis för att det fanns.

10
00:00:29,770 --> 00:00:33,720
Vi har inte ett sätt att lagra
ihållande, information

11
00:00:33,720 --> 00:00:36,890
som existerar efter vår
Programmet har stannat,

12
00:00:36,890 --> 00:00:39,241
eller så har vi inte upp till denna punkt.

13
00:00:39,241 --> 00:00:41,490
Lyckligtvis gör c
ge oss möjlighet

14
00:00:41,490 --> 00:00:44,220
att göra detta genom att implementera
något som kallas

15
00:00:44,220 --> 00:00:48,330
en fil, en struktur som i grund och botten
representerar en fil som du skulle fördubbla

16
00:00:48,330 --> 00:00:53,826
klicka på din dator, om du är
van vid ett grafiskt användarmiljö.

17
00:00:53,826 --> 00:00:55,700
Generellt vid arbete
med c, vi är faktiskt

18
00:00:55,700 --> 00:00:59,965
kommer att arbeta med
pekare till files-- fil stars--

19
00:00:59,965 --> 00:01:02,090
med undantag för lite
när vi talar om ett par

20
00:01:02,090 --> 00:01:04,560
av de funktioner som
arbeta med fil pekare.

21
00:01:04,560 --> 00:01:08,990
Du behöver inte ha riktigt grävt
för djupt för att öka kunskapen pekare

22
00:01:08,990 --> 00:01:09,730
själva.

23
00:01:09,730 --> 00:01:12,870
Det finns en liten pyttelitet bit
där vi kommer att prata om dem,

24
00:01:12,870 --> 00:01:18,090
men i allmänhet fil pekare och
pekare, medan varandra,

25
00:01:18,090 --> 00:01:20,290
är inte exakt samma sak.

26
00:01:20,290 --> 00:01:22,440
>> Nu vad jag menar när
Jag säger ihållande data?

27
00:01:22,440 --> 00:01:23,650
Vad är beständiga data?

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

29
00:01:25,232 --> 00:01:27,190
Säg till exempel att
du kör ett program

30
00:01:27,190 --> 00:01:29,850
eller om du har skrivit om en
program som är ett spel,

31
00:01:29,850 --> 00:01:32,960
och du vill hålla koll
av alla användarens rörelser

32
00:01:32,960 --> 00:01:36,620
så att kanske om något går fel,
du kan granska filen efter matchen.

33
00:01:36,620 --> 00:01:39,970
Det är vad vi menar när vi
prata om beständiga data.

34
00:01:39,970 --> 00:01:43,930
>> Under köra din
program, skapas en fil.

35
00:01:43,930 --> 00:01:45,680
Och när ditt program
har stannat,

36
00:01:45,680 --> 00:01:48,689
att filen finns fortfarande på ditt system.

37
00:01:48,689 --> 00:01:50,230
Och vi kan titta på det och undersöka det.

38
00:01:50,230 --> 00:01:53,670
Och så det programmet skulle ställas in på
har skapat några beständiga data,

39
00:01:53,670 --> 00:01:57,390
Det finns uppgifter efter programmet
har körts.

40
00:01:57,390 --> 00:02:02,320
>> Nu har alla dessa funktioner som fungerar
med att skapa filer och manipulera

41
00:02:02,320 --> 00:02:04,940
dem på olika sätt
bor i standard io.h,

42
00:02:04,940 --> 00:02:08,210
vilket är en header-fil som
du har förmodligen varit pund

43
00:02:08,210 --> 00:02:10,910
inbegripet på toppen av vackra
mycket alla dina program

44
00:02:10,910 --> 00:02:14,130
eftersom den innehåller en av de
mest användbara funktioner för oss,

45
00:02:14,130 --> 00:02:16,130
printf, som också låter
bor i standard io.h.

46
00:02:16,130 --> 00:02:20,400
Så du behöver inte pund inkluderar
eventuella ytterligare filer förmodligen

47
00:02:20,400 --> 00:02:23,540
för att arbeta med fil pekare.

48
00:02:23,540 --> 00:02:29,980
>> Nu varenda filpekaren funktion,
eller varje enskild fil I / O, Input Output

49
00:02:29,980 --> 00:02:33,310
funktionen accepterar som en
av dess parametrar eller insatsvaror

50
00:02:33,310 --> 00:02:35,822
en fil pointer-- utom
för en, fopen, vilket

51
00:02:35,822 --> 00:02:38,280
är vad du använder för att hämta filen
pekaren i första hand.

52
00:02:38,280 --> 00:02:41,010
Men efter att du har öppnat
fil och du får filen pekare,

53
00:02:41,010 --> 00:02:43,510
Du kan sedan skicka dem som
argument till de olika funktionerna

54
00:02:43,510 --> 00:02:46,720
vi kommer att prata om
idag, liksom många andra

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

56
00:02:48,520 --> 00:02:50,980
>> Så det finns sex ganska
gemensamma grundläggande ettor

57
00:02:50,980 --> 00:02:52,870
att vi kommer att prata om idag.

58
00:02:52,870 --> 00:02:57,160
fopen och dess följeslagare
funktion fclose, fgetc

59
00:02:57,160 --> 00:03:02,670
och dess följeslagare funktion fputc,
och fread och dess följeslagare funktion,

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

61
00:03:03,820 --> 00:03:05,180
Så låt oss få rätt till det.

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

63
00:03:07,050 --> 00:03:10,050
Tja, öppnar det en fil och det
ger dig en fil pekare till det,

64
00:03:10,050 --> 00:03:14,000
så att du sedan kan använda det
fil pekare som ett argument

65
00:03:14,000 --> 00:03:16,730
till någon av de andra fil-I / O-funktioner.

66
00:03:16,730 --> 00:03:19,100
Det viktigaste
att minnas med fopen

67
00:03:19,100 --> 00:03:24,222
är att när du har öppnat
fil eller gjorde ett samtal som den här,

68
00:03:24,222 --> 00:03:26,930
du behöver för att kontrollera att
att pekaren att du kommer tillbaka

69
00:03:26,930 --> 00:03:28,320
är inte lika med noll.

70
00:03:28,320 --> 00:03:31,320
Om du inte har sett videon på
pekare, vilket kanske inte vettigt.

71
00:03:31,320 --> 00:03:35,639
Men om du försöker och dereference
en null-pekare återkallelse,

72
00:03:35,639 --> 00:03:38,180
ditt program kommer sannolikt att bli lidande
en segmente [OHÖRBAR].

73
00:03:38,180 --> 00:03:40,540
Vi vill se till att vi
fick en legitim pekare tillbaka.

74
00:03:40,540 --> 00:03:43,665
Den stora majoriteten av den tid som vi kommer
har fått en legitim pekare tillbaka

75
00:03:43,665 --> 00:03:45,280
och det kommer inte att vara ett problem.

76
00:03:45,280 --> 00:03:46,760
>> Så hur gör vi ett anrop till fopen?

77
00:03:46,760 --> 00:03:48,051
Det ser ut ungefär som den här.

78
00:03:48,051 --> 00:03:52,690
Fil stjärna ptr-- PTR vara en generisk
namn för fil pointer-- fopen

79
00:03:52,690 --> 00:03:57,300
och vi passera i två saker, ett filnamn
och en operation som vi vill utföra.

80
00:03:57,300 --> 00:04:01,690
Så vi kan ha ett samtal som ser ut
this-- fil stjärn ptr en lika fopen

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

82
00:04:04,040 --> 00:04:07,020
Och operationen jag har valt r.

83
00:04:07,020 --> 00:04:08,639
>> Så vad tror du r är här?

84
00:04:08,639 --> 00:04:11,180
Vad är den typ av saker som vi
skulle kunna göra för att filer?

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

86
00:04:13,760 --> 00:04:17,500
Så r är den verksamhet som vi
välja när vi vill läsa en fil.

87
00:04:17,500 --> 00:04:20,260
Så skulle vi i princip när
Vi gör ett samtal så här

88
00:04:20,260 --> 00:04:25,440
att få oss en filpekare
så att vi sedan kan läsa information

89
00:04:25,440 --> 00:04:27,770
från fil1.txt.

90
00:04:27,770 --> 00:04:34,190
>> På samma sätt kan vi öppna filen 2.txt
för att skriva och så att vi kan passera ptr2,

91
00:04:34,190 --> 00:04:38,210
filpekaren jag har skapat här,
som ett argument till en funktion som

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

93
00:04:40,080 --> 00:04:43,767
Och liknande till skrivande, det finns
också möjlighet att lägga till en.

94
00:04:43,767 --> 00:04:45,600
Skillnaden mellan
skriva och lägga

95
00:04:45,600 --> 00:04:50,920
är att när du skriver till en fil,
om du gör ett samtal till fopen för att skriva

96
00:04:50,920 --> 00:04:54,761
och att filen redan existerar, det är
kommer att skriva över hela filen.

97
00:04:54,761 --> 00:04:56,510
Det kommer att börja
i början,

98
00:04:56,510 --> 00:04:58,820
radera all information
det är redan där.

99
00:04:58,820 --> 00:05:02,210
>> Medan om du öppnar det för att lägga,
det kommer att gå till slutet av filen

100
00:05:02,210 --> 00:05:04,340
Om det redan finns text i
det eller informationen i den,

101
00:05:04,340 --> 00:05:06,040
och det kommer då att börja
skriver därifrån.

102
00:05:06,040 --> 00:05:08,570
Så du kommer inte att förlora någon av de
information som du har gjort förut.

103
00:05:08,570 --> 00:05:12,110
Oavsett om du vill skriva eller lägga
sorts beror på situationen.

104
00:05:12,110 --> 00:05:16,840
Men du kommer förmodligen vet vad
rätt verksamhet är när det är dags.

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

106
00:05:18,020 --> 00:05:18,930
>> Vad sägs om fclose?

107
00:05:18,930 --> 00:05:21,600
Tja, ganska enkelt, fclose
bara accepterar filpekaren.

108
00:05:21,600 --> 00:05:24,000
Och som man kan förvänta sig,
det stänger den filen.

109
00:05:24,000 --> 00:05:29,270
Och när vi har stängt en fil, vi kan inte
utföra mer fil-I / O-funktioner,

110
00:05:29,270 --> 00:05:31,420
läser eller skriver på den filen.

111
00:05:31,420 --> 00:05:36,444
Vi måste åter öppna
fil en annan tid för

112
00:05:36,444 --> 00:05:38,610
att fortsätta arbeta med
den med hjälp av I / O-funktioner.

113
00:05:38,610 --> 00:05:41,520
Så fclose sätt vi gjort
arbeta med denna fil.

114
00:05:41,520 --> 00:05:44,690
Och allt vi behöver skicka in är
namnet på en fil pekare.

115
00:05:44,690 --> 00:05:50,010
Så på ett par glider sedan, vi
fopened fil 1 dot text för läsning

116
00:05:50,010 --> 00:05:52,854
och vi tilldelade att
fil pekare till ptr1.

117
00:05:52,854 --> 00:05:55,020
Nu har vi beslutat att vi är
gjort läsning från den filen.

118
00:05:55,020 --> 00:05:56,561
Vi behöver inte göra något mer med det.

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

120
00:05:58,890 --> 00:06:01,950
Och på samma sätt, kunde vi
fclose de andra.

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

122
00:06:02,450 --> 00:06:03,700
Så det är att öppna och stänga.

123
00:06:03,700 --> 00:06:05,780
De är de två grundläggande
startoperationer.

124
00:06:05,780 --> 00:06:08,050
>> Nu vill vi faktiskt
göra några intressanta saker,

125
00:06:08,050 --> 00:06:11,940
och första funktion som vi ska
se som kommer att göra det är fgetc--

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

127
00:06:14,110 --> 00:06:17,350
Det är vad fgetc allmänhet
skulle översätta till.

128
00:06:17,350 --> 00:06:20,190
Dess mål i livet är att
Läs nästa tecken,

129
00:06:20,190 --> 00:06:22,079
eller om detta är din mycket
första samtalet till fgetc

130
00:06:22,079 --> 00:06:23,870
för en viss fil,
det första tecknet.

131
00:06:23,870 --> 00:06:26,210
Men sedan efter det,
du får nästa,

132
00:06:26,210 --> 00:06:31,500
redan nästa karaktär filen,
och lagrar det i ett tecken variabel.

133
00:06:31,500 --> 00:06:34,490
Som vi har gjort här,
char ch lika fgetc,

134
00:06:34,490 --> 00:06:36,389
passera i namnet på en fil pekare.

135
00:06:36,389 --> 00:06:38,180
Återigen, det är mycket
viktigt här att komma ihåg

136
00:06:38,180 --> 00:06:41,430
att för att ha
denna operation lyckas,

137
00:06:41,430 --> 00:06:45,690
filpekaren själv måste har
öppnats för läsning.

138
00:06:45,690 --> 00:06:50,589
Vi kan inte läsa en karaktär från en fil
pekare som vi öppnade för skrivning.

139
00:06:50,589 --> 00:06:52,630
Så det är en av de
begränsningar av fopen, eller hur?

140
00:06:52,630 --> 00:06:55,470
Vi måste begränsa
oss endast utför

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

142
00:06:57,710 --> 00:07:00,220
Om vi ​​ville läsa och
skriva från samma fil,

143
00:07:00,220 --> 00:07:03,840
vi skulle ha öppet två separata
fil pekare till samma file--

144
00:07:03,840 --> 00:07:05,670
ett för läsning, en för att skriva.

145
00:07:05,670 --> 00:07:08,400
>> Så återigen, det enda skälet
Jag tar upp det nu är

146
00:07:08,400 --> 00:07:11,920
för om vi ska ringa
till fgetc, den filen pekare måste har

147
00:07:11,920 --> 00:07:14,172
öppnats för läsning.

148
00:07:14,172 --> 00:07:15,880
Och sedan ganska enkelt,
allt vi behöver göra

149
00:07:15,880 --> 00:07:17,546
är passera i namnet på filen pekaren.

150
00:07:17,546 --> 00:07:21,060
Så röding lm lika fgetc ptr1.

151
00:07:21,060 --> 00:07:23,200
>> Det kommer att få oss
nästa character--

152
00:07:23,200 --> 00:07:25,575
eller återigen, om detta är den första
När vi har gjort det här samtalet,

153
00:07:25,575 --> 00:07:29,750
den första character-- oavsett
fil pekas på av ptr1.

154
00:07:29,750 --> 00:07:32,210
Minns att det var fil 1 dot text.

155
00:07:32,210 --> 00:07:36,490
Det får det första tecknet i det
och vi kommer att lagra det i variabeln ch.

156
00:07:36,490 --> 00:07:37,941
Ganska enkelt.

157
00:07:37,941 --> 00:07:40,190
Så vi har bara tittat på tre
funktioner och redan vi

158
00:07:40,190 --> 00:07:43,070
kan göra något ganska snyggt.

159
00:07:43,070 --> 00:07:46,320
>> Så om vi tar denna förmåga
för att få ett tecken

160
00:07:46,320 --> 00:07:48,943
och vi slinga det-- så vi
fortsätter att få tecken

161
00:07:48,943 --> 00:07:51,390
från en fil över och
över och over-- nu vi

162
00:07:51,390 --> 00:07:54,500
kan läsa varenda
karaktären av en fil.

163
00:07:54,500 --> 00:07:58,670
Och om vi trycker varje tecken
omedelbart efter att vi läst det,

164
00:07:58,670 --> 00:08:01,960
Vi har nu läsa från en fil och
tryckta innehållet till skärmen.

165
00:08:01,960 --> 00:08:05,610
Vi har faktiskt sammanlänkade
den filen på bildskärmen.

166
00:08:05,610 --> 00:08:09,670
Och det är vad
Linux kommandot cat gör.

167
00:08:09,670 --> 00:08:13,250
>> Om du skriver katt i filnamnet, det
kommer att skriva ut hela innehållet

168
00:08:13,250 --> 00:08:15,160
av filen i din terminalfönster.

169
00:08:15,160 --> 00:08:19,010
Och så denna lilla slinga här,
bara tre rader kod,

170
00:08:19,010 --> 00:08:23,270
men det effektivt duplicerar
Linux kommandot cat.

171
00:08:23,270 --> 00:08:25,210
Så här syntaxen kanske
ser lite konstigt,

172
00:08:25,210 --> 00:08:26,670
men här är vad som händer här.

173
00:08:26,670 --> 00:08:31,460
Medan ch lika fgetc, inte ptr
lika med EOF-- det är en hel munsbit,

174
00:08:31,460 --> 00:08:34,669
men låt oss bryta ner det bara
så det är klart på syntax.

175
00:08:34,669 --> 00:08:37,169
Jag har konsoliderat det
för tydlighets utrymme,

176
00:08:37,169 --> 00:08:39,049
även om det är lite
syntaktiskt knepigt.

177
00:08:39,049 --> 00:08:41,194
>> Så här delen i grönt till höger
nu, vad gör det?

178
00:08:41,194 --> 00:08:42,860
Tja, det är bara vår fgetc samtal, eller hur?

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

180
00:08:44,530 --> 00:08:49,500
Det är få en
tecken från filen.

181
00:08:49,500 --> 00:08:53,220
Sedan jämföra vi att
karaktär mot EOF.

182
00:08:53,220 --> 00:08:57,470
EOF är ett speciellt värde som är
definieras i standarden io.h, vilket

183
00:08:57,470 --> 00:08:59,390
är slutet på filen karaktär.

184
00:08:59,390 --> 00:09:03,450
Så i princip vad som kommer att hända
är denna slinga kommer att läsa ett tecken,

185
00:09:03,450 --> 00:09:07,445
jämföra det med EOF, den
filslut karaktär.

186
00:09:07,445 --> 00:09:10,070
Om de inte stämmer överens, så vi har inte
nått slutet av filen,

187
00:09:10,070 --> 00:09:11,490
Vi kommer att skriva tecknet ut.

188
00:09:11,490 --> 00:09:13,740
Sedan ska vi gå tillbaka till
slingans början igen.

189
00:09:13,740 --> 00:09:18,310
Vi får en karaktär, kontrollera
mot EOF, skriva ut, och så vidare

190
00:09:18,310 --> 00:09:21,094
och så vidare och så vidare,
looping igenom på det sättet

191
00:09:21,094 --> 00:09:22,760
tills vi har nått slutet av filen.

192
00:09:22,760 --> 00:09:24,593
Och sedan vid den tidpunkten,
Vi kommer att ha tryckt

193
00:09:24,593 --> 00:09:26,210
ut hela innehållet i filen.

194
00:09:26,210 --> 00:09:29,450
Så återigen, har vi bara sett
fopen, fclose och fgetc

195
00:09:29,450 --> 00:09:34,950
och redan kan vi duplicera
en linux terminal kommando.

196
00:09:34,950 --> 00:09:38,850
>> Som jag sade i början,
Vi hade fgetc och fputc,

197
00:09:38,850 --> 00:09:41,860
och fputc var följeslagare
funktion av fgetc.

198
00:09:41,860 --> 00:09:44,880
Och så, som ni kanske förstår,
det är skriv motsvarande.

199
00:09:44,880 --> 00:09:49,440
Det ger oss möjlighet att skriva en
enstaka tecken till en fil.

200
00:09:49,440 --> 00:09:53,290
>> Återigen, det förbehållet att, precis
som det var med fgetc, filen

201
00:09:53,290 --> 00:09:56,660
att vi skriver till måste har varit
öppnat för att skriva eller lägga till.

202
00:09:56,660 --> 00:10:00,820
Om vi ​​försöker använda fputc på en fil
att vi har öppnat för läsning,

203
00:10:00,820 --> 00:10:02,760
vi kommer att lida
en bit av ett misstag.

204
00:10:02,760 --> 00:10:04,440
Men samtalet är ganska enkel.

205
00:10:04,440 --> 00:10:08,000
fputc huvudstad En ptr2, alla
det kommer att göra är att det är

206
00:10:08,000 --> 00:10:12,040
kommer att skriva brev
i A i fil 2 dot

207
00:10:12,040 --> 00:10:14,760
text, som var namnet på den
filen som vi öppnade och tilldelas

208
00:10:14,760 --> 00:10:17,280
pekaren till ptr2.

209
00:10:17,280 --> 00:10:20,430
Så vi kommer att skriva ett
kapital A till fil 2 dot text.

210
00:10:20,430 --> 00:10:24,592
Och vi kommer att skriva ett utropstecken
peka på fil 3 dot

211
00:10:24,592 --> 00:10:27,330
text, som utpekas av ptr3.

212
00:10:27,330 --> 00:10:29,730
Så återigen, ganska enkelt här.

213
00:10:29,730 --> 00:10:32,727
>> Men nu kan vi göra en annan sak.

214
00:10:32,727 --> 00:10:34,560
Vi har detta exempel
vi bara gå över

215
00:10:34,560 --> 00:10:38,950
om att kunna replikera katten
Linux kommando, den som skriver ut

216
00:10:38,950 --> 00:10:40,500
till skärmen.

217
00:10:40,500 --> 00:10:43,510
Nåväl, nu när vi har förmågan
att läsa tecken från filer

218
00:10:43,510 --> 00:10:46,590
och skriva tecken till filer,
varför inte vi bara ersätta det

219
00:10:46,590 --> 00:10:50,720
ringa för att printf med en uppmaning till fputc.

220
00:10:50,720 --> 00:10:54,090
>> Och nu har vi dupliceras cp,
en mycket grundläggande linux kommando

221
00:10:54,090 --> 00:10:59,100
att vi pratade om hur länge
sedan i linux kommandon videon.

222
00:10:59,100 --> 00:11:01,070
Vi har på ett effektivt sätt
dupliceras denna rätt här.

223
00:11:01,070 --> 00:11:04,790
Vi läser en karaktär och då är vi
skriftligen tecken till en annan fil.

224
00:11:04,790 --> 00:11:07,660
Läsning från en fil, skriva
till en annan, om och om igen

225
00:11:07,660 --> 00:11:11,350
och om igen tills vi hit EOF.

226
00:11:11,350 --> 00:11:14,250
Vi har kommit till slutet av
fil vi försöker kopiera från.

227
00:11:14,250 --> 00:11:18,500
Och genom att vi har skrivit alla
av karaktärerna måste vi filen

228
00:11:18,500 --> 00:11:19,500
att vi skriver till.

229
00:11:19,500 --> 00:11:24,270
Så det här är cp, kopiera kommandot Linux.

230
00:11:24,270 --> 00:11:26,550
>> Alldeles i början av
den här videon hade jag varning

231
00:11:26,550 --> 00:11:29,840
att vi skulle prata
lite om pekare.

232
00:11:29,840 --> 00:11:32,480
Här är särskilt där vi är
kommer att tala om pekare

233
00:11:32,480 --> 00:11:34,800
förutom till fil pekare.

234
00:11:34,800 --> 00:11:37,870
Så här funktionen ser lite skrämmande.

235
00:11:37,870 --> 00:11:39,120
Det har fått flera parametrar.

236
00:11:39,120 --> 00:11:40,430
Det är mycket som händer här.

237
00:11:40,430 --> 00:11:42,760
Det finns en massa olika
färger och texter.

238
00:11:42,760 --> 00:11:47,100
Men egentligen, det är bara
generisk version av fgetc

239
00:11:47,100 --> 00:11:50,110
som tillåter oss att få någon
mängd information.

240
00:11:50,110 --> 00:11:53,560
Det kan vara lite ineffektivt om vi är
få tecken ett i taget,

241
00:11:53,560 --> 00:11:55,770
iterera igenom filen
ett tecken i taget.

242
00:11:55,770 --> 00:12:00,230
Skulle det inte vara trevligare att få
100 åt gången eller 500 på en gång?

243
00:12:00,230 --> 00:12:03,250
>> Tja, fread och dess följeslagare funktion
fwrite, som vi kommer att prata om

244
00:12:03,250 --> 00:12:05,490
i en andra, tillåter oss att göra just detta.

245
00:12:05,490 --> 00:12:08,480
Vi kan läsa ett godtyckligt belopp
av information från en fil

246
00:12:08,480 --> 00:12:10,290
och vi förvara den någonstans tillfälligt.

247
00:12:10,290 --> 00:12:12,980
I stället för att kunna precis
montera den i en enda variabel,

248
00:12:12,980 --> 00:12:15,790
Vi kanske behöver förvara den i en array.

249
00:12:15,790 --> 00:12:19,980
Och så, vi passerar i fyra
argument att fread-- en pekare

250
00:12:19,980 --> 00:12:23,940
till den plats där vi är
kommer att lagra information,

251
00:12:23,940 --> 00:12:29,180
hur stor varje informationsenhet
kommer att bli, hur många enheter av informations

252
00:12:29,180 --> 00:12:35,192
Vi vill att förvärva, och från
vilken fil vi vill få dem.

253
00:12:35,192 --> 00:12:37,150
Illustreras förmodligen bäst
med ett exempel här.

254
00:12:37,150 --> 00:12:41,640
Så låt oss säga att vi deklarerar
en array av 10 heltal.

255
00:12:41,640 --> 00:12:45,080
Vi har just förklarat på
stapla godtyckligt int arr 10.

256
00:12:45,080 --> 00:12:46,970
Så det är ganska enkelt.

257
00:12:46,970 --> 00:12:51,970
Nu vad vi gör men är
frecall är vi läser storleken på int

258
00:12:51,970 --> 00:12:54,180
gånger 10 byte med information.

259
00:12:54,180 --> 00:12:59,040
Storlek på int vara four-- det är
storleken på ett heltal i c.

260
00:12:59,040 --> 00:13:02,790
>> Så vad vi gör är att vi läser
40 byte till ett värde av uppgifter

261
00:13:02,790 --> 00:13:05,850
från filen som utpekas av PTR.

262
00:13:05,850 --> 00:13:08,600
Och vi lagrar dem
40 bytes någonstans

263
00:13:08,600 --> 00:13:12,080
där vi har avsatt
40 byte värde av minne.

264
00:13:12,080 --> 00:13:15,970
Lyckligtvis har vi redan gjort det genom att
förklara arr att array där.

265
00:13:15,970 --> 00:13:19,770
Som har förmåga att innehav
10 fyra-byte enheter.

266
00:13:19,770 --> 00:13:22,860
Så totalt, kan det hålla 40
bytes värde av information.

267
00:13:22,860 --> 00:13:26,540
Och vi nu läser 40 byte
information från filen,

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

269
00:13:30,330 --> 00:13:35,470
>> Minns från videon på pekare som
namnet på en array, såsom arr,

270
00:13:35,470 --> 00:13:38,370
är egentligen bara en pekare
till dess första elementet.

271
00:13:38,370 --> 00:13:43,680
Så när vi passerar i arr där, vi
är i själva verket, som passerar i en pekare.

272
00:13:43,680 --> 00:13:46,120
>> På samma sätt kan vi göra this--
Vi gör inte nödvändigtvis

273
00:13:46,120 --> 00:13:51,200
måste rädda vår buffert på stacken.

274
00:13:51,200 --> 00:13:54,990
Vi kunde också dynamiskt allokera
en buffert så här, med hjälp av malloc.

275
00:13:54,990 --> 00:13:57,340
Kom ihåg att när vi
dynamiskt allokera minne,

276
00:13:57,340 --> 00:14:00,550
vi sparar det på
hög, inte bunten.

277
00:14:00,550 --> 00:14:02,110
Men det är fortfarande en buffert.

278
00:14:02,110 --> 00:14:06,810
>> Det fortfarande, i det här fallet, är
hålla 640 byte med information

279
00:14:06,810 --> 00:14:09,230
eftersom en dubbel tar upp åtta byte.

280
00:14:09,230 --> 00:14:11,570
Och vi ber för 80 av dem.

281
00:14:11,570 --> 00:14:13,770
Vi vill ha utrymme
att hålla 80 dubbel.

282
00:14:13,770 --> 00:14:17,210
Så 80 gånger 8 är 640 bytes information.

283
00:14:17,210 --> 00:14:21,880
Och denna uppmaning till fread är
samla 640 byte med information

284
00:14:21,880 --> 00:14:27,770
från filen som pekas på av
PTR och lagra den nu arr2.

285
00:14:27,770 --> 00:14:32,770
>> Nu kan vi också behandla fread
precis som ett samtal till fgetc.

286
00:14:32,770 --> 00:14:37,140
I det här fallet, vi försöker bara
få ett tecken från filen.

287
00:14:37,140 --> 00:14:40,070
Och vi behöver inte ett
array för att hålla ett tecken.

288
00:14:40,070 --> 00:14:43,170
Vi kan bara förvara den i
en teckenvariabel.

289
00:14:43,170 --> 00:14:46,390
>> Fångsten är dock att
när vi har bara en variabel,

290
00:14:46,390 --> 00:14:50,290
Vi behöver skicka i
adressen till den variabel

291
00:14:50,290 --> 00:14:52,550
eftersom minns att
första argumentet till fread

292
00:14:52,550 --> 00:14:59,210
är en pekare till platsen och minne
där vi vill lagra informationen.

293
00:14:59,210 --> 00:15:01,550
Återigen, namnet på en
matris är en pekare.

294
00:15:01,550 --> 00:15:04,200
Så vi behöver inte göra-tecken array.

295
00:15:04,200 --> 00:15:07,270
Men c, karaktären c
här är inte en matris.

296
00:15:07,270 --> 00:15:08,390
Det är bara en variabel.

297
00:15:08,390 --> 00:15:11,840
Och så vi behöver för att klara ett
et-c för att indikera

298
00:15:11,840 --> 00:15:15,350
att det är den adress där vi vill
att lagra denna en byte med information,

299
00:15:15,350 --> 00:15:20,479
detta ett tecken som
vi samla från PTR.

300
00:15:20,479 --> 00:15:22,270
Fwrite-- jag ska gå igenom
detta lite mer

301
00:15:22,270 --> 00:15:25,440
quickly-- är ganska mycket
exakt motsvarighet till fread

302
00:15:25,440 --> 00:15:27,720
förutom att det är för att skriva
istället för att läsa, bara

303
00:15:27,720 --> 00:15:31,610
som other-- vi har haft öppna
och nära, få en karaktär,

304
00:15:31,610 --> 00:15:32,530
skriva ett tecken.

305
00:15:32,530 --> 00:15:35,040
Nu är det få godtycklig
mängd information,

306
00:15:35,040 --> 00:15:37,170
rätt godtycklig mängd information.

307
00:15:37,170 --> 00:15:39,790
Så precis som förut, vi kan
har en matris med 10 heltal

308
00:15:39,790 --> 00:15:43,210
där vi redan har
information som lagras, kanske.

309
00:15:43,210 --> 00:15:46,580
>> Det var förmodligen några rader kod
som bör gå mellan dessa två

310
00:15:46,580 --> 00:15:49,990
där jag fyller arr med
något meningsfullt.

311
00:15:49,990 --> 00:15:51,880
Jag fyller den med 10 olika heltal.

312
00:15:51,880 --> 00:15:54,920
Och i stället, vad jag
gör skriver från arr

313
00:15:54,920 --> 00:15:58,600
och samla in information från arr.

314
00:15:58,600 --> 00:16:02,390
Och jag tar denna information
och sätta in den i filen.

315
00:16:02,390 --> 00:16:05,410
>> Så i stället för att det är från
filen till bufferten,

316
00:16:05,410 --> 00:16:08,790
vi nu går från
bufferten till filen.

317
00:16:08,790 --> 00:16:10,580
Så det är bara det omvända.

318
00:16:10,580 --> 00:16:16,680
Så återigen, precis som tidigare, kan vi
har också en heap bit av minne

319
00:16:16,680 --> 00:16:19,600
att vi har dynamiskt
fördelas och läsa från den

320
00:16:19,600 --> 00:16:21,570
och skriver att till filen.

321
00:16:21,570 --> 00:16:24,900
>> Och vi har också en enda variabel
förmåga att hålla en bitgrupp

322
00:16:24,900 --> 00:16:27,200
av information, såsom ett tecken.

323
00:16:27,200 --> 00:16:29,830
Men återigen, vi måste passera
adressen för den variabeln

324
00:16:29,830 --> 00:16:31,840
när vi vill läsa från den.

325
00:16:31,840 --> 00:16:35,280
Så vi kan skriva ner informationen
Vi hittar på denna adress

326
00:16:35,280 --> 00:16:39,050
till filpekaren, PTR.

327
00:16:39,050 --> 00:16:41,630
>> Det finns massor av andra
stor fil I / O-funktioner

328
00:16:41,630 --> 00:16:44,650
att göra olika saker förutom
de vi har pratat om i dag.

329
00:16:44,650 --> 00:16:46,450
Ett par av dem
du kan ha nytta av

330
00:16:46,450 --> 00:16:50,840
är fgets och fputs,
vilka är ekvivalenta

331
00:16:50,840 --> 00:16:56,190
av fgetc och fputc men för läsning
en enda sträng från en fil.

332
00:16:56,190 --> 00:16:59,020
I stället för ett enda tecken,
Det kommer att läsa en hel sträng.

333
00:16:59,020 --> 00:17:02,940
fprintf, som i princip gör det möjligt
du kan använda printf att skriva till filen.

334
00:17:02,940 --> 00:17:05,619
Så precis som du kan göra
variabelsubstitution med hjälp av

335
00:17:05,619 --> 00:17:09,900
den platshållarna procent i och
procent d, och så vidare, med printf

336
00:17:09,900 --> 00:17:14,690
kan på liknande sätt ta
printf sträng och skriva ut något

337
00:17:14,690 --> 00:17:16,800
så där till en fil.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- om du har en DVD-spelare
är analogin jag brukar använda här--

339
00:17:20,720 --> 00:17:23,109
är ungefär som att använda din
spola tillbaka och snabbspola framåt

340
00:17:23,109 --> 00:17:25,819
knapparna för att flytta runt på filmen.

341
00:17:25,819 --> 00:17:28,369
På samma sätt kan du flytta runt filen.

342
00:17:28,369 --> 00:17:30,250
En av de saker inuti
att filstrukturen

343
00:17:30,250 --> 00:17:34,270
att c skapar för dig är en indikator
av var du befinner dig i filen.

344
00:17:34,270 --> 00:17:36,420
Är du på mycket
början, vid byte noll?

345
00:17:36,420 --> 00:17:39,290
Är du på byte 100,
byte 1000, och så vidare?

346
00:17:39,290 --> 00:17:44,340
Du kan använda fseek godtyckligt flytta
denna indikator framåt eller bakåt.

347
00:17:44,340 --> 00:17:46,744
>> Och ftell, återigen
liknar en DVD-spelare,

348
00:17:46,744 --> 00:17:49,660
är som en liten klocka som berättar
hur många minuter och sekunder dig

349
00:17:49,660 --> 00:17:52,480
är i en viss film.

350
00:17:52,480 --> 00:17:56,990
På liknande sätt, berättar ftell hur
många bytes du är i filen.

351
00:17:56,990 --> 00:18:00,210
feof är en annan version
detektera om du har

352
00:18:00,210 --> 00:18:01,700
nått slutet av filen.

353
00:18:01,700 --> 00:18:03,600
Och ferror är en funktion
som du kan använda

354
00:18:03,600 --> 00:18:06,959
att upptäcka om något har
gått fel arbetsdag med en fil.

355
00:18:06,959 --> 00:18:08,750
Återigen, detta är bara
skrapa på ytan.

356
00:18:08,750 --> 00:18:12,730
Det finns fortfarande mycket mer fil-I / O
funktioner i standard io.h.

357
00:18:12,730 --> 00:18:16,620
Men det kommer förmodligen att få dig
började arbeta med fil pekare.

358
00:18:16,620 --> 00:18:17,640
Jag är Doug Lloyd.

359
00:18:17,640 --> 00:18:19,750
Detta är CS50.

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