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

2
00:00:05,330 --> 00:00:07,870
>> COLUMNA: Ata o momento, é probable
que a maioría dos seus programas

3
00:00:07,870 --> 00:00:10,170
ser un pouco efémera.

4
00:00:10,170 --> 00:00:13,310
Executar un programa como Mario ou ávido.

5
00:00:13,310 --> 00:00:17,350
Fai algo, quizais solicitará
o usuario para unha información,

6
00:00:17,350 --> 00:00:20,400
imprimir algunha saída para a pantalla,
pero, a continuación, cando o programa acabou,

7
00:00:20,400 --> 00:00:23,252
non hai realmente ningunha evidencia alí
nunca foi executado en primeiro lugar.

8
00:00:23,252 --> 00:00:25,960
Quero dicir, por suposto, que pode deixar
el abrir a fiestra da terminal,

9
00:00:25,960 --> 00:00:29,770
pero se limpar a súa pantalla, non hai
realmente ningunha evidencia de que existía.

10
00:00:29,770 --> 00:00:33,720
Non temos un medio de almacenamento
información persistente, información

11
00:00:33,720 --> 00:00:36,890
que hai despois do noso
programa deixou de funcionar,

12
00:00:36,890 --> 00:00:39,241
ou que non ten, ata este punto.

13
00:00:39,241 --> 00:00:41,490
Afortunadamente, porén, fai c
proporcionar-nos coa capacidade

14
00:00:41,490 --> 00:00:44,220
facelo a través da posta en marcha
algo chamado

15
00:00:44,220 --> 00:00:48,330
un arquivo, unha estrutura que basicamente
representa un ficheiro que dobraría

16
00:00:48,330 --> 00:00:53,826
prema no seu ordenador, se está
usado para un ambiente de usuario gráfica.

17
00:00:53,826 --> 00:00:55,700
Dun modo xeral cando se traballa
con c, estamos, en realidade,

18
00:00:55,700 --> 00:00:59,965
vai estar traballando con
punteiros para files-- ficheiro stars--

19
00:00:59,965 --> 00:01:02,090
con excepción de un pouco
cando falamos dunha parella

20
00:01:02,090 --> 00:01:04,560
de que as funcións
traballar con punteiros de arquivo.

21
00:01:04,560 --> 00:01:08,990
Non é preciso ter realmente cavou
moi profundo entendemento punteiros

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

23
00:01:09,730 --> 00:01:12,870
Hai un pouco de hippies
onde iremos falar sobre eles,

24
00:01:12,870 --> 00:01:18,090
pero xeralmente o ficheiro e punteiros
punteiros, mentres interrelacionados,

25
00:01:18,090 --> 00:01:20,290
non son exactamente o mesmo.

26
00:01:20,290 --> 00:01:22,440
>> Agora o que quero dicir cando
Digo datos persistentes?

27
00:01:22,440 --> 00:01:23,650
¿Qué son datos persistentes?

28
00:01:23,650 --> 00:01:25,232
Por que nos preocupa con iso?

29
00:01:25,232 --> 00:01:27,190
Digamos que, por exemplo, que
está executando un programa

30
00:01:27,190 --> 00:01:29,850
ou que teña reescrito un
programa que é un xogo,

31
00:01:29,850 --> 00:01:32,960
e quere manter o control
de todos os movementos do usuario

32
00:01:32,960 --> 00:01:36,620
de xeito que se cadra, se algo sae mal,
pode revisar o ficheiro despois do partido.

33
00:01:36,620 --> 00:01:39,970
Iso é o que queremos dicir cando
falar datos persistentes.

34
00:01:39,970 --> 00:01:43,930
>> No decurso da execución do seu
programa, un arquivo é creado.

35
00:01:43,930 --> 00:01:45,680
E cando o seu programa
deixou de funcionar,

36
00:01:45,680 --> 00:01:48,689
o ficheiro aínda existe no seu sistema.

37
00:01:48,689 --> 00:01:50,230
E podemos ollar para el e examina-lo.

38
00:01:50,230 --> 00:01:53,670
E así que o programa sería definida como
crearon algúns datos persistentes,

39
00:01:53,670 --> 00:01:57,390
existen datos despois do programa
rematar a execución.

40
00:01:57,390 --> 00:02:02,320
>> Agora todas estas funcións que funcionan
coa creación de ficheiros e manipulación

41
00:02:02,320 --> 00:02:04,940
los de diversos xeitos
vivir io.h estándar,

42
00:02:04,940 --> 00:02:08,210
que é un ficheiro de cabeceira que
probablemente foi libra

43
00:02:08,210 --> 00:02:10,910
incluíndo na parte superior da considerablemente
moi todos os seus programas

44
00:02:10,910 --> 00:02:14,130
porque contén un dos
a maioría das funcións útiles para nós,

45
00:02:14,130 --> 00:02:16,130
printf, que tamén permite
vive io.h. estándar

46
00:02:16,130 --> 00:02:20,400
Entón non bater inclúen
os ficheiros adicionais probablemente

47
00:02:20,400 --> 00:02:23,540
a fin de traballar con punteiros de arquivo.

48
00:02:23,540 --> 00:02:29,980
>> Agora, cada función de punteiro de arquivo único,
ou cada ficheiro I / O, de entrada e saída

49
00:02:29,980 --> 00:02:33,310
función, acepta como un
dos seus parámetros ou insumos

50
00:02:33,310 --> 00:02:35,822
pointer-- un ficheiro gardado
por exemplo, fopen, que

51
00:02:35,822 --> 00:02:38,280
é o que usa para obter o ficheiro
punteiro en primeiro lugar.

52
00:02:38,280 --> 00:02:41,010
Pero despois de que abriu a
arquivo e comeza punteiros de ficheiro,

53
00:02:41,010 --> 00:02:43,510
pode, a continuación, paso-los como
argumentos para as varias funcións

54
00:02:43,510 --> 00:02:46,720
imos falar
Hoxe en día, así como moitos outros

55
00:02:46,720 --> 00:02:48,520
de modo que pode traballar con arquivos.

56
00:02:48,520 --> 00:02:50,980
>> Polo tanto, hai seis fermosa
os básicos comúns

57
00:02:50,980 --> 00:02:52,870
que imos falar hoxe.

58
00:02:52,870 --> 00:02:57,160
fopen eo seu compañeiro
función fclose, fgetc

59
00:02:57,160 --> 00:03:02,670
ea súa función fputc compañeiro,
e fread ea súa función compañeiro,

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

61
00:03:03,820 --> 00:03:05,180
Entón imos directo ao asunto.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- o que fai?

63
00:03:07,050 --> 00:03:10,050
Ben, el abre un arquivo eo
dálle un punteiro de ficheiro a el,

64
00:03:10,050 --> 00:03:14,000
de modo que pode usar este
arquivo punteiro como un argumento

65
00:03:14,000 --> 00:03:16,730
para calquera das outras funcións de E / S de ficheiro.

66
00:03:16,730 --> 00:03:19,100
O máis importante
para lembrar con fopen

67
00:03:19,100 --> 00:03:24,222
é que, despois de ter aberto o
ficheiro ou fixo unha conexión como a que aquí,

68
00:03:24,222 --> 00:03:26,930
ten que comprobar para asegurarse de
que o punteiro que ten de volta

69
00:03:26,930 --> 00:03:28,320
non é igual a cero.

70
00:03:28,320 --> 00:03:31,320
Se aínda non asistiu o vídeo en
punteiros, isto pode non ter sentido.

71
00:03:31,320 --> 00:03:35,639
Pero se tentar e dereference
un recall punteiro nulo,

72
00:03:35,639 --> 00:03:38,180
seu programa probablemente sufrirán
unha segmentación [inaudível].

73
00:03:38,180 --> 00:03:40,540
Queremos estar seguro de que nós
ten un punteiro de volta lexítimo.

74
00:03:40,540 --> 00:03:43,665
A gran maioría do tempo imos
obter un punteiro lexítimo ao

75
00:03:43,665 --> 00:03:45,280
e non será un problema.

76
00:03:45,280 --> 00:03:46,760
>> Entón, como imos facer unha chamada para fopen?

77
00:03:46,760 --> 00:03:48,051
Parece moi bonito como este.

78
00:03:48,051 --> 00:03:52,690
Estrela ficheiro ptr-- PTR sendo un xenérico
nome para o ficheiro pointer-- fopen

79
00:03:52,690 --> 00:03:57,300
e nós pasamos en dúas cousas, o nome do ficheiro
e unha operación que queremos emprender.

80
00:03:57,300 --> 00:04:01,690
Así, poderiamos ter unha chamada que se parece
isto-- estrela ficheiro PTR 1 é igual a fopen

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

82
00:04:04,040 --> 00:04:07,020
E a operación que escollín é r.

83
00:04:07,020 --> 00:04:08,639
>> Entón, o que pensas r é aquí?

84
00:04:08,639 --> 00:04:11,180
Cales son os tipos de cousas que
Pode ser capaz de facer a ficheiros?

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

86
00:04:13,760 --> 00:04:17,500
Así, R é a operación que
escoller cando queremos ler un arquivo.

87
00:04:17,500 --> 00:04:20,260
Por iso, sería, basicamente, cando
facemos unha chamada como este

88
00:04:20,260 --> 00:04:25,440
estar recibindo nós un punteiro de ficheiro
de tal forma que nós podería entón ler información

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

90
00:04:27,770 --> 00:04:34,190
>> Do mesmo xeito, poderiamos abrir o ficheiro 2.txt
para escribir e para que poidamos pasar ptr2,

91
00:04:34,190 --> 00:04:38,210
o punteiro do ficheiro que eu creei aquí,
como un argumento para calquera función que

92
00:04:38,210 --> 00:04:40,080
grava información nun arquivo.

93
00:04:40,080 --> 00:04:43,767
E semellante á escrita, hai
tamén a posibilidade de engadir, a.

94
00:04:43,767 --> 00:04:45,600
A diferenza entre
escribindo e anexando

95
00:04:45,600 --> 00:04:50,920
sendo que cando gravar nun ficheiro,
se fai unha chamada para fopen para a escrita

96
00:04:50,920 --> 00:04:54,761
e este ficheiro xa existe, é
vai substituír o ficheiro.

97
00:04:54,761 --> 00:04:56,510
Comezará
en principio,

98
00:04:56,510 --> 00:04:58,820
borrar toda a información
que xa está aí.

99
00:04:58,820 --> 00:05:02,210
>> Tendo en conta que, se abri-lo para engadir,
vai para o final do arquivo

100
00:05:02,210 --> 00:05:04,340
se xa existe texto
ou información nel contidas,

101
00:05:04,340 --> 00:05:06,040
e vai entón comezar
escrita de alí.

102
00:05:06,040 --> 00:05:08,570
Entón non vai perder calquera dos
información que fixo antes.

103
00:05:08,570 --> 00:05:12,110
Se queres escribir ou achegar
tipo de depende da situación.

104
00:05:12,110 --> 00:05:16,840
Pero probablemente vai saber o que o
operación correcta é cando chega a hora.

105
00:05:16,840 --> 00:05:18,020
Entón, iso é fopen.

106
00:05:18,020 --> 00:05:18,930
>> E sobre fclose?

107
00:05:18,930 --> 00:05:21,600
Ben, moi simplemente, fclose
só acepta o punteiro do ficheiro.

108
00:05:21,600 --> 00:05:24,000
E como podería esperar,
el pecha o arquivo.

109
00:05:24,000 --> 00:05:29,270
E unha vez que pechou un ficheiro, non podemos
realizar calquera arquivo de funcións de E / S,

110
00:05:29,270 --> 00:05:31,420
lendo ou escribindo, naquel arquivo.

111
00:05:31,420 --> 00:05:36,444
Temos que volver a abrir a
presentar outra vez, a fin

112
00:05:36,444 --> 00:05:38,610
seguir traballando con
Lo usando as funcións de I / O.

113
00:05:38,610 --> 00:05:41,520
Entón medios fclose estamos a facer
traballar con este ficheiro.

114
00:05:41,520 --> 00:05:44,690
E todos necesitamos é pasar en
o nome dun ficheiro de punteiro.

115
00:05:44,690 --> 00:05:50,010
Entón, nun par desliza atrás,
fopened arquivo de texto 1 punto para a lectura

116
00:05:50,010 --> 00:05:52,854
e nós asignado que
arquivo punteiro para ptr1.

117
00:05:52,854 --> 00:05:55,020
Agora decidimos que somos
lectura feita a partir dese ficheiro.

118
00:05:55,020 --> 00:05:56,561
Non teñen que facer máis nada con el.

119
00:05:56,561 --> 00:05:58,890
Podemos ptr1 só fclose.

120
00:05:58,890 --> 00:06:01,950
E do mesmo xeito, poderiamos
usar fclose os outros.

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

122
00:06:02,450 --> 00:06:03,700
De xeito que está abrindo e pechando.

123
00:06:03,700 --> 00:06:05,780
Estes son os dous básico
operacións de partida.

124
00:06:05,780 --> 00:06:08,050
>> Agora queremos realmente
facer algunhas cousas interesantes,

125
00:06:08,050 --> 00:06:11,940
ea primeira función que imos
ver que vai facer iso é fgetc--

126
00:06:11,940 --> 00:06:14,110
arquivar obter un personaxe.

127
00:06:14,110 --> 00:06:17,350
Iso é o que xeralmente fgetc
se traduciría en.

128
00:06:17,350 --> 00:06:20,190
O seu obxectivo na vida é
le o seguinte carácter,

129
00:06:20,190 --> 00:06:22,079
ou se esta é a súa moi
primeira chamada para fgetc

130
00:06:22,079 --> 00:06:23,870
para un determinado arquivo,
o primeiro carácter.

131
00:06:23,870 --> 00:06:26,210
Pero, entón, despois diso,
comeza a próxima,

132
00:06:26,210 --> 00:06:31,500
o moi próximo carácter deste arquivo,
e as almacena nunha variable de carácter.

133
00:06:31,500 --> 00:06:34,490
Como fixemos aquí,
carácter ch igual fgetc,

134
00:06:34,490 --> 00:06:36,389
pasar o nome dun ficheiro de punteiro.

135
00:06:36,389 --> 00:06:38,180
De novo, é moi
importante aquí para recordar

136
00:06:38,180 --> 00:06:41,430
que, a fin de ter
esta operación foi un éxito,

137
00:06:41,430 --> 00:06:45,690
o propio punteiro do ficheiro debo ter
foi aberto para lectura.

138
00:06:45,690 --> 00:06:50,589
Non podemos ler un personaxe dun ficheiro
punteiro que abrimos para a escrita.

139
00:06:50,589 --> 00:06:52,630
Entón esta é unha das
limitacións de fopen, non?

140
00:06:52,630 --> 00:06:55,470
Temos para restrinxir
nós só para realizar

141
00:06:55,470 --> 00:06:57,710
unha operación cun punteiro de arquivo.

142
00:06:57,710 --> 00:07:00,220
Se quixésemos ler e
escribir desde o mesmo arquivo,

143
00:07:00,220 --> 00:07:03,840
teriamos aberto dous separados
punteiros de arquivos para o mesmo file--

144
00:07:03,840 --> 00:07:05,670
unha lectura, unha para a escrita.

145
00:07:05,670 --> 00:07:08,400
>> Entón, de novo, a única razón
Eu traio que ata agora é

146
00:07:08,400 --> 00:07:11,920
porque se nós estamos indo a facer unha chamada
para fgetc, que debe ter un punteiro de ficheiro

147
00:07:11,920 --> 00:07:14,172
foi aberto para lectura.

148
00:07:14,172 --> 00:07:15,880
E, a continuación, moi simplemente,
todo o que necesitamos facer

149
00:07:15,880 --> 00:07:17,546
é pasar o nome do punteiro do ficheiro.

150
00:07:17,546 --> 00:07:21,060
Entón ch carbón equivale a ptr1 fgetc.

151
00:07:21,060 --> 00:07:23,200
>> Isto vai levarnos
a próxima character--

152
00:07:23,200 --> 00:07:25,575
ou aínda, se este é o primeiro
xa que xa se fixo esta chamada,

153
00:07:25,575 --> 00:07:29,750
o primeiro character-- de calquera
ficheiro é apuntada por ptr1.

154
00:07:29,750 --> 00:07:32,210
Lembre que isto era un arquivo de texto de punto.

155
00:07:32,210 --> 00:07:36,490
Vai ter o primeiro carácter desa
e imos almacena-lo no ch variable.

156
00:07:36,490 --> 00:07:37,941
Moi sinxelo.

157
00:07:37,941 --> 00:07:40,190
Entón, temos só mirou para tres
funcións e xa nós

158
00:07:40,190 --> 00:07:43,070
pode facer algo moi ordenado.

159
00:07:43,070 --> 00:07:46,320
>> Entón, se tomamos esa capacidade
de obtención dun personaxe

160
00:07:46,320 --> 00:07:48,943
e nós lazo ele-- tanto,
continuar a recibir personaxes

161
00:07:48,943 --> 00:07:51,390
a partir dun ficheiro de cada vez
máis e agora nós over--

162
00:07:51,390 --> 00:07:54,500
pode ler cada
personaxe dun ficheiro.

163
00:07:54,500 --> 00:07:58,670
E se nós imprimir cada personaxe
inmediatamente despois de ler,

164
00:07:58,670 --> 00:08:01,960
temos agora lidos dun arquivo e
seu contido impreso para a pantalla.

165
00:08:01,960 --> 00:08:05,610
Temos efectivamente concatenado
o ficheiro en pantalla.

166
00:08:05,610 --> 00:08:09,670
E iso é o que o
Comando cat Linux fai.

167
00:08:09,670 --> 00:08:13,250
>> Se escribe gato no nome do arquivo,
imprimirá todos os contidos

168
00:08:13,250 --> 00:08:15,160
Arquivo da xanela do seu terminal.

169
00:08:15,160 --> 00:08:19,010
E así este pequeno lazo aquí,
só tres liñas de código,

170
00:08:19,010 --> 00:08:23,270
pero duplica efectivamente
o gato de comandos de Linux.

171
00:08:23,270 --> 00:08:25,210
Polo tanto, esta sintaxe pode
Parece un pouco raro,

172
00:08:25,210 --> 00:08:26,670
pero aquí está o que está a suceder aquí.

173
00:08:26,670 --> 00:08:31,460
Mentres ch igual fgetc, PTR non é
igual a EOF-- é un pouco todo,

174
00:08:31,460 --> 00:08:34,669
pero imos división la só
polo que está claro sobre a sintaxe.

175
00:08:34,669 --> 00:08:37,169
Eu consolidouse lo
por unha cuestión de espazo,

176
00:08:37,169 --> 00:08:39,049
aínda que é un pouco
sintaticamente complicado.

177
00:08:39,049 --> 00:08:41,194
>> Polo tanto, esta parte no dereito verde
agora, o que está facendo?

178
00:08:41,194 --> 00:08:42,860
Ben, iso é só o noso chamamento fgetc, non?

179
00:08:42,860 --> 00:08:44,530
Vimos que antes.

180
00:08:44,530 --> 00:08:49,500
É obtención dun
personaxe dende o arquivo.

181
00:08:49,500 --> 00:08:53,220
A continuación, comparar ese
carácter contra EOF.

182
00:08:53,220 --> 00:08:57,470
EOF é un valor especial que é
definido io.h estándar, que

183
00:08:57,470 --> 00:08:59,390
é o fin do personaxe de arquivo.

184
00:08:59,390 --> 00:09:03,450
Entón, basicamente o que vai pasar
é este ciclo vai ler un personaxe,

185
00:09:03,450 --> 00:09:07,445
comparar a EOF, o
fin do personaxe de arquivo.

186
00:09:07,445 --> 00:09:10,070
No caso de que non se corresponden, polo que non ten
chegou ao fin do ficheiro,

187
00:09:10,070 --> 00:09:11,490
imos imprimir ese personaxe para fóra.

188
00:09:11,490 --> 00:09:13,740
Entón imos voltar para o
inicio do ciclo de novo.

189
00:09:13,740 --> 00:09:18,310
Nós imos chegar a un personaxe, comprobe
contra EOF, imprimir lo, e así por diante

190
00:09:18,310 --> 00:09:21,094
e así por diante e así por diante,
loop través desa forma

191
00:09:21,094 --> 00:09:22,760
ata que chegamos ao final do arquivo.

192
00:09:22,760 --> 00:09:24,593
E, a continuación, por ese punto,
imos ter impreso

193
00:09:24,593 --> 00:09:26,210
fóra todo o contido do ficheiro.

194
00:09:26,210 --> 00:09:29,450
Entón, de novo, só vin
fopen, fclose, e fgetc

195
00:09:29,450 --> 00:09:34,950
e xa podemos duplicar
unha orde de terminal de Linux.

196
00:09:34,950 --> 00:09:38,850
>> Como dixen ao principio,
tivemos fgetc e fputc,

197
00:09:38,850 --> 00:09:41,860
e fputc foi o compañeiro
función de fgetc.

198
00:09:41,860 --> 00:09:44,880
E así, como pode imaxinar,
é o equivalente escrito.

199
00:09:44,880 --> 00:09:49,440
Ela nos permite escribir
único carácter nun arquivo.

200
00:09:49,440 --> 00:09:53,290
>> Unha vez máis, sendo a excepción, só
como se fose con fgetc, o ficheiro

201
00:09:53,290 --> 00:09:56,660
que estamos escribindo para debe ser
aberto para gravar ou para engadir.

202
00:09:56,660 --> 00:10:00,820
Se intentamos e utilizar fputc nun ficheiro
que temos aberto para lectura,

203
00:10:00,820 --> 00:10:02,760
imos sufrir
un pouco de un erro.

204
00:10:02,760 --> 00:10:04,440
A súa chamada é ben sinxelo.

205
00:10:04,440 --> 00:10:08,000
A capital de fputc ptr2, todo
que vai facer é que é

206
00:10:08,000 --> 00:10:12,040
vai escribir a letra
en A en arquivo de 2 punto

207
00:10:12,040 --> 00:10:14,760
o texto, que foi o nome do
ficheiro que aberto e asignado

208
00:10:14,760 --> 00:10:17,280
o punteiro para ptr2.

209
00:10:17,280 --> 00:10:20,430
Entón, nós estamos indo a escribir un
maiúsculo para ficheiro 2 texto punto.

210
00:10:20,430 --> 00:10:24,592
E nós imos escribir exclamación
apuntar para o arquivo 3 dot

211
00:10:24,592 --> 00:10:27,330
texto, que foi apuntado por ptr3.

212
00:10:27,330 --> 00:10:29,730
Entón, de novo, moi sinxelo aquí.

213
00:10:29,730 --> 00:10:32,727
>> Pero agora podemos facer outra cousa.

214
00:10:32,727 --> 00:10:34,560
Temos este exemplo
estabamos só pasando por riba

215
00:10:34,560 --> 00:10:38,950
sobre a posibilidade de replicar o gato
De comandos de Linux, o que imprime

216
00:10:38,950 --> 00:10:40,500
para a pantalla.

217
00:10:40,500 --> 00:10:43,510
Ben, agora que temos a capacidade
para ler caracteres de arquivos

218
00:10:43,510 --> 00:10:46,590
e escribir caracteres para arquivos,
por que non podemos simplemente substituír ese

219
00:10:46,590 --> 00:10:50,720
chamar a printf cunha chamada a fputc.

220
00:10:50,720 --> 00:10:54,090
>> E agora temos duplicado cp,
un comando moi básico Linux

221
00:10:54,090 --> 00:10:59,100
que falamos camiño longo
atrás en Linux comandos vídeo.

222
00:10:59,100 --> 00:11:01,070
Temos efectivamente
duplicados que aquí.

223
00:11:01,070 --> 00:11:04,790
Estamos lendo un personaxe e entón nós estamos
escribindo este personaxe a outro arquivo.

224
00:11:04,790 --> 00:11:07,660
Lectura dun ficheiro, escrita
a outro, máis e máis

225
00:11:07,660 --> 00:11:11,350
e outra vez ata chegar EOF.

226
00:11:11,350 --> 00:11:14,250
Temos ata o final do
arquivar estamos intentando copiar.

227
00:11:14,250 --> 00:11:18,500
E por que imos escribir todo
dos personaxes que necesitamos para o ficheiro

228
00:11:18,500 --> 00:11:19,500
que estamos escribindo.

229
00:11:19,500 --> 00:11:24,270
Polo tanto, este é cp, o comando de copia de Linux.

230
00:11:24,270 --> 00:11:26,550
>> A principios de
Neste vídeo, eu tiña a excepción

231
00:11:26,550 --> 00:11:29,840
que queremos falar dun
pouco sobre punteiros.

232
00:11:29,840 --> 00:11:32,480
Aquí está especialmente onde estamos
vai falar punteiros

233
00:11:32,480 --> 00:11:34,800
ademais de presentar punteiros.

234
00:11:34,800 --> 00:11:37,870
Polo tanto, esta función parece medio asustado.

235
00:11:37,870 --> 00:11:39,120
Ten varios parámetros.

236
00:11:39,120 --> 00:11:40,430
Hai moita cousa a ocorrer aquí.

237
00:11:40,430 --> 00:11:42,760
Hai unha morea de diferentes
cores e textos.

238
00:11:42,760 --> 00:11:47,100
Pero, realmente, non é máis que o
versión xenérica do fgetc

239
00:11:47,100 --> 00:11:50,110
que nos permite obter calquera
cantidade de información.

240
00:11:50,110 --> 00:11:53,560
Pode ser un pouco ineficiente se estamos
caracteres quedando unha de cada vez,

241
00:11:53,560 --> 00:11:55,770
iteración a través do arquivo
un carácter á vez.

242
00:11:55,770 --> 00:12:00,230
Non sería máis agradable para estar
100 á vez 500 ou ao mesmo tempo?

243
00:12:00,230 --> 00:12:03,250
>> Ben, fread ea súa función compañeiro
fwrite, que nós imos falar sobre

244
00:12:03,250 --> 00:12:05,490
nun segundo, permitir-nos para facer exactamente isto.

245
00:12:05,490 --> 00:12:08,480
Podemos ler unha cantidade arbitraria
de información dun ficheiro

246
00:12:08,480 --> 00:12:10,290
e almacena-lo nalgún lugar temporalmente.

247
00:12:10,290 --> 00:12:12,980
No canto de poder só
axusta-lo nunha única variable,

248
00:12:12,980 --> 00:12:15,790
que pode ser necesario para almacena-lo nunha matriz.

249
00:12:15,790 --> 00:12:19,980
E así, pasamos en catro
argumentos para fread-- un punteiro

250
00:12:19,980 --> 00:12:23,940
ata o lugar onde estamos
indo para almacenar información,

251
00:12:23,940 --> 00:12:29,180
o grande cada unidade de información
será, cantas unidades de información

252
00:12:29,180 --> 00:12:35,192
queremos adquirir, e de
o ficheiro queremos obtelos.

253
00:12:35,192 --> 00:12:37,150
Probablemente mellor ilustrado
cun exemplo aquí.

254
00:12:37,150 --> 00:12:41,640
Entón, imos dicir que declaramos
un conxunto de 10 números enteiros.

255
00:12:41,640 --> 00:12:45,080
Acabamos declarado no
apilar arbitrariamente int arr 10.

256
00:12:45,080 --> 00:12:46,970
Entón, iso é moi sinxelo.

257
00:12:46,970 --> 00:12:51,970
Agora, o que estamos facendo, con todo, é o
frecall é que estamos tamaño do int lendo

258
00:12:51,970 --> 00:12:54,180
veces 10 bytes de información.

259
00:12:54,180 --> 00:12:59,040
Tamaño do int estar four-- que é
o tamaño dun número enteiro no c.

260
00:12:59,040 --> 00:13:02,790
>> Entón, o que estamos facendo é que estamos lendo
40 bytes por valor de información

261
00:13:02,790 --> 00:13:05,850
a partir do ficheiro sinalado por PTR.

262
00:13:05,850 --> 00:13:08,600
E nós estamos almacenando os
40 bytes en algún lugar

263
00:13:08,600 --> 00:13:12,080
onde nós reservamos
40 bytes por valor de memoria.

264
00:13:12,080 --> 00:13:15,970
Afortunadamente, xa fixemos isto por
declarando arr, esa matriz da dereita.

265
00:13:15,970 --> 00:13:19,770
Que é capaz de manter
10 unidades de catro bytes.

266
00:13:19,770 --> 00:13:22,860
Así, en total, pode almacenar 40
bytes pena de información.

267
00:13:22,860 --> 00:13:26,540
E agora estamos lendo 40 bytes
de información do arquivo,

268
00:13:26,540 --> 00:13:30,330
e estamos almacenando o en arr.

269
00:13:30,330 --> 00:13:35,470
>> Teña en conta que do vídeo no que os punteiros
o nome dunha matriz, como arr,

270
00:13:35,470 --> 00:13:38,370
é realmente só un punteiro
para o seu primeiro elemento.

271
00:13:38,370 --> 00:13:43,680
Entón, cando pasamos en arr alí, nós
son, en realidade, pasando un enlace.

272
00:13:43,680 --> 00:13:46,120
>> Do mesmo xeito que podemos facer isto--
Non necesariamente

273
00:13:46,120 --> 00:13:51,200
necesitamos gardar nosa tapón na pila.

274
00:13:51,200 --> 00:13:54,990
Tamén poderiamos reservar dinamicamente
Un buffer como este, utilizando malloc.

275
00:13:54,990 --> 00:13:57,340
Lembre, cando
reservar dinamicamente a memoria,

276
00:13:57,340 --> 00:14:00,550
estamos salvando o no
heap, non a pila.

277
00:14:00,550 --> 00:14:02,110
Senón que é un buffer.

278
00:14:02,110 --> 00:14:06,810
>> Aínda, neste caso, é
sostendo 640 bytes de información

279
00:14:06,810 --> 00:14:09,230
porque unha parella ocupa oito bytes.

280
00:14:09,230 --> 00:14:11,570
E nós estamos pedindo 80 deles.

281
00:14:11,570 --> 00:14:13,770
Queremos ter espazo
para prender 80 habitacións dobres.

282
00:14:13,770 --> 00:14:17,210
Entón 80 veces 8 é de 640 bytes de información.

283
00:14:17,210 --> 00:14:21,880
E iso é chamada a fread
recolección de 640 bytes de información

284
00:14:21,880 --> 00:14:27,770
a partir do ficheiro sinalado por
PTR e almacena-lo agora en arr2.

285
00:14:27,770 --> 00:14:32,770
>> Agora tamén podemos tratar fread
así como unha chamada a fgetc.

286
00:14:32,770 --> 00:14:37,140
Neste caso, nós estamos só tentando
obter un personaxe a partir do ficheiro.

287
00:14:37,140 --> 00:14:40,070
E nós non necesitamos un
array para conter un personaxe.

288
00:14:40,070 --> 00:14:43,170
Podemos simplemente almacena-lo
unha variable de carácter.

289
00:14:43,170 --> 00:14:46,390
>> O problema, porén, é que
cando só temos unha variable,

290
00:14:46,390 --> 00:14:50,290
necesitamos pasar na
dirección desa variable

291
00:14:50,290 --> 00:14:52,550
pois recorda que o
primeiro argumento para fread

292
00:14:52,550 --> 00:14:59,210
é un punteiro para a localización e memoria
onde queremos gardar a información.

293
00:14:59,210 --> 00:15:01,550
Unha vez máis, o nome dun
array é un punteiro.

294
00:15:01,550 --> 00:15:04,200
Entón, nós non temos que facer matriz e comercial.

295
00:15:04,200 --> 00:15:07,270
Pero c, o personaxe c
aquí, non é unha matriz.

296
00:15:07,270 --> 00:15:08,390
É só unha variable.

297
00:15:08,390 --> 00:15:11,840
E por iso necesitamos pasar un
c comercial para indicar

298
00:15:11,840 --> 00:15:15,350
que ese é o enderezo de onde queremos
para almacenar este un byte de información,

299
00:15:15,350 --> 00:15:20,479
este personaxe que
estamos recadando de PTR.

300
00:15:20,479 --> 00:15:22,270
Fwrite-- vou pasar por
este un pouco máis

301
00:15:22,270 --> 00:15:25,440
quickly-- é practicamente o
equivalente exacto de fread

302
00:15:25,440 --> 00:15:27,720
agás que é para a escrita
en vez de ler, só

303
00:15:27,720 --> 00:15:31,610
como o outro-- tivemos aberto
e próximo, obter un personaxe,

304
00:15:31,610 --> 00:15:32,530
escribir un personaxe.

305
00:15:32,530 --> 00:15:35,040
Agora é obter arbitraria
cantidade de información,

306
00:15:35,040 --> 00:15:37,170
cantidade arbitraria dereito de información.

307
00:15:37,170 --> 00:15:39,790
Así como antes, podemos
ter un array de 10 enteiros

308
00:15:39,790 --> 00:15:43,210
onde xa temos
información almacenada, quizais.

309
00:15:43,210 --> 00:15:46,580
>> Foi, probablemente, algunhas liñas de código
que debe ir entre estes dous

310
00:15:46,580 --> 00:15:49,990
onde cubrir con arr
algo significativo.

311
00:15:49,990 --> 00:15:51,880
Eu enche-lo con 10 enteiros diferentes.

312
00:15:51,880 --> 00:15:54,920
E no seu lugar, o que eu son
facendo está escribindo desde arr

313
00:15:54,920 --> 00:15:58,600
e traídos a información do arr.

314
00:15:58,600 --> 00:16:02,390
E eu estou tomando esta información
e poñer-lo para o arquivo.

315
00:16:02,390 --> 00:16:05,410
>> Entón, en vez de ser desde
o ficheiro para o buffer,

316
00:16:05,410 --> 00:16:08,790
agora imos de
o buffer no ficheiro.

317
00:16:08,790 --> 00:16:10,580
Entón, é todo o contrario.

318
00:16:10,580 --> 00:16:16,680
Entón, de novo, como antes, podemos
tamén teñen unha peza chea de memoria

319
00:16:16,680 --> 00:16:19,600
que temos dinamicamente
alocados e lidos desde ese

320
00:16:19,600 --> 00:16:21,570
e escribir que para o ficheiro.

321
00:16:21,570 --> 00:16:24,900
>> E tamén temos unha única variable
capaz de manter un byte

322
00:16:24,900 --> 00:16:27,200
de información, como un personaxe.

323
00:16:27,200 --> 00:16:29,830
Pero, de novo, cómpre pasar
a dirección desa variable

324
00:16:29,830 --> 00:16:31,840
cando queremos ler a partir del.

325
00:16:31,840 --> 00:16:35,280
Así, podemos escribir a información
atopamos nese enderezo

326
00:16:35,280 --> 00:16:39,050
para o punteiro do ficheiro, PTR.

327
00:16:39,050 --> 00:16:41,630
>> Hai moitas outras
gran arquivo E / funcións

328
00:16:41,630 --> 00:16:44,650
que facer moitas cousas ademais de
os que xa falamos sobre hoxe.

329
00:16:44,650 --> 00:16:46,450
Un par de os
pode considerar útil

330
00:16:46,450 --> 00:16:50,840
son fgets e fputs,
que son o equivalente

331
00:16:50,840 --> 00:16:56,190
de fgetc e fputc pero para a lectura
unha única cadea de caracteres dun ficheiro.

332
00:16:56,190 --> 00:16:59,020
No canto dun único personaxe,
ha ler unha cadea enteira.

333
00:16:59,020 --> 00:17:02,940
fprintf, que basicamente permite
usa printf para escribir no ficheiro.

334
00:17:02,940 --> 00:17:05,619
Entón, así como pode facer o
a substitución de variables usando

335
00:17:05,619 --> 00:17:09,900
a espazos reservados por cento i e
por cento d, e así por diante, con printf

336
00:17:09,900 --> 00:17:14,690
pode tomar de forma semellante a
secuencia de printf e imprimir algo

337
00:17:14,690 --> 00:17:16,800
como que a un arquivo.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- se ten un reprodutor de DVD
é a analoxía que eu costume usar aqui--

339
00:17:20,720 --> 00:17:23,109
é unha especie de como usar o seu
rebobinar e avanzar rapidamente

340
00:17:23,109 --> 00:17:25,819
botóns para mover a película.

341
00:17:25,819 --> 00:17:28,369
Do mesmo xeito, pode mover o ficheiro.

342
00:17:28,369 --> 00:17:30,250
Unha das cousas dentro
que a estrutura de arquivo

343
00:17:30,250 --> 00:17:34,270
c que crea para vostede é un indicador
de onde está no arquivo.

344
00:17:34,270 --> 00:17:36,420
Está no moi
comezando, no byte cero?

345
00:17:36,420 --> 00:17:39,290
Está vostede en byte 100,
1000 bytes, etc.?

346
00:17:39,290 --> 00:17:44,340
Pode usar fseek para mover arbitrariamente
ese indicador para adiante ou cara atrás.

347
00:17:44,340 --> 00:17:46,744
>> E ftell, de novo
semellante a un lector de DVD,

348
00:17:46,744 --> 00:17:49,660
é como un pequeno reloxo que di
cantos minutos e segundos

349
00:17:49,660 --> 00:17:52,480
están nunha película particular.

350
00:17:52,480 --> 00:17:56,990
Do mesmo xeito, ftell dille como
moitos bytes está no arquivo.

351
00:17:56,990 --> 00:18:00,210
feof é unha versión diferente
de detectar se ten

352
00:18:00,210 --> 00:18:01,700
chegou ao fin do ficheiro.

353
00:18:01,700 --> 00:18:03,600
E é unha función ferror
que pode usar

354
00:18:03,600 --> 00:18:06,959
para detectar se algo ten
ir traballo mal con un arquivo.

355
00:18:06,959 --> 00:18:08,750
De novo, iso é só
rabuñando a superficie.

356
00:18:08,750 --> 00:18:12,730
Aínda hai moito máis arquivo E /
funcións do estándar io.h.

357
00:18:12,730 --> 00:18:16,620
Pero iso probablemente vai te
comezou a traballar con punteiros de arquivo.

358
00:18:16,620 --> 00:18:17,640
Eu son Doug Lloyd.

359
00:18:17,640 --> 00:18:19,750
Este é CS50.

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