1
00:00:00,000 --> 00:00:09,780
>> [GIOCO MUSICA]

2
00:00:09,780 --> 00:00:11,150
>> ZAMYLA CHAN: Affrontiamo recuperare.

3
00:00:11,150 --> 00:00:14,030
Recuperare è probabilmente il mio preferito PSET,
e soprattutto perché penso che sia

4
00:00:14,030 --> 00:00:15,650
davvero, davvero cool.

5
00:00:15,650 --> 00:00:19,040
In sostanza, si è dato un ricordo
file di carte in cui

6
00:00:19,040 --> 00:00:20,900
le immagini sono state cancellate.

7
00:00:20,900 --> 00:00:23,650
Ma che cosa avete intenzione di
fare è recuperare tutti.

8
00:00:23,650 --> 00:00:24,250
>> OK.

9
00:00:24,250 --> 00:00:28,230
Quindi è davvero emozionante, ma forse un
po 'intimidatorio, perché sei

10
00:00:28,230 --> 00:00:32,430
dato un file C vuota e
devi riempire dentro

11
00:00:32,430 --> 00:00:36,250
Ok, quindi cerchiamo di rompere questo
in parti gestibili.

12
00:00:36,250 --> 00:00:38,160
Avrai voglia di aprire il
file della scheda di memoria.

13
00:00:38,160 --> 00:00:39,900
Che sembra abbastanza semplice.

14
00:00:39,900 --> 00:00:43,030
Quindi, individuare l'inizio
di un'immagine JPG.

15
00:00:43,030 --> 00:00:46,740
Tutti i file presenti in questa memoria
carta stanno per essere JPG.

16
00:00:46,740 --> 00:00:50,840
Poi, una volta trovato l'inizio,
si sta andando ad aprire un nuovo JPG, che

17
00:00:50,840 --> 00:00:57,610
è, come creare un file JPG, e scrivere 512
byte alla volta fino a quando un nuovo JPG è

18
00:00:57,610 --> 00:01:02,930
trovato, e termina il programma, una volta
si rileva la fine del file.

19
00:01:02,930 --> 00:01:06,400
>> Così i primi passi prima è di aprire
il file della scheda di memoria.

20
00:01:06,400 --> 00:01:09,850
Ma si conosce già questo, e non c'è
una funzione di I / O di file che sta per

21
00:01:09,850 --> 00:01:12,030
rivelarsi molto utile.

22
00:01:12,030 --> 00:01:12,820
OK.

23
00:01:12,820 --> 00:01:14,760
Quindi quali sono JPG?

24
00:01:14,760 --> 00:01:16,330
Perché abbiamo bisogno di principio esso.

25
00:01:16,330 --> 00:01:21,310
Beh, JPG, proprio come le mappe di bit,
sono solo sequenze di byte.

26
00:01:21,310 --> 00:01:30,660
Per fortuna, ogni JPG inizia con uno
0xFF, 0xd8, 0xFF, 0xe0, una sequenza

27
00:01:30,660 --> 00:01:33,610
di byte o un'altra
sequenza di byte.

28
00:01:33,610 --> 00:01:37,250
>> Così quei quattro byte indicano
l'inizio di un JPG.

29
00:01:37,250 --> 00:01:40,780
Niente meno che queste due combinazioni
di quattro byte.

30
00:01:40,780 --> 00:01:44,840
E fortunatamente per noi, un altro fatto che ci
possono trarre vantaggio è che ogni

31
00:01:44,840 --> 00:01:48,550
JPG viene memorizzato side-by-side
sulla scheda di memoria.

32
00:01:48,550 --> 00:01:52,210
Ho rappresentato la struttura di un
scheda di memoria schematicamente su questo

33
00:01:52,210 --> 00:01:53,310
far scorrere qui.

34
00:01:53,310 --> 00:01:59,270
Qui, ogni piazza, ogni rettangolo,
rappresenta 512 byte, e si inizia

35
00:01:59,270 --> 00:02:01,750
con un grigio che non lo facciamo
davvero un JPG.

36
00:02:01,750 --> 00:02:05,700
>> Ma poi abbiamo finalmente raggiunto
un blocco con una stella.

37
00:02:05,700 --> 00:02:10,940
Ciò significa che i primi quattro byte su
di questi 512 sono uno di questi due

38
00:02:10,940 --> 00:02:13,230
partendo sequenze di un JPG.

39
00:02:13,230 --> 00:02:17,340
E andiamo da lì, e poi una volta
una JPG termina, il successivo inizia.

40
00:02:17,340 --> 00:02:20,990
Noi non abbiamo mai più
spazio grigio in-between.

41
00:02:20,990 --> 00:02:25,550
>> Ma come possiamo effettivamente leggiamo questo, e
leggere i 512 byte in modo che possiamo fare

42
00:02:25,550 --> 00:02:27,500
il confronto primo luogo?

43
00:02:27,500 --> 00:02:33,470
Bene, torniamo a fread, che
prende nella struttura che conterrà

44
00:02:33,470 --> 00:02:34,470
i byte che stai leggendo.

45
00:02:34,470 --> 00:02:36,570
Quindi stai andando a mettere
quelli in là -

46
00:02:36,570 --> 00:02:42,192
la dimensione, il numero, e poi inpointer
che stai leggendo da.

47
00:02:42,192 --> 00:02:49,900
Ora, vogliamo leggere 512 alla volta, e
vogliamo conservare questo in un buffer,

48
00:02:49,900 --> 00:02:50,700
Ho intenzione di chiamarlo.

49
00:02:50,700 --> 00:02:54,100
>> In sostanza, stiamo andando a tenere
su quei 512 byte e da fare

50
00:02:54,100 --> 00:02:55,500
cose con esso, giusto?

51
00:02:55,500 --> 00:02:58,260
Stiamo sia andando a confrontare il primo
quattro byte, o stiamo per

52
00:02:58,260 --> 00:02:59,830
leggerlo in, OK?

53
00:02:59,830 --> 00:03:05,050
Allora il puntatore dati sarà poi
servire come buffer, e il

54
00:03:05,050 --> 00:03:07,745
inpointer, bene, questo è solo andare
per essere la scheda di memoria.

55
00:03:07,745 --> 00:03:09,500
>> Torna alla nostra schematica scheda di memoria.

56
00:03:09,500 --> 00:03:14,690
Stiamo andando a leggere 512 byte alla volta,
memorizzare ogni blocco di 512 byte

57
00:03:14,690 --> 00:03:19,190
in un buffer, trattenendo quelle
tampone, questi 512 byte, finché non sapremo

58
00:03:19,190 --> 00:03:22,000
esattamente cosa fare di loro.

59
00:03:22,000 --> 00:03:25,960
Così l'inizio non è niente, quindi
ci leggiamo il buffer, confrontiamo, e

60
00:03:25,960 --> 00:03:28,160
non avremo bisogno di fare qualsiasi cosa con esso.

61
00:03:28,160 --> 00:03:32,030
E poi, abbiamo finalmente raggiunto una stella
blocchiamo, il che significa che abbiamo

62
00:03:32,030 --> 00:03:33,630
trovato il nostro primo JPG.

63
00:03:33,630 --> 00:03:36,560
Così il buffer detengono ormai
byte da quel JPG.

64
00:03:36,560 --> 00:03:40,220
>> La prossima volta 512 byte, perché sono
Non un blocco stella, sono anche

65
00:03:40,220 --> 00:03:41,740
parte di quel JPG.

66
00:03:41,740 --> 00:03:47,630
E JPG sono continue da lì
dentro, fino a quando abbiamo raggiunto il prossimo JPG.

67
00:03:47,630 --> 00:03:51,880
E poi il buffer contiene poi
512 byte per quel JPG, e

68
00:03:51,880 --> 00:03:53,580
così via, e così via.

69
00:03:53,580 --> 00:03:54,250
OK.

70
00:03:54,250 --> 00:03:58,980
>> Quindi, una volta colpito il primo stellato
blocco, la prima JPG, come si fa

71
00:03:58,980 --> 00:04:01,910
in realtà, beh, aprirlo?

72
00:04:01,910 --> 00:04:04,990
Facciamo un nuovo JPG.

73
00:04:04,990 --> 00:04:08,846
I nomi dei file per un JPG stanno per
essere nel formato, numero, numero,

74
00:04:08,846 --> 00:04:13,830
number.jpg, in che stanno nominati in
l'ordine in cui si trovano,

75
00:04:13,830 --> 00:04:14,780
partendo da 0.

76
00:04:14,780 --> 00:04:19,890
>> Quindi la prima JPG che si
trovare saranno 000.jpg.

77
00:04:19,890 --> 00:04:26,560
Quindi, probabilmente una buona idea per tenere traccia
di quante JPG hai trovato finora.

78
00:04:26,560 --> 00:04:27,610
Ecco, questo è il nome del file.

79
00:04:27,610 --> 00:04:29,660
Ma come si fa effettivamente fare che?

80
00:04:29,660 --> 00:04:34,310
Beh, stiamo andando a utilizzare un
funzione chiamata sprintf.

81
00:04:34,310 --> 00:04:38,260
Un po 'simile a printf, dove
è possibile utilizzare segnaposto per archi,

82
00:04:38,260 --> 00:04:42,420
tranne che in questo caso, sprintf stamperà
il file nella corrente

83
00:04:42,420 --> 00:04:45,550
Elenco, non nel terminale.

84
00:04:45,550 --> 00:04:46,120
>> OK.

85
00:04:46,120 --> 00:04:49,950
Quindi qui si vede che abbiamo titolo,
un array di char che memorizzerà l'

86
00:04:49,950 --> 00:04:55,120
stringa risultante, e passiamo in
titolo della stringa effettiva con

87
00:04:55,120 --> 00:04:58,720
segnaposto, proprio come abbiamo
imparato a fare con printf.

88
00:04:58,720 --> 00:05:05,530
Ma questo codice che ho qui
darà 2.jpg, non 002.jpg.

89
00:05:05,530 --> 00:05:09,920
Quindi lascio a voi scoprire come
modificare il segnaposto per rendere l'

90
00:05:09,920 --> 00:05:11,920
nome corretto.

91
00:05:11,920 --> 00:05:12,610
>> OK.

92
00:05:12,610 --> 00:05:17,390
Quindi, una volta che hai sprintf'd allora potete
aprire il file, perché esiste in

93
00:05:17,390 --> 00:05:22,690
la directory, con fopen, utilizzando il
titolo, e quindi tutto ciò modalità che si desidera

94
00:05:22,690 --> 00:05:25,140
per aprire quel file dentro

95
00:05:25,140 --> 00:05:30,260
Quindi, ora che abbiamo aperto un nuovo file JPG,
Ora possiamo scrivere 512 byte a

96
00:05:30,260 --> 00:05:33,320
tempo, fino a quando viene trovato un nuovo JPG.

97
00:05:33,320 --> 00:05:36,640
Quindi diamo un altro sguardo
alla sintassi di fwrite.

98
00:05:36,640 --> 00:05:40,060
>> So che sto mostrando questa diapositiva un
lotto, ma voglio solo fare in modo che

99
00:05:40,060 --> 00:05:43,530
voi ragazzi non siate troppo confuso, perché
So che è molto facile da

100
00:05:43,530 --> 00:05:47,000
mescolare il primo e l'ultimo
argomento, in particolare.

101
00:05:47,000 --> 00:05:54,390
Ma ricordate che si sta scrivendo da
il buffer nelle immagini di file fuori.

102
00:05:54,390 --> 00:05:59,250
>> Ora che sapete come la scrittura 512
byte nel file JPG che hai

103
00:05:59,250 --> 00:06:03,230
creato, bene, vogliamo fermare che
processo una volta che abbiamo raggiunto la fine del

104
00:06:03,230 --> 00:06:06,720
nostra carta, perché non ci sarà
altre immagini da trovare.

105
00:06:06,720 --> 00:06:10,760
Quindi torniamo a fread
ancora una volta, lo prometto.

106
00:06:10,760 --> 00:06:15,600
fread restituisce il numero di elementi di dimensioni,
dimensioni, erano pronti a successo.

107
00:06:15,600 --> 00:06:19,440
Idealmente, questo sta per essere qualunque
si passa per numero, giusto?

108
00:06:19,440 --> 00:06:24,140
Perché si sta cercando di leggere il numero
di elementi di formato, formato.

109
00:06:24,140 --> 00:06:29,380
Ma se fread non è in grado di leggere che
numero di elementi, poi tornerà

110
00:06:29,380 --> 00:06:32,530
qualunque numero si leggeva correttamente.

111
00:06:32,530 --> 00:06:36,310
>> Ora, una cosa importante da notare è
che se si utilizza un altro file I / O

112
00:06:36,310 --> 00:06:43,860
funzionano come fgetc, sarà anche di ritorno
quanti articoli si leggeva correttamente.

113
00:06:43,860 --> 00:06:48,000
Cosa c'è di utile su questa funzione è
che se si utilizzano funzioni all'interno di un

114
00:06:48,000 --> 00:06:53,190
condizioni, sarà eseguire se stesso mentre
determinazione di tale condizione,

115
00:06:53,190 --> 00:06:54,340
basta veramente utile.

116
00:06:54,340 --> 00:07:00,440
Quindi, se avete queste condizioni, diciamo,
se il buffer fread, DOG sizeof, 2,

117
00:07:00,440 --> 00:07:04,870
puntatore, uguale uguale a 1, che
vuol dire che mi piacerebbe leggere

118
00:07:04,870 --> 00:07:06,540
2 cani al momento.

119
00:07:06,540 --> 00:07:13,490
Ma se fread restituisce 1 invece di 2 come
previsto, il che significa che ci sono 2

120
00:07:13,490 --> 00:07:16,480
cani lasciati nel mio file, ma piuttosto 1.

121
00:07:16,480 --> 00:07:22,450
Ma se restituisce 2, quindi ho ancora
quei 2 cani all'interno del mio tampone.

122
00:07:22,450 --> 00:07:26,280
>> Quindi, ora che ti dà un senso di come
verificare la fine del file, ma

123
00:07:26,280 --> 00:07:28,940
andiamo ora attraverso la logica.

124
00:07:28,940 --> 00:07:32,460
Come abbiamo effettivamente pezzo tutto
di questi elementi insieme?

125
00:07:32,460 --> 00:07:36,880
Una volta che abbiamo raggiunto il nostro primo JPG, dal momento che
sappiamo che JPGs vengono memorizzati

126
00:07:36,880 --> 00:07:40,910
contiguo, saremo scrivendo fino
si raggiunge la fine del file carta.

127
00:07:40,910 --> 00:07:43,950
Ma noi non vogliamo scrivere
nulla fino ad allora.

128
00:07:43,950 --> 00:07:48,710
Quindi è importante, non solo che siamo al
l'inizio di un nuovo JPG, ma se

129
00:07:48,710 --> 00:07:50,655
abbiamo già trovato un JPG o meno.

130
00:07:50,655 --> 00:07:55,390
>> Se E 'l'inizio di una nuova JPG, faremo
voler chiudere il nostro file JPG corrente se

131
00:07:55,390 --> 00:07:59,110
abbiamo uno aperto, e aperto
uno nuovo di scrivere in.

132
00:07:59,110 --> 00:08:03,340
Se non è l'inizio del nuovo JPG,
però, ci terremo lo stesso file JPG

133
00:08:03,340 --> 00:08:05,910
aprire e scrivere in quella.

134
00:08:05,910 --> 00:08:10,100
Ti scriviamo il nostro tampone in qualsiasi
JPG abbiamo aperto, a condizione che

135
00:08:10,100 --> 00:08:12,120
abbiamo uno aperto, naturalmente.

136
00:08:12,120 --> 00:08:16,190
Se non abbiamo trovato il nostro primo JPG
tuttavia, non scriviamo niente.

137
00:08:16,190 --> 00:08:20,290
E questo processo continua finché non si
raggiungere la fine del file carta.

138
00:08:20,290 --> 00:08:23,410
>> E, infine, si vuole fare
Assicurarsi che si fclose qualsiasi

139
00:08:23,410 --> 00:08:25,800
i file che hai fopened.

140
00:08:25,800 --> 00:08:28,360
Una volta che sei a tuo agio con la
concetti, date un'occhiata ad alcuni

141
00:08:28,360 --> 00:08:30,840
pseudocodice, che ho incluso qui.

142
00:08:30,840 --> 00:08:34,830
In primo luogo, si desidera aprire il file della carta,
e poi ripetere il processo seguente

143
00:08:34,830 --> 00:08:37,144
fino a quando hai raggiunto l'
estremità della scheda.

144
00:08:37,144 --> 00:08:40,880
Si desidera leggere 512 byte
in un buffer.

145
00:08:40,880 --> 00:08:43,934
Utilizzando questo buffer, ti consigliamo di controllare
se siete all'inizio di una

146
00:08:43,934 --> 00:08:45,300
nuovo JPG o meno.

147
00:08:45,300 --> 00:08:48,400
E la risposta a questa domanda sarà
influenzare la gestione dei file -

148
00:08:48,400 --> 00:08:51,940
quali file si apre, che
quelli che non si chiudono.

149
00:08:51,940 --> 00:08:55,220
>> Allora, avete già trovato un JPG?

150
00:08:55,220 --> 00:08:57,740
Come siete stati mantenendo
traccia di questo?

151
00:08:57,740 --> 00:09:01,735
Poi, a seconda che, ti sia
scrivere in JPG corrente che si

152
00:09:01,735 --> 00:09:07,090
hanno aperto, o non scrivere affatto,
perché non avete ancora trovato un JPG.

153
00:09:07,090 --> 00:09:10,870
Infine, una volta che hai raggiunto la fine del
il file, ti consigliamo di chiudere qualsiasi

154
00:09:10,870 --> 00:09:12,590
restando i file che avete aperto.

155
00:09:12,590 --> 00:09:14,590
Vogliamo essere ordinato qui.

156
00:09:14,590 --> 00:09:18,790
>> E con questo, di aver recuperato tutti
i file mancanti da quella memoria

157
00:09:18,790 --> 00:09:21,620
carta, che è un piuttosto sorprendente feat.

158
00:09:21,620 --> 00:09:23,430
Quindi datevi una pacca sulla schiena.

159
00:09:23,430 --> 00:09:27,560
Ma, c'è un altro elemento
il PSET, che è il concorso.

160
00:09:27,560 --> 00:09:30,920
Troverete che tutte le immagini
che hai recuperato sono in realtà

161
00:09:30,920 --> 00:09:32,820
foto del personale del CS50.

162
00:09:32,820 --> 00:09:38,500
Quindi, se siete nel campus o in qualche
vicino, quindi è possibile scattare foto con

163
00:09:38,500 --> 00:09:42,600
il personale, e la sezione che ha la
la maggior parte delle foto con i membri del personale

164
00:09:42,600 --> 00:09:46,940
dalle loro file recuperati saranno
ottenere un premio impressionante.

165
00:09:46,940 --> 00:09:50,650
Con questo, allora avete finito
il PSET recuperare.

166
00:09:50,650 --> 00:09:53,600
Il mio nome è Zamyla, e questo è CS50.

167
00:09:53,600 --> 00:10:01,835