1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Valgrind]

2
00:00:02,000 --> 00:00:05,000
[Nate Hardison, Harvard University]

3
00:00:05,000 --> 00:00:07,000
See on CS50, CS50.TV]

4
00:00:07,000 --> 00:00:10,000
Mõned kõige raskem vigu C programmide

5
00:00:10,000 --> 00:00:13,000
pärit halba mälu.

6
00:00:13,000 --> 00:00:15,000
Seal on tohutu hulk võimalusi, kuidas keerata asju,

7
00:00:15,000 --> 00:00:17,000
sealhulgas eraldades vale mälu,

8
00:00:17,000 --> 00:00:20,000
unustades initsialiseerida muutujad,

9
00:00:20,000 --> 00:00:23,000
kirjalikult enne või pärast selle lõppu puhver,

10
00:00:23,000 --> 00:00:25,000
ja vabastades hoida mälu mitu korda.

11
00:00:25,000 --> 00:00:28,000
Sümptomid ulatuvad vahelduva jookseb

12
00:00:28,000 --> 00:00:30,000
kuni müstiliselt kirjutatakse väärtused,

13
00:00:30,000 --> 00:00:34,000
sageli aset kohtades ja aegadel kaugel originaal viga.

14
00:00:34,000 --> 00:00:37,000
Tracing vaadeldav probleemi Tagasi aluseks oleva algpõhjus

15
00:00:37,000 --> 00:00:39,000
saab vaidlustada,

16
00:00:39,000 --> 00:00:42,000
kuid õnneks on kasulik programm nimega Valgrind

17
00:00:42,000 --> 00:00:44,000
et saab teha palju aidata.

18
00:00:44,000 --> 00:00:47,000
>> Sa jooksed programmi raames Valgrind võimaldada

19
00:00:47,000 --> 00:00:50,000
ulatuslik kontrollimine hunnik mälu eraldised ja juurdepääsud.

20
00:00:50,000 --> 00:00:53,000
Kui Valgrind tuvastab probleemi, see annab teile kohe,

21
00:00:53,000 --> 00:00:56,000
otsest teavet, mis võimaldab teil

22
00:00:56,000 --> 00:00:58,000
kergemini leida ja probleemi lahendada.

23
00:00:58,000 --> 00:01:01,000
Valgrind ka aruandeid vähem surmav mälu probleemid,

24
00:01:01,000 --> 00:01:04,000
nagu mälu lekib, eraldades hunnik mälu,

25
00:01:04,000 --> 00:01:07,000
, unustades, et vabastada ta.

26
00:01:07,000 --> 00:01:10,000
Nagu meie kompilaator, rõkkama, meie siluri GDB,

27
00:01:10,000 --> 00:01:14,000
Valgrind on vaba tarkvara, ja see on paigaldatud seade.

28
00:01:14,000 --> 00:01:16,000
Valgrind töötab oma binaarsel,

29
00:01:16,000 --> 00:01:20,000
ei oma. c või. h lähtekoodi failid,

30
00:01:20,000 --> 00:01:23,000
et olla kindel olete koostanud up-to-date koopia oma programmi

31
00:01:23,000 --> 00:01:25,000
kasutades rõkkama või teha.

32
00:01:25,000 --> 00:01:28,000
Siis töötab oma programmi alusel Valgrind saab

33
00:01:28,000 --> 00:01:32,000
nii lihtne, et prefixing standard programmi käsu sõna Valgrind,

34
00:01:32,000 --> 00:01:35,000
mis käivitub Valgrind ja käivitab programmi sees on.

35
00:01:35,000 --> 00:01:38,000
Kui alustada, Valgrind ei teatud keerulised

36
00:01:38,000 --> 00:01:41,000
jiggering seadistada käivitatava mälu kontrolli,

37
00:01:41,000 --> 00:01:44,000
nii et see võib võtta natuke, et saada valmis ja töötab.

38
00:01:44,000 --> 00:01:48,000
Programm siis täita tavaliselt, olgu see palju aeglasemalt,

39
00:01:48,000 --> 00:01:52,000
ja kui ta lõpetab, Valgrind prinditakse kokkuvõte selle mälukasutust.

40
00:01:52,000 --> 00:01:58,000
Kui kõik hästi läheb, siis näeb välja umbes selline:

41
00:01:58,000 --> 00:02:01,000
Sel juhul. / Clean_program

42
00:02:01,000 --> 00:02:04,000
on tee programmi ma tahan joosta.

43
00:02:04,000 --> 00:02:06,000
Ja kuigi see ei võta mingeid argumente,

44
00:02:06,000 --> 00:02:09,000
kui ta tegi ma lihtsalt kinnitada neid edasi käsu lõppu nagu tavaliselt.

45
00:02:09,000 --> 00:02:12,000
Clean programm on lihtsalt rumal väike programm lõin

46
00:02:12,000 --> 00:02:15,000
et eraldab ruumi ploki ints kohta hunnik,

47
00:02:15,000 --> 00:02:19,000
panna mõned väärtused sees neist, ja vabastab kogu blokeerida.

48
00:02:19,000 --> 00:02:23,000
See on see, mida sa pildistada, vigu ja lekked.

49
00:02:23,000 --> 00:02:27,000
>> Teine oluline mõõdik on baitide eraldatud.

50
00:02:27,000 --> 00:02:32,000
Sõltuvalt programmist, kui teie eraldised on megabaiti või suurem,

51
00:02:32,000 --> 00:02:34,000
oled ilmselt midagi valesti.

52
00:02:34,000 --> 00:02:37,000
Kas sa asjatult ladustamiseks duplikaate?

53
00:02:37,000 --> 00:02:40,000
Kas kasutate hunnik ladustamise, millal oleks parem kasutada korstnat?

54
00:02:40,000 --> 00:02:43,000
Niisiis, mälu vead võivad olla tõeliselt paha.

55
00:02:43,000 --> 00:02:46,000
Rohkem väljendunud need põhjustada tähelepanuväärne jookseb,

56
00:02:46,000 --> 00:02:49,000
kuid isegi siis võib veel olla raske avastada

57
00:02:49,000 --> 00:02:51,000
mida täpselt viinud krahhi.

58
00:02:51,000 --> 00:02:54,000
Rohkem salakavalasti, programmi mälu viga

59
00:02:54,000 --> 00:02:56,000
saab ikka koostada puhtalt

60
00:02:56,000 --> 00:02:58,000
ja saab veel tundub, et töö korrektselt

61
00:02:58,000 --> 00:03:01,000
sest sa suutsid saada õnnelik enamiku ajast.

62
00:03:01,000 --> 00:03:04,000
Pärast mitu "edukaid tulemusi,"

63
00:03:04,000 --> 00:03:07,000
võid lihtsalt arvan, et crash on juhus arvuti,

64
00:03:07,000 --> 00:03:10,000
kuid arvuti ei ole kunagi vale.

65
00:03:10,000 --> 00:03:13,000
>> Running Valgrind aitab teil tabada põhjus nähtav mälu vead

66
00:03:13,000 --> 00:03:18,000
samuti leida peituvad vead sa isegi ei tea veel umbes.

67
00:03:18,000 --> 00:03:22,000
Iga kord Valgrind tuvastab probleemi, see prindib info selle kohta, mida järgida.

68
00:03:22,000 --> 00:03:24,000
Iga kirje on üsna napisõnaline -

69
00:03:24,000 --> 00:03:27,000
allikas liin rikkuva juhendamine, mis on küsimus,

70
00:03:27,000 --> 00:03:30,000
ja vähe infot mälu seotud -

71
00:03:30,000 --> 00:03:34,000
kuid sageli on see piisavalt teavet, et suunata oma tähelepanu õigesse kohta.

72
00:03:34,000 --> 00:03:37,000
Siin on näide Valgrind töötab lollakas programmi

73
00:03:37,000 --> 00:03:40,000
mis teeb vale loetud hunnik mälu.

74
00:03:40,000 --> 00:03:49,000
Me ei näe vigu või hoiatusi koostamine.

75
00:03:49,000 --> 00:03:53,000
Uh-oh, viga kokkuvõte ütleb, et on kaks viga -

76
00:03:53,000 --> 00:03:56,000
kaks vale loetud suurus 4 - bytes, et on.

77
00:03:56,000 --> 00:04:01,000
Nii halb loeb toimus põhiülesanne invalid_read.c,

78
00:04:01,000 --> 00:04:04,000
esimene real 16 ja teine ​​rida 19.

79
00:04:04,000 --> 00:04:06,000
Vaatame kood.

80
00:04:06,000 --> 00:04:11,000
Paistab esimese osamakse printf üritab lugeda ühe int juba lõppenud meie mälu plokk.

81
00:04:11,000 --> 00:04:13,000
Kui me vaatame tagasi Valgrind toodanguna,

82
00:04:13,000 --> 00:04:16,000
näeme, et Valgrind rääkis meile just nii.

83
00:04:16,000 --> 00:04:19,000
Aadress me üritame lugeda algab 0 baiti

84
00:04:19,000 --> 00:04:22,000
Viimase aasta lõpuni ploki suurus 16 baiti -

85
00:04:22,000 --> 00:04:25,000
4 32-bit ints et me eraldatud.

86
00:04:25,000 --> 00:04:29,000
See tähendab, aadress püüdsime lugeda algab just lõpus meie blokaad,

87
00:04:29,000 --> 00:04:32,000
nagu me näeme meie halb printf kõne.

88
00:04:32,000 --> 00:04:36,000
Nüüd kehtetu loetud pruugi tunduda, et suur ja lahendamiseks,

89
00:04:36,000 --> 00:04:39,000
aga kui sa kasutad neid andmeid kontrollida voolu oma programmi -

90
00:04:39,000 --> 00:04:42,000
näiteks osana, kui avaldus või loop -

91
00:04:42,000 --> 00:04:45,000
siis asju saab vaikselt lähe halvaks.

92
00:04:45,000 --> 00:04:47,000
Vaata, kuidas ma saan käivitada invalid_read programmi

93
00:04:47,000 --> 00:04:50,000
ja midagi ebatavalist juhtub.

94
00:04:50,000 --> 00:04:52,000
Hirmutav, ah?

95
00:04:52,000 --> 00:04:56,000
>> Nüüd vaatame mõned rohkem erinevaid vigu, mis võivad tekkida oma koodi,

96
00:04:56,000 --> 00:04:59,000
ja me näeme, kuidas Valgrind avastab neid.

97
00:04:59,000 --> 00:05:01,000
Me lihtsalt nägime näiteks invalid_read,

98
00:05:01,000 --> 00:05:04,000
nii et nüüd lähme tutvu invalid_write.

99
00:05:04,000 --> 00:05:09,000
Jällegi, vigu või hoiatusi koostamine.

100
00:05:09,000 --> 00:05:12,000
Okei, Valgrind sõnul on kaks viga selles programmis -

101
00:05:12,000 --> 00:05:15,000
ja invalid_write ja invalid_read.

102
00:05:15,000 --> 00:05:18,000
Olgem tsekkata seda koodi.

103
00:05:18,000 --> 00:05:21,000
Paistab, meil näiteks klassikaline strlen pluss üks viga.

104
00:05:21,000 --> 00:05:24,000
Kood ei malloc pildi baidi ruumi

105
00:05:24,000 --> 00:05:26,000
jaoks / 0 iseloomu,

106
00:05:26,000 --> 00:05:30,000
nii et kui str koopia läks seda kirjutada aadressil ssubstrlen "cs50 rocks!"

107
00:05:30,000 --> 00:05:33,000
see kirjutas 1 bait juba lõppenud meie blokeerida.

108
00:05:33,000 --> 00:05:36,000
Invalid_read tuleb siis, kui me teeme oma üleskutset printf.

109
00:05:36,000 --> 00:05:40,000
Printf jõuab lugemine vigane mälu, kui ta loeb / 0 iseloom

110
00:05:40,000 --> 00:05:43,000
kui tundub lõpus selle E string on see trükkimiseks.

111
00:05:43,000 --> 00:05:45,000
Aga see kõik ei pääsenud Valgrind.

112
00:05:45,000 --> 00:05:48,000
Me näeme, et see on püütud invalid_write osana tn koopia

113
00:05:48,000 --> 00:05:51,000
on line 11 peamist ja invalid_read on osa printf.

114
00:05:51,000 --> 00:05:54,000
Rock, Valgrind.

115
00:05:54,000 --> 00:05:57,000
Jällegi, see ei pruugi tunduda suur asi.

116
00:05:57,000 --> 00:06:00,000
Me võime käivitada programm ikka ja väljaspool Valgrind

117
00:06:00,000 --> 00:06:03,000
ja ei näe mingit viga sümptomid.

118
00:06:03,000 --> 00:06:06,000
>> Kuid vaatame veidi erinevad käesoleva näha

119
00:06:06,000 --> 00:06:09,000
kuidas asjad saavad tõesti halb.

120
00:06:09,000 --> 00:06:14,000
Niisiis, antud, oleme kuritarvitanud asju rohkem kui lihtsalt natuke seda koodi.

121
00:06:14,000 --> 00:06:17,000
Me ainult eraldades ruumi hunnik kaks stringid

122
00:06:17,000 --> 00:06:19,000
pikkus cs50 kivid,

123
00:06:19,000 --> 00:06:22,000
Sel ajal, meenutades / 0 iseloomu.

124
00:06:22,000 --> 00:06:25,000
Aga siis me visata super-pikk string mälu plokk

125
00:06:25,000 --> 00:06:27,000
et S osutab.

126
00:06:27,000 --> 00:06:30,000
Kuidas mõjutab see olla mälu plokk, mis T punkte?

127
00:06:30,000 --> 00:06:34,000
Noh, kui T osutab mälu, et on lihtsalt kõrval S,

128
00:06:34,000 --> 00:06:37,000
tulevad just pärast seda,

129
00:06:37,000 --> 00:06:39,000
siis oleks võinud kirjutada ka osa T.

130
00:06:39,000 --> 00:06:41,000
Olgem käivitada selle koodi.

131
00:06:41,000 --> 00:06:43,000
Vaadake, mis juhtus.

132
00:06:43,000 --> 00:06:47,000
Stringid me hoida meie hunnik plokke nii paistis olevat trükitud õigesti.

133
00:06:47,000 --> 00:06:49,000
Miski tundub vale üldse.

134
00:06:49,000 --> 00:06:52,000
Kuid lähme tagasi meie koodi ja

135
00:06:52,000 --> 00:06:55,000
kommenteeri välja rida, kus me kopeerida cs50 kivid

136
00:06:55,000 --> 00:06:59,000
arvesse teise mälu plokk, osutas t.

137
00:06:59,000 --> 00:07:02,000
Nüüd, kui me teeme selle koodi peaksime

138
00:07:02,000 --> 00:07:06,000
ainult näha sisu Esimest mälu plokk välja printida.

139
00:07:06,000 --> 00:07:09,000
Vau, kuigi me ei tn koopia

140
00:07:09,000 --> 00:07:12,000
ühtegi märki arvesse teises hunnik plokk, üks viitas T,

141
00:07:12,000 --> 00:07:15,000
saame välja printida.

142
00:07:15,000 --> 00:07:18,000
Tõepoolest, string me topitakse meie esimene plokk

143
00:07:18,000 --> 00:07:21,000
overran esimene plokk ja sisse teise ploki,

144
00:07:21,000 --> 00:07:23,000
teha kõike tundu normaalne.

145
00:07:23,000 --> 00:07:26,000
Valgrind, aga ütleb meile tõestisündinud lugu.

146
00:07:26,000 --> 00:07:28,000
Nii juba läheb.

147
00:07:28,000 --> 00:07:32,000
Kõik need kehtetuks loeb ja kirjutab.

148
00:07:32,000 --> 00:07:36,000
>> Vaatame näiteks teist tüüpi viga.

149
00:07:36,000 --> 00:07:39,000
Siin me midagi üsna kahetsusväärne.

150
00:07:39,000 --> 00:07:41,000
Me haarata ruumi int kohta hunnik,

151
00:07:41,000 --> 00:07:45,000
ja me initsialiseerida int pointer - p - käsk, et ruumi.

152
00:07:45,000 --> 00:07:48,000
Kuigi meie osuti käivitub,

153
00:07:48,000 --> 00:07:52,000
andmeid, et see osutab vaid on mis iganes rämps on selles osas hunnik.

154
00:07:52,000 --> 00:07:55,000
Nii et kui me koormus, et andmed int i,

155
00:07:55,000 --> 00:07:57,000
me tehniliselt initsialiseerida i,

156
00:07:57,000 --> 00:08:00,000
kuid me teeme seda junk andmeid.

157
00:08:00,000 --> 00:08:03,000
Kõne väita, mis on mugav silumine makro

158
00:08:03,000 --> 00:08:06,000
määratletud tabavalt nimeks väita raamatukogu,

159
00:08:06,000 --> 00:08:09,000
katkestab programmi kui selle katsetingimustes ebaõnnestub.

160
00:08:09,000 --> 00:08:11,000
See tähendab, et kui ma ei ole 0.

161
00:08:11,000 --> 00:08:14,000
Sõltuvalt sellest, mida oli hunnik ruumi, osutas p,

162
00:08:14,000 --> 00:08:18,000
see programm võib töötada mõnikord ja ei suuda muul ajal.

163
00:08:18,000 --> 00:08:20,000
Kui see töötab, me lihtsalt saada õnnelik.

164
00:08:20,000 --> 00:08:24,000
Kompilaator ei saagi seda viga, kuid Valgrind kindel tahe.

165
00:08:24,000 --> 00:08:28,000
Seal näeme viga tuleneb meie kasutamisest, et junk andmeid.

166
00:08:28,000 --> 00:08:32,000
>> Kui eraldada hunnik mälu, kuid ei deallocate see või tasuta see,

167
00:08:32,000 --> 00:08:34,000
mida nimetatakse leke.

168
00:08:34,000 --> 00:08:37,000
Väikese, lühiajaline programm, mis töötab ja kohe väljapääsu,

169
00:08:37,000 --> 00:08:39,000
lekked on üsna valutu,

170
00:08:39,000 --> 00:08:42,000
kuid projekti jaoks suurematele ja / või pikaealisust,

171
00:08:42,000 --> 00:08:46,000
isegi väike leke võib ühend millekski suureks.

172
00:08:46,000 --> 00:08:49,000
Sest CS50, me ootame teid

173
00:08:49,000 --> 00:08:51,000
hoolitseda vabastades kõik hunnik mälu, mida eraldavad,

174
00:08:51,000 --> 00:08:54,000
kuna me tahame teid ehitada oskusi nõuetekohaselt käitlema käsitsi protsessi

175
00:08:54,000 --> 00:08:56,000
nõutud C.

176
00:08:56,000 --> 00:08:59,000
Selleks, teie programm peaks olema täpne

177
00:08:59,000 --> 00:09:03,000
üks-ühele kirjavahetus malloc ja tasuta kõned.

178
00:09:03,000 --> 00:09:06,000
Õnneks Valgrind aitab teil mälu lekkeid ka.

179
00:09:06,000 --> 00:09:09,000
Siin on lekkiv programmi nimega leak.c et eraldab

180
00:09:09,000 --> 00:09:13,000
ruumi hunnik, kirjutab ta, kuid ei vabasta see.

181
00:09:13,000 --> 00:09:16,000
Me kompileerida Mark ja kasutada seda vastavalt Valgrind,

182
00:09:16,000 --> 00:09:18,000
ja me näeme, et kuigi meil ei ole mälu vead,

183
00:09:18,000 --> 00:09:20,000
meil on üks lekkida.

184
00:09:20,000 --> 00:09:23,000
Seal on 16 baiti lõplikult kaotanud,

185
00:09:23,000 --> 00:09:27,000
mis tähendab, et kursor, et mälu ei ole ulatuselt kui programm sulgub.

186
00:09:27,000 --> 00:09:30,000
Nüüd Valgrind ei anna meile ton teavet leke,

187
00:09:30,000 --> 00:09:35,000
aga kui me järgime seda vähe tähele, et see annab alla põhja poole oma aruande

188
00:09:35,000 --> 00:09:38,000
kuni uuesti, koos - leke kontrollige = täis

189
00:09:38,000 --> 00:09:41,000
näha kõiki üksikasju lekkinud mälu,

190
00:09:41,000 --> 00:09:44,000
me saada rohkem informatsiooni.

191
00:09:44,000 --> 00:09:46,000
Nüüd, hunnik kokkuvõte,

192
00:09:46,000 --> 00:09:50,000
Valgrind ütleb meile, kus mälu, mis oli kadunud oli algselt eraldatud.

193
00:09:50,000 --> 00:09:52,000
Nii nagu me teame, vaadates lähtekoodi,

194
00:09:52,000 --> 00:09:55,000
Valgrind teatab meile, et me lekkinud mälu

195
00:09:55,000 --> 00:09:58,000
eraldamisel kõne malloc real 8 leak.c

196
00:09:58,000 --> 00:10:00,000
aastal põhiülesanne.

197
00:10:00,000 --> 00:10:02,000
Päris vahva.

198
00:10:02,000 --> 00:10:04,000
>> Valgrind kategoriseerib lekkeid kasutades neid termineid:

199
00:10:04,000 --> 00:10:07,000
Kindlasti kadunud - see on hunnik eraldatud mälu

200
00:10:07,000 --> 00:10:10,000
mille programm ei ole enam osuti.

201
00:10:10,000 --> 00:10:14,000
Valgrind teab, et sa kord oli osuti kuid on nüüdseks kaotanud jälgida seda.

202
00:10:14,000 --> 00:10:17,000
See mälu on kindlasti lekkinud.

203
00:10:17,000 --> 00:10:20,000
Kaudselt kadunud - see on hunnik eraldatud mälu

204
00:10:20,000 --> 00:10:24,000
mille ainus vihjeid Samuti on kadunud.

205
00:10:24,000 --> 00:10:27,000
Näiteks, kui olete kaotanud oma kursor esimese sõlme seotud nimekirja,

206
00:10:27,000 --> 00:10:30,000
siis esimese sõlme ise oleks kindlasti kaotanud,

207
00:10:30,000 --> 00:10:34,000
samas hilisemad sõlmed oleks kaudselt kadunud.

208
00:10:34,000 --> 00:10:37,000
Võimalik kadunud - see on hunnik eraldatud mälu

209
00:10:37,000 --> 00:10:41,000
mille Valgrind ei saa olla kindel, kas seal on viit või mitte.

210
00:10:41,000 --> 00:10:44,000
Ikka kättesaadav on hunnik eraldatud mälu

211
00:10:44,000 --> 00:10:47,000
mille programm on veel pointer exit

212
00:10:47,000 --> 00:10:50,000
mis tavaliselt tähendab, et globaalne muutuja osutab ta.

213
00:10:50,000 --> 00:10:53,000
Et näha neid lekkeid, siis on teil ka lisada võimalus

214
00:10:53,000 --> 00:10:55,000
- Endiselt kättesaadav = jah

215
00:10:55,000 --> 00:10:58,000
Teie appihüüde Valgrind.

216
00:10:58,000 --> 00:11:01,000
>> Need erinevad juhtumid võivad vajada erinevaid strateegiaid nende puhastamiseks üles

217
00:11:01,000 --> 00:11:05,000
kuid lekked tuleb kõrvaldada.

218
00:11:05,000 --> 00:11:08,000
Kahjuks millega lekked võivad olla raske teha,

219
00:11:08,000 --> 00:11:11,000
kuna ebaõige kõned tasuta saate õhkima oma programmi.

220
00:11:11,000 --> 00:11:14,000
Näiteks kui me vaatame invalid_free.c,

221
00:11:14,000 --> 00:11:18,000
näeme näiteks halb mälu deallocation.

222
00:11:18,000 --> 00:11:21,000
Milline peaks olema üks kõne, et vabastada kogu ploki

223
00:11:21,000 --> 00:11:24,000
mälu poolt esile tõstetud int_block,

224
00:11:24,000 --> 00:11:27,000
on selle asemel saanud katse vabastada iga int suurusega osa

225
00:11:27,000 --> 00:11:29,000
on mälu individuaalselt.

226
00:11:29,000 --> 00:11:32,000
See ei katastroofiliselt.

227
00:11:32,000 --> 00:11:34,000
Boom! Mis viga.

228
00:11:34,000 --> 00:11:36,000
See ei ole kindlasti hea.

229
00:11:36,000 --> 00:11:39,000
Kui sa oled ummikus selline viga, küll, ja sa ei tea, kust otsida,

230
00:11:39,000 --> 00:11:41,000
toetuda oma uue parima sõbra.

231
00:11:41,000 --> 00:11:44,000
Sa arvasid - Valgrind.

232
00:11:44,000 --> 00:11:47,000
Valgrind, nagu alati, teab täpselt, mis värk on.

233
00:11:47,000 --> 00:11:50,000
Alloc ja vaba arvud ei kattu üles.

234
00:11:50,000 --> 00:11:52,000
Meil 1 alloc ja 4 vabastab.

235
00:11:52,000 --> 00:11:55,000
Ja Valgrind ka ütleb meile, kus esimene halb tasuta kõne -

236
00:11:55,000 --> 00:11:58,000
üks, mis vallandas Plahvatus - on pärit -

237
00:11:58,000 --> 00:12:00,000
rida 16.

238
00:12:00,000 --> 00:12:03,000
Nagu näete, halb kõned tasuta on tõesti halb,

239
00:12:03,000 --> 00:12:05,000
nii et soovitame lasta oma programmi leke

240
00:12:05,000 --> 00:12:08,000
kui oled tööd saada funktsionaalsus õige.

241
00:12:08,000 --> 00:12:12,000
Start otsin lekkeid alles pärast teie programm töötab korralikult,

242
00:12:12,000 --> 00:12:14,000
ilma muid vigu.

243
00:12:14,000 --> 00:12:16,000
>> Ja ongi kõik meil selle video.

244
00:12:16,000 --> 00:12:18,000
Nüüd mida sa ootad?

245
00:12:18,000 --> 00:12:21,000
Mine jooksma Valgrind oma programme just nüüd.

246
00:12:21,000 --> 00:12:25,000
Minu nimi on Nate Hardison. See on CS50. [CS50.TV]