1
00:00:00,000 --> 00:00:02,760
[Powered by Google Translate] [SETTIMANA 5]

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

3
00:00:04,760 --> 00:00:11,990
[Questo è CS50.] [CS50.TV]

4
00:00:11,990 --> 00:00:17,780
[Donna] Sta mentendo, di quello che, non lo so.

5
00:00:17,780 --> 00:00:20,300
[L'uomo] Allora, cosa ne sappiamo?

6
00:00:20,300 --> 00:00:24,120
[Donna] che alle 9:15, Ray Santoya era al bancomat.

7
00:00:24,120 --> 00:00:27,420
[L'uomo] Quindi la domanda è: che cosa ci faceva alle 9:16?

8
00:00:27,420 --> 00:00:29,980
[Donna] Tiro a 9 mm a qualcosa.

9
00:00:29,980 --> 00:00:31,900
Forse ha visto il cecchino.

10
00:00:31,900 --> 00:00:34,000
[L'uomo] O stava lavorando con lui.

11
00:00:34,000 --> 00:00:36,330
[Donna] Aspetta. Torna indietro di una.

12
00:00:36,330 --> 00:00:38,330
[L'uomo] Che cosa vedi?

13
00:00:38,330 --> 00:00:44,520
[♫ ♫ musica suspense]

14
00:00:44,520 --> 00:00:48,320
[Donna] Portare la sua faccia in su. Schermo intero.

15
00:00:48,320 --> 00:00:51,230
[All'uomo] la sua occhiali. >> C'è una riflessione.

16
00:00:51,230 --> 00:01:00,810
[♫ ♫ musica suspense]

17
00:01:00,810 --> 00:01:03,580
[L'uomo] Questa è la squadra di baseball di Nuevita. Questo è il loro logo.

18
00:01:03,580 --> 00:01:07,790
[Donna] E sta parlando a chi indossa quella giacca.

19
00:01:07,790 --> 00:01:13,730
>> [David Malan] Quindi, questo è CS50 settimana 5, e oggi si rovina un po 'di televisione e film per voi.

20
00:01:13,730 --> 00:01:16,170
Così ogni volta che si sta guardando un programma come questo qui,

21
00:01:16,170 --> 00:01:19,910
e la polizia dicono "Si può pulire che fino?" o "Enhance",

22
00:01:19,910 --> 00:01:21,900
non vi è migliorare nel mondo reale.

23
00:01:21,900 --> 00:01:25,220
In realtà, quello che si ottiene è davvero un po 'di qualcosa come questo.

24
00:01:25,220 --> 00:01:27,570
Ho tirato su una delle foto del personale dalla pagina.

25
00:01:27,570 --> 00:01:30,980
Si tratta di un programma chiamato Photoshop. Questo è 1 di 2 Bowdens,

26
00:01:30,980 --> 00:01:36,300
1 di 3 Bowdens in realtà, oggi, perché abbiamo la signora Bowden anche qui, con Rob e Paolo.

27
00:01:36,300 --> 00:01:41,950
Ma ecco Rob sullo schermo, e se lo zoom su quel luccichio che ha sempre avuto nel suo occhio,

28
00:01:41,950 --> 00:01:47,600
quello che si vede attualmente è che ciò che vedi è quello che si ottiene.

29
00:01:47,600 --> 00:01:51,690
Questo è "migliorata", così "CSI" ha un po 'sbagliato.

30
00:01:51,690 --> 00:01:55,190
C'è un altro clip, se siamo in grado di cogliere in "CSI" solo un po 'più a lungo.

31
00:01:55,190 --> 00:01:58,500
Questa è una bella frase di pronunciare d'ora in poi, se si desidera

32
00:01:58,500 --> 00:02:10,280
buona formazione tecnica con i tuoi amici, quando, in realtà, stai dicendo niente.

33
00:02:10,280 --> 00:02:12,970
>> [L'uomo] Per settimane ho indagato sugli omicidi Killer Cabby

34
00:02:12,970 --> 00:02:15,360
con un certo fascino morboso.

35
00:02:15,360 --> 00:02:17,160
[Woman # 1] Questo è in tempo reale.

36
00:02:17,160 --> 00:02:22,930
[Woman # 2] creerò una interfaccia GUI utilizzando Visual Basic, vedere se riesco a rintracciare un indirizzo IP.

37
00:02:22,930 --> 00:02:29,570
>> [Malan] Quindi, audio fuori sincrono a parte, la creazione di una interfaccia GUI utilizzando Visual Basic

38
00:02:29,570 --> 00:02:31,820
per rintracciare un indirizzo IP è una totale assurdità.

39
00:02:31,820 --> 00:02:33,840
In questi giorni non si utilizza Visual Basic,

40
00:02:33,840 --> 00:02:38,920
non c'è bisogno di una GUI, e l'indirizzo IP era un termine tecnico preciso.

41
00:02:38,920 --> 00:02:41,730
Quindi tenete gli occhi aperti per questi, e uno dei miei preferiti:

42
00:02:41,730 --> 00:02:45,070
Questo e 'un po' più arcano, perché è necessario conoscere una lingua diversa.

43
00:02:45,070 --> 00:02:47,860
C'è un linguaggio chiamato Objective-C, che è un superset di C.

44
00:02:47,860 --> 00:02:51,960
Il che significa che è il C con alcune funzionalità aggiuntive, tra cui programmazione orientata agli oggetti.

45
00:02:51,960 --> 00:02:55,070
E questo è il linguaggio che Apple ha reso popolare per la programmazione iOS.

46
00:02:55,070 --> 00:02:58,760
E così ecco una clip da uno spettacolo completamente diverso, da "Numeri"

47
00:02:58,760 --> 00:03:02,450
che se si guarda da vicino effettivamente sul vostro TiVo e mettere in pausa al momento giusto,

48
00:03:02,450 --> 00:03:07,700
vedrai che quello che stanno guardando non è proprio ciò che viene descritto.

49
00:03:07,700 --> 00:03:11,170
E mi permetta di provare un connettore audio diverso qui e vedere se non possiamo

50
00:03:11,170 --> 00:03:13,780
mantenere l'audio in sincronia questa volta.

51
00:03:13,780 --> 00:03:20,530
Io ti do "Numeri".

52
00:03:20,530 --> 00:03:23,240
>> [Man # 1] E 'un indirizzo a 32 bit IPv4.

53
00:03:23,240 --> 00:03:38,930
[Man # 2] IP, che è Internet. >> Rete privata. Si tratta di una rete privata di Anita.

54
00:03:38,930 --> 00:03:43,810
[Malan] Ok. Si tratta di Objective-C, ed è per il programma di colorazione un po 'di bambini,

55
00:03:43,810 --> 00:03:51,140
come si può forse dedurre dal nome della variabile lì.

56
00:03:51,140 --> 00:03:54,410
In modo che, allora, era "Numeri". Così oggi e questa settimana vi presentiamo

57
00:03:54,410 --> 00:03:57,740
un po 'del mondo forense e il contesto nei problemi quindi.

58
00:03:57,740 --> 00:04:00,590
Oggi sarà una lezione abbreviato perché c'è un evento speciale in qui

59
00:04:00,590 --> 00:04:05,530
dopo, quindi dovremo dare un'occhiata, e prendere in giro sia gli studenti e genitori oggi

60
00:04:05,530 --> 00:04:07,420
con alcune delle cose che sono all'orizzonte.

61
00:04:07,420 --> 00:04:12,240
Tra questi, come di Lunedi, si avrà un paio di compagni di classe.

62
00:04:12,240 --> 00:04:16,050
Edx, Harvard e MIT nuova iniziativa on-line per open courseware

63
00:04:16,050 --> 00:04:19,120
e di più, sta lanciando nel campus di Harvard il Lunedi.

64
00:04:19,120 --> 00:04:21,490
Il che significa che vengono Lunedi si avrà - come di ultimo conteggio,

65
00:04:21,490 --> 00:04:26,210
86.000 compagni di classe aggiuntivi saranno in seguito insieme a lezioni di CS50

66
00:04:26,210 --> 00:04:29,170
e sezioni e procedure dettagliate e set problema.

67
00:04:29,170 --> 00:04:32,350
E come parte di questo, si diventa membri della classe inaugurale del

68
00:04:32,350 --> 00:04:35,090
CS50 e ora CS50x.

69
00:04:35,090 --> 00:04:39,310
>> Come parte di questo, ora, conto che ci saranno alcune upsides pure.

70
00:04:39,310 --> 00:04:43,790
Per prepararsi a questo, per il numero enorme di studenti,

71
00:04:43,790 --> 00:04:47,180
basti dire che, anche se abbiamo 108 TF e CA,

72
00:04:47,180 --> 00:04:50,790
non proprio il miglior rapporto studenti / insegnanti, una volta abbiamo raggiunto 80.000 studenti di altri.

73
00:04:50,790 --> 00:04:52,850
Quindi non sta andando ad essere un problema di classificazione tanti imposta manualmente.

74
00:04:52,850 --> 00:04:55,920
Così ha introdotto questa settimana nel set problema sarà CS50 Check,

75
00:04:55,920 --> 00:04:58,450
che sta per essere una utility a riga di comando all'interno dell'apparecchio

76
00:04:58,450 --> 00:05:01,200
che si otterrà una volta che si aggiorna dopo questo fine settimana,

77
00:05:01,200 --> 00:05:03,200
e voi sarete in grado di eseguire un comando, controllo 50,

78
00:05:03,200 --> 00:05:06,500
sul pset proprio, e si otterrà un feedback sul fatto che il programma è

79
00:05:06,500 --> 00:05:11,160
corretto o non corretto in base alle specifiche di design che ci hanno fornito.

80
00:05:11,160 --> 00:05:13,580
Quindi più su questo e la definizione di un set problema e

81
00:05:13,580 --> 00:05:17,240
i compagni di classe CS50x quali si utilizza questo pure.

82
00:05:17,240 --> 00:05:19,230
>> Così insieme il problema 4 è tutto forense.

83
00:05:19,230 --> 00:05:21,940
E questo pezzo è stato ispirato da un po 'di vita reale roba,

84
00:05:21,940 --> 00:05:24,620
per cui quando ero a scuola di specializzazione, ho internato per un po 'con

85
00:05:24,620 --> 00:05:28,650
Ufficio della contea di Middlesex procuratore distrettuale di fare il lavoro forense

86
00:05:28,650 --> 00:05:31,650
con il loro investigatore capo forense, e ciò che questo è pari a

87
00:05:31,650 --> 00:05:35,260
si, penso che ho detto dopo alcune settimane, è la Polizia di Stato di massa o altri

88
00:05:35,260 --> 00:05:39,000
farebbe entrare, avrebbero scendere cose come hard disk e CD e floppy disk

89
00:05:39,000 --> 00:05:42,340
e simili, e quindi l'obiettivo dell'ufficio forense era di accertare se

90
00:05:42,340 --> 00:05:44,600
non vi era o non era la prova di qualche tipo.

91
00:05:44,600 --> 00:05:48,010
Questa è stata la Squadra Speciale Investigativa, quindi era criminalità dei colletti bianchi,

92
00:05:48,010 --> 00:05:52,350
era una sorta di più inquietante di crimini,

93
00:05:52,350 --> 00:05:55,990
qualsiasi azione che comporti una sorta di media digitali, scopre che non è che molte persone

94
00:05:55,990 --> 00:05:59,370
scrivere una e-mail dicendo: "L'ho fatto."

95
00:05:59,370 --> 00:06:03,290
Quindi, molto spesso queste ricerche forensi non si presentò tutto ciò che molto frutto,

96
00:06:03,290 --> 00:06:05,850
ma a volte la gente scrivere tali e-mail.

97
00:06:05,850 --> 00:06:08,490
Così a volte gli sforzi sono stati premiati.

98
00:06:08,490 --> 00:06:14,420
>> Ma per portare a questo pset forense, saremo introdurre in pset 4 un po 'di grafica.

99
00:06:14,420 --> 00:06:18,260
Quindi probabilmente prendere queste cose per scontato, JPEG, GIF e che in questi giorni,

100
00:06:18,260 --> 00:06:21,640
ma se davvero pensate, un'immagine, proprio come il viso di Rob,

101
00:06:21,640 --> 00:06:24,430
potrebbe essere modellato come una sequenza di punti, o pixel.

102
00:06:24,430 --> 00:06:26,680
Ora, nel caso di faccia di Rob, ci sono tutti i colori,

103
00:06:26,680 --> 00:06:29,940
e abbiamo iniziato a vedere i singoli punti, otherwide noti come pixel,

104
00:06:29,940 --> 00:06:31,610
una volta che abbiamo iniziato a Immagine

105
00:06:31,610 --> 00:06:35,590
Ma se semplificare il mondo un po ', e dire che questo qui è Rob

106
00:06:35,590 --> 00:06:40,560
in bianco e nero, bene, per rappresentare in bianco e nero si può semplicemente utilizzare binario.

107
00:06:40,560 --> 00:06:44,960
E se abbiamo intenzione di utilizzare binario, 1 o 0, siamo in grado di esprimere questa stessa immagine

108
00:06:44,960 --> 00:06:51,970
del volto sorridente di Rob con questo modello di bit: 11000011 rappresenta

109
00:06:51,970 --> 00:06:55,160
bianco, bianco, nero, nero, nero, nero, bianco.

110
00:06:55,160 --> 00:06:59,290
E quindi non è un salto enorme, quindi, cominciare a parlare di fotografie colorate.

111
00:06:59,290 --> 00:07:01,920
Le cose che si vedono su Facebook o prendere con una macchina fotografica digitale,

112
00:07:01,920 --> 00:07:04,730
ma, di certo, quando si tratta di colori, avete bisogno di più bit.

113
00:07:04,730 --> 00:07:08,470
E abbastanza comune nel mondo delle fotografie è di non usare 1-bit di colore,

114
00:07:08,470 --> 00:07:12,730
come questo suggerisce, ma colori a 24 bit, in cui è effettivamente ottenere milioni di colori.

115
00:07:12,730 --> 00:07:15,430
Così come nel caso in cui ci zoom su occhi di Rob,

116
00:07:15,430 --> 00:07:19,270
che era un numero qualsiasi di milioni di differenti possibilità colorati.

117
00:07:19,270 --> 00:07:22,260
>> Quindi dovremo introdurre questo problema insieme a 4 nonché nella procedura dettagliata,

118
00:07:22,260 --> 00:07:27,050
che sarà oggi alle 3:30 invece del solito a causa della conferenza 02:30 Venerdì qui.

119
00:07:27,050 --> 00:07:29,930
Ma il video sarà online, come di consueto, domani.

120
00:07:29,930 --> 00:07:31,880
Inoltre, ti introducono in un altro formato di file.

121
00:07:31,880 --> 00:07:34,150
Quindi questo è volutamente pensato per guardare intimidatorio in un primo momento,

122
00:07:34,150 --> 00:07:38,980
ma questo è solo un po 'di documentazione per una struct C.

123
00:07:38,980 --> 00:07:42,280
Si scopre che Microsoft, anni fa, ha contribuito a diffondere questo formato,

124
00:07:42,280 --> 00:07:46,630
chiamato il formato di file bitmap, BMP, e questo era un super-semplice,

125
00:07:46,630 --> 00:07:50,390
colorato formato di file grafico che è stato utilizzato per un bel po 'di tempo

126
00:07:50,390 --> 00:07:53,640
e talvolta ancora per sfondi per desktop.

127
00:07:53,640 --> 00:07:57,410
Se si pensa di nuovo a Windows XP e le dolci colline e il cielo blu,

128
00:07:57,410 --> 00:08:00,660
che era tipicamente un file BMP, o di un'immagine bitmap e bitmap

129
00:08:00,660 --> 00:08:03,340
sono divertenti per noi, perché hanno la complessità di un po 'di più.

130
00:08:03,340 --> 00:08:05,640
Non è così semplice come questa griglia di 0 e di 1;

131
00:08:05,640 --> 00:08:10,680
invece, si dispone di cose come un colpo di testa all'inizio di un file.

132
00:08:10,680 --> 00:08:15,520
In altre parole, all'interno di un file. Bmp è un insieme di 0 e di 1,

133
00:08:15,520 --> 00:08:18,070
ma c'è qualche supplementare 0 e di 1 in là.

134
00:08:18,070 --> 00:08:21,450
E si scopre che quello che abbiamo probabilmente dato per scontato per anni,

135
00:08:21,450 --> 00:08:27,040
formati di file come. doc o. xls o. mp3 o. mp4,

136
00:08:27,040 --> 00:08:29,910
quali che siano i formati di file che si ha familiarità con.

137
00:08:29,910 --> 00:08:31,900
Beh, che cosa significa essere anche un formato di file?

138
00:08:31,900 --> 00:08:35,740
Perché alla fine della giornata, tutti questi file usiamo avere solo 0 e di 1

139
00:08:35,740 --> 00:08:39,950
e forse coloro 0 e 1 rappresentano a, b, c, tramite ASCII o simile,

140
00:08:39,950 --> 00:08:42,030
ma attraverso la fine della giornata, è solo 0 e di 1.

141
00:08:42,030 --> 00:08:45,300
>> Così gli esseri umani solo occasionalmente decide di inventare un nuovo formato di file

142
00:08:45,300 --> 00:08:49,420
dove standardizzare ciò che i modelli di bit effettivamente dire.

143
00:08:49,420 --> 00:08:52,790
E in questo caso qui, la gente che ha progettato il formato di file bitmap

144
00:08:52,790 --> 00:08:58,260
detto che al primo byte in un file bitmap, come indicata da offset 0, esiste,

145
00:08:58,260 --> 00:09:02,320
ci sarà un po 'di nomi incomprensibili bfType variabile chiamata,

146
00:09:02,320 --> 00:09:06,510
che sta proprio per il tipo di file bitmap, il tipo di file bitmap è.

147
00:09:06,510 --> 00:09:10,780
Si può dedurre, forse, dalla seconda fila che ha compensato 2, numero byte 2,

148
00:09:10,780 --> 00:09:15,980
ha un modello di 0 e 1 che rappresenta ciò?

149
00:09:15,980 --> 00:09:18,320
Le dimensioni di qualcosa, e si va avanti da lì.

150
00:09:18,320 --> 00:09:20,660
Così nel set problema 4, sarete camminato attraverso alcune di queste cose.

151
00:09:20,660 --> 00:09:24,480
>> Non finirà per prendersi cura di ognuno di loro, a meno di notare che inizia a diventare interessante

152
00:09:24,480 --> 00:09:30,780
attorno alla riga o byte 54, rgbtBlue, verde e rosso.

153
00:09:30,780 --> 00:09:35,280
Se hai mai sentito la sigla RGB, rosso verde blu, questo è un riferimento a questo.

154
00:09:35,280 --> 00:09:37,840
Perché si scopre che può dipingere tutti i colori dell'arcobaleno

155
00:09:37,840 --> 00:09:41,580
con una combinazione di rosso e blu e verde.

156
00:09:41,580 --> 00:09:46,560
E, infatti, i genitori nella stanza può ricordare alcuni dei primi proiettori.

157
00:09:46,560 --> 00:09:49,360
In questi giorni, basta vedere 1 luce uscendo da una lente.

158
00:09:49,360 --> 00:09:52,870
Ma torniamo nel corso della giornata, avete avuto la lente rossa, la lente blu, e la lente verde

159
00:09:52,870 --> 00:09:56,620
e insieme volto a schermo e formato un immagine colorata.

160
00:09:56,620 --> 00:09:59,590
E molto spesso le scuole medie e superiori avrebbero quelle lenti

161
00:09:59,590 --> 00:10:02,680
sempre così un po 'di traverso, in modo che erano una specie di vedere immagini doppie o triple,

162
00:10:02,680 --> 00:10:07,500
ma questa era l'idea. Hai avuto luce rossa e verde e blu dipingere un quadro.

163
00:10:07,500 --> 00:10:09,570
E questo stesso principio è usato nei computer.

164
00:10:09,570 --> 00:10:12,000
>> Quindi, tra le sfide, allora, per voi nel problema set 4

165
00:10:12,000 --> 00:10:16,080
saranno un paio di cose: uno è quello di ridimensionare un immagine.

166
00:10:16,080 --> 00:10:18,050
Prendere in un modello di 0 e di 1,

167
00:10:18,050 --> 00:10:22,840
capire quali pezzi di 0 e 1 rappresentano ciò che in una struttura come questa,

168
00:10:22,840 --> 00:10:26,800
e poi capire come replicare i pixel: i rossi, i blu, i verdi

169
00:10:26,800 --> 00:10:32,460
all'interno in modo che quando una foto simile a questa prima fase, potrebbe essere simile a questo, invece dopo.

170
00:10:32,460 --> 00:10:35,590
Tra le altre sfide, anche, sarà che ti verrà consegnato

171
00:10:35,590 --> 00:10:38,900
un'immagine forense di un file vero e proprio da una fotocamera digitale

172
00:10:38,900 --> 00:10:42,410
e su quella macchina fotografica, un tempo, erano un sacco di foto.

173
00:10:42,410 --> 00:10:47,030
Il problema è che abbiamo accidentalmente cancellato o ha avuto l'immagine danneggiato in qualche modo.

174
00:10:47,030 --> 00:10:51,040
Le cose brutte succedono con le fotocamere digitali, e così abbiamo subito copiato tutti i 0 e di 1

175
00:10:51,040 --> 00:10:55,410
fuori di quella carta per te, salvato tutti in 1 file grande, e poi noi li mano a te

176
00:10:55,410 --> 00:11:00,000
nel problema posto 4 in modo che sia possibile scrivere un programma in C con il quale recuperare

177
00:11:00,000 --> 00:11:02,660
tutti questi file JPEG, idealmente.

178
00:11:02,660 --> 00:11:06,280
E si scopre che i file JPEG, anche se sono un po 'di un formato di file complesso,

179
00:11:06,280 --> 00:11:09,580
sono molto più complesso di questo volto sorridente qui.

180
00:11:09,580 --> 00:11:14,320
Si scopre che ogni JPEG inizia con gli stessi schemi di 0 e di 1.

181
00:11:14,320 --> 00:11:18,820
Quindi, utilizzando un ciclo while o un ciclo for o simili,

182
00:11:18,820 --> 00:11:22,350
è possibile scorrere tutte le 0 la e 1 in questa immagine forense

183
00:11:22,350 --> 00:11:26,670
e ogni volta che si vede il motivo speciale che è definito nella specifica il problema proposto, la

184
00:11:26,670 --> 00:11:29,770
si può assumere, 'Oh, è qui, con probabilità molto alta,

185
00:11:29,770 --> 00:11:33,520
l'inizio di un JPEG, 'e appena si trova lo stesso modello,

186
00:11:33,520 --> 00:11:36,050
un certo numero di byte o kilobyte o in megabyte più tardi,

187
00:11:36,050 --> 00:11:40,550
si può assumere, 'Ooh! Ecco un secondo JPEG, la foto ho preso dopo il primo.

188
00:11:40,550 --> 00:11:44,720
Vorrei smettere di leggere quel file in primo luogo, iniziare a scrivere questo nuovo. '

189
00:11:44,720 --> 00:11:49,980
E l'uscita del programma per pset 4 sta per essere fino a 50 JPEG.

190
00:11:49,980 --> 00:11:52,400
E se non è 50 file JPEG, si dispone di un po 'di un ciclo.

191
00:11:52,400 --> 00:11:55,580
Se si dispone di un numero infinito di file JPEG, si dispone di un ciclo infinito.

192
00:11:55,580 --> 00:11:58,280
Così, anche, sarà un bel caso comune.

193
00:11:58,280 --> 00:12:00,280
Questo è quello che è all'orizzonte.

194
00:12:00,280 --> 00:12:03,740
>> Quiz 0, dietro di noi. Realizzare, per il mio e-mail, che sempre c'è gente

195
00:12:03,740 --> 00:12:06,820
che sono entrambi soddisfatti, una sorta di folle, e triste intorno quiz 0 Tempo.

196
00:12:06,820 --> 00:12:10,160
E vi prego di non entrare in contatto con me, i TF testa, Zamyla, il tuo TF proprio

197
00:12:10,160 --> 00:12:14,120
o uno dei CA che si sa se si vuole discutere di come sono andate le cose.

198
00:12:14,120 --> 00:12:16,460
>> Quindi, per impressionare i genitori qui in sala,

199
00:12:16,460 --> 00:12:23,990
qual è la biblioteca CS50? Buon lavoro.

200
00:12:23,990 --> 00:12:32,280
Qual è la biblioteca CS50? Si '? [Le risposte degli studenti, incomprensibile]

201
00:12:32,280 --> 00:12:35,730
>> Ok, bene. Quindi è un insieme di predefiniti di codice che abbiamo, il personale, ha scritto,

202
00:12:35,730 --> 00:12:38,460
che offriamo a voi, per fornire alcune funzionalità comuni.

203
00:12:38,460 --> 00:12:42,290
Roba come farmi una stringa; farmi un int, tutte le funzioni che sono elencate qui.

204
00:12:42,290 --> 00:12:45,260
A partire da ora, si comincia a prendere realmente queste ruote di formazione off.

205
00:12:45,260 --> 00:12:48,230
Quindi stiamo per iniziare a portare via una "stringa" da te,

206
00:12:48,230 --> 00:12:52,790
che, ricordo, era solo un sinonimo per il tipo di dati effettivo? char *.

207
00:12:52,790 --> 00:12:57,020
Quindi, per i genitori, che era probabilmente - questo è un bene, in modo da char * inizieremo a vedere

208
00:12:57,020 --> 00:13:00,810
sullo schermo tanto più dal momento che eliminiamo "stringa" dal nostro vocabolario,

209
00:13:00,810 --> 00:13:02,760
almeno quando si tratta di realtà la scrittura di codice.

210
00:13:02,760 --> 00:13:06,240
Allo stesso modo, ci smettere di usare alcune di queste funzioni tanto,

211
00:13:06,240 --> 00:13:08,390
perché i nostri programmi si sta per ottenere più sofisticati

212
00:13:08,390 --> 00:13:11,370
piuttosto che scrivere programmi che si trovano lì con un lampeggiante prompt,

213
00:13:11,370 --> 00:13:13,580
attesa che l'utente a digitare qualcosa trovi

214
00:13:13,580 --> 00:13:15,220
Avrai i tuoi ingressi da qualche altra parte.

215
00:13:15,220 --> 00:13:18,720
Per esempio, potrai ottenere da una serie di bit sul disco rigido locale.

216
00:13:18,720 --> 00:13:23,340
Avrete invece ottenere in futuro da una connessione di rete, qualche sito web da qualche parte.

217
00:13:23,340 --> 00:13:27,460
Quindi cerchiamo di togliere questo strato per la prima volta, e tirare il CS50 apparecchio

218
00:13:27,460 --> 00:13:32,300
e questo file chiamato CS50.h, che sei stato forte anche per settimane.

219
00:13:32,300 --> 00:13:34,380
>> Ma andiamo effettivamente vedere cosa c'è dentro di questo.

220
00:13:34,380 --> 00:13:38,250
Quindi, la parte superiore del file in blu è solo un insieme di osservazioni,

221
00:13:38,250 --> 00:13:41,340
informazioni sulla garanzia e la concessione di licenze. Questa è una sorta di paradigma comune

222
00:13:41,340 --> 00:13:44,600
nel software, perché un sacco di software in questi giorni è quello che si chiama "open source"

223
00:13:44,600 --> 00:13:46,940
il che significa che qualcuno ha scritto il codice

224
00:13:46,940 --> 00:13:50,060
e reso disponibile gratuitamente, non solo di correre e di utilizzare,

225
00:13:50,060 --> 00:13:53,660
ma in realtà leggere e modificare e integrare nel proprio lavoro.

226
00:13:53,660 --> 00:13:55,790
Ecco, questo è quello che hai usato, il software open source,

227
00:13:55,790 --> 00:13:58,030
sebbene in una forma molto piccola.

228
00:13:58,030 --> 00:14:01,860
Se scorrere verso il basso oltre i commenti, però, che inizieremo a vedere alcune cose più familiari.

229
00:14:01,860 --> 00:14:08,090
Così notare in alto qui, che il file CS50.h comprende un insieme di file di intestazione.

230
00:14:08,090 --> 00:14:11,160
Ora, la maggior parte di questi non abbiamo mai visto prima, ma si è

231
00:14:11,160 --> 00:14:15,640
familiare, quale di queste abbiamo visto, anche se brevemente, fino ad ora?

232
00:14:15,640 --> 00:14:18,720
Si ', librerie standard. Stdlib.h ha malloc,

233
00:14:18,720 --> 00:14:21,590
così una volta che abbiamo iniziato a parlare di allocazione dinamica della memoria,

234
00:14:21,590 --> 00:14:24,960
che torneremo la prossima settimana pure, abbiamo iniziato anche il file.

235
00:14:24,960 --> 00:14:29,660
Si scopre che bool e vero e il falso in realtà non esiste in C, di per sé,

236
00:14:29,660 --> 00:14:32,460
a meno che non si include questo file qui.

237
00:14:32,460 --> 00:14:35,770
Così abbiamo, per settimane, è compreso di serie bool.h

238
00:14:35,770 --> 00:14:39,020
in modo che è possibile utilizzare il concetto di un bool, vero o falso.

239
00:14:39,020 --> 00:14:41,830
Senza questo, si dovrebbe ordinare di fingere e utilizzare un int

240
00:14:41,830 --> 00:14:45,920
e solo arbitrariamente supporre che 0 è falso e 1 è vero.

241
00:14:45,920 --> 00:14:49,980
>> Ora, se scorrere verso il basso più, ecco la nostra definizione di una stringa.

242
00:14:49,980 --> 00:14:54,820
Si scopre, come abbiamo detto prima, che quando ciò * non ha molta importanza.

243
00:14:54,820 --> 00:14:56,750
Si può anche avere lo spazio tutto intorno.

244
00:14:56,750 --> 00:15:01,550
Noi, in questo semestre, sono state promuovendo come questo per chiarire che la * ha a che fare con il tipo.

245
00:15:01,550 --> 00:15:05,370
Ma rendersi conto, come comune, se non un po 'più comune, è quello di mettere lì

246
00:15:05,370 --> 00:15:07,480
ma funzionalmente è la stessa cosa.

247
00:15:07,480 --> 00:15:11,070
Ma ora, se leggiamo ulteriormente verso il basso, diamo un'occhiata a dire, GetInt,

248
00:15:11,070 --> 00:15:15,350
perché abbiamo usato che, forse, prima di tutto questo semestre.

249
00:15:15,350 --> 00:15:19,620
Ed ecco GetInt. Questo è ciò?

250
00:15:19,620 --> 00:15:24,650
Questo è il prototipo. Così spesso, abbiamo messo prototipi ai vertici della nostra. File c,

251
00:15:24,650 --> 00:15:28,190
ma si può anche mettere prototipi nei file di intestazione, i file. h,

252
00:15:28,190 --> 00:15:32,110
come questo qui, in modo che quando si scrive alcune funzioni

253
00:15:32,110 --> 00:15:36,790
che si desidera che altre persone di essere in grado di utilizzare, che è esattamente il caso della biblioteca CS50,

254
00:15:36,790 --> 00:15:40,900
non solo implementare le funzioni in qualcosa come CS50.c,

255
00:15:40,900 --> 00:15:46,720
è anche mettere i prototipi non all'inizio del file, ma nella parte superiore di un file di intestazione,

256
00:15:46,720 --> 00:15:50,810
poi il file di intestazione è quello che amici e colleghi comprendono,

257
00:15:50,810 --> 00:15:52,800
con forte includere nel proprio codice.

258
00:15:52,800 --> 00:15:55,440
Quindi tutto questo tempo siete stati inclusi tutti questi prototipi

259
00:15:55,440 --> 00:15:59,870
efficacemente nella parte superiore del file, ma per mezzo di questo meccanismo sono taglienti

260
00:15:59,870 --> 00:16:03,320
che essenzialmente copie e paste di questo file nel proprio.

261
00:16:03,320 --> 00:16:06,400
Ora, ecco un po 'di documentazione molto dettagliata.

262
00:16:06,400 --> 00:16:08,880
>> Abbiamo più o meno per scontato che GetInt ottiene un int,

263
00:16:08,880 --> 00:16:10,740
ma è venuto fuori ci sono alcuni casi angolo, giusto?

264
00:16:10,740 --> 00:16:14,320
Che cosa succede se l'utente digita in un numero che è troppo grande?

265
00:16:14,320 --> 00:16:17,350
Un trilione, che proprio non può andare bene all'interno di un int?

266
00:16:17,350 --> 00:16:21,180
Qual è il comportamento previsto? Beh, idealmente, è prevedibile.

267
00:16:21,180 --> 00:16:23,460
Quindi, in questo caso, se effettivamente leggere la stampa fine,

268
00:16:23,460 --> 00:16:27,850
vedrai che se la linea non può essere letto, questo INT_MAX restituisce.

269
00:16:27,850 --> 00:16:30,800
Non abbiamo mai parlato di questo, ma in base alla sua capitalizzazione,

270
00:16:30,800 --> 00:16:33,030
quello che è, forse?

271
00:16:33,030 --> 00:16:36,610
E 'una costante, quindi è una costante speciale che probabilmente ha dichiarato

272
00:16:36,610 --> 00:16:39,460
in una di quelle file di intestazione che c'è più in alto nel file,

273
00:16:39,460 --> 00:16:43,400
e INT_MAX è probabilmente qualcosa di simile, circa, 2 miliardi di euro.

274
00:16:43,400 --> 00:16:48,160
L'idea è che, perché abbiamo bisogno di indicare in qualche modo che qualcosa è andato storto,

275
00:16:48,160 --> 00:16:51,090
noi, sì, hanno 4000000000 numeri a nostra disposizione,

276
00:16:51,090 --> 00:16:53,980
negativo 2 miliardi fino a 2 miliardi di euro, prendere o lasciare.

277
00:16:53,980 --> 00:16:58,030
Ebbene, ciò che è comune nella programmazione è rubi solo uno di questi numeri.

278
00:16:58,030 --> 00:17:02,250
Forse 0, forse 2 miliardi di euro, forse negativo 2 miliardi di euro.

279
00:17:02,250 --> 00:17:06,720
Così si spende uno dei vostri valori possibili in modo che si può commettere al mondo

280
00:17:06,720 --> 00:17:10,089
che se qualcosa va storto, io tornerò questo super-grande valore.

281
00:17:10,089 --> 00:17:13,329
Ma non si desidera che l'utente digita qualcosa di criptico come "2, 3, 4 ..."

282
00:17:13,329 --> 00:17:17,079
di numero molto grande, dove si generalizza invece come una costante.

283
00:17:17,079 --> 00:17:19,380
Quindi, veramente, se venivano anale nelle ultime settimane,

284
00:17:19,380 --> 00:17:23,800
in qualsiasi momento si chiama GetInt, si sarebbe dovuto verificare con una condizione if.

285
00:17:23,800 --> 00:17:27,109
Forse il tipo di utente in INT_MAX, o più precisamente,

286
00:17:27,109 --> 00:17:29,900
ha fatto ritorno INT_MAX GetInt? Perché se così fosse,

287
00:17:29,900 --> 00:17:35,140
questo significa che in realtà non lo scrivere, qualcosa è andato storto in questo caso.

288
00:17:35,140 --> 00:17:38,970
Quindi questo è ciò che è generalmente conosciuto come un valore "sentinella", che significa semplicemente speciale.

289
00:17:38,970 --> 00:17:41,020
>> Bene, ora girare per i file. C.

290
00:17:41,020 --> 00:17:44,500
Il file C è esistita nel apparecchio per molto tempo,

291
00:17:44,500 --> 00:17:47,540
e, in effetti, l'apparecchio ha lo pre-compilati

292
00:17:47,540 --> 00:17:49,720
in quella cosa che abbiamo chiamato "codice oggetto",

293
00:17:49,720 --> 00:17:52,940
ma semplicemente non importa a voi dove è perché il sistema sa,

294
00:17:52,940 --> 00:17:54,780
in questo caso, dove si trova, l'apparecchio.

295
00:17:54,780 --> 00:18:00,620
Ma andiamo ora a scorrere verso il basso getInt, e vedere come GetInt ha lavorato per tutto questo tempo.

296
00:18:00,620 --> 00:18:02,380
Quindi qui abbiamo commenti simili da prima.

297
00:18:02,380 --> 00:18:04,930
Vorrei ingrandire solo la porzione di codice,

298
00:18:04,930 --> 00:18:07,410
e ciò che abbiamo per GetInt è la seguente.

299
00:18:07,410 --> 00:18:12,770
Prende nessun input e restituisce un int, while (true), quindi abbiamo un ciclo infinito deliberata

300
00:18:12,770 --> 00:18:16,560
ma, presumibilmente, faremo uscire da questo in qualche modo, o ritornare all'interno di questa.

301
00:18:16,560 --> 00:18:19,890
Quindi cerchiamo di vedere come funziona. Beh, sembrano utilizzare GetString

302
00:18:19,890 --> 00:18:22,550
in questa prima linea all'interno del ciclo, 166.

303
00:18:22,550 --> 00:18:25,320
Questo è ora buona pratica perché in quali circostanze

304
00:18:25,320 --> 00:18:30,820
GetString potrebbe restituire questo particolare parola chiave, NULL?

305
00:18:30,820 --> 00:18:38,460
Se qualcosa va storto. Cosa potrebbe andare storto quando si chiama qualcosa come GetString?

306
00:18:38,460 --> 00:18:42,550
Si '? [Risposta studente, incomprensibile] >> Si '. Quindi forse malloc non riesce.

307
00:18:42,550 --> 00:18:45,310
Da qualche parte sotto il cofano GetString sta chiamando malloc,

308
00:18:45,310 --> 00:18:48,210
che alloca la memoria, che consente al negozio di computer

309
00:18:48,210 --> 00:18:50,950
tutti i caratteri che l'utente digita nella tastiera.

310
00:18:50,950 --> 00:18:53,270
E se l'utente ha avuto un sacco di tempo libero

311
00:18:53,270 --> 00:18:56,470
e digitato più, per esempio, di 2 miliardi di caratteri.

312
00:18:56,470 --> 00:18:59,600
Altri personaggi che il computer ha anche RAM.

313
00:18:59,600 --> 00:19:02,350
Ebbene, GetString deve essere in grado di significare che ti,

314
00:19:02,350 --> 00:19:05,650
anche se questo è un super, super-angolo caso raro.

315
00:19:05,650 --> 00:19:08,490
Deve essere in qualche modo in grado di gestire questa situazione, e così GetString,

316
00:19:08,490 --> 00:19:11,850
se tornare indietro e leggere la sua documentazione, fa, infatti, restituisce NULL.

317
00:19:11,850 --> 00:19:16,150
Ora, se non riesce GetString restituendo NULL, GetInt sta per fallire

318
00:19:16,150 --> 00:19:19,370
ritornando INT_MAX, proprio come una sentinella.

319
00:19:19,370 --> 00:19:22,650
Questi sono solo convenzioni umane. L'unico modo sarebbe che questo è il caso

320
00:19:22,650 --> 00:19:24,840
è leggendo la documentazione.

321
00:19:24,840 --> 00:19:28,200
Quindi cerchiamo di scorrere verso il basso dove la int è in realtà GotInt.

322
00:19:28,200 --> 00:19:34,220
>> Quindi, se ho scorrere verso il basso un po 'più, in linea 170 abbiamo un commento di cui sopra queste righe.

323
00:19:34,220 --> 00:19:38,470
Quindi noi dichiariamo, nel 172, un int n e c char, e poi questa nuova funzione

324
00:19:38,470 --> 00:19:41,870
che alcuni di voi hanno imbattuto prima, ma sscanf.

325
00:19:41,870 --> 00:19:44,190
Questo sta per stringa f scansione.

326
00:19:44,190 --> 00:19:48,580
In altre parole, dammi una stringa e lo esamina per pezzi di informazioni di interesse.

327
00:19:48,580 --> 00:19:53,820
Che cosa vuol dire? Bene, supponiamo che digito, letteralmente, 1 2 3 alla tastiera,

328
00:19:53,820 --> 00:19:59,730
e poi premere invio. Qual è il tipo di dati di 1 2 3 quando restituito da GetString?

329
00:19:59,730 --> 00:20:05,010
E 'ovviamente una stringa, giusto? Ho una stringa, quindi 1 2 3 è davvero "1 2 3"

330
00:20:05,010 --> 00:20:07,260
con il \ 0 al termine di essa. Questo non è un int.

331
00:20:07,260 --> 00:20:10,420
Questo non è un numero. Si presenta come un numero, ma non è in realtà.

332
00:20:10,420 --> 00:20:14,680
Così che cosa GetInt fare? Si deve scansionare la stringa da sinistra a destra,

333
00:20:14,680 --> 00:20:19,010
1 2 3 \ 0, e in qualche modo convertire in numero intero reale.

334
00:20:19,010 --> 00:20:21,010
Ora, si può capire come fare questo.

335
00:20:21,010 --> 00:20:24,240
Se si pensa di nuovo a pset 2, che presumibilmente sono un po 'confortevole

336
00:20:24,240 --> 00:20:26,810
con Cesare o Vigenère in modo da poter scorrere una stringa,

337
00:20:26,810 --> 00:20:29,800
è possibile convertire i caratteri di interi con scelta. Questo è un sacco di lavoro.

338
00:20:29,800 --> 00:20:32,800
Perché non chiamare una funzione come sscanf che fa per voi?

339
00:20:32,800 --> 00:20:37,520
Così sscanf aspetta un argomento, in questo caso chiamato linea, che è una stringa.

340
00:20:37,520 --> 00:20:41,310
È quindi possibile specificare, tra virgolette, molto simile a printf,

341
00:20:41,310 --> 00:20:44,960
cosa vi aspettate di vedere in questa stringa?

342
00:20:44,960 --> 00:20:52,980
Quello che sto dicendo qui è, mi aspetto di vedere un numero decimale e forse un carattere.

343
00:20:52,980 --> 00:20:54,990
E vedremo perché questo è il caso in un attimo.

344
00:20:54,990 --> 00:20:58,440
Si scopre che questa notazione è ora ricorda di roba

345
00:20:58,440 --> 00:21:00,840
abbiamo iniziato a parlare poco più di una settimana fa.

346
00:21:00,840 --> 00:21:05,430
>> Che cosa è & n e & c facendo per noi qui? [Le risposte degli studenti, incomprensibile]

347
00:21:05,430 --> 00:21:07,610
Sì >>. Mi sta dando l'indirizzo di n e l'indirizzo di c.

348
00:21:07,610 --> 00:21:10,440
Ora, perché è così importante? Beh, lo sai che con le funzioni in C

349
00:21:10,440 --> 00:21:13,440
si può sempre restituire un valore o nessun valore.

350
00:21:13,440 --> 00:21:16,630
È possibile restituire un int, una stringa, un galleggiante, un char, qualsiasi cosa.

351
00:21:16,630 --> 00:21:21,150
Oppure si può restituire void, ma si può restituire solo 1 cosa al massimo.

352
00:21:21,150 --> 00:21:26,100
Ma qui vogliamo sscanf tornare me forse un int, un numero decimale,

353
00:21:26,100 --> 00:21:29,240
e anche un char, e ti spiego il perché il carattere in un momento.

354
00:21:29,240 --> 00:21:34,250
Così si vuole effettivamente f per tornare 2 cose, che non è solo possibile in C.

355
00:21:34,250 --> 00:21:38,460
Così si può evitare ciò passando in 2 indirizzi,

356
00:21:38,460 --> 00:21:43,710
perché non appena vi consegnerà una funzione di 2 indirizzi, che cosa può fare con loro funzione?

357
00:21:43,710 --> 00:21:49,880
E 'in grado di scrivere a questi indirizzi. È possibile utilizzare l'operazione * e "go there" a ciascuna di tali indirizzi.

358
00:21:49,880 --> 00:21:54,320
È un po 'questo meccanismo porta di servizio, ma molto comune per modificare i valori delle variabili

359
00:21:54,320 --> 00:21:58,020
in più di 1 posto, in questo caso 2.

360
00:21:58,020 --> 00:22:04,590
Ora, notate sto controllando per == a1, e poi tornare n se si, in effetti, restituiscono true.

361
00:22:04,590 --> 00:22:09,340
Allora, cosa sta succedendo? Beh, tecnicamente, tutto quello che vuole veramente accadere in GetInt è questo.

362
00:22:09,340 --> 00:22:12,340
Vogliamo analizzare, per così dire, vogliamo leggere la stringa

363
00:22:12,340 --> 00:22:16,210
"1 2 3" e se sembra che ci sia un numero,

364
00:22:16,210 --> 00:22:21,360
quello che stiamo dicendo sscanf fare è mettere quel numero, 1 2 3, in questa variabile n per me.

365
00:22:21,360 --> 00:22:26,060
Perché, allora, ho avuto anche questo?

366
00:22:26,060 --> 00:22:33,750
Qual è il ruolo di dire anche, sscanf, si potrebbe anche ottenere un carattere qui.

367
00:22:33,750 --> 00:22:36,890
[Parlando Studente, incomprensibile] >> Non - un punto decimale potrebbe funzionare.

368
00:22:36,890 --> 00:22:40,650
Facciamo ritengono che pensò per un momento. Che altro?

369
00:22:40,650 --> 00:22:42,570
[Studente, incomprensibile] >> Quindi, buon pensiero, potrebbe essere il carattere NULL.

370
00:22:42,570 --> 00:22:44,970
Non è in realtà, in questo caso. Si '? [Studente, incomprensibile]

371
00:22:44,970 --> 00:22:47,100
>> >> ASCII. Oppure, vorrei generalizzare ancora di più.

372
00:22:47,100 --> 00:22:49,670
Il c% è solo per il controllo degli errori.

373
00:22:49,670 --> 00:22:52,510
Non vogliamo che ci sia carattere dopo il numero,

374
00:22:52,510 --> 00:22:54,980
ma ciò che questo mi permette di fare è la seguente:

375
00:22:54,980 --> 00:23:01,270
Risulta che sscanf, oltre a memorizzare i valori N e C, in questo esempio qui,

376
00:23:01,270 --> 00:23:08,170
quello che fa è anche restituisce il numero di variabili messo valori trovi

377
00:23:08,170 --> 00:23:13,330
Quindi, se solo digitare 1 2 3, quindi solo il% d sta per corrispondere

378
00:23:13,330 --> 00:23:18,830
e solo n viene memorizzato con un valore come 1 2 3 e nulla viene messo in c;

379
00:23:18,830 --> 00:23:20,870
c resta un valore spazzatura, per così dire.

380
00:23:20,870 --> 00:23:23,550
Garbage, perché non è mai stato inizializzato come un certo valore.

381
00:23:23,550 --> 00:23:29,390
Quindi, in questo caso, sscanf restituisce 1, perché popolato uno di quei puntatori,

382
00:23:29,390 --> 00:23:33,650
in tal caso, grande. Ho un int, quindi liberare la linea per liberare la memoria

383
00:23:33,650 --> 00:23:37,150
che GetString effettivamente stanziato, e poi torno n.

384
00:23:37,150 --> 00:23:42,210
Altrimenti, se siete mai chiesti dove riprovare dichiarazione che viene, viene da qui.

385
00:23:42,210 --> 00:23:45,770
Se, al contrario, di tipo I in 1 2 3 foo,

386
00:23:45,770 --> 00:23:48,640
solo alcune sequenza casuale di testo, sscanf è andare a vedere,

387
00:23:48,640 --> 00:23:51,500
ooh, numero, ooh, numero, ooh, numero, ooh - f.

388
00:23:51,500 --> 00:23:54,190
E sta andando a mettere la 1 2 3 n.

389
00:23:54,190 --> 00:23:59,970
E 'intenzione di mettere la f in c, e poi tornare 2.

390
00:23:59,970 --> 00:24:02,980
Così abbiamo, usando solo la definizione di base del comportamento di scanf,

391
00:24:02,980 --> 00:24:06,170
un modo molto semplice - bene, complesso a prima vista, ma alla fine della giornata,

392
00:24:06,170 --> 00:24:11,460
meccanismo abbastanza semplice di dire, c'è un int, e in tal caso, è che l'unica cosa che ho trovato?

393
00:24:11,460 --> 00:24:14,950
E lo spazio bianco qui è intenzionale. Se andate a leggere la documentazione per sscanf,

394
00:24:14,950 --> 00:24:18,690
ti dice che se si include un pezzo di spazio bianco all'inizio o alla fine,

395
00:24:18,690 --> 00:24:24,990
sscanf troppo consentirà all'utente, per qualsiasi motivo, per colpire la barra spaziatrice 1 2 3, e che sarà legittimo.

396
00:24:24,990 --> 00:24:28,310
Non griderà presso l'utente solo perché hanno colpito la barra spaziatrice, all'inizio o alla fine,

397
00:24:28,310 --> 00:24:32,160
che è solo un po 'più user-friendly.

398
00:24:32,160 --> 00:24:34,160
>> Tutte le domande, poi, GetInts? Si '?

399
00:24:34,160 --> 00:24:36,820
[Domanda Studente, incomprensibile]

400
00:24:36,820 --> 00:24:40,740
>> Buona domanda. Che cosa succede se hai appena digitato un carattere, come la f, e premi invio

401
00:24:40,740 --> 00:24:47,830
senza mai digitare 1 2 3, che ne pensi del comportamento di questa riga di codice sarebbe allora?

402
00:24:47,830 --> 00:24:50,500
Così sscanf in grado di coprire anche questo, perché in tal caso,

403
00:24:50,500 --> 00:24:56,280
non sta andando a riempire n o c, che sta per tornare invece 0.

404
00:24:56,280 --> 00:25:01,540
In questo caso, sono anche la cattura di tale scenario, in quanto il valore atteso che voglio è 1.

405
00:25:01,540 --> 00:25:07,310
Voglio solo 1, e solo 1 cosa da riempire. Bella domanda. Altri?

406
00:25:07,310 --> 00:25:09,610
>> Va bene, quindi cerchiamo di non passare attraverso tutte le funzioni qui dentro,

407
00:25:09,610 --> 00:25:11,820
ma quello che sembra essere, forse, di interesse rimane

408
00:25:11,820 --> 00:25:14,530
è GetString perché si scopre che getFloat, GetInt,

409
00:25:14,530 --> 00:25:19,490
GetDouble, GetLongLong tutto punt un sacco di loro funzionalità per GetString.

410
00:25:19,490 --> 00:25:22,860
Quindi, diamo uno sguardo a come si è implementato qui.

411
00:25:22,860 --> 00:25:27,040
Questo sembra un po 'complessa, ma utilizza i fondamenti stessi

412
00:25:27,040 --> 00:25:29,680
che abbiamo iniziato a parlare la settimana scorsa. Quindi, in GetString,

413
00:25:29,680 --> 00:25:32,670
che prende alcun argomento secondo il vuoto qui,

414
00:25:32,670 --> 00:25:37,110
e restituisce una stringa, così mi dichiara una stringa denominata buffer.

415
00:25:37,110 --> 00:25:39,670
Io non so davvero che cosa che sta per essere utilizzato per ancora, ma staremo a vedere.

416
00:25:39,670 --> 00:25:42,950
Assomiglia capacità è, per impostazione predefinita, 0, non del tutto sicuro dove questo sta andando.

417
00:25:42,950 --> 00:25:44,920
Non sei sicuro di quello che n sta per essere utilizzato per la ancora.

418
00:25:44,920 --> 00:25:47,860
Ma ora sta diventando un po 'più interessante, così in linea 243,

419
00:25:47,860 --> 00:25:51,760
si dichiara un int c, questo è una sorta di un dettaglio stupido.

420
00:25:51,760 --> 00:25:58,080
Un char è di 8 bit, e 8 bit in grado di memorizzare il numero di valori diversi?

421
00:25:58,080 --> 00:26:03,310
256. Il problema è che, se si desidera avere 256 caratteri ASCII differenti,

422
00:26:03,310 --> 00:26:06,210
che ci sono, se si pensa tornato, e questa non è una cosa da memorizzare.

423
00:26:06,210 --> 00:26:09,100
Ma se ripenso a quel grande grafico ASCII abbiamo avuto settimane fa,

424
00:26:09,100 --> 00:26:13,780
vi erano, in quel caso, 128 o 256 caratteri ASCII.

425
00:26:13,780 --> 00:26:16,220
Abbiamo usato tutti i modelli di 0 e di 1 in su.

426
00:26:16,220 --> 00:26:19,410
Questo è un problema se si vuole essere in grado di rilevare un errore.

427
00:26:19,410 --> 00:26:23,290
Perché se si sta già utilizzando 256 valori per i tuoi personaggi,

428
00:26:23,290 --> 00:26:26,390
che in realtà non pianificare in anticipo, perché ora non c'è modo di dire,

429
00:26:26,390 --> 00:26:29,750
"Questo non è un carattere legittimo, questo è un messaggio errato."

430
00:26:29,750 --> 00:26:32,430
Quindi, ciò che il mondo non è, si utilizza il valore più prossimo,

431
00:26:32,430 --> 00:26:35,790
qualcosa di simile a un int in modo da avere un numero pazzesco di bit,

432
00:26:35,790 --> 00:26:39,610
32 per 4 miliardi di possibili valori, in modo che si può semplicemente finire con,

433
00:26:39,610 --> 00:26:44,800
essenzialmente, 257 di loro, uno dei quali ha un significato speciale come un errore.

434
00:26:44,800 --> 00:26:49,190
>> Quindi cerchiamo di vedere come funziona. In linea 246, ho questo grande anello, mentre

435
00:26:49,190 --> 00:26:54,530
che chiama fgetc; file di significato f, getc, e quindi stdin.

436
00:26:54,530 --> 00:26:59,030
Si scopre che questo è solo il modo più preciso per dire "leggere l'input da tastiera."

437
00:26:59,030 --> 00:27:02,730
Tastiera standard mezzi di input, standard output significa schermo,

438
00:27:02,730 --> 00:27:06,920
e l'errore standard, che vedremo nel pset 4, significa che lo schermo,

439
00:27:06,920 --> 00:27:09,670
ma una parte speciale dello schermo in modo che non è fusero

440
00:27:09,670 --> 00:27:13,760
con uscita effettivo che si intende stampare, ma più su che in futuro.

441
00:27:13,760 --> 00:27:19,430
Così fgetc significa solo leggere un carattere dalla tastiera, e conservarla dove?

442
00:27:19,430 --> 00:27:24,000
Conservare in c, e quindi controllare, quindi sono solo l'utilizzo di alcune congiunzioni booleane qui,

443
00:27:24,000 --> 00:27:28,430
verificare che non è uguale a \ n, in modo che l'utente ha premuto invio.

444
00:27:28,430 --> 00:27:31,510
Vogliamo fermare a quel punto, fine del ciclo, e vogliamo anche verificare

445
00:27:31,510 --> 00:27:36,170
per la costante speciale, EOF, che se si conosce o indovinare - che cosa rappresenta?

446
00:27:36,170 --> 00:27:39,860
Fine del file. Quindi questo è una specie di assurdo, perché se sto scrivendo sulla tastiera,

447
00:27:39,860 --> 00:27:41,900
non c'è davvero alcun file coinvolti in questo,

448
00:27:41,900 --> 00:27:44,330
ma questa è solo una specie di termine generico usato per indicare

449
00:27:44,330 --> 00:27:50,320
che nessun altro è in arrivo dalle dita del dell'essere umano. EOF. Fine del file.

450
00:27:50,320 --> 00:27:52,600
Per inciso, se hai mai colpito il controllo d a tastiera,

451
00:27:52,600 --> 00:27:54,680
non che si devono ancora, hai raggiunto il controllo c.

452
00:27:54,680 --> 00:27:57,920
Ma il controllo d invia questo speciale EOF costante chiamata.

453
00:27:57,920 --> 00:28:03,100
>> Così ora non ci resta che un po 'di allocazione dinamica della memoria.

454
00:28:03,100 --> 00:28:06,460
Quindi, se n + 1> capacità, ora ti spiego n.

455
00:28:06,460 --> 00:28:09,380
n è solo il numero di byte attualmente nel buffer,

456
00:28:09,380 --> 00:28:11,970
la stringa che si sta costruendo da parte dell'utente.

457
00:28:11,970 --> 00:28:16,240
Se si dispone di più caratteri nel buffer di quello che hai capacità nel buffer,

458
00:28:16,240 --> 00:28:20,760
intuitivamente, quello che dobbiamo fare è quindi allocare più capacità.

459
00:28:20,760 --> 00:28:24,490
Ho intenzione di sorvolare su alcune delle aritmetica qui

460
00:28:24,490 --> 00:28:26,900
e concentrarsi solo su questa funzione qui.

461
00:28:26,900 --> 00:28:29,170
Sai cosa malloc è, o almeno generalmente familiare.

462
00:28:29,170 --> 00:28:32,380
Prova a indovinare cosa realloc fa. [Risposta studente, incomprensibile]

463
00:28:32,380 --> 00:28:35,690
Sì >>. E non è tutto l'aggiunta di memoria, ma riassegna memoria come segue:

464
00:28:35,690 --> 00:28:40,530
Se c'è ancora spazio alla fine della stringa per dare più di quel ricordo

465
00:28:40,530 --> 00:28:43,370
che dà origine, allora si otterrà che la memoria aggiuntiva.

466
00:28:43,370 --> 00:28:46,640
Così si può solo mettere i caratteri stringhe back to back to back to back.

467
00:28:46,640 --> 00:28:49,290
Ma se non è questo il caso, perché hai aspettato troppo a lungo

468
00:28:49,290 --> 00:28:51,700
e qualcosa di casuale ottenuto si lasciò in memoria lì, ma non c'è più

469
00:28:51,700 --> 00:28:56,480
memoria qui, va bene. Realloc sta andando a fare tutto il lavoro pesante per voi,

470
00:28:56,480 --> 00:28:58,810
spostare la stringa che hai letto in così lontano da qui,

471
00:28:58,810 --> 00:29:02,550
metterlo laggiù, e poi danno pista ancora un po 'a quel punto.

472
00:29:02,550 --> 00:29:05,610
Così, con un gesto della mano, lasciatemi dire che quello che sta facendo GetString

473
00:29:05,610 --> 00:29:09,540
si sta partendo con un buffer piccolo, forse 1 singolo carattere,

474
00:29:09,540 --> 00:29:12,300
e se l'utente digita in 2 caratteri, GetString finisce

475
00:29:12,300 --> 00:29:15,210
chiamare realloc e dice: 'Ooh, 1 carattere non era sufficiente.

476
00:29:15,210 --> 00:29:18,480
Dammi 2 caratteri. ' Poi se si legge attraverso la logica del ciclo,

477
00:29:18,480 --> 00:29:21,070
sta andando a dire: 'Ooh, l'utente ha digitato in 3 caratteri.

478
00:29:21,070 --> 00:29:25,690
Dammi ora non 2 ma 4 caratteri, allora dammi 8, poi dammi 16 e 32. '

479
00:29:25,690 --> 00:29:28,180
Il fatto che io sono il raddoppio della capacità di volta in volta

480
00:29:28,180 --> 00:29:30,320
significa che il buffer non ha intenzione di crescere lentamente.

481
00:29:30,320 --> 00:29:35,870
E 'intenzione di crescere super veloce, e quale potrebbe essere il vantaggio di questo?

482
00:29:35,870 --> 00:29:38,540
Perché mi raddoppiando la dimensione del buffer, anche se l'utente

483
00:29:38,540 --> 00:29:41,450
potrebbe solo bisogno di 1 carattere aggiuntivo dalla tastiera?

484
00:29:41,450 --> 00:29:44,830
[Risposta studente, incomprensibile]. >> Che cos'è?

485
00:29:44,830 --> 00:29:46,750
Esattamente. Non c'è bisogno di crescere come spesso.

486
00:29:46,750 --> 00:29:48,870
E questo è solo una specie di - tu sei di copertura vostre scommesse qui.

487
00:29:48,870 --> 00:29:54,150
L'idea è che non si desidera chiamare realloc molto, perché tende ad essere lento.

488
00:29:54,150 --> 00:29:56,840
Ogni volta che si chiede il sistema operativo per la memoria, come vedrete presto

489
00:29:56,840 --> 00:30:00,620
in un set problema futuro, tende a richiedere un certo tempo.

490
00:30:00,620 --> 00:30:04,980
Quindi, riducendo al minimo tale periodo di tempo, anche se si sta perdendo un po 'di spazio, tende ad essere una buona cosa.

491
00:30:04,980 --> 00:30:07,250
>> Ma se si legge attraverso la parte finale della GetString qui,

492
00:30:07,250 --> 00:30:10,880
e ancora, capire ogni singola riga qui non è così importante oggi.

493
00:30:10,880 --> 00:30:14,830
Ma notare che alla fine chiama malloc di nuovo, e si assegna

494
00:30:14,830 --> 00:30:16,980
esattamente come byte quanti ne sono necessari per la stringa

495
00:30:16,980 --> 00:30:21,620
e poi getta via al numero gratuito, il buffer eccessivamente grande,

496
00:30:21,620 --> 00:30:23,510
se davvero ha raddoppiato troppe volte.

497
00:30:23,510 --> 00:30:25,970
In breve, questo è il modo GetString ha lavorato per tutto questo tempo.

498
00:30:25,970 --> 00:30:30,100
Tutto ciò che fa è leggere un carattere alla volta ancora e ancora e ancora

499
00:30:30,100 --> 00:30:37,930
e ogni volta che ha bisogno di un po 'di memoria aggiuntiva, chiede il sistema operativo per chiamando realloc.

500
00:30:37,930 --> 00:30:41,660
Hai ancora domande? Bene.

501
00:30:41,660 --> 00:30:45,220
>> Un attacco. Ora che abbiamo capito i puntatori, o per lo meno

502
00:30:45,220 --> 00:30:47,560
sono sempre più familiari con i puntatori,

503
00:30:47,560 --> 00:30:50,020
prendiamo in considerazione come il mondo intero inizia a crollare

504
00:30:50,020 --> 00:30:53,160
se non riesco a difendersi contro gli utenti contraddittorio,

505
00:30:53,160 --> 00:30:55,180
le persone che stanno cercando di penetrare nel vostro sistema.

506
00:30:55,180 --> 00:31:00,260
Le persone che stanno cercando di rubare il software aggirando qualche codice di registrazione

507
00:31:00,260 --> 00:31:02,150
che potrebbero altrimenti essere necessario digitare trovi

508
00:31:02,150 --> 00:31:04,860
Date un'occhiata a questo esempio qui, che è solo il codice C

509
00:31:04,860 --> 00:31:07,920
che ha una funzione principale in fondo, che chiama una funzione foo,

510
00:31:07,920 --> 00:31:12,100
e ciò che sta passando a foo? [Studente] Un singolo argomento.

511
00:31:12,100 --> 00:31:15,660
>> Singolo argomento. Quindi, argv [1], il che significa che la prima parola l'utente ha digitato

512
00:31:15,660 --> 00:31:19,150
dalla riga di comando dopo a.out o qualunque sia il programma si chiama.

513
00:31:19,150 --> 00:31:24,920
Quindi foo, in alto, prende in un char *, char *, ma è proprio quello?

514
00:31:24,920 --> 00:31:28,860
String. Non c'è niente di nuovo qui, e che la stringa viene arbitrariamente chiamato bar.

515
00:31:28,860 --> 00:31:36,090
In questa linea qui, char c [12], in una sorta di semi-inglese tecnico, cosa sta facendo questa linea?

516
00:31:36,090 --> 00:31:40,640
Array di -? Caratteri. Dammi un array di 12 caratteri.

517
00:31:40,640 --> 00:31:44,970
Così si potrebbe chiamare questo un buffer. E 'tecnicamente chiamato c, ma un buffer in programmazione

518
00:31:44,970 --> 00:31:47,890
significa solo un mucchio di spazio che si può mettere un po 'di roba trovi

519
00:31:47,890 --> 00:31:49,940
>> Poi infine, memcpy, non abbiamo usato prima.

520
00:31:49,940 --> 00:31:52,380
Ma si può intuire ciò che fa. Esso copia della memoria.

521
00:31:52,380 --> 00:31:58,790
Che cosa fa? Beh, a quanto pare copia bar, il suo ingresso, in c,

522
00:31:58,790 --> 00:32:03,420
ma solo fino alla lunghezza della barra.

523
00:32:03,420 --> 00:32:07,440
Ma c'è un bug qui.

524
00:32:07,440 --> 00:32:14,500
Okay, tecnicamente si dovrebbe davvero fare strlen (bar) x sizeof (char), e 'corretto.

525
00:32:14,500 --> 00:32:17,920
Ma nel peggiore dei casi qui, supponiamo che that's - così, va bene.

526
00:32:17,920 --> 00:32:23,760
Poi ci sono 2 bug. Quindi, sizeof (char), va bene, facciamo questo un po 'di più.

527
00:32:23,760 --> 00:32:28,860
Così ora c'è ancora un bug, che è quello che?

528
00:32:28,860 --> 00:32:31,630
[Risposta studente, incomprensibile] >> Controlla per cosa? Ok, allora ci dovrebbe essere il controllo

529
00:32:31,630 --> 00:32:35,010
per NULL, perché le cose vanno così male quando il puntatore è NULL,

530
00:32:35,010 --> 00:32:38,490
Perché si potrebbe finire per andare lì, e non si dovrebbe mai andare a NULL

531
00:32:38,490 --> 00:32:40,890
deferenziandolo con l'operatore *.

532
00:32:40,890 --> 00:32:45,250
Quindi questo è un bene, e che altro stiamo facendo? Logicamente c'è un difetto anche qui.

533
00:32:45,250 --> 00:32:47,650
[Risposta studente, incomprensibile]

534
00:32:47,650 --> 00:32:51,340
>> Quindi controllare se argc ≥ 2?

535
00:32:51,340 --> 00:32:54,130
Ok, quindi non c'è 3 bug in questo programma.

536
00:32:54,130 --> 00:33:00,080
Non stiamo verificando se l'utente effettivamente digitato qualcosa in argv [1], bene.

537
00:33:00,080 --> 00:33:02,240
Allora qual è il bug terzo? Si '?

538
00:33:02,240 --> 00:33:04,420
[Risposta studente, incomprensibile] >> Bene.

539
00:33:04,420 --> 00:33:09,590
Così abbiamo controllato uno scenario. Abbiamo controllato implicitamente non copiare più memoria

540
00:33:09,590 --> 00:33:12,800
che supera la lunghezza della barra.

541
00:33:12,800 --> 00:33:15,720
Quindi, se la stringa che l'utente digitato è di 10 caratteri,

542
00:33:15,720 --> 00:33:18,260
questo sta dicendo, 'Copia solo 10 caratteri.'

543
00:33:18,260 --> 00:33:21,140
E va bene, ma cosa succede se l'utente ha digitato in una parola al prompt

544
00:33:21,140 --> 00:33:29,360
come una parola di 20 caratteri, questo è, dicendo copia 20 caratteri dalla barra in che cosa?

545
00:33:29,360 --> 00:33:32,840
c, altrimenti noto come il buffer, il che significa che i dati appena scritto

546
00:33:32,840 --> 00:33:35,950
a 8 posizioni di byte che non si è proprietari,

547
00:33:35,950 --> 00:33:38,320
e tu non ne sei il proprietario, nel senso che non li avete mai assegnato.

548
00:33:38,320 --> 00:33:41,190
Quindi questo è ciò che è comunemente noto come l'attacco di tipo buffer overflow,

549
00:33:41,190 --> 00:33:46,650
o attacco di buffer overrun, e l'attacco, nel senso che se l'utente

550
00:33:46,650 --> 00:33:50,650
o il programma che sta chiamando la funzione sta facendo questo maliziosamente,

551
00:33:50,650 --> 00:33:53,780
ciò che effettivamente accade successivo potrebbe essere piuttosto male.

552
00:33:53,780 --> 00:33:55,690
>> Diamo uno sguardo a questa immagine qui.

553
00:33:55,690 --> 00:33:59,070
Questa foto rappresenta la tua pila di memoria.

554
00:33:59,070 --> 00:34:01,050
E ricordare che ogni volta che si chiama una funzione,

555
00:34:01,050 --> 00:34:04,520
si ottiene questo quadro poco nello stack e poi un altro e poi un altro e poi un altro.

556
00:34:04,520 --> 00:34:07,250
E fin qui abbiamo solo un po 'astratto via come questi rettangoli

557
00:34:07,250 --> 00:34:09,380
sia lì sul bordo o sulla schermata qui.

558
00:34:09,380 --> 00:34:12,219
Ma se lo zoom su uno di quei rettangoli,

559
00:34:12,219 --> 00:34:16,460
quando si chiama una funzione foo, si scopre che c'è di più in pila

560
00:34:16,460 --> 00:34:18,739
all'interno di detto telaio e che rettangolo

561
00:34:18,739 --> 00:34:23,370
non solo x e y e a e b, come abbiamo fatto parlare di swap.

562
00:34:23,370 --> 00:34:25,949
Si scopre che ci sono alcuni dettagli di livello inferiore,

563
00:34:25,949 --> 00:34:27,780
tra di loro indirizzo di ritorno.

564
00:34:27,780 --> 00:34:33,020
Così si scopre quando principale chiama foo, principale deve informare foo

565
00:34:33,020 --> 00:34:36,760
quale indirizzo principale è nella memoria del computer.

566
00:34:36,760 --> 00:34:40,659
Perché altrimenti, non appena foo è fatto esecuzione, come in questo caso qui,

567
00:34:40,659 --> 00:34:43,790
una volta raggiunto questo tutore vicino riccio alla fine di foo,

568
00:34:43,790 --> 00:34:48,860
come cavolo si sa dove foo controllo del programma dovrebbe andare?

569
00:34:48,860 --> 00:34:52,460
Si scopre che la risposta a questa domanda è in quel rettangolo rosso qui.

570
00:34:52,460 --> 00:34:56,130
Si tratta di un puntatore, e sta al computer per memorizzare, temporaneamente,

571
00:34:56,130 --> 00:35:00,250
sulla cosiddetta pila l'indirizzo principale in modo che non appena foo è fatto esecuzione,

572
00:35:00,250 --> 00:35:04,110
il computer sa dove e cosa linea principale per tornare a.

573
00:35:04,110 --> 00:35:06,900
Frame pointer salvata riferisce in modo simile a questo.

574
00:35:06,900 --> 00:35:09,620
Bar * Char qui rappresenta ciò?

575
00:35:09,620 --> 00:35:14,740
Bene, ora questo segmento blu è qui cornice foo, che cosa è il bar?

576
00:35:14,740 --> 00:35:18,300
Ok, quindi bar è solo l'argomento per la funzione foo.

577
00:35:18,300 --> 00:35:20,720
>> Così ora siamo tornati il ​​quadro familiare.

578
00:35:20,720 --> 00:35:22,960
Ci sono più cose e più distrazioni sullo schermo

579
00:35:22,960 --> 00:35:27,490
ma questo segmento di luce blu è quello che abbiamo disegnare alla lavagna per qualcosa come swap.

580
00:35:27,490 --> 00:35:31,890
Questa è la cornice per foo e l'unica cosa in proprio ora è il bar,

581
00:35:31,890 --> 00:35:34,630
che è questo parametro.

582
00:35:34,630 --> 00:35:39,840
Ma che altro dovrebbe essere nello stack, in base a questo codice qui?

583
00:35:39,840 --> 00:35:44,280
Char c [12]. Quindi dovremmo anche vedere 12 quadrati di memoria,

584
00:35:44,280 --> 00:35:46,260
assegnato ad una variabile denominata c.

585
00:35:46,260 --> 00:35:48,340
E infatti noi abbiamo che sullo schermo.

586
00:35:48,340 --> 00:35:51,650
La cima è c [0], e poi l'autore di questo schema

587
00:35:51,650 --> 00:35:55,130
non si preoccupò di disegnare tutte le piazze, ma ci sono davvero 12 si

588
00:35:55,130 --> 00:36:00,120
perché se si guarda in basso a destra, c [11], se si contano da 0, sono i 12 byte del genere.

589
00:36:00,120 --> 00:36:06,190
Ma ecco il problema: In quale direzione sta crescendo c?

590
00:36:06,190 --> 00:36:10,390
Un po 'verso il basso, giusto? Se inizia in alto e cresce verso il basso,

591
00:36:10,390 --> 00:36:13,480
non sembra ci lasciato pista molto qui a tutti.

592
00:36:13,480 --> 00:36:15,320
Abbiamo tipo di noi stessi in un angolo,

593
00:36:15,320 --> 00:36:20,210
e che c [11] è proprio contro il bar, che si trova proprio di fronte puntatore dello stack frame,

594
00:36:20,210 --> 00:36:23,800
che si trova proprio di fronte l'indirizzo di ritorno, non c'è più posto.

595
00:36:23,800 --> 00:36:26,100
Allora, qual è l'implicazione, allora, se si avvitare,

596
00:36:26,100 --> 00:36:30,460
e provare a leggere 20 byte in un buffer di 12 byte?

597
00:36:30,460 --> 00:36:33,460
Dove questi 8 byte aggiuntivi intenzione di andare?

598
00:36:33,460 --> 00:36:36,370
All'interno tutto il resto, alcuni dei quali è super importante.

599
00:36:36,370 --> 00:36:40,480
E la cosa più importante, potenzialmente, è la scatola rossa c'è, l'indirizzo di ritorno.

600
00:36:40,480 --> 00:36:44,720
Perché supporre che o si è accidentalmente o contraddittorio

601
00:36:44,720 --> 00:36:48,040
sovrascrivere le 4 byte, che si rivolgono a puntatore,

602
00:36:48,040 --> 00:36:53,190
non solo con i rifiuti, ma con un numero che succede a rappresentare un indirizzo effettivo di memoria?

603
00:36:53,190 --> 00:36:55,930
Qual è il implicaiton, logicamente?

604
00:36:55,930 --> 00:36:59,080
[Le risposte degli studenti, incomprensibile] >> Esattamente. Quando ritorna foo

605
00:36:59,080 --> 00:37:03,560
e colpisce che la parentesi graffa, il programma sta per procedere non per tornare alla pagina principale,

606
00:37:03,560 --> 00:37:08,320
che sta per tornare a qualsiasi indirizzo si trova in quella scatola rossa.

607
00:37:08,320 --> 00:37:11,560
>> Ora, nel caso di registrazione del software eludere,

608
00:37:11,560 --> 00:37:14,400
qual è l'indirizzo che viene restituito è la funzione

609
00:37:14,400 --> 00:37:18,820
che normalmente viene chiamato dopo che hai pagato per il software e immesso il codice di registrazione?

610
00:37:18,820 --> 00:37:23,160
Si potrebbe ordinare di trucco del computer in non andare qui, ma invece, andando qui.

611
00:37:23,160 --> 00:37:27,950
Oppure, se sei davvero intelligente, un avversario può effettivamente digitare alla tastiera,

612
00:37:27,950 --> 00:37:32,500
per esempio, non una parola vera, non 20 caratteri, ma supponiamo che lui o lei

613
00:37:32,500 --> 00:37:36,200
in alcuni tipi di caratteri che rappresentano il codice?

614
00:37:36,200 --> 00:37:38,860
E non sarà il codice C, che sta per essere i caratteri

615
00:37:38,860 --> 00:37:42,920
che rappresentano codici macchina binario, 0 e di 1.

616
00:37:42,920 --> 00:37:46,740
Ma se sono abbastanza intelligenti per farlo, per incollare in qualche modo nel prompt GetString

617
00:37:46,740 --> 00:37:49,460
qualcosa che è essenzialmente codice compilato,

618
00:37:49,460 --> 00:37:56,900
e gli ultimi 4 byte sovrascrivere l'indirizzo di ritorno, ea che indirizzo vuol fare ingresso?

619
00:37:56,900 --> 00:38:01,860
Lo memorizza in questo rettangolo rosso l'indirizzo del primo byte del buffer.

620
00:38:01,860 --> 00:38:04,270
Quindi devi essere molto intelligente, e questo è un sacco di tentativi ed errori

621
00:38:04,270 --> 00:38:08,500
per le persone cattive là fuori, ma se si riesce a capire quanto è grande questo buffer è,

622
00:38:08,500 --> 00:38:12,170
tale che gli ultimi bytes in ingresso che fornisce al programma

623
00:38:12,170 --> 00:38:15,970
capita di essere equivalente al indirizzo iniziale del buffer,

624
00:38:15,970 --> 00:38:22,270
si può fare questo. Se diciamo, di solito, ciao, e \ 0, questo è ciò che finisce nel buffer.

625
00:38:22,270 --> 00:38:27,860
Ma se siamo più intelligenti, e noi riempire il buffer con quello che ci chiamiamo genericamente codice di attacco,

626
00:38:27,860 --> 00:38:31,920
A, A, A, A: attacco, attacco, attacco, attacco, dove questo è solo qualcosa che fa qualcosa di male.

627
00:38:31,920 --> 00:38:35,190
Ebbene, che cosa succede se si è davvero intelligente, si potrebbe fare questo:

628
00:38:35,190 --> 00:38:41,740
Nella scatola rossa qui è una sequenza di numeri: 80, CO, 35, 08.

629
00:38:41,740 --> 00:38:44,890
Si noti che che corrisponde al numero che è qui.

630
00:38:44,890 --> 00:38:47,280
E 'in ordine inverso, ma più su che un'altra volta.

631
00:38:47,280 --> 00:38:51,430
Si noti che questo indirizzo di ritorno siano stati deliberatamente modificati

632
00:38:51,430 --> 00:38:54,970
per eguagliare l'indirizzo qui, non l'indirizzo del principale.

633
00:38:54,970 --> 00:39:00,170
Quindi, se il cattivo è super intelligente, lui o lei sta andando a includere in tale codice di attacco

634
00:39:00,170 --> 00:39:02,890
qualcosa di simile, 'Elimina tutti i file dell'utente.'

635
00:39:02,890 --> 00:39:06,320
O 'Copiare le password,' o 'Creare un account utente che può accedere.'

636
00:39:06,320 --> 00:39:10,130
Nulla, e questo è sia il pericolo e il potere di C.

637
00:39:10,130 --> 00:39:12,900
Perché si ha accesso alla memoria tramite puntatori

638
00:39:12,900 --> 00:39:15,950
e si può quindi scrivere tutto quello che vuoi nella memoria di un computer.

639
00:39:15,950 --> 00:39:19,290
Si può fare un computer a fare tutto quello che vuoi semplicemente

640
00:39:19,290 --> 00:39:22,780
averlo saltare nel suo spazio di memoria.

641
00:39:22,780 --> 00:39:27,230
E così, fino ad oggi, così molti programmi e siti web così tanti che sono compromesse

642
00:39:27,230 --> 00:39:29,730
si riducono a persone che beneficiano di questo.

643
00:39:29,730 --> 00:39:32,510
E questo potrebbe sembrare un super-sofisticato attacco,

644
00:39:32,510 --> 00:39:34,220
ma non sempre iniziare in quel modo.

645
00:39:34,220 --> 00:39:36,770
>> La realtà è che ciò che le persone cattive in genere fare è,

646
00:39:36,770 --> 00:39:41,470
se si tratta di un programma a riga di comando o un programma con interfaccia grafica o un sito web,

647
00:39:41,470 --> 00:39:43,290
vi basta iniziare a fornire una sciocchezza.

648
00:39:43,290 --> 00:39:46,940
Si digita in una parola molto grande nel campo di ricerca e premi Invio,

649
00:39:46,940 --> 00:39:49,030
e si aspetta di vedere se il crash del sito web.

650
00:39:49,030 --> 00:39:53,270
Oppure aspettare per vedere se il programma si manifesta qualche messaggio di errore.

651
00:39:53,270 --> 00:39:55,480
Perché se sei fortunato, come il cattivo,

652
00:39:55,480 --> 00:39:59,610
e di fornire alcuni input pazzo che va in crash il programma,

653
00:39:59,610 --> 00:40:02,280
questo significa che il programmatore non ha previsto il tuo cattivo comportamento

654
00:40:02,280 --> 00:40:05,420
il che significa che probabilmente si può, con uno sforzo sufficiente,

655
00:40:05,420 --> 00:40:09,870
prova sufficiente ed errori, capire come condurre un attacco più preciso.

656
00:40:09,870 --> 00:40:15,900
Così tanto una parte della sicurezza non è solo di evitare questi attacchi del tutto, ma individuarli

657
00:40:15,900 --> 00:40:20,250
e in realtà guardando i log e vedere quali fattori pazzi sono persone digitato nel tuo sito web.

658
00:40:20,250 --> 00:40:26,040
Quali parole di ricerca sono le persone digitato nel tuo sito web nella speranza di traboccante un buffer?

659
00:40:26,040 --> 00:40:28,900
E questo tutto si riduce a semplici le basi di ciò che è un array,

660
00:40:28,900 --> 00:40:32,510
e cosa significa per allocare e utilizzare la memoria?

661
00:40:32,510 --> 00:40:34,920
E, per tale, anche, è questo.

662
00:40:34,920 --> 00:40:37,520
>> Così facciamo solo uno sguardo all'interno di un hard disk ancora una volta.

663
00:40:37,520 --> 00:40:40,190
Così si richiama da una settimana o due fa che quando si trascinare i file

664
00:40:40,190 --> 00:40:45,470
al cestino o cestino, cosa succede?

665
00:40:45,470 --> 00:40:47,850
[Studente] Niente. >> Si ', assolutamente nulla. Alla fine se si esegue basso

666
00:40:47,850 --> 00:40:51,370
lo spazio su disco, Windows o Mac OS avvierà l'eliminazione dei file per voi.

667
00:40:51,370 --> 00:40:53,670
Ma se si trascina qualcosa in là, allora non è affatto sicuro.

668
00:40:53,670 --> 00:40:56,550
Tutto il membro compagno di stanza, amico o un familiare ha a che fare è fare doppio clic, e voilà.

669
00:40:56,550 --> 00:40:59,720
Ci sono tutti i file abbozzato che stai cercando di eliminare.

670
00:40:59,720 --> 00:41:02,840
Così la maggior parte di noi almeno sappiamo che è necessario fare clic destro o controllare click

671
00:41:02,840 --> 00:41:05,320
e svuotare il cestino, o qualcosa del genere.

672
00:41:05,320 --> 00:41:07,900
Ma anche allora, che non farà il trucco.

673
00:41:07,900 --> 00:41:11,340
Perché ciò che accade quando si ha un file sul disco rigido

674
00:41:11,340 --> 00:41:14,590
che rappresenta circa il documento di Word o un po 'di JPEG?

675
00:41:14,590 --> 00:41:18,820
E questo rappresenta il disco rigido, e diciamo che questo frammento qui rappresenta quel file,

676
00:41:18,820 --> 00:41:21,640
ed è composto da un insieme di 0 e di 1.

677
00:41:21,640 --> 00:41:25,470
Cosa succede quando non solo trascinare il file nel cestino o cestino,

678
00:41:25,470 --> 00:41:30,390
ma anche svuotarla?

679
00:41:30,390 --> 00:41:32,820
Una specie di nulla. Non è assolutamente nulla.

680
00:41:32,820 --> 00:41:37,630
Ora è proprio niente, perché un po 'di qualcosa che accade in forma di questa tabella.

681
00:41:37,630 --> 00:41:41,170
Quindi c'è una sorta di database o una tabella all'interno della memoria di un computer

682
00:41:41,170 --> 00:41:44,470
che ha essenzialmente 1 colonna per i nomi dei file,

683
00:41:44,470 --> 00:41:50,550
e 1 colonna per la posizione del file, dove questo potrebbe essere posizione 123, solo un numero casuale.

684
00:41:50,550 --> 00:41:58,270
Così potremmo avere qualcosa di simile x.jpg, e la posizione 123.

685
00:41:58,270 --> 00:42:02,870
E cosa succede poi, quando si svuota il cestino?

686
00:42:02,870 --> 00:42:06,720
Che se ne va. Ma ciò che non va via è lo 0 e di 1.

687
00:42:06,720 --> 00:42:09,690
>> Così che cosa è, poi, il collegamento al pset 4?

688
00:42:09,690 --> 00:42:13,460
Bene, con pset 4, solo perché abbiamo accidentalmente cancellato

689
00:42:13,460 --> 00:42:15,890
la scheda Compact Flash che aveva tutte queste foto,

690
00:42:15,890 --> 00:42:18,710
o semplicemente perché dalla sfortuna è corrotto,

691
00:42:18,710 --> 00:42:21,170
non significa che lo 0 e 1 non sono ancora lì.

692
00:42:21,170 --> 00:42:23,920
Forse alcuni di loro si perdono perché qualcosa ha danneggiato

693
00:42:23,920 --> 00:42:26,530
nel senso che alcuni divenne 1 0 e di 1 diventa 0.

694
00:42:26,530 --> 00:42:30,460
Le cose brutte possono accadere a causa di software difettoso o hardware difettoso.

695
00:42:30,460 --> 00:42:33,510
Ma molti di questi frammenti, forse anche il 100% di loro sono ancora lì,

696
00:42:33,510 --> 00:42:38,330
è solo che il computer o la fotocamera non sa dove JPEG 1 è partito

697
00:42:38,330 --> 00:42:41,660
e dove JPEG 2 è partito, ma se si, il programmatore,

698
00:42:41,660 --> 00:42:45,800
sa, con un po 'di buon senso, se tali file JPEG sono o quello che sembrano,

699
00:42:45,800 --> 00:42:49,570
è possibile analizzare la 0 e 1 e dire, 'Ooh. JPEG. Ooh, JPEG. '

700
00:42:49,570 --> 00:42:52,830
È possibile scrivere un programma con essenzialmente solo un ciclo for o while

701
00:42:52,830 --> 00:42:56,100
che recupera ognuno di quei file.

702
00:42:56,100 --> 00:42:59,360
Così la lezione quindi, è quello di iniziare "in modo sicuro" cancellare i file

703
00:42:59,360 --> 00:43:01,720
se vuoi evitare questo del tutto. Sì?

704
00:43:01,720 --> 00:43:06,940
[Domanda Studente, incomprensibile]

705
00:43:06,940 --> 00:43:11,150
>> Avere più memoria di quanto fatto prima -

706
00:43:11,150 --> 00:43:14,790
Oh! Bella domanda. Perché, poi, dopo lo svuotamento del cestino,

707
00:43:14,790 --> 00:43:18,300
è il computer vi dirà che avete più spazio libero che avete fatto prima?

708
00:43:18,300 --> 00:43:22,450
In poche parole, perché sta mentendo. Più tecnicamente, si ha più spazio.

709
00:43:22,450 --> 00:43:26,720
Perché ora si è detto, si può mettere altre cose in cui il file una volta,

710
00:43:26,720 --> 00:43:28,930
ma questo non significa che i bit stanno andando via,

711
00:43:28,930 --> 00:43:33,070
e questo non significa che i bit sono stati cambiati tutti 0, per esempio, per la vostra protezione.

712
00:43:33,070 --> 00:43:37,520
Al contrario, se "in modo sicuro" cancellare file, o distruggere fisicamente il dispositivo,

713
00:43:37,520 --> 00:43:40,810
questo è davvero l'unico modo, a volte, intorno a quello.

714
00:43:40,810 --> 00:43:45,300
Allora perché non lasciamo che il semi-spaventoso nota, e ci vedremo il Lunedi.

715
00:43:45,300 --> 00:43:52,810
CS50.TV