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

2
00:00:09,572 --> 00:00:12,030
ROB BOWDEN: Hoi, ik ben Rob Bowden,
en laten we praten over quiz0.

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

4
00:00:13,280 --> 00:00:14,545
>> Dus, de eerste vraag.

5
00:00:14,545 --> 00:00:17,750
Dat is de vraag waar
u nodig om het aantal te coderen

6
00:00:17,750 --> 00:00:21,270
127 in de binaire bollen.

7
00:00:21,270 --> 00:00:23,550
Als je wilde, kon je
doen de reguliere conversie

8
00:00:23,550 --> 00:00:25,950
uit bi-- of, van decimaal naar binair.

9
00:00:25,950 --> 00:00:28,300
Maar dat gaat waarschijnlijk
om veel tijd in beslag nemen.

10
00:00:28,300 --> 00:00:31,750
Ik bedoel, je zou erachter te komen dat,
OK, 1 is daar, 2 is daar,

11
00:00:31,750 --> 00:00:33,650
4 is daar, 8 is daar.

12
00:00:33,650 --> 00:00:39,280
Gemakkelijkere manier, 127 is 128 minus één.

13
00:00:39,280 --> 00:00:42,013
Dat meest linkse lamp is de 128-bit.

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

15
00:00:43,490 --> 00:00:47,860
Dus 127 is eigenlijk gewoon alles
van de andere gloeilampen,

16
00:00:47,860 --> 00:00:51,420
want dat is de meest linkse
gloeilamp minus 1.

17
00:00:51,420 --> 00:00:52,800
Dat is het voor die vraag.

18
00:00:52,800 --> 00:00:54,060
>> Vraag één.

19
00:00:54,060 --> 00:00:56,710
Dus met 3 bits kunt u
vertegenwoordigen 8 verschillende waarden.

20
00:00:56,710 --> 00:01:01,000
Waarom dan 7 de grootste niet-negatief
decimale integer je kan vertegenwoordigen?

21
00:01:01,000 --> 00:01:04,050
Nou, als we kunnen alleen
vertegenwoordigen 8 verschillende waarden,

22
00:01:04,050 --> 00:01:07,430
dan wat we gaan te zijn
die is 0 tot 7.

23
00:01:07,430 --> 00:01:08,745
0 neemt een van de waarden.

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

25
00:01:09,980 --> 00:01:11,190
>> Vraag twee.

26
00:01:11,190 --> 00:01:14,610
Met n bits, hoeveel verschillende
waarden kunt u vertegenwoordigt?

27
00:01:14,610 --> 00:01:19,080
Dus, met n bits, je hebt 2
mogelijke waarden voor elke bit.

28
00:01:19,080 --> 00:01:22,300
Dus hebben we 2 mogelijke waarden voor
de eerste bit, 2 mogelijke waarden

29
00:01:22,300 --> 00:01:24,450
voor de tweede, 2
mogelijk het derde.

30
00:01:24,450 --> 00:01:28,730
En dat is dus 2 maal 2 maal 2, en
uiteindelijk is het antwoord op de 2 n.

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

32
00:01:30,010 --> 00:01:31,100
>> Vraag drie.

33
00:01:31,100 --> 00:01:33,450
Wat is 0x50 in binaire?

34
00:01:33,450 --> 00:01:39,490
Dus vergeet niet dat hexadecimale heeft een zeer
eenvoudige conversie naar binair.

35
00:01:39,490 --> 00:01:43,180
Dus hier, we hoeven alleen maar te kijken naar
de 5 en 0 onafhankelijk.

36
00:01:43,180 --> 00:01:45,110
Dus wat is 5 in binaire?

37
00:01:45,110 --> 00:01:48,400
0101, dat is de 1 bit en 4 bit.

38
00:01:48,400 --> 00:01:49,900
Wat is 0 in binaire?

39
00:01:49,900 --> 00:01:50,520
Niet lastig.

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

41
00:01:52,180 --> 00:01:54,970
Dus gewoon zet ze samen, en
dat is het volledige nummer in binaire.

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

43
00:01:57,640 --> 00:02:00,439
En als je wilde kon je
de start die meest linkse nul.

44
00:02:00,439 --> 00:02:01,105
Het is irrelevant.

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

46
00:02:02,920 --> 00:02:05,733
>> Dus dan als alternatief,
wat is 0x50 in decimale?

47
00:02:05,733 --> 00:02:08,649
Als je wilde, je could-- als je
meer comfortabel met het binaire,

48
00:02:08,649 --> 00:02:11,340
kon je dat binaire antwoord nemen
en zetten die naar decimalen.

49
00:02:11,340 --> 00:02:13,870
Of we kunnen alleen niet vergeten
dat hexadecimaal.

50
00:02:13,870 --> 00:02:21,140
Dus dat 0 is in de 0-e plaats, en
de 5 in de 16 eerste plaats.

51
00:02:21,140 --> 00:02:25,990
Dus hier, hebben we 5 maal 16 tot de
eerste, plus 0 maal 16 tot de nul,

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

53
00:02:27,520 --> 00:02:29,710
En als je keek naar de
titel op de vraag,

54
00:02:29,710 --> 00:02:32,920
het was CS 80, wat voor soort was van een
hint naar het antwoord op dit probleem.

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

56
00:02:34,460 --> 00:02:35,420
>> Vraag vijf.

57
00:02:35,420 --> 00:02:40,320
Wij hebben dit Scratch script, dat is
herhalen 4 keer pindakaas gelei.

58
00:02:40,320 --> 00:02:42,800
Dus hoe kunnen we nu code die in C?

59
00:02:42,800 --> 00:02:47,730
Nou, we hebben hier-- het deel in het vet
is het enige deel dat u moest implementeren.

60
00:02:47,730 --> 00:02:51,950
Dus we hebben een 4 lus die is looping 4
tijden, printf ing pindakaas gelei,

61
00:02:51,950 --> 00:02:53,910
met nieuwe lijn als het probleem vraagt.

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

63
00:02:55,250 --> 00:02:57,490
>> Vraag zes, een ander Scratch probleem.

64
00:02:57,490 --> 00:03:00,210
We zien dat we in een eeuwig lus.

65
00:03:00,210 --> 00:03:05,000
We zijn de variabele i zeggen
en dan het verhogen i door 1.

66
00:03:05,000 --> 00:03:09,580
Nu willen we dat doen in C. Er zijn
meerdere manieren kunnen we dit gedaan hebben.

67
00:03:09,580 --> 00:03:12,840
Hier gebeurde we om de code
forever loop als een while (true).

68
00:03:12,840 --> 00:03:16,600
Dus we verklaren de variabele i, net
alsof we variabele i in Scratch.

69
00:03:16,600 --> 00:03:21,950
Verklaar de variabele i, en voor altijd
while (true), zeggen dat we de variabele i.

70
00:03:21,950 --> 00:03:25,260
Dus printf% I-- of je zou kunnen hebben gebruikt% d.

71
00:03:25,260 --> 00:03:27,985
We zeggen dat de variabele, en
verhoog het dan, i ++.

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

73
00:03:29,560 --> 00:03:30,830
>> Vraag zeven.

74
00:03:30,830 --> 00:03:35,560
Nu willen we iets vergelijkbaars doen
Mario dot c van probleem set één.

75
00:03:35,560 --> 00:03:39,110
We willen deze hashtags af te drukken,
we willen afdrukken van een vijf

76
00:03:39,110 --> 00:03:40,700
door drie rechthoek deze hashes.

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

78
00:03:41,770 --> 00:03:43,162
Dus hoe gaan we dat doen?

79
00:03:43,162 --> 00:03:45,370
Nou, geven wij u een hele
bos van code, en je gewoon

80
00:03:45,370 --> 00:03:47,560
hebben in de functie afdruk rooster in te vullen.

81
00:03:47,560 --> 00:03:49,540
>> Dus wat doet PrintGrid eruit?

82
00:03:49,540 --> 00:03:51,480
Nou, je bent voorbij de
breedte en hoogte.

83
00:03:51,480 --> 00:03:53,520
Dus we hebben een buitenste 4
lus, dat is looping

84
00:03:53,520 --> 00:03:57,650
in alle rijen van deze
raster dat we willen om uit te printen.

85
00:03:57,650 --> 00:04:01,250
Dan hebben we de inter-geneste 4 lus,
dat is afgedrukt op een elke kolom.

86
00:04:01,250 --> 00:04:06,210
Dus voor elke rij is een afdruk voor
elke kolom, een enkele hash.

87
00:04:06,210 --> 00:04:10,045
Dan aan het einde van de rij drukken wij een
enkele nieuwe regel te gaan naar de volgende rij.

88
00:04:10,045 --> 00:04:11,420
En dat is het voor het hele net.

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

90
00:04:12,810 --> 00:04:13,675
>> Vraag acht.

91
00:04:13,675 --> 00:04:17,170
Een functie als PrintGrid schijt
een neveneffect, maar geen terugkeer

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

93
00:04:17,670 --> 00:04:19,209
Verklaar het onderscheid.

94
00:04:19,209 --> 00:04:23,080
Dus dit op u vertrouwt het herinneren
wat een bijwerking is.

95
00:04:23,080 --> 00:04:25,180
Nou ja, een terugkeer value--
we weten PrintGrid niet

96
00:04:25,180 --> 00:04:28,180
hebben return waarde, omdat
hier het zegt leegte.

97
00:04:28,180 --> 00:04:31,150
Dus alles wat die leegte terugkeert
niet echt iets terug.

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

99
00:04:32,200 --> 00:04:33,620
Dus wat is de bijwerking?

100
00:04:33,620 --> 00:04:36,620
Nou, een neveneffect is
iets dat soort blijft bestaan

101
00:04:36,620 --> 00:04:39,500
nadat de functie eindigt
dat was niet net terug,

102
00:04:39,500 --> 00:04:41,340
en het was niet alleen van de ingangen.

103
00:04:41,340 --> 00:04:44,970
>> Dus, bijvoorbeeld, kunnen we
wijzigen van een globale variabele.

104
00:04:44,970 --> 00:04:46,590
Dat zou een neveneffect.

105
00:04:46,590 --> 00:04:49,000
In dit geval een
zeer belangrijk neveneffect

106
00:04:49,000 --> 00:04:51,070
is het afdrukken op het scherm.

107
00:04:51,070 --> 00:04:53,110
Zodat een neveneffect
dat PrintGrid heeft.

108
00:04:53,110 --> 00:04:54,980
Wij drukken deze dingen naar het scherm.

109
00:04:54,980 --> 00:04:56,370
En je kunt bedenken
die als bijwerking,

110
00:04:56,370 --> 00:04:58,690
want dat is iets dat
aanhoudt nadat deze functie beëindigt.

111
00:04:58,690 --> 00:05:01,481
Dat is iets wat buiten het toepassingsgebied
van deze functie die uiteindelijk

112
00:05:01,481 --> 00:05:03,380
wordt gewijzigd, de
inhoud van het scherm.

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

114
00:05:05,200 --> 00:05:05,839
>> Vraag negen.

115
00:05:05,839 --> 00:05:07,880
Beschouw onder het programma,
waaraan regelnummers

116
00:05:07,880 --> 00:05:09,740
zijn toegevoegd
Ter wille van de discussie.

117
00:05:09,740 --> 00:05:13,480
Dus in dit programma zijn we gewoon
roepen GetString, slaan

118
00:05:13,480 --> 00:05:16,220
in deze variabele s, en vervolgens
het afdrukken van die variabele s.

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

120
00:05:16,720 --> 00:05:19,090
Dus waarom lijn niemand aanwezig is.

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

122
00:05:20,920 --> 00:05:23,820
Waarom moeten we #include CS50 dot h?

123
00:05:23,820 --> 00:05:26,180
Nou we het aanroepen van de
GetString functie,

124
00:05:26,180 --> 00:05:28,840
en GetString wordt gedefinieerd
in de CS50 bibliotheek.

125
00:05:28,840 --> 00:05:31,600
Dus als we niet hoefden
#include CS50 dot h,

126
00:05:31,600 --> 00:05:35,760
we zouden dat impliciete verklaring krijgen
van de GetString functie fout

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

128
00:05:36,840 --> 00:05:40,110
Dus moeten we de library-- bevatten
we nodig hebben om de header-bestand bevatten,

129
00:05:40,110 --> 00:05:42,870
of anders de compiler zal niet
erkennen dat GetString bestaat.

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

131
00:05:44,380 --> 00:05:46,140
>> Leg uit waarom lijn twee aanwezig is.

132
00:05:46,140 --> 00:05:47,890
Dus standaard io dot h.

133
00:05:47,890 --> 00:05:50,430
Het is precies hetzelfde
de vorige oplossing,

134
00:05:50,430 --> 00:05:53,310
behalve in plaats van omgaan met
GetString, we hebben het over printf.

135
00:05:53,310 --> 00:05:56,654
Dus als we niet zeggen dat we nodig hebben
standaard io dot h omvatten,

136
00:05:56,654 --> 00:05:58,820
dan zouden we niet in staat zijn
naar de printf functie te gebruiken,

137
00:05:58,820 --> 00:06:00,653
omdat de compiler
zou het niet weten.

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

139
00:06:01,750 --> 00:06:05,260
>> Why-- wat is de betekenis
van vervallen in lijn vier?

140
00:06:05,260 --> 00:06:08,010
Dus hier hebben we int main (void).

141
00:06:08,010 --> 00:06:10,600
Dat is gewoon te zeggen dat we
krijgen geen command line

142
00:06:10,600 --> 00:06:12,280
argumenten naar main.

143
00:06:12,280 --> 00:06:17,390
Vergeet niet dat we int kon zeggen
belangrijkste int argc touwtje argv beugels.

144
00:06:17,390 --> 00:06:20,400
Dus hier zijn we gewoon zeggen leegte te zeggen dat we
negeren commandoregel argumenten.

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

146
00:06:21,840 --> 00:06:25,225
>> Leggen met betrekking tot geheugen, precies
wat GetString in lijn zes rendementen.

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

148
00:06:27,040 --> 00:06:31,640
GetString is het terugsturen van een blok van
geheugen, een reeks tekens.

149
00:06:31,640 --> 00:06:34,870
Het is echt het terugsturen van een
pointer naar het eerste teken.

150
00:06:34,870 --> 00:06:37,170
Vergeet niet dat een string is een char ster.

151
00:06:37,170 --> 00:06:41,360
Dus s is een pointer naar de eerste
karakter in welke de string

152
00:06:41,360 --> 00:06:43,510
dat de gebruiker op het toetsenbord ingevoerd.

153
00:06:43,510 --> 00:06:47,070
En dat geheugen toevallig malloced,
dus dat het geheugen in de heap.

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

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

156
00:06:50,450 --> 00:06:51,960
Beschouw het programma hieronder.

157
00:06:51,960 --> 00:06:55,579
Dus alles wat dit programma doet
wordt printf-ing 1 gedeeld door 10.

158
00:06:55,579 --> 00:06:57,370
Zo worden opgesteld en
uitgevoerde programma,

159
00:06:57,370 --> 00:07:01,170
uitgangen 0.0, hoewel
1 gedeeld door 10 is 0,1.

160
00:07:01,170 --> 00:07:02,970
Dus waarom is het 0.0?

161
00:07:02,970 --> 00:07:05,510
Nou, dit is omdat
van integer divisie.

162
00:07:05,510 --> 00:07:08,580
Dus 1 een geheel getal, 10 een geheel getal is.

163
00:07:08,580 --> 00:07:11,980
So 1 gedeeld door 10, alles
wordt beschouwd als gehele getallen,

164
00:07:11,980 --> 00:07:16,380
en in C, als we dat doen integer divisie,
we afkappen elke komma.

165
00:07:16,380 --> 00:07:19,590
So 1 gedeeld door 10
0, en dan proberen we

166
00:07:19,590 --> 00:07:24,410
afdrukken die als float, zodat
nul afgedrukt als een float is 0.0.

167
00:07:24,410 --> 00:07:27,400
En daarom krijgen we 0.0.

168
00:07:27,400 --> 00:07:28,940
>> Beschouw het programma hieronder.

169
00:07:28,940 --> 00:07:31,280
Nu zijn we het afdrukken van 0,1.

170
00:07:31,280 --> 00:07:34,280
Dus geen integer divisie,
we zijn gewoon afdrukken 0.1,

171
00:07:34,280 --> 00:07:37,100
maar we zijn het af te drukken
tot 28 cijfers achter de komma.

172
00:07:37,100 --> 00:07:41,810
En we krijgen dit 0,1000, een hele hoop
nullen, 5 5 5, blah blah blah.

173
00:07:41,810 --> 00:07:45,495
Dus de vraag is hier waarom doet het
afdrukken die plaats precies 0.1?

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

175
00:07:46,620 --> 00:07:49,640
>> Dus de reden is hier nu
floating point onnauwkeurigheid.

176
00:07:49,640 --> 00:07:53,410
Vergeet niet dat een float is slechts 32 bits.

177
00:07:53,410 --> 00:07:57,540
Dus kunnen we alleen maar een eindig aantal vertegenwoordigen
van floating point waarden met die 32

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

179
00:07:58,560 --> 00:08:01,760
Nou er is uiteindelijk oneindig
veel floating point waarden,

180
00:08:01,760 --> 00:08:04,940
en er is oneindig veel zwevende
punt waarden tussen 0 en 1,

181
00:08:04,940 --> 00:08:07,860
en we zijn uiteraard in staat om
vertegenwoordigen nog meer waarden dan.

182
00:08:07,860 --> 00:08:13,230
Dus we moeten offers brengen om
kunnen de meeste waarden vertegenwoordigen.

183
00:08:13,230 --> 00:08:16,960
>> Dus een waarde zoals 0.1, blijkbaar
kunnen we niet garanderen dat precies.

184
00:08:16,960 --> 00:08:22,500
Dus in plaats van die 0.1 doen we het
beste kunnen we dit 0.100000 5 5 vertegenwoordigen

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

186
00:08:23,260 --> 00:08:26,306
En dat is aardig in de buurt, maar
voor veel toepassingen

187
00:08:26,306 --> 00:08:28,430
je zorgen te maken over
floating point onnauwkeurigheid,

188
00:08:28,430 --> 00:08:30,930
want we kunnen gewoon niet vertegenwoordigen
alle zwevende punten precies.

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

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

191
00:08:33,380 --> 00:08:34,679
Beschouw de onderstaande code.

192
00:08:34,679 --> 00:08:36,630
We zijn net het afdrukken van 1 plus 1.

193
00:08:36,630 --> 00:08:38,289
Dus er is geen truc.

194
00:08:38,289 --> 00:08:41,780
1 plus 1 evalueert tot 2, en
dan zijn we het afdrukken van dat.

195
00:08:41,780 --> 00:08:42,789
Hiermee wordt slechts 2.

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

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

198
00:08:44,700 --> 00:08:49,450
Nu zijn we het afdrukken van het karakter
1 plus het karakter 1.

199
00:08:49,450 --> 00:08:52,110
Dus waarom is dit niet
print het zelfde ding?

200
00:08:52,110 --> 00:08:57,680
Nou het karakter 1 plus het karakter
1, het karakter 1 heeft ASCII-waarde 49.

201
00:08:57,680 --> 00:09:04,840
Dus dit zegt echt 49 plus 49, en
uiteindelijk dit gaat om af te drukken 98.

202
00:09:04,840 --> 00:09:06,130
Dus dit wordt niet afgedrukt 2.

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

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

205
00:09:09,271 --> 00:09:11,520
Voltooiing van de uitvoering
oneven hieronder zodanig

206
00:09:11,520 --> 00:09:14,615
dat de functie geeft true als
n oneven en onwaar als n even is.

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

208
00:09:16,710 --> 00:09:19,330
Dit is een groot doel
voor de mod operator.

209
00:09:19,330 --> 00:09:24,530
Dus nemen we ons argument n,
als n mod 2 gelijk is aan 1, goed

210
00:09:24,530 --> 00:09:28,030
Dat betekent dat n verdeeld
door 2 had een restant.

211
00:09:28,030 --> 00:09:33,270
Als n gedeeld door 2 had een restant, dat
betekent dat n oneven is, dus we return true.

212
00:09:33,270 --> 00:09:34,910
Anders keren we vals.

213
00:09:34,910 --> 00:09:39,070
Je zou ook kunnen n hebben gedaan mod 2 gelijken
nul, return false, anders return true.

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

215
00:09:41,600 --> 00:09:43,640
>> Beschouw het recursieve functie hieronder.

216
00:09:43,640 --> 00:09:46,920
Als n kleiner is dan of
gelijk aan 1, return 1,

217
00:09:46,920 --> 00:09:50,430
anders return n keer f van n minus 1.

218
00:09:50,430 --> 00:09:52,556
Dus wat is de functie?

219
00:09:52,556 --> 00:09:54,305
Nou, dit is slechts het
faculteit-functie.

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

221
00:09:55,410 --> 00:09:57,405
Dit is mooi vertegenwoordigd
als n faculteit.

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

223
00:09:58,720 --> 00:10:02,310
>> Dus vraag 19 nu, we willen
neem deze recursieve functie.

224
00:10:02,310 --> 00:10:04,530
We willen het iteratieve maken.

225
00:10:04,530 --> 00:10:05,874
Dus hoe kunnen we dat doen?

226
00:10:05,874 --> 00:10:07,790
Goed voor het personeel
oplossing, en weer is er

227
00:10:07,790 --> 00:10:11,090
meerdere manieren je had kunnen doen
dat, beginnen we met dit int product

228
00:10:11,090 --> 00:10:11,812
gelijk aan 1.

229
00:10:11,812 --> 00:10:13,520
En in dit hele
lus, we gaan

230
00:10:13,520 --> 00:10:17,590
te product uiteindelijk vermenigvuldigen
eindigen met de volledige faculteit.

231
00:10:17,590 --> 00:10:21,870
Dus voor int i is gelijk aan 2, i
minder dan of gelijk aan n, i ++.

232
00:10:21,870 --> 00:10:24,130
>> U vraagt ​​zich misschien af ​​waarom ik gelijk aan 2.

233
00:10:24,130 --> 00:10:28,380
Nou, vergeet niet dat hier hebben we te
zorg ervoor dat ons basisscenario correct is.

234
00:10:28,380 --> 00:10:32,180
Als n kleiner is dan of gelijk
1, we zijn net terug 1.

235
00:10:32,180 --> 00:10:34,830
Dus hier, we beginnen bij i is gelijk aan 2.

236
00:10:34,830 --> 00:10:39,090
Nou als ik waren 1, dan the-- of
als n waren 1, dan is het voor de lus

237
00:10:39,090 --> 00:10:40,600
helemaal niet zou uitvoeren.

238
00:10:40,600 --> 00:10:43,190
En dus zouden we gewoon
terugkeer product, dat is 1.

239
00:10:43,190 --> 00:10:45,920
Evenzo, als n zijn
iets minder dan 1--

240
00:10:45,920 --> 00:10:49,290
als het 0, 1 negatief, whatever--
we zouden nog steeds terugkeren 1,

241
00:10:49,290 --> 00:10:52,260
dat is precies wat de
recursieve versie doet.

242
00:10:52,260 --> 00:10:54,660
>> Nu, als n groter
dan 1, dan gaan we

243
00:10:54,660 --> 00:10:56,550
ten minste één do
iteratie van deze lus.

244
00:10:56,550 --> 00:11:00,630
Dus laten we zeggen n 5 is, dan zijn we
ga naar het product keer doen gelijk 2.

245
00:11:00,630 --> 00:11:02,165
Dus nu product is 2.

246
00:11:02,165 --> 00:11:04,040
Nu gaan we doen
product keer is gelijk aan 3.

247
00:11:04,040 --> 00:11:04,690
Nu is 6.

248
00:11:04,690 --> 00:11:07,500
Product keer gelijk 4, nu is het 24.

249
00:11:07,500 --> 00:11:10,420
Product keer gelijk 5, nu is het 120.

250
00:11:10,420 --> 00:11:16,730
Dus dan uiteindelijk zijn we terug
120, die juist 5 faculteit is.

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

252
00:11:17,510 --> 00:11:22,480
Dit is degene waar je moet invullen
in de tabel met een bepaalde algoritme,

253
00:11:22,480 --> 00:11:25,735
alles wat we hebben gezien, dat
past deze algoritmische run

254
00:11:25,735 --> 00:11:28,060
malen deze asymptotische doorlooptijden.

255
00:11:28,060 --> 00:11:33,270
Wat is een algoritme dat
is omega van 1, maar big O van n?

256
00:11:33,270 --> 00:11:35,970
Dus oneindig kan
veel antwoorden hier.

257
00:11:35,970 --> 00:11:39,790
Degene die we waarschijnlijk het meest heb gezien
vaak is gewoon lineair zoeken.

258
00:11:39,790 --> 00:11:42,050
>> Dus in het beste geval
scenario, het item dat we

259
00:11:42,050 --> 00:11:44,050
naar de
begin van de lijst

260
00:11:44,050 --> 00:11:47,400
en zo in omega van 1 stappen,
het eerste wat we checken,

261
00:11:47,400 --> 00:11:49,740
we gewoon onmiddellijk terug
dat vonden we het item.

262
00:11:49,740 --> 00:11:52,189
In het worst case scenario,
de functie bij het einde,

263
00:11:52,189 --> 00:11:53,730
of het item niet in de lijst op alle.

264
00:11:53,730 --> 00:11:56,700
Dus we moeten zoeken
de hele lijst, alle n

265
00:11:56,700 --> 00:11:58,480
elementen, en dat is waarom het is o n.

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

267
00:11:59,670 --> 00:12:04,880
>> Dus nu is het iets dat zowel
omega van n log n, en de grote O van n log n.

268
00:12:04,880 --> 00:12:08,650
Nou de meest relevante ding
we hebben hier te zien is fuseren soort.

269
00:12:08,650 --> 00:12:12,950
Dus samenvoegen sorteren, onthouden,
is uiteindelijk Theta

270
00:12:12,950 --> 00:12:16,920
n log n, waarbij theta gedefinieerd
als zowel omega en grote O hetzelfde.

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

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

273
00:12:18,690 --> 00:12:21,970
>> Wat is iets dat omega
van n en o, van n kwadraat?

274
00:12:21,970 --> 00:12:23,990
Nou, nogmaals er is
meerdere antwoorden mogelijk.

275
00:12:23,990 --> 00:12:26,440
Hier gebeuren we bubble sort zeggen.

276
00:12:26,440 --> 00:12:28,840
Insertion sort zou hier ook werken.

277
00:12:28,840 --> 00:12:31,400
Vergeet niet dat bubble sort
heeft dat optimalisatie waar,

278
00:12:31,400 --> 00:12:34,630
als je in staat om te krijgen zijn
de hele lijst

279
00:12:34,630 --> 00:12:37,402
zonder te doen
elke swaps, dan, nou ja,

280
00:12:37,402 --> 00:12:40,110
we kunnen onmiddellijk terug te keren dat
de lijst gesorteerd was om mee te beginnen.

281
00:12:40,110 --> 00:12:43,185
Dus in het beste geval,
het is gewoon omega van n.

282
00:12:43,185 --> 00:12:45,960
Als het is niet alleen een mooi
gesorteerde lijst om mee te beginnen,

283
00:12:45,960 --> 00:12:48,270
dan hebben we O van n kwadraat swaps.

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

285
00:12:49,330 --> 00:12:55,610
En tot slot hebben we selectie sorteren
voor n kwadraat, zowel omega en grote O.

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

287
00:12:56,850 --> 00:12:58,870
Wat is integer overflow?

288
00:12:58,870 --> 00:13:02,160
Weer goed, vergelijkbaar met eerdere,
we hebben maar een eindig aantal stukjes

289
00:13:02,160 --> 00:13:04,255
een integer vertegenwoordigen
dus misschien 32 bits.

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

291
00:13:06,300 --> 00:13:09,180
Laten we zeggen dat we een signed integer.

292
00:13:09,180 --> 00:13:12,800
Dan uiteindelijk de hoogste
positief getal we kunnen vertegenwoordigen

293
00:13:12,800 --> 00:13:15,910
2 tot 31 min 1.

294
00:13:15,910 --> 00:13:19,370
Dus wat gebeurt er als we proberen te
vervolgens increment dat integer?

295
00:13:19,370 --> 00:13:25,320
Nou, we gaan om te gaan van 2 tot en met de 31
minus 1, helemaal naar beneden om negatieve 2

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

297
00:13:26,490 --> 00:13:29,470
Dus dit integer overflow is
wanneer je blijft ophogen,

298
00:13:29,470 --> 00:13:32,330
en uiteindelijk kun je niet
get any hoger en het gewoon

299
00:13:32,330 --> 00:13:34,520
wraps helemaal terug
rond een negatieve waarde.

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

301
00:13:35,850 --> 00:13:37,779
>> Hoe zit het met een buffer overflow?

302
00:13:37,779 --> 00:13:39,820
Dus een buffer overflow--
herinneren wat een buffer is.

303
00:13:39,820 --> 00:13:41,000
Het is gewoon een stuk van het geheugen.

304
00:13:41,000 --> 00:13:43,350
Iets als een array is een buffer.

305
00:13:43,350 --> 00:13:46,120
Dus een buffer overflow is wanneer
u probeert om toegang te krijgen tot het geheugen

306
00:13:46,120 --> 00:13:47,880
na het einde van die array.

307
00:13:47,880 --> 00:13:50,410
Dus als je een
waaier van grootte 5 en je

308
00:13:50,410 --> 00:13:53,700
proberen om toegang te krijgen scala beugel
5 of beugel 6 of beugel 7,

309
00:13:53,700 --> 00:13:56,610
of iets verder dan de
einde, of zelfs iets

310
00:13:56,610 --> 00:14:00,790
below-- scala beugel negatieve 1--
al die zijn buffer overflows.

311
00:14:00,790 --> 00:14:02,810
Je raakt het geheugen in slechte manieren.

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

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

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

315
00:14:05,760 --> 00:14:09,100
Dus in dit degene die je nodig hebt
te implementeren strlen.

316
00:14:09,100 --> 00:14:11,630
En wij zeggen jullie dat je kan
veronderstellen s zal niet leeg zijn,

317
00:14:11,630 --> 00:14:13,790
zodat je niet hoeft te
Voer een check voor null.

318
00:14:13,790 --> 00:14:16,190
Er zijn meerdere manieren
kon je dit hebt gedaan.

319
00:14:16,190 --> 00:14:18,440
Hier nemen we gewoon het eenvoudig.

320
00:14:18,440 --> 00:14:21,780
We beginnen met een teller, n. n
tellen hoeveel tekens er zijn.

321
00:14:21,780 --> 00:14:25,560
Dus beginnen we op 0, en dan hebben we
itereren over de hele lijst.

322
00:14:25,560 --> 00:14:29,092
>> Is s 0 beugel gelijk aan de
null terminator karakter?

323
00:14:29,092 --> 00:14:31,425
Vergeet niet dat we op zoek naar
de null terminator karakter

324
00:14:31,425 --> 00:14:33,360
te bepalen hoe lang onze string.

325
00:14:33,360 --> 00:14:35,890
Dat gaat te beëindigen
alle relevante string.

326
00:14:35,890 --> 00:14:39,400
Dus is s beugel 0 gelijk
om de null terminator?

327
00:14:39,400 --> 00:14:42,850
Als het niet, dan gaan we naar
kijken naar s beugel 1, s beugel 2.

328
00:14:42,850 --> 00:14:45,050
We blijven gaan tot we
vind het null terminator.

329
00:14:45,050 --> 00:14:48,580
Zodra we het gevonden hebt, dan n bevat
de totale lengte van de tekenreeks,

330
00:14:48,580 --> 00:14:49,942
en we kunnen gewoon terug dat.

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

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

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

334
00:14:53,010 --> 00:14:56,050
Dus dit is het een waar je
moeten de afweging maken.

335
00:14:56,050 --> 00:14:59,810
Dus een ding is goed in één
manier, maar op welke manier is het slecht?

336
00:14:59,810 --> 00:15:02,980
Dus hier, samenvoegen soort heeft de neiging om
zijn sneller dan bubble sort.

337
00:15:02,980 --> 00:15:06,530
Dat gezegd dat-- goed, er
zijn hier meerdere antwoorden.

338
00:15:06,530 --> 00:15:12,930
Maar het belangrijkste is dat de bubble sort
is omega van n voor een gesorteerde lijst.

339
00:15:12,930 --> 00:15:14,950
>> Vergeet niet dat de tafel we gewoon eerder zagen.

340
00:15:14,950 --> 00:15:17,600
Dus bel sorteert omega van
n, het best case scenario

341
00:15:17,600 --> 00:15:20,010
is het is om iets meer te kunnen gaan
de lijst een keer, bepalen

342
00:15:20,010 --> 00:15:22,270
hey dit ding is nu al
gesorteerd en rendement.

343
00:15:22,270 --> 00:15:25,960
Samenvoegen sorteren, wat er ook gebeurt
je doet, is het omega van n log n.

344
00:15:25,960 --> 00:15:29,200
Dus voor gesorteerde lijst, bel
soort gaat sneller.

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

346
00:15:30,870 --> 00:15:32,430
>> Nu wat over gelinkte lijsten?

347
00:15:32,430 --> 00:15:36,070
Dus een gelinkte lijst kan groeien en krimpen
zoveel elementen passen als nodig.

348
00:15:36,070 --> 00:15:38,489
Dat gezegd dat-- zo
meestal directe vergelijking

349
00:15:38,489 --> 00:15:40,280
gaat worden een gekoppelde
een lijst met een array.

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

351
00:15:41,600 --> 00:15:44,050
Dus hoewel arrays kunnen
gemakkelijk groeien en krimpen

352
00:15:44,050 --> 00:15:47,130
om zoveel mogelijk elementen passen
indien nodig, een gekoppelde lijst

353
00:15:47,130 --> 00:15:49,600
vergeleken met een array-- een
array heeft random access.

354
00:15:49,600 --> 00:15:52,960
We kunnen indexeren in elke
bepaald element van de array.

355
00:15:52,960 --> 00:15:56,430
>> Dus voor een gelinkte lijst, kunnen we niet
ga je gewoon naar het vijfde element,

356
00:15:56,430 --> 00:16:00,260
We moeten doorkruisen van het begin
tot we bij het vijfde element.

357
00:16:00,260 --> 00:16:03,990
En dat gaat ons te verhinderen
iets als binary search doen.

358
00:16:03,990 --> 00:16:08,150
Spreken van binary search, binary search
meestal sneller dan lineair zoekactie.

359
00:16:08,150 --> 00:16:11,120
Dat gezegd dat--
ja, één ding mogelijk

360
00:16:11,120 --> 00:16:13,380
is dat je niet binair kunnen doen
zoeken op gelinkte lijsten,

361
00:16:13,380 --> 00:16:14,730
kunt u alleen doen op arrays.

362
00:16:14,730 --> 00:16:18,030
Maar wellicht nog belangrijker,
kun je binary search niet doen

363
00:16:18,030 --> 00:16:20,690
op een array niet gesorteerd.

364
00:16:20,690 --> 00:16:23,990
Upfront moet u mogelijk om te sorteren
de array, en alleen dan kan

365
00:16:23,990 --> 00:16:25,370
je doet binary search.

366
00:16:25,370 --> 00:16:27,660
Dus als je ding is niet
gesorteerde om te beginnen,

367
00:16:27,660 --> 00:16:29,250
dan lineair zoeken zou sneller zijn.

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

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

370
00:16:31,740 --> 00:16:34,770
Dus overweeg hieronder het programma,
die in de volgende dia.

371
00:16:34,770 --> 00:16:37,790
En dit is de ene waar we zijn
gaat willen expliciet te vermelden

372
00:16:37,790 --> 00:16:39,980
de waarden van verschillende variabelen.

373
00:16:39,980 --> 00:16:41,990
Dus laten we eens kijken naar dat.

374
00:16:41,990 --> 00:16:43,160
>> Dus regel één.

375
00:16:43,160 --> 00:16:45,457
We hebben int x gelijk aan 1.

376
00:16:45,457 --> 00:16:47,040
Dat is het enige wat er is gebeurd.

377
00:16:47,040 --> 00:16:50,440
Dus op lijn één, zien we in onze
tafel, dat y, a, b en TMP zijn

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

379
00:16:51,540 --> 00:16:52,280
Dus wat is x?

380
00:16:52,280 --> 00:16:53,860
Nou we zojuist het gelijk is aan 1.

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

382
00:16:55,020 --> 00:16:58,770
En dan lijn twee, goed,
we zien dat y is ingesteld op 2,

383
00:16:58,770 --> 00:17:00,550
en de tafel is al
ingevuld voor ons.

384
00:17:00,550 --> 00:17:03,040
Dus x 1 is en y 2 is.

385
00:17:03,040 --> 00:17:05,890
>> Nu, lijn drie, we zijn nu
binnen in de swap-functie.

386
00:17:05,890 --> 00:17:07,560
Wat deden we langs om te ruilen?

387
00:17:07,560 --> 00:17:11,609
We passeerden ampersand x voor
een, en ampersand y voor b.

388
00:17:11,609 --> 00:17:15,160
Wanneer het probleem eerder
verklaarde dat het adres van x

389
00:17:15,160 --> 00:17:17,520
is 0x10, en het adres van y is 0x14.

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

391
00:17:18,970 --> 00:17:21,909
Dus a en b gelijk zijn aan
0x10 en 0x14, respectievelijk.

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

393
00:17:23,670 --> 00:17:26,250
>> Nu op lijn drie, wat zijn x en y?

394
00:17:26,250 --> 00:17:28,554
Nou is er niets veranderd
over x en y op dit punt.

395
00:17:28,554 --> 00:17:30,470
Ook al zijn ze
in een grote stack frame,

396
00:17:30,470 --> 00:17:32,469
ze nog steeds dezelfde
waarden voorheen.

397
00:17:32,469 --> 00:17:34,030
We hebben niet gewijzigd enkele herinnering.

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

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

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

401
00:17:37,050 --> 00:17:40,300
Dus nu hebben we gezegd int tmp gelijk aan een ster.

402
00:17:40,300 --> 00:17:44,410
Dus op lijn vier, alles
is hetzelfde, behalve voor tmp.

403
00:17:44,410 --> 00:17:47,130
We hebben geen waarden veranderd
van om het even wat, behalve voor tmp.

404
00:17:47,130 --> 00:17:49,230
We zijn het instellen tmp gelijk aan een ster.

405
00:17:49,230 --> 00:17:50,620
Wat is een ster?

406
00:17:50,620 --> 00:17:56,240
Nou, een puntensysteem om x, So ster een
gaat gelijk x, die 1.

407
00:17:56,240 --> 00:18:00,080
Dus alles wordt gekopieerd
beneden en TMP ingesteld op 1.

408
00:18:00,080 --> 00:18:01,110
>> Nu is de volgende regel.

409
00:18:01,110 --> 00:18:03,380
Star een gelijk ster b.

410
00:18:03,380 --> 00:18:10,000
Dus door lijn five-- weer goed, alles
is hetzelfde, behalve wat ster een is.

411
00:18:10,000 --> 00:18:10,830
Wat is een ster?

412
00:18:10,830 --> 00:18:13,720
Nou, we hebben net gezegd ster a x.

413
00:18:13,720 --> 00:18:16,400
Dus we veranderen x gelijke ster b.

414
00:18:16,400 --> 00:18:18,960
Wat is ster b? y. b punten op y.

415
00:18:18,960 --> 00:18:21,030
Dus ster b y.

416
00:18:21,030 --> 00:18:25,140
Dus we zijn het instellen van x gelijk is aan y,
en al het andere is hetzelfde.

417
00:18:25,140 --> 00:18:29,130
Zo zien we in de volgende rij dat x is nu
2, en de rest zijn gewoon naar beneden gekopieerd.

418
00:18:29,130 --> 00:18:31,120
>> Nu in de volgende regel, ster b gelijk tmp.

419
00:18:31,120 --> 00:18:34,740
Nou, we hebben net gezegd ster b is y,
dus we zijn het instellen van y gelijk aan tmp.

420
00:18:34,740 --> 00:18:37,450
Alles is hetzelfde,
dus alles wordt gekopieerd naar beneden.

421
00:18:37,450 --> 00:18:42,050
We zijn het instellen van y gelijk aan tmp, dat is
één, en al het andere is hetzelfde.

422
00:18:42,050 --> 00:18:43,210
>> Nu eindelijk, lijn zeven.

423
00:18:43,210 --> 00:18:44,700
We zijn terug in de belangrijkste functie.

424
00:18:44,700 --> 00:18:46,350
We zijn na swap is voltooid.

425
00:18:46,350 --> 00:18:48,972
We hebben a, b verloren, en
tmp, maar uiteindelijk hebben we

426
00:18:48,972 --> 00:18:51,180
zijn geen waarden veranderen
iets op dit punt,

427
00:18:51,180 --> 00:18:52,800
we gewoon kopiëren x en y naar beneden.

428
00:18:52,800 --> 00:18:56,490
En we zien dat x en y
Nu 2 en 1 in plaats van 1 en 2.

429
00:18:56,490 --> 00:18:58,160
De swap heeft met succes uitgevoerd.

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

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

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

433
00:19:01,226 --> 00:19:03,100
Stel dat je tegenkomt
de foutmeldingen

434
00:19:03,100 --> 00:19:06,790
hieronder tijdens kantooruren
volgend jaar als een CA of TF.

435
00:19:06,790 --> 00:19:08,930
Adviseren hoe elk van deze fouten te herstellen.

436
00:19:08,930 --> 00:19:11,160
Dus undefined verwijzing naar GetString.

437
00:19:11,160 --> 00:19:12,540
Waarom zou je dit zien?

438
00:19:12,540 --> 00:19:15,380
Nou, als een student wordt met behulp van
GetString in hun code,

439
00:19:15,380 --> 00:19:20,310
ze hebben de juiste hash opgenomen CS50
dot h om de CS50 bibliotheek op te nemen.

440
00:19:20,310 --> 00:19:22,380
>> Nou, wat doen ze
nodig hebt om deze fout te verhelpen?

441
00:19:22,380 --> 00:19:26,810
Ze moeten een dash lcs50 bij het doen
command line als ze samenstellen.

442
00:19:26,810 --> 00:19:29,501
Dus als ze niet voorbij
clang dash lcs50, ze zijn

443
00:19:29,501 --> 00:19:32,000
niet van plan om de werkelijke hebben
code die GetString implementeert.

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

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

446
00:19:34,170 --> 00:19:36,190
Impliciet verklaren
bibliotheekfunctie strlen.

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

448
00:19:37,550 --> 00:19:40,360
Nou dit nu, ze hebben niet
gedaan de juiste hash omvatten.

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

450
00:19:41,440 --> 00:19:45,410
In dit specifieke geval, de header file
ze nodig hebben om onder meer is touwtje dot h,

451
00:19:45,410 --> 00:19:48,710
en met touwtje dot h, nu
de student-- nu de compiler

452
00:19:48,710 --> 00:19:51,750
toegang tot de
verklaringen van strlen,

453
00:19:51,750 --> 00:19:54,120
en hij weet dat je code
correct gebruik van strlen.

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

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

456
00:19:56,580 --> 00:20:00,240
Meer procent conversies
dan gegevens argumenten.

457
00:20:00,240 --> 00:20:01,540
Dus wat is dit?

458
00:20:01,540 --> 00:20:06,470
Goed herinneren dat deze procent
signs-- hoe ze relevant zijn voor printf bent.

459
00:20:06,470 --> 00:20:08,890
Dus in printf zouden we percent--
we misschien wel iets af te drukken

460
00:20:08,890 --> 00:20:11,380
zoals procent i Backslash n.

461
00:20:11,380 --> 00:20:15,310
Of we kunnen printen, zoals procent i,
ruimte, procent i, ruimte, procent i.

462
00:20:15,310 --> 00:20:18,950
Dus voor elk van deze
procenttekens moeten we

463
00:20:18,950 --> 00:20:21,560
om een ​​variabele gaat over op het einde van printf.

464
00:20:21,560 --> 00:20:26,980
>> Dus als we zeggen printf paren procent
i backslash n dicht paren,

465
00:20:26,980 --> 00:20:30,270
goed, zeggen we dat we
naar een integer drukken,

466
00:20:30,270 --> 00:20:33,970
maar dan doen we niet printf passeren
een integer daadwerkelijk drukken.

467
00:20:33,970 --> 00:20:37,182
Dus hier meer procent
omzettingen dan data argumenten?

468
00:20:37,182 --> 00:20:39,390
Dat zegt dat we
een hele hoop van procenten,

469
00:20:39,390 --> 00:20:42,445
en we hebben niet genoeg variabelen
om daadwerkelijk in die procenten invullen.

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

471
00:20:44,850 --> 00:20:50,010
>> En dan zeker, voor vraag 31,
zeker verloren 40 bytes in één blokken.

472
00:20:50,010 --> 00:20:52,350
Dus dit is een Valgrind fout.

473
00:20:52,350 --> 00:20:54,720
Deze zegt dat
ergens in je code,

474
00:20:54,720 --> 00:20:59,010
heb je een toewijzing die is 40
bytes groot dus je malloced 40 bytes,

475
00:20:59,010 --> 00:21:00,515
en je nooit bevrijd is.

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

477
00:21:02,480 --> 00:21:05,140
Waarschijnlijk heb je gewoon nodig hebt
om wat geheugenlek vinden,

478
00:21:05,140 --> 00:21:07,650
en vinden waar je moet
bevrijden dit blok van het geheugen.

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

480
00:21:08,780 --> 00:21:11,910
>> En vraag 32,
ongeldige schrijfsnelheid van maat 4.

481
00:21:11,910 --> 00:21:13,250
Ook dit is een Valgrind fout.

482
00:21:13,250 --> 00:21:15,440
Dit hoeft niet te doen
met memory leaks nu.

483
00:21:15,440 --> 00:21:20,750
Dit is de meeste likely-- Ik bedoel, het is
een soort van ongeldige geheugen rechten.

484
00:21:20,750 --> 00:21:23,270
En het meest waarschijnlijk is dit aantal
soort van buffer overflow.

485
00:21:23,270 --> 00:21:26,560
Waar heb je een array, misschien
een integer array, en laten we

486
00:21:26,560 --> 00:21:30,115
zeggen dat het van maat 5, en je
probeer scala beugel 5 raken.

487
00:21:30,115 --> 00:21:34,150
Dus als u probeert te schrijven naar die
waarde, dat is niet een stuk van het geheugen

488
00:21:34,150 --> 00:21:37,440
dat u daadwerkelijk toegang hebben tot, en
dus je gaat om deze fout te krijgen,

489
00:21:37,440 --> 00:21:39,272
zegt ongeldige write van maat 4.

490
00:21:39,272 --> 00:21:42,480
Valgrind gaat herkennen je bent
proberen om het geheugen op ongepaste wijze te raken.

491
00:21:42,480 --> 00:21:43,980
>> En dat is het voor quiz0.

492
00:21:43,980 --> 00:21:47,065
Ik ben Rob Bowden, en dit is CS50.

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