1
00:00:00,000 --> 00:00:09,572

2
00:00:09,572 --> 00:00:12,030
ROB BOWDEN: Ciao, io sono Rob Bowden,
e parliamo di quiz0.

3
00:00:12,030 --> 00:00:13,280

4
00:00:13,280 --> 00:00:14,545
>> Quindi, prima domanda.

5
00:00:14,545 --> 00:00:17,750
Questa è la domanda cui
avevi bisogno di codificare il numero

6
00:00:17,750 --> 00:00:21,270
127 dei bulbi binari.

7
00:00:21,270 --> 00:00:23,550
Se si voleva, si potrebbe
fare la conversione regolare

8
00:00:23,550 --> 00:00:25,950
da bi-- o, da decimale a binario.

9
00:00:25,950 --> 00:00:28,300
Ma questo è probabilmente andando
di prendere un sacco di tempo.

10
00:00:28,300 --> 00:00:31,750
Voglio dire, si può capire che,
OK, 1 è in là, 2 è in là,

11
00:00:31,750 --> 00:00:33,650
4 è lì, 8 è in là.

12
00:00:33,650 --> 00:00:39,280
Modo più semplice, è di 128 127 meno uno.

13
00:00:39,280 --> 00:00:42,013
Quella lampadina più a sinistra è il 128-bit.

14
00:00:42,013 --> 00:00:43,490

15
00:00:43,490 --> 00:00:47,860
Quindi 127 è in realtà solo tutto
delle altre lampadine,

16
00:00:47,860 --> 00:00:51,420
dato che è il più a sinistra
lampadina meno 1.

17
00:00:51,420 --> 00:00:52,800
Questo è tutto per questa domanda.

18
00:00:52,800 --> 00:00:54,060
>> Prima domanda.

19
00:00:54,060 --> 00:00:56,710
Quindi, con 3 bit è possibile
rappresentano 8 valori distinti.

20
00:00:56,710 --> 00:01:01,000
Perché, allora, è il più grande 7 non negativo
numero intero decimale si può rappresentare?

21
00:01:01,000 --> 00:01:04,050
Beh, se si può solo
rappresentano 8 valori distinti,

22
00:01:04,050 --> 00:01:07,430
allora quello che stiamo andando a essere
che rappresenta è da 0 a 7.

23
00:01:07,430 --> 00:01:08,745
0 occupa uno dei valori.

24
00:01:08,745 --> 00:01:09,980

25
00:01:09,980 --> 00:01:11,190
>> Domanda due.

26
00:01:11,190 --> 00:01:14,610
Con n bit, il numero di distinte
I valori si possono rappresentare?

27
00:01:14,610 --> 00:01:19,080
Così, con n bit, si dispone di 2
valori possibili per ogni bit.

28
00:01:19,080 --> 00:01:22,300
Quindi abbiamo 2 valori possibili per
il primo bit, 2 valori possibili

29
00:01:22,300 --> 00:01:24,450
per il secondo, 2
possibile per il terzo.

30
00:01:24,450 --> 00:01:28,730
E così che è 2 volte 2 volte 2, e
in ultima analisi, la risposta è 2 al n.

31
00:01:28,730 --> 00:01:30,010

32
00:01:30,010 --> 00:01:31,100
>> Domanda tre.

33
00:01:31,100 --> 00:01:33,450
Cosa c'è di 0x50 in binario?

34
00:01:33,450 --> 00:01:39,490
Quindi ricorda che esadecimale è molto
conversione semplice binario.

35
00:01:39,490 --> 00:01:43,180
Così qui, abbiamo solo bisogno di guardare
il 5 e 0 indipendentemente.

36
00:01:43,180 --> 00:01:45,110
Così che cosa è 5 in binario?

37
00:01:45,110 --> 00:01:48,400
0101, questo è il 1 bit e il bit 4.

38
00:01:48,400 --> 00:01:49,900
Cosa c'è 0 in binario?

39
00:01:49,900 --> 00:01:50,520
Non difficile.

40
00:01:50,520 --> 00:01:52,180
0000.

41
00:01:52,180 --> 00:01:54,970
Quindi, solo metterli insieme, e
questo è il numero intero in binario.

42
00:01:54,970 --> 00:01:57,640
01.010.000.

43
00:01:57,640 --> 00:02:00,439
E se si voleva si poteva
togliere quella più a sinistra a zero.

44
00:02:00,439 --> 00:02:01,105
E 'irrilevante.

45
00:02:01,105 --> 00:02:02,920

46
00:02:02,920 --> 00:02:05,733
>> E allora, in alternativa,
ciò che è 0x50 in decimale?

47
00:02:05,733 --> 00:02:08,649
Se si voleva, si could-- se siete
più a suo agio con il binario,

48
00:02:08,649 --> 00:02:11,340
si potrebbe prendere quella risposta binaria
e convertire in decimale.

49
00:02:11,340 --> 00:02:13,870
Oppure potremmo ricordare
che esadecimale.

50
00:02:13,870 --> 00:02:21,140
Affinché 0 nel 0-esimo posto, e
il 5 è in 16 alla prima.

51
00:02:21,140 --> 00:02:25,990
Ecco, noi abbiamo 5 volte 16 per il
prima, più 0 volte 16 allo zero,

52
00:02:25,990 --> 00:02:27,520
è 80.

53
00:02:27,520 --> 00:02:29,710
E se hai guardato il
titolo alla domanda,

54
00:02:29,710 --> 00:02:32,920
era CS 80, che era una specie di
suggerimento per la risposta a questo problema.

55
00:02:32,920 --> 00:02:34,460

56
00:02:34,460 --> 00:02:35,420
>> Domanda cinque.

57
00:02:35,420 --> 00:02:40,320
Abbiamo questo script Scratch, che è
ripetere 4 volte il burro di arachidi gelatina.

58
00:02:40,320 --> 00:02:42,800
Quindi, come facciamo noi ora codice in C?

59
00:02:42,800 --> 00:02:47,730
Bene, abbiamo qui-- la parte in grassetto
è l'unica parte si doveva attuare.

60
00:02:47,730 --> 00:02:51,950
Quindi abbiamo un 4 ciclo che sta loop 4
volte-ing printf burro di arachidi gelatina,

61
00:02:51,950 --> 00:02:53,910
con la nuova linea come il problema chiede.

62
00:02:53,910 --> 00:02:55,250

63
00:02:55,250 --> 00:02:57,490
>> Domanda di sei, un altro problema Scratch.

64
00:02:57,490 --> 00:03:00,210
Si vede che siamo in un eterno ciclo.

65
00:03:00,210 --> 00:03:05,000
Stiamo dicendo che la variabile i
e poi incrementando i di 1.

66
00:03:05,000 --> 00:03:09,580
Ora vogliamo farlo in C. Ci sono
molteplici modi in cui avrebbe potuto farlo.

67
00:03:09,580 --> 00:03:12,840
Qui ci è capitato di codificare il
sempre ciclo come while (true).

68
00:03:12,840 --> 00:03:16,600
Così si dichiara la variabile i, appena
come abbiamo avuto i variabili in Scratch.

69
00:03:16,600 --> 00:03:21,950
Dichiarare la variabile i, e per sempre
while (true), diciamo che la variabile i.

70
00:03:21,950 --> 00:03:25,260
Così printf% I-- o avresti potuto usato% d.

71
00:03:25,260 --> 00:03:27,985
Diciamo che variabili, e
poi incrementarlo, i ++.

72
00:03:27,985 --> 00:03:29,560

73
00:03:29,560 --> 00:03:30,830
>> Domanda sette.

74
00:03:30,830 --> 00:03:35,560
Ora vogliamo fare qualcosa di molto simile
di Mario dot c dal problema impostare uno.

75
00:03:35,560 --> 00:03:39,110
Vogliamo stampare questi hashtags,
vogliamo stampare un cinque

76
00:03:39,110 --> 00:03:40,700
per tre rettangolo di questi hash.

77
00:03:40,700 --> 00:03:41,770

78
00:03:41,770 --> 00:03:43,162
Quindi, come facciamo a fare questo?

79
00:03:43,162 --> 00:03:45,370
Beh, vi diamo un intero
mucchio di codice, e basta

80
00:03:45,370 --> 00:03:47,560
devono compilare la funzione di griglia di stampa.

81
00:03:47,560 --> 00:03:49,540
>> Così che cosa PrintGrid assomiglia?

82
00:03:49,540 --> 00:03:51,480
Beh, tu sei oltre il
larghezza e l'altezza.

83
00:03:51,480 --> 00:03:53,520
Quindi abbiamo un esterno 4
ciclo, che è looping

84
00:03:53,520 --> 00:03:57,650
su tutte le righe di questo
griglia che vogliamo stampare.

85
00:03:57,650 --> 00:04:01,250
Poi abbiamo l'inter-nested 4 loop,
questa è la stampa su ogni colonna.

86
00:04:01,250 --> 00:04:06,210
Quindi, per ogni riga, il risultato della stampa per
ogni colonna, un unico hash.

87
00:04:06,210 --> 00:04:10,045
Poi alla fine della riga della stampa una
singola nuova linea per passare alla riga successiva.

88
00:04:10,045 --> 00:04:11,420
E questo è tutto per l'intera griglia.

89
00:04:11,420 --> 00:04:12,810

90
00:04:12,810 --> 00:04:13,675
>> Domanda di otto.

91
00:04:13,675 --> 00:04:17,170
Una funzione come PrintGrid si dice
avere un effetto collaterale, ma non un ritorno

92
00:04:17,170 --> 00:04:17,670
valore.

93
00:04:17,670 --> 00:04:19,209
Spiegare la distinzione.

94
00:04:19,209 --> 00:04:23,080
Quindi questo si basa su di voi ricordare
ciò è un effetto collaterale.

95
00:04:23,080 --> 00:04:25,180
Beh, un ritorno value--
sappiamo PrintGrid non lo fa

96
00:04:25,180 --> 00:04:28,180
avere un valore di ritorno, dal momento che
proprio qui si dice nulla.

97
00:04:28,180 --> 00:04:31,150
Quindi tutto ciò che restituisce void
in realtà non restituire nulla.

98
00:04:31,150 --> 00:04:32,200

99
00:04:32,200 --> 00:04:33,620
Allora, qual è l'effetto collaterale?

100
00:04:33,620 --> 00:04:36,620
Ebbene, un effetto collaterale è
tutto ciò che tipo di persiste

101
00:04:36,620 --> 00:04:39,500
dopo la fine della funzione
che non era appena tornato,

102
00:04:39,500 --> 00:04:41,340
e non era solo dagli ingressi.

103
00:04:41,340 --> 00:04:44,970
>> Così, per esempio, potremmo
modificare una variabile globale.

104
00:04:44,970 --> 00:04:46,590
Sarebbe un effetto collaterale.

105
00:04:46,590 --> 00:04:49,000
In questo caso particolare,
molto importante effetto collaterale

106
00:04:49,000 --> 00:04:51,070
è la stampa su schermo.

107
00:04:51,070 --> 00:04:53,110
Così che è un effetto collaterale
che PrintGrid ha.

108
00:04:53,110 --> 00:04:54,980
Stampiamo queste cose sullo schermo.

109
00:04:54,980 --> 00:04:56,370
E si può pensare di
che come effetto collaterale,

110
00:04:56,370 --> 00:04:58,690
dato che è una cosa che
persiste dopo questa funzione si conclude.

111
00:04:58,690 --> 00:05:01,481
Questo è qualcosa al di fuori del campo di applicazione
di questa funzione che infine

112
00:05:01,481 --> 00:05:03,380
viene modificato, il
contenuto dello schermo.

113
00:05:03,380 --> 00:05:05,200

114
00:05:05,200 --> 00:05:05,839
>> Domanda nove.

115
00:05:05,839 --> 00:05:07,880
Si consideri il seguente programma,
a cui i numeri di riga

116
00:05:07,880 --> 00:05:09,740
sono stati aggiunti per
il bene della discussione.

117
00:05:09,740 --> 00:05:13,480
Quindi, in questo programma ci sono solo
chiamando GetString, riporlo

118
00:05:13,480 --> 00:05:16,220
In questa variabile s, e poi
stampa la variabile s.

119
00:05:16,220 --> 00:05:16,720
Ok.

120
00:05:16,720 --> 00:05:19,090
Quindi spiegare perché la linea uno è presente.

121
00:05:19,090 --> 00:05:20,920
#include CS50 dot h.

122
00:05:20,920 --> 00:05:23,820
Perché abbiamo bisogno di #include CS50 dot h?

123
00:05:23,820 --> 00:05:26,180
Bene, noi stiamo chiamando il
Funzione GetString,

124
00:05:26,180 --> 00:05:28,840
e GetString è definito
in biblioteca CS50.

125
00:05:28,840 --> 00:05:31,600
Quindi, se non avessimo
#include CS50 dot h,

126
00:05:31,600 --> 00:05:35,760
otterremmo tale dichiarazione implicita
dell'errore funzione GetString

127
00:05:35,760 --> 00:05:36,840
dal compilatore.

128
00:05:36,840 --> 00:05:40,110
Quindi abbiamo bisogno di includere il library--
abbiamo bisogno di includere il file di intestazione,

129
00:05:40,110 --> 00:05:42,870
altrimenti il ​​compilatore non
riconoscere che GetString esiste.

130
00:05:42,870 --> 00:05:44,380

131
00:05:44,380 --> 00:05:46,140
>> Spiegare perché la linea due è presente.

132
00:05:46,140 --> 00:05:47,890
Così standard io punto h.

133
00:05:47,890 --> 00:05:50,430
E 'esattamente lo stesso
come il problema precedente,

134
00:05:50,430 --> 00:05:53,310
tranne che invece di trattare con
GetString, stiamo parlando di printf.

135
00:05:53,310 --> 00:05:56,654
Quindi, se non abbiamo detto che abbiamo bisogno di
per includere norma io dot h,

136
00:05:56,654 --> 00:05:58,820
allora non saremmo in grado
Per utilizzare la funzione printf,

137
00:05:58,820 --> 00:06:00,653
perché il compilatore
non sarebbe sapere.

138
00:06:00,653 --> 00:06:01,750

139
00:06:01,750 --> 00:06:05,260
>> Why-- qual è il significato
di diritto nella linea a quattro?

140
00:06:05,260 --> 00:06:08,010
Quindi qui abbiamo int main (void).

141
00:06:08,010 --> 00:06:10,600
Questo è solo dicendo che noi
non si ottiene alcuna riga di comando

142
00:06:10,600 --> 00:06:12,280
argomenti di principale.

143
00:06:12,280 --> 00:06:17,390
Ricordate che potremmo dire int
principali int argc parentesi stringa argv.

144
00:06:17,390 --> 00:06:20,400
Così qui ci limitiamo a dire nulla a dire che
stanno ignorando gli argomenti della riga di comando.

145
00:06:20,400 --> 00:06:21,840

146
00:06:21,840 --> 00:06:25,225
>> Spiegare, riferendosi alla memoria, esattamente
cosa GetString in linea sei rendimenti.

147
00:06:25,225 --> 00:06:27,040

148
00:06:27,040 --> 00:06:31,640
GetString restituisce un blocco di
memoria, un array di caratteri.

149
00:06:31,640 --> 00:06:34,870
E 'davvero un ritorno
puntatore al primo carattere.

150
00:06:34,870 --> 00:06:37,170
Ricordate che una stringa è una stella char.

151
00:06:37,170 --> 00:06:41,360
Quindi s è un puntatore alla prima
carattere qualunque sia la stringa è

152
00:06:41,360 --> 00:06:43,510
che l'utente immessi tramite tastiera.

153
00:06:43,510 --> 00:06:47,070
E che la memoria sembra essere malloced,
in modo che la memoria è in mucchio.

154
00:06:47,070 --> 00:06:49,080

155
00:06:49,080 --> 00:06:50,450
>> Domanda 13.

156
00:06:50,450 --> 00:06:51,960
Si consideri il seguente programma.

157
00:06:51,960 --> 00:06:55,579
Quindi tutto questo programma sta facendo
è printf-ing 1 diviso per 10.

158
00:06:55,579 --> 00:06:57,370
Così, quando compilato e
eseguito, questo programma

159
00:06:57,370 --> 00:07:01,170
uscite 0.0, anche se
1 diviso per 10 è 0,1.

160
00:07:01,170 --> 00:07:02,970
Allora perché è 0.0?

161
00:07:02,970 --> 00:07:05,510
Beh, questo è dovuto al fatto
della divisione intera.

162
00:07:05,510 --> 00:07:08,580
Quindi 1 è un numero intero, 10 è un numero intero.

163
00:07:08,580 --> 00:07:11,980
Così 1 diviso 10, tutto
è trattato come numeri interi,

164
00:07:11,980 --> 00:07:16,380
e in C, quando facciamo divisione intera,
abbiamo troncare qualsiasi punto decimale.

165
00:07:16,380 --> 00:07:19,590
Quindi 1 diviso per 10 è
0, e quindi stiamo cercando

166
00:07:19,590 --> 00:07:24,410
stampare che come un galleggiante, così
lo zero stampato come un galleggiante è 0.0.

167
00:07:24,410 --> 00:07:27,400
Ed è per questo che otteniamo 0.0.

168
00:07:27,400 --> 00:07:28,940
>> Si consideri il seguente programma.

169
00:07:28,940 --> 00:07:31,280
Ora stiamo stampa 0.1.

170
00:07:31,280 --> 00:07:34,280
Quindi no divisione intera,
stiamo solo la stampa 0.1,

171
00:07:34,280 --> 00:07:37,100
ma stiamo stamparlo
a 28 cifre decimali.

172
00:07:37,100 --> 00:07:41,810
E riusciamo ad ottenere questo 0.1000, un intero gruppo
di zeri, 5 5 5, bla bla bla.

173
00:07:41,810 --> 00:07:45,495
Quindi la domanda qui è il motivo per cui lo fa
stampare che, invece di esattamente 0,1?

174
00:07:45,495 --> 00:07:46,620

175
00:07:46,620 --> 00:07:49,640
>> Quindi la ragione qui è ora
virgola mobile imprecisioni.

176
00:07:49,640 --> 00:07:53,410
Ricordate che un galleggiante si trova a soli 32 bit.

177
00:07:53,410 --> 00:07:57,540
Così possiamo rappresentare solo un numero finito
di valori in virgola mobile con quelle 32

178
00:07:57,540 --> 00:07:58,560
bit.

179
00:07:58,560 --> 00:08:01,760
Beh c'è infine infinitamente
molti valori in virgola mobile,

180
00:08:01,760 --> 00:08:04,940
e ci sono infiniti galleggiante
valori in punti in tra 0 e 1,

181
00:08:04,940 --> 00:08:07,860
e siamo ovviamente in grado di
rappresentano ancora di più i valori di quello.

182
00:08:07,860 --> 00:08:13,230
Quindi dobbiamo fare sacrifici per
essere in grado di rappresentare la maggior parte dei valori.

183
00:08:13,230 --> 00:08:16,960
>> Quindi un valore come 0.1, a quanto pare
non possiamo garantirne la precisione.

184
00:08:16,960 --> 00:08:22,500
Così, invece di rappresentare 0.1 facciamo il
meglio che possiamo rappresentare questa 0.100000 5 5

185
00:08:22,500 --> 00:08:23,260
5.

186
00:08:23,260 --> 00:08:26,306
E questo è abbastanza vicino, ma
per molte applicazioni

187
00:08:26,306 --> 00:08:28,430
si deve preoccupare di
virgola mobile imprecisioni,

188
00:08:28,430 --> 00:08:30,930
perché noi non possiamo rappresentare
tutte galleggiante punti esattamente.

189
00:08:30,930 --> 00:08:32,500

190
00:08:32,500 --> 00:08:33,380
>> Domanda 15.

191
00:08:33,380 --> 00:08:34,679
Si consideri il codice di seguito.

192
00:08:34,679 --> 00:08:36,630
Stiamo solo la stampa di 1 più 1.

193
00:08:36,630 --> 00:08:38,289
Quindi non c'è nessun trucco.

194
00:08:38,289 --> 00:08:41,780
1 più 1 restituisce a 2, e
allora siamo di stampare tale.

195
00:08:41,780 --> 00:08:42,789
Questo stampa solo 2.

196
00:08:42,789 --> 00:08:43,850

197
00:08:43,850 --> 00:08:44,700
>> Domanda 16.

198
00:08:44,700 --> 00:08:49,450
Ora stiamo stampando il carattere
1 più il carattere 1.

199
00:08:49,450 --> 00:08:52,110
Allora perché questo non
stampare la stessa cosa?

200
00:08:52,110 --> 00:08:57,680
Beh, il carattere 1 più il carattere
1, il carattere 1 ha valore ASCII 49.

201
00:08:57,680 --> 00:09:04,840
Quindi questo è davvero dire 49 più 49, e
in ultima analisi, si tratta di andare per la stampa 98.

202
00:09:04,840 --> 00:09:06,130
Quindi questo non stampa 2.

203
00:09:06,130 --> 00:09:08,070

204
00:09:08,070 --> 00:09:09,271
>> Domanda 17.

205
00:09:09,271 --> 00:09:11,520
Completare l'attuazione
dispari di seguito in modo

206
00:09:11,520 --> 00:09:14,615
che la funzione restituisce true se
n è dispari e falso se n è pari.

207
00:09:14,615 --> 00:09:16,710

208
00:09:16,710 --> 00:09:19,330
Questo è un grande scopo
per l'operatore mod.

209
00:09:19,330 --> 00:09:24,530
Quindi prendiamo il nostro argomento n,
se n mod 2 è uguale a 1, e

210
00:09:24,530 --> 00:09:28,030
ciò significa che n divide
da 2 aveva un resto.

211
00:09:28,030 --> 00:09:33,270
Se n diviso 2 aveva un residuo, che
significa che n è dispari, quindi torniamo vero.

212
00:09:33,270 --> 00:09:34,910
Altrimenti si ritorna falso.

213
00:09:34,910 --> 00:09:39,070
Si potrebbe anche aver fatto n MOD 2 uguali
pari a zero, restituire false, altrimenti restituisce true.

214
00:09:39,070 --> 00:09:41,600

215
00:09:41,600 --> 00:09:43,640
>> Si consideri la funzione ricorsiva di seguito.

216
00:09:43,640 --> 00:09:46,920
Quindi, se n è minore o
uguale a 1, ritorno 1,

217
00:09:46,920 --> 00:09:50,430
else return n volte f di n meno 1.

218
00:09:50,430 --> 00:09:52,556
Così che cosa è questa funzione?

219
00:09:52,556 --> 00:09:54,305
Beh, questo è solo il
funzione fattoriale.

220
00:09:54,305 --> 00:09:55,410

221
00:09:55,410 --> 00:09:57,405
Questo è ben rappresentato
come n fattoriale.

222
00:09:57,405 --> 00:09:58,720

223
00:09:58,720 --> 00:10:02,310
>> Quindi, mettere in discussione 19 ora, vogliamo
prendere questa funzione ricorsiva.

224
00:10:02,310 --> 00:10:04,530
Noi vogliamo rendere iterativo.

225
00:10:04,530 --> 00:10:05,874
Quindi, come possiamo farlo?

226
00:10:05,874 --> 00:10:07,790
Bene per il personale
soluzione, e ancora una volta non c'è

227
00:10:07,790 --> 00:10:11,090
diversi modi che avresti potuto fare
che, iniziamo con questo int prodotto

228
00:10:11,090 --> 00:10:11,812
è uguale a 1.

229
00:10:11,812 --> 00:10:13,520
E per tutto questo
ciclo for, stiamo andando

230
00:10:13,520 --> 00:10:17,590
da moltiplicare prodotto in ultima analisi,
finire con la piena fattoriale.

231
00:10:17,590 --> 00:10:21,870
Così, per int i uguale a 2, i è
minore o uguale an, i ++.

232
00:10:21,870 --> 00:10:24,130
>> Ci si potrebbe chiedere il motivo per cui i uguale a 2.

233
00:10:24,130 --> 00:10:28,380
Beh, ricordate che qui dobbiamo
assicurarsi che il nostro scenario di base è corretta.

234
00:10:28,380 --> 00:10:32,180
Quindi, se n è minore o uguale
a 1, stiamo solo tornando 1.

235
00:10:32,180 --> 00:10:34,830
Così qui, iniziamo a i uguale a 2.

236
00:10:34,830 --> 00:10:39,090
Beh, se fossi 1, allora the-- o
se n fosse 1, quindi il ciclo for

237
00:10:39,090 --> 00:10:40,600
Non avrebbe eseguito affatto.

238
00:10:40,600 --> 00:10:43,190
E così ci sarebbe solo
prodotto di ritorno, che è 1.

239
00:10:43,190 --> 00:10:45,920
Allo stesso modo, se n fosse
niente di meno che 1--

240
00:10:45,920 --> 00:10:49,290
se fosse 0, 1 negativa, whatever--
saremmo ancora torneremo 1,

241
00:10:49,290 --> 00:10:52,260
che è esattamente ciò che il
versione ricorsiva sta facendo.

242
00:10:52,260 --> 00:10:54,660
>> Ora, se n è maggiore
di 1, allora stiamo andando

243
00:10:54,660 --> 00:10:56,550
fare almeno un
iterazione di questo ciclo.

244
00:10:56,550 --> 00:11:00,630
Quindi diciamo che n è 5, allora siamo
intenzione di fare i tempi di prodotto è uguale a 2.

245
00:11:00,630 --> 00:11:02,165
Così ora prodotto è 2.

246
00:11:02,165 --> 00:11:04,040
Ora stiamo andando a fare
volte di prodotto è uguale a 3.

247
00:11:04,040 --> 00:11:04,690
Ora è 6.

248
00:11:04,690 --> 00:11:07,500
Volte del prodotto è uguale a 4, ora è 24.

249
00:11:07,500 --> 00:11:10,420
Prodotto è uguale a 5 volte, ora è 120.

250
00:11:10,420 --> 00:11:16,730
Allora in definitiva, siamo di ritorno
120, che è corretto e 5 fattoriale.

251
00:11:16,730 --> 00:11:17,510
>> Domanda 20.

252
00:11:17,510 --> 00:11:22,480
Questo è quello in cui è necessario compilare
in questa tabella con qualsiasi dato algoritmo,

253
00:11:22,480 --> 00:11:25,735
tutto ciò che abbiamo visto, che
si adatta questi run algoritmico

254
00:11:25,735 --> 00:11:28,060
volte questi tempi di esecuzione asintotici.

255
00:11:28,060 --> 00:11:33,270
Così che cosa è un algoritmo che
è omega di 1, ma grande O di n?

256
00:11:33,270 --> 00:11:35,970
Quindi ci potrebbe essere infinitamente
molte risposte qui.

257
00:11:35,970 --> 00:11:39,790
Quello che abbiamo visto probabilmente più
spesso è solo ricerca lineare.

258
00:11:39,790 --> 00:11:42,050
>> Quindi, nel migliore dei casi
scenario, la voce siamo

259
00:11:42,050 --> 00:11:44,050
cercando al
all'inizio della lista

260
00:11:44,050 --> 00:11:47,400
e così in omega di passi di 1,
la prima cosa che controlliamo,

261
00:11:47,400 --> 00:11:49,740
abbiamo appena torniamo subito
che abbiamo trovato il prodotto.

262
00:11:49,740 --> 00:11:52,189
Nel peggiore dei casi,
l'elemento è alla fine,

263
00:11:52,189 --> 00:11:53,730
o l'articolo non è nell'elenco affatto.

264
00:11:53,730 --> 00:11:56,700
Quindi dobbiamo cercare
l'intera lista, tutti gli n

265
00:11:56,700 --> 00:11:58,480
elementi, ed è per questo che è o di n.

266
00:11:58,480 --> 00:11:59,670

267
00:11:59,670 --> 00:12:04,880
>> Così ora è qualcosa che è sia
omega di log n n, e grande O di log n n.

268
00:12:04,880 --> 00:12:08,650
Beh, la cosa più rilevante
che abbiamo visto qui è merge sort.

269
00:12:08,650 --> 00:12:12,950
Così merge sort, ricordare,
Theta è in ultima analisi,

270
00:12:12,950 --> 00:12:16,920
di n log n, dove è definito theta
se entrambi omega e grande O sono uguali.

271
00:12:16,920 --> 00:12:17,580
Sia n log n.

272
00:12:17,580 --> 00:12:18,690

273
00:12:18,690 --> 00:12:21,970
>> Che cosa è qualcosa che è omega
di n, e O di n al quadrato?

274
00:12:21,970 --> 00:12:23,990
Beh, ancora non c'è
più risposte possibili.

275
00:12:23,990 --> 00:12:26,440
Qui ci capita di dire bubble sort.

276
00:12:26,440 --> 00:12:28,840
Insertion sort sarebbe anche lavorare qui.

277
00:12:28,840 --> 00:12:31,400
Ricordate che bubble sort
ha che l'ottimizzazione in cui,

278
00:12:31,400 --> 00:12:34,630
se si è in grado di ottenere
attraverso l'intera lista

279
00:12:34,630 --> 00:12:37,402
senza bisogno di fare
eventuali swap, poi, beh,

280
00:12:37,402 --> 00:12:40,110
possiamo tornare subito che
l'elenco è stato ordinato per cominciare.

281
00:12:40,110 --> 00:12:43,185
Quindi, nel migliore dei casi,
è solo omega di n.

282
00:12:43,185 --> 00:12:45,960
Se non è solo un bene
ordinati lista per cominciare,

283
00:12:45,960 --> 00:12:48,270
allora abbiamo O di n al quadrato swap.

284
00:12:48,270 --> 00:12:49,330

285
00:12:49,330 --> 00:12:55,610
E, infine, abbiamo ordinamento per selezione
per n al quadrato, sia omega e grande O.

286
00:12:55,610 --> 00:12:56,850
>> Domanda 21.

287
00:12:56,850 --> 00:12:58,870
Cosa c'è di integer overflow?

288
00:12:58,870 --> 00:13:02,160
Ebbene nuovo, simile al precedente,
abbiamo solo un numero finito di bit

289
00:13:02,160 --> 00:13:04,255
per rappresentare un numero intero,
così forse 32 bit.

290
00:13:04,255 --> 00:13:06,300

291
00:13:06,300 --> 00:13:09,180
Diciamo che abbiamo un intero con segno.

292
00:13:09,180 --> 00:13:12,800
Quindi in ultima analisi, il più alto
numero positivo possiamo rappresentare

293
00:13:12,800 --> 00:13:15,910
è 2 alla 31 meno 1.

294
00:13:15,910 --> 00:13:19,370
Che cosa succede se proviamo a
quindi incrementare tale numero intero?

295
00:13:19,370 --> 00:13:25,320
Beh, stiamo andando a passare dal 2 al 31
meno 1, tutta la strada fino a negativo 2

296
00:13:25,320 --> 00:13:26,490
al 31.

297
00:13:26,490 --> 00:13:29,470
Quindi questo Integer Overflow è
quando si mantiene l'incremento,

298
00:13:29,470 --> 00:13:32,330
e in ultima analisi, non si può
ottenere solo più in alto e

299
00:13:32,330 --> 00:13:34,520
avvolge tutto il viaggio di ritorno
intorno ad un valore negativo.

300
00:13:34,520 --> 00:13:35,850

301
00:13:35,850 --> 00:13:37,779
>> Che dire di un buffer overflow?

302
00:13:37,779 --> 00:13:39,820
Così un buffer overflow--
ricordare ciò che un buffer è.

303
00:13:39,820 --> 00:13:41,000
E 'solo un pezzo di memoria.

304
00:13:41,000 --> 00:13:43,350
Qualcosa di simile a un array è un buffer.

305
00:13:43,350 --> 00:13:46,120
Così un buffer overflow è quando
si tenta di accedere alla memoria

306
00:13:46,120 --> 00:13:47,880
oltre la fine di tale matrice.

307
00:13:47,880 --> 00:13:50,410
Quindi, se si dispone di un
array di dimensione 5 e

308
00:13:50,410 --> 00:13:53,700
tentare di accedere staffa matrice
5 o 6 o staffa staffa 7,

309
00:13:53,700 --> 00:13:56,610
o qualcosa al di là del
fine, o addirittura nulla

310
00:13:56,610 --> 00:14:00,790
staffa di serie below-- negativo 1--
tutti questi sono buffer overflow.

311
00:14:00,790 --> 00:14:02,810
Stai toccando la memoria in cattiva strada.

312
00:14:02,810 --> 00:14:04,090

313
00:14:04,090 --> 00:14:04,730
>> Domanda 23.

314
00:14:04,730 --> 00:14:05,760

315
00:14:05,760 --> 00:14:09,100
Quindi, in questo è necessario
per implementare strlen.

316
00:14:09,100 --> 00:14:11,630
E vi diciamo che è possibile
assumere s non sarà nullo,

317
00:14:11,630 --> 00:14:13,790
in modo da non dover
fare tutti i controlli per nulla.

318
00:14:13,790 --> 00:14:16,190
E ci sono diversi modi
avresti potuto fare questo.

319
00:14:16,190 --> 00:14:18,440
Qui dobbiamo solo prendere il semplice.

320
00:14:18,440 --> 00:14:21,780
Si comincia con un contatore, n. n è
contare quanti caratteri ci sono.

321
00:14:21,780 --> 00:14:25,560
Così iniziamo a 0, e poi ci
iterare l'intero elenco.

322
00:14:25,560 --> 00:14:29,092
>> È s staffa 0 pari al
carattere terminatore null?

323
00:14:29,092 --> 00:14:31,425
Ricordate che stiamo cercando
il carattere terminatore null

324
00:14:31,425 --> 00:14:33,360
per determinare quanto tempo la nostra stringa è.

325
00:14:33,360 --> 00:14:35,890
Che sta per terminare
qualsiasi stringa in questione.

326
00:14:35,890 --> 00:14:39,400
Così è s staffa 0 uguale
per il terminatore nullo?

327
00:14:39,400 --> 00:14:42,850
Se non lo è, allora stiamo andando a
guardare staffa s 1, s 2 staffa.

328
00:14:42,850 --> 00:14:45,050
Continuiamo fino a quando non
trovare il terminatore null.

329
00:14:45,050 --> 00:14:48,580
Una volta che abbiamo trovato, allora n contiene
la lunghezza totale della stringa,

330
00:14:48,580 --> 00:14:49,942
e possiamo solo tornare quella.

331
00:14:49,942 --> 00:14:51,180

332
00:14:51,180 --> 00:14:51,865
>> Domanda 24.

333
00:14:51,865 --> 00:14:53,010

334
00:14:53,010 --> 00:14:56,050
Quindi questo è quello in cui si
devono fare il compromesso.

335
00:14:56,050 --> 00:14:59,810
Quindi una cosa è buona in un
modo, ma in che modo è brutto?

336
00:14:59,810 --> 00:15:02,980
Quindi, ecco, merge sort tende a
essere più veloce di bubble sort.

337
00:15:02,980 --> 00:15:06,530
Detto che-- bene, ci
di risposte qui.

338
00:15:06,530 --> 00:15:12,930
Ma la principale è che bubble sort
è omega di n per un elenco ordinato.

339
00:15:12,930 --> 00:15:14,950
>> Ricordate quel tavolo che abbiamo appena visto in precedenza.

340
00:15:14,950 --> 00:15:17,600
Così bolla ordina omega di
n, la migliore delle ipotesi

341
00:15:17,600 --> 00:15:20,010
è che è in grado di andare poco più di
la lista una volta, determinano

342
00:15:20,010 --> 00:15:22,270
ehi questa cosa è già
ordinati, e ritorno.

343
00:15:22,270 --> 00:15:25,960
Merge sort, non importa quale
che fai, è l'omega di log n n.

344
00:15:25,960 --> 00:15:29,200
Così per la lista ordinata, bolla
tipo sta per essere più veloce.

345
00:15:29,200 --> 00:15:30,870

346
00:15:30,870 --> 00:15:32,430
>> Ora, per quanto riguarda le liste collegate?

347
00:15:32,430 --> 00:15:36,070
Quindi, una lista concatenata può crescere e ridursi
per adattarsi tanti elementi come necessario.

348
00:15:36,070 --> 00:15:38,489
Detto così che--
di solito il confronto diretto

349
00:15:38,489 --> 00:15:40,280
sta per essere collegato
elenco di una serie.

350
00:15:40,280 --> 00:15:41,600

351
00:15:41,600 --> 00:15:44,050
Così, anche se gli array possono
facilmente crescere e ridursi

352
00:15:44,050 --> 00:15:47,130
per soddisfare il maggior numero di elementi
se necessario, un elenco collegato

353
00:15:47,130 --> 00:15:49,600
rispetto ad un un array--
matrice ha accesso casuale.

354
00:15:49,600 --> 00:15:52,960
Siamo in grado di indicizzare in qualsiasi
particolare elemento della matrice.

355
00:15:52,960 --> 00:15:56,430
>> Così, per una lista collegata, non possiamo
basta andare al quinto elemento,

356
00:15:56,430 --> 00:16:00,260
dobbiamo attraversare dall'inizio
fino ad arrivare al quinto elemento.

357
00:16:00,260 --> 00:16:03,990
E che sta per impedirci di
fare qualcosa come la ricerca binaria.

358
00:16:03,990 --> 00:16:08,150
Parlando di ricerca binaria, ricerca binaria
tende ad essere più veloce di ricerca lineare.

359
00:16:08,150 --> 00:16:11,120
Detto che--
così, una cosa possibile

360
00:16:11,120 --> 00:16:13,380
è che non si può fare binario
cercare liste concatenate,

361
00:16:13,380 --> 00:16:14,730
si può fare solo su array.

362
00:16:14,730 --> 00:16:18,030
Ma probabilmente ancora più importante,
non si può fare ricerca binaria

363
00:16:18,030 --> 00:16:20,690
su una matrice che non è ordinato.

364
00:16:20,690 --> 00:16:23,990
Upfront potrebbe essere necessario ordinare
l'array, e solo allora può

365
00:16:23,990 --> 00:16:25,370
fate la ricerca binaria.

366
00:16:25,370 --> 00:16:27,660
Quindi, se la vostra passione non è
ordinato per cominciare,

367
00:16:27,660 --> 00:16:29,250
poi ricerca lineare potrebbe essere più veloce.

368
00:16:29,250 --> 00:16:30,620

369
00:16:30,620 --> 00:16:31,740
>> Domanda 27.

370
00:16:31,740 --> 00:16:34,770
Quindi prendere in considerazione il programma qui di seguito,
che sarà nella diapositiva successiva.

371
00:16:34,770 --> 00:16:37,790
E questo è quello dove siamo
andando a voler dichiarare esplicitamente

372
00:16:37,790 --> 00:16:39,980
i valori per le diverse variabili.

373
00:16:39,980 --> 00:16:41,990
Quindi diamo un'occhiata a questo.

374
00:16:41,990 --> 00:16:43,160
>> Così la linea uno.

375
00:16:43,160 --> 00:16:45,457
Abbiamo int x è uguale a 1.

376
00:16:45,457 --> 00:16:47,040
Questa è l'unica cosa che è successo.

377
00:16:47,040 --> 00:16:50,440
Quindi in linea uno, vediamo nel nostro
tavolo, che y, a, b, e TMP sono tutti

378
00:16:50,440 --> 00:16:51,540
oscurati.

379
00:16:51,540 --> 00:16:52,280
Così che cosa è x?

380
00:16:52,280 --> 00:16:53,860
Beh, abbiamo appena impostato è pari a 1.

381
00:16:53,860 --> 00:16:55,020

382
00:16:55,020 --> 00:16:58,770
E poi la linea due, beh,
vediamo che y è impostato su 2,

383
00:16:58,770 --> 00:17:00,550
e la tabella è già
compilato per noi.

384
00:17:00,550 --> 00:17:03,040
Quindi x è 1 e y è 2.

385
00:17:03,040 --> 00:17:05,890
>> Ora, la linea a tre, ora siamo
all'interno della funzione di scambio.

386
00:17:05,890 --> 00:17:07,560
Cosa abbiamo passiamo a scambiare?

387
00:17:07,560 --> 00:17:11,609
Passammo commerciale x per
una e commerciale y per b.

388
00:17:11,609 --> 00:17:15,160
Nei casi in cui il problema precedente
affermato che l'indirizzo di x

389
00:17:15,160 --> 00:17:17,520
è 0x10, e l'indirizzo di y è 0x14.

390
00:17:17,520 --> 00:17:18,970

391
00:17:18,970 --> 00:17:21,909
Quindi a e b sono pari a
0x10 e 0x14, rispettivamente.

392
00:17:21,909 --> 00:17:23,670

393
00:17:23,670 --> 00:17:26,250
>> Ora in linea tre, quali sono x e y?

394
00:17:26,250 --> 00:17:28,554
Beh, non è cambiato nulla
merito xey a questo punto.

395
00:17:28,554 --> 00:17:30,470
Anche se sono
all'interno di una stack frame principale,

396
00:17:30,470 --> 00:17:32,469
hanno ancora la stessa
I valori hanno fatto prima.

397
00:17:32,469 --> 00:17:34,030
Non abbiamo modificato la memoria.

398
00:17:34,030 --> 00:17:35,710
Quindi x è 1, y 2.

399
00:17:35,710 --> 00:17:36,550

400
00:17:36,550 --> 00:17:37,050
Bene.

401
00:17:37,050 --> 00:17:40,300
Così ora abbiamo detto int tmp pari ad una stella.

402
00:17:40,300 --> 00:17:44,410
Così alla linea a quattro, tutto
è la stessa tranne tmp.

403
00:17:44,410 --> 00:17:47,130
Non abbiamo cambiato i valori
di qualsiasi cosa tranne che per tmp.

404
00:17:47,130 --> 00:17:49,230
Stiamo allestendo tmp pari ad una stella.

405
00:17:49,230 --> 00:17:50,620
Che cosa è una stella?

406
00:17:50,620 --> 00:17:56,240
Beh, un punti di x, così una stella
sta per la parità di x, che è 1.

407
00:17:56,240 --> 00:18:00,080
Quindi tutto è copiato
verso il basso, e tmp è impostato su 1.

408
00:18:00,080 --> 00:18:01,110
>> Ora la riga successiva.

409
00:18:01,110 --> 00:18:03,380
Stella è uguale a una stella b.

410
00:18:03,380 --> 00:18:10,000
Quindi, linea five-- di nuovo bene, tutto
è lo stesso, tranne qualunque stella a è.

411
00:18:10,000 --> 00:18:10,830
Che cosa è una stella?

412
00:18:10,830 --> 00:18:13,720
Beh, abbiamo appena detto una stella è x.

413
00:18:13,720 --> 00:18:16,400
Quindi stiamo cambiando x alla parità di stelle b.

414
00:18:16,400 --> 00:18:18,960
Che cos'è stelle b? y. b indica y.

415
00:18:18,960 --> 00:18:21,030
Quindi stelle b è y.

416
00:18:21,030 --> 00:18:25,140
Quindi stiamo impostando x uguale ay,
e tutto il resto è lo stesso.

417
00:18:25,140 --> 00:18:29,130
Così vediamo nella riga successiva che x ora è
2, e il resto sono appena copiato verso il basso.

418
00:18:29,130 --> 00:18:31,120
>> Ora, nella riga successiva, stella b è uguale tmp.

419
00:18:31,120 --> 00:18:34,740
Beh, abbiamo appena detto stella b è y,
quindi stiamo impostando y pari a tmp.

420
00:18:34,740 --> 00:18:37,450
Tutto il resto è lo stesso,
quindi tutto viene copiato verso il basso.

421
00:18:37,450 --> 00:18:42,050
Stiamo impostando y pari a tmp, che è
uno, e tutto il resto è lo stesso.

422
00:18:42,050 --> 00:18:43,210
>> Ora finalmente, linea sette.

423
00:18:43,210 --> 00:18:44,700
Siamo di nuovo nella funzione principale.

424
00:18:44,700 --> 00:18:46,350
Siamo dopo di swap è finito.

425
00:18:46,350 --> 00:18:48,972
Abbiamo perso a, b, e
tmp, ma alla fine siamo

426
00:18:48,972 --> 00:18:51,180
Non cambiano i valori
niente a questo punto,

427
00:18:51,180 --> 00:18:52,800
dobbiamo solo copiare x e y verso il basso.

428
00:18:52,800 --> 00:18:56,490
E vediamo che x e y sono
ora 2 e 1 invece di 1 e 2.

429
00:18:56,490 --> 00:18:58,160
Lo swap è stato eseguito con successo.

430
00:18:58,160 --> 00:18:59,500

431
00:18:59,500 --> 00:19:00,105
>> Domanda 28.

432
00:19:00,105 --> 00:19:01,226

433
00:19:01,226 --> 00:19:03,100
Supponiamo che si incontrano
i messaggi di errore

434
00:19:03,100 --> 00:19:06,790
di seguito durante l'orario di ufficio
l'anno prossimo come CA o TF.

435
00:19:06,790 --> 00:19:08,930
Consiglia come risolvere ciascuno di questi errori.

436
00:19:08,930 --> 00:19:11,160
Così undefined reference to GetString.

437
00:19:11,160 --> 00:19:12,540
Perché si potrebbe vedere questo?

438
00:19:12,540 --> 00:19:15,380
Beh, se uno studente sta usando
GetString nel loro codice,

439
00:19:15,380 --> 00:19:20,310
hanno correttamente hash incluso CS50
dot h per includere la libreria CS50.

440
00:19:20,310 --> 00:19:22,380
>> Ebbene, che cosa
bisogno di correggere questo errore?

441
00:19:22,380 --> 00:19:26,810
Hanno bisogno di fare un lcs50 trattino al
riga di comando quando sono la compilazione.

442
00:19:26,810 --> 00:19:29,501
Quindi, se non passano
clang trattino lcs50, sono

443
00:19:29,501 --> 00:19:32,000
non andando ad avere l'attuale
codice che implementa GetString.

444
00:19:32,000 --> 00:19:33,190

445
00:19:33,190 --> 00:19:34,170
>> Domanda 29.

446
00:19:34,170 --> 00:19:36,190
Implicitamente dichiara
funzione di libreria strlen.

447
00:19:36,190 --> 00:19:37,550

448
00:19:37,550 --> 00:19:40,360
Bene adesso, che non ha
fatto la corretta hash includere.

449
00:19:40,360 --> 00:19:41,440

450
00:19:41,440 --> 00:19:45,410
In questo caso particolare, il file di intestazione
hanno bisogno di includere è stringa dot h,

451
00:19:45,410 --> 00:19:48,710
e compresa una stringa punto h, ora
il student-- ora il compilatore

452
00:19:48,710 --> 00:19:51,750
ha accesso al
dichiarazioni di strlen,

453
00:19:51,750 --> 00:19:54,120
e si sa che il codice
sta usando correttamente strlen.

454
00:19:54,120 --> 00:19:55,380

455
00:19:55,380 --> 00:19:56,580
>> Domanda 30.

456
00:19:56,580 --> 00:20:00,240
Più conversioni per cento
di argomenti di dati.

457
00:20:00,240 --> 00:20:01,540
Così che cosa è questo?

458
00:20:01,540 --> 00:20:06,470
Bene ricordare che queste cento
signs-- come sono rilevanti per printf.

459
00:20:06,470 --> 00:20:08,890
Quindi, in printf potremmo percent--
potremmo stampare qualcosa

460
00:20:08,890 --> 00:20:11,380
come cento i backslash n.

461
00:20:11,380 --> 00:20:15,310
Oppure potremmo stampare come i cento,
spazio, cento i, spazio, cento i.

462
00:20:15,310 --> 00:20:18,950
Quindi, per ciascuno di detti
segni di percentuale, abbiamo bisogno di

463
00:20:18,950 --> 00:20:21,560
per passare una variabile alla fine del printf.

464
00:20:21,560 --> 00:20:26,980
>> Quindi se diciamo paren printf per cento
i backslash n stretti paren,

465
00:20:26,980 --> 00:20:30,270
beh, diciamo che siamo
andare in stampa un numero intero,

466
00:20:30,270 --> 00:20:33,970
ma poi noi non passiamo printf
un numero intero da stampare in realtà.

467
00:20:33,970 --> 00:20:37,182
Quindi, qui più per cento
conversioni di argomenti di dati?

468
00:20:37,182 --> 00:20:39,390
Che sta dicendo che abbiamo
un sacco di percentuali,

469
00:20:39,390 --> 00:20:42,445
e noi non abbiamo abbastanza variabili
di compilare in realtà in quelle percentuali.

470
00:20:42,445 --> 00:20:44,850

471
00:20:44,850 --> 00:20:50,010
>> E poi sicuramente, per la domanda 31,
definitivamente perso 40 byte in una blocchi.

472
00:20:50,010 --> 00:20:52,350
Quindi questo è un errore Valgrind.

473
00:20:52,350 --> 00:20:54,720
Questo sta dicendo che
da qualche parte nel codice,

474
00:20:54,720 --> 00:20:59,010
si dispone di una dotazione che è di 40
byte di grandi dimensioni in modo da malloced 40 byte,

475
00:20:59,010 --> 00:21:00,515
e non avete mai liberato esso.

476
00:21:00,515 --> 00:21:02,480

477
00:21:02,480 --> 00:21:05,140
Molto probabilmente è sufficiente
di trovare qualche perdita di memoria,

478
00:21:05,140 --> 00:21:07,650
e scoprire dove è necessario
liberare il blocco di memoria.

479
00:21:07,650 --> 00:21:08,780

480
00:21:08,780 --> 00:21:11,910
>> E mettere in discussione 32,
scrittura non valido di dimensioni 4.

481
00:21:11,910 --> 00:21:13,250
Anche in questo caso si tratta di un errore di Valgrind.

482
00:21:13,250 --> 00:21:15,440
Ciò non deve fare
con perdite di memoria ora.

483
00:21:15,440 --> 00:21:20,750
Questo è, più likely-- voglio dire, è
una sorta di diritti di memoria non validi.

484
00:21:20,750 --> 00:21:23,270
E molto probabilmente questo è un po '
sorta di buffer overflow.

485
00:21:23,270 --> 00:21:26,560
Nei casi in cui si dispone di una matrice, forse
un array di interi, e cerchiamo di

486
00:21:26,560 --> 00:21:30,115
dicono che è di dimensione 5, e si
provate a toccare la staffa serie 5.

487
00:21:30,115 --> 00:21:34,150
Quindi, se si tenta di scrivere in quella
valore, che non è un pezzo di memoria

488
00:21:34,150 --> 00:21:37,440
che in realtà ha accesso a, e
così si sta andando ad ottenere questo errore,

489
00:21:37,440 --> 00:21:39,272
dicendo di scrittura non valido di dimensioni 4.

490
00:21:39,272 --> 00:21:42,480
Valgrind sta andando a riconoscere che sei
cercando di toccare la memoria in modo inappropriato.

491
00:21:42,480 --> 00:21:43,980
>> E questo è tutto per quiz0.

492
00:21:43,980 --> 00:21:47,065
Sono Rob Bowden, e questo è CS50.

493
00:21:47,065 --> 00:21:51,104