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

2
00:00:05,330 --> 00:00:07,870
>> SPEAKER: Finora, è probabile
che la maggior parte dei vostri programmi

3
00:00:07,870 --> 00:00:10,170
sono stati un po 'effimera.

4
00:00:10,170 --> 00:00:13,310
Si esegue un programma come Mario o Greedy.

5
00:00:13,310 --> 00:00:17,350
Si fa qualcosa, viene richiesto forse
all'utente alcune informazioni,

6
00:00:17,350 --> 00:00:20,400
stampare alcune output sullo schermo,
ma poi quando il programma è finito,

7
00:00:20,400 --> 00:00:23,252
non c'è davvero nessuna prova lì
è stato mai eseguito in primo luogo.

8
00:00:23,252 --> 00:00:25,960
Voglio dire, certo, si potrebbe avere lasciato
si apre nella finestra del terminale,

9
00:00:25,960 --> 00:00:29,770
ma se si cancella lo schermo, c'è
davvero nessuna prova che esistesse.

10
00:00:29,770 --> 00:00:33,720
Non abbiamo un mezzo di memorizzazione
informazioni persistente, informazioni

11
00:00:33,720 --> 00:00:36,890
che esiste dopo la nostra
programma ha smesso di correre,

12
00:00:36,890 --> 00:00:39,241
o non abbiamo fino a questo punto.

13
00:00:39,241 --> 00:00:41,490
Fortunatamente, però, c fa
ci forniscono la capacità

14
00:00:41,490 --> 00:00:44,220
per fare questo mediante l'attuazione di
qualcosa chiamato

15
00:00:44,220 --> 00:00:48,330
un file, una struttura che fondamentalmente
rappresenta un file che si desidera raddoppiare

16
00:00:48,330 --> 00:00:53,826
clicca sul vostro computer, se siete
utilizzato per un ambiente grafico.

17
00:00:53,826 --> 00:00:55,700
Generalmente quando si lavora
con c, siamo in realtà

18
00:00:55,700 --> 00:00:59,965
andando a lavorare con
puntatori a files-- lima stars--

19
00:00:59,965 --> 00:01:02,090
tranne per un po '
quando si parla di una coppia

20
00:01:02,090 --> 00:01:04,560
delle funzioni che
lavorare con i puntatori di file.

21
00:01:04,560 --> 00:01:08,990
Non è necessario avere davvero scavato
troppo in profondità per la comprensione dei puntatori

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

23
00:01:09,730 --> 00:01:12,870
C'è un po 'teeny
dove parleremo di loro,

24
00:01:12,870 --> 00:01:18,090
ma in genere di file e puntatori
puntatori, mentre interconnessi,

25
00:01:18,090 --> 00:01:20,290
non sono esattamente la stessa cosa.

26
00:01:20,290 --> 00:01:22,440
>> Ora che cosa voglio dire quando
Dico dati persistenti?

27
00:01:22,440 --> 00:01:23,650
Cosa sono i dati persistenti?

28
00:01:23,650 --> 00:01:25,232
Perché ci preoccupiamo a questo proposito?

29
00:01:25,232 --> 00:01:27,190
Diciamo, per esempio, che
si sta eseguendo un programma

30
00:01:27,190 --> 00:01:29,850
o hai riscritto un
programma che è un gioco,

31
00:01:29,850 --> 00:01:32,960
e si desidera tenere traccia
di tutte le mosse dell'utente

32
00:01:32,960 --> 00:01:36,620
in modo che forse se qualcosa va storto,
è possibile esaminare il file dopo la partita.

33
00:01:36,620 --> 00:01:39,970
Questo è ciò che intendiamo quando
parlare di dati persistenti.

34
00:01:39,970 --> 00:01:43,930
>> Nel corso di esecuzione il
il programma, viene creato un file.

35
00:01:43,930 --> 00:01:45,680
E quando il programma
ha smesso di correre,

36
00:01:45,680 --> 00:01:48,689
che file esiste ancora nel sistema.

37
00:01:48,689 --> 00:01:50,230
E possiamo guardare ed esaminarlo.

38
00:01:50,230 --> 00:01:53,670
E così che il programma sarà impostato
hanno creato alcuni dati persistenti,

39
00:01:53,670 --> 00:01:57,390
Esistono dati dopo il programma
ha terminato l'esecuzione.

40
00:01:57,390 --> 00:02:02,320
>> Ora tutte queste funzioni che funzionano
con la creazione di file e la manipolazione

41
00:02:02,320 --> 00:02:04,940
in vari modi
vivere in io.h norma,

42
00:02:04,940 --> 00:02:08,210
che è un file di intestazione che
probabilmente hai stato libbra

43
00:02:08,210 --> 00:02:10,910
compreso in cima piuttosto
gran parte tutti i programmi

44
00:02:10,910 --> 00:02:14,130
perché contiene uno dei
la maggior parte delle funzioni utili per noi,

45
00:02:14,130 --> 00:02:16,130
printf, che lascia anche
vive in io.h. norma

46
00:02:16,130 --> 00:02:20,400
Quindi non c'è bisogno di battere includere
eventuali file aggiuntivi probabilmente

47
00:02:20,400 --> 00:02:23,540
per lavorare con i puntatori di file.

48
00:02:23,540 --> 00:02:29,980
>> Ora ogni singola funzione puntatore a file,
o O, uscita di ogni singolo file di I / ingresso

49
00:02:29,980 --> 00:02:33,310
funzione accetta come uno
dei suoi parametri o ingressi

50
00:02:33,310 --> 00:02:35,822
un pointer-- file se non
per uno, fopen, che

51
00:02:35,822 --> 00:02:38,280
è quello che si utilizza per accedere al file
puntatore in primo luogo.

52
00:02:38,280 --> 00:02:41,010
Ma dopo aver aperto il
archiviare e si ottiene puntatori a file,

53
00:02:41,010 --> 00:02:43,510
si può quindi passare come
argomenti alle varie funzioni

54
00:02:43,510 --> 00:02:46,720
stiamo andando a parlare
oggi, così come molti altri

55
00:02:46,720 --> 00:02:48,520
in modo da poter lavorare con i file.

56
00:02:48,520 --> 00:02:50,980
>> Quindi ci sono sei abbastanza
quelli di base comuni

57
00:02:50,980 --> 00:02:52,870
che stiamo andando a parlare oggi.

58
00:02:52,870 --> 00:02:57,160
fopen e la sua compagna
la funzione fclose, fgetc

59
00:02:57,160 --> 00:03:02,670
e la sua funzione compagna fputc,
e fread e la sua funzione compagna,

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

61
00:03:03,820 --> 00:03:05,180
Quindi cerchiamo di ottenere a destra in esso.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- che cosa fa?

63
00:03:07,050 --> 00:03:10,050
Beh, si apre un file e
ti dà un puntatore a file ad esso,

64
00:03:10,050 --> 00:03:14,000
in modo da poter poi utilizzare tale
presentare puntatore come argomento

65
00:03:14,000 --> 00:03:16,730
qualsiasi funzioni di I / O l'altro file.

66
00:03:16,730 --> 00:03:19,100
La cosa più importante
da ricordare con fopen

67
00:03:19,100 --> 00:03:24,222
è che dopo aver aperto il
file o fatto una chiamata come quella qui,

68
00:03:24,222 --> 00:03:26,930
è necessario controllare per essere sicuri
che il puntatore che avete ottenuto indietro

69
00:03:26,930 --> 00:03:28,320
non è uguale a null.

70
00:03:28,320 --> 00:03:31,320
Se non avete visto il video su
puntatori, questo potrebbe non avere senso.

71
00:03:31,320 --> 00:03:35,639
Ma se si cerca di risolvere il riferimento
un richiamo puntatore nullo,

72
00:03:35,639 --> 00:03:38,180
il programma verrà probabilmente soffrirà
una segmentazione [incomprensibile].

73
00:03:38,180 --> 00:03:40,540
Vogliamo fare in modo che
ha ottenuto un puntatore indietro legittima.

74
00:03:40,540 --> 00:03:43,665
La stragrande maggioranza del tempo ci sarà
hanno ottenuto un puntatore legittima indietro

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

76
00:03:45,280 --> 00:03:46,760
>> Quindi, come possiamo fare una chiamata a fopen?

77
00:03:46,760 --> 00:03:48,051
Sembra molto simile a questo.

78
00:03:48,051 --> 00:03:52,690
Stella File ptr-- PTR essendo un generico
nome per il file pointer-- fopen

79
00:03:52,690 --> 00:03:57,300
e passiamo in due cose, un nome di file
e un'operazione vogliamo intraprendere.

80
00:03:57,300 --> 00:04:01,690
Così potremmo avere una chiamata che assomiglia
questo-- ptr file di stella 1 è uguale a fopen

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

82
00:04:04,040 --> 00:04:07,020
E l'operazione che ho scelto è r.

83
00:04:07,020 --> 00:04:08,639
>> Allora, cosa ne pensi r è qui?

84
00:04:08,639 --> 00:04:11,180
Quali sono i tipi di cose che abbiamo
potrebbe essere in grado di fare per i file?

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

86
00:04:13,760 --> 00:04:17,500
Così r è l'operazione che abbiamo
scegliere quando si vuole leggere un file.

87
00:04:17,500 --> 00:04:20,260
Quindi ci sarebbe fondamentalmente quando
facciamo una chiamata come questo

88
00:04:20,260 --> 00:04:25,440
essere sempre noi stessi un puntatore a file
in modo tale che si potrebbe quindi leggere informazioni

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

90
00:04:27,770 --> 00:04:34,190
>> Allo stesso modo, abbiamo potuto aprire il file 2.txt
per la scrittura e quindi possiamo passare ptr2,

91
00:04:34,190 --> 00:04:38,210
il puntatore del file che ho creato qui,
come argomento a qualsiasi funzione che

92
00:04:38,210 --> 00:04:40,080
scrive le informazioni in un file.

93
00:04:40,080 --> 00:04:43,767
E simile alla scrittura, c'è
anche la possibilità di aggiungere, a.

94
00:04:43,767 --> 00:04:45,600
La differenza tra
scrittura e aggiungendo

95
00:04:45,600 --> 00:04:50,920
è che quando si scrive in un file,
se si effettua una chiamata di fopen per la scrittura

96
00:04:50,920 --> 00:04:54,761
e tale file esiste già, è
andando a sovrascrivere l'intero file.

97
00:04:54,761 --> 00:04:56,510
Sta per iniziare
proprio all'inizio,

98
00:04:56,510 --> 00:04:58,820
eliminando tutte le informazioni
che è già lì.

99
00:04:58,820 --> 00:05:02,210
>> Mentre se lo si apre per l'aggiunta,
andrà alla fine del file

100
00:05:02,210 --> 00:05:04,340
se c'è già testo
o le informazioni in esso,

101
00:05:04,340 --> 00:05:06,040
e sarà quindi avviare
la scrittura da lì.

102
00:05:06,040 --> 00:05:08,570
In modo da non perdere nessuna delle
informazioni che hai fatto prima.

103
00:05:08,570 --> 00:05:12,110
Se si desidera scrivere o aggiungere
sorta di dipende dalla situazione.

104
00:05:12,110 --> 00:05:16,840
Ma probabilmente conoscerete ciò che il
operazione destra è quando sarà il momento.

105
00:05:16,840 --> 00:05:18,020
Ecco, questo è fopen.

106
00:05:18,020 --> 00:05:18,930
>> Che dire fclose?

107
00:05:18,930 --> 00:05:21,600
Beh, abbastanza semplicemente, fclose
solo accetta il puntatore del file.

108
00:05:21,600 --> 00:05:24,000
E come ci si potrebbe aspettare,
si chiude il file.

109
00:05:24,000 --> 00:05:29,270
E una volta che abbiamo chiuso un file, non possiamo
eseguire qualsiasi altro file di funzioni di I / O,

110
00:05:29,270 --> 00:05:31,420
lettura o la scrittura, su quel file.

111
00:05:31,420 --> 00:05:36,444
Dobbiamo riaprire il
file di un altro tempo, al fine

112
00:05:36,444 --> 00:05:38,610
continuare a lavorare con
utilizzando le funzioni di I / O.

113
00:05:38,610 --> 00:05:41,520
Mezzi così fclose abbiamo finito
lavorare con questo file.

114
00:05:41,520 --> 00:05:44,690
E tutti abbiamo bisogno di passare in è
il nome di un puntatore file.

115
00:05:44,690 --> 00:05:50,010
Così in un paio scorre fa, abbiamo
fopened file di testo 1 punto per la lettura

116
00:05:50,010 --> 00:05:52,854
e abbiamo assegnato che
il file puntatore ptr1.

117
00:05:52,854 --> 00:05:55,020
Ora abbiamo deciso che siamo
fatto leggere da quel file.

118
00:05:55,020 --> 00:05:56,561
Non abbiamo bisogno di fare di più con esso.

119
00:05:56,561 --> 00:05:58,890
Possiamo ptr1 appena fclose.

120
00:05:58,890 --> 00:06:01,950
E allo stesso modo, potremmo
fclose gli altri.

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

122
00:06:02,450 --> 00:06:03,700
Ecco, questo è l'apertura e la chiusura.

123
00:06:03,700 --> 00:06:05,780
Questi sono i due di base
le operazioni di partenza.

124
00:06:05,780 --> 00:06:08,050
>> Ora vogliamo realmente
fare alcune cose interessanti,

125
00:06:08,050 --> 00:06:11,940
e la prima funzione che faremo
vedere che farà questo è fgetc--

126
00:06:11,940 --> 00:06:14,110
presentare ottenere un carattere.

127
00:06:14,110 --> 00:06:17,350
Questo è ciò che generalmente fgetc
si tradurrebbe a.

128
00:06:17,350 --> 00:06:20,190
Il suo obiettivo nella vita è quello
leggere il carattere successivo,

129
00:06:20,190 --> 00:06:22,079
o se questo è il vostro molto
prima chiamata a fgetc

130
00:06:22,079 --> 00:06:23,870
per un file particolare,
il primo carattere.

131
00:06:23,870 --> 00:06:26,210
Ma poi, dopo che,
si ottiene il prossimo,

132
00:06:26,210 --> 00:06:31,500
il carattere molto prossimo di quel file,
e lo memorizza in una variabile di carattere.

133
00:06:31,500 --> 00:06:34,490
Come abbiamo fatto qui,
char ch uguale a fgetc,

134
00:06:34,490 --> 00:06:36,389
passare il nome di un puntatore file.

135
00:06:36,389 --> 00:06:38,180
Anche in questo caso, è molto
importante da ricordare

136
00:06:38,180 --> 00:06:41,430
che per avere
l'operazione riesce,

137
00:06:41,430 --> 00:06:45,690
il puntatore del file stesso deve aver
aperto in scrittura.

138
00:06:45,690 --> 00:06:50,589
Non possiamo leggere un carattere da un file
puntatore che abbiamo aperto per la scrittura.

139
00:06:50,589 --> 00:06:52,630
Ecco, questo è uno dei
limitazioni di fopen, giusto?

140
00:06:52,630 --> 00:06:55,470
Dobbiamo limitare
a noi stessi di eseguire solo

141
00:06:55,470 --> 00:06:57,710
una operazione con un puntatore al file.

142
00:06:57,710 --> 00:07:00,220
Se volessimo leggere e
scrivere dallo stesso file,

143
00:07:00,220 --> 00:07:03,840
avremmo aperto due distinti
puntatori file nella stessa file--

144
00:07:03,840 --> 00:07:05,670
uno per la lettura, uno per la scrittura.

145
00:07:05,670 --> 00:07:08,400
>> Così ancora una volta, l'unica ragione
Io porto che ora è

146
00:07:08,400 --> 00:07:11,920
perché se stiamo andando a fare una chiamata
a fgetc, che puntatore al file deve aver

147
00:07:11,920 --> 00:07:14,172
aperto in scrittura.

148
00:07:14,172 --> 00:07:15,880
E poi abbastanza semplicemente,
tutto quello che dobbiamo fare

149
00:07:15,880 --> 00:07:17,546
è passare nel nome del puntatore del file.

150
00:07:17,546 --> 00:07:21,060
Così ch char uguale ptr1 fgetc.

151
00:07:21,060 --> 00:07:23,200
>> Che sta per ottenere noi
il prossimo character--

152
00:07:23,200 --> 00:07:25,575
o ancora, se questa è la prima
tempo abbiamo fatto questo appello,

153
00:07:25,575 --> 00:07:29,750
la prima character-- di qualsiasi
file viene puntato da ptr1.

154
00:07:29,750 --> 00:07:32,210
Ricordiamo che quello era il file di testo 1 punto.

155
00:07:32,210 --> 00:07:36,490
Si otterrà il primo carattere di quella
e noi memorizziamo nella variabile ch.

156
00:07:36,490 --> 00:07:37,941
Abbastanza semplice.

157
00:07:37,941 --> 00:07:40,190
Così abbiamo guardato solo alle tre
funzioni e già siamo

158
00:07:40,190 --> 00:07:43,070
può fare qualcosa abbastanza carino.

159
00:07:43,070 --> 00:07:46,320
>> Quindi, se prendiamo questa capacità
di ottenere un carattere

160
00:07:46,320 --> 00:07:48,943
e noi ciclo it-- quindi abbiamo
continuare a ottenere caratteri

161
00:07:48,943 --> 00:07:51,390
da un file più e
sopra e over-- ora siamo

162
00:07:51,390 --> 00:07:54,500
in grado di leggere ogni singola
carattere di un file.

163
00:07:54,500 --> 00:07:58,670
E se stampiamo ogni personaggio
subito dopo la leggiamo,

164
00:07:58,670 --> 00:08:01,960
ora abbiamo letto da un file e
stampato il suo contenuto sullo schermo.

165
00:08:01,960 --> 00:08:05,610
Abbiamo effettivamente concatenati
il file sullo schermo.

166
00:08:05,610 --> 00:08:09,670
Ed è quello che il
Comando di Linux gatto fa.

167
00:08:09,670 --> 00:08:13,250
>> Se si digita gatto nel nome del file che,
stamperà l'intero contenuto

168
00:08:13,250 --> 00:08:15,160
del file nella finestra del terminale.

169
00:08:15,160 --> 00:08:19,010
E così questo piccolo ciclo qui,
solo tre linee di codice,

170
00:08:19,010 --> 00:08:23,270
ma duplica in modo efficace
il comando cat Linux.

171
00:08:23,270 --> 00:08:25,210
Quindi questa sintassi potrebbe
guardare un po 'strano,

172
00:08:25,210 --> 00:08:26,670
ma ecco cosa sta succedendo qui.

173
00:08:26,670 --> 00:08:31,460
Mentre ch uguale a fgetc, ptr non è
pari a EOF-- è un intero boccone,

174
00:08:31,460 --> 00:08:34,669
ma cerchiamo di scomposizione solo
quindi è chiaro sulla sintassi.

175
00:08:34,669 --> 00:08:37,169
Ho consolidati, essa
per motivi di spazio,

176
00:08:37,169 --> 00:08:39,049
anche se è un po '
sintatticamente difficile.

177
00:08:39,049 --> 00:08:41,194
>> Quindi questa parte a destra verde
Ora, che cosa sta facendo?

178
00:08:41,194 --> 00:08:42,860
Beh, questo è solo il nostro appello fgetc, giusto?

179
00:08:42,860 --> 00:08:44,530
Abbiamo visto che prima.

180
00:08:44,530 --> 00:08:49,500
E 'ottenere uno
carattere dal file.

181
00:08:49,500 --> 00:08:53,220
Poi si confronta che
carattere contro EOF.

182
00:08:53,220 --> 00:08:57,470
EOF è un valore speciale che è
definito io.h standard, che

183
00:08:57,470 --> 00:08:59,390
è la fine del carattere file.

184
00:08:59,390 --> 00:09:03,450
Quindi, in pratica quello che sta per succedere
è questo ciclo sarà letto un carattere,

185
00:09:03,450 --> 00:09:07,445
confrontarlo EOF, la
carattere di fine file.

186
00:09:07,445 --> 00:09:10,070
Se non corrispondono, quindi non ci siamo
raggiunta la fine del file,

187
00:09:10,070 --> 00:09:11,490
noi lo stamperemo quel personaggio fuori.

188
00:09:11,490 --> 00:09:13,740
Poi torneremo al
all'inizio del ciclo di nuovo.

189
00:09:13,740 --> 00:09:18,310
Avremo un personaggio, controlliamo
contro EOF, stamparlo, e così via

190
00:09:18,310 --> 00:09:21,094
e così via e così via,
scorrendo in modo che

191
00:09:21,094 --> 00:09:22,760
fino a quando abbiamo raggiunto la fine del file.

192
00:09:22,760 --> 00:09:24,593
E poi da quel punto,
avremo stampato

193
00:09:24,593 --> 00:09:26,210
l'intero contenuto del file.

194
00:09:26,210 --> 00:09:29,450
Così ancora una volta, abbiamo visto solo
fopen, fclose, e fgetc

195
00:09:29,450 --> 00:09:34,950
e già possiamo duplicare
un comando da terminale Linux.

196
00:09:34,950 --> 00:09:38,850
>> Come ho detto all'inizio,
abbiamo avuto fgetc e fputc,

197
00:09:38,850 --> 00:09:41,860
e fputc era la compagna
funzione fgetc.

198
00:09:41,860 --> 00:09:44,880
E così, come si potrebbe immaginare,
è l'equivalente di scrittura.

199
00:09:44,880 --> 00:09:49,440
Esso ci permette di scrivere un
singolo carattere in un file.

200
00:09:49,440 --> 00:09:53,290
>> Anche in questo caso, l'avvertenza di essere, semplicemente
come è stato con fgetc, il file

201
00:09:53,290 --> 00:09:56,660
che stiamo scrivendo a Dev'essere stato
aperto per la scrittura o per l'aggiunta.

202
00:09:56,660 --> 00:10:00,820
Se cerchiamo e usiamo fputc su un file
che abbiamo aperto per la lettura,

203
00:10:00,820 --> 00:10:02,760
stiamo andando a soffrire
un po 'di un errore.

204
00:10:02,760 --> 00:10:04,440
Ma la chiamata è piuttosto semplice.

205
00:10:04,440 --> 00:10:08,000
capitale fputc Un ptr2, tutto
che sta per fare è che è

206
00:10:08,000 --> 00:10:12,040
intenzione di scrivere la lettera
in A in file di 2 punti

207
00:10:12,040 --> 00:10:14,760
testo, che era il nome del
file abbiamo aperto e assegnato

208
00:10:14,760 --> 00:10:17,280
il puntatore ptr2.

209
00:10:17,280 --> 00:10:20,430
Così stiamo andando a dare una
A maiuscola in un file di testo 2 punti.

210
00:10:20,430 --> 00:10:24,592
E noi scriveremo un'esclamazione
puntare al file 3 punti

211
00:10:24,592 --> 00:10:27,330
il testo, che è stato puntato da ptr3.

212
00:10:27,330 --> 00:10:29,730
Quindi, di nuovo, abbastanza semplice qui.

213
00:10:29,730 --> 00:10:32,727
>> Ma ora siamo in grado di fare un'altra cosa.

214
00:10:32,727 --> 00:10:34,560
Abbiamo questo esempio
siamo stati solo andando oltre

215
00:10:34,560 --> 00:10:38,950
di essere in grado di replicare il gatto
Comando di Linux, quello che stampa

216
00:10:38,950 --> 00:10:40,500
allo schermo.

217
00:10:40,500 --> 00:10:43,510
Bene, ora che abbiamo la capacità
a leggere i caratteri da file

218
00:10:43,510 --> 00:10:46,590
e scrivere i caratteri di file,
perché non solo che sostituiamo

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

220
00:10:50,720 --> 00:10:54,090
>> E ora abbiamo duplicato cp,
un comando molto semplice Linux

221
00:10:54,090 --> 00:10:59,100
che abbiamo parlato di cammino lungo
fa nel comandi Linux video.

222
00:10:59,100 --> 00:11:01,070
ABBIAMO efficacemente
duplicato che proprio qui.

223
00:11:01,070 --> 00:11:04,790
Stiamo leggendo una lettera e poi siamo
scrivendo che personaggio a un altro file.

224
00:11:04,790 --> 00:11:07,660
La lettura da un file, la scrittura
ad un altro, più e più

225
00:11:07,660 --> 00:11:11,350
e più volte fino a quando ci ha colpito EOF.

226
00:11:11,350 --> 00:11:14,250
Dobbiamo alla fine del
il file che stiamo cercando di copiare.

227
00:11:14,250 --> 00:11:18,500
E con questo avremo smorfie
dei personaggi abbiamo bisogno di file

228
00:11:18,500 --> 00:11:19,500
che stiamo scrivendo a.

229
00:11:19,500 --> 00:11:24,270
Quindi questo è cp, il comando di copia di Linux.

230
00:11:24,270 --> 00:11:26,550
>> All'inizio di
questo video, ho avuto l'avvertenza

231
00:11:26,550 --> 00:11:29,840
che avremmo parlato di un
po 'di puntatori.

232
00:11:29,840 --> 00:11:32,480
Qui è in particolare dove siamo
andando a parlare di puntatori

233
00:11:32,480 --> 00:11:34,800
oltre al file puntatori.

234
00:11:34,800 --> 00:11:37,870
Quindi, questa funzione sembra un po 'spaventoso.

235
00:11:37,870 --> 00:11:39,120
E 'ottenuto diversi parametri.

236
00:11:39,120 --> 00:11:40,430
Ci sono un sacco di cose qui.

237
00:11:40,430 --> 00:11:42,760
C'è un sacco di diverso
colori e testi.

238
00:11:42,760 --> 00:11:47,100
Ma in realtà, è solo il
versione generica di fgetc

239
00:11:47,100 --> 00:11:50,110
che ci permette di ottenere qualsiasi
quantità di informazioni.

240
00:11:50,110 --> 00:11:53,560
Può essere un po 'inefficiente se siamo
ottenendo caratteri uno alla volta,

241
00:11:53,560 --> 00:11:55,770
scorrendo il file
un carattere alla volta.

242
00:11:55,770 --> 00:12:00,230
Non sarebbe bello per ottenere
100 alla volta o 500 alla volta?

243
00:12:00,230 --> 00:12:03,250
>> Beh, fread e la sua funzione compagna
fwrite, che parleremo

244
00:12:03,250 --> 00:12:05,490
in un secondo, ci permettono di fare proprio questo.

245
00:12:05,490 --> 00:12:08,480
Possiamo leggere una quantità arbitraria
di informazioni da un file

246
00:12:08,480 --> 00:12:10,290
e immagazziniamo da qualche parte temporaneamente.

247
00:12:10,290 --> 00:12:12,980
Invece di essere in grado di solo
inserirla in una singola variabile,

248
00:12:12,980 --> 00:12:15,790
potremmo aver bisogno di conservarlo in un array.

249
00:12:15,790 --> 00:12:19,980
E così, passiamo in quattro
argomenti per fread-- un puntatore

250
00:12:19,980 --> 00:12:23,940
alla posizione in cui siamo
andando a memorizzare le informazioni,

251
00:12:23,940 --> 00:12:29,180
quanto grande ogni unità di informazioni
sarà il numero di unità di informazioni

252
00:12:29,180 --> 00:12:35,192
vogliamo acquisire, e da
quale file vogliamo ottenere loro.

253
00:12:35,192 --> 00:12:37,150
Probabilmente meglio illustrato
con un esempio qui.

254
00:12:37,150 --> 00:12:41,640
Quindi diciamo che dichiariamo
un array di 10 interi.

255
00:12:41,640 --> 00:12:45,080
Abbiamo appena dichiarato sul
impilare arbitrariamente int arr 10.

256
00:12:45,080 --> 00:12:46,970
Ecco, questo è abbastanza semplice.

257
00:12:46,970 --> 00:12:51,970
Ora quello che stiamo facendo è però il
frecall viene stiamo leggendo dimensioni di int

258
00:12:51,970 --> 00:12:54,180
volte 10 byte di informazioni.

259
00:12:54,180 --> 00:12:59,040
Dimensioni di int essere four-- che è
le dimensioni di un intero c.

260
00:12:59,040 --> 00:13:02,790
>> Quindi quello che stiamo facendo è che stiamo leggendo
40 byte valore delle informazioni

261
00:13:02,790 --> 00:13:05,850
dal file puntato da ptr.

262
00:13:05,850 --> 00:13:08,600
E stiamo memorizzare quelle
40 byte da qualche parte

263
00:13:08,600 --> 00:13:12,080
dove abbiamo messo da parte
40 byte per un valore di memoria.

264
00:13:12,080 --> 00:13:15,970
Per fortuna, abbiamo già fatto che,
dichiarando arr, tale matrice proprio lì.

265
00:13:15,970 --> 00:13:19,770
Che è capace di partecipazione
10 unità a quattro byte.

266
00:13:19,770 --> 00:13:22,860
Quindi, in totale, che può contenere 40
byte di valore di dati.

267
00:13:22,860 --> 00:13:26,540
Ed ora stiamo leggendo 40 byte
delle informazioni dal file,

268
00:13:26,540 --> 00:13:30,330
e stiamo riporlo in arr.

269
00:13:30,330 --> 00:13:35,470
>> Ricordiamo dal video su puntatori che
il nome di una matrice, come arr,

270
00:13:35,470 --> 00:13:38,370
è in realtà solo un puntatore
al suo primo elemento.

271
00:13:38,370 --> 00:13:43,680
Così, quando si passa in arr lì, abbiamo
sono, infatti, passando in un puntatore.

272
00:13:43,680 --> 00:13:46,120
>> Allo stesso modo possiamo fare questo--
non lo facciamo necessariamente

273
00:13:46,120 --> 00:13:51,200
necessità di salvare il nostro buffer sullo stack.

274
00:13:51,200 --> 00:13:54,990
Potremmo anche allocare dinamicamente
un tampone come questa, usando malloc.

275
00:13:54,990 --> 00:13:57,340
Ricordate, quando si
allocare dinamicamente la memoria,

276
00:13:57,340 --> 00:14:00,550
stiamo risparmiando sul
mucchio, non lo stack.

277
00:14:00,550 --> 00:14:02,110
Ma è ancora un buffer.

278
00:14:02,110 --> 00:14:06,810
>> E ancora, in questo caso, è
tenendo 640 byte di informazioni

279
00:14:06,810 --> 00:14:09,230
perché un doppio occupa otto byte.

280
00:14:09,230 --> 00:14:11,570
E stiamo chiedendo per 80 di loro.

281
00:14:11,570 --> 00:14:13,770
Vogliamo avere spazio
per contenere 80 camere doppie.

282
00:14:13,770 --> 00:14:17,210
Così 80 volte 8 sono informazioni 640 byte.

283
00:14:17,210 --> 00:14:21,880
E che è chiamata a fread
raccogliere 640 byte di informazioni

284
00:14:21,880 --> 00:14:27,770
dal file puntato da
ptr e riporlo ora in arr2.

285
00:14:27,770 --> 00:14:32,770
>> Ora possiamo anche trattare fread
proprio come una chiamata a fgetc.

286
00:14:32,770 --> 00:14:37,140
In questo caso, stiamo solo cercando di
ottenere un carattere dal file.

287
00:14:37,140 --> 00:14:40,070
E non abbiamo bisogno di un
array per contenere un carattere.

288
00:14:40,070 --> 00:14:43,170
Possiamo solo conservarla in
una variabile di carattere.

289
00:14:43,170 --> 00:14:46,390
>> La cattura, però, è che
quando non ci resta che una variabile,

290
00:14:46,390 --> 00:14:50,290
occorre passare in
indirizzo di quella variabile

291
00:14:50,290 --> 00:14:52,550
perché ricordo che il
primo argomento a fread

292
00:14:52,550 --> 00:14:59,210
è un puntatore alla posizione e alla memoria
dove vogliamo memorizzare le informazioni.

293
00:14:59,210 --> 00:15:01,550
Anche in questo caso, il nome di un
array è un puntatore.

294
00:15:01,550 --> 00:15:04,200
Quindi non abbiamo bisogno di fare di matrice commerciale.

295
00:15:04,200 --> 00:15:07,270
Ma c, il carattere c
qui, non è un array.

296
00:15:07,270 --> 00:15:08,390
E 'solo una variabile.

297
00:15:08,390 --> 00:15:11,840
E così abbiamo bisogno di passare un
commerciale c per indicare

298
00:15:11,840 --> 00:15:15,350
che questo è l'indirizzo dove si vuole
memorizzare questa un byte di informazioni,

299
00:15:15,350 --> 00:15:20,479
questo personaggio che
stiamo raccogliendo da ptr.

300
00:15:20,479 --> 00:15:22,270
Fwrite-- Andrò attraverso
questo un po 'di più

301
00:15:22,270 --> 00:15:25,440
quickly-- è praticamente la
esatto equivalente di fread

302
00:15:25,440 --> 00:15:27,720
tranne che è per la scrittura
invece di leggere, appena

303
00:15:27,720 --> 00:15:31,610
come il other-- abbiamo avuto aperta
e vicino, ottenere un carattere,

304
00:15:31,610 --> 00:15:32,530
scrivere un personaggio.

305
00:15:32,530 --> 00:15:35,040
Ora è ottenere arbitrario
quantità di informazioni,

306
00:15:35,040 --> 00:15:37,170
giusta quantità arbitraria di dati.

307
00:15:37,170 --> 00:15:39,790
Quindi, proprio come prima, possiamo
avere un array di 10 interi

308
00:15:39,790 --> 00:15:43,210
dove abbiamo già
informazioni memorizzate, forse.

309
00:15:43,210 --> 00:15:46,580
>> E 'stato probabilmente alcune righe di codice
che dovrebbe andare tra questi due

310
00:15:46,580 --> 00:15:49,990
dove riempio con arr
qualcosa di significativo.

311
00:15:49,990 --> 00:15:51,880
Lo riempio con 10 diversi numeri interi.

312
00:15:51,880 --> 00:15:54,920
E invece, quello che sto
facendo sta scrivendo da arr

313
00:15:54,920 --> 00:15:58,600
e la raccolta delle informazioni da arr.

314
00:15:58,600 --> 00:16:02,390
E sto prendendo questa informazione
e metterlo nel file.

315
00:16:02,390 --> 00:16:05,410
>> Così, invece di essere da
il file al buffer,

316
00:16:05,410 --> 00:16:08,790
ora stiamo passando da
il buffer al file.

317
00:16:08,790 --> 00:16:10,580
Quindi è proprio il contrario.

318
00:16:10,580 --> 00:16:16,680
Quindi, di nuovo, come prima, possiamo
hanno anche un pezzo di memoria heap

319
00:16:16,680 --> 00:16:19,600
che abbiamo dinamicamente
assegnato e leggere da quella

320
00:16:19,600 --> 00:16:21,570
e scrivere che il file.

321
00:16:21,570 --> 00:16:24,900
>> E abbiamo anche una singola variabile
in grado di contenere un byte

322
00:16:24,900 --> 00:16:27,200
di informazioni, come un carattere.

323
00:16:27,200 --> 00:16:29,830
Ma ancora una volta, abbiamo bisogno di passare a
l'indirizzo di quella variabile

324
00:16:29,830 --> 00:16:31,840
quando vogliamo leggere da esso.

325
00:16:31,840 --> 00:16:35,280
Quindi possiamo scrivere le informazioni
troviamo a quell'indirizzo

326
00:16:35,280 --> 00:16:39,050
per il puntatore del file, ptr.

327
00:16:39,050 --> 00:16:41,630
>> C'è un sacco di altri
grande di file funzioni di I / O

328
00:16:41,630 --> 00:16:44,650
che fanno varie cose oltre
quelli di cui abbiamo parlato oggi.

329
00:16:44,650 --> 00:16:46,450
Un paio di quelli
potreste trovare utile

330
00:16:46,450 --> 00:16:50,840
sono fgets e fputs,
che sono l'equivalente

331
00:16:50,840 --> 00:16:56,190
di fgetc e fputc ma per la lettura
una singola stringa da un file.

332
00:16:56,190 --> 00:16:59,020
Invece di un singolo carattere,
si leggerà un'intera stringa.

333
00:16:59,020 --> 00:17:02,940
fprintf, che permette in sostanza
di utilizzare printf per scrivere sul file.

334
00:17:02,940 --> 00:17:05,619
Così come si può fare il
sostituzione di variabile utilizzando

335
00:17:05,619 --> 00:17:09,900
il segnaposto per cento ie
d cento, e così via, con printf

336
00:17:09,900 --> 00:17:14,690
Analogamente, è possibile prendere il
stringa printf e stampare qualcosa

337
00:17:14,690 --> 00:17:16,800
come quella di un file.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- se si dispone di un lettore DVD
è l'analogia io di solito uso qui--

339
00:17:20,720 --> 00:17:23,109
è un po 'come usare il
riavvolgimento e avanzamento veloce

340
00:17:23,109 --> 00:17:25,819
per spostare intorno al film.

341
00:17:25,819 --> 00:17:28,369
Allo stesso modo, è possibile scorrere la lima.

342
00:17:28,369 --> 00:17:30,250
Una delle cose dentro
che struttura dei file

343
00:17:30,250 --> 00:17:34,270
che c crea per voi è un indicatore
di dove siete nel file.

344
00:17:34,270 --> 00:17:36,420
Sei al più
inizio, a zero byte?

345
00:17:36,420 --> 00:17:39,290
Sei al byte 100,
1.000 byte, e così via?

346
00:17:39,290 --> 00:17:44,340
È possibile utilizzare fseek per spostare arbitrariamente
che l'indicatore in avanti o indietro.

347
00:17:44,340 --> 00:17:46,744
>> E ftell, di nuovo
simile ad un lettore DVD,

348
00:17:46,744 --> 00:17:49,660
è come un piccolo orologio che racconta
voi quanti minuti e secondi

349
00:17:49,660 --> 00:17:52,480
sono in un particolare film.

350
00:17:52,480 --> 00:17:56,990
Allo stesso modo, come dice ftell
molti byte che sono nel file.

351
00:17:56,990 --> 00:18:00,210
feof è una versione diversa
di rilevare se hai

352
00:18:00,210 --> 00:18:01,700
raggiunta la fine del file.

353
00:18:01,700 --> 00:18:03,600
E ferror è una funzione
che è possibile utilizzare

354
00:18:03,600 --> 00:18:06,959
per rilevare se qualcosa deve
andato storto lavoro con un file.

355
00:18:06,959 --> 00:18:08,750
Ancora una volta, questo è solo
graffiare la superficie.

356
00:18:08,750 --> 00:18:12,730
C'è ancora molto di più file di I / O
funzioni nel io.h. norma

357
00:18:12,730 --> 00:18:16,620
Ma questo probabilmente porterà
ha iniziato a lavorare con i puntatori di file.

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

359
00:18:17,640 --> 00:18:19,750
Questo è CS50.

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