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

2
00:00:09,572 --> 00:00:12,030
ROB BOWDEN: Bună, eu sunt Rob Bowden,
și hai să vorbim despre quiz0.

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

4
00:00:13,280 --> 00:00:14,545
>> Așa că, la prima întrebare.

5
00:00:14,545 --> 00:00:17,750
Aceasta este întrebarea în cazul în care
ai nevoie pentru a coda numărul

6
00:00:17,750 --> 00:00:21,270
127 din becurile binare.

7
00:00:21,270 --> 00:00:23,550
Dacă ți-ai dorit, ai putea
face conversia regulat

8
00:00:23,550 --> 00:00:25,950
din bi-- sau, din zecimal în binar.

9
00:00:25,950 --> 00:00:28,300
Dar asta e, probabil, va
pentru a lua o mulțime de timp.

10
00:00:28,300 --> 00:00:31,750
Adică, ai putea da seama că,
OK, 1 este acolo, 2 este acolo,

11
00:00:31,750 --> 00:00:33,650
4 este acolo, 8 este acolo.

12
00:00:33,650 --> 00:00:39,280
Cale mai ușoară, 127 este de 128 minus unul.

13
00:00:39,280 --> 00:00:42,013
Că bec stânga este de 128 de biți.

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

15
00:00:43,490 --> 00:00:47,860
Deci, 127 este de fapt doar tot
de alte becuri,

16
00:00:47,860 --> 00:00:51,420
din moment ce e cel mai din stânga
bec minus 1.

17
00:00:51,420 --> 00:00:52,800
Asta e pentru această întrebare.

18
00:00:52,800 --> 00:00:54,060
>> Întrebarea unul.

19
00:00:54,060 --> 00:00:56,710
Deci, cu 3 biți poți
reprezintă 8 valori distincte.

20
00:00:56,710 --> 00:01:01,000
De ce, atunci, este de 7 cel mai mare non-negativ
număr întreg zecimal puteți reprezenta?

21
00:01:01,000 --> 00:01:04,050
Ei bine, dacă putem doar
reprezintă 8 valori distincte,

22
00:01:04,050 --> 00:01:07,430
atunci ce vom fi
reprezentând este de la 0 la 7.

23
00:01:07,430 --> 00:01:08,745
0 preia una din valorile.

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

25
00:01:09,980 --> 00:01:11,190
>> Întrebarea a doua.

26
00:01:11,190 --> 00:01:14,610
Cu n biți, câte distinct
Valorile puteți reprezenta?

27
00:01:14,610 --> 00:01:19,080
Așa că, cu n biți, aveți 2
Valorile posibile pentru fiecare bit.

28
00:01:19,080 --> 00:01:22,300
Deci avem două valori posibile pentru
primul bit, 2 valori posibile

29
00:01:22,300 --> 00:01:24,450
pentru a doua, 2
posibil pentru a treia.

30
00:01:24,450 --> 00:01:28,730
Și așa încât e de 2 ori de 2 ori 2, și
în cele din urmă răspunsul este 2 n.

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

32
00:01:30,010 --> 00:01:31,100
>> Întrebarea trei.

33
00:01:31,100 --> 00:01:33,450
Ce este 0x50 în binar?

34
00:01:33,450 --> 00:01:39,490
Deci, amintiți-vă că hexazecimal are o foarte
conversie simplu la binar.

35
00:01:39,490 --> 00:01:43,180
Deci, aici, trebuie doar să se uite la
5 și 0 independent.

36
00:01:43,180 --> 00:01:45,110
Deci, ce e de 5 în binar?

37
00:01:45,110 --> 00:01:48,400
0101, care este de 1 bit si 4 biți.

38
00:01:48,400 --> 00:01:49,900
Ce este 0 în binar?

39
00:01:49,900 --> 00:01:50,520
Nu este complicat.

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

41
00:01:52,180 --> 00:01:54,970
Deci, doar le-a pus împreună, și
care este numărul complet în binar.

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

43
00:01:57,640 --> 00:02:00,439
Și dacă ai vrut ai putea
decolare, care stânga zero.

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

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

46
00:02:02,920 --> 00:02:05,733
>> Așa că atunci alternativ,
ceea ce este 0x50 în zecimal?

47
00:02:05,733 --> 00:02:08,649
Dacă ți-ai dorit, ai putea-- daca esti
mai confortabil cu binar,

48
00:02:08,649 --> 00:02:11,340
ai putea lua ca răspuns binar
și de a converti că în zecimal.

49
00:02:11,340 --> 00:02:13,870
Sau am putea aminti doar
că hexazecimal.

50
00:02:13,870 --> 00:02:21,140
Astfel că 0 este în loc de 0-lea, și
5 este în 16 de primul loc.

51
00:02:21,140 --> 00:02:25,990
Deci, aici, avem 5 ori 16 la
în primul rând, plus 0 ori 16 la zero,

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

53
00:02:27,520 --> 00:02:29,710
Și dacă uitat la
titlu la întrebarea,

54
00:02:29,710 --> 00:02:32,920
a fost CS-80, care a fost un fel de
indiciu pentru răspunsul la această problemă.

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

56
00:02:34,460 --> 00:02:35,420
>> Întrebarea cinci.

57
00:02:35,420 --> 00:02:40,320
Avem acest scenariu Scratch, care este
repetând de 4 ori unt de arahide jeleu.

58
00:02:40,320 --> 00:02:42,800
Deci, cum facem noi acum, cod care in C?

59
00:02:42,800 --> 00:02:47,730
Ei bine, avem here-- partea cu caractere aldine
este doar o parte a trebuit să pună în aplicare.

60
00:02:47,730 --> 00:02:51,950
Deci, avem o buclă de 4 care este looping 4
ori,-printf ING unt de arahide jeleu,

61
00:02:51,950 --> 00:02:53,910
cu noua linie ca problema cere.

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

63
00:02:55,250 --> 00:02:57,490
>> Întrebarea șase, o altă problemă Scratch.

64
00:02:57,490 --> 00:03:00,210
Vedem că suntem într-o buclă pentru totdeauna.

65
00:03:00,210 --> 00:03:05,000
Noi spunem i variabil
și apoi incrementarea i cu 1.

66
00:03:05,000 --> 00:03:09,580
Acum vrem să facem acest lucru în C. Nu sunt
mai multe moduri am fi putut face acest lucru.

67
00:03:09,580 --> 00:03:12,840
Aici ne sa întâmplat cu cod
pentru totdeauna buclă ca un timp (adevărat).

68
00:03:12,840 --> 00:03:16,600
Așa că am declara variabila i, doar
ca și cum am avut eu variabil în Scratch.

69
00:03:16,600 --> 00:03:21,950
Declara i variabil, și pentru totdeauna
în timp ce (adevărat), spunem variabila i.

70
00:03:21,950 --> 00:03:25,260
Deci, printf% Eu-- sau ai fi putut folosi in% d.

71
00:03:25,260 --> 00:03:27,985
Spunem că variabila, și
apoi incrementarea, i ++.

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

73
00:03:29,560 --> 00:03:30,830
>> Întrebarea șapte.

74
00:03:30,830 --> 00:03:35,560
Acum vrem să facem ceva foarte asemănător
la Mario punct c din problemă seta o.

75
00:03:35,560 --> 00:03:39,110
Vrem să imprimați aceste hashtags,
vrem să imprimați o perioada de cinci

76
00:03:39,110 --> 00:03:40,700
de trei dreptunghi de aceste hash-uri.

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

78
00:03:41,770 --> 00:03:43,162
Deci, cum vom face asta?

79
00:03:43,162 --> 00:03:45,370
Ei bine, am să vă dau un întreg
buchet de cod, și tu doar

80
00:03:45,370 --> 00:03:47,560
trebuie să completeze în funcția de rețea de imprimare.

81
00:03:47,560 --> 00:03:49,540
>> Deci, ce se PrintGrid arata?

82
00:03:49,540 --> 00:03:51,480
Ei bine, tu ești trecut
lățime și înălțime.

83
00:03:51,480 --> 00:03:53,520
Deci, avem un exterior 4
buclă, care este looping

84
00:03:53,520 --> 00:03:57,650
peste toate rândurile prezentei
grilă pe care dorim să imprime.

85
00:03:57,650 --> 00:04:01,250
Apoi avem inter-cuibărit 4 bucla,
asta e imprimarea pe fiecare coloană.

86
00:04:01,250 --> 00:04:06,210
Deci, pentru fiecare rând, ne-am imprimat pentru
fiecare coloană, un singur hash.

87
00:04:06,210 --> 00:04:10,045
Apoi, la sfârșitul rândului ne imprima o
line nou single pentru a trece la rândul următor.

88
00:04:10,045 --> 00:04:11,420
Și asta e pentru toată rețeaua.

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

90
00:04:12,810 --> 00:04:13,675
>> Întrebarea opt.

91
00:04:13,675 --> 00:04:17,170
O funcție ca PrintGrid este declarat a
avea un efect secundar, dar nu o întoarcere

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

93
00:04:17,670 --> 00:04:19,209
Explică diferența.

94
00:04:19,209 --> 00:04:23,080
Deci, acest lucru se bazează pe tine amintindu-
ceea ce un efect secundar este.

95
00:04:23,080 --> 00:04:25,180
Ei bine, o întoarcere value--
știm PrintGrid nu

96
00:04:25,180 --> 00:04:28,180
au o valoare întoarcere, întrucât
aici se spune anulate.

97
00:04:28,180 --> 00:04:31,150
Deci, ceva care returnează void
nu se întoarce într-adevăr nimic.

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

99
00:04:32,200 --> 00:04:33,620
Deci, ce este efectul secundar?

100
00:04:33,620 --> 00:04:36,620
Ei bine, un efect secundar este
ceva la fel de bine persistă

101
00:04:36,620 --> 00:04:39,500
după terminarea funcției
că nu a fost tocmai sa întors,

102
00:04:39,500 --> 00:04:41,340
și nu a fost doar de la intrările.

103
00:04:41,340 --> 00:04:44,970
>> Așa că, de exemplu, am putea
a schimba o variabilă globală.

104
00:04:44,970 --> 00:04:46,590
Asta ar fi un efect secundar.

105
00:04:46,590 --> 00:04:49,000
În acest caz particular, o
efect secundar foarte important

106
00:04:49,000 --> 00:04:51,070
se imprimă pe ecran.

107
00:04:51,070 --> 00:04:53,110
Astfel că este un efect secundar
care PrintGrid are.

108
00:04:53,110 --> 00:04:54,980
Noi imprimam aceste lucruri pe ecran.

109
00:04:54,980 --> 00:04:56,370
Și vă puteți gândi
care ca un efect secundar,

110
00:04:56,370 --> 00:04:58,690
din moment ce asta e ceva care
persistă după ce această funcție se termină.

111
00:04:58,690 --> 00:05:01,481
Asta e ceva în afara domeniului de aplicare
din această funcție care în cele din urmă

112
00:05:01,481 --> 00:05:03,380
se schimbă,
conținutul ecranului.

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

114
00:05:05,200 --> 00:05:05,839
>> Întrebare nouă.

115
00:05:05,839 --> 00:05:07,880
Luați în considerare programul de mai jos,
pentru care numerele de linie

116
00:05:07,880 --> 00:05:09,740
au fost adăugate pentru
dragul discuției.

117
00:05:09,740 --> 00:05:13,480
Deci, în acest program, suntem doar
de asteptare getString, depozita

118
00:05:13,480 --> 00:05:16,220
în acest s variabile, iar apoi
imprimarea că variabila s.

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

120
00:05:16,720 --> 00:05:19,090
Deci, explica de ce este prezentă linia unu.

121
00:05:19,090 --> 00:05:20,920
#include CS50 punct de ore.

122
00:05:20,920 --> 00:05:23,820
De ce avem nevoie pentru a #include CS50 punct de ore?

123
00:05:23,820 --> 00:05:26,180
Ei bine, suntem de asteptare
Funcția getString,

124
00:05:26,180 --> 00:05:28,840
și getString este definită
în bibliotecă CS50.

125
00:05:28,840 --> 00:05:31,600
Deci, dacă nu am avea
#include CS50 punct de ore,

126
00:05:31,600 --> 00:05:35,760
ne-ar lua această declarație implicită
de eroare funcției getString

127
00:05:35,760 --> 00:05:36,840
de compilator.

128
00:05:36,840 --> 00:05:40,110
Așa că trebuie să includă library--
trebuie să includă fișierul header,

129
00:05:40,110 --> 00:05:42,870
sau altfel compilatorul nu va
recunosc că getString există.

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

131
00:05:44,380 --> 00:05:46,140
>> Explicați de ce este prezentă linia doi.

132
00:05:46,140 --> 00:05:47,890
Deci, standard, io punct de ore.

133
00:05:47,890 --> 00:05:50,430
Este exact la fel
ca problema anterioară,

134
00:05:50,430 --> 00:05:53,310
cu excepția în loc de a face cu
GetString, vorbim despre printf.

135
00:05:53,310 --> 00:05:56,654
Deci, dacă nu am spune că am nevoie
pentru a include standard, io punct de ore,

136
00:05:56,654 --> 00:05:58,820
atunci nu ar fi capabil
pentru a utiliza funcția printf,

137
00:05:58,820 --> 00:06:00,653
deoarece compilatorul
nu ar ști despre asta.

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

139
00:06:01,750 --> 00:06:05,260
>> Why-- ceea ce este semnificația
de drept, în linie cu patru?

140
00:06:05,260 --> 00:06:08,010
Deci, aici avem int main (void).

141
00:06:08,010 --> 00:06:10,600
Asta e doar spune că am
nu primesc nici o linie de comandă

142
00:06:10,600 --> 00:06:12,280
argumente în principal.

143
00:06:12,280 --> 00:06:17,390
Amintiți-vă că am putea spune int
Principalele int argc paranteze șir argv.

144
00:06:17,390 --> 00:06:20,400
Deci, aici suntem doar spunem anulate la spunem
ignoră argumente în linia de comandă.

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

146
00:06:21,840 --> 00:06:25,225
>> Explicați, în ceea ce privește memoria, exact
ceea ce getString în linie șase întoarce.

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

148
00:06:27,040 --> 00:06:31,640
GetString se întoarce un bloc de
memorie, o serie de caractere.

149
00:06:31,640 --> 00:06:34,870
Este într-adevăr întoarce o
pointer la primul caracter.

150
00:06:34,870 --> 00:06:37,170
Amintiți-vă că un șir este o stea char.

151
00:06:37,170 --> 00:06:41,360
Deci s este un pointer la primul
personaj în orice șirul este

152
00:06:41,360 --> 00:06:43,510
că utilizatorul a introdus de la tastatura.

153
00:06:43,510 --> 00:06:47,070
Și asta se întâmplă de memorie să fie malloced,
astfel că memoria este în heap.

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

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

156
00:06:50,450 --> 00:06:51,960
Luați în considerare programul de mai jos.

157
00:06:51,960 --> 00:06:55,579
Deci, tot acest program este de a face
este printf-ing 1 împărțit la 10.

158
00:06:55,579 --> 00:06:57,370
Deci, atunci când sunt compilate și
executat, acest program

159
00:06:57,370 --> 00:07:01,170
iesiri 0.0, chiar dacă
1 împărțit la 10 este de 0,1.

160
00:07:01,170 --> 00:07:02,970
Deci, ce este de 0.0?

161
00:07:02,970 --> 00:07:05,510
Ei bine, acest lucru se datorează faptului că
de diviziune număr întreg.

162
00:07:05,510 --> 00:07:08,580
Deci 1 este un număr întreg, 10 este un număr întreg.

163
00:07:08,580 --> 00:07:11,980
Deci, 1 împărțit la 10, tot
este tratată ca numere întregi,

164
00:07:11,980 --> 00:07:16,380
și în C, atunci când facem diviziune număr întreg,
am trunchia orice punct zecimal.

165
00:07:16,380 --> 00:07:19,590
Deci, 1 împărțit la 10 este
0, iar apoi încercăm

166
00:07:19,590 --> 00:07:24,410
pentru a imprima ca pe un flotor, așa
zero, tipărite ca un float este 0.0.

167
00:07:24,410 --> 00:07:27,400
Și de aceea avem 0,0.

168
00:07:27,400 --> 00:07:28,940
>> Luați în considerare programul de mai jos.

169
00:07:28,940 --> 00:07:31,280
Acum suntem imprimare 0.1.

170
00:07:31,280 --> 00:07:34,280
Deci, nici o diviziune număr întreg,
suntem doar 0,1 imprimare,

171
00:07:34,280 --> 00:07:37,100
dar suntem o imprimare
la 28 de zecimale.

172
00:07:37,100 --> 00:07:41,810
Și am obține acest 0.1000, o grămadă
de zerouri, 5 5 5, bla bla bla.

173
00:07:41,810 --> 00:07:45,495
Deci, intrebarea aici este de ce o face
imprima că, în loc de exact 0,1?

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

175
00:07:46,620 --> 00:07:49,640
>> Deci, motivul pentru care aici este acum
virgulă mobilă imprecizie.

176
00:07:49,640 --> 00:07:53,410
Amintiți-vă că un flotor este de numai 32 de biți.

177
00:07:53,410 --> 00:07:57,540
Astfel încât să putem reprezenta doar un număr finit
de plutitoare valorile punctelor cu cele 32

178
00:07:57,540 --> 00:07:58,560
biți.

179
00:07:58,560 --> 00:08:01,760
Ei bine, nu e în cele din urmă la infinit
multe valori în virgulă mobilă,

180
00:08:01,760 --> 00:08:04,940
și nu există infinit de multe plutitor
Valorile în puncte în între 0 și 1,

181
00:08:04,940 --> 00:08:07,860
și suntem în mod evident în măsură să
reprezintă chiar mai multe valori decât asta.

182
00:08:07,860 --> 00:08:13,230
Deci, avem de a face sacrificii pentru a
fie în măsură să reprezinte cele mai multe valori.

183
00:08:13,230 --> 00:08:16,960
>> Deci, o valoare cum ar fi 0,1, aparent
nu putem reprezenta asta exact.

184
00:08:16,960 --> 00:08:22,500
Deci, în loc de a reprezenta 0,1 facem
cel mai bun putem reprezenta această 0.100000 5 5

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

186
00:08:23,260 --> 00:08:26,306
Și asta e destul de aproape, dar
pentru o mulțime de aplicații

187
00:08:26,306 --> 00:08:28,430
va trebui să vă faceți griji cu privire la
virgulă mobilă imprecizie,

188
00:08:28,430 --> 00:08:30,930
pentru că nu ne putem reprezenta
exact toate punctele de flotant.

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

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

191
00:08:33,380 --> 00:08:34,679
Luați în considerare codul de mai jos.

192
00:08:34,679 --> 00:08:36,630
Noi doar de imprimare 1 plus 1.

193
00:08:36,630 --> 00:08:38,289
Deci, nu există nici un truc aici.

194
00:08:38,289 --> 00:08:41,780
1 plus 1 este evaluată la 2, și
atunci suntem imprimare asta.

195
00:08:41,780 --> 00:08:42,789
Tipărește numai 2.

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

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

198
00:08:44,700 --> 00:08:49,450
Acum suntem imprimare caracterul
1 plus caracterul 1.

199
00:08:49,450 --> 00:08:52,110
Deci, de ce face acest lucru nu
imprima același lucru?

200
00:08:52,110 --> 00:08:57,680
Ei bine, personajul 1 plus caracterul
1, personajul 1 are o valoare ASCII 49.

201
00:08:57,680 --> 00:09:04,840
Deci, acest lucru este într-adevăr spune 49 plus 49, și
în cele din urmă acest lucru se întâmplă pentru a imprima 98.

202
00:09:04,840 --> 00:09:06,130
Deci, acest lucru nu se imprimă 2.

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

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

205
00:09:09,271 --> 00:09:11,520
Finalizarea procesului de punere în aplicare
de impar de mai jos într-un mod

206
00:09:11,520 --> 00:09:14,615
că funcția returnează true dacă
n este impar și fals în cazul în care n este chiar.

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

208
00:09:16,710 --> 00:09:19,330
Acesta este un scop mare
pentru operator mod.

209
00:09:19,330 --> 00:09:24,530
Deci, luăm argument n noastră,
dacă n mod 2 este egal cu 1, și

210
00:09:24,530 --> 00:09:28,030
ceea ce înseamnă că n divizat
de 2 a avut un rest.

211
00:09:28,030 --> 00:09:33,270
Dacă n împărțit la 2 a avut un rest, care
înseamnă că n este impar, deci ne întoarcem adevărat.

212
00:09:33,270 --> 00:09:34,910
Altfel ne vom întoarce false.

213
00:09:34,910 --> 00:09:39,070
De asemenea, ar fi putut face n MOD 2 egali
la zero, return false, altfel return true.

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

215
00:09:41,600 --> 00:09:43,640
>> Luați în considerare funcția recursiv de mai jos.

216
00:09:43,640 --> 00:09:46,920
Deci, dacă n este mai mic sau
egală cu 1, se întoarcă 1,

217
00:09:46,920 --> 00:09:50,430
întoarcere altceva de n ori f de n minus 1.

218
00:09:50,430 --> 00:09:52,556
Deci, ce este această funcție?

219
00:09:52,556 --> 00:09:54,305
Ei bine, acesta este doar
funcția factorial.

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

221
00:09:55,410 --> 00:09:57,405
Acest lucru este frumos reprezentat
ar fi n factorial.

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

223
00:09:58,720 --> 00:10:02,310
>> Deci, întrebarea 19 acum, vrem să
să ia această funcție recursive.

224
00:10:02,310 --> 00:10:04,530
Vrem să-l iterativ.

225
00:10:04,530 --> 00:10:05,874
Deci, cum facem asta?

226
00:10:05,874 --> 00:10:07,790
Ei bine, pentru personalul
soluție, și din nou, nu e

227
00:10:07,790 --> 00:10:11,090
mai multe moduri în care ar fi putut face
că, vom începe cu acest produs int

228
00:10:11,090 --> 00:10:11,812
egal cu 1.

229
00:10:11,812 --> 00:10:13,520
Și în toată această
pentru bucla, vom

230
00:10:13,520 --> 00:10:17,590
care urmează să fie produs la înmulțirea în cele din urmă
încheia cu factorialul complet.

231
00:10:17,590 --> 00:10:21,870
Deci, pentru int i este egal cu 2, i este
mai mică sau egală cu n, i ++.

232
00:10:21,870 --> 00:10:24,130
>> S-ar putea fi mirat de ce i este egal cu 2.

233
00:10:24,130 --> 00:10:28,380
Ei bine, amintiți-vă că aici avem de a
asigurați-vă cazul nostru de bază este corectă.

234
00:10:28,380 --> 00:10:32,180
Deci, dacă n este mai mic sau egal
la 1, noi suntem doar revenirea 1.

235
00:10:32,180 --> 00:10:34,830
Deci, aici, vom începe la i este egal cu 2.

236
00:10:34,830 --> 00:10:39,090
Ei bine, dacă i s-au 1, atunci the-- sau
dacă n-au fost cu 1, atunci pentru buclă

237
00:10:39,090 --> 00:10:40,600
nu s-ar executa deloc.

238
00:10:40,600 --> 00:10:43,190
Și așa ne-ar pur și simplu
produs întoarcere, care este 1.

239
00:10:43,190 --> 00:10:45,920
În mod similar, în cazul în care n-au
nimic mai puțin decât 1--

240
00:10:45,920 --> 00:10:49,290
în cazul în care au fost de 0, 1 negativ, whatever--
am fi mai întoarce 1,

241
00:10:49,290 --> 00:10:52,260
care este exact ceea ce
Versiunea recursiv este de a face.

242
00:10:52,260 --> 00:10:54,660
>> Acum, dacă n este mai mare
mult de 1, apoi vom merge

243
00:10:54,660 --> 00:10:56,550
de a face cel puțin o
repetare a acestei buclă.

244
00:10:56,550 --> 00:11:00,630
Deci, haideți să spunem n este 5, atunci suntem
de gând să faci ori de produs este egal cu 2.

245
00:11:00,630 --> 00:11:02,165
Deci, acum produs este de 2.

246
00:11:02,165 --> 00:11:04,040
Acum am de gând să faci
ori de produs este egal cu 3.

247
00:11:04,040 --> 00:11:04,690
Acum e 6.

248
00:11:04,690 --> 00:11:07,500
Ori de produs este egal cu 4, acum e 24.

249
00:11:07,500 --> 00:11:10,420
Ori de produs este egal cu 5, acum e de 120.

250
00:11:10,420 --> 00:11:16,730
Deci, atunci în cele din urmă, vom revenind
120, care este corect 5 factorial.

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

252
00:11:17,510 --> 00:11:22,480
Aceasta este cea în care va trebui să completați
în acest tabel cu orice algoritm dat,

253
00:11:22,480 --> 00:11:25,735
nimic din ce am văzut, că
se potrivește acestea centrare algoritmică

254
00:11:25,735 --> 00:11:28,060
ori aceste ori asimptotice termen.

255
00:11:28,060 --> 00:11:33,270
Deci, ce este un algoritm care
este omega de 1, dar O mare de n?

256
00:11:33,270 --> 00:11:35,970
Deci, ar putea exista la infinit
mai multe răspunsuri aici.

257
00:11:35,970 --> 00:11:39,790
Cel pe care l-am văzut, probabil, cel mai
frecvent este doar de căutare liniară.

258
00:11:39,790 --> 00:11:42,050
>> Deci, în cel mai bun caz
scenariu, elementul suntem

259
00:11:42,050 --> 00:11:44,050
căutați este de la
începând din lista

260
00:11:44,050 --> 00:11:47,400
și așa în omega de 1 etapele,
primul lucru pe care îl verifica,

261
00:11:47,400 --> 00:11:49,740
ne-am întoarce imediat
că am găsit elementul.

262
00:11:49,740 --> 00:11:52,189
În cel mai rău caz,
elementul este la sfârșitul anului,

263
00:11:52,189 --> 00:11:53,730
sau elementul nu este în listă, la toate.

264
00:11:53,730 --> 00:11:56,700
Așa că trebuie să caute
întreaga listă, toate n

265
00:11:56,700 --> 00:11:58,480
elemente, și de aceea este o de n.

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

267
00:11:59,670 --> 00:12:04,880
>> Deci, acum este ceva care este atât de
omega de n log n, și O mare de n log n.

268
00:12:04,880 --> 00:12:08,650
Ei bine, lucrul cel mai relevant
am vazut aici este fuziona fel.

269
00:12:08,650 --> 00:12:12,950
Așa că îmbinare sortare, amintiți-vă,
este în cele din urmă Theta

270
00:12:12,950 --> 00:12:16,920
de n log n, unde theta este definit
dacă ambele omega și mari O sunt la fel.

271
00:12:16,920 --> 00:12:17,580
Atât n log n.

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

273
00:12:18,690 --> 00:12:21,970
>> Ce-i ceva care este omega
de n, și O. n pătrat?

274
00:12:21,970 --> 00:12:23,990
Ei bine, din nou, nu e
mai multe răspunsuri posibile.

275
00:12:23,990 --> 00:12:26,440
Aici se întâmplă să spunem bubble sort.

276
00:12:26,440 --> 00:12:28,840
Fel de inserție va lucra, de asemenea, aici.

277
00:12:28,840 --> 00:12:31,400
Amintiți-vă că bubble sort
are ca optimizare în cazul în care,

278
00:12:31,400 --> 00:12:34,630
dacă sunteți în stare să mă
prin întreaga listă

279
00:12:34,630 --> 00:12:37,402
fără a fi nevoie de a face
orice swap-uri, atunci, ei bine,

280
00:12:37,402 --> 00:12:40,110
ne putem întoarce imediat că
lista a fost sortate pentru a începe cu.

281
00:12:40,110 --> 00:12:43,185
Deci, în cel mai bun caz,
e doar omega de n.

282
00:12:43,185 --> 00:12:45,960
În cazul în care nu e doar un frumos
listă pentru a începe cu sortate,

283
00:12:45,960 --> 00:12:48,270
atunci avem de O n pătrat swap-urilor.

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

285
00:12:49,330 --> 00:12:55,610
Și, în sfârșit, ne-am selectie fel
pentru n pătrat, atât omega și mare O.

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

287
00:12:56,850 --> 00:12:58,870
Ce este număr întreg de preaplin?

288
00:12:58,870 --> 00:13:02,160
Ei bine din nou, similar cu mai devreme,
avem doar finit multi biti

289
00:13:02,160 --> 00:13:04,255
pentru a reprezenta un număr întreg,
Deci, poate 32 de biți.

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

291
00:13:06,300 --> 00:13:09,180
Să presupunem că avem un număr întreg semnat.

292
00:13:09,180 --> 00:13:12,800
Cea mai mare apoi în cele din urmă
număr pozitiv putem reprezenta

293
00:13:12,800 --> 00:13:15,910
este de la 2 la 31 minus 1.

294
00:13:15,910 --> 00:13:19,370
Deci, ce se întâmplă dacă încercăm să
apoi incrementarea că întreg?

295
00:13:19,370 --> 00:13:25,320
Ei bine, vom merge de la 2 la 31
minus 1, tot drumul până la negativ 2

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

297
00:13:26,490 --> 00:13:29,470
Deci, această depășire număr întreg este
atunci când vă păstrați incrementare,

298
00:13:29,470 --> 00:13:32,330
și în cele din urmă nu se poate
a lua orice mai mare și doar

299
00:13:32,330 --> 00:13:34,520
inveleste tot drumul înapoi
în jurul valorii de la o valoare negativă.

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

301
00:13:35,850 --> 00:13:37,779
>> Ce zici de un buffer overflow?

302
00:13:37,779 --> 00:13:39,820
Deci, un tampon overflow--
amintesc ce un tampon este.

303
00:13:39,820 --> 00:13:41,000
E doar o bucată de memorie.

304
00:13:41,000 --> 00:13:43,350
Ceva de genul un tablou este un tampon.

305
00:13:43,350 --> 00:13:46,120
Deci, un buffer overflow este atunci când
când încercați să accesați memorie

306
00:13:46,120 --> 00:13:47,880
dincolo de sfârșitul acestei matrice.

307
00:13:47,880 --> 00:13:50,410
Deci, dacă aveți o
matrice de dimensiune 5 și tu

308
00:13:50,410 --> 00:13:53,700
incercati sa accesati in suport matrice
5 sau 6 suport sau suport 7,

309
00:13:53,700 --> 00:13:56,610
sau ceva dincolo
scop, sau chiar nimic

310
00:13:56,610 --> 00:14:00,790
Suport matrice below-- negativ 1--
toți cei care sunt buffer overflow.

311
00:14:00,790 --> 00:14:02,810
Te atinge de memorie într-un mod rău.

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

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

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

315
00:14:05,760 --> 00:14:09,100
Deci, în aceasta aveți nevoie
să pună în aplicare strlen.

316
00:14:09,100 --> 00:14:11,630
Și am să vă spun că puteți
presupune s nu va fi considerat nul,

317
00:14:11,630 --> 00:14:13,790
astfel încât să nu trebuie să
face orice verificare pentru nul.

318
00:14:13,790 --> 00:14:16,190
Și acolo sunt mai multe moduri
ai fi putut face acest lucru.

319
00:14:16,190 --> 00:14:18,440
Aici ne-am lua simplă.

320
00:14:18,440 --> 00:14:21,780
Vom începe cu un contor, n. n este
numărare câte caractere sunt.

321
00:14:21,780 --> 00:14:25,560
Deci, vom începe de la 0, iar apoi ne-am
repeta peste întreaga listă.

322
00:14:25,560 --> 00:14:29,092
>> Este s suport 0 egal cu
null caracter terminator?

323
00:14:29,092 --> 00:14:31,425
Amintiți-vă căutăm
caracterul terminator nul

324
00:14:31,425 --> 00:14:33,360
pentru a determina cât de mult șir noastră este.

325
00:14:33,360 --> 00:14:35,890
Care se va termina
orice șir relevant.

326
00:14:35,890 --> 00:14:39,400
Deci, este s suport 0 egal
pentru terminatorul nul?

327
00:14:39,400 --> 00:14:42,850
În cazul în care nu e, atunci vom
uita-te la s suport 1, s suport 2.

328
00:14:42,850 --> 00:14:45,050
Noi continuăm până când vom
găsi terminatorul nul.

329
00:14:45,050 --> 00:14:48,580
După ce l-am găsit, atunci n conține
lungimea totală a șirului,

330
00:14:48,580 --> 00:14:49,942
și ne putem întoarce doar asta.

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

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

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

334
00:14:53,010 --> 00:14:56,050
Deci, aceasta este cea în care ați
au de a face compromisul.

335
00:14:56,050 --> 00:14:59,810
Deci, un lucru este bun într-o singură
Astfel, dar, în ce mod este rău?

336
00:14:59,810 --> 00:15:02,980
Deci, aici, merge tinde fel de
fi mai rapid decât balon fel.

337
00:15:02,980 --> 00:15:06,530
Acestea fiind spuse that-- bine, acolo
sunt mai multe răspunsuri aici.

338
00:15:06,530 --> 00:15:12,930
Dar cel principal este că bula fel
este omega de n pentru o listă sortat.

339
00:15:12,930 --> 00:15:14,950
>> Amintiți-vă că tabelul tocmai am văzut mai devreme.

340
00:15:14,950 --> 00:15:17,600
Deci, cu bule soiuri omega de
n, cel mai bun scenariu

341
00:15:17,600 --> 00:15:20,010
este capabil de a merge doar peste
lista dată, determina

342
00:15:20,010 --> 00:15:22,270
hei acest lucru este deja
sortate, și retur.

343
00:15:22,270 --> 00:15:25,960
Merge fel, indiferent de ce
ce faci, este omega de n log n.

344
00:15:25,960 --> 00:15:29,200
Deci, pentru lista de sortat, cu bule
sortare va fi mai rapid.

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

346
00:15:30,870 --> 00:15:32,430
>> Acum, ce putem spune despre legată de listele de?

347
00:15:32,430 --> 00:15:36,070
Deci, o listă legat poate să crească și reduce
pentru a se potrivi cât mai multe elemente cum este necesar.

348
00:15:36,070 --> 00:15:38,489
După ce a spus that-- astfel
de obicei, comparația directă

349
00:15:38,489 --> 00:15:40,280
va fi o legătură
lista cu o serie.

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

351
00:15:41,600 --> 00:15:44,050
Deci, chiar dacă matrice poate
să crească ușor și reduce

352
00:15:44,050 --> 00:15:47,130
pentru a se potrivi cât mai multe elemente
după cum este necesar, o listă legată

353
00:15:47,130 --> 00:15:49,600
comparativ cu un un array--
matrice are acces aleator.

354
00:15:49,600 --> 00:15:52,960
Putem index în orice
element particular de matrice.

355
00:15:52,960 --> 00:15:56,430
>> Deci, pentru o listă legat, nu putem
du-te la al cincilea element,

356
00:15:56,430 --> 00:16:00,260
avem de a traversa de la început
până când vom ajunge la al cincilea element.

357
00:16:00,260 --> 00:16:03,990
Și asta ne va împiedica să
a face ceva de genul căutare binar.

358
00:16:03,990 --> 00:16:08,150
Vorbind de căutare binare, căutare binară
tinde să fie mai rapid decât căutarea liniară.

359
00:16:08,150 --> 00:16:11,120
După ce a spus that--
astfel, un singur lucru este posibil

360
00:16:11,120 --> 00:16:13,380
este că nu se poate face binar
cauta pe liste legate,

361
00:16:13,380 --> 00:16:14,730
o poti face doar pe tablouri.

362
00:16:14,730 --> 00:16:18,030
Dar, probabil, mai important,
nu se poate face căutare binare

363
00:16:18,030 --> 00:16:20,690
pe o matrice care nu este sortată.

364
00:16:20,690 --> 00:16:23,990
Avans ați putea avea nevoie pentru a sorta
matrice, și abia apoi se poate

365
00:16:23,990 --> 00:16:25,370
ce faci căutare binară.

366
00:16:25,370 --> 00:16:27,660
Deci, dacă lucru nu este
sortat pentru a începe cu,

367
00:16:27,660 --> 00:16:29,250
apoi căutare liniară ar putea fi mai rapidă.

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

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

370
00:16:31,740 --> 00:16:34,770
Deci, ia în considerare programul de mai jos,
care va fi în slide-ul urmator.

371
00:16:34,770 --> 00:16:37,790
Și acest lucru este cea în care suntem
gând să doriți să precizeze în mod explicit

372
00:16:37,790 --> 00:16:39,980
valorile pentru diverse variabile.

373
00:16:39,980 --> 00:16:41,990
Deci, să ne uităm la asta.

374
00:16:41,990 --> 00:16:43,160
>> Deci, o linie.

375
00:16:43,160 --> 00:16:45,457
Avem int x este egal cu 1.

376
00:16:45,457 --> 00:16:47,040
Asta e singurul lucru care sa întâmplat.

377
00:16:47,040 --> 00:16:50,440
Deci, la o linie, vom vedea în nostru
tabel, că y, a, b, și tmp sunt toate

378
00:16:50,440 --> 00:16:51,540
leșinat.

379
00:16:51,540 --> 00:16:52,280
Deci, ce este x?

380
00:16:52,280 --> 00:16:53,860
Ei bine, ne-am stabilit o egală cu 1.

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

382
00:16:55,020 --> 00:16:58,770
Și apoi linia doi, ei bine,
vom vedea că y este setat la 2,

383
00:16:58,770 --> 00:17:00,550
iar masa este deja
completate pentru noi.

384
00:17:00,550 --> 00:17:03,040
Deci x este 1 și y este 2.

385
00:17:03,040 --> 00:17:05,890
>> Acum, linia trei, suntem acum
in interiorul functiei swap.

386
00:17:05,890 --> 00:17:07,560
Ce am trece la schimb?

387
00:17:07,560 --> 00:17:11,609
Am trecut ampersand x pentru
o, și y ampersand pentru b.

388
00:17:11,609 --> 00:17:15,160
În cazul în care problema anterioară
afirmat că adresa de x

389
00:17:15,160 --> 00:17:17,520
este 0x10, și adresa y este 0x14.

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

391
00:17:18,970 --> 00:17:21,909
Deci a și b sunt egale cu
0x10 și 0x14, respectiv.

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

393
00:17:23,670 --> 00:17:26,250
>> Acum, la linia trei, care sunt x și y?

394
00:17:26,250 --> 00:17:28,554
Ei bine, nimic nu sa schimbat
despre x și y în acest moment.

395
00:17:28,554 --> 00:17:30,470
Chiar dacă ele sunt
într-un cadru stivă principal,

396
00:17:30,470 --> 00:17:32,469
ei încă mai au aceeași
Valorile au făcut-o înainte.

397
00:17:32,469 --> 00:17:34,030
Noi nu am modificat nici memorie.

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

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

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

401
00:17:37,050 --> 00:17:40,300
Deci, acum ne-a declarat int tmp egal să stea o.

402
00:17:40,300 --> 00:17:44,410
Deci, la linia patru, tot
este aceeași, cu excepția tmp.

403
00:17:44,410 --> 00:17:47,130
Noi nu am schimbat valori
de nimic în afară de tmp.

404
00:17:47,130 --> 00:17:49,230
Suntem stabilirea tmp egal să stea o.

405
00:17:49,230 --> 00:17:50,620
Ce este o stea?

406
00:17:50,620 --> 00:17:56,240
Ei bine, un puncte pentru x, Deci juca un
se va x egal, care este 1.

407
00:17:56,240 --> 00:18:00,080
Deci, totul este copiat
jos, iar tmp este setat la 1.

408
00:18:00,080 --> 00:18:01,110
>> Acum, următoarea linie.

409
00:18:01,110 --> 00:18:03,380
Stea un egal stea b.

410
00:18:03,380 --> 00:18:10,000
Deci, prin linia five-- bine din nou, totul
este același, cu excepția indiferent de stea a este.

411
00:18:10,000 --> 00:18:10,830
Ce este o stea?

412
00:18:10,830 --> 00:18:13,720
Ei bine, tocmai am spus stea o este de x.

413
00:18:13,720 --> 00:18:16,400
Așa că schimbă x la egal stea b.

414
00:18:16,400 --> 00:18:18,960
Ce este steaua b? y. punctele B la y.

415
00:18:18,960 --> 00:18:21,030
Deci, stele și b este y.

416
00:18:21,030 --> 00:18:25,140
Așa că setarea x egal cu y,
și orice altceva este la fel.

417
00:18:25,140 --> 00:18:29,130
Deci, vedem în rândul următor, care x este acum
2, iar restul sunt doar copiate jos.

418
00:18:29,130 --> 00:18:31,120
>> Acum, în următoarea linie, stea b este egal cu tmp.

419
00:18:31,120 --> 00:18:34,740
Ei bine, tocmai ne-a declarat stea b este y,
așa că setarea y egal cu tmp.

420
00:18:34,740 --> 00:18:37,450
Orice altceva este același,
așa că totul devine copiat jos.

421
00:18:37,450 --> 00:18:42,050
Ne setarea y egal cu TMP, care este
unul, și orice altceva este aceeași.

422
00:18:42,050 --> 00:18:43,210
>> Acum în cele din urmă, linia șapte.

423
00:18:43,210 --> 00:18:44,700
Ne-am întors în funcția de principal.

424
00:18:44,700 --> 00:18:46,350
Suntem după ce de swap este terminat.

425
00:18:46,350 --> 00:18:48,972
Am pierdut a, b, și
tmp, dar în cele din urmă noi

426
00:18:48,972 --> 00:18:51,180
nu se schimbă valori
de ceva în acest moment,

427
00:18:51,180 --> 00:18:52,800
ne-am copia x și y în jos.

428
00:18:52,800 --> 00:18:56,490
Și vedem că x și y sunt
acum 2 și 1 în loc de 1 și 2.

429
00:18:56,490 --> 00:18:58,160
Swap-a executat cu succes.

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

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

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

433
00:19:01,226 --> 00:19:03,100
Să presupunem că vă confruntați
mesajele de eroare

434
00:19:03,100 --> 00:19:06,790
de mai jos în timpul orelor de serviciu
anul viitor, ca un CA sau TF.

435
00:19:06,790 --> 00:19:08,930
Sfătui cum să o rezolvi fiecare dintre aceste erori.

436
00:19:08,930 --> 00:19:11,160
Referință astfel nedefinit la getString.

437
00:19:11,160 --> 00:19:12,540
De ce te-ar putea vedea acest lucru?

438
00:19:12,540 --> 00:19:15,380
Ei bine, în cazul în care un student se utilizează
GetString în codul lor,

439
00:19:15,380 --> 00:19:20,310
ei au Hash în mod corespunzător inclus CS50
dot h pentru a include biblioteca CS50.

440
00:19:20,310 --> 00:19:22,380
>> Ei bine, ceea ce fac ei
Trebuie să repara această eroare?

441
00:19:22,380 --> 00:19:26,810
Ei au nevoie pentru a face o lcs50 liniuță de la
linie de comandă atunci când acestea sunt compilarea.

442
00:19:26,810 --> 00:19:29,501
Deci, dacă acestea nu trec
zăngăni lcs50 bord, sunt

443
00:19:29,501 --> 00:19:32,000
nu va avea reale
cod care implementează getString.

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

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

446
00:19:34,170 --> 00:19:36,190
Implicit de declarare
funcția de bibliotecă strlen.

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

448
00:19:37,550 --> 00:19:40,360
Ei bine acest lucru acum, ei nu au
face hash corespunzătoare includ.

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

450
00:19:41,440 --> 00:19:45,410
În acest caz particular, fișierul header
de care au nevoie pentru a include este șir punct de ore,

451
00:19:45,410 --> 00:19:48,710
inclusiv șir punct de ore, acum
student-- acum compilator

452
00:19:48,710 --> 00:19:51,750
are acces la
declarațiile de strlen,

453
00:19:51,750 --> 00:19:54,120
și se știe că codul dvs.
folosește corect strlen.

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

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

456
00:19:56,580 --> 00:20:00,240
Mai multe conversii la sută
decât argumentele date.

457
00:20:00,240 --> 00:20:01,540
Deci, ce e asta?

458
00:20:01,540 --> 00:20:06,470
Ei bine, amintiți-vă că aceste procente
signs-- modul în care acestea sunt relevante pentru printf.

459
00:20:06,470 --> 00:20:08,890
Deci, în printf am putea percent--
s-ar putea imprima ceva

460
00:20:08,890 --> 00:20:11,380
ca la sută i backslash n.

461
00:20:11,380 --> 00:20:15,310
Sau am putea imprima ca la sută i,
spațiu, sut i, spațiu, sut i.

462
00:20:15,310 --> 00:20:18,950
Deci, pentru fiecare dintre cei
semne la sută, avem nevoie de

463
00:20:18,950 --> 00:20:21,560
pentru a trece o variabilă la sfârșitul printf.

464
00:20:21,560 --> 00:20:26,980
>> Deci, dacă spunem paren printf la sută
i backslash Parant n apropiate,

465
00:20:26,980 --> 00:20:30,270
ei bine, noi spunem că suntem
merge pentru a imprima un număr întreg,

466
00:20:30,270 --> 00:20:33,970
dar atunci nu ne trece printf
un număr întreg de a imprima de fapt.

467
00:20:33,970 --> 00:20:37,182
Deci, aici mai mult la sută
conversii decât argumentele date?

468
00:20:37,182 --> 00:20:39,390
Asta spune că avem
o grămadă de procente,

469
00:20:39,390 --> 00:20:42,445
și nu avem suficiente variabile
pentru a umple de fapt, în aceste procente.

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

471
00:20:44,850 --> 00:20:50,010
>> Și apoi cu siguranță, pentru întrebarea 31,
cu siguranta pierdut 40 de bytes în una blocuri.

472
00:20:50,010 --> 00:20:52,350
Deci, aceasta este o eroare Valgrind.

473
00:20:52,350 --> 00:20:54,720
Aceasta spune că
undeva în codul dvs.,

474
00:20:54,720 --> 00:20:59,010
aveți o alocare care este de 40
bytes mare, astfel încât să malloced 40 de bytes,

475
00:20:59,010 --> 00:21:00,515
și niciodată nu-l eliberați.

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

477
00:21:02,480 --> 00:21:05,140
Cel mai probabil doar ce ai nevoie
pentru a găsi unele scurgeri de memorie,

478
00:21:05,140 --> 00:21:07,650
și pentru a găsi în cazul în care aveți nevoie pentru a
desprindă acest bloc de memorie.

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

480
00:21:08,780 --> 00:21:11,910
>> Și întrebarea 32,
scrie invalid de dimensiune 4.

481
00:21:11,910 --> 00:21:13,250
Din nou, aceasta este o eroare Valgrind.

482
00:21:13,250 --> 00:21:15,440
Acest lucru nu trebuie să faci
cu pierderi de memorie acum.

483
00:21:15,440 --> 00:21:20,750
Acesta este, cel mai likely-- Adică, e
un fel de drepturi de memorie invalide.

484
00:21:20,750 --> 00:21:23,270
Și cel mai probabil, acest lucru este ceva
un fel de buffer overflow.

485
00:21:23,270 --> 00:21:26,560
În cazul în care aveți o matrice, poate
o matrice întreg, și să

486
00:21:26,560 --> 00:21:30,115
spune că e de dimensiune 5, și tu
încercați să atingeți suportul matrice 5.

487
00:21:30,115 --> 00:21:34,150
Deci, dacă încercați să scrie pentru că
valoare, că nu este o piesă de memorie

488
00:21:34,150 --> 00:21:37,440
pe care le au de fapt acces la, și
deci ai de gând pentru a obține această eroare,

489
00:21:37,440 --> 00:21:39,272
spunând scrie invalid de dimensiune 4.

490
00:21:39,272 --> 00:21:42,480
Valgrind este de gând să recunoască că ești
încercarea de a atinge memorie necorespunzător.

491
00:21:42,480 --> 00:21:43,980
>> Și asta e pentru quiz0.

492
00:21:43,980 --> 00:21:47,065
Sunt Rob Bowden, iar acest lucru este CS50.

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