1
00:00:00,000 --> 00:00:02,860
[Powered by Google Translate] [Settimana 5]

2
00:00:02,860 --> 00:00:04,860
[David J. Malan - Harvard University]

3
00:00:04,860 --> 00:00:07,260
[Questo è CS50. - CS50.TV]

4
00:00:07,260 --> 00:00:09,740
>> Questo è CS50, settimana 5.

5
00:00:09,740 --> 00:00:12,900
Oggi e questa settimana, si introduce un po 'del mondo della medicina legale

6
00:00:12,900 --> 00:00:14,850
nel contesto del problema posto 4.

7
00:00:14,850 --> 00:00:18,480
Oggi sarà una lezione abbreviato perché c'è un evento speciale qui in seguito.

8
00:00:18,480 --> 00:00:21,940
Quindi dovremo dare un'occhiata e prendere in giro sia a studenti e genitori di oggi

9
00:00:21,940 --> 00:00:24,600
con alcune delle cose che sono all'orizzonte.

10
00:00:24,600 --> 00:00:29,050
>> Tra questi, come di Lunedi, si avrà un paio di compagni di classe.

11
00:00:29,050 --> 00:00:32,980
edx, Harvard e la nuova iniziativa on line del MIT OpenCourseWare e per di più,

12
00:00:32,980 --> 00:00:36,730
sta lanciando nel campus di Harvard il Lunedi, il che significa venire Lunedi

13
00:00:36,730 --> 00:00:40,930
si avrà, a partire dal le ultime stime, 86.000 compagni supplementari

14
00:00:40,930 --> 00:00:43,680
che sarà seguito con lezioni CS50 e le sezioni

15
00:00:43,680 --> 00:00:45,890
e procedure dettagliate e set problema.

16
00:00:45,890 --> 00:00:51,870
E come parte di questo, si diventa membri della classe inaugurale del CS50 e ora CS50x.

17
00:00:51,870 --> 00:00:56,150
Come parte di questo momento, si rendono conto che ci saranno alcuni aspetti positivi pure.

18
00:00:56,150 --> 00:01:00,620
Per prepararsi a questo, per il numero enorme di studenti,

19
00:01:00,620 --> 00:01:03,820
basti dire che, anche se abbiamo 108 TF e CA,

20
00:01:03,820 --> 00:01:07,560
non è proprio il miglior rapporto studenti-insegnanti, una volta abbiamo raggiunto 80.000 studenti.

21
00:01:07,560 --> 00:01:09,830
Non sta andando ad essere un problema di classificazione tanti imposta manualmente,

22
00:01:09,830 --> 00:01:13,050
così introdotto questa settimana nel set problema sarà CS50 Check,

23
00:01:13,050 --> 00:01:15,410
che sta per essere una riga di comando all'interno dell'apparecchio

24
00:01:15,410 --> 00:01:17,880
che si otterrà una volta che si aggiorna dopo questo fine settimana.

25
00:01:17,880 --> 00:01:21,030
Sarete in grado di eseguire un comando, check50, sul pset proprio,

26
00:01:21,030 --> 00:01:24,770
e si otterrà un feedback immediato sul fatto che il programma è giusta o sbagliata

27
00:01:24,770 --> 00:01:27,980
secondo le specifiche di progetto diversi che abbiamo fornito.

28
00:01:27,980 --> 00:01:30,310
Più su che nella specifica set problema.

29
00:01:30,310 --> 00:01:34,220
I compagni di classe CS50x quali si utilizza questo pure.

30
00:01:34,220 --> 00:01:36,170
>> Set Problema 4 è tutto forense,

31
00:01:36,170 --> 00:01:38,630
e questo pset era davvero ispirato da alcuni vita reale roba

32
00:01:38,630 --> 00:01:41,210
per cui quando ero a scuola di specializzazione ho internato per un po '

33
00:01:41,210 --> 00:01:45,270
con sede procuratore distrettuale della contea di Middlesex sta facendo il lavoro forense

34
00:01:45,270 --> 00:01:47,660
con il loro capo ricercatore forense.

35
00:01:47,660 --> 00:01:50,280
Ciò che questo è pari a, come penso ho già detto un paio di settimane passate,

36
00:01:50,280 --> 00:01:52,720
è la Polizia di Stato di massa o altri sarebbe venuto in,

37
00:01:52,720 --> 00:01:56,150
avrebbero lasciare le cose come hard disk e CD e floppy disk e simili,

38
00:01:56,150 --> 00:01:58,770
e quindi l'obiettivo dell'ufficio forense era accertare

39
00:01:58,770 --> 00:02:01,470
se ci fosse o meno la prova di qualche tipo.

40
00:02:01,470 --> 00:02:04,730
Questa è stata la Squadra Speciale Investigativa, quindi era criminalità dei colletti bianchi.

41
00:02:04,730 --> 00:02:10,949
Era una specie più inquietante di delitti, qualsiasi azione che comporti una sorta di media digitali.

42
00:02:10,949 --> 00:02:16,450
Si scopre che non è che molte persone scrivere una e-mail dicendo: "L'ho fatto."

43
00:02:16,450 --> 00:02:20,490
Così molto spesso, queste ricerche forensi non si presentò tutto ciò che molto frutto,

44
00:02:20,490 --> 00:02:22,820
ma a volte la gente scrivere tali e-mail.

45
00:02:22,820 --> 00:02:25,240
Così a volte, gli sforzi sono stati premiati.

46
00:02:25,240 --> 00:02:31,210
>> Ma per portare a questo pset forense, saremo in pset4 introdurre un po 'di grafica.

47
00:02:31,210 --> 00:02:35,410
Probabilmente prendere queste cose per scontato - JPEG, GIF, e simili - in questi giorni.

48
00:02:35,410 --> 00:02:38,320
Ma se davvero pensate, un'immagine, proprio come il viso di Rob,

49
00:02:38,320 --> 00:02:41,270
potrebbe essere modellato come una sequenza di punti o pixel.

50
00:02:41,270 --> 00:02:43,380
Nel caso della faccia di Rob, ci sono tutti i colori,

51
00:02:43,380 --> 00:02:46,760
e abbiamo iniziato a vedere i singoli punti, altrimenti noti come pixel,

52
00:02:46,760 --> 00:02:48,610
una volta che abbiamo iniziato a Immagine

53
00:02:48,610 --> 00:02:54,660
Ma se semplificare il mondo un po 'e solo dire che questo qui è Rob in bianco e nero,

54
00:02:54,660 --> 00:02:57,490
per rappresentare in bianco e nero, si può semplicemente utilizzare binario.

55
00:02:57,490 --> 00:03:01,660
E se abbiamo intenzione di utilizzare binario, 1 o 0, siamo in grado di esprimere questa stessa immagine

56
00:03:01,660 --> 00:03:06,140
del volto sorridente di Rob con questo modello di bit.

57
00:03:06,140 --> 00:03:12,100
11000011 rappresenta il bianco, bianco, nero, nero, nero, nero, bianco, bianco.

58
00:03:12,100 --> 00:03:16,150
E quindi non è un enorme balzo in poi cominciare a parlare di fotografie colorate,

59
00:03:16,150 --> 00:03:18,600
le cose che ci si vede su Facebook o prendere con una macchina fotografica digitale.

60
00:03:18,600 --> 00:03:21,410
Ma certamente quando si tratta di colori, avete bisogno di più bit.

61
00:03:21,410 --> 00:03:25,690
E abbastanza comune nel mondo delle fotografie è di non usare 1-bit di colore,

62
00:03:25,690 --> 00:03:29,560
come questo suggerisce, ma colori a 24 bit, in cui è effettivamente ottenere milioni di colori.

63
00:03:29,560 --> 00:03:32,250
Così come nel caso in cui ci zoom su occhi di Rob,

64
00:03:32,250 --> 00:03:36,370
che era un numero qualsiasi di milioni di differenti possibilità colorati.

65
00:03:36,370 --> 00:03:39,040
Quindi dovremo introdurre questo nel set Problema 4, nonché nella procedura dettagliata,

66
00:03:39,040 --> 00:03:43,370
che sarà oggi alle 3:30 invece del solito a causa della conferenza 02:30 Venerdì qui.

67
00:03:43,370 --> 00:03:46,620
Ma il video sarà online da domani al solito.

68
00:03:46,620 --> 00:03:48,820
>> Inoltre, ti introducono in un altro formato di file.

69
00:03:48,820 --> 00:03:51,270
Questo è deliberatamente vuole guardare intimidatorio in un primo momento,

70
00:03:51,270 --> 00:03:55,670
ma questo è solo un po 'di documentazione per una struct C.

71
00:03:55,670 --> 00:03:58,940
Si scopre che anni fa, Microsoft ha contribuito a diffondere questo formato

72
00:03:58,940 --> 00:04:05,150
chiamato il formato di file bitmap, bmp, e questo era un super semplice, formato di file grafico colorato

73
00:04:05,150 --> 00:04:10,150
che è stato utilizzato per un bel po 'di tempo e, a volte ancora per sfondi per desktop.

74
00:04:10,150 --> 00:04:14,760
Se si pensa di nuovo a Windows XP e le dolci colline e l'azzurro del cielo,

75
00:04:14,760 --> 00:04:17,170
che era tipicamente un'immagine bmp o bitmap.

76
00:04:17,170 --> 00:04:19,959
Bitmap sono divertenti per noi perché hanno la complessità di un po 'di più.

77
00:04:19,959 --> 00:04:22,610
Non è così semplice come questa griglia di 0 e 1.

78
00:04:22,610 --> 00:04:27,510
Invece, avete cose come un colpo di testa all'inizio di un file.

79
00:04:27,510 --> 00:04:31,990
In altre parole, all'interno di un file. Bmp è un insieme di 0 e 1,

80
00:04:31,990 --> 00:04:34,910
ma c'è qualche ulteriore 0s e 1s in là.

81
00:04:34,910 --> 00:04:38,220
E si scopre che quello che abbiamo probabilmente dato per scontato da anni -

82
00:04:38,220 --> 00:04:45,170
formati di file come. doc o. xls o. mp3, mp4., a prescindere dai formati di file

83
00:04:45,170 --> 00:04:48,480
che si ha familiarità con - cosa vuol dire essere anche un formato di file,

84
00:04:48,480 --> 00:04:52,480
perché alla fine della giornata tutti questi file usiamo avere solo 0 e 1.

85
00:04:52,480 --> 00:04:56,810
E forse coloro 0 e 1 rappresentano ABC tramite ASCII o simili,

86
00:04:56,810 --> 00:04:58,820
ma alla fine della giornata, è ancora solo 0 e 1.

87
00:04:58,820 --> 00:05:02,100
Così gli esseri umani solo occasionalmente decide di inventare un nuovo formato di file

88
00:05:02,100 --> 00:05:06,420
dove standardizzare ciò che i modelli di bit effettivamente dire.

89
00:05:06,420 --> 00:05:09,220
E in questo caso qui, la gente che ha progettato il formato di file bitmap

90
00:05:09,220 --> 00:05:15,620
ha detto che al primo byte in un file bitmap, come indicato da 0 Offset lì,

91
00:05:15,620 --> 00:05:18,940
ci sarà un po 'di nomi incomprensibili bfType variabile chiamata,

92
00:05:18,940 --> 00:05:23,080
che sta solo per tipo di file bitmap, che tipo di file bitmap è questo.

93
00:05:23,080 --> 00:05:27,700
Si può dedurre, forse dalla seconda fila che ha compensato 2, numero byte 2,

94
00:05:27,700 --> 00:05:33,740
ha un modello di 0 e 1 che rappresenta ciò che? La dimensione di qualcosa.

95
00:05:33,740 --> 00:05:35,310
E si va avanti da lì.

96
00:05:35,310 --> 00:05:37,410
Così nel Set Problema 4, sarete camminato attraverso alcune di queste cose.

97
00:05:37,410 --> 00:05:39,520
Non finirà per prendersi cura di ognuno di loro.

98
00:05:39,520 --> 00:05:47,510
Ma nota che inizia a diventare interessante in giro byte 54: rgbtBlue, verde e rosso.

99
00:05:47,510 --> 00:05:52,110
Se hai mai sentito la sigla RGB - rosso, verde, blu - questo è un riferimento a tale

100
00:05:52,110 --> 00:05:54,610
perché è venuto fuori è possibile dipingere tutti i colori dell'arcobaleno

101
00:05:54,610 --> 00:05:58,180
con una combinazione di rosso e blu e verde.

102
00:05:58,180 --> 00:06:03,320
E infatti, i genitori nella stanza può ricordare alcuni dei primi proiettori.

103
00:06:03,320 --> 00:06:05,890
In questi giorni, si vede solo una luce forte proveniente da una lente,

104
00:06:05,890 --> 00:06:09,800
ma nel giorno in cui ha avuto la lente rossa, la lente blu, e la lente verde,

105
00:06:09,800 --> 00:06:13,380
e insieme volto a uno schermo e formato un immagine colorata.

106
00:06:13,380 --> 00:06:16,270
E molto spesso, scuole medie e scuole superiori avrebbero quelle lenti

107
00:06:16,270 --> 00:06:19,720
sempre in modo leggermente di traverso, in modo che erano una specie di vedere immagini doppie o triple.

108
00:06:19,720 --> 00:06:24,100
Ma questa era l'idea. Hai avuto luce rossa e verde e blu dipingere un quadro.

109
00:06:24,100 --> 00:06:26,590
E questo stesso principio è usato nei computer.

110
00:06:26,590 --> 00:06:30,230
>> Quindi, tra le sfide allora per voi in Problema Set 4 stanno per essere un paio di cose.

111
00:06:30,230 --> 00:06:34,800
Uno è quello di ridimensionare un immagine, di prendere in un modello di 0 e 1,

112
00:06:34,800 --> 00:06:40,200
capire quali pezzi di 0 e 1 rappresentano ciò che in una struttura come questa,

113
00:06:40,200 --> 00:06:43,630
e poi capire come replicare i pixel - i rossi, i blu, i verdi -

114
00:06:43,630 --> 00:06:46,660
all'interno in modo che, quando un'immagine è simile inizialmente,

115
00:06:46,660 --> 00:06:49,210
potrebbe apparire come questo, invece dopo.

116
00:06:49,210 --> 00:06:53,640
Tra le altre sfide troppo sarà che ti verrà consegnato un immagine forense

117
00:06:53,640 --> 00:06:56,030
di un file vero e proprio da una fotocamera digitale.

118
00:06:56,030 --> 00:06:58,960
E su quella macchina fotografica, un tempo, erano un sacco di foto.

119
00:06:58,960 --> 00:07:03,760
Il problema è che accidentalmente cancellati o ha avuto l'immagine danneggiato in qualche modo.

120
00:07:03,760 --> 00:07:05,750
Le cose brutte succedono con le fotocamere digitali.

121
00:07:05,750 --> 00:07:09,150
E così abbiamo subito copiato tutti i off 0 e 1 di quella carta per voi,

122
00:07:09,150 --> 00:07:13,610
salvati tutti in un unico grande file, e poi noi li consegnare a voi in Problema Set 4

123
00:07:13,610 --> 00:07:19,320
in modo che sia possibile scrivere un programma in C con il quale recuperare tutti quei file JPEG, idealmente.

124
00:07:19,320 --> 00:07:23,330
E si scopre che i file JPEG, anche se sono un po 'di un formato di file complesso -

125
00:07:23,330 --> 00:07:26,360
sono molto più complesso di questo volto sorridente qui -

126
00:07:26,360 --> 00:07:31,160
si scopre che ogni JPEG inizia con gli stessi schemi di 0 e 1.

127
00:07:31,160 --> 00:07:35,630
Quindi, utilizzando, in ultima analisi, un ciclo while o un ciclo for o simili,

128
00:07:35,630 --> 00:07:38,880
è possibile scorrere tutte le 0 e 1 in questa immagine forense,

129
00:07:38,880 --> 00:07:43,150
e ogni volta che si vede il motivo speciale che è definito nella specifica set problema,

130
00:07:43,150 --> 00:07:47,880
si può assumere ecco, con elevata probabilità, l'inizio di un JPEG.

131
00:07:47,880 --> 00:07:51,230
E non appena si trova lo stesso modello un certo numero di byte

132
00:07:51,230 --> 00:07:55,430
o kilobyte o in megabyte successive, è possibile assumere qui è un secondo JPEG,

133
00:07:55,430 --> 00:07:57,380
la foto che ho scattato dopo il primo.

134
00:07:57,380 --> 00:08:01,370
Vorrei smettere di leggere quel file in primo luogo, iniziare a scrivere questo nuovo,

135
00:08:01,370 --> 00:08:06,310
e l'uscita del programma per pset4 sta per essere fino a 50 JPEG.

136
00:08:06,310 --> 00:08:09,270
E se non è 50 file JPEG, si dispone di un po 'di un ciclo.

137
00:08:09,270 --> 00:08:12,490
Se si dispone di un numero infinito di file JPEG, si dispone di un ciclo infinito.

138
00:08:12,490 --> 00:08:14,910
Quindi, anche questo sarà un bel caso comune.

139
00:08:14,910 --> 00:08:16,600
Ecco, questo è ciò che è all'orizzonte.

140
00:08:16,600 --> 00:08:21,310
>> Quiz 0, dietro di noi, per realizzare il mio e-mail che ci sono sempre persone che sono entrambi felici,

141
00:08:21,310 --> 00:08:23,640
sorta di folle, e triste intorno quiz 0 Tempo.

142
00:08:23,640 --> 00:08:26,800
E vi prego di non entrare in contatto con me, la testa TF Zamyla, il TF proprio,

143
00:08:26,800 --> 00:08:31,180
o uno dei CA che si sa se si vuole discutere di come sono andate le cose.

144
00:08:31,180 --> 00:08:35,539
>> Quindi, per impressionare i genitori qui in camera, che è la libreria CS50?

145
00:08:36,429 --> 00:08:40,390
[Risate] Ottimo lavoro.

146
00:08:40,390 --> 00:08:48,340
Qual è la biblioteca CS50? Gia '. >> [Studente] E 'un pre-scritto insieme di codice [incomprensibile]

147
00:08:48,340 --> 00:08:49,750
Ok, bene.

148
00:08:49,750 --> 00:08:53,240
Si tratta di un pre-scritto insieme di codice che abbiamo scritto il personale, che offriamo a voi,

149
00:08:53,240 --> 00:08:55,030
che fornisce alcune funzionalità comuni,

150
00:08:55,030 --> 00:08:59,020
roba come farmi una stringa, mi ottenere un int - tutte le funzioni che sono elencate qui.

151
00:08:59,020 --> 00:09:02,260
>> A partire da ora, si comincia a prendere realmente queste ruote di formazione off.

152
00:09:02,260 --> 00:09:05,050
Stiamo per iniziare a togliere una stringa da te,

153
00:09:05,050 --> 00:09:08,870
richiamo che era solo un sinonimo di ciò che tipo di dati effettivo? [>> Più studenti] Char *.

154
00:09:08,870 --> 00:09:12,730
* Char. Per i genitori, che era probabilmente [rende il suono sibilante]. Questo è un bene.

155
00:09:12,730 --> 00:09:17,550
* Char inizieremo a vedere sullo schermo tanto più dal momento che eliminiamo stringa dal nostro vocabolario,

156
00:09:17,550 --> 00:09:19,730
almeno quando si tratta di realtà la scrittura di codice.

157
00:09:19,730 --> 00:09:22,840
Allo stesso modo, ci smettere di usare alcune di queste funzioni il più

158
00:09:22,840 --> 00:09:25,280
perché i nostri programmi stanno andando ottenere più sofisticati.

159
00:09:25,280 --> 00:09:28,480
Piuttosto che scrivere programmi che si trovano lì con un lampeggiante prompt,

160
00:09:28,480 --> 00:09:31,870
attesa che l'utente a digitare qualcosa, avrai gli ingressi da qualche altra parte.

161
00:09:31,870 --> 00:09:35,490
Per esempio, potrai ottenere da una serie di bit sul disco rigido locale.

162
00:09:35,490 --> 00:09:38,580
Avrete invece ottenere in futuro da una connessione di rete,

163
00:09:38,580 --> 00:09:40,230
qualche sito da qualche parte.

164
00:09:40,230 --> 00:09:44,110
>> Quindi cerchiamo di togliere questo strato per la prima volta e tirare il CS50 Appliance

165
00:09:44,110 --> 00:09:49,010
e questo file chiamato cs50.h, che hai # anche per settimane,

166
00:09:49,010 --> 00:09:51,140
ma cerchiamo di realmente vedere cosa c'è dentro di questo.

167
00:09:51,140 --> 00:09:54,430
La parte superiore del file in blu è solo un insieme di commenti:

168
00:09:54,430 --> 00:09:57,050
informazioni sulla garanzia e la concessione di licenze.

169
00:09:57,050 --> 00:09:59,050
Questa è una sorta di paradigma comune nel software

170
00:09:59,050 --> 00:10:01,580
perché un sacco di software in questi giorni è ciò che si chiama open source,

171
00:10:01,580 --> 00:10:05,220
il che significa che qualcuno ha scritto il codice e reso liberamente disponibile

172
00:10:05,220 --> 00:10:10,470
non solo per correre e da usare, ma in realtà per leggere e modificare e integrare nel proprio lavoro.

173
00:10:10,470 --> 00:10:14,660
Ecco, questo è quello che hai usato, il software open source, anche se in una forma molto piccola.

174
00:10:14,660 --> 00:10:18,560
Se scorrere verso il basso oltre i commenti, però, che inizieremo a vedere alcune cose più familiari.

175
00:10:18,560 --> 00:10:25,010
Si noti in alto qui che il file cs50.h comprende un insieme di file di intestazione.

176
00:10:25,010 --> 00:10:28,560
La maggior parte di questi, che non abbiamo mai visto prima, ma è familiare.

177
00:10:28,560 --> 00:10:32,270
Quale di questi abbiamo visto, anche se brevemente, fino ad ora? >> [Studente] libreria standard.

178
00:10:32,270 --> 00:10:35,810
Si ', libreria standard. stdlib.h ha malloc.

179
00:10:35,810 --> 00:10:38,320
Una volta che abbiamo iniziato a parlare di allocazione dinamica della memoria,

180
00:10:38,320 --> 00:10:41,650
che torneremo la prossima settimana pure, abbiamo iniziato anche il file.

181
00:10:41,650 --> 00:10:46,640
Si scopre che bool e vero e il falso in realtà non esiste in C per sé

182
00:10:46,640 --> 00:10:49,440
a meno che non si include questo file qui.

183
00:10:49,440 --> 00:10:52,710
Ci siamo stati per settimane tra stdbool.h

184
00:10:52,710 --> 00:10:55,620
in modo che è possibile utilizzare il concetto di un bool, vero o falso.

185
00:10:55,620 --> 00:10:58,620
Senza questo, si dovrebbe ordinare di fingere e utilizzare un int

186
00:10:58,620 --> 00:11:02,610
e solo arbitrariamente supporre che 0 è falso e 1 è vero.

187
00:11:02,610 --> 00:11:07,150
Se scorrere verso il basso più, ecco la nostra definizione di una stringa.

188
00:11:07,150 --> 00:11:11,390
Si scopre, come abbiamo detto prima, che dove questa stella non ha molta importanza.

189
00:11:11,390 --> 00:11:13,720
Si può anche avere lo spazio tutto intorno.

190
00:11:13,720 --> 00:11:16,740
Abbiamo questo semestre sono state promuovendo come questo per chiarire

191
00:11:16,740 --> 00:11:18,620
la stella che ha a che fare con il tipo,

192
00:11:18,620 --> 00:11:21,700
ma rendersi conto di come comune, se non un po 'più comune,

193
00:11:21,700 --> 00:11:24,430
è quello di mettere lì, ma funzionalmente è la stessa cosa.

194
00:11:24,430 --> 00:11:27,720
Ma ora se leggiamo ulteriormente verso il basso, diamo un'occhiata a GetInt

195
00:11:27,720 --> 00:11:32,190
perché abbiamo usato che, forse, prima di ogni altra cosa questo semestre.

196
00:11:32,190 --> 00:11:37,440
Ecco GetInt. Questo è ciò? >> [Studente] Un prototipo. >> Questo è solo un prototipo.

197
00:11:37,440 --> 00:11:41,410
Spesso, abbiamo messo prototipi ai vertici della nostra. File c,

198
00:11:41,410 --> 00:11:46,690
ma si può anche mettere prototipi nei file di intestazione, h. file, come questo qui

199
00:11:46,690 --> 00:11:50,840
in modo che quando si scrive alcune funzioni che si desidera che altre persone di essere in grado di utilizzare,

200
00:11:50,840 --> 00:11:53,550
che è esattamente il caso della biblioteca CS50,

201
00:11:53,550 --> 00:11:57,040
non solo implementare le funzioni in qualcosa come cs50.c,

202
00:11:57,040 --> 00:12:02,790
è anche mettere i prototipi non all'inizio del file, ma nella parte superiore di un file di intestazione.

203
00:12:02,790 --> 00:12:07,170
Poi quel file di intestazione è quello che amici e colleghi sono

204
00:12:07,170 --> 00:12:09,760
con # include nel proprio codice.

205
00:12:09,760 --> 00:12:12,210
Quindi tutto questo tempo, hai anche tutti questi prototipi,

206
00:12:12,210 --> 00:12:16,580
efficacemente nella parte superiore del file, ma per mezzo di questo # include meccanismo,

207
00:12:16,580 --> 00:12:20,070
che essenzialmente copie e paste di questo file nel vostro.

208
00:12:20,070 --> 00:12:23,070
Ecco un po 'di documentazione molto dettagliata.

209
00:12:23,070 --> 00:12:25,640
Abbiamo più o meno per scontato che GetInt ottiene un int,

210
00:12:25,640 --> 00:12:27,640
ma è venuto fuori ci sono alcuni casi particolari.

211
00:12:27,640 --> 00:12:31,810
Che cosa succede se l'utente digita in un numero che è troppo grande, un trilione,

212
00:12:31,810 --> 00:12:35,490
che proprio non può andare bene all'interno di un int? Qual è il comportamento previsto?

213
00:12:35,490 --> 00:12:38,020
Idealmente, è prevedibile.

214
00:12:38,020 --> 00:12:40,280
Quindi, in questo caso, se effettivamente leggere la stampa fine,

215
00:12:40,280 --> 00:12:44,500
ci troveremo a vedere che se la linea non può essere letto, questo INT_MAX restituisce.

216
00:12:44,500 --> 00:12:48,320
Non abbiamo mai parlato di questo, ma in base alla sua capitalizzazione, che è probabilmente?

217
00:12:48,320 --> 00:12:50,640
[Studente] Una costante. >> E 'una costante.

218
00:12:50,640 --> 00:12:54,770
E 'una costante speciale che probabilmente dichiarato in una di quelle file di intestazione

219
00:12:54,770 --> 00:13:00,090
che è più in alto nel file, e INT_MAX è probabilmente qualcosa di simile a circa 2 miliardi di euro,

220
00:13:00,090 --> 00:13:04,990
l'idea è che, perché abbiamo bisogno di indicare in qualche modo che qualcosa è andato storto,

221
00:13:04,990 --> 00:13:10,700
noi, sì, hanno 4000000000 numeri a nostra disposizione: -2 miliardi fino a 2 miliardi di euro, prendere o lasciare.

222
00:13:10,700 --> 00:13:14,710
Ebbene, ciò che è comune nella programmazione è rubi solo uno di questi numeri,

223
00:13:14,710 --> 00:13:18,920
forse 0, forse 2 miliardi di euro, forse -2000000000,

224
00:13:18,920 --> 00:13:23,280
in modo da trascorrere uno dei vostri valori possibili in modo che si può commettere al mondo

225
00:13:23,280 --> 00:13:26,820
che se qualcosa va storto, io tornerò questo valore super grande.

226
00:13:26,820 --> 00:13:31,030
Ma non si desidera che l'utente digita qualcosa di criptico come 234 ..., un numero molto grande.

227
00:13:31,030 --> 00:13:34,060
Lo generalizzare invece come una costante.

228
00:13:34,060 --> 00:13:38,060
Quindi, veramente, se venivano anale nelle ultime settimane, ogni volta che si chiama GetInt,

229
00:13:38,060 --> 00:13:42,900
si sarebbe dovuto verificare con una condizione if ha fatto il tipo di utente a INT_MAX,

230
00:13:42,900 --> 00:13:46,590
o, più precisamente, ha fatto ritorno INT_MAX GetInt, perché se lo facesse,

231
00:13:46,590 --> 00:13:51,830
questo significa che in realtà non lo scrivere. Qualcosa è andato storto in questo caso.

232
00:13:51,830 --> 00:13:56,080
Quindi questo è ciò che è noto come un valore sentinella, che significa semplicemente speciale.

233
00:13:56,080 --> 00:13:58,120
>> Passiamo ora nel file. C.

234
00:13:58,120 --> 00:14:01,340
Il file C è esistita nel apparecchio per molto tempo.

235
00:14:01,340 --> 00:14:06,840
E infatti, l'apparecchio ha il pre-compilato per voi in che cosa abbiamo chiamato codice oggetto,

236
00:14:06,840 --> 00:14:09,540
ma semplicemente non importa a voi dove è perché il sistema sa

237
00:14:09,540 --> 00:14:11,730
in questo caso è: l'apparecchio.

238
00:14:11,730 --> 00:14:17,400
Andiamo ora a scorrere verso il basso e vedere come getInt GetInt ha lavorato per tutto questo tempo.

239
00:14:17,400 --> 00:14:19,460
Qui ci sono commenti simili da prima.

240
00:14:19,460 --> 00:14:21,660
Vorrei ingrandire solo la porzione di codice.

241
00:14:21,660 --> 00:14:23,900
E quello che abbiamo per GetInt è la seguente.

242
00:14:23,900 --> 00:14:25,700
Ci vuole nessun input.

243
00:14:25,700 --> 00:14:29,510
Esso restituisce un int, while (true), quindi abbiamo un ciclo infinito deliberata,

244
00:14:29,510 --> 00:14:33,180
ma presumibilmente faremo uscire da questo in qualche modo o da restituire all'interno di questo.

245
00:14:33,180 --> 00:14:34,870
>> Vediamo come funziona.

246
00:14:34,870 --> 00:14:39,240
Ci sembrano utilizzare GetString in questa prima linea all'interno del ciclo, 166.

247
00:14:39,240 --> 00:14:43,780
Questo è ora buona pratica perché in quali circostanze potrebbe tornare GetString

248
00:14:43,780 --> 00:14:47,660
la parola chiave null speciale? >> [Studente] Se qualcosa va storto.

249
00:14:47,660 --> 00:14:51,630
Se qualcosa va storto. E cosa potrebbe andare male quando si chiama qualcosa come GetString?

250
00:14:54,960 --> 00:14:57,640
Gia '. >> [Studente] Malloc non riesce a dare le int.

251
00:14:57,640 --> 00:14:59,150
Gia '. Forse malloc fallisce.

252
00:14:59,150 --> 00:15:03,190
Da qualche parte sotto il cofano, GetString sta chiamando malloc, che alloca la memoria,

253
00:15:03,190 --> 00:15:06,020
che consente al negozio di computer tutti i personaggi

254
00:15:06,020 --> 00:15:07,750
che l'utente digita nella tastiera.

255
00:15:07,750 --> 00:15:11,590
E se l'utente ha avuto un sacco di tempo libero e scritto di più, per esempio,

256
00:15:11,590 --> 00:15:16,160
di 2 miliardi di caratteri, numero di caratteri superiore al computer ha anche RAM.

257
00:15:16,160 --> 00:15:19,250
GetString deve essere in grado di indicare che vi.

258
00:15:19,250 --> 00:15:22,560
Anche se questo è un super, super-angolo caso non comune,

259
00:15:22,560 --> 00:15:24,340
deve essere in qualche modo in grado di gestire questo,

260
00:15:24,340 --> 00:15:28,750
e così GetString, se siamo andati indietro e leggere la sua documentazione, fa in NULL fatto ritorno.

261
00:15:28,750 --> 00:15:34,460
Così ora se GetString fallisce restituendo NULL, GetInt sta per fallire restituendo INT_MAX

262
00:15:34,460 --> 00:15:37,690
proprio come una sentinella. Questi sono solo convenzioni umane.

263
00:15:37,690 --> 00:15:41,450
L'unico modo sarebbe che questo è il caso è quello di leggere la documentazione.

264
00:15:41,450 --> 00:15:45,040
>> Facciamo scorrere fino al punto in cui l'int è effettivamente ottenuto.

265
00:15:45,040 --> 00:15:51,160
Se scorrere verso il basso un po 'più, in linea 170, abbiamo un commento di cui sopra queste righe.

266
00:15:51,160 --> 00:15:55,100
Si dichiara nel 172 un int, n, e un char, c, e quindi questa nuova funzione,

267
00:15:55,100 --> 00:15:58,930
che alcuni di voi hanno imbattuto prima, sscanf.

268
00:15:58,930 --> 00:16:00,870
Questo sta per scanf stringa.

269
00:16:00,870 --> 00:16:05,700
In altre parole, dammi una stringa e lo esamina per pezzi di informazioni di interesse.

270
00:16:05,700 --> 00:16:07,360
Che cosa vuol dire?

271
00:16:07,360 --> 00:16:11,800
Supponiamo che digito, letteralmente, 123 alla tastiera e poi premere Invio.

272
00:16:11,800 --> 00:16:16,470
Qual è il tipo di dati di 123 in caso di ritorno da GetString? >> [Studente] Stringa.

273
00:16:16,470 --> 00:16:18,380
E 'ovviamente una stringa, giusto? Ho una stringa.

274
00:16:18,380 --> 00:16:23,220
Quindi 123 è davvero, quote-unquote, 123 con il \ 0 alla fine di esso.

275
00:16:23,220 --> 00:16:27,110
Questo non è un int. Questo non è un numero. Si presenta come un numero, ma non è in realtà.

276
00:16:27,110 --> 00:16:29,080
Così che cosa GetInt fare?

277
00:16:29,080 --> 00:16:35,750
Si deve esaminare la stringa da sinistra a destra - 123 \ 0 - e in qualche modo convertire in numero intero reale.

278
00:16:35,750 --> 00:16:37,850
Si può capire come fare questo.

279
00:16:37,850 --> 00:16:41,450
Se ripenso a pset2, che presumibilmente ottenuto un po 'confortevole con Cesare

280
00:16:41,450 --> 00:16:44,820
o Vigenère, in modo da poter scorrere una stringa, è possibile convertire i caratteri da int.

281
00:16:44,820 --> 00:16:46,710
Ma diamine, è un sacco di lavoro.

282
00:16:46,710 --> 00:16:49,860
Perché non chiamare una funzione come sscanf che fa per voi?

283
00:16:49,860 --> 00:16:54,230
Così sscanf si aspetta un argomento - in questo caso chiamato linea, che è una stringa.

284
00:16:54,230 --> 00:17:01,840
È quindi possibile specificare tra virgolette, molto simile a printf, che cosa vi aspettate di vedere in questa stringa.

285
00:17:01,840 --> 00:17:09,000
E quello che sto dicendo qui è mi aspetto di vedere un numero decimale e forse un carattere.

286
00:17:09,000 --> 00:17:12,000
E vedremo perché questo è il caso in un attimo.

287
00:17:12,000 --> 00:17:15,869
E si scopre che questa notazione è ora ricorda di cose abbiamo iniziato a parlare

288
00:17:15,869 --> 00:17:17,619
poco più di una settimana fa.

289
00:17:17,619 --> 00:17:21,740
Che cosa è & n e & c facendo per noi qui? >> [Studente] Indirizzo di n e l'indirizzo di c.

290
00:17:21,740 --> 00:17:25,400
Gia '. Mi sta dando l'indirizzo di n e l'indirizzo di c. Perché è così importante?

291
00:17:25,400 --> 00:17:30,220
Voi sapete che con le funzioni in C, si può sempre restituire un valore o nessun valore.

292
00:17:30,220 --> 00:17:34,530
È possibile restituire un int, una stringa, un galleggiante, un char, qualunque cosa, oppure è possibile restituire void,

293
00:17:34,530 --> 00:17:38,030
ma si può restituire solo una cosa al massimo.

294
00:17:38,030 --> 00:17:42,760
Ma qui vogliamo sscanf tornare me forse un int, un numero decimale,

295
00:17:42,760 --> 00:17:46,220
e anche un char, e ti spiego il perché il carattere in un momento.

296
00:17:46,220 --> 00:17:51,460
Si effettivamente desidera sscanf tornare due cose, ma non è solo possibile in C.

297
00:17:51,460 --> 00:17:55,200
È possibile lavorare in giro che passando in due indirizzi

298
00:17:55,200 --> 00:17:57,370
perché non appena vi consegnerà una funzione di due indirizzi,

299
00:17:57,370 --> 00:18:00,470
che cosa può fare con loro funzione? >> [Studente] Scrivi a quegli indirizzi.

300
00:18:00,470 --> 00:18:02,010
E 'in grado di scrivere a questi indirizzi.

301
00:18:02,010 --> 00:18:05,770
È possibile utilizzare l'operazione di stella e andare lì, a ciascuna di tali indirizzi.

302
00:18:05,770 --> 00:18:11,260
È un po 'questo meccanismo di back-door, ma molto comune per la modifica dei valori delle variabili

303
00:18:11,260 --> 00:18:14,870
più di un luogo - in questo caso, due.

304
00:18:14,870 --> 00:18:21,340
Ora notate sto controllando == 1 e poi tornare n se si, in effetti, restituiscono true.

305
00:18:21,340 --> 00:18:26,170
Allora, cosa sta succedendo? Tecnicamente, tutto quello che vuole veramente accadere in GetInt è questo.

306
00:18:26,170 --> 00:18:30,740
Vogliamo analizzare, per così dire, vogliamo leggere la stringa - fine citazione quote-123 -

307
00:18:30,740 --> 00:18:34,560
e se sembra che ci sia un numero, quello che stiamo dicendo di fare sscanf

308
00:18:34,560 --> 00:18:38,190
è mettere quel numero - 123 - in questa variabile n per me.

309
00:18:38,190 --> 00:18:42,090
Perché allora io in realtà sono anche questo?

310
00:18:42,090 --> 00:18:48,220
Qual è il ruolo di sscanf dicendo che si potrebbe anche ottenere un carattere qui?

311
00:18:48,220 --> 00:18:53,470
[Risposta degli studenti incomprensibile] >> Un punto decimale in realtà potrebbe funzionare.

312
00:18:53,470 --> 00:18:56,330
Facciamo ritengono che pensò per un momento. Che altro?

313
00:18:56,330 --> 00:18:59,270
[Studente] Potrebbe essere NULL. >> Buon pensiero. Potrebbe essere il carattere null.

314
00:18:59,270 --> 00:19:01,660
Non è in realtà in questo caso. Gia '. >> [Studente] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. Oppure vorrei generalizzare ancora di più.

316
00:19:04,340 --> 00:19:06,640
Il c% è solo per il controllo degli errori.

317
00:19:06,640 --> 00:19:09,300
Non vogliamo che ci sia un carattere dopo il numero,

318
00:19:09,300 --> 00:19:11,870
ma ciò che questo mi permette di fare è la seguente.

319
00:19:11,870 --> 00:19:18,210
Risulta che sscanf, oltre a memorizzare i valori N e C in questo esempio qui,

320
00:19:18,210 --> 00:19:24,890
quello che fa è anche restituisce il numero di variabili messo valori trovi

321
00:19:24,890 --> 00:19:30,260
Quindi, se solo digitare 123, quindi solo il% d sta per corrispondenza,

322
00:19:30,260 --> 00:19:33,880
e solo n viene memorizzato con un valore come 123,

323
00:19:33,880 --> 00:19:35,640
e nulla viene messo in c.

324
00:19:35,640 --> 00:19:37,620
C resta un valore spazzatura, per così dire -

325
00:19:37,620 --> 00:19:40,730
spazzatura perché non è mai stato inizializzato a un valore.

326
00:19:40,730 --> 00:19:45,520
Quindi, in questo caso, sscanf restituisce 1 perché ho popolato 1 di tali puntatori,

327
00:19:45,520 --> 00:19:50,190
in questo caso grande, ho un int in modo da liberare la linea per liberare la memoria

328
00:19:50,190 --> 00:19:54,000
che GetString effettivamente stanziato, e poi torno n,

329
00:19:54,000 --> 00:19:58,500
altrimenti se siete mai chiesti dove Riprova dichiarazione che viene, viene da qui.

330
00:19:58,500 --> 00:20:04,390
Quindi, se, al contrario, di tipo I in 123foo - solo una sequenza casuale di testo -

331
00:20:04,390 --> 00:20:08,490
sscanf è andare a vedere il numero, numero, numero, f,

332
00:20:08,490 --> 00:20:16,410
e sta andando a mettere il 123 in n; sta andando a mettere il f in c e poi tornare 2.

333
00:20:16,410 --> 00:20:20,640
Così abbiamo, usando solo la definizione di base del comportamento sscanf, un modo molto semplice -

334
00:20:20,640 --> 00:20:23,900
bene, complesso a prima vista, ma alla fine della giornata meccanismo abbastanza semplice -

335
00:20:23,900 --> 00:20:28,320
di dire vi è un int e in tal caso, è che l'unica cosa che ho trovato?

336
00:20:28,320 --> 00:20:29,860
E lo spazio bianco qui è intenzionale.

337
00:20:29,860 --> 00:20:34,000
Se andate a leggere la documentazione per sscanf, ti dice che se si include un pezzo di spazio bianco

338
00:20:34,000 --> 00:20:38,810
all'inizio o alla fine, sscanf troppo permetterà all'utente, per qualsiasi motivo,

339
00:20:38,810 --> 00:20:41,860
per toccare 123 bar nello spazio e che sarà legittimo.

340
00:20:41,860 --> 00:20:44,150
Non urlare l'utente solo perché hanno colpito la barra spaziatrice

341
00:20:44,150 --> 00:20:48,640
all'inizio o alla fine, che è solo un po 'più user-friendly.

342
00:20:48,640 --> 00:20:52,300
>> Tutte le domande poi su GetInt? Gia '. >> [Studente] Che cosa succede se hai appena messo in un char?

343
00:20:52,300 --> 00:20:54,030
Bella domanda.

344
00:20:54,030 --> 00:20:59,890
Che cosa succede se hai appena digitato un carattere come f e premere Invio senza mai digitare 123?

345
00:20:59,890 --> 00:21:02,420
Cosa ne pensi del comportamento di questa riga di codice sarebbe allora?

346
00:21:02,420 --> 00:21:04,730
[Risposta degli studenti incomprensibile]

347
00:21:04,730 --> 00:21:08,790
Si ', quindi sscanf in grado di coprire anche questo perché in quel caso, non sta andando a riempire n o c.

348
00:21:08,790 --> 00:21:15,310
E 'intenzione di tornare invece 0, nel qual caso sto anche la cattura di questo scenario

349
00:21:15,310 --> 00:21:18,750
perché il valore atteso che voglio è 1.

350
00:21:18,750 --> 00:21:22,000
Voglio solo una e una sola cosa da riempire. Bella domanda.

351
00:21:22,000 --> 00:21:24,290
>> Altri? Bene.

352
00:21:24,290 --> 00:21:26,250
>> Non lasciare che il passare attraverso tutte le funzioni qui dentro,

353
00:21:26,250 --> 00:21:29,500
ma quello che sembra essere forse interessante rimanente è GetString

354
00:21:29,500 --> 00:21:32,790
perché si scopre che getFloat, GetInt, GetDouble, GetLongLong

355
00:21:32,790 --> 00:21:36,260
tutti i punt un sacco di loro funzionalità per GetString.

356
00:21:36,260 --> 00:21:39,750
Quindi, diamo uno sguardo a come si è implementato qui.

357
00:21:39,750 --> 00:21:43,630
Questo sembra un po 'complessa, ma utilizza i fondamenti stessi

358
00:21:43,630 --> 00:21:45,670
che abbiamo iniziato a parlare la settimana scorsa.

359
00:21:45,670 --> 00:21:49,490
In GetString, che prende alcun argomento secondo il vuoto qui

360
00:21:49,490 --> 00:21:53,730
e restituisce una stringa, a quanto pare mi dichiaro una stringa chiamata buffer.

361
00:21:53,730 --> 00:21:56,270
Io non so davvero che cosa che sta per essere utilizzato per ancora, ma staremo a vedere.

362
00:21:56,270 --> 00:21:58,390
Sembra che la capacità è di default 0.

363
00:21:58,390 --> 00:22:01,350
Non del tutto sicuro di dove questo sta andando, non so cosa n sta per essere utilizzato per ancora,

364
00:22:01,350 --> 00:22:03,590
ma ora sta diventando un po 'più interessante.

365
00:22:03,590 --> 00:22:06,520
In linea 243, dichiariamo un int, c.

366
00:22:06,520 --> 00:22:08,800
Questa è una sorta di un dettaglio stupido.

367
00:22:08,800 --> 00:22:15,820
Un char è di 8 bit, e 8 bit in grado di memorizzare il numero di valori diversi? >> [Studente] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
Il problema è che se si vuole avere 256 caratteri ASCII diversi, i quali vi sono

369
00:22:20,730 --> 00:22:23,340
se si pensa di nuovo - e questo non è una cosa da memorizzare.

370
00:22:23,340 --> 00:22:25,710
Ma se ripenso a quel grande grafico ASCII abbiamo avuto settimane fa,

371
00:22:25,710 --> 00:22:30,600
ci sono stati in questo caso 128 o 256 caratteri ASCII.

372
00:22:30,600 --> 00:22:32,940
Abbiamo usato tutti i modelli fino 0 e 1.

373
00:22:32,940 --> 00:22:36,210
Questo è un problema se si vuole essere in grado di rilevare un errore

374
00:22:36,210 --> 00:22:40,190
perché se si sta già utilizzando 256 valori per i tuoi personaggi,

375
00:22:40,190 --> 00:22:43,050
che in realtà non pianificare in anticipo, perché ora non avete modo di dire,

376
00:22:43,050 --> 00:22:46,270
questo non è un carattere legittimo, questo è un messaggio errato.

377
00:22:46,270 --> 00:22:50,270
Quindi, ciò che il mondo non è che usano il valore più prossimo, qualcosa di simile a un int,

378
00:22:50,270 --> 00:22:54,720
in modo da avere un numero pazzesco di bit, 32, per 4 miliardi di possibili valori

379
00:22:54,720 --> 00:22:58,860
in modo che si può semplicemente finire con essenzialmente 257 di loro,

380
00:22:58,860 --> 00:23:01,720
Uno dei quali ha un significato speciale come un errore.

381
00:23:01,720 --> 00:23:03,120
>> Quindi cerchiamo di vedere come funziona.

382
00:23:03,120 --> 00:23:07,760
In linea 246, ho questo grande anello mentre quello sta chiamando fgetc,

383
00:23:07,760 --> 00:23:11,090
f file significato, così getc, e poi stdin.

384
00:23:11,090 --> 00:23:15,520
Si scopre questo è solo il modo più preciso per dire leggere l'input da tastiera.

385
00:23:15,520 --> 00:23:19,300
Tastiera standard mezzi di input, standard output significa schermo,

386
00:23:19,300 --> 00:23:23,310
e l'errore standard, che vedremo nel pset4, significa che lo schermo

387
00:23:23,310 --> 00:23:27,490
ma una parte speciale dello schermo in modo che non è tutt'uno con uscita effettiva

388
00:23:27,490 --> 00:23:30,750
che si intende stampare. Ma più su che in futuro.

389
00:23:30,750 --> 00:23:34,440
Così fgetc significa solo leggere un carattere dalla tastiera e conservarla dove?

390
00:23:34,440 --> 00:23:37,350
Conservare in c.

391
00:23:37,350 --> 00:23:41,360
E quindi controllare - quindi sto usando solo alcune congiunzioni booleane qui -

392
00:23:41,360 --> 00:23:46,000
verificare che non è uguale a - \ n, in modo che l'utente ha premere Invio, si vuole fermare a quel punto,

393
00:23:46,000 --> 00:23:49,850
fine del ciclo - e vogliamo anche per verificare la costante EOF speciale,

394
00:23:49,850 --> 00:23:53,610
che se si conosce o indovinare, che cosa rappresenta? >> [Studente] Fine del file. Fine >> del file.

395
00:23:53,610 --> 00:23:56,560
Questa è una specie di assurdo, perché se sto scrivendo sulla tastiera,

396
00:23:56,560 --> 00:23:58,870
non c'è davvero alcun file coinvolti in questo,

397
00:23:58,870 --> 00:24:01,150
ma questa è solo una specie di termine generico usato per indicare

398
00:24:01,150 --> 00:24:04,220
che nessun altro è in arrivo dalle dita del dell'essere umano.

399
00:24:04,220 --> 00:24:06,460
EOF - fine del file.

400
00:24:06,460 --> 00:24:09,920
Per inciso, se hai mai colpito Control D a vostra tastiera non, che si dovrebbe ancora -

401
00:24:09,920 --> 00:24:15,230
hai colpito di controllo C - Control D invia questa costante speciale chiamato EOF.

402
00:24:15,230 --> 00:24:19,850
Così ora non ci resta che un po 'di allocazione dinamica della memoria.

403
00:24:19,850 --> 00:24:23,440
>> Quindi, se (n + 1 capacità>). Ora ti spiego n.

404
00:24:23,440 --> 00:24:26,100
N è solo il numero di byte attualmente nel buffer,

405
00:24:26,100 --> 00:24:28,620
la stringa che si sta costruendo da parte dell'utente.

406
00:24:28,620 --> 00:24:33,450
Se si dispone di più caratteri nel buffer di quello che hai capacità nel buffer,

407
00:24:33,450 --> 00:24:37,410
intuitivamente quello che dobbiamo fare è quindi allocare più capacità.

408
00:24:37,410 --> 00:24:43,330
Quindi ho intenzione di sorvolare su alcune delle aritmetica qui e concentrarsi solo su questa funzione qui.

409
00:24:43,330 --> 00:24:46,070
Sai cosa malloc è o sono almeno generalmente familiare.

410
00:24:46,070 --> 00:24:48,970
Prova a indovinare cosa realloc fa. >> [Studente] Aggiunge memoria.

411
00:24:48,970 --> 00:24:52,920
Non è del tutto l'aggiunta di memoria. Esso rialloca memoria come segue.

412
00:24:52,920 --> 00:24:57,220
Se c'è ancora spazio alla fine della stringa per dare più di quel ricordo

413
00:24:57,220 --> 00:25:00,000
che dà origine, allora si otterrà che la memoria aggiuntiva.

414
00:25:00,000 --> 00:25:03,460
Così si può solo continuare a mettere i caratteri della stringa, back to back to back to back.

415
00:25:03,460 --> 00:25:05,830
Ma se non è questo il caso, perché hai aspettato troppo a lungo

416
00:25:05,830 --> 00:25:07,940
e qualcosa di casuale ha lasciato cadere in memoria ci

417
00:25:07,940 --> 00:25:10,290
ma non c'è memoria aggiuntiva qui, va bene.

418
00:25:10,290 --> 00:25:13,100
Realloc sta andando a fare tutto il lavoro pesante per voi,

419
00:25:13,100 --> 00:25:16,750
spostare la stringa che hai letto in modo molto lontano da qui, messo lì,

420
00:25:16,750 --> 00:25:19,460
e poi vi darà pista ancora un po 'a quel punto.

421
00:25:19,460 --> 00:25:22,550
>> Così, con un gesto della mano, lasciatemi dire che quello che sta facendo GetString

422
00:25:22,550 --> 00:25:26,330
si sta partendo con un buffer piccolo, forse un singolo carattere,

423
00:25:26,330 --> 00:25:30,820
e se l'utente digita in due personaggi, GetString finisce per chiamare realloc e dice:

424
00:25:30,820 --> 00:25:33,150
un personaggio non era abbastanza, dammi due caratteri.

425
00:25:33,150 --> 00:25:35,950
Poi se si legge attraverso la logica del ciclo, sta andando a dire

426
00:25:35,950 --> 00:25:39,600
l'utente ha digitato in 3 caratteri; mi danno ora non 2 ma 4 caratteri,

427
00:25:39,600 --> 00:25:42,320
allora dammi 8, poi dammi 16 e 32.

428
00:25:42,320 --> 00:25:45,000
Il fatto che io sono il raddoppio della capacità di volta in volta

429
00:25:45,000 --> 00:25:48,570
significa che il buffer non ha intenzione di crescere lentamente, sta andando a crescere super veloce.

430
00:25:48,570 --> 00:25:51,380
E quale potrebbe essere il vantaggio di questo?

431
00:25:51,380 --> 00:25:54,600
Perché sto raddoppiare la dimensione del buffer

432
00:25:54,600 --> 00:25:58,020
anche se l'utente può solo bisogno di un carattere in più dalla tastiera?

433
00:25:58,020 --> 00:26:01,750
[Risposta degli studenti incomprensibile] >> Che cos'è? >> [Studente] Non c'è bisogno di crescere come spesso.

434
00:26:01,750 --> 00:26:03,300
Esattamente. Non c'è bisogno di crescere come spesso.

435
00:26:03,300 --> 00:26:05,510
E questo è solo tipo di copertura che stai qui le vostre scommesse,

436
00:26:05,510 --> 00:26:10,850
l'idea è che non si vuole chiamare realloc molto perché tende ad essere lento.

437
00:26:10,850 --> 00:26:12,910
Ogni volta che si chiede il sistema operativo per la memoria,

438
00:26:12,910 --> 00:26:16,990
come vedrete presto in un set di problema futuro, tende a richiedere un certo tempo.

439
00:26:16,990 --> 00:26:20,010
Quindi, riducendo al minimo tale periodo di tempo, anche se si sta perdendo un po 'di spazio,

440
00:26:20,010 --> 00:26:21,900
tende ad essere una buona cosa.

441
00:26:21,900 --> 00:26:24,060
>> Ma se si legge attraverso la parte finale del GetString qui -

442
00:26:24,060 --> 00:26:27,950
e ancora capire ogni singola riga qui non è così importante oggi -

443
00:26:27,950 --> 00:26:30,530
notare che alla fine chiama malloc di nuovo

444
00:26:30,530 --> 00:26:33,880
e alloca esattamente byte quanti ne sono necessari per la stringa

445
00:26:33,880 --> 00:26:38,060
e poi getta via chiamando gratuitamente il buffer di dimensioni eccessive

446
00:26:38,060 --> 00:26:40,080
se davvero ha raddoppiato troppe volte.

447
00:26:40,080 --> 00:26:42,730
Così, in breve, è così che GetString ha lavorato per tutto questo tempo.

448
00:26:42,730 --> 00:26:47,060
Tutto ciò che fa è leggere un carattere alla volta ancora e ancora e ancora,

449
00:26:47,060 --> 00:26:50,750
e ogni volta che ha bisogno di un po 'di memoria aggiuntiva, si chiede al sistema operativo per lo

450
00:26:50,750 --> 00:26:53,670
chiamando realloc.

451
00:26:53,670 --> 00:26:57,890
>> Hai ancora domande? Bene.

452
00:26:57,890 --> 00:26:59,270
>> Un attacco.

453
00:26:59,270 --> 00:27:04,060
Ora che abbiamo capito i puntatori o per lo meno sono sempre più familiari con i puntatori,

454
00:27:04,060 --> 00:27:06,700
prendiamo in considerazione come il mondo intero inizia a crollare

455
00:27:06,700 --> 00:27:10,030
se non riesco a difendersi contro gli utenti contraddittorio,

456
00:27:10,030 --> 00:27:11,850
le persone che stanno cercando di penetrare nel vostro sistema,

457
00:27:11,850 --> 00:27:16,890
persone che stanno cercando di rubare il software aggirando qualche codice di registrazione

458
00:27:16,890 --> 00:27:19,090
che potrebbero altrimenti essere necessario digitare trovi

459
00:27:19,090 --> 00:27:22,990
>> Date un'occhiata a questo esempio qui, che è solo il codice C che ha una funzione principale nella parte inferiore

460
00:27:22,990 --> 00:27:26,380
che chiama una funzione foo. E che cosa sta passando a foo?

461
00:27:26,380 --> 00:27:29,680
[Studente] Un singolo argomento. >> [Malan] Un singolo argomento.

462
00:27:29,680 --> 00:27:33,450
Quindi, argv [1], il che significa che la prima parola che l'utente ha digitato nella riga di comando

463
00:27:33,450 --> 00:27:36,360
dopo a.out o qualunque sia il programma si chiama.

464
00:27:36,360 --> 00:27:41,680
Così foo in alto prende in un char *. Ma char * è proprio quello? >> [Studente] Una stringa.

465
00:27:41,680 --> 00:27:43,350
[Malan] Una stringa, quindi non c'è nulla di nuovo qui.

466
00:27:43,350 --> 00:27:45,420
Tale stringa viene arbitrariamente chiamato bar.

467
00:27:45,420 --> 00:27:51,430
In questa linea qui, char c [12], in una sorta di semi-inglese tecnico, cosa sta facendo questa linea?

468
00:27:51,430 --> 00:27:55,220
[Studente] Matrice di - Array di >>? >> [Studente] caratteri. Personaggi >>.

469
00:27:55,220 --> 00:27:58,870
Dammi un array di 12 caratteri. Così si potrebbe chiamare questo un buffer.

470
00:27:58,870 --> 00:28:02,920
E 'tecnicamente chiamato c, ma un buffer in programmazione significa solo un mucchio di spazio

471
00:28:02,920 --> 00:28:04,800
che si può mettere un po 'di roba trovi

472
00:28:04,800 --> 00:28:07,940
Poi infine, memcpy non abbiamo usato prima, ma si può intuire ciò che fa.

473
00:28:07,940 --> 00:28:10,480
Esso copia della memoria. Che cosa fa?

474
00:28:10,480 --> 00:28:19,270
E a quanto pare copia bar, il suo ingresso, in c ma solo fino alla lunghezza della barra.

475
00:28:19,270 --> 00:28:24,930
Ma c'è un bug qui. >> [Studente] è necessario il carattere sizeof. Va bene >>.

476
00:28:24,930 --> 00:28:30,860
Tecnicamente, si dovrebbe davvero fare strlen (bar) * sizeof (char)). Questo è corretto.

477
00:28:30,860 --> 00:28:33,930
Ma nel peggiore dei casi qui, supponiamo che that's -

478
00:28:33,930 --> 00:28:35,950
Va bene. Poi ci sono due errori.

479
00:28:35,950 --> 00:28:39,160
Quindi, sizeof (char));

480
00:28:39,160 --> 00:28:41,290
Facciamo in modo che questo un po 'di più.

481
00:28:41,290 --> 00:28:44,910
Così ora c'è ancora un bug, che è quello che? >> [Risposta degli studenti incomprensibile]

482
00:28:44,910 --> 00:28:46,990
Controllare per cosa? >> [Studente] Verificare la presenza di NULL.

483
00:28:46,990 --> 00:28:50,270
Dovremmo essere generalmente controllando NULL perché le cose vanno così male

484
00:28:50,270 --> 00:28:53,200
quando il puntatore è NULL, perché si potrebbe finire per andare lì,

485
00:28:53,200 --> 00:28:57,630
e non si dovrebbe mai andare a NULL deferenziandolo con l'operatore stella.

486
00:28:57,630 --> 00:29:01,050
Quindi questo è un bene. E cos'altro stiamo facendo? Logicamente, c'è un difetto anche qui.

487
00:29:01,050 --> 00:29:04,450
[Studente] Controllare se argc è> = a 2.

488
00:29:04,450 --> 00:29:10,550
Quindi verificare se argc è> = 2. Ok, quindi ci sono tre errori in questo programma.

489
00:29:10,550 --> 00:29:16,630
Stiamo verificando se l'utente ha effettivamente digitato qualcosa in argv [1]. Buona.

490
00:29:16,630 --> 00:29:20,950
Allora qual è il bug terzo? Gia '. >> [Studente] C potrebbe non essere abbastanza grande.

491
00:29:20,950 --> 00:29:23,320
Buona. Abbiamo controllato uno scenario.

492
00:29:23,320 --> 00:29:29,520
Abbiamo controllato implicitamente non copiare più memoria di quella superare la lunghezza della barra.

493
00:29:29,520 --> 00:29:32,510
Quindi, se la stringa che l'utente digitato è di 10 caratteri,

494
00:29:32,510 --> 00:29:36,020
questo sta dicendo solo copiare 10 caratteri. E va bene così.

495
00:29:36,020 --> 00:29:39,940
Ma cosa succede se l'utente ha digitato in una parola al prompt come una parola di 20 caratteri?

496
00:29:39,940 --> 00:29:44,900
Questo sta dicendo copia 20 caratteri dalla barra in che cosa?

497
00:29:44,900 --> 00:29:49,750
C, altrimenti noto come il buffer, il che significa che i dati appena scritto

498
00:29:49,750 --> 00:29:52,540
a 8 posizioni di byte che non si è proprietari,

499
00:29:52,540 --> 00:29:54,870
e tu non ne sei il proprietario, nel senso che non li avete mai assegnato.

500
00:29:54,870 --> 00:30:00,370
Quindi questo è ciò che è comunemente noto come l'attacco di tipo buffer overflow o di sovraccarico del buffer di attacco.

501
00:30:00,370 --> 00:30:05,580
Ed è un attacco, nel senso che se l'utente o il programma che sta chiamando la funzione

502
00:30:05,580 --> 00:30:10,490
sta facendo questo maliziosamente, ciò che effettivamente accade prossimo potrebbe in realtà essere piuttosto male.

503
00:30:10,490 --> 00:30:12,450
>> Quindi diamo un'occhiata a questa immagine qui.

504
00:30:12,450 --> 00:30:16,060
Questa foto rappresenta la tua pila di memoria.

505
00:30:16,060 --> 00:30:19,580
Ricordiamo che ogni volta che si chiama una funzione si ottiene questo quadro poco nello stack

506
00:30:19,580 --> 00:30:21,520
e poi un altro e poi un altro e un altro.

507
00:30:21,520 --> 00:30:24,300
E fin qui, abbiamo solo un po 'astratta questi come rettangoli

508
00:30:24,300 --> 00:30:26,290
sia sul bordo o sulla schermata qui.

509
00:30:26,290 --> 00:30:30,580
Ma se zoomare su uno di quei rettangoli, quando si chiama una funzione foo,

510
00:30:30,580 --> 00:30:35,880
si scopre che c'è di più all'interno pila di quel frame in quel rettangolo

511
00:30:35,880 --> 00:30:40,060
non solo x e y e a e b, come abbiamo fatto parlare di swap.

512
00:30:40,060 --> 00:30:44,410
Si scopre che ci sono alcuni dettagli di basso livello, tra i quali l'indirizzo di ritorno.

513
00:30:44,410 --> 00:30:49,550
Così si scopre quando principale chiama foo, principale deve informare foo

514
00:30:49,550 --> 00:30:53,520
quale indirizzo principale è nella memoria del computer

515
00:30:53,520 --> 00:30:57,770
perché altrimenti, non appena foo è fatto esecuzione, come in questo caso qui,

516
00:30:57,770 --> 00:31:00,830
una volta raggiunto questo tutore chiuso riccio alla fine di foo,

517
00:31:00,830 --> 00:31:05,310
come cavolo si foo sa dove il controllo del programma dovrebbe andare?

518
00:31:05,310 --> 00:31:08,970
Si scopre che la risposta a questa domanda è in questo rettangolo rosso qui.

519
00:31:08,970 --> 00:31:12,670
Si tratta di un puntatore, e sta al computer per memorizzare temporaneamente

520
00:31:12,670 --> 00:31:17,030
sulla cosiddetta pila l'indirizzo principale in modo che non appena foo è fatto esecuzione,

521
00:31:17,030 --> 00:31:21,120
il computer sa dove e cosa linea principale per tornare a.

522
00:31:21,120 --> 00:31:23,940
Puntatore del fotogramma salvato si riferisce in modo simile a questo.

523
00:31:23,940 --> 00:31:26,310
Bar * Char qui rappresenta ciò?

524
00:31:26,310 --> 00:31:31,350
Ora questo segmento blu è qui cornice di foo. Che cosa è il bar?

525
00:31:31,570 --> 00:31:35,010
Bar è solo l'argomento per la funzione foo.

526
00:31:35,010 --> 00:31:37,500
Così ora siamo tornati a una sorta di quadro familiare.

527
00:31:37,500 --> 00:31:39,850
Ci sono più cose e più distrazioni sullo schermo,

528
00:31:39,850 --> 00:31:43,380
ma questo segmento azzurro è proprio quello che abbiamo disegnare alla lavagna

529
00:31:43,380 --> 00:31:45,790
per qualcosa come swap. Questo è il quadro per foo.

530
00:31:45,790 --> 00:31:51,490
E l'unica cosa che in questo momento è il bar, che è questo parametro.

531
00:31:51,490 --> 00:31:55,220
Ma che altro dovrebbe essere nello stack in base a questo codice qui?

532
00:31:55,220 --> 00:31:57,760
[Studente] char c [12]. >> [Malan] char c [12].

533
00:31:57,760 --> 00:32:02,810
Dovremmo anche vedere 12 quadrati di memoria assegnati a una variabile denominata c,

534
00:32:02,810 --> 00:32:04,970
e infatti noi abbiamo che sullo schermo.

535
00:32:04,970 --> 00:32:08,480
La cima è c [0], e poi l'autore di questo schema

536
00:32:08,480 --> 00:32:11,850
non si preoccupò di disegnare tutte le piazze, ma ci sono davvero 12 si

537
00:32:11,850 --> 00:32:16,590
perché se si guarda in basso a destra, c [11] se si conta da 0 è il byte 12 ° del genere.

538
00:32:16,590 --> 00:32:18,400
Ma ecco il problema.

539
00:32:18,400 --> 00:32:22,390
In quale direzione sta crescendo c?

540
00:32:22,390 --> 00:32:27,080
Sorta di top-down se inizia in alto e cresce verso il basso.

541
00:32:27,080 --> 00:32:30,110
Non sembra come ci siamo lasciati pista molto qui a tutti.

542
00:32:30,110 --> 00:32:32,090
Abbiamo tipo di noi stessi in un angolo,

543
00:32:32,090 --> 00:32:36,940
e che c [11] è proprio contro il bar, che si trova proprio di fronte puntatore del fotogramma salvato,

544
00:32:36,940 --> 00:32:39,960
che si trova proprio di fronte l'indirizzo di ritorno. Non c'è più spazio.

545
00:32:39,960 --> 00:32:42,810
Allora, qual è l'implicazione poi se si avvitare

546
00:32:42,810 --> 00:32:46,500
e provare a leggere 20 byte in un buffer di 12 byte?

547
00:32:46,500 --> 00:32:50,060
Dove questi 8 byte aggiuntivi intenzione di andare? >> [Studente] Inside -

548
00:32:50,060 --> 00:32:53,200
All'interno tutto il resto, alcuni dei quali è super importante.

549
00:32:53,200 --> 00:32:57,260
E la cosa più importante, potenzialmente, è la scatola rossa lì, indirizzo del mittente,

550
00:32:57,260 --> 00:33:03,560
perché supponiamo che si sia accidentalmente o contraddittorio sovrascrivere quei 4 byte,

551
00:33:03,560 --> 00:33:07,260
che l'indirizzo del puntatore, non solo ai rifiuti, ma con un numero di

552
00:33:07,260 --> 00:33:09,810
che succede a rappresentare un indirizzo effettivo in memoria.

553
00:33:09,810 --> 00:33:13,880
Qual è l'implicazione, logicamente? >> [Studente] Funzione sta per tornare in un luogo diverso.

554
00:33:13,880 --> 00:33:15,250
Esattamente.

555
00:33:15,250 --> 00:33:19,170
Quando ritorna foo e colpisce che parentesi graffe, il programma sta per procedere

556
00:33:19,170 --> 00:33:25,060
non per tornare alla pagina principale, sta andando per tornare a qualsiasi indirizzo si trova in quella scatola rossa.

557
00:33:25,060 --> 00:33:28,600
>> Nel caso di registrazione del software eludere,

558
00:33:28,600 --> 00:33:32,260
cosa succede se l'indirizzo che viene restituito è la funzione che normalmente viene chiamata

559
00:33:32,260 --> 00:33:35,690
dopo aver pagato per il software e immesso il codice di registrazione?

560
00:33:35,690 --> 00:33:39,870
È possibile ordinare di trucco del computer in non andare qui ma andando qui.

561
00:33:39,870 --> 00:33:45,100
Oppure, se sei davvero intelligente, un avversario può effettivamente digitare sulla tastiera, ad esempio,

562
00:33:45,100 --> 00:33:50,690
non una parola vera, non 20 caratteri, ma supponiamo lui o lei in realtà i tipi della

563
00:33:50,690 --> 00:33:52,770
alcuni personaggi che rappresentano il codice.

564
00:33:52,770 --> 00:33:55,320
E non sarà il codice C, in realtà sta per essere i personaggi

565
00:33:55,320 --> 00:33:59,290
che rappresentano il codice binario della macchina, 0 e 1.

566
00:33:59,290 --> 00:34:01,290
Ma se sono abbastanza intelligenti per farlo,

567
00:34:01,290 --> 00:34:06,500
per incollare in qualche modo in qualcosa GetString richiesta che è essenzialmente il codice compilato,

568
00:34:06,500 --> 00:34:09,980
e gli ultimi 4 byte sovrascrivere l'indirizzo di ritorno.

569
00:34:09,980 --> 00:34:13,360
E che cosa vuol indirizzo di ingresso fare?

570
00:34:13,360 --> 00:34:18,630
Memorizza effettivamente in questo rettangolo rosso l'indirizzo del primo byte del buffer.

571
00:34:18,630 --> 00:34:23,070
Quindi devi essere molto intelligente, e questo è un sacco di tentativi ed errori per le persone cattive là fuori,

572
00:34:23,070 --> 00:34:25,639
ma se si riesce a capire quanto è grande questo buffer è

573
00:34:25,639 --> 00:34:28,820
tale che gli ultimi bytes nell'input fornire al programma

574
00:34:28,820 --> 00:34:33,540
capita di essere equivalente al indirizzo iniziale del buffer, si può fare questo.

575
00:34:33,540 --> 00:34:39,320
Se diciamo di solito ciao e \ 0, questo è ciò che finisce nel buffer.

576
00:34:39,320 --> 00:34:44,420
Ma se siamo più intelligenti e riempire il buffer con quello che ci chiamiamo genericamente codice di attacco -

577
00:34:44,420 --> 00:34:48,860
AAA, attacco, attacco, attacco - dove questo è solo qualcosa che fa qualcosa di male,

578
00:34:48,860 --> 00:34:51,820
cosa succede se sei molto intelligente, si potrebbe fare questo.

579
00:34:51,820 --> 00:34:58,610
Nella scatola rossa qui è una sequenza di numeri - 80, C0, 35, 08.

580
00:34:58,610 --> 00:35:01,610
Si noti che che corrisponde al numero che è qui.

581
00:35:01,610 --> 00:35:04,430
E 'in ordine inverso, ma più su che un'altra volta.

582
00:35:04,430 --> 00:35:08,140
Si noti che questo indirizzo di ritorno siano stati deliberatamente modificati

583
00:35:08,140 --> 00:35:12,020
per eguagliare l'indirizzo qui, non l'indirizzo del principale.

584
00:35:12,020 --> 00:35:17,500
Quindi, se il cattivo è super intelligente, lui o lei sta andando a includere in tale codice di attacco

585
00:35:17,500 --> 00:35:20,930
qualcosa di simile a eliminare tutti i file dell'utente o copiare le password

586
00:35:20,930 --> 00:35:24,680
o creare un account utente che posso quindi accedere al - nulla.

587
00:35:24,680 --> 00:35:26,950
>> E questo è sia il pericolo e il potere di C.

588
00:35:26,950 --> 00:35:29,840
Perché si ha accesso alla memoria tramite puntatori

589
00:35:29,840 --> 00:35:32,520
e si può quindi scrivere tutto quello che vuoi nella memoria di un computer,

590
00:35:32,520 --> 00:35:35,080
si può fare un computer a fare tutto quello che vuoi

591
00:35:35,080 --> 00:35:39,550
semplicemente averlo saltare nel suo spazio di memoria.

592
00:35:39,550 --> 00:35:44,650
E così fino ad oggi tanti programmi e siti web così tanti che sono compromessi

593
00:35:44,650 --> 00:35:46,200
si riducono a persone che beneficiano di questo.

594
00:35:46,200 --> 00:35:50,760
E questo potrebbe sembrare un attacco super sofisticato, ma non sempre iniziare in quel modo.

595
00:35:50,760 --> 00:35:53,560
La realtà è che ciò che le persone cattive in genere fare è,

596
00:35:53,560 --> 00:35:58,200
se si tratta di un programma a riga di comando o un programma con interfaccia grafica o un sito web,

597
00:35:58,200 --> 00:35:59,940
basta iniziare a fornire una sciocchezza.

598
00:35:59,940 --> 00:36:03,980
Si digita in una parola molto grande nel campo di ricerca e premere Invio,

599
00:36:03,980 --> 00:36:05,780
e si aspetta di vedere se il sito si blocca

600
00:36:05,780 --> 00:36:09,990
o si aspetta di vedere se il programma si manifesta qualche messaggio di errore

601
00:36:09,990 --> 00:36:14,330
perché se sei fortunato come il cattivo e di fornire alcuni input pazzo

602
00:36:14,330 --> 00:36:18,980
che va in crash il programma, che significa che il programmatore non ha previsto il tuo cattivo comportamento,

603
00:36:18,980 --> 00:36:23,630
il che significa che si può probabilmente con uno sforzo sufficiente prova, abbastanza ed errori,

604
00:36:23,630 --> 00:36:26,650
capire come condurre un attacco più preciso.

605
00:36:26,650 --> 00:36:31,410
Così tanto una parte della sicurezza non è solo di evitare questi attacchi del tutto

606
00:36:31,410 --> 00:36:34,100
ma li avverte e in realtà guardando i log

607
00:36:34,100 --> 00:36:36,780
e vedere quali fattori pazzi sono persone digitato nel tuo sito web,

608
00:36:36,780 --> 00:36:38,960
quali termini di ricerca sono le persone digitato nel tuo sito web

609
00:36:38,960 --> 00:36:42,870
nella speranza di un po 'di traboccante buffer.

610
00:36:42,870 --> 00:36:45,500
E questo tutto si riduce a semplici le basi di ciò che è un array

611
00:36:45,500 --> 00:36:49,080
e cosa significa per allocare e utilizzare la memoria.

612
00:36:49,080 --> 00:36:51,710
>> Relativo a che poi è anche questo.

613
00:36:51,710 --> 00:36:54,280
Diciamo solo un'occhiata all'interno di un hard disk ancora una volta.

614
00:36:54,280 --> 00:36:58,440
Vi ricordate di una o due settimane fa, che quando si trascina i file sul cestino o cestino,

615
00:36:58,440 --> 00:37:03,710
che cosa succede? >> [Studente] Niente. >> Assolutamente niente, giusto?

616
00:37:03,710 --> 00:37:05,740
Alla fine se si esegue poco spazio su disco,

617
00:37:05,740 --> 00:37:08,190
Windows o Mac OS avvierà l'eliminazione dei file per te.

618
00:37:08,190 --> 00:37:10,390
Ma se si trascina qualcosa in là, che non è affatto sicuro.

619
00:37:10,390 --> 00:37:13,800
Tutto il tuo compagno di stanza o un amico o un familiare ha a che fare un doppio clic e, voilà,

620
00:37:13,800 --> 00:37:16,310
ci sono tutti i file abbozzato che stai cercando di eliminare.

621
00:37:16,310 --> 00:37:19,590
La maggior parte di noi almeno sappiamo che è necessario fare clic destro o di controllo fare clic su

622
00:37:19,590 --> 00:37:22,310
e svuotare il cestino o qualcosa del genere.

623
00:37:22,310 --> 00:37:25,000
Ma anche allora che non farà il trucco

624
00:37:25,000 --> 00:37:28,010
perché ciò che succede quando si ha un file sul disco rigido

625
00:37:28,010 --> 00:37:32,770
che rappresenta circa il documento di Word o un JPEG, e questo rappresenta il disco rigido,

626
00:37:32,770 --> 00:37:35,350
e diciamo che questo frammento qui rappresenta quel file,

627
00:37:35,350 --> 00:37:38,390
ed è composto da un insieme di 0 e 1.

628
00:37:38,390 --> 00:37:42,470
Cosa succede quando non solo trascinare il file nel cestino o nel cestino

629
00:37:42,470 --> 00:37:48,020
ma anche svuotarla? Una specie di nulla.

630
00:37:48,020 --> 00:37:49,640
Non è assolutamente nulla.

631
00:37:49,640 --> 00:37:54,290
Ora è solo niente perché un po 'di qualcosa che accade in forma di questa tabella.

632
00:37:54,290 --> 00:37:58,370
Quindi c'è una sorta di database o una tabella all'interno della memoria di un computer

633
00:37:58,370 --> 00:38:03,850
che ha essenzialmente una colonna per i nomi dei file e una colonna per i file 'ubicazione,

634
00:38:03,850 --> 00:38:07,720
in cui questo potrebbe essere posizione 123, solo un numero casuale.

635
00:38:07,720 --> 00:38:14,560
Così potremmo avere qualcosa di simile a x.jpeg e la posizione 123.

636
00:38:14,560 --> 00:38:18,800
Che cosa succede allora quando effettivamente svuotare il cestino?

637
00:38:18,800 --> 00:38:20,330
Che se ne va.

638
00:38:20,330 --> 00:38:23,610
Ma ciò che non va via è la 0 e 1.

639
00:38:23,610 --> 00:38:26,270
>> Allora, qual è quindi la connessione al pset4?

640
00:38:26,270 --> 00:38:31,240
Bene, con pset4, solo perché abbiamo accidentalmente cancellato la scheda Compact Flash

641
00:38:31,240 --> 00:38:35,750
che aveva tutte queste foto o semplicemente perché dalla sfortuna è corrotto

642
00:38:35,750 --> 00:38:38,000
non significa che la 0 e 1 non sono ancora lì.

643
00:38:38,000 --> 00:38:40,410
Forse alcuni di loro si perdono perché qualcosa ha danneggiato

644
00:38:40,410 --> 00:38:43,320
nel senso che alcuni 0s divenne 1s 1s e 0s diventato.

645
00:38:43,320 --> 00:38:47,240
Le cose brutte possono accadere a causa di software difettoso o hardware difettoso.

646
00:38:47,240 --> 00:38:50,370
Ma molti di questi frammenti, forse anche il 100% di loro, sono ancora lì.

647
00:38:50,370 --> 00:38:55,050
E 'solo che il computer o la fotocamera non sa dove JPEG1 cominciato

648
00:38:55,050 --> 00:38:56,910
e dove JPEG2 iniziato.

649
00:38:56,910 --> 00:39:01,070
Ma se si, il programmatore, sapere con un po 'di buon senso in cui tali file JPEG sono

650
00:39:01,070 --> 00:39:06,010
o il loro aspetto in modo da poter analizzare la 0 e 1 e dire: JPEG, JPEG,

651
00:39:06,010 --> 00:39:09,440
è possibile scrivere un programma con essenzialmente solo un ciclo for o while

652
00:39:09,440 --> 00:39:12,820
che recupera ognuno di quei file.

653
00:39:12,820 --> 00:39:16,030
Quindi la lezione è quindi di avviare in modo sicuro cancellare i file

654
00:39:16,030 --> 00:39:18,340
se vuoi evitare questo del tutto. Sì.

655
00:39:18,340 --> 00:39:21,010
>> [Studente] Come mai si dice sul tuo computer

656
00:39:21,010 --> 00:39:23,550
di avere più memoria di quella che hai fatto prima?

657
00:39:23,550 --> 00:39:27,820
Avere più memoria di quanto si faceva prima - >> [studente] più memoria disponibile.

658
00:39:27,820 --> 00:39:29,630
Oh. Bella domanda.

659
00:39:29,630 --> 00:39:32,360
Allora, perché poi dopo lo svuotamento del cestino del computer non vi dico

660
00:39:32,360 --> 00:39:34,910
di avere più spazio libero che avete fatto prima?

661
00:39:34,910 --> 00:39:36,770
In poche parole, perché sta mentendo.

662
00:39:36,770 --> 00:39:40,740
Più tecnicamente, si ha più spazio perché ora che hai detto

663
00:39:40,740 --> 00:39:43,680
si può mettere altre cose in cui il file era una volta.

664
00:39:43,680 --> 00:39:45,450
Ma questo non significa che i bit stanno andando via,

665
00:39:45,450 --> 00:39:48,590
e questo non significa che i bit vengono modificate per tutti 0, per esempio,

666
00:39:48,590 --> 00:39:50,150
per la vostra protezione.

667
00:39:50,150 --> 00:39:54,640
Così invece, se in modo sicuro cancellare i file o distruggere fisicamente il dispositivo,

668
00:39:54,640 --> 00:39:57,300
questo è davvero l'unico modo a volte intorno a quella.

669
00:39:57,300 --> 00:40:02,020
>> Allora perché non lasciamo che il semi-spaventoso nota, e ci vedremo il Lunedi.

670
00:40:02,020 --> 00:40:07,000
[Applausi]

671
00:40:07,780 --> 00:40:10,000
>> [CS50.TV]