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

2
00:00:05,330 --> 00:00:07,870
>> ALTAVOZ: Hasta el momento, lo más probable
que la mayoría de sus programas

3
00:00:07,870 --> 00:00:10,170
han sido un poco efímero.

4
00:00:10,170 --> 00:00:13,310
Ejecutar un programa como Mario o codicioso.

5
00:00:13,310 --> 00:00:17,350
Lo hace algo, tal vez le pide
el usuario alguna información,

6
00:00:17,350 --> 00:00:20,400
imprimir alguna salida a la pantalla,
pero luego cuando el programa ha terminado,

7
00:00:20,400 --> 00:00:23,252
no hay realmente ninguna evidencia existe
Alguna vez se ha ejecutado en el primer lugar.

8
00:00:23,252 --> 00:00:25,960
Quiero decir, claro, que podría haber dejado
se abre en la ventana de terminal,

9
00:00:25,960 --> 00:00:29,770
pero si se borra la pantalla, hay
Realmente no hay evidencia de que existió.

10
00:00:29,770 --> 00:00:33,720
No tenemos un medio de almacenamiento
información persistente, la información

11
00:00:33,720 --> 00:00:36,890
que existe después de nuestra
programa ha dejado de funcionar,

12
00:00:36,890 --> 00:00:39,241
o nosotros no tenemos hasta este punto.

13
00:00:39,241 --> 00:00:41,490
Afortunadamente, sin embargo, hace c
nos proporcionan la capacidad

14
00:00:41,490 --> 00:00:44,220
para hacer esto mediante la implementación
algo que se llama

15
00:00:44,220 --> 00:00:48,330
un archivo, una estructura que básicamente
representa un archivo que quieres duplicar

16
00:00:48,330 --> 00:00:53,826
haga clic en el equipo, si estás
utilizado para un entorno gráfico de usuario.

17
00:00:53,826 --> 00:00:55,700
Generalmente cuando se trabaja
con c, en realidad estamos

18
00:00:55,700 --> 00:00:59,965
va a estar trabajando con
punteros a archivos-- archivo stars--

19
00:00:59,965 --> 00:01:02,090
a excepción de un poco
cuando hablamos de un par

20
00:01:02,090 --> 00:01:04,560
de las funciones que
trabajar con punteros de archivos.

21
00:01:04,560 --> 00:01:08,990
Usted no tiene que realmente han cavado
demasiado profundo en la comprensión de los punteros

22
00:01:08,990 --> 00:01:09,730
sí mismos.

23
00:01:09,730 --> 00:01:12,870
Hay un poco de pequeñísima
donde vamos a hablar de ellos,

24
00:01:12,870 --> 00:01:18,090
pero generalmente presentar punteros y
punteros, mientras que están relacionados entre sí,

25
00:01:18,090 --> 00:01:20,290
no son exactamente lo mismo.

26
00:01:20,290 --> 00:01:22,440
>> Ahora, ¿qué quiero decir cuando
Digo datos persistentes?

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

28
00:01:23,650 --> 00:01:25,232
¿Por qué nos importa eso?

29
00:01:25,232 --> 00:01:27,190
Decir, por ejemplo, que
se está ejecutando un programa de

30
00:01:27,190 --> 00:01:29,850
o que haya reescrito una
programa que es un juego,

31
00:01:29,850 --> 00:01:32,960
y desea hacer un seguimiento
de todos los movimientos del usuario

32
00:01:32,960 --> 00:01:36,620
de manera que tal vez si algo sale mal,
puede revisar el archivo después del partido.

33
00:01:36,620 --> 00:01:39,970
Eso es lo que queremos decir cuando
hablar de datos persistentes.

34
00:01:39,970 --> 00:01:43,930
>> En el curso de la ejecución de su
programa, se crea un archivo.

35
00:01:43,930 --> 00:01:45,680
Y cuando su programa
ha dejado de funcionar,

36
00:01:45,680 --> 00:01:48,689
ese archivo aún existe en el sistema.

37
00:01:48,689 --> 00:01:50,230
Y podemos verlo y examinarlo.

38
00:01:50,230 --> 00:01:53,670
Y para que el programa se establece en
han creado algunos datos persistentes,

39
00:01:53,670 --> 00:01:57,390
existen datos después del programa
ha terminado de ejecutarse.

40
00:01:57,390 --> 00:02:02,320
>> Ahora todas estas funciones que trabajan
con la creación de archivos y la manipulación

41
00:02:02,320 --> 00:02:04,940
de diversas formas
vivir en io.h estándar,

42
00:02:04,940 --> 00:02:08,210
que es un archivo de cabecera que
probablemente has estado libras

43
00:02:08,210 --> 00:02:10,910
incluyendo en la parte superior de bastante
mucho todos tus programas

44
00:02:10,910 --> 00:02:14,130
porque contiene una de las
la mayoría de funciones útiles para nosotros,

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

46
00:02:16,130 --> 00:02:20,400
Así que usted no tiene que golpear incluye
los archivos adicionales, probablemente,

47
00:02:20,400 --> 00:02:23,540
con el fin de trabajar con los punteros de archivos.

48
00:02:23,540 --> 00:02:29,980
>> Ahora, cada función de puntero solo archivo,
o de E / S, la salida de entrada cada archivo que he

49
00:02:29,980 --> 00:02:33,310
función, acepta como uno
de sus parámetros o entradas

50
00:02:33,310 --> 00:02:35,822
un pointer-- archivo excepto
para uno, fopen, que

51
00:02:35,822 --> 00:02:38,280
es lo que se utiliza para obtener el archivo
puntero en el primer lugar.

52
00:02:38,280 --> 00:02:41,010
Pero después de haber abierto la
archiva y se obtiene apuntadores de archivo,

53
00:02:41,010 --> 00:02:43,510
a continuación, puede pasar a ellos como
argumentos a las diversas funciones

54
00:02:43,510 --> 00:02:46,720
vamos a hablar acerca de
Hoy en día, así como muchos otros

55
00:02:46,720 --> 00:02:48,520
para que pueda trabajar con archivos.

56
00:02:48,520 --> 00:02:50,980
>> Así que hay seis bonita
los básicos comunes

57
00:02:50,980 --> 00:02:52,870
que vamos a hablar hoy.

58
00:02:52,870 --> 00:02:57,160
fopen y su compañera
función fclose, fgetc

59
00:02:57,160 --> 00:03:02,670
y su función compañero fputc,
y fread y su función compañero,

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

61
00:03:03,820 --> 00:03:05,180
Así que vamos a tener derecho a ella.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- qué hace?

63
00:03:07,050 --> 00:03:10,050
Bueno, se abre un archivo y
le da un apuntador de archivo a la misma,

64
00:03:10,050 --> 00:03:14,000
de modo que usted puede utilizar ese
presentar puntero como argumento

65
00:03:14,000 --> 00:03:16,730
a cualquiera de las otras funciones de E / S de archivos.

66
00:03:16,730 --> 00:03:19,100
Lo más importante
para recordar con fopen

67
00:03:19,100 --> 00:03:24,222
es que después de haber abierto la
presentar o hecho una llamada como el que aquí,

68
00:03:24,222 --> 00:03:26,930
es necesario comprobar para asegurarse
que el puntero que volviste

69
00:03:26,930 --> 00:03:28,320
no es igual a null.

70
00:03:28,320 --> 00:03:31,320
Si no has visto el video en
punteros, esto podría no tener sentido.

71
00:03:31,320 --> 00:03:35,639
Pero si usted trata de eliminar la referencia
un retiro de puntero nulo,

72
00:03:35,639 --> 00:03:38,180
su programa probablemente sufrirán
una segmentación [inaudible].

73
00:03:38,180 --> 00:03:40,540
Queremos asegurarnos de que
nos dieron una vuelta puntero legítimo.

74
00:03:40,540 --> 00:03:43,665
La gran mayoría de las veces lo haremos
han conseguido un puntero legítima vuelta

75
00:03:43,665 --> 00:03:45,280
y no va a ser un problema.

76
00:03:45,280 --> 00:03:46,760
>> Entonces, ¿cómo hacemos una llamada a fopen?

77
00:03:46,760 --> 00:03:48,051
Se ve muy parecido a esto.

78
00:03:48,051 --> 00:03:52,690
Estrella Archivo ptr-- ptr es un genérico
nombre de archivo pointer-- fopen

79
00:03:52,690 --> 00:03:57,300
y se pasa en dos cosas, un nombre de archivo
y una operación que queremos llevar a cabo.

80
00:03:57,300 --> 00:04:01,690
Así que puede ser que tengamos una llamada que se parece a
esto-- ptr estrella archivo 1 es igual a fopen

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

82
00:04:04,040 --> 00:04:07,020
Y la operación que he elegido es r.

83
00:04:07,020 --> 00:04:08,639
>> Entonces, ¿qué cree usted que r es aquí?

84
00:04:08,639 --> 00:04:11,180
¿Cuáles son los tipos de cosas que
podría ser capaz de hacer a los archivos?

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

86
00:04:13,760 --> 00:04:17,500
Así que r es la operación que nos
elegir cuando queremos leer un archivo.

87
00:04:17,500 --> 00:04:20,260
Así que, básicamente, cuando
hacemos una llamada como esta

88
00:04:20,260 --> 00:04:25,440
estar recibiendo nosotros un apuntador de archivo
de tal manera que pudiéramos luego leer la información

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

90
00:04:27,770 --> 00:04:34,190
>> Del mismo modo, podríamos abrir el archivo 2.txt
para escribir y para que podamos pasar ptr2,

91
00:04:34,190 --> 00:04:38,210
el puntero del archivo que he creado aquí,
como argumento para cualquier función que

92
00:04:38,210 --> 00:04:40,080
escribe información en un archivo.

93
00:04:40,080 --> 00:04:43,767
Y al igual que la escritura, hay
También la opción de anexar, a.

94
00:04:43,767 --> 00:04:45,600
La diferencia entre
escritura y añadiendo

95
00:04:45,600 --> 00:04:50,920
es que cuando se escribe en un archivo,
si usted hace una llamada a fopen para la escritura

96
00:04:50,920 --> 00:04:54,761
y ya existe ese archivo, que es
va a sobrescribir el archivo completo.

97
00:04:54,761 --> 00:04:56,510
Esto va a empezar
Al principio,

98
00:04:56,510 --> 00:04:58,820
borrando toda la información
eso es ya allí.

99
00:04:58,820 --> 00:05:02,210
>> Mientras que si la abres para anexar,
irá a la final del archivo

100
00:05:02,210 --> 00:05:04,340
si ya hay texto en
o la información en él,

101
00:05:04,340 --> 00:05:06,040
y continuación, se iniciará
escribir desde allí.

102
00:05:06,040 --> 00:05:08,570
Así que usted no perderá ninguno de los
la información que has hecho antes.

103
00:05:08,570 --> 00:05:12,110
Tanto si desea escribir o anexar
tipo de depende de la situación.

104
00:05:12,110 --> 00:05:16,840
Pero usted probablemente sabe lo que el
el funcionamiento adecuado es cuando llegue el momento.

105
00:05:16,840 --> 00:05:18,020
Así que eso es fopen.

106
00:05:18,020 --> 00:05:18,930
>> ¿Qué pasa con fclose?

107
00:05:18,930 --> 00:05:21,600
Bueno, bastante simple, fclose
Sólo acepta el puntero de archivo.

108
00:05:21,600 --> 00:05:24,000
Y como era de esperar,
que cierre ese archivo.

109
00:05:24,000 --> 00:05:29,270
Y una vez que hemos cerrado un archivo, no podemos
realizar más funciones de archivo de E / S,

110
00:05:29,270 --> 00:05:31,420
leer o escribir, en ese archivo.

111
00:05:31,420 --> 00:05:36,444
Tenemos que volver a abrir la
presentar otra vez con el fin

112
00:05:36,444 --> 00:05:38,610
seguir trabajando con
usando las funciones de E / S.

113
00:05:38,610 --> 00:05:41,520
Medios Así fclose hemos terminado
trabajar con este archivo.

114
00:05:41,520 --> 00:05:44,690
Y todo lo que necesitamos para pasar en es
el nombre de un apuntador de archivo.

115
00:05:44,690 --> 00:05:50,010
Así que en un par hace desliza, nos
fopened archivo de texto 1 punto para la lectura

116
00:05:50,010 --> 00:05:52,854
y asignamos que
presentar puntero a ptr1.

117
00:05:52,854 --> 00:05:55,020
Ahora hemos decidido que estamos
hecho la lectura de ese archivo.

118
00:05:55,020 --> 00:05:56,561
Nosotros no tenemos que hacer nada más con ella.

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

120
00:05:58,890 --> 00:06:01,950
Y de manera similar, que podría
fclose los otros.

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

122
00:06:02,450 --> 00:06:03,700
Así que ha de abrir y cerrar.

123
00:06:03,700 --> 00:06:05,780
Esos son los dos básica
iniciar operaciones.

124
00:06:05,780 --> 00:06:08,050
>> Ahora queremos realidad
hacer algunas cosas interesantes,

125
00:06:08,050 --> 00:06:11,940
y la primera función que vamos a
ver que va a hacer es fgetc--

126
00:06:11,940 --> 00:06:14,110
presentar obtener un carácter.

127
00:06:14,110 --> 00:06:17,350
Eso es lo que fgetc general
se traduciría en.

128
00:06:17,350 --> 00:06:20,190
Su objetivo en la vida es
leer el siguiente carácter,

129
00:06:20,190 --> 00:06:22,079
o si este es su muy
primera llamada a fgetc

130
00:06:22,079 --> 00:06:23,870
para un archivo en particular,
el primer carácter.

131
00:06:23,870 --> 00:06:26,210
Pero entonces después de eso,
se obtiene la siguiente,

132
00:06:26,210 --> 00:06:31,500
el siguiente carácter de ese archivo,
y la almacena en una variable de carácter.

133
00:06:31,500 --> 00:06:34,490
Como lo hemos hecho aquí,
char ch equivale fgetc,

134
00:06:34,490 --> 00:06:36,389
Aconteció en el nombre de un apuntador de archivo.

135
00:06:36,389 --> 00:06:38,180
Una vez más, es muy
importante aquí recordar

136
00:06:38,180 --> 00:06:41,430
que con el fin de tener
esta operación tenga éxito,

137
00:06:41,430 --> 00:06:45,690
el puntero del propio archivo Debió haber
ha abierto para lectura.

138
00:06:45,690 --> 00:06:50,589
No podemos leer un personaje de un archivo
puntero que abrimos para la escritura.

139
00:06:50,589 --> 00:06:52,630
Así que esa es una de las
limitaciones de fopen, ¿verdad?

140
00:06:52,630 --> 00:06:55,470
Tenemos que restringir
nosotros mismos sólo para realizar

141
00:06:55,470 --> 00:06:57,710
una operación con un puntero de archivo.

142
00:06:57,710 --> 00:07:00,220
Si quisiéramos leer y
escribir desde el mismo archivo,

143
00:07:00,220 --> 00:07:03,840
tendríamos abierto sendos
apuntadores de archivo a la misma file--

144
00:07:03,840 --> 00:07:05,670
uno para la lectura, uno para la escritura.

145
00:07:05,670 --> 00:07:08,400
>> Así que de nuevo, la única razón
Traigo que hasta ahora es

146
00:07:08,400 --> 00:07:11,920
porque si vamos a hacer una llamada
a fgetc, que debe de haber apuntador de archivo

147
00:07:11,920 --> 00:07:14,172
ha abierto para lectura.

148
00:07:14,172 --> 00:07:15,880
Y entonces bastante simple,
todo lo que necesitamos hacer

149
00:07:15,880 --> 00:07:17,546
es pasar en el nombre del fichero apuntado.

150
00:07:17,546 --> 00:07:21,060
Así char ch equivale ptr1 fgetc.

151
00:07:21,060 --> 00:07:23,200
>> Eso va a sacarnos
la siguiente character--

152
00:07:23,200 --> 00:07:25,575
o de nuevo, si este es el primero
el tiempo que hemos hecho esta llamada,

153
00:07:25,575 --> 00:07:29,750
la primera character-- de cualquier
archivo está apuntado por ptr1.

154
00:07:29,750 --> 00:07:32,210
Recordemos que ese era el archivo de texto 1 punto.

155
00:07:32,210 --> 00:07:36,490
Va a llegar el primer carácter de esa
y nosotros la almacenamos en la ch variable.

156
00:07:36,490 --> 00:07:37,941
Muy claro.

157
00:07:37,941 --> 00:07:40,190
Así que sólo hemos visto a las tres
funciones y ya tenemos

158
00:07:40,190 --> 00:07:43,070
puede hacer algo con buena pinta.

159
00:07:43,070 --> 00:07:46,320
>> Así que si tenemos esta capacidad
de conseguir un personaje

160
00:07:46,320 --> 00:07:48,943
y bucle it-- así que
continuar recibiendo caracteres

161
00:07:48,943 --> 00:07:51,390
desde un archivo de una y
una y over-- ahora

162
00:07:51,390 --> 00:07:54,500
puede leer cada
carácter de un archivo.

163
00:07:54,500 --> 00:07:58,670
Y si imprimimos todos los personajes
inmediatamente después de la leemos,

164
00:07:58,670 --> 00:08:01,960
ahora hemos leído de un archivo y
impresa su contenido a la pantalla.

165
00:08:01,960 --> 00:08:05,610
Hemos concatenados con eficacia
ese archivo en la pantalla.

166
00:08:05,610 --> 00:08:09,670
Y eso es lo que el
Linux comando cat hace.

167
00:08:09,670 --> 00:08:13,250
>> Si escribe gato en el nombre de archivo,
imprimirá todo el contenido

168
00:08:13,250 --> 00:08:15,160
del archivo en la ventana del terminal.

169
00:08:15,160 --> 00:08:19,010
Y así, este pequeño bucle de aquí,
sólo tres líneas de código,

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

171
00:08:23,270 --> 00:08:25,210
Así que esta sintaxis podría
mirar un poco extraño,

172
00:08:25,210 --> 00:08:26,670
pero esto es lo que está pasando aquí.

173
00:08:26,670 --> 00:08:31,460
Mientras ch equivale fgetc, ptr no es
igual a EOF-- es todo un bocado,

174
00:08:31,460 --> 00:08:34,669
pero vamos a romper justo
por lo que es claro en la sintaxis.

175
00:08:34,669 --> 00:08:37,169
He consolidó
por el bien de espacio,

176
00:08:37,169 --> 00:08:39,049
aunque es un poco
sintácticamente complicado.

177
00:08:39,049 --> 00:08:41,194
>> Así que esta parte de la derecha verde
ahora, ¿qué está haciendo?

178
00:08:41,194 --> 00:08:42,860
Bueno, eso es sólo nuestra llamada fgetc, ¿verdad?

179
00:08:42,860 --> 00:08:44,530
Hemos visto eso antes.

180
00:08:44,530 --> 00:08:49,500
Es la obtención de uno
carácter del archivo.

181
00:08:49,500 --> 00:08:53,220
Luego comparamos que
carácter contra EOF.

182
00:08:53,220 --> 00:08:57,470
EOF es un valor especial que es
se define en io.h estándar, que

183
00:08:57,470 --> 00:08:59,390
es el carácter de fin de archivo.

184
00:08:59,390 --> 00:09:03,450
Así que básicamente lo que va a pasar
este bucle se leerá un personaje,

185
00:09:03,450 --> 00:09:07,445
compararlo con EF, el
carácter de fin de archivo.

186
00:09:07,445 --> 00:09:10,070
Si no coinciden, por lo que no tenemos
llegado al final del archivo,

187
00:09:10,070 --> 00:09:11,490
vamos a imprimir ese carácter a cabo.

188
00:09:11,490 --> 00:09:13,740
Entonces vamos a ir de nuevo a la
principio del bucle de nuevo.

189
00:09:13,740 --> 00:09:18,310
Vamos a llegar a un personaje, comprobamos
contra EOF, imprimirlo, etc.

190
00:09:18,310 --> 00:09:21,094
Y así sucesivamente y así sucesivamente,
bucle a través de esa manera

191
00:09:21,094 --> 00:09:22,760
hasta que hemos llegado al final del archivo.

192
00:09:22,760 --> 00:09:24,593
Y entonces en ese momento,
habremos impresa

193
00:09:24,593 --> 00:09:26,210
a cabo la totalidad del contenido del archivo.

194
00:09:26,210 --> 00:09:29,450
Así que de nuevo, sólo hemos visto
fopen, fclose y fgetc

195
00:09:29,450 --> 00:09:34,950
y ya podemos duplicar
un comando de terminal de Linux.

196
00:09:34,950 --> 00:09:38,850
>> Como he dicho al principio,
tuvimos fgetc y fputc,

197
00:09:38,850 --> 00:09:41,860
y fputc era el compañero
función de fgetc.

198
00:09:41,860 --> 00:09:44,880
Y así, como se puede imaginar,
es la escritura equivalente.

199
00:09:44,880 --> 00:09:49,440
Se nos permite escribir una
solo carácter en un archivo.

200
00:09:49,440 --> 00:09:53,290
>> Una vez más, siendo la salvedad, justo
como lo fue con fgetc, el archivo

201
00:09:53,290 --> 00:09:56,660
que estamos escribiendo a debe haber sido
abierto para escribir o para anexar.

202
00:09:56,660 --> 00:10:00,820
Si tratamos y utilizamos fputc en un archivo
que hemos abierto para la lectura,

203
00:10:00,820 --> 00:10:02,760
vamos a sufrir
un poco de un error.

204
00:10:02,760 --> 00:10:04,440
Pero la llamada es bastante simple.

205
00:10:04,440 --> 00:10:08,000
el capital fputc Un ptr2, todo
que va a hacer es que es

206
00:10:08,000 --> 00:10:12,040
va a escribir la carta
en A en un archivo de 2 puntos

207
00:10:12,040 --> 00:10:14,760
texto, que era el nombre de la
archivo que abrimos y asignamos

208
00:10:14,760 --> 00:10:17,280
el puntero a PTR2.

209
00:10:17,280 --> 00:10:20,430
Así que vamos a escribir una
A mayúscula al archivo de texto 2 puntos.

210
00:10:20,430 --> 00:10:24,592
Y vamos a escribir una exclamación
apuntar a presentar 3 puntos

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

212
00:10:27,330 --> 00:10:29,730
Así que de nuevo, bastante sencillo aquí.

213
00:10:29,730 --> 00:10:32,727
>> Pero ahora podemos hacer otra cosa.

214
00:10:32,727 --> 00:10:34,560
Tenemos este ejemplo
solo nos íbamos más

215
00:10:34,560 --> 00:10:38,950
acerca de ser capaz de replicar el gato
Comandos de Linux, la que imprime

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

217
00:10:40,500 --> 00:10:43,510
Bueno, ahora que tenemos la capacidad
leer caracteres de archivos

218
00:10:43,510 --> 00:10:46,590
y escribir caracteres en archivos,
¿por qué no simplemente sustituimos que

219
00:10:46,590 --> 00:10:50,720
llamar a printf con una llamada a fputc.

220
00:10:50,720 --> 00:10:54,090
>> Y ahora que hemos duplicamos cp,
un comando muy básico Linux

221
00:10:54,090 --> 00:10:59,100
que hemos hablado largo camino
Hace en el Linux comandos vídeo.

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

223
00:11:01,070 --> 00:11:04,790
Estamos leyendo un personaje y luego estamos
escribir ese personaje a otro archivo.

224
00:11:04,790 --> 00:11:07,660
La lectura de un archivo, la escritura
a otro, una y otra

225
00:11:07,660 --> 00:11:11,350
y otra vez hasta que golpeamos EOF.

226
00:11:11,350 --> 00:11:14,250
Tenemos hasta el final de la
presentar estamos tratando de copiar.

227
00:11:14,250 --> 00:11:18,500
Y con esto habremos escrito todo
de los personajes necesitamos el archivo

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

229
00:11:19,500 --> 00:11:24,270
Así que esto es cp, el comando de copia de Linux.

230
00:11:24,270 --> 00:11:26,550
>> En el comienzo de
este video, yo tenía la advertencia

231
00:11:26,550 --> 00:11:29,840
que íbamos a hablar un
poco acerca de los punteros.

232
00:11:29,840 --> 00:11:32,480
Aquí está específicamente donde estamos
vamos a hablar de punteros

233
00:11:32,480 --> 00:11:34,800
además de presentar punteros.

234
00:11:34,800 --> 00:11:37,870
Así que esta función se ve un poco de miedo.

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

236
00:11:39,120 --> 00:11:40,430
Hay mucho que hacer aquí.

237
00:11:40,430 --> 00:11:42,760
Hay un montón de diferentes
colores y textos.

238
00:11:42,760 --> 00:11:47,100
Pero, en realidad, es sólo el
versión genérica de fgetc

239
00:11:47,100 --> 00:11:50,110
que nos permite obtener cualquier
cantidad de información.

240
00:11:50,110 --> 00:11:53,560
Puede ser un poco ineficiente si somos
obtener caracteres de uno en uno,

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

242
00:11:55,770 --> 00:12:00,230
¿No sería mejor para conseguir
100 a la vez o 500 a la vez?

243
00:12:00,230 --> 00:12:03,250
>> Bueno, fread y su función compañero
fwrite, lo que vamos a hablar de

244
00:12:03,250 --> 00:12:05,490
en un segundo, nos permiten hacer precisamente eso.

245
00:12:05,490 --> 00:12:08,480
Podemos leer una cantidad arbitraria
de información de un archivo

246
00:12:08,480 --> 00:12:10,290
y lo almacenamos en algún lugar temporalmente.

247
00:12:10,290 --> 00:12:12,980
En lugar de ser capaz de simplemente
encajar en una sola variable,

248
00:12:12,980 --> 00:12:15,790
que podríamos necesitar para almacenarlo en una matriz.

249
00:12:15,790 --> 00:12:19,980
Así, se pasa de cada cuatro
argumentos para fread-- un puntero

250
00:12:19,980 --> 00:12:23,940
a la ubicación donde estamos
va a almacenar la información,

251
00:12:23,940 --> 00:12:29,180
lo grande que cada unidad de información
será, cuántas unidades de información

252
00:12:29,180 --> 00:12:35,192
queremos adquirir, y desde
qué archivo queremos conseguirlos.

253
00:12:35,192 --> 00:12:37,150
Probablemente el mejor ilustrado
con un ejemplo aquí.

254
00:12:37,150 --> 00:12:41,640
Así que digamos que declaremos
un arreglo de 10 enteros.

255
00:12:41,640 --> 00:12:45,080
Nos hemos declarado en la
apilar arbitrariamente int arr 10.

256
00:12:45,080 --> 00:12:46,970
Así que eso es bastante sencillo.

257
00:12:46,970 --> 00:12:51,970
Ahora lo que estamos haciendo, aunque es el
frecall es que estamos tamaño de int leyendo

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

259
00:12:54,180 --> 00:12:59,040
Tamaño de int ser four-- eso es
el tamaño de un número entero en c.

260
00:12:59,040 --> 00:13:02,790
>> Así que lo que estamos haciendo es que estamos leyendo
40 bytes por valor de la información

261
00:13:02,790 --> 00:13:05,850
desde el archivo apuntado por ptr.

262
00:13:05,850 --> 00:13:08,600
Y estamos almacenando los
40 bytes en alguna parte

263
00:13:08,600 --> 00:13:12,080
donde hemos reservado
40 bytes por valor de la memoria.

264
00:13:12,080 --> 00:13:15,970
Afortunadamente, ya hemos hecho eso por
declarando arr, esa matriz allí mismo.

265
00:13:15,970 --> 00:13:19,770
Eso es capaz de mantener
10 unidades de cuatro bytes.

266
00:13:19,770 --> 00:13:22,860
Así que en total, que puede contener 40
bytes valor de la información.

267
00:13:22,860 --> 00:13:26,540
Y ahora estamos leyendo 40 bytes
de la información del archivo,

268
00:13:26,540 --> 00:13:30,330
y estamos almacenarlo en arr.

269
00:13:30,330 --> 00:13:35,470
>> Recordemos el video en punteros que
el nombre de una matriz, como arr,

270
00:13:35,470 --> 00:13:38,370
es en realidad un puntero
a su primer elemento.

271
00:13:38,370 --> 00:13:43,680
Así que cuando pasamos en arr allí,
son, de hecho, pasando en un puntero.

272
00:13:43,680 --> 00:13:46,120
>> Del mismo modo que podemos hacer esto--
No necesariamente

273
00:13:46,120 --> 00:13:51,200
deberá guardar nuestro buffer en la pila.

274
00:13:51,200 --> 00:13:54,990
También podríamos asignar dinámicamente
un tampón como este, usando malloc.

275
00:13:54,990 --> 00:13:57,340
Recuerde, cuando
asignar dinámicamente memoria,

276
00:13:57,340 --> 00:14:00,550
estamos ahorrando en el
montón, no la pila.

277
00:14:00,550 --> 00:14:02,110
Pero sigue siendo un búfer.

278
00:14:02,110 --> 00:14:06,810
>> Todavía, en este caso, es
la celebración de 640 bytes de información

279
00:14:06,810 --> 00:14:09,230
porque una doble toma hasta ocho bytes.

280
00:14:09,230 --> 00:14:11,570
Y estamos pidiendo 80 de ellos.

281
00:14:11,570 --> 00:14:13,770
Queremos tener espacio
para celebrar 80 dobles.

282
00:14:13,770 --> 00:14:17,210
Así que 80 veces 8 es información de 640 bytes.

283
00:14:17,210 --> 00:14:21,880
Y esa llamada a fread es
recogida de 640 bytes de información

284
00:14:21,880 --> 00:14:27,770
desde el archivo apuntado por
ptr y almacenar ahora en arr2.

285
00:14:27,770 --> 00:14:32,770
>> Ahora también podemos tratar fread
al igual que una llamada a fgetc.

286
00:14:32,770 --> 00:14:37,140
En este caso, sólo estamos tratando de
tener un carácter del archivo.

287
00:14:37,140 --> 00:14:40,070
Y no necesitamos un
matriz para sostener un personaje.

288
00:14:40,070 --> 00:14:43,170
Sólo podemos almacenarla en
una variable de carácter.

289
00:14:43,170 --> 00:14:46,390
>> La captura, sin embargo, es que
cuando sólo tenemos una variable,

290
00:14:46,390 --> 00:14:50,290
tenemos que pasar en el
dirección de esa variable

291
00:14:50,290 --> 00:14:52,550
porque recuerdo que el
primer argumento de fread

292
00:14:52,550 --> 00:14:59,210
es un puntero a la ubicación y la memoria
donde queremos almacenar la información.

293
00:14:59,210 --> 00:15:01,550
Una vez más, el nombre de una
array es un puntero.

294
00:15:01,550 --> 00:15:04,200
Así que no tenemos que hacer arsenal signo.

295
00:15:04,200 --> 00:15:07,270
Pero c, el carácter c
aquí, no es una matriz.

296
00:15:07,270 --> 00:15:08,390
Es sólo una variable.

297
00:15:08,390 --> 00:15:11,840
Y así tenemos que pasar una
c ampersand para indicar

298
00:15:11,840 --> 00:15:15,350
que esa es la dirección en la que queremos
para almacenar este un byte de información,

299
00:15:15,350 --> 00:15:20,479
éste carácter que
estamos recogiendo el ptr.

300
00:15:20,479 --> 00:15:22,270
Fwrite-- voy a ir a través
esto un poco más

301
00:15:22,270 --> 00:15:25,440
quickly-- es más o menos la
equivalente exacto de fread

302
00:15:25,440 --> 00:15:27,720
excepto que es para la escritura
en lugar de leer, simplemente

303
00:15:27,720 --> 00:15:31,610
como el otro-- que hemos tenido abierta
y cerca, consiga un carácter,

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

305
00:15:32,530 --> 00:15:35,040
Ahora es conseguir arbitraria
cantidad de información,

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

307
00:15:37,170 --> 00:15:39,790
Así que al igual que antes, podemos
tener un arreglo de 10 enteros

308
00:15:39,790 --> 00:15:43,210
donde ya tenemos
la información almacenada, tal vez.

309
00:15:43,210 --> 00:15:46,580
>> Fue probablemente algunas líneas de código
que debe ir entre estos dos

310
00:15:46,580 --> 00:15:49,990
donde lleno yo arr con
algo significativo.

311
00:15:49,990 --> 00:15:51,880
Lleno con 10 enteros diferentes.

312
00:15:51,880 --> 00:15:54,920
Y en su lugar, lo que estoy
haciendo es escribir desde arr

313
00:15:54,920 --> 00:15:58,600
y la recolección de la información de arr.

314
00:15:58,600 --> 00:16:02,390
Y yo voy a llevar esa información
y ponerlo en el archivo.

315
00:16:02,390 --> 00:16:05,410
>> Así que en lugar de que sea de
el archivo a la memoria intermedia,

316
00:16:05,410 --> 00:16:08,790
ahora estamos pasando de
el buffer en el archivo.

317
00:16:08,790 --> 00:16:10,580
Así que es justo lo contrario.

318
00:16:10,580 --> 00:16:16,680
Así que de nuevo, al igual que antes, podemos
también tienen un pedazo montón de memoria

319
00:16:16,680 --> 00:16:19,600
que hemos dinámicamente
asignado y leer a partir de ese

320
00:16:19,600 --> 00:16:21,570
y escribir que en el archivo.

321
00:16:21,570 --> 00:16:24,900
>> Y también tenemos una sola variable
capaz de contener un byte

322
00:16:24,900 --> 00:16:27,200
de la información, tal como un carácter.

323
00:16:27,200 --> 00:16:29,830
Pero, de nuevo, tenemos que pasar
la dirección de esa variable

324
00:16:29,830 --> 00:16:31,840
cuando queremos leer de él.

325
00:16:31,840 --> 00:16:35,280
Así que podemos escribir la información
nos encontramos en esa dirección

326
00:16:35,280 --> 00:16:39,050
al puntero de archivo, ptr.

327
00:16:39,050 --> 00:16:41,630
>> Hay un montón de otros
funciones de gran archivo de E / S

328
00:16:41,630 --> 00:16:44,650
que hacen varias cosas además
los que han hablado de la actualidad.

329
00:16:44,650 --> 00:16:46,450
Un par de los
que pueden interesarte

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

331
00:16:50,840 --> 00:16:56,190
de fgetc y fputc pero para la lectura
una única cadena de un archivo.

332
00:16:56,190 --> 00:16:59,020
En lugar de un solo carácter,
leerá una cadena entera.

333
00:16:59,020 --> 00:17:02,940
fprintf, lo que permite, básicamente,
utilizar printf para escribir en el archivo.

334
00:17:02,940 --> 00:17:05,619
Así que al igual que usted puede hacer lo
la sustitución de variables utilizando

335
00:17:05,619 --> 00:17:09,900
Los marcadores de posición por ciento iy
d ciento, y así sucesivamente, con printf

336
00:17:09,900 --> 00:17:14,690
puede igualmente tomar la
cadena printf e imprimir algo

337
00:17:14,690 --> 00:17:16,800
al igual que en un archivo.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- si usted tiene un reproductor de DVD
es la analogía que suelen utilizar aquí--

339
00:17:20,720 --> 00:17:23,109
es algo así como el uso de su
rebobinado y avance rápido

340
00:17:23,109 --> 00:17:25,819
para mover alrededor de la película.

341
00:17:25,819 --> 00:17:28,369
Del mismo modo, puedes moverte por el archivo.

342
00:17:28,369 --> 00:17:30,250
Una de las cosas en el interior
que la estructura de archivos

343
00:17:30,250 --> 00:17:34,270
que c crea para usted es un indicador
de dónde se encuentra en el archivo.

344
00:17:34,270 --> 00:17:36,420
¿Está usted en el mismo
comenzando, en el byte cero?

345
00:17:36,420 --> 00:17:39,290
¿Está usted en el byte 100,
byte de 1000, y así sucesivamente?

346
00:17:39,290 --> 00:17:44,340
Puede utilizar fseek mover arbitrariamente
ese indicador hacia adelante o hacia atrás.

347
00:17:44,340 --> 00:17:46,744
>> Y ftell, de nuevo
similar a un reproductor de DVD,

348
00:17:46,744 --> 00:17:49,660
es como un pequeño reloj que le dice
cuántos minutos y segundos le

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

350
00:17:52,480 --> 00:17:56,990
Del mismo modo, ftell le dice cómo
muchos bytes que están en el archivo.

351
00:17:56,990 --> 00:18:00,210
feof es una versión diferente
de detectar si usted tiene

352
00:18:00,210 --> 00:18:01,700
llegado al final del archivo.

353
00:18:01,700 --> 00:18:03,600
Y es una función ferror
que se puede utilizar

354
00:18:03,600 --> 00:18:06,959
para detectar si algo tiene
ido de trabajo mal con un archivo.

355
00:18:06,959 --> 00:18:08,750
Una vez más, esto es sólo
arañar la superficie.

356
00:18:08,750 --> 00:18:12,730
Todavía hay muchos más archivos de E / S
funciones en el estándar io.h.

357
00:18:12,730 --> 00:18:16,620
Pero esto probablemente conseguirle
comenzado a trabajar con punteros de archivos.

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

359
00:18:17,640 --> 00:18:19,750
Esto es CS50.

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