1
00:00:00,000 --> 00:00:11,242
>> [MUSIC PLAYING]

2
00:00:11,242 --> 00:00:16,630
>> DAVID J. MALAN: Va bene questo è CS50
e questo è l'inizio di settimana cinque.

3
00:00:16,630 --> 00:00:21,480
Così oggi, sotto i cuscini di seduta,
non troverete nulla.

4
00:00:21,480 --> 00:00:24,790
Ma, soprattutto, si dovrebbe trovare questi, un
piccolo segno del nostro apprezzamento per il

5
00:00:24,790 --> 00:00:26,970
tutto il lavoro che hai messo
nel Gioco dei Quindici.

6
00:00:26,970 --> 00:00:30,290
Basta rimuovere il piccolo cerchio sul
fondo per iniziare a giocare per la

7
00:00:30,290 --> 00:00:31,680
resto della classe.

8
00:00:31,680 --> 00:00:38,930
>> Così ricordare che, o sapere che problema posto
quattro, che è uscito questo fine settimana,

9
00:00:38,930 --> 00:00:40,340
comporta la scrittura di un altro gioco.

10
00:00:40,340 --> 00:00:43,740
Ma questa volta comporta l'uso di un
interfaccia utente grafica effettiva, non una

11
00:00:43,740 --> 00:00:46,310
interfaccia testuale come
Gioco del Quindici è stato.

12
00:00:46,310 --> 00:00:50,210
E il gioco che si trova davanti a voi,
se non avete ancora visto questo prossimo,

13
00:00:50,210 --> 00:00:52,310
sembra un po 'qualcosa di simile a questo.

14
00:00:52,310 --> 00:00:55,170
Ho intenzione di andare nel mio terminale
finestra qui a GDB.

15
00:00:55,170 --> 00:00:58,600
E ho intenzione di andare avanti ed eseguire il
soluzione personale, cui è possibile accedere

16
00:00:58,600 --> 00:01:01,010
dopo l'esecuzione di update 50 come al solito.

17
00:01:01,010 --> 00:01:04,090
>> Ma ho intenzione di metterla in un po 'di
modo segreto, un piccolo uovo di Pasqua,

18
00:01:04,090 --> 00:01:08,480
cosiddetta modalità di Dio, da
mettere Dio in argv1.

19
00:01:08,480 --> 00:01:12,920
E devo seguire le mie indicazioni,
eseguirlo nel mio

20
00:01:12,920 --> 00:01:14,220
problema impostare la directory.

21
00:01:14,220 --> 00:01:19,190
Così ora si vede una versione completa
del gioco di Breakout.

22
00:01:19,190 --> 00:01:21,090
In realtà, questo è modalità nessuna mani.

23
00:01:21,090 --> 00:01:24,850
Quindi, in realtà -

24
00:01:24,850 --> 00:01:26,470
entusiasmato anche se si potrebbe essere -

25
00:01:26,470 --> 00:01:30,850
abbastanza banale da implementare la modalità Dio in
Breakout, a differenza del gioco di quindici anni,

26
00:01:30,850 --> 00:01:33,590
che alcuni di voi hanno affrontato
per l'edizione di hacker.

27
00:01:33,590 --> 00:01:37,890
>> In Breakout è sufficiente in Dio
Modalità di semplicemente fare ciò,

28
00:01:37,890 --> 00:01:41,220
intuitivamente con la pagaia?

29
00:01:41,220 --> 00:01:45,630
Basta fare uguale qualunque sia il
posizione orizzontale è della palla.

30
00:01:45,630 --> 00:01:49,220
E fino a quando si esegue questa operazione in sincronia
con la palla in movimento questo gioco sarà

31
00:01:49,220 --> 00:01:53,100
mai, mai, mai perdere la palla
e potrai vincere ogni volta.

32
00:01:53,100 --> 00:01:55,430
>> Ma in questa settimana edizione di hacker
c'è più di un semplice modo di Dio.

33
00:01:55,430 --> 00:01:56,720
C'è una serie di altre funzioni.

34
00:01:56,720 --> 00:01:58,140
Tra questi, i laser.

35
00:01:58,140 --> 00:02:01,070
In modo che se hai davvero impaziente di
può iniziare abbattere i mattoni

36
00:02:01,070 --> 00:02:02,120
e pochi altri.

37
00:02:02,120 --> 00:02:04,560
E per quelli di voi che vorrebbe
calibrare Standard piuttosto che degli hacker

38
00:02:04,560 --> 00:02:08,750
edizione, vedo che di questa settimana
edizione degli hacker volutamente è un

39
00:02:08,750 --> 00:02:12,830
poco più fattibile, per dire, che Dio
Modalità era con Gioco del Quindici.

40
00:02:12,830 --> 00:02:15,300
>> Quindi, se siete alla ricerca di un tratto e di
siete alla ricerca di un po 'di divertimento aggiuntivo

41
00:02:15,300 --> 00:02:18,400
caratteristiche fanno immersione in caso di interesse.

42
00:02:18,400 --> 00:02:21,280
Ora più praticamente, vorrei sottolineare
fuori una cosa così.

43
00:02:21,280 --> 00:02:24,780
GDB, che alcuni di voi potrebbero non avere ancora
toccato personalmente, che va bene.

44
00:02:24,780 --> 00:02:28,530
Ma ora è davvero il tempo di abituarsi
per questo e confortevole con questo strumento

45
00:02:28,530 --> 00:02:31,510
perché renderà la vostra vita
molto più semplice, veramente.

46
00:02:31,510 --> 00:02:34,900
>> A lezione di Rob su GDB una coppia
di settimane fa, ricordare

47
00:02:34,900 --> 00:02:36,810
che GDB è un debugger.

48
00:02:36,810 --> 00:02:41,230
E 'uno strumento che consente di eseguire il vostro
programma, ma eseguito passo passo, linea

49
00:02:41,230 --> 00:02:45,680
per riga, in modo che sia possibile esplorare,
in modo che si vedono le cose accadere, così

50
00:02:45,680 --> 00:02:47,310
che è possibile stampare
valori delle variabili.

51
00:02:47,310 --> 00:02:50,580
In breve, ti dà molto di più
potere che printDef fa.

52
00:02:50,580 --> 00:02:52,900
>> Ora è vero, l'interfaccia
è piuttosto arcano.

53
00:02:52,900 --> 00:02:55,180
Interfaccia testuale in bianco e nero
per la maggior parte.

54
00:02:55,180 --> 00:02:57,400
I comandi sono un po 'duri
ricordare a prima.

55
00:02:57,400 --> 00:03:01,230
Ma anche se si potrebbe prendere la metà
un'ora, un'ora, per mettere che in anticipo

56
00:03:01,230 --> 00:03:02,940
investimento di tempo in esso, fidati di me.

57
00:03:02,940 --> 00:03:06,440
Certamente entro la fine del semestre, la salverà
voi un ordine di grandezza più

58
00:03:06,440 --> 00:03:07,600
tempo di quello.

59
00:03:07,600 --> 00:03:09,200
>> Così all'inizio della settimana tuffarsi dentro

60
00:03:09,200 --> 00:03:13,200
E in termini di Breakout, sapere che si
può fare questo in modo finché si dispone di

61
00:03:13,200 --> 00:03:18,230
il codice di distribuzione o il proprio codice
in corso nella vostra directory Pst4.

62
00:03:18,230 --> 00:03:21,680
Sappiate che è possibile eseguire gdb. / Breakout.

63
00:03:21,680 --> 00:03:23,490
>> Questo sta per aprirsi
una finestra come questa.

64
00:03:23,490 --> 00:03:25,530
Lasciate che mi do più
di una finestra di terminale.

65
00:03:25,530 --> 00:03:27,770
E allora che cosa ho intenzione di andare avanti
e fare, non è solo eseguirlo.

66
00:03:27,770 --> 00:03:30,690
Ho intenzione di impostare prima un punto di rottura
richiamo, che consente di mettere in pausa

67
00:03:30,690 --> 00:03:32,500
esecuzione in un luogo particolare.

68
00:03:32,500 --> 00:03:35,750
>> Giusto per mantenere le cose semplici Vado
a rompere in linea uno semplicemente digitando

69
00:03:35,750 --> 00:03:37,000
il numero uno.

70
00:03:37,000 --> 00:03:40,080

71
00:03:40,080 --> 00:03:43,250
Lasciatemi in realtà riaprire questa finestra
perché si sta facendo un

72
00:03:43,250 --> 00:03:45,700
piccolo piccolo lì.

73
00:03:45,700 --> 00:03:53,270
Quindi quello che sto ora intenzione di fare qui è
se apro la mia finestra di terminale.

74
00:03:53,270 --> 00:03:53,910
Dai, ci siamo.

75
00:03:53,910 --> 00:03:59,850
>> Così ora se torno al set, Pst4
ed eseguire gdb. / breakout entrare, si noti

76
00:03:59,850 --> 00:04:02,600
Io vado a rompere uno per impostare
un punto di interruzione alla riga uno.

77
00:04:02,600 --> 00:04:04,840
E ora ho intenzione di andare
avanti e di tipo gestito.

78
00:04:04,840 --> 00:04:07,370
E quando lo faccio, non accorgersi di nulla
sembra accadere.

79
00:04:07,370 --> 00:04:08,120
>> Non c'è nessun pop-up.

80
00:04:08,120 --> 00:04:09,790
Non c'è alcun grafico
interfaccia utente ancora.

81
00:04:09,790 --> 00:04:13,340
Ma questo è comprensibile perché sono
letteralmente in linea uno nel mio programma.

82
00:04:13,340 --> 00:04:17,110
E notare che non ho fretta trasmesso,
specificamente ora a 62, perché tutti

83
00:04:17,110 --> 00:04:20,600
la roba nella parte superiore di questo file è
cose come i commenti e le costanti e

84
00:04:20,600 --> 00:04:22,460
poco interessante roba per ora.

85
00:04:22,460 --> 00:04:25,840
>> Così ora sono all'interno del principale,
a quanto pare, alla riga 62.

86
00:04:25,840 --> 00:04:27,960
E questo è solo la distribuzione
codice, richiamo.

87
00:04:27,960 --> 00:04:33,810
Se apro questo up andando, allo stesso modo,
nella mia cartella drop box in Pst4,

88
00:04:33,810 --> 00:04:35,450
in breakout.c.

89
00:04:35,450 --> 00:04:40,670
E se ho scorrere verso il basso e verso il basso e verso il basso,
e mi permetta di andare avanti e accendo

90
00:04:40,670 --> 00:04:44,990
i miei numeri di riga.

91
00:04:44,990 --> 00:04:50,300
>> Che cosa vedrò, se ho scorrere verso il basso per
linea 62, è esattamente la linea che

92
00:04:50,300 --> 00:04:50,910
ci siamo soffermati su.

93
00:04:50,910 --> 00:04:53,720
Così questa linea qui, 62 anni, è
dove stiamo per essere.

94
00:04:53,720 --> 00:04:57,470
Così ora in GDB, se vado avanti e digito
ora successiva, immettere sta andando a

95
00:04:57,470 --> 00:04:58,450
eseguire quella linea.

96
00:04:58,450 --> 00:05:00,610
E voilà, abbiamo il
cosiddetta finestra g.

97
00:05:00,610 --> 00:05:02,800
Se non hanno familiarità con ciò che un GWindow
è, di non preoccuparsi.

98
00:05:02,800 --> 00:05:05,740
La spec vi introdurrà ad esso, come
così come una serie di video walkthrough

99
00:05:05,740 --> 00:05:06,830
incorporato nella spec.

100
00:05:06,830 --> 00:05:08,610
>> Ma ora facciamo questo un
po 'più interessante.

101
00:05:08,610 --> 00:05:10,960
Permettetemi di spostare questa finestra sopra
per il lato un po '.

102
00:05:10,960 --> 00:05:13,480
Permettetemi di fare un po 'la finestra
più grande in modo da poter vedere di più.

103
00:05:13,480 --> 00:05:16,140
>> E ora lasciami andare avanti
e fare dopo di nuovo.

104
00:05:16,140 --> 00:05:17,550
E ci sono i miei mattoni.

105
00:05:17,550 --> 00:05:20,490
Se digito prossima volta
ora vedo la palla.

106
00:05:20,490 --> 00:05:23,520
E se scrivo di nuovo Avanti
ora vedo la pagaia.

107
00:05:23,520 --> 00:05:26,690
>> E per fortuna questo non è gedit
davvero cooperare mostrando me

108
00:05:26,690 --> 00:05:27,660
tutto quello che voglio.

109
00:05:27,660 --> 00:05:30,820
Ma ora, se devo fare di nuovo,
prossima volta, sono solo

110
00:05:30,820 --> 00:05:32,260
che dichiara alcune variabili.

111
00:05:32,260 --> 00:05:34,750
E posso stampare una qualsiasi
di questi ragazzi fuori.

112
00:05:34,750 --> 00:05:37,170
Mattoni di stampa, stampe vite.

113
00:05:37,170 --> 00:05:39,910
>> E ora se continuo a fare
prossimo, noto che sarò

114
00:05:39,910 --> 00:05:40,870
all'interno di quel ciclo.

115
00:05:40,870 --> 00:05:43,380
Ma il codice sta per eseguire
esattamente come mi aspetto.

116
00:05:43,380 --> 00:05:45,810
Così, quando mi ha colpito di questa funzione, attendere
per Click, è andare a fare

117
00:05:45,810 --> 00:05:46,830
letteralmente questo.

118
00:05:46,830 --> 00:05:48,870
Così mi sembrava di aver perso il controllo
sul programma.

119
00:05:48,870 --> 00:05:50,480
>> GDB non mi sta dando un nuovo prompt.

120
00:05:50,480 --> 00:05:51,500
Ma non preoccupatevi.

121
00:05:51,500 --> 00:05:53,720
Vai al mio gioco, cliccare da qualche parte.

122
00:05:53,720 --> 00:05:56,270
>> E voilà, adesso si procede alla linea 86.

123
00:05:56,270 --> 00:05:59,460
Quindi, di nuovo, è un valore inestimabile, in ultima analisi,
per problemi di debug.

124
00:05:59,460 --> 00:06:03,050
Perché si può letteralmente scorrere
il codice, le cose stampare e molto,

125
00:06:03,050 --> 00:06:03,640
molto, di più.

126
00:06:03,640 --> 00:06:07,210
Ma per ora, questi soli strumenti
dovrebbe arrivare abbastanza lontano.

127
00:06:07,210 --> 00:06:10,050
>> Quindi siamo, ovviamente, dare un'occhiata
in grafica ora, tutto d'un tratto.

128
00:06:10,050 --> 00:06:12,350
E ora il nostro mondo diventa un po '
più interessante.

129
00:06:12,350 --> 00:06:15,680
E si sa, forse, da alcune delle
video online che abbiamo questi

130
00:06:15,680 --> 00:06:18,280
pantaloncini che siete stati a guardare
come parte del set problema.

131
00:06:18,280 --> 00:06:20,460
>> E sono stati fucilati, deliberatamente,
contro uno sfondo bianco.

132
00:06:20,460 --> 00:06:23,380
E alcuni di loro hanno l'insegnamento
Fellows disegno del testo sul

133
00:06:23,380 --> 00:06:25,490
schermo che è sovrapposta
sul lato di loro.

134
00:06:25,490 --> 00:06:27,760
Ma, naturalmente, questo non è tutto ciò che
interessante nel mondo reale.

135
00:06:27,760 --> 00:06:30,520
Questa è solo una sala conferenze con una
grande schermo bianco e sfondo.

136
00:06:30,520 --> 00:06:33,330
E il nostro incredibile team di produzione di specie
di fa sembrare tutto bello

137
00:06:33,330 --> 00:06:36,620
dopo il fatto da ritaglio fuori
o sovrapponendo nulla

138
00:06:36,620 --> 00:06:37,840
che facciamo o non vogliamo.

139
00:06:37,840 --> 00:06:41,560
>> Ora basta per motivare questa settimana e
davvero, dove si può andare, in ultima analisi,

140
00:06:41,560 --> 00:06:42,560
con l'informatica.

141
00:06:42,560 --> 00:06:44,260
Non solo dopo problema impostare quattro.

142
00:06:44,260 --> 00:06:48,240
Ma dopo un altro corso o di un intero
curriculum è incredibile quello che si può

143
00:06:48,240 --> 00:06:51,090
fare in questi giorni, in termini di
grafica in particolare.

144
00:06:51,090 --> 00:06:53,440
>> Alcuni di voi avranno visto questo
scorre intorno online.

145
00:06:53,440 --> 00:06:56,240
Ma ho pensato di mostrarvi, solo per un
paio di minuti, un assaggio di quello

146
00:06:56,240 --> 00:07:01,890
tecnologie informatiche e quali CGI,
computer grafica può fare in questi giorni

147
00:07:01,890 --> 00:07:04,510
con una canzone familiare
e forse film.

148
00:07:04,510 --> 00:07:05,760
>> [MUSICA - Lana Del Ray,
"Giovane e bella]

149
00:07:05,760 --> 00:10:50,270

150
00:10:50,270 --> 00:10:52,470
>> SPEAKER 1: E 'solo un po'
sorprendente, forse, proprio come

151
00:10:52,470 --> 00:10:52,857
onnipresente -

152
00:10:52,857 --> 00:10:57,040
>> [Applausi]

153
00:10:57,040 --> 00:10:59,230
>> SPEAKER 1: Ho appena scaricato.

154
00:10:59,230 --> 00:11:02,920
Ma è davvero incredibile, credo, solo
come il software onnipresente e codice e

155
00:11:02,920 --> 00:11:04,230
strumenti come questo sono davvero.

156
00:11:04,230 --> 00:11:07,685
Ecco, questo è un assaggio della direzione
in cui si può andare.

157
00:11:07,685 --> 00:11:10,620
Oh, non più Appliance oggi.

158
00:11:10,620 --> 00:11:14,640
Beh, questo è tempismo davvero tragica
dato il punto ho solo cercato di fare.

159
00:11:14,640 --> 00:11:18,670
>> Va bene, quindi cerchiamo di lanciare
Fusion nuovo.

160
00:11:18,670 --> 00:11:20,800
Ricorda in seguito.

161
00:11:20,800 --> 00:11:24,190
Va bene, e si dovrebbe aver ricevuto un
e-mail come un a parte se hai fatto prendere un

162
00:11:24,190 --> 00:11:25,460
notare come tale.

163
00:11:25,460 --> 00:11:29,940
Va bene, quindi ricordare che la scorsa settimana
abbiamo iniziato a staccare questo

164
00:11:29,940 --> 00:11:31,380
più tardi conosciuta come stringa.

165
00:11:31,380 --> 00:11:34,700
>> stringa richiama un tipo di dati che è
dichiarata nella libreria CS50.

166
00:11:34,700 --> 00:11:37,740
Ed è parte delle ruote di formazione
che inizierà a decollare.

167
00:11:37,740 --> 00:11:41,280
E 'stato un concetto utile nella fase iniziale.

168
00:11:41,280 --> 00:11:43,750
Ma ora sta andando per ottenere più
interessante e più potente per

169
00:11:43,750 --> 00:11:48,330
effettivamente vedere che sotto il cofano,
una stringa è proprio quello che, abbiamo detto?

170
00:11:48,330 --> 00:11:50,500
>> Sì, quindi è un cosiddetto char *.

171
00:11:50,500 --> 00:11:53,860
E il * ci indica che non c'è
qualche tipo di indirizzo coinvolti.

172
00:11:53,860 --> 00:11:58,690
E così quando si dice char * basta dire
una variabile il cui tipo di dati è un

173
00:11:58,690 --> 00:11:59,290
puntatore ora.

174
00:11:59,290 --> 00:12:01,770
Il fatto che ci sia la star lì
significa solo che si dichiara un

175
00:12:01,770 --> 00:12:03,020
cosiddetti puntatore.

176
00:12:03,020 --> 00:12:06,220
E questo puntatore è andare a quanto pare
memorizzare l'indirizzo, di

177
00:12:06,220 --> 00:12:07,810
Naturalmente, un char.

178
00:12:07,810 --> 00:12:08,960
>> Ora, perché questo ha senso?

179
00:12:08,960 --> 00:12:11,200
Ebbene, che cosa è una stringa
sotto il cofano?

180
00:12:11,200 --> 00:12:15,130
Beh, da qualche tempo che abbiamo detto
che una stringa sotto la cappa è

181
00:12:15,130 --> 00:12:18,460
appena h-e-l-l-o, per esempio.

182
00:12:18,460 --> 00:12:21,585
>> Ma abbiamo parlato di questo come
essendo, in sostanza, un array.

183
00:12:21,585 --> 00:12:25,410
E una serie sarebbe poi guardare un po '
Prodotto, con ciascuno di questi

184
00:12:25,410 --> 00:12:26,460
prendendo un morso.

185
00:12:26,460 --> 00:12:28,710
E poi abbiamo detto che non c'è
qualcosa di speciale qui dietro, il

186
00:12:28,710 --> 00:12:31,270
backslash 0 o null terminator.

187
00:12:31,270 --> 00:12:35,230
>> Quindi tutto questo tempo, questo qui
è stata una stringa.

188
00:12:35,230 --> 00:12:38,320
Ma in realtà, una stringa è
in realtà un indirizzo.

189
00:12:38,320 --> 00:12:43,210
E indirizzi, come vedremo, sono spesso
con il prefisso 0x per convenzione.

190
00:12:43,210 --> 00:12:44,540
Che cosa significa 0x denotano?

191
00:12:44,540 --> 00:12:45,970
Qualcuno lo sa?

192
00:12:45,970 --> 00:12:47,320
>> Quindi significa solo esadecimale.

193
00:12:47,320 --> 00:12:52,360
Così si potrebbe ricordare, in realtà, da Pst
1, credo, uno dei warm-up

194
00:12:52,360 --> 00:12:55,740
domande effettivamente chiesto
notazione esadecimale in aggiunta a

195
00:12:55,740 --> 00:12:57,100
binaria e decimale.

196
00:12:57,100 --> 00:13:00,460
E la motivazione qui è che
con esadecimale hai 16

197
00:13:00,460 --> 00:13:01,770
cifre a vostra disposizione.

198
00:13:01,770 --> 00:13:07,900
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, seguita
da a, b, c, d, e, f.

199
00:13:07,900 --> 00:13:10,430
>> E se si contano tutti coloro up,
si ottiene un totale di 16.

200
00:13:10,430 --> 00:13:13,200
Quindi questo è in contrasto con
decimale, dove abbiamo 10

201
00:13:13,200 --> 00:13:14,690
cifre, da 0 a nove.

202
00:13:14,690 --> 00:13:17,750
E 'in contrasto con binario
dove dobbiamo solo 0 e 1.

203
00:13:17,750 --> 00:13:21,450
>> Ma alla fine della giornata, si può solo
rappresentare gli stessi numeri, ma

204
00:13:21,450 --> 00:13:22,500
un po 'diverso.

205
00:13:22,500 --> 00:13:25,840
E esadecimale è comune, perché come
si scopre - e vedremo questa

206
00:13:25,840 --> 00:13:28,790
successivamente nel corso - anche quando otteniamo
alla programmazione web in un contesto di

207
00:13:28,790 --> 00:13:32,100
HTML e codici di colore,
esadecimale è bello.

208
00:13:32,100 --> 00:13:36,390
Perché ogni cifra, risulta,
rappresenta perfettamente quattro bit.

209
00:13:36,390 --> 00:13:39,280
Quindi è solo tipo di linee su piacevolmente
come vedremo alla fine vediamo.

210
00:13:39,280 --> 00:13:44,720
Quindi questo potrebbe essere Ox123 o qualcosa
come quello, che denota l'indirizzo 123

211
00:13:44,720 --> 00:13:47,050
da qualche parte dentro di mia
memoria del computer.

212
00:13:47,050 --> 00:13:50,600
>> Ma, naturalmente, alcuni problemi sorgono
a causa di questo sottostante

213
00:13:50,600 --> 00:13:51,520
attuazione.

214
00:13:51,520 --> 00:13:55,930
E ricordo che ho preso una pugnalata a
implementazione di una funzione come questa -

215
00:13:55,930 --> 00:14:00,260
confrontare dash 0 dot c scorsa settimana, che
anche se sembrava che fosse

216
00:14:00,260 --> 00:14:04,270
giusto, semplicemente non paragonabile
due stringhe correttamente.

217
00:14:04,270 --> 00:14:07,470
>> Ho buttato via principale, e ho buttato
via i commenti solo a concentrarsi su

218
00:14:07,470 --> 00:14:08,970
il codice che è di interesse qui.

219
00:14:08,970 --> 00:14:10,660
Ed è in rosso perché è bacato.

220
00:14:10,660 --> 00:14:11,670
Per quale motivo?

221
00:14:11,670 --> 00:14:15,890
>> Beh, in cima lì quando ho dichiarato
una stringa, che cosa stava realmente accadendo

222
00:14:15,890 --> 00:14:17,260
sotto il cofano?

223
00:14:17,260 --> 00:14:19,530
Beh, mi permetta di andare oltre la
schermare qui e disegnare quello.

224
00:14:19,530 --> 00:14:23,230
Così ho dichiarato, ancora una volta,
GetString stringa s.

225
00:14:23,230 --> 00:14:26,640
>> Quindi ho intenzione di andare avanti ora e
disegnare s per quello che è veramente.

226
00:14:26,640 --> 00:14:28,590
Sta andando essere un quadrato qui.

227
00:14:28,590 --> 00:14:30,490
E ho intenzione di rivendicare
che questo è 32 bit.

228
00:14:30,490 --> 00:14:32,890
Almeno di solito è,
almeno sul CS50

229
00:14:32,890 --> 00:14:34,520
apparecchio in un sacco di computer.

230
00:14:34,520 --> 00:14:35,980
Io vado a chiamare s.

231
00:14:35,980 --> 00:14:39,070
>> Ma ora ricordare che noi
chiamato GetString.

232
00:14:39,070 --> 00:14:41,430
Ritorna così GetString,
naturalmente, una stringa.

233
00:14:41,430 --> 00:14:45,790
Se l'utente digita in h-e-l-l-o entrano
la stringa ciao viene restituito.

234
00:14:45,790 --> 00:14:51,010
E quella stringa, come abbiamo appena detto, si conclude
da qualche parte nella memoria del computer

235
00:14:51,010 --> 00:14:53,240
con un backslash 0 alla fine.

236
00:14:53,240 --> 00:14:56,650
Io traggo questa come la matrice - o
blocco contiguo di caratteri -

237
00:14:56,650 --> 00:14:58,330
che in realtà è.

238
00:14:58,330 --> 00:15:01,790
>> E ora, che cosa è GetString
in realtà il ritorno?

239
00:15:01,790 --> 00:15:04,340
Che cosa è stato GetString tornando
tutto questo tempo?

240
00:15:04,340 --> 00:15:07,520
Beh, diciamo, in settimane prima,
restituisce una stringa.

241
00:15:07,520 --> 00:15:10,250
Ma, più tecnicamente, cosa fa
GetString ritorno apparentemente?

242
00:15:10,250 --> 00:15:11,610
>> PUBBLICO: Un indirizzo.

243
00:15:11,610 --> 00:15:12,600
>> SPEAKER 1: Un indirizzo.

244
00:15:12,600 --> 00:15:16,630
Specificamente restituisce l'indirizzo del
il primo boccone, qualunque essa sia.

245
00:15:16,630 --> 00:15:18,830
Continuo a usare una, due, tre
perché è conveniente.

246
00:15:18,830 --> 00:15:21,380
>> Esso restituisce l'indirizzo del primo
carattere della stringa.

247
00:15:21,380 --> 00:15:23,510
E abbiamo detto la scorsa settimana che
ciò è sufficiente.

248
00:15:23,510 --> 00:15:26,710
Perché possiamo sempre capire dove
la fine della stringa semplicemente

249
00:15:26,710 --> 00:15:30,150
iterando su di esso, forse, con una per
loop o di un ciclo while o qualcosa di simile

250
00:15:30,150 --> 00:15:34,990
che, solo in cerca di "backslash 0",
il carattere speciale sentinella.

251
00:15:34,990 --> 00:15:37,220
>> E poi sappiamo che la stringa
sembra essere di lunghezza -

252
00:15:37,220 --> 00:15:37,980
in questo caso -

253
00:15:37,980 --> 00:15:38,670
cinque.

254
00:15:38,670 --> 00:15:43,800
Quindi tecnicamente cosa GetString fa
è restituisce Ox123 in questo caso.

255
00:15:43,800 --> 00:15:53,670
E tecnicamente quello che poi accade è
che noi conserviamo, dentro di s, Ox123.

256
00:15:53,670 --> 00:15:56,460
Alla fine della giornata, anche se questo
è di nuova concezione, puntatori, sono

257
00:15:56,460 --> 00:15:57,350
solo le variabili.

258
00:15:57,350 --> 00:16:00,440
Ma capita di memorizzare i bit che
rappresentare collettivamente un indirizzo.

259
00:16:00,440 --> 00:16:03,700
Quindi tecnicamente tutto ciò che ottiene
memorizzato in s è Ox123.

260
00:16:03,700 --> 00:16:04,680
>> Ma noi, come esseri umani -

261
00:16:04,680 --> 00:16:06,020
compreso oggi in poi -

262
00:16:06,020 --> 00:16:09,290
sono davvero non andare a prendersi cura, in genere,
quello che l'indirizzo sia

263
00:16:09,290 --> 00:16:10,520
di qualche pezzo di memoria.

264
00:16:10,520 --> 00:16:14,040
E 'solo a basso livello di dettaglio per
essere intellettualmente interessante.

265
00:16:14,040 --> 00:16:15,440
Quindi ho intenzione di annullare questo.

266
00:16:15,440 --> 00:16:19,810
E invece, di più alto livello, basta dire
che quando si parla di puntatori

267
00:16:19,810 --> 00:16:22,170
Io vado a disegnare solo più
freccia di facile uso che trasmette il

268
00:16:22,170 --> 00:16:26,060
stessa idea e astrae le
particolari di ciò che l'attuale

269
00:16:26,060 --> 00:16:27,700
indirizzo di fondo è.

270
00:16:27,700 --> 00:16:33,290
>> Ora, se torniamo al codice, cosa
è successo la scorsa settimana se abbiamo stringa t

271
00:16:33,290 --> 00:16:34,510
uguale GetString?

272
00:16:34,510 --> 00:16:38,630
Beh, se ho di nuovo, digitare ciao
questa volta ho intenzione di ottenere

273
00:16:38,630 --> 00:16:40,460
un altro pezzo di memoria.

274
00:16:40,460 --> 00:16:44,820
h-e-l-l-o backslash 0.

275
00:16:44,820 --> 00:16:48,320
>> Ma perché ho chiamato GetString
una seconda volta -

276
00:16:48,320 --> 00:16:51,100
e so che questo da guardare il
codice sorgente per GetString - anche

277
00:16:51,100 --> 00:16:54,350
anche se è una coincidenza che il ciao era
digitato due volte, GetString non è

278
00:16:54,350 --> 00:16:55,890
andando a cercare di ottimizzare
e di essere intelligente.

279
00:16:55,890 --> 00:16:58,550
E 'solo andando a prendere un altro pezzo di
memoria dal computer, che è

280
00:16:58,550 --> 00:16:59,640
sta per essere a un altro indirizzo.

281
00:16:59,640 --> 00:17:02,330
Diciamo arbitrariamente solo dire 456.

282
00:17:02,330 --> 00:17:04,079
>> E allora che cosa sta andando per tornare?

283
00:17:04,079 --> 00:17:08,030
E 'intenzione di tornare 456
e conservarla in t.

284
00:17:08,030 --> 00:17:12,010
Così che cosa sta realmente accadendo, sul
sinistra è che ho un altro pezzo

285
00:17:12,010 --> 00:17:14,260
di memoria, tipicamente 32 bit.

286
00:17:14,260 --> 00:17:16,720
E lì sta per andare Ox456.

287
00:17:16,720 --> 00:17:20,140
Ma ancora una volta, io non sono interessato a questi
particolari numeri più.

288
00:17:20,140 --> 00:17:23,069
Sto solo andando a astrattamente
disegnare come una freccia.

289
00:17:23,069 --> 00:17:25,202
>> Quindi questa è ora una nuova spiegazione.

290
00:17:25,202 --> 00:17:28,735
Ma è la stessa idea esatta che è
sta accadendo tutto questo tempo.

291
00:17:28,735 --> 00:17:33,150
E così la ragione allora, che questo primo
versione del confronto era buggy

292
00:17:33,150 --> 00:17:34,480
la scorsa settimana è il motivo?

293
00:17:34,480 --> 00:17:38,000
Quando si esegue, se s è uguale uguale
t Che cosa siete veramente

294
00:17:38,000 --> 00:17:40,550
sotto la cappa confrontando?

295
00:17:40,550 --> 00:17:41,910
>> Di confrontare gli indirizzi.

296
00:17:41,910 --> 00:17:47,950
E proprio intuitivo, chiaramente, Ox123
non è andare a pari Ox456.

297
00:17:47,950 --> 00:17:49,380
Quei numeri, questi bit
sono solo diversi.

298
00:17:49,380 --> 00:17:53,220
>> E così sempre, la settimana scorsa ha detto
si digita cose diverse, anche se il

299
00:17:53,220 --> 00:17:55,360
parole erano pari pari la stessa.

300
00:17:55,360 --> 00:17:58,770
Così possiamo risolvere questo problema.

301
00:17:58,770 --> 00:18:00,120
In parole povere, ciò che è stata la correzione?

302
00:18:00,120 --> 00:18:02,110
>> AUDIENCE: Utilizzare una funzione.

303
00:18:02,110 --> 00:18:02,870
>> SPEAKER 1: Utilizzare una funzione.

304
00:18:02,870 --> 00:18:05,190
O stelle sono sicuramente coinvolti,
ma utilizzare una funzione per fare cosa?

305
00:18:05,190 --> 00:18:05,962
>> PUBBLICO: Per confrontare le stringhe.

306
00:18:05,962 --> 00:18:07,390
>> SPEAKER 1: Per confrontare le stringhe.

307
00:18:07,390 --> 00:18:11,030
Quindi, il problema fondamentale qui è stato
che stavo solo prendendo in considerazione il

308
00:18:11,030 --> 00:18:15,870
qualità di stringhe da essere definito da
confronto dei loro indirizzi.

309
00:18:15,870 --> 00:18:18,540
E, ovviamente, questo è solo stupido ora una volta
si capisce che cosa sta succedendo

310
00:18:18,540 --> 00:18:19,510
sotto la cappa.

311
00:18:19,510 --> 00:18:23,270
Per confrontare veramente stringhe per vedere se
sono uguali nel senso che un umano

312
00:18:23,270 --> 00:18:26,680
vorrei considerare due stringhe siano uguali
abbiamo bisogno di confrontarli carattere per

313
00:18:26,680 --> 00:18:28,070
carattere per carattere.

314
00:18:28,070 --> 00:18:30,020
>> Ora avrei potuto fare
questo molto noioso.

315
00:18:30,020 --> 00:18:32,240
Ma familiarmente, siamo
utilizzando un ciclo for.

316
00:18:32,240 --> 00:18:36,050
E basta confrontare staffa s
I contro t staffa i.

317
00:18:36,050 --> 00:18:39,590
s Staffa i più 1 contro t staffa
I più 1, e così via, all'interno

318
00:18:39,590 --> 00:18:40,580
qualche tipo di ciclo.

319
00:18:40,580 --> 00:18:44,950
E se ho posto le due personaggi che
differiscono, o se mi rendo conto che ooh, s è

320
00:18:44,950 --> 00:18:48,410
più breve o più lungo t t
Posso subito dire falso,

321
00:18:48,410 --> 00:18:49,390
non sono la stessa cosa.

322
00:18:49,390 --> 00:18:55,370
>> Ma se ottengo attraverso s e t e dico
stesso, stessa, stesso, medesimo, stesso, fine

323
00:18:55,370 --> 00:18:58,520
entrambe le stringhe, posso dire
vero, sono uguale.

324
00:18:58,520 --> 00:19:01,040
Beh, per fortuna, anni fa qualcuno
ha scritto che il codice per noi.

325
00:19:01,040 --> 00:19:03,790
>> E lo chiamavano StrComp
per la stringa di confronto.

326
00:19:03,790 --> 00:19:11,900
E anche se è un po 'contatore
intuitivo, StrComp restituisce 0 se quelli

327
00:19:11,900 --> 00:19:14,520
due stringhe, s e t sono uguali.

328
00:19:14,520 --> 00:19:18,090
Ma restituisce valore negativo se s
dovrebbe venire prima di t in ordine alfabetico o

329
00:19:18,090 --> 00:19:20,610
valore positivo se deve venire
dopo t in ordine alfabetico.

330
00:19:20,610 --> 00:19:24,030
>> Quindi, se mai desidera ordinare qualcosa,
si scopre che StrComp è utile.

331
00:19:24,030 --> 00:19:26,660
Perché non si limita a dire
sì o no, uguale o meno.

332
00:19:26,660 --> 00:19:30,440
Ti dà un senso di ordine
come una forza dizionario.

333
00:19:30,440 --> 00:19:33,770
Così StrComp, s virgola t è uguale a
vale 0 significa che il

334
00:19:33,770 --> 00:19:35,200
stringhe sono davvero uguali.

335
00:19:35,200 --> 00:19:38,680
Perché chi ha scritto questa funzione
anni fa, presumibilmente utilizzato un ciclo for

336
00:19:38,680 --> 00:19:42,840
o un ciclo while o qualcosa di simile
integrare sui caratteri nuovamente

337
00:19:42,840 --> 00:19:45,270
e ancora e ancora.

338
00:19:45,270 --> 00:19:47,300
>> Ma due problemi sorsero qui.

339
00:19:47,300 --> 00:19:48,750
Questo era copy0.c.

340
00:19:48,750 --> 00:19:51,680
Ed i due in rosso è
perché è viziata.

341
00:19:51,680 --> 00:19:52,800
E cosa abbiamo fatto qui?

342
00:19:52,800 --> 00:19:54,310
Beh, prima ho chiamato GetString.

343
00:19:54,310 --> 00:19:56,255
E ho memorizzato il valore di ritorno di s.

344
00:19:56,255 --> 00:20:00,260
Ecco, questo è più o meno lo stesso di
Questa parte superiore dell'immagine.

345
00:20:00,260 --> 00:20:01,490
>> Ma che cosa viene dopo?

346
00:20:01,490 --> 00:20:04,980
Beh, mi permetta di andare avanti e di sbarazzarsi
di un intero gruppo di questo.

347
00:20:04,980 --> 00:20:09,650
Ci Rewind nel tempo per cui abbiamo appena
avere s, che ora è in linea con

348
00:20:09,650 --> 00:20:10,940
linea uno lassù.

349
00:20:10,940 --> 00:20:11,400
>> Posso controllare.

350
00:20:11,400 --> 00:20:13,450
Se s è uguale uguale a 0.

351
00:20:13,450 --> 00:20:18,670
Ora, una nota a margine veloce, quando
Potrebbe GetString restituire 0?

352
00:20:18,670 --> 00:20:19,580
Non c'è abbastanza memoria.

353
00:20:19,580 --> 00:20:19,880
Giusto?

354
00:20:19,880 --> 00:20:22,310
>> E 'raro che questo sta per accadere,
certamente su un computer che è

355
00:20:22,310 --> 00:20:24,740
ottenuto centinaia di mega o
anche giga di RAM.

356
00:20:24,740 --> 00:20:27,080
Ma potrebbe, in teoria, il ritorno
0, soprattutto se l'

357
00:20:27,080 --> 00:20:28,080
utente non collabora.

358
00:20:28,080 --> 00:20:31,640
Ci sono modi per far finta che tu non hai
immesso nulla e trucco

359
00:20:31,640 --> 00:20:34,100
GetString in ritorno
0 efficacemente.

360
00:20:34,100 --> 00:20:35,470
>> Così sta andando a controllare per questo.

361
00:20:35,470 --> 00:20:39,430
Perché se qualcuno di voi ha iniziato a
ottenere, già, segmentation fault -

362
00:20:39,430 --> 00:20:42,280
che è probabilmente stata una fonte
di un po 'di frustrazione -

363
00:20:42,280 --> 00:20:46,150
quelli sono quasi sempre il risultato
di memoria correlata errore.

364
00:20:46,150 --> 00:20:50,440
In qualche modo incasinato nei confronti di un
puntatore, anche se non si rese conto

365
00:20:50,440 --> 00:20:51,530
c'era un puntatore.

366
00:20:51,530 --> 00:20:55,260
Così si potrebbe avere indotto segmentazione
difetti fin dalla settimana usando uno

367
00:20:55,260 --> 00:21:02,100
qualcosa di simile a un ciclo for o un po '
loop e un array di andare troppo lontano

368
00:21:02,100 --> 00:21:05,900
oltre i confini di alcuni array che
avete dichiarato, in due settimane in

369
00:21:05,900 --> 00:21:06,690
particolare.

370
00:21:06,690 --> 00:21:09,220
>> Si potrebbe avere fatto anche nel problema
impostare quattro con Breakout.

371
00:21:09,220 --> 00:21:12,910
Anche se probabilmente non avete visto
le stelle del codice di distribuzione per

372
00:21:12,910 --> 00:21:17,410
Breakout, si scopre che quelli GRect
e Goval e altre cose del genere,

373
00:21:17,410 --> 00:21:19,650
quelli sono in realtà puntatori
sotto la cappa.

374
00:21:19,650 --> 00:21:23,430
>> Ma Stanford, come noi, una sorta di pelli
che precisa almeno per le librerie

375
00:21:23,430 --> 00:21:26,540
scopi, tanto come facciamo noi
per la stringa e char *.

376
00:21:26,540 --> 00:21:30,060
Ma GRect e Goval e tutti coloro
cose che voi ragazzi siete o useranno

377
00:21:30,060 --> 00:21:32,630
Questa settimana sono in ultima analisi,
indirizzi di memoria.

378
00:21:32,630 --> 00:21:33,650
È solo che non lo sai.

379
00:21:33,650 --> 00:21:37,240
>> Quindi non è sorprendente allora, forse,
che si potrebbe inciampare qualche

380
00:21:37,240 --> 00:21:38,580
segmentation fault.

381
00:21:38,580 --> 00:21:41,290
Ma ciò che è interessante qui ora,
se dopo che controlliamo per 0 che facciamo

382
00:21:41,290 --> 00:21:43,460
stringa t ottiene s.

383
00:21:43,460 --> 00:21:44,690
Beh, lasciatemi dichiarare t.

384
00:21:44,690 --> 00:21:47,730
Io vado a disegnare come un quadrato,
32 bit, lo chiamano t.

385
00:21:47,730 --> 00:21:49,740
E poi ho intenzione di fare diventa s.

386
00:21:49,740 --> 00:21:51,130
>> Ebbene, che cosa vuol dire?

387
00:21:51,130 --> 00:21:53,280
Beh, è ​​un po 'difficile pensare
su di esso raffigurarsi saggio.

388
00:21:53,280 --> 00:21:55,025
Ma pensiamo a
cosa c'è dentro di x?

389
00:21:55,025 --> 00:21:59,430
Cosa c'è letteralmente dentro questa variabile?

390
00:21:59,430 --> 00:22:01,500
Il valore Ox123.

391
00:22:01,500 --> 00:22:05,815
>> Quindi, quando dico stringa t ottiene s, che proprio
significa letteralmente prendere il numero

392
00:22:05,815 --> 00:22:10,070
in s, che è Ox123 e metterlo Ox123.

393
00:22:10,070 --> 00:22:13,740
Oppure, pittoricamente, se io tipo di abstract
lontano da quel dettaglio ha la

394
00:22:13,740 --> 00:22:16,600
effetto di fare letteralmente
questo.

395
00:22:16,600 --> 00:22:22,110
>> Così ora, ripensare a settimana scorsa, quando
si è proceduto alla capitalista T.

396
00:22:22,110 --> 00:22:23,800
ha fatto T staffa 0.

397
00:22:23,800 --> 00:22:27,150
Beh, T staffa 0, anche se si tratta di un
puntatore, è possibile trattarlo come se

398
00:22:27,150 --> 00:22:29,220
si tratta di un array, con un quadrato
notazione staffa.

399
00:22:29,220 --> 00:22:31,550
>> Allora, dove è T staffa 0?

400
00:22:31,550 --> 00:22:32,990
Beh, è ​​l'h.

401
00:22:32,990 --> 00:22:36,800
E così quando usiamo quella riga di codice,
due superiori, che è in quella c type.h

402
00:22:36,800 --> 00:22:38,460
file di intestazione, ecco dove
viene dichiarata.

403
00:22:38,460 --> 00:22:44,410
Stai capitalizzando questo H. Ma di
Naturalmente, questa è la stessa h esatto che è

404
00:22:44,410 --> 00:22:46,540
all'interno di s, per così dire.

405
00:22:46,540 --> 00:22:51,930
E così ora si è modificato o
capitalizzati sia l'originale e la

406
00:22:51,930 --> 00:22:53,120
cosiddetti copia.

407
00:22:53,120 --> 00:22:56,620
Perché non hai fatto una copia nella
modo che un essere umano vorrebbe che fosse.

408
00:22:56,620 --> 00:22:59,710
>> Così che cosa è stata la correzione qui,
in copy1.c scorsa settimana?

409
00:22:59,710 --> 00:23:03,070

410
00:23:03,070 --> 00:23:05,580
Funzioni, quindi in realtà potrebbe
copiare la stringa.

411
00:23:05,580 --> 00:23:08,700
E fondamentalmente, ciò che abbiamo bisogno di
fare in modo di copiare la stringa?

412
00:23:08,700 --> 00:23:12,070
>> Ebbene, in questa versione verde qui sono
intenzione di farlo piuttosto basso livello.

413
00:23:12,070 --> 00:23:14,260
Ci sono in realtà funzioni
potrebbero aiutare con questo.

414
00:23:14,260 --> 00:23:17,710
Ma il più semplice ed il più
un familiare, almeno, sarà presto

415
00:23:17,710 --> 00:23:19,600
familiare a noi, è la seguente -

416
00:23:19,600 --> 00:23:21,910
così uno sulla prima riga
del codice in verde ora.

417
00:23:21,910 --> 00:23:23,970
>> Ho appena riscritto s come char *.

418
00:23:23,970 --> 00:23:25,250
Non c'è funzionale
differenza lì.

419
00:23:25,250 --> 00:23:28,790
Ho appena buttato via la biblioteca CS50 e
Lo sto chiamando quello che è, un char *.

420
00:23:28,790 --> 00:23:31,640
>> Ora punto, punto, punto, perché ci sono stati
qualche controllo degli errori che non

421
00:23:31,640 --> 00:23:33,200
interessante parlare di nuovo.

422
00:23:33,200 --> 00:23:34,710
Così ora t è dichiarato.

423
00:23:34,710 --> 00:23:35,780
Anch'esso è un char *.

424
00:23:35,780 --> 00:23:38,280
Così ho disegnato un piccolo quadrato sulla
lo schermo come prima.

425
00:23:38,280 --> 00:23:41,870
>> Ma sul lato destro, malloc,
abbiamo detto è la memoria allocare.

426
00:23:41,870 --> 00:23:44,130
Quindi assegnare alcuni pezzo di memoria.

427
00:23:44,130 --> 00:23:48,830
E quanti byte abbiamo effettivamente
desidera allocare, ti sembra?

428
00:23:48,830 --> 00:23:50,340
>> Beh, la lunghezza della stringa di s.

429
00:23:50,340 --> 00:23:52,310
Quindi, se è ciao questo è
sta per essere cinque.

430
00:23:52,310 --> 00:23:53,950
Diremo h-e-l-l-o.

431
00:23:53,950 --> 00:23:55,090
Così cinque byte.

432
00:23:55,090 --> 00:23:57,960
>> Ma poi più 1, perché 1?

433
00:23:57,960 --> 00:23:58,830
Il carattere 0.

434
00:23:58,830 --> 00:24:03,640
Se non lasciamo spazio a questo ragazzo abbiamo
potrebbe creare accidentalmente una situazione

435
00:24:03,640 --> 00:24:05,600
in cui la stringa è h-e-l-l-o.

436
00:24:05,600 --> 00:24:08,470
E poi la prossima volta GetString è
chiamato e digito, per esempio,

437
00:24:08,470 --> 00:24:14,020
David, D-a-v-i-d, il computer sta
a pensare che s è in realtà

438
00:24:14,020 --> 00:24:18,900
h-e-l-l-o-d-a-v-i-d, perché c'è
nessuna rottura tra quelle parole.

439
00:24:18,900 --> 00:24:19,810
>> Quindi abbiamo bisogno che si rompono.

440
00:24:19,810 --> 00:24:20,720
Quindi non vogliamo cinque.

441
00:24:20,720 --> 00:24:22,100
Vogliamo sei byte.

442
00:24:22,100 --> 00:24:23,110
>> E byte mi dicono.

443
00:24:23,110 --> 00:24:25,220
Ma è davvero il momento di dimensione carattere.

444
00:24:25,220 --> 00:24:28,040
Tecnicamente char è quasi
sempre un singolo byte.

445
00:24:28,040 --> 00:24:31,030
>> Ma proprio per rendere il nostro codice portabile,
così dire, in modo che funzioni su

446
00:24:31,030 --> 00:24:33,750
computer diversi, anche se potrebbe
essere diverso sotto l'

447
00:24:33,750 --> 00:24:36,590
cappa, ho intenzione di genericamente
dire dimensione del carattere in modo che

448
00:24:36,590 --> 00:24:37,660
il mio codice funziona sempre.

449
00:24:37,660 --> 00:24:40,610
E io non devo ricompilare solo
perché aggiorno il mio computer o utilizzare

450
00:24:40,610 --> 00:24:42,140
qualche piattaforma diversa.

451
00:24:42,140 --> 00:24:45,300
>> Così ho 6 volte la dimensione della
un char, che risulta essere 1.

452
00:24:45,300 --> 00:24:47,440
In modo che i mezzi malloc potrebbe
dammi sei byte.

453
00:24:47,440 --> 00:24:49,140
Che cosa è che effettivamente facendo?

454
00:24:49,140 --> 00:24:52,810
Bene, lasciate rotolare indietro nel tempo qui
al punto in cui siamo nella storia.

455
00:24:52,810 --> 00:24:57,620
>> Quindi, se torno qui, ho dichiarato
un char * chiamato t.

456
00:24:57,620 --> 00:25:00,280
Ora ho chiamato malloc per sei byte.

457
00:25:00,280 --> 00:25:06,400
E ora vado a disegnare quei sei
bytes proprio come la matrice precedente.

458
00:25:06,400 --> 00:25:10,570
Ma io in realtà non so che cosa è
all'interno di questa matrice.

459
00:25:10,570 --> 00:25:14,640
>> Se si alloca la memoria si scopre che
non ti puoi fidare che c'è qualche

460
00:25:14,640 --> 00:25:15,810
valore noto lì.

461
00:25:15,810 --> 00:25:18,400
Potrebbe essere stato usato da qualcosa
altro, qualche altra funzione, qualche altro

462
00:25:18,400 --> 00:25:19,630
riga di codice che hai scritto.

463
00:25:19,630 --> 00:25:22,870
Quindi dovremo generalmente chiamiamo questi spazzatura
valori e disegnarli, forse, come

464
00:25:22,870 --> 00:25:26,170
punti interrogativi, proprio ad indicare che abbiamo
non so che cosa in realtà è lì.

465
00:25:26,170 --> 00:25:30,390
E questo è un grosso problema fino a quando ci
sono abbastanza intelligente per sovrascrivere quelli

466
00:25:30,390 --> 00:25:34,550
valori di immondizia con numeri o
caratteri che ci stanno a cuore.

467
00:25:34,550 --> 00:25:36,340
>> Quindi in questo caso cosa posso fare?

468
00:25:36,340 --> 00:25:38,670
Bene, la mia riga di codice
prossimo, ho quattro.

469
00:25:38,670 --> 00:25:41,350
INT ottengo 0, n diventa il
lunghezza della stringa di s.

470
00:25:41,350 --> 00:25:42,750
Quindi un familiare ciclo for.

471
00:25:42,750 --> 00:25:45,875
I è minore o uguale an,
che di solito è al di sopra.

472
00:25:45,875 --> 00:25:47,500
>> Ma questa volta è intenzionale.

473
00:25:47,500 --> 00:25:51,890
I + +, e poi io semplicemente faccio
t staffa mi viene s.

474
00:25:51,890 --> 00:25:56,320
Perché la mia immagine si presenta così al
questo momento, memorizzate in t è l'

475
00:25:56,320 --> 00:25:59,530
indirizzo di tale blocco casuale di memoria
valori di cui sono sconosciuti.

476
00:25:59,530 --> 00:26:03,030
Ma appena faccio t staffa
0 che mi pone qui.

477
00:26:03,030 --> 00:26:07,430
>> E che finisce per essere disegnato lì?

478
00:26:07,430 --> 00:26:08,740
Si finisce per mettere h.

479
00:26:08,740 --> 00:26:11,170
Perché questo è ciò che è in s staffa 0.

480
00:26:11,170 --> 00:26:14,300
E poi la stessa cosa per
E e L e L, e o.

481
00:26:14,300 --> 00:26:17,930
>> n, per cui sono andato attraverso
un uguale an?

482
00:26:17,930 --> 00:26:19,200
A causa del carattere 0.

483
00:26:19,200 --> 00:26:23,580
Quindi, tanto per essere chiari, allora, se ho effettivamente
cancellare qualunque questi spazzatura

484
00:26:23,580 --> 00:26:28,870
I valori sono poi effettivamente disegnare in
quello che mi aspetto, questo è s staffa 1, 2,

485
00:26:28,870 --> 00:26:32,440
3, 4, oltre a quello è trailing
nuovo personaggio.

486
00:26:32,440 --> 00:26:36,080
>> E così ora, se abbiamo continuato passato il punto,
puntini, puntini in questa versione corretta

487
00:26:36,080 --> 00:26:41,930
e capitalizzato t staffa 0 vorrei, di
naturalmente essere capitalizzare solo questo

488
00:26:41,930 --> 00:26:47,050
tizio qui, che concettualmente,
era, in definitiva l'obiettivo.

489
00:26:47,050 --> 00:26:48,040
Ecco, questo è tutto il puntatore.

490
00:26:48,040 --> 00:26:51,430
>> E hai usato loro per settimane
ora nel contesto delle stringhe.

491
00:26:51,430 --> 00:26:53,530
Ma sotto il cofano sono
un po 'più complessa.

492
00:26:53,530 --> 00:26:57,520
Ma se si pensa a loro in questo
forma pittorica propongo che siano

493
00:26:57,520 --> 00:27:01,720
Probabilmente non tutto quello spaventoso quanto
potrebbe sembrare a prima vista, a prima vista,

494
00:27:01,720 --> 00:27:04,730
in particolare con tale nuova sintassi.

495
00:27:04,730 --> 00:27:07,290
Tutte le domande su puntatori,
stringhe o salmerini?

496
00:27:07,290 --> 00:27:07,580
Sì?

497
00:27:07,580 --> 00:27:09,252
>> AUDIENCE: Puoi tornare indietro
per il [incomprensibile]?

498
00:27:09,252 --> 00:27:10,502
>> SPEAKER 1: Certo.

499
00:27:10,502 --> 00:27:14,058

500
00:27:14,058 --> 00:27:19,525
>> AUDIENCE: Allora come mai nella vostra ultima
linea, non si dispone di una linea di t *

501
00:27:19,525 --> 00:27:21,513
e un * s nella linea?

502
00:27:21,513 --> 00:27:23,004
Non avete il riferimento al -

503
00:27:23,004 --> 00:27:24,640
>> SPEAKER 1: Ah, davvero una bella domanda.

504
00:27:24,640 --> 00:27:26,800
Perché non ho un * t ed a * s?

505
00:27:26,800 --> 00:27:30,340
Perché brevemente, la scorsa settimana, come nel nostro
funzione swap, ho detto che quando

506
00:27:30,340 --> 00:27:33,350
hai un puntatore il mezzo attraverso il
che ci andate come abbiamo fatto noi

507
00:27:33,350 --> 00:27:36,590
fisicamente sul palco, è stato quello di realtà
utilizzare l'operatore stella.

508
00:27:36,590 --> 00:27:40,570
>> Si scopre che questo quadrato-fascia
notazione è quella che chiameremo sintattica

509
00:27:40,570 --> 00:27:44,190
zucchero, che è solo un modo sexy di
dicendo che è notazione abbreviata per

510
00:27:44,190 --> 00:27:45,950
esattamente quello che stai descrivendo.

511
00:27:45,950 --> 00:27:49,385
Ma è un po 'più intuitivo.

512
00:27:49,385 --> 00:27:53,510
E con il rischio di rendere questo sembra più
complicato di quanto dovrebbe essere,

513
00:27:53,510 --> 00:27:56,990
ciò che sta realmente accadendo qui
è il seguente -

514
00:27:56,990 --> 00:28:01,450
Se dico * t che significa andare a
l'indirizzo memorizzato in t.

515
00:28:01,450 --> 00:28:04,350
>> Quindi, letteralmente, se t è la memorizzazione
l'indirizzo di tale h

516
00:28:04,350 --> 00:28:07,300
inizialmente, * t mezzi andare qui.

517
00:28:07,300 --> 00:28:10,730
Ora, che cosa t staffa 0 significa?

518
00:28:10,730 --> 00:28:11,560
Stessa cosa esatta.

519
00:28:11,560 --> 00:28:13,510
E 'solo un po' più user
amichevole di scrivere.

520
00:28:13,510 --> 00:28:14,430
>> Ma io non ho ancora finito.

521
00:28:14,430 --> 00:28:17,800
Non posso dire * t * s ottiene.

522
00:28:17,800 --> 00:28:19,440
Perché quello che dovrei fare allora?

523
00:28:19,440 --> 00:28:22,950
Sarei mettendo h, h, h, h, h
in tutta l'intera faccenda.

524
00:28:22,950 --> 00:28:22,995
Giusto?

525
00:28:22,995 --> 00:28:26,020
>> Perché * t è aprire l'indirizzo in t.

526
00:28:26,020 --> 00:28:27,580
Ma siamo all'interno di un ciclo.

527
00:28:27,580 --> 00:28:32,150
E che valore sto incrementando,
ovviamente, ad ogni iterazione?

528
00:28:32,150 --> 00:28:32,690
i.

529
00:28:32,690 --> 00:28:34,590
>> Ma c'è la possibilità
qui, giusto?

530
00:28:34,590 --> 00:28:37,870
Anche se questo si sente come si sta facendo
un po 'più sofisticato

531
00:28:37,870 --> 00:28:40,730
rispetto alla notazione quadrata staffa
abbiamo usato per qualche tempo -

532
00:28:40,730 --> 00:28:43,840
fammi Annulla l'cambiamento h lì -

533
00:28:43,840 --> 00:28:48,870
anche se questo è ora ottenere un po 'di
amatore, l'idea di base, se * t

534
00:28:48,870 --> 00:28:53,630
significa qui e * t è solo
aprire l'indirizzo in t.

535
00:28:53,630 --> 00:28:54,990
>> Ma quello che era l'indirizzo in t?

536
00:28:54,990 --> 00:28:56,850
Il numero continua a usare?

537
00:28:56,850 --> 00:29:00,540
Come Ox456, cerchiamo di portare indietro
solo per il gusto della discussione.

538
00:29:00,540 --> 00:29:05,380
Beh, se voglio arrivare alla posta in
stringa t, voglio solo andare a,

539
00:29:05,380 --> 00:29:06,460
essenzialmente, 456.

540
00:29:06,460 --> 00:29:09,230
>> O meglio, 457.

541
00:29:09,230 --> 00:29:10,590
Ho solo bisogno di aggiungere uno.

542
00:29:10,590 --> 00:29:11,790
Ma io posso farlo, giusto?

543
00:29:11,790 --> 00:29:14,680
Perché t, anche se continuo a disegno
ora come una freccia, è solo un

544
00:29:14,680 --> 00:29:16,570
numero, Ox456.

545
00:29:16,570 --> 00:29:21,400
E se aggiungo uno a che, o più
in generale, se aggiungo io per quello che posso

546
00:29:21,400 --> 00:29:24,350
effettivamente ottenere esattamente dove voglio.

547
00:29:24,350 --> 00:29:26,260
Quindi, se ho fatto fare questo -

548
00:29:26,260 --> 00:29:28,970
e questo è ciò che è ora chiamato
l'aritmetica dei puntatori -

549
00:29:28,970 --> 00:29:30,375
Posso rimuovere questa riga.

550
00:29:30,375 --> 00:29:33,550
Il che è, francamente, penso che più chiara e
un po 'più facile da leggere.

551
00:29:33,550 --> 00:29:35,970
Ma questo non è meno corretto.

552
00:29:35,970 --> 00:29:38,570
>> Questa linea di codice ora sta usando
l'aritmetica dei puntatori.

553
00:29:38,570 --> 00:29:40,920
Sta dicendo che andare al
seguente indirizzo -

554
00:29:40,920 --> 00:29:44,670
qualunque sia l'inizio di t è, che
è t più ho, che inizialmente

555
00:29:44,670 --> 00:29:45,730
è 0, che è grande.

556
00:29:45,730 --> 00:29:49,280
Perché questo significa l'inizio di t
più 1, più 2, più 3, e così via.

557
00:29:49,280 --> 00:29:51,030
E lo stesso affare con s.

558
00:29:51,030 --> 00:29:52,750
>> Zucchero in modo sintattico per questo.

559
00:29:52,750 --> 00:29:55,900
Ma la comprensione di ciò che sta realmente accadendo
sotto il cofano, direi,

560
00:29:55,900 --> 00:29:57,410
in realtà è utile in sé e per sé.

561
00:29:57,410 --> 00:30:00,620
Perché significa ora non c'è
molto di più la magia succede

562
00:30:00,620 --> 00:30:01,620
sotto la cappa.

563
00:30:01,620 --> 00:30:03,920
Non ci stanno per essere molti di più
strati che si possa staccare per voi.

564
00:30:03,920 --> 00:30:04,810
Questo è c.

565
00:30:04,810 --> 00:30:06,410
E questa è la programmazione.

566
00:30:06,410 --> 00:30:08,002
Davvero buona domanda.

567
00:30:08,002 --> 00:30:11,570
>> Va bene, quindi questo è stato che buggy
programma mi riferivo prima.

568
00:30:11,570 --> 00:30:12,650
di swap era viziata.

569
00:30:12,650 --> 00:30:14,070
Se sembra funzionare.

570
00:30:14,070 --> 00:30:17,390
Ricordiamo che, proprio come con il latte e
il succo d'arancia - che ho iniziato

571
00:30:17,390 --> 00:30:18,660
bere la manifestazione di oggi.

572
00:30:18,660 --> 00:30:22,220
Quindi, proprio come con il succo d'arancia e
il latte, abbiamo avuto bisogno di usare una

573
00:30:22,220 --> 00:30:26,200
variabile temporanea, tmp, per tenere un
temporaneamente in modo che si potrebbe poi

574
00:30:26,200 --> 00:30:28,820
modificarne il valore e quindi aggiornare b.

575
00:30:28,820 --> 00:30:32,870
>> Ma questa funzione, ci ha detto, o questa
programma in cui questa funzione era

576
00:30:32,870 --> 00:30:35,670
scritto era sbagliato e viziata, perché?

577
00:30:35,670 --> 00:30:38,870

578
00:30:38,870 --> 00:30:39,090
Sì?

579
00:30:39,090 --> 00:30:42,471
>> AUDIENCE: [incomprensibile].

580
00:30:42,471 --> 00:30:44,940
>> SPEAKER 1: Esattamente, quando
si chiama swap -

581
00:30:44,940 --> 00:30:47,820
o più in generale, quando si
chiamare più alcuna funzione -

582
00:30:47,820 --> 00:30:51,210
se gli argomenti a tale funzione sono
primitive, per così dire, int e char

583
00:30:51,210 --> 00:30:56,740
e doppie e galleggianti, cose senza
stelle, si passa in una copia di

584
00:30:56,740 --> 00:30:57,540
l'argomento.

585
00:30:57,540 --> 00:31:01,580
Quindi se x è 1 ey è stato 2, una sta
a 1 e B sta per essere 2.

586
00:31:01,580 --> 00:31:05,250
Ma loro stanno andando a essere diversi pezzi
di bit, diversi pezzi di

587
00:31:05,250 --> 00:31:07,540
memoria che capita di essere l'archiviazione
valori identici.

588
00:31:07,540 --> 00:31:12,160
>> Quindi, questo codice è super perfetto
a scambiare a e b.

589
00:31:12,160 --> 00:31:13,850
Non va bene a scambiare -

590
00:31:13,850 --> 00:31:15,290
nell'esempio della scorsa settimana -

591
00:31:15,290 --> 00:31:16,390
x ed y.

592
00:31:16,390 --> 00:31:18,780
Perché ancora una volta, sono
nel campo di applicazione sbagliata.

593
00:31:18,780 --> 00:31:21,310
>> Ora, come abbiamo fatto a fare per risolvere questo?

594
00:31:21,310 --> 00:31:23,140
Abbiamo dovuto fare la funzione di
guardare un po 'più brutta.

595
00:31:23,140 --> 00:31:25,250
Ma ancora una volta, considerare ciò che
questo significa solo.

596
00:31:25,250 --> 00:31:27,840

597
00:31:27,840 --> 00:31:31,500
>> E in realtà, mi permetta, per coerenza,
cambiare una cosa così è identica a

598
00:31:31,500 --> 00:31:33,200
quello che abbiamo appena fatto.

599
00:31:33,200 --> 00:31:35,690
Come ho già detto la scorsa settimana, non lo fa
importa dove va.

600
00:31:35,690 --> 00:31:38,120
In realtà, di solito si dovrebbe mettere il
stella accanto al nome della variabile.

601
00:31:38,120 --> 00:31:40,750
Ma penso che sarebbe un po 'più facile
considerare il * accanto

602
00:31:40,750 --> 00:31:44,910
tipo di dati nel senso che è un puntatore
ad un int in questo caso.

603
00:31:44,910 --> 00:31:46,270
>> Allora, cosa ci faccio qui?

604
00:31:46,270 --> 00:31:49,590
Io sto dicendo che non mi danno un int
seguito da un altro int,

605
00:31:49,590 --> 00:31:50,810
chiamandoli a e b.

606
00:31:50,810 --> 00:31:52,460
Dammi l'indirizzo di un int.

607
00:31:52,460 --> 00:31:53,960
Dammi l'indirizzo di un altro int.

608
00:31:53,960 --> 00:31:56,330
Chiamare questi indirizzi a e b.

609
00:31:56,330 --> 00:32:00,860
>> E quindi utilizzando la notazione * giù
sotto, andare a ciascuno di questi indirizzi

610
00:32:00,860 --> 00:32:05,290
come necessario per ottenere sia
o impostare il valore.

611
00:32:05,290 --> 00:32:07,400
Ma c'è un'eccezione qui.

612
00:32:07,400 --> 00:32:11,130
Perché non ho un * accanto al tmp?

613
00:32:11,130 --> 00:32:15,070
Perché non lo faccio, per esempio?

614
00:32:15,070 --> 00:32:19,370
Ci si sente come dovrei solo andare tutti
fuori e correggere il tutto.

615
00:32:19,370 --> 00:32:19,752
Sì?

616
00:32:19,752 --> 00:32:21,002
>> AUDIENCE: [incomprensibile].

617
00:32:21,002 --> 00:32:23,280

618
00:32:23,280 --> 00:32:25,480
>> SPEAKER 1: Non ho dichiarato
tmp come stringa.

619
00:32:25,480 --> 00:32:28,830

620
00:32:28,830 --> 00:32:34,950
Quindi questo sarebbe dichiarare, in questo caso,
un tmp di essere l'indirizzo di un int.

621
00:32:34,950 --> 00:32:37,380
Ma non è tutto quello che voglio,
per un paio di motivi.

622
00:32:37,380 --> 00:32:38,616
>> AUDIENCE: Non si vuole per scambiarle.

623
00:32:38,616 --> 00:32:41,800
>> SPEAKER 1: Esatto, io non voglio scambiare
nulla con tmp. tmp è solo

624
00:32:41,800 --> 00:32:42,790
settimana-una roba.

625
00:32:42,790 --> 00:32:45,150
Tutto quello che voglio è una variabile
per memorizzare qualche numero.

626
00:32:45,150 --> 00:32:47,330
Non ho nemmeno importa di indirizzi
in questo momento.

627
00:32:47,330 --> 00:32:50,530
>> Ho solo bisogno di 32 bit o
modo per memorizzare un int.

628
00:32:50,530 --> 00:32:56,690
E voglio mettere in quei 32 bit
tutto ciò che non in una, per così dire, ma

629
00:32:56,690 --> 00:33:01,260
ciò è ad una, solo per essere più precisi.

630
00:33:01,260 --> 00:33:06,420
Perché se a è un indirizzo, * un mezzo
andare lì e ottenere il valore 1.

631
00:33:06,420 --> 00:33:10,560
Ad esempio, nell'esempio della scorsa settimana
o in caso di B, ottenere il valore di 2.

632
00:33:10,560 --> 00:33:11,750
>> Così che cosa sta realmente accadendo?

633
00:33:11,750 --> 00:33:15,070
Permettetemi di fare un disegno che qui si
solo prendere in giro a parte parte di oggi.

634
00:33:15,070 --> 00:33:18,580
Ma questo continuerà ad apparire
per un bel po 'di tempo.

635
00:33:18,580 --> 00:33:22,430
>> Questo, io sostengo, è ciò che il computer di
memoria appare come quando si esegue un

636
00:33:22,430 --> 00:33:24,060
programma, qualsiasi programma.

637
00:33:24,060 --> 00:33:28,340
Quando si esegue un programma in cima
della RAM del computer - in modo da pensare di

638
00:33:28,340 --> 00:33:33,530
questo rettangolo, veramente, come il tuo
RAM o della memoria del computer, tutti i 101

639
00:33:33,530 --> 00:33:36,920
miliardi di byte di esso, tutto due miliardi
byte, tutti i due gigabyte di esso,

640
00:33:36,920 --> 00:33:39,910
qualunque sia la quantità che hai è,
Impara a disegnare come un rettangolo.

641
00:33:39,910 --> 00:33:43,260
E io sostengo che quando si esegue un programma
come Microsoft Word o Chrome

642
00:33:43,260 --> 00:33:49,220
o qualcosa di simile, i bit che
Microsoft o che Google ha scritto -

643
00:33:49,220 --> 00:33:50,910
nei casi di quei programmi -

644
00:33:50,910 --> 00:33:54,490
vengono caricati nella memoria del computer
dove possono essere eseguiti più

645
00:33:54,490 --> 00:33:57,520
rapidamente ed immessa nella CPU, che
è il cervello del computer.

646
00:33:57,520 --> 00:34:00,940
>> E in TAM ma sono archiviati per lo
superiore del vostro programma, per così dire.

647
00:34:00,940 --> 00:34:03,300
In altre parole, se questo è un pezzo di
memoria, quando si fa doppio clic su

648
00:34:03,300 --> 00:34:05,740
Microsoft Word, i bit vengono
fuori il disco rigido.

649
00:34:05,740 --> 00:34:06,680
Essi vengono caricati nella RAM.

650
00:34:06,680 --> 00:34:10,330
E faremo tirarle fino in cima
di questo rettangolo concettualmente.

651
00:34:10,330 --> 00:34:13,010
>> Beh, il resto della vostra memoria è
usato per cose diverse.

652
00:34:13,010 --> 00:34:16,460
Nella parte superiore si vede inizializzare
dati e Uninitialize dati.

653
00:34:16,460 --> 00:34:20,500
Questo ha a che fare, per la maggior parte, con
costanti o variabili globali

654
00:34:20,500 --> 00:34:21,340
che hanno valori.

655
00:34:21,340 --> 00:34:22,980
Ma più su quelle un altro tempo.

656
00:34:22,980 --> 00:34:25,150
>> Allora avete il mucchio, che
torneremo a.

657
00:34:25,150 --> 00:34:28,420
Ma sul fondo è la parte che è
particolarmente germano momento.

658
00:34:28,420 --> 00:34:30,210
È il cosiddetto stack.

659
00:34:30,210 --> 00:34:33,850
Quindi, proprio come nella maggior parte qualsiasi sala D qui su
campus, avete quei vassoi che

660
00:34:33,850 --> 00:34:37,210
basta impilare uno sopra l'altro su cui
si può mettere il cibo e quant'altro.

661
00:34:37,210 --> 00:34:40,139
Lo stack in un sistema informatico
è molto simile.

662
00:34:40,139 --> 00:34:42,679
Tranne mentre il vassoio, come si usa in
la sala da pranzo, naturalmente, si intende

663
00:34:42,679 --> 00:34:45,710
per portare le cose i vassoi
o le cornici -

664
00:34:45,710 --> 00:34:49,469
come li chiameremo - in un computer di
memoria è utilizzato per contenere

665
00:34:49,469 --> 00:34:51,610
variabili e valori.

666
00:34:51,610 --> 00:34:53,929
>> Quindi, cosa succede veramente
sotto il cofano?

667
00:34:53,929 --> 00:34:55,820
Beh, mi permetta di capovolgere
alla schermata qui.

668
00:34:55,820 --> 00:34:58,370
E concentriamoci solo sul
parte inferiore per un momento.

669
00:34:58,370 --> 00:35:02,770
Se questa è la porzione di fondo della mia
memoria del computer si scopre quando ho

670
00:35:02,770 --> 00:35:05,350
chiamare la funzione principale -
che avviene, francamente,

671
00:35:05,350 --> 00:35:06,950
automaticamente per me -

672
00:35:06,950 --> 00:35:10,510
Ho un pezzo di memoria al
profondo del mio RAM per così dire.

673
00:35:10,510 --> 00:35:13,390
Ed è qui che principale di
variabili locali vanno.

674
00:35:13,390 --> 00:35:16,770
E 'dove argc e argv forse
andare, e le eventuali variabili di I

675
00:35:16,770 --> 00:35:18,170
dichiarare all'interno del principale.

676
00:35:18,170 --> 00:35:20,260
Finiscono in fondo
di RAM del mio computer.

677
00:35:20,260 --> 00:35:25,040
>> Ora supponiamo che i principali chiama una funzione
come swap, come ha fatto la settimana scorsa?

678
00:35:25,040 --> 00:35:30,620
Beh, abbiamo essenzialmente messo un nuovo vassoio, un
nuovo telaio, sul mio pezzo di memoria.

679
00:35:30,620 --> 00:35:34,160
E ho intenzione di descrivere questo come
appartenente alla funzione swap.

680
00:35:34,160 --> 00:35:35,770
>> Ora cosa c'è dentro di swap?

681
00:35:35,770 --> 00:35:39,240
Ebbene, sulla base del programma della scorsa settimana e
quello che abbiamo appena visto un estratto,

682
00:35:39,240 --> 00:35:46,590
all'interno della struttura di swap, o scambio di
vassoio, sono ciò che le variabili?

683
00:35:46,590 --> 00:35:47,970
Beh, a e b.

684
00:35:47,970 --> 00:35:51,850
Perché quelli erano i suoi argomenti locali,
più un terzo, tmp.

685
00:35:51,850 --> 00:35:54,470
Quindi, in realtà, ho potuto disegnare questo
un po 'più pulito.

686
00:35:54,470 --> 00:35:56,680
Lasciami andare avanti e annullare l'etichetta.

687
00:35:56,680 --> 00:35:58,520
E mi permetta di affermare che si sa che cosa?

688
00:35:58,520 --> 00:36:00,560
>> una è probabilmente andando a finire qui.

689
00:36:00,560 --> 00:36:02,160
B sta per finire qui.

690
00:36:02,160 --> 00:36:03,810
E tmp sta per finire qui.

691
00:36:03,810 --> 00:36:05,160
Ora, il giudice potrebbe
essere un po 'diverso.

692
00:36:05,160 --> 00:36:06,840
Ma concettualmente questa è l'idea.

693
00:36:06,840 --> 00:36:11,490
>> E proprio collettivamente, questo è ciò
chiameremo cornice di swap, o

694
00:36:11,490 --> 00:36:12,136
vassoio refettorio.

695
00:36:12,136 --> 00:36:13,150
E lo stesso affare con il principale.

696
00:36:13,150 --> 00:36:14,040
Ma non voglio che ridisegnare.

697
00:36:14,040 --> 00:36:17,810
Ma è qui che argc e argv e qualsiasi
delle sue variabili locali come x e y

698
00:36:17,810 --> 00:36:18,940
potrebbe essere pure.

699
00:36:18,940 --> 00:36:22,170
>> Così ora prendere in considerazione ciò che sta realmente accadendo
quando si chiama swap.

700
00:36:22,170 --> 00:36:26,370
Quando si chiama swap, codice in esecuzione come
questo, si sta passando, nel

701
00:36:26,370 --> 00:36:30,670
versione buggy, a e b
come copie di x e y.

702
00:36:30,670 --> 00:36:34,300
Quindi, se io ora traggo questa
sullo schermo -

703
00:36:34,300 --> 00:36:36,700
avuto modo di arrivare meglio a questo -

704
00:36:36,700 --> 00:36:40,850
così la storia che stavo dicendo a me stesso
fu in questa versione buggy, quando abbiamo

705
00:36:40,850 --> 00:36:46,130
Inversione di chiamata passando letteralmente a e b
come numeri interi, cosa sta realmente accadendo?

706
00:36:46,130 --> 00:36:48,250
>> Beh, quello che sta succedendo davvero è questo.

707
00:36:48,250 --> 00:36:52,850
Lasciami andare avanti e annullare solo
per chiarire un pò di spazio qui.

708
00:36:52,850 --> 00:36:54,720
Quindi questa è la memoria del mio computer.

709
00:36:54,720 --> 00:36:57,510
>> Quindi, se ho, per esempio -

710
00:36:57,510 --> 00:36:58,910
in realtà cerchiamo di fare in questo modo -

711
00:36:58,910 --> 00:37:02,690
se io sostengo che questo è x, la memorizzazione
il valore 1, proprio come la settimana scorsa.

712
00:37:02,690 --> 00:37:05,930
E questo è y, memorizzare il valore
2 proprio come la settimana scorsa.

713
00:37:05,930 --> 00:37:11,370
E questa è la principale, quando chiamo swap,
dando così accesso a un me e

714
00:37:11,370 --> 00:37:15,150
b, tmp, ho intenzione di affermare che
questa è una e questo è 1.

715
00:37:15,150 --> 00:37:16,080
>> Questo è b.

716
00:37:16,080 --> 00:37:17,010
Questo è 2.

717
00:37:17,010 --> 00:37:18,370
Questo si chiama tmp.

718
00:37:18,370 --> 00:37:23,360
>> Ed inizialmente, ha un certo valore spazzatura
fino a quando ho effettivamente memorizzare in una,

719
00:37:23,360 --> 00:37:24,450
che è 1.

720
00:37:24,450 --> 00:37:28,320
Poi vado avanti e cambiare
una di essere ciò?

721
00:37:28,320 --> 00:37:29,720
Valore di B.

722
00:37:29,720 --> 00:37:31,980
>> E così ora ho due qui.

723
00:37:31,980 --> 00:37:34,050
E poi ci siamo detti b ottiene tmp.

724
00:37:34,050 --> 00:37:37,670
Ancora una volta, proprio come un controllo di sanità mentale, il terzo
riga di codice qui è semplicemente questo

725
00:37:37,670 --> 00:37:39,440
uno, B ottiene tmp.

726
00:37:39,440 --> 00:37:41,730
>> E così, infine, che cosa devo fare?

727
00:37:41,730 --> 00:37:46,800
Io vado avanti e cambiare B per essere qualunque cosa
il valore di tmp è, che è 1.

728
00:37:46,800 --> 00:37:48,390
Non tocco nuovo tmp.

729
00:37:48,390 --> 00:37:54,100
>> Ma ora, il problema è più presto di swap
ritorna, perché non è che distribuiscono

730
00:37:54,100 --> 00:37:57,540
eseguire un certo valore, non c'è ritorno
dichiarazione esplicitamente in essa.

731
00:37:57,540 --> 00:37:59,080
Che cosa sta realmente accadendo?

732
00:37:59,080 --> 00:38:03,480
Beh, essenzialmente tutta questa memoria -

733
00:38:03,480 --> 00:38:07,410
OK, a quanto pare la gomma piace
un solo dito alla volta -

734
00:38:07,410 --> 00:38:08,180
semplicemente scompare.

735
00:38:08,180 --> 00:38:10,070
>> Ora, in realtà, non è
va da nessuna parte.

736
00:38:10,070 --> 00:38:11,810
Ma si può pensare di esso
ora come punti interrogativi.

737
00:38:11,810 --> 00:38:14,040
Perché non è più
realmente in uso.

738
00:38:14,040 --> 00:38:17,470
E non si fa nulla con quei valori.

739
00:38:17,470 --> 00:38:21,920
>> Quindi, nel caso della versione verde
questo codice, quello che invece è essere

740
00:38:21,920 --> 00:38:24,640
passato in swap?

741
00:38:24,640 --> 00:38:25,770
Così indirizzi.

742
00:38:25,770 --> 00:38:28,520
Quindi l'indirizzo di x e
l'indirizzo di y.

743
00:38:28,520 --> 00:38:35,790
Quindi, se noi ri-raccontare questa storia un ultimo
tempo, e io in realtà traggo ancora swap,

744
00:38:35,790 --> 00:38:44,620
ma con puntatori, essendo questa una, questa
essendo b, e questo essere tmp, ciò che è

745
00:38:44,620 --> 00:38:49,080
effettivamente memorizzati in una in questo verde
versione del mio codice dove sto passando

746
00:38:49,080 --> 00:38:52,110
in indirizzi?

747
00:38:52,110 --> 00:38:53,780
>> Sta andando essere un puntatore a x.

748
00:38:53,780 --> 00:38:54,890
Così ho potuto disegnare una freccia.

749
00:38:54,890 --> 00:38:57,310
Ma usiamo la stessa arbitraria
esempio di prima.

750
00:38:57,310 --> 00:39:01,220
Diciamo che questo è
qualcosa come Ox123.

751
00:39:01,220 --> 00:39:04,970
E questo sta per essere Ox127 perché
si tratta di quattro byte di distanza perché è un

752
00:39:04,970 --> 00:39:07,370
int, così Ox127.

753
00:39:07,370 --> 00:39:09,080
>> E di nuovo, mi sto prendendo qualche libertà
con i numeri.

754
00:39:09,080 --> 00:39:11,430
Sono molto più piccolo di quello che sarebbe
effettivamente e in un ordine diverso.

755
00:39:11,430 --> 00:39:14,350
Ma è così che l'immagine
ora è diverso.

756
00:39:14,350 --> 00:39:19,060
>> Ma quando uso questo codice verde
e io int tmp ricevo * a.

757
00:39:19,060 --> 00:39:25,010
* Un mezzo per fare la seguente, prendere la
affrontare che è in una e andare ad esso,

758
00:39:25,010 --> 00:39:26,190
che è 1.

759
00:39:26,190 --> 00:39:28,480
Ed è quello che ho poi messo in tmp.

760
00:39:28,480 --> 00:39:32,480
Nel frattempo, nella riga successiva di codice
qui, * una ottiene b, che cosa significa?

761
00:39:32,480 --> 00:39:36,910
>> Beh, * a, in modo da andare qui ottiene * b,
che significa andare lì.

762
00:39:36,910 --> 00:39:39,310
E questo significa mettere il valore a lì.

763
00:39:39,310 --> 00:39:43,670
Infine, l'ultima riga di codice
semplicemente detto * b ottiene tmp.

764
00:39:43,670 --> 00:39:48,900
>> Quindi b dice di andare lì e sovrascriverlo con
tmp che, in questo caso, sta

765
00:39:48,900 --> 00:39:51,520
essere, nuovamente, 1.

766
00:39:51,520 --> 00:39:54,920
Ed è per questo che la versione verde di
le nostre opere di codice, mentre il rosso

767
00:39:54,920 --> 00:39:56,010
versione non ha mai fatto.

768
00:39:56,010 --> 00:39:59,020
Tutto solo si riduce a come il
la memoria è gestita e dove è

769
00:39:59,020 --> 00:40:02,580
effettivamente immesso nel vostro
RAM del computer.

770
00:40:02,580 --> 00:40:07,270
E per ora, questa è una delle cose
che lo stack viene utilizzato per.

771
00:40:07,270 --> 00:40:09,225
>> Domande sul layout?

772
00:40:09,225 --> 00:40:10,380
Su puntatori?

773
00:40:10,380 --> 00:40:11,630
O su swap?

774
00:40:11,630 --> 00:40:13,740

775
00:40:13,740 --> 00:40:17,043
>> Va bene, allora malloc, richiamo,
ha fatto qualcosa di simile.

776
00:40:17,043 --> 00:40:18,260
Questo è stato un super semplice esempio.

777
00:40:18,260 --> 00:40:20,550
E questo era quello che Binky
ci ha presentato, anche se piuttosto

778
00:40:20,550 --> 00:40:21,870
rapidamente, al termine della classe.

779
00:40:21,870 --> 00:40:24,480
Dannazione, non ci siamo di nuovo.

780
00:40:24,480 --> 00:40:28,780
>> Quindi ricorda che questa era l'esempio che
Binky ci ha presentato, sia pure

781
00:40:28,780 --> 00:40:30,360
alquanto rapidamente a fine classe.

782
00:40:30,360 --> 00:40:33,640
E qui abbiamo utilizzato malloc davvero
per la seconda volta.

783
00:40:33,640 --> 00:40:37,330
Perché la prima volta che abbiamo usato per
creare abbastanza RAM, allocare abbastanza memoria RAM

784
00:40:37,330 --> 00:40:38,340
per memorizzare una stringa.

785
00:40:38,340 --> 00:40:40,250
>> Questa volta Binky teneva semplice.

786
00:40:40,250 --> 00:40:42,465
Quindi è per memorizzare solo
un int, a quanto pare.

787
00:40:42,465 --> 00:40:43,510
E questo è tutto bene.

788
00:40:43,510 --> 00:40:46,560
E 'un po' strano, francamente, a
utilizzare malloc per allocare un int.

789
00:40:46,560 --> 00:40:50,650
Ma il punto di claymation di Nick era
in realtà solo raccontare la storia di ciò che

790
00:40:50,650 --> 00:40:53,830
accade o non accade quando
vi maltrattano memoria.

791
00:40:53,830 --> 00:40:56,520
>> Quindi in questo caso, questo programma
ha fatto un paio di cose.

792
00:40:56,520 --> 00:41:01,580
Nel primo caso qui, dichiara
un puntatore chiamato x ad un int.

793
00:41:01,580 --> 00:41:04,480
E poi dichiara un puntatore
chiamato y ad un int.

794
00:41:04,480 --> 00:41:06,150
Quindi memorizza in x, che cosa?

795
00:41:06,150 --> 00:41:07,110
Qualcun altro adesso.

796
00:41:07,110 --> 00:41:09,685
Ciò che viene memorizzato in x secondo
la terza linea di questo programma?

797
00:41:09,685 --> 00:41:12,380
>> AUDIENCE: [incomprensibile].

798
00:41:12,380 --> 00:41:14,130
>> SPEAKER 1: Beh, non proprio
byte, per dire.

799
00:41:14,130 --> 00:41:16,760
Essere più preciso ora.

800
00:41:16,760 --> 00:41:18,325
Ciò che viene memorizzato in x?

801
00:41:18,325 --> 00:41:21,000

802
00:41:21,000 --> 00:41:22,060
Un indirizzo, penso che l'ho sentito.

803
00:41:22,060 --> 00:41:23,570
>> Così che cosa malloc restituisce?

804
00:41:23,570 --> 00:41:26,030
malloc alloca comportamentale
un pezzo di memoria.

805
00:41:26,030 --> 00:41:27,850
Ma come fa a dare l'accesso ad esso?

806
00:41:27,850 --> 00:41:29,460
Esso restituisce cosa?

807
00:41:29,460 --> 00:41:32,000
L'indirizzo del primo byte
nel pezzo di memoria.

808
00:41:32,000 --> 00:41:33,020
>> Ora, questo è super semplice.

809
00:41:33,020 --> 00:41:35,380
E 'solo un byte, il che significa che la
rivolgiamo stiamo tornando è il

810
00:41:35,380 --> 00:41:37,300
indirizzo di tutta la faccenda.

811
00:41:37,300 --> 00:41:42,070
Così memorizzato in x, allora, è l'indirizzo
di quel pezzo di memoria.

812
00:41:42,070 --> 00:41:43,400
Nel frattempo, che cosa succede dopo?

813
00:41:43,400 --> 00:41:45,890
Quindi, in realtà, andiamo avanti e
disegnare questo fuori in fretta.

814
00:41:45,890 --> 00:41:52,490
>> Quindi, se andiamo oltre alla schermata qui e
giochiamo questo fuori int * x e int * y

815
00:41:52,490 --> 00:41:53,740
sta per fare che cosa per me?

816
00:41:53,740 --> 00:41:58,280
Io sostengo che è solo andare a fare
qualcosa di simile a questo e lo chiamano x, e

817
00:41:58,280 --> 00:42:00,010
questo e chiamano a.

818
00:42:00,010 --> 00:42:03,110
Nel frattempo, la terza riga di codice è
andando ad allocare le dimensioni di un int,

819
00:42:03,110 --> 00:42:06,160
che risulta essere - scusate se ho detto
uno prima volevo dire uno int -

820
00:42:06,160 --> 00:42:08,280
quattro byte su un computer tipico.

821
00:42:08,280 --> 00:42:09,720
Almeno con l'apparecchio CS50.

822
00:42:09,720 --> 00:42:11,490
>> Quindi questo sta per allocare
si, chi lo sa?

823
00:42:11,490 --> 00:42:12,800
Da qualche parte qui.

824
00:42:12,800 --> 00:42:15,780
E questo è memorizzato in qualche
Indirizzo Bue, chi lo sa?

825
00:42:15,780 --> 00:42:18,330
Ma quello che sta per ottenere tornato
è tale indirizzo.

826
00:42:18,330 --> 00:42:22,270
Ma noi disegneremo questo pittoricamente
come solo una freccia simile.

827
00:42:22,270 --> 00:42:25,430
>> Ora, nella riga successiva * x diventa 42.

828
00:42:25,430 --> 00:42:29,400
Che cosa significa * x significa in parole povere?

829
00:42:29,400 --> 00:42:30,040
Basta andare lì.

830
00:42:30,040 --> 00:42:30,960
Vai a questo indirizzo.

831
00:42:30,960 --> 00:42:35,900
O in altre parole, seguire la
freccia e mettere 42 lì.

832
00:42:35,900 --> 00:42:38,140
Ma poi è successo qualcosa di brutto
a Binky, giusto?

833
00:42:38,140 --> 00:42:43,950
>> Ricordiamo che la linea di cinque qui, * y ottiene
13, in effetti un numero sfortunato,

834
00:42:43,950 --> 00:42:44,760
fatto quello che per noi?

835
00:42:44,760 --> 00:42:47,320
Bene, * mezzi y ci vanno.

836
00:42:47,320 --> 00:42:50,460
Ebbene, questo non è stato dato
ancora un valore, giusto?

837
00:42:50,460 --> 00:42:54,090
Il codice non deve essere y
inizializzato a nulla.

838
00:42:54,090 --> 00:42:56,120
Avevamo x essere inizializzato
ad un indirizzo.

839
00:42:56,120 --> 00:42:57,640
Ma y è stato dichiarato fino in alto.

840
00:42:57,640 --> 00:43:00,250
Ma poi un punto e virgola, senza valore
è stato effettivamente messo in esso.

841
00:43:00,250 --> 00:43:02,330
Quindi è giusto chiamare questa
un valore spazzatura.

842
00:43:02,330 --> 00:43:03,430
Chi sa che cosa è?

843
00:43:03,430 --> 00:43:07,160
Sono i resti di bit che sono stati utilizzati
da qualche riga di codice precedente in

844
00:43:07,160 --> 00:43:08,300
il mio programma.

845
00:43:08,300 --> 00:43:13,250
>> Quindi, se io dico andare lì, questo è come,
Non ho idea di dove questa freccia è

846
00:43:13,250 --> 00:43:14,490
andando a finire.

847
00:43:14,490 --> 00:43:17,720
E che quando in genere si
ottenere un errore di segmentazione.

848
00:43:17,720 --> 00:43:22,430
Se accidentalmente dereferenziare, per così
parlare, o andare a un indirizzo che non è

849
00:43:22,430 --> 00:43:25,400
in realtà un indirizzo legittimo,
succedono cose brutte.

850
00:43:25,400 --> 00:43:27,550
>> E questo è esattamente quello che è successo
pensare Binky.

851
00:43:27,550 --> 00:43:31,060
Quindi, ricordare che la storia che Nick era
raccontando qui era la stessa idea che cosa

852
00:43:31,060 --> 00:43:34,050
Ho disegnato con l'illusione di
gesso sulla lavagna c'è.

853
00:43:34,050 --> 00:43:35,960
X e Y sono dichiarate.

854
00:43:35,960 --> 00:43:39,690
>> Poi abbiamo assegnato la dimensione di
un int e memorizzato in x.

855
00:43:39,690 --> 00:43:42,130
Poi la linea successiva abbiamo fatto * x.

856
00:43:42,130 --> 00:43:46,070
Questa è stata la bacchetta magica di Nick
di dereferencing.

857
00:43:46,070 --> 00:43:49,780
Che ha messo 42 nella memoria
sottolineato da x.

858
00:43:49,780 --> 00:43:51,600
>> Ma questo è dove le cose
è andato terribilmente storto.

859
00:43:51,600 --> 00:43:51,820
Giusto?

860
00:43:51,820 --> 00:43:53,550
Abbiamo cercato di risolvere il riferimento a.

861
00:43:53,550 --> 00:43:55,620
Ma y ha un valore falso, giusto?

862
00:43:55,620 --> 00:43:57,720
>> Quella freccia in basso a sinistra
angolo, non è

863
00:43:57,720 --> 00:43:58,950
in realtà punta a nulla.

864
00:43:58,950 --> 00:44:01,520
È un po 'a fare quello che
fatto qui sulla scheda.

865
00:44:01,520 --> 00:44:05,900
Quindi le cose brutte accadono, segmentazione
guasto oppure Binky guasto, in questo caso.

866
00:44:05,900 --> 00:44:10,800
>> Ma se poi fissiamo che facendo x
ottiene y come cambia la storia?

867
00:44:10,800 --> 00:44:15,760
Beh, se lo faccio x diventa y, che è
effettivamente lo stesso che dire

868
00:44:15,760 --> 00:44:19,235
qualunque cosa sia, Ox-qualcosa
sta per essere lo stesso qui,

869
00:44:19,235 --> 00:44:20,080
Ox-qualcosa.

870
00:44:20,080 --> 00:44:22,970
O pittoricamente faremo disegnare una freccia.

871
00:44:22,970 --> 00:44:25,530
>> Così qui sul bordo con Binky,
con la prossima linea di

872
00:44:25,530 --> 00:44:28,350
codice, * y significa andare lì.

873
00:44:28,350 --> 00:44:29,400
Dove si trova lì?

874
00:44:29,400 --> 00:44:30,820
Significa qui.

875
00:44:30,820 --> 00:44:36,050
>> E quando ci aggiorniamo che per essere 13
si tratta solo andando e

876
00:44:36,050 --> 00:44:39,470
scrivere 13 qui ora.

877
00:44:39,470 --> 00:44:44,130
Quindi, forse non del tutto
semplice a prima vista.

878
00:44:44,130 --> 00:44:47,740
Ma per ricapitolare e di utilizzare lo stesso gergo
Binky che stava usando qui, quindi

879
00:44:47,740 --> 00:44:50,485
le prime due assegnano i puntatori,
x e y, ma non le pointees.

880
00:44:50,485 --> 00:44:54,750
E pointees non è un
generalmente termine usato.

881
00:44:54,750 --> 00:44:56,120
Ma puntatore assolutamente è.

882
00:44:56,120 --> 00:44:59,200
Ma è quello che è stato sottolineato
a nella nomenclatura di Binky.

883
00:44:59,200 --> 00:45:01,660
>> Questo successiva linea, naturalmente,
alloca un pointee int.

884
00:45:01,660 --> 00:45:04,840
Così un pezzo di memoria - come ho disegnato sopra il
il lato destro c'è - e insieme

885
00:45:04,840 --> 00:45:06,470
x uguale per puntare a esso.

886
00:45:06,470 --> 00:45:11,350
Questo dereferenzia x per memorizzare 42 in
la memoria che sta indicando.

887
00:45:11,350 --> 00:45:13,380
E poi questo, naturalmente,
era una cosa negativa.

888
00:45:13,380 --> 00:45:15,600
Poiché y non puntava
a ancora nulla.

889
00:45:15,600 --> 00:45:16,530
Questo lo ripara.

890
00:45:16,530 --> 00:45:18,240
Quindi, questo è ancora programma bacato.

891
00:45:18,240 --> 00:45:21,580
Proprio perché stiamo soffia attraverso la
codice riga per riga e dire, oh, va bene,

892
00:45:21,580 --> 00:45:22,690
lasciarlo lì in crash.

893
00:45:22,690 --> 00:45:23,420
Questa è una brutta cosa.

894
00:45:23,420 --> 00:45:26,790
Le probabilità sono il programma è solo andare a
interrompere del tutto a quella linea.

895
00:45:26,790 --> 00:45:30,550
Ma se si dovesse rimuovere il schiantato
Line e sostituirlo con le ultime due

896
00:45:30,550 --> 00:45:32,470
Linee lì assegnate -

897
00:45:32,470 --> 00:45:35,310
con assegnazione puntatore - y
per puntare a x come punto t.

898
00:45:35,310 --> 00:45:39,280
E poi si dereferenziare
y in un modo molto sicuro.

899
00:45:39,280 --> 00:45:41,520
>> Perché allora questa ci lascia?

900
00:45:41,520 --> 00:45:45,350
Ebbene, risulta che sotto il cofano
nella biblioteca CS50, i puntatori sono

901
00:45:45,350 --> 00:45:46,320
utilizzati in tutto.

902
00:45:46,320 --> 00:45:48,910
E saremo effettivamente iniziare a sbucciare
indietro quello strato in breve tempo.

903
00:45:48,910 --> 00:45:51,740
Ma si scopre troppo, un'espressione che
alcuni di voi potrebbero avere familiarità con,

904
00:45:51,740 --> 00:45:54,580
particolare quelli più comodo,
è in realtà quella di una molto popolare

905
00:45:54,580 --> 00:45:56,390
sito web, oppure un overflow dello stack,
in questi giorni.

906
00:45:56,390 --> 00:45:58,720
>> Ma questo è in realtà molto
significato tecnico.

907
00:45:58,720 --> 00:46:00,160
Ora sappiamo che cosa è una pila.

908
00:46:00,160 --> 00:46:02,550
E 'come una pila di vassoi
all'interno di una sala da pranzo.

909
00:46:02,550 --> 00:46:05,140
>> O all'interno del vostro computer
memoria its quei fotogrammi

910
00:46:05,140 --> 00:46:06,900
che vengono utilizzati dalle funzioni.

911
00:46:06,900 --> 00:46:10,760
Bene, si scopre che a causa di questo
molto semplice implementazione

912
00:46:10,760 --> 00:46:14,970
memoria e le cornici sulla cosiddetta
Catasta, si può effettivamente prendere il controllo

913
00:46:14,970 --> 00:46:17,050
di un sistema di computer abbastanza facilmente.

914
00:46:17,050 --> 00:46:22,180
Si può incidere in un sistema se la gente
come noi non abbiamo scritto il nostro codice

915
00:46:22,180 --> 00:46:23,300
particolarmente bene.

916
00:46:23,300 --> 00:46:26,670
>> Se la gente come noi usano pezzi
di memoria o di utilizzare matrici -

917
00:46:26,670 --> 00:46:27,810
ancor più comunemente -

918
00:46:27,810 --> 00:46:31,800
ma a volte dimenticare di controllare il
confini della nostra gamma come si potrebbe

919
00:46:31,800 --> 00:46:38,470
Lasciati a volte, e iterata
troppo lontano oltre la fine di un array.

920
00:46:38,470 --> 00:46:40,520
Nel migliore dei casi, il tuo programma
potrebbe anche bloccarsi.

921
00:46:40,520 --> 00:46:42,280
Errore di segmentazione, tipo
di imbarazzante.

922
00:46:42,280 --> 00:46:45,480
Non eccezionale, ma non è necessariamente
una cosa estremamente negativa.

923
00:46:45,480 --> 00:46:49,480
>> Ma se il vostro programma è in realtà il vero
computer degli utenti, se è in esecuzione

924
00:46:49,480 --> 00:46:53,070
su un sito web che le persone casuali reali
su internet stanno colpendo, lasciando

925
00:46:53,070 --> 00:46:56,690
inducono le persone brutte cose sul tuo codice è
generalmente non è una buona cosa perché

926
00:46:56,690 --> 00:46:59,930
significa l'occasione per fare
controllo del computer.

927
00:46:59,930 --> 00:47:01,350
E questo sta a guardare
un po 'criptico.

928
00:47:01,350 --> 00:47:04,570
Ma ho pensato di spaventare voi con
questo ultimo esempio qui.

929
00:47:04,570 --> 00:47:05,650
>> Ecco un esempio di codice.

930
00:47:05,650 --> 00:47:07,370
E c'è una buona Wikipedia
articolo che cammina attraverso

931
00:47:07,370 --> 00:47:08,530
più in dettaglio.

932
00:47:08,530 --> 00:47:13,890
Ho principale sulla vocazione fondo
pippo, passando argv di 1.

933
00:47:13,890 --> 00:47:15,750
E questo è solo così che si può
eseguire il programma e passare

934
00:47:15,750 --> 00:47:17,080
un ingresso arbitrario.

935
00:47:17,080 --> 00:47:20,180
>> E poi pippo è dichiarata fino in alto
come accettare una stringa, o più

936
00:47:20,180 --> 00:47:21,700
appunto, un char *.

937
00:47:21,700 --> 00:47:23,860
E poi dichiara un array di caratteri.

938
00:47:23,860 --> 00:47:27,130
Chiamare un tampone, più in generale,
di dimensione 12.

939
00:47:27,130 --> 00:47:30,900
Quindi 12 caratteri può essere contenuto in
di tale matrice chiamata c.

940
00:47:30,900 --> 00:47:33,510
>> E poi utilizza questa nuova funzione,
che è nuovo, ma non è difficile da

941
00:47:33,510 --> 00:47:34,930
capire, copia della memoria.

942
00:47:34,930 --> 00:47:39,290
Si copia la memoria da bar, che era
passato n variabile, qualunque sia la

943
00:47:39,290 --> 00:47:42,080
utente digitato in argv 1 in c.

944
00:47:42,080 --> 00:47:43,090
Quanti byte?

945
00:47:43,090 --> 00:47:44,260
La lunghezza della stringa di bar.

946
00:47:44,260 --> 00:47:48,380
>> Quindi, in altre parole, se l'utente digita in
h-e-l-l-o ENTER, la lunghezza della stringa

947
00:47:48,380 --> 00:47:49,260
di ciao è cinque.

948
00:47:49,260 --> 00:47:52,790
Così cinque di quei byte sta per arrivare
copiati nella matrice denominata c, che

949
00:47:52,790 --> 00:47:54,110
è di taglia 12.

950
00:47:54,110 --> 00:47:58,710
Ma ciò che l'utente digita in un molto più lungo
parola che è 13 caratteri o 14

951
00:47:58,710 --> 00:48:01,250
caratteri o 100 caratteri o più?

952
00:48:01,250 --> 00:48:02,660
>> Dove stanno andando andare?

953
00:48:02,660 --> 00:48:06,090
Beh, questo telaio, che vassoio
nello stack refettorio,

954
00:48:06,090 --> 00:48:06,930
hanno intenzione di andare lì.

955
00:48:06,930 --> 00:48:10,080
Ed è solo andare per iniziare la sovrascrittura
altra roba che è già

956
00:48:10,080 --> 00:48:12,880
su quella pila, traboccante
la pila, per così dire.

957
00:48:12,880 --> 00:48:14,780
>> Così pittoricamente, pensare in questo modo.

958
00:48:14,780 --> 00:48:17,970
Questa è solo una versione colorata di
la foto abbiamo attirato.

959
00:48:17,970 --> 00:48:20,060
In fondo, diciamo, è il principale.

960
00:48:20,060 --> 00:48:24,690
E in alto, quello che stai vedendo ora
è il telaio, il colore codificato ora, per un

961
00:48:24,690 --> 00:48:26,090
funzione chiamata foo.

962
00:48:26,090 --> 00:48:30,170
Ma ciò che è interessante circa
foo è che qui è la sua cornice.

963
00:48:30,170 --> 00:48:32,860
Così è disegnato proprio come ho
fatto ma in azzurro.

964
00:48:32,860 --> 00:48:35,220
E ora è qui
c staffa 0 va.

965
00:48:35,220 --> 00:48:37,410
Ed è qui che staffa c
11 sta per finire.

966
00:48:37,410 --> 00:48:39,670
>> In altre parole, succede a
essere rappresentato come un quadrato.

967
00:48:39,670 --> 00:48:42,320
Ma se continui plopping bytes
giù - o caratteri - che stanno andando a finire

968
00:48:42,320 --> 00:48:46,070
fino alla posizione 0 tutta la strada fino
a 11 perché è 0 indicizzato.

969
00:48:46,070 --> 00:48:49,170
>> Ma dove è il carattere 13
andando a finire?

970
00:48:49,170 --> 00:48:50,310
Dov'e 'il 14?

971
00:48:50,310 --> 00:48:52,430
Dov'è il carattere 50 °
andando a finire?

972
00:48:52,430 --> 00:48:54,070
>> E 'intenzione di continuare ad andare giù.

973
00:48:54,070 --> 00:48:57,350
Perché anche se abbiamo disegnato la
foto con la pila cresce, il

974
00:48:57,350 --> 00:48:59,920
indirizzi, si scopre, vanno da
piccole indirizzi, piccolo

975
00:48:59,920 --> 00:49:01,830
puntatori, ai grandi indirizzi.

976
00:49:01,830 --> 00:49:03,540
Quindi continua a andare su e su.

977
00:49:03,540 --> 00:49:05,660
>> Quindi, se l'utente digita in
ciao, che è grande.

978
00:49:05,660 --> 00:49:08,650
Nessun problema, nessun problema, sicuro di tutti.

979
00:49:08,650 --> 00:49:11,940
Ma se l'utente digita in quello che faremo
chiamare codice contraddittorio, rappresentato

980
00:49:11,940 --> 00:49:16,040
genericamente come, attaccare, attaccare,
attaccare, attaccare, cosa può succedere?

981
00:49:16,040 --> 00:49:19,760
>> Ebbene, se tutto l'input che l'utente
digitato non è solo qualche amichevole

982
00:49:19,760 --> 00:49:21,540
o una stringa di caratteri offensivo.

983
00:49:21,540 --> 00:49:24,050
In realtà è una sequenza di caratteri
che se è stato compilato,

984
00:49:24,050 --> 00:49:26,050
in realtà è il codice.

985
00:49:26,050 --> 00:49:29,570
Forse è il codice che elimina tutte le
file sul disco rigido o invia lo spam

986
00:49:29,570 --> 00:49:30,810
o qualcosa di simile.

987
00:49:30,810 --> 00:49:35,110
Si noti che ciò che è fondamentale è che
Se il cattivo avuto la fortuna di

988
00:49:35,110 --> 00:49:37,830
sovrascrivere il pezzo rosso della memoria -

989
00:49:37,830 --> 00:49:41,080
che non ho disegnare sulla mia immagine, ma
Wikipedia questa immagine qui ha -

990
00:49:41,080 --> 00:49:42,890
il suo cosiddetto indirizzo di ritorno.

991
00:49:42,890 --> 00:49:47,470
>> Quando ritorna cibo, quando ritorni swap,
come fa il computer a sapere di andare da

992
00:49:47,470 --> 00:49:49,790
qui a qui?

993
00:49:49,790 --> 00:49:52,920
O nel segmento tecnologico in alto, come
fa a sapere di andare allo swap

994
00:49:52,920 --> 00:49:54,870
codice - il 0 e di 1
che compongono swap -

995
00:49:54,870 --> 00:49:56,020
torna alla pagina principale?

996
00:49:56,020 --> 00:50:00,450
C'è un cosiddetto indirizzo di ritorno
memorizzato in quello stesso stack frame, il

997
00:50:00,450 --> 00:50:02,140
la stessa caffetteria cassetto.

998
00:50:02,140 --> 00:50:06,080
>> Quindi, se il cattivo è abbastanza intelligente da
inserire il codice di attacco, il codice di attacco, attacco

999
00:50:06,080 --> 00:50:07,960
codice, e ottenere la fortuna -

1000
00:50:07,960 --> 00:50:11,630
spesso attraverso tentativi ed errori - per
sovrascrivere l'indirizzo di ritorno rosso,

1001
00:50:11,630 --> 00:50:14,360
con l'indirizzo e la comunicazione
la cima.

1002
00:50:14,360 --> 00:50:16,830
Notate 0835C080.

1003
00:50:16,830 --> 00:50:20,650
E 'scritto a ritroso fino in alto per
ragioni che faranno forse rivisitare.

1004
00:50:20,650 --> 00:50:22,050
Questo è quel numero.

1005
00:50:22,050 --> 00:50:25,790
>> Quindi, se il cattivo diventa abbastanza fortunato o
è abbastanza intelligente per sovrascrivere il rosso

1006
00:50:25,790 --> 00:50:29,480
striscia di memoria con l'indirizzo del
codice che lui o lei ha in qualche modo

1007
00:50:29,480 --> 00:50:34,980
iniettato nel vostro computer, indovina il cui
codice sta per essere restituito al

1008
00:50:34,980 --> 00:50:38,260
appena pippo viene fatto eseguendo?

1009
00:50:38,260 --> 00:50:39,440
>> Codice del cattivo.

1010
00:50:39,440 --> 00:50:43,610
Quindi questo codice attacco, AAA, ancora una volta, potrebbe
inviare spam, potrebbe eliminare tutti i file

1011
00:50:43,610 --> 00:50:44,500
sul disco rigido.

1012
00:50:44,500 --> 00:50:48,740
Ma questo è ciò che veramente un overflow dello stack
è, o un sovraccarico del buffer, o di un

1013
00:50:48,740 --> 00:50:51,060
Buffer overflow.

1014
00:50:51,060 --> 00:50:54,400
>> Ed è incredibilmente, incredibilmente comune
a questo giorno con programmi scritti in

1015
00:50:54,400 --> 00:50:58,220
C, C + +, e anche alcune altre lingue.

1016
00:50:58,220 --> 00:51:02,275
In tale nota spaventoso, faremo
terminare con una battuta.

1017
00:51:02,275 --> 00:51:03,230
>> [Risata]

1018
00:51:03,230 --> 00:51:04,550
>> Ci vediamo il Mercoledì.

1019
00:51:04,550 --> 00:51:07,920

1020
00:51:07,920 --> 00:51:10,310
Al prossimo CS50 -

1021
00:51:10,310 --> 00:51:15,920
Quindi sono tutti fuori di lampade disco oggi, ma
aspettare, senza grassi del latte, la metà del telefono

1022
00:51:15,920 --> 00:51:17,850
libro, il succo d'arancia
che ho bevuto oggi.

1023
00:51:17,850 --> 00:51:20,370

1024
00:51:20,370 --> 00:51:22,780
Cavo USB, una chiave inglese.

1025
00:51:22,780 --> 00:51:24,800
>> [MUSIC PLAYING]