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, Sveučilište Harvard]

3
00:00:05,000 --> 00:00:07,000
Ovo je CS50, CS50.TV]

4
00:00:07,000 --> 00:00:10,000
Neki od najtežih bugova u C programima

5
00:00:10,000 --> 00:00:13,000
dolaze iz lošeg pamćenja.

6
00:00:13,000 --> 00:00:15,000
Postoji veliki broj načina da se vijak stvari,

7
00:00:15,000 --> 00:00:17,000
uključujući izdvajanja pogrešnu količinu memorije,

8
00:00:17,000 --> 00:00:20,000
zaboravljajući da inicijalizirati varijable,

9
00:00:20,000 --> 00:00:23,000
pisanje prije ili nakon završetka tampon,

10
00:00:23,000 --> 00:00:25,000
i oslobađanje zadržati memorijske više puta.

11
00:00:25,000 --> 00:00:28,000
Simptomi se kreću od povremenih ruši

12
00:00:28,000 --> 00:00:30,000
da misteriozno prebrisana vrijednosti,

13
00:00:30,000 --> 00:00:34,000
često na mjestima iu vremenima daleko od izvornog pogreške.

14
00:00:34,000 --> 00:00:37,000
Tragom promatranu problema vratiti na temeljne uzrok

15
00:00:37,000 --> 00:00:39,000
može biti izazov,

16
00:00:39,000 --> 00:00:42,000
ali srećom tu je pomogla program koji se zove Valgrind

17
00:00:42,000 --> 00:00:44,000
koji može učiniti puno pomoći.

18
00:00:44,000 --> 00:00:47,000
>> Možete pokrenuti program pod Valgrind kako bi se omogućilo

19
00:00:47,000 --> 00:00:50,000
opsežna provjera spremišta memorije izdvajanja i pristupa.

20
00:00:50,000 --> 00:00:53,000
Kada Valgrind otkrije problem, to vam daje neposredna,

21
00:00:53,000 --> 00:00:56,000
izravni podaci koji vam omogućuje da

22
00:00:56,000 --> 00:00:58,000
lakše pronaći i riješiti problem.

23
00:00:58,000 --> 00:01:01,000
Valgrind također izvješća o manje smrtonosnih memorijskih pitanjima,

24
00:01:01,000 --> 00:01:04,000
kao što su memorijske curenja, dodjele hrpa memorije,

25
00:01:04,000 --> 00:01:07,000
i zaboravljajući da ga oslobodi.

26
00:01:07,000 --> 00:01:10,000
Kao naš prevodilac, zveka, u našem debugger, gdb,

27
00:01:10,000 --> 00:01:14,000
Valgrind je slobodni softver, i to je instaliran na uređaj.

28
00:01:14,000 --> 00:01:16,000
Valgrind radi na vašem binarnom izvršnom,

29
00:01:16,000 --> 00:01:20,000
nije vaša. c ili. h izvorni kod datoteke,

30
00:01:20,000 --> 00:01:23,000
pa budite sigurni da ste sastavili up-to-date kopiju programa

31
00:01:23,000 --> 00:01:25,000
korištenje jeka ili napraviti.

32
00:01:25,000 --> 00:01:28,000
Zatim, prikazuju svoj program pod Valgrind može biti

33
00:01:28,000 --> 00:01:32,000
kao jednostavan kao samo prefiksa standardnu ​​programsku naredbu s riječju Valgrind,

34
00:01:32,000 --> 00:01:35,000
koji se pokreće Valgrind i pokreće program unutar njega.

35
00:01:35,000 --> 00:01:38,000
Prilikom pokretanja, Valgrind ne neki kompleks

36
00:01:38,000 --> 00:01:41,000
jiggering konfigurirati izvršnu za memorijske provjere,

37
00:01:41,000 --> 00:01:44,000
tako da se može uzeti malo da biste dobili gore i trčanje.

38
00:01:44,000 --> 00:01:48,000
Program će tada izvršiti normalno, bilo da se radi puno sporije,

39
00:01:48,000 --> 00:01:52,000
a kad završi, Valgrind će ispisati sažetak njegove memorije.

40
00:01:52,000 --> 00:01:58,000
Ako sve ide dobro, to će izgledati otprilike ovako:

41
00:01:58,000 --> 00:02:01,000
U ovom slučaju,. / Clean_program

42
00:02:01,000 --> 00:02:04,000
je put na programu želim pokrenuti.

43
00:02:04,000 --> 00:02:06,000
I dok to netko ne poduzimati nikakve argumente,

44
00:02:06,000 --> 00:02:09,000
ako je to učinio bih ih samo letati na kraju naredbe, kao i obično.

45
00:02:09,000 --> 00:02:12,000
Čisto program je samo glup mali program sam stvorio

46
00:02:12,000 --> 00:02:15,000
koje dodjeljuje prostor za blok Ints na hrpi,

47
00:02:15,000 --> 00:02:19,000
staviti neke vrijednosti unutar njih, i oslobađa cijeli blok.

48
00:02:19,000 --> 00:02:23,000
To je ono što snimate za, bez greške i bez curenja.

49
00:02:23,000 --> 00:02:27,000
>> Drugi važan podatak je ukupan broj bajtova dodijeljenih.

50
00:02:27,000 --> 00:02:32,000
Ovisno o programu, ako su vaši izdvajanja su u megabajta ili više,

51
00:02:32,000 --> 00:02:34,000
vjerojatno radite nešto krivo.

52
00:02:34,000 --> 00:02:37,000
Jeste li nepotrebno spremanje kopije?

53
00:02:37,000 --> 00:02:40,000
Koristite li hrpu za pohranu, kada bi bilo bolje koristiti stog?

54
00:02:40,000 --> 00:02:43,000
Dakle, memorijske pogreške mogu biti doista zlo.

55
00:02:43,000 --> 00:02:46,000
Što je više otvorenih one izazvati spektakularne ruši,

56
00:02:46,000 --> 00:02:49,000
ali čak i tada to još uvijek može biti teško odrediti

57
00:02:49,000 --> 00:02:51,000
što je točno dovelo do nesreće.

58
00:02:51,000 --> 00:02:54,000
Više podmuklo, program s memorijske greške

59
00:02:54,000 --> 00:02:56,000
još uvijek može sastaviti čisto

60
00:02:56,000 --> 00:02:58,000
i još uvijek se može činiti da rade ispravno

61
00:02:58,000 --> 00:03:01,000
zato što je uspio dobiti sretan većinu vremena.

62
00:03:01,000 --> 00:03:04,000
Nakon nekoliko uspješnih ishoda ","

63
00:03:04,000 --> 00:03:07,000
možda samo mislim da je sudar je slučajnost na računalu,

64
00:03:07,000 --> 00:03:10,000
ali računalo je nikada nije u krivu.

65
00:03:10,000 --> 00:03:13,000
>> Trčanje Valgrind može vam pomoći pronaći uzrok vidljivih memorije pogrešaka

66
00:03:13,000 --> 00:03:18,000
kao i pronaći vreba pogreške koje uopće ne još znati.

67
00:03:18,000 --> 00:03:22,000
Svaki put Valgrind otkrije problem, ispisuje informacije o tome što je to primijetio.

68
00:03:22,000 --> 00:03:24,000
Svaki predmet je prilično kratak -

69
00:03:24,000 --> 00:03:27,000
izvor linija prekršitelja nastave, u čemu je problem,

70
00:03:27,000 --> 00:03:30,000
i malo info o memoriji uključeni -

71
00:03:30,000 --> 00:03:34,000
ali često je dovoljno informacija da usmjeri svoju pozornost na pravom mjestu.

72
00:03:34,000 --> 00:03:37,000
Ovdje je primjer Valgrind trčanje na buggy programu

73
00:03:37,000 --> 00:03:40,000
da ne nevažeći pročitati hrpa memorije.

74
00:03:40,000 --> 00:03:49,000
Vidimo nema greške ili upozorenja u kompilaciju.

75
00:03:49,000 --> 00:03:53,000
Uh-oh, pogreška sažetak kaže da postoje dvije pogreške -

76
00:03:53,000 --> 00:03:56,000
dva nevažeća čita veličine 4 - bajtova, koji je.

77
00:03:56,000 --> 00:04:01,000
Oba loše čita dogodila u glavnom funkciji invalid_read.c,

78
00:04:01,000 --> 00:04:04,000
prvi na liniji 16 i drugi na liniji 19.

79
00:04:04,000 --> 00:04:06,000
Pogledajmo koda.

80
00:04:06,000 --> 00:04:11,000
Izgleda da je prvi poziv na printf pokušava pročitati jedan int prošlosti kraja našeg pamćenja bloka.

81
00:04:11,000 --> 00:04:13,000
Ako se osvrnemo na Valgrind je izlaz,

82
00:04:13,000 --> 00:04:16,000
vidimo da Valgrind rekao nam je da je točno.

83
00:04:16,000 --> 00:04:19,000
Adresa pokušavamo pročitati počinje 0 bytes

84
00:04:19,000 --> 00:04:22,000
prošlosti kraju bloka veličine 16 bajtova -

85
00:04:22,000 --> 00:04:25,000
četiri 32-bitne Ints da smo dodijeljeni.

86
00:04:25,000 --> 00:04:29,000
To je, adresa pokušavali smo čitati počinje pravo na kraju našeg bloka,

87
00:04:29,000 --> 00:04:32,000
Upravo kao što smo vidjeli u našem lošem printf poziva.

88
00:04:32,000 --> 00:04:36,000
Sada, nevažeći čita možda ne čini kao da je veliki posao,

89
00:04:36,000 --> 00:04:39,000
ali ako ste koristeći te podatke kontrolirati tijek svog programa -

90
00:04:39,000 --> 00:04:42,000
na primjer, kao dio ako izjava ili petlje -

91
00:04:42,000 --> 00:04:45,000
onda stvari tiho može ići loše.

92
00:04:45,000 --> 00:04:47,000
Pogledajte kako mogu pokrenuti invalid_read programa

93
00:04:47,000 --> 00:04:50,000
i ništa od običnih događa.

94
00:04:50,000 --> 00:04:52,000
Zastrašujuće, ha?

95
00:04:52,000 --> 00:04:56,000
>> Sada, pogledajmo neke više vrsta pogrešaka koje možete naići u svom kodu,

96
00:04:56,000 --> 00:04:59,000
pa ćemo vidjeti kako Valgrind ih otkrije.

97
00:04:59,000 --> 00:05:01,000
Upravo smo vidjeli primjer jednog invalid_read,

98
00:05:01,000 --> 00:05:04,000
pa sad ajmo provjeriti je invalid_write.

99
00:05:04,000 --> 00:05:09,000
Opet, nema pogreške ili upozorenja u kompilaciju.

100
00:05:09,000 --> 00:05:12,000
Ok, Valgrind kaže da postoje dvije pogreške u ovom programu -

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

102
00:05:15,000 --> 00:05:18,000
Idemo provjeriti ovaj kod.

103
00:05:18,000 --> 00:05:21,000
Izgleda da smo dobili primjerak klasične strlen plus jedan bug.

104
00:05:21,000 --> 00:05:24,000
Kod ne malloc dodatni byte prostora

105
00:05:24,000 --> 00:05:26,000
za / 0 karaktera,

106
00:05:26,000 --> 00:05:30,000
pa kad str kopija otišao da ga pisati na ssubstrlen "cs50 stijena!"

107
00:05:30,000 --> 00:05:33,000
to je napisao jedan bajt prošlosti kraja našeg bloka.

108
00:05:33,000 --> 00:05:36,000
The invalid_read dolazi kada smo napraviti naš poziv na printf.

109
00:05:36,000 --> 00:05:40,000
Printf završi čitanje nevažeći pamćenje kad čita / 0 karakter

110
00:05:40,000 --> 00:05:43,000
kao što izgleda na kraju ovog niza E to je tisak.

111
00:05:43,000 --> 00:05:45,000
No, ništa od toga pobjegao Valgrind.

112
00:05:45,000 --> 00:05:48,000
Vidimo da je uhvaćen invalid_write kao dio str primjerku

113
00:05:48,000 --> 00:05:51,000
na liniji 11 glavna i invalid_read dio printf.

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

115
00:05:54,000 --> 00:05:57,000
Opet, to ne može činiti kao veliki posao.

116
00:05:57,000 --> 00:06:00,000
Možemo pokrenuti ovaj program više i više izvan Valgrind

117
00:06:00,000 --> 00:06:03,000
i ne vidim nikakve simptome pogrešaka.

118
00:06:03,000 --> 00:06:06,000
>> Međutim, pogledajmo blagim varijacijama to vidjeti

119
00:06:06,000 --> 00:06:09,000
kako stvari mogu dobiti jako loše.

120
00:06:09,000 --> 00:06:14,000
Dakle, odobren, mi smo zloupotrebljavaju stvari više nego samo malo u ovom kodeksu.

121
00:06:14,000 --> 00:06:17,000
Mi samo ste dodjele prostora na hrpi za dvije žice

122
00:06:17,000 --> 00:06:19,000
duljina cs50 stijena,

123
00:06:19,000 --> 00:06:22,000
ovaj put, prisjećajući se / 0 karakter.

124
00:06:22,000 --> 00:06:25,000
Ali onda bacamo u super-dugi niz u memoriju blok

125
00:06:25,000 --> 00:06:27,000
da S pokazuje da.

126
00:06:27,000 --> 00:06:30,000
Što će učinak koji imaju na memorijsku blok koji ukazuje na T?

127
00:06:30,000 --> 00:06:34,000
Pa, ako je T ukazuje na memoriju koja je samo u susjedstvu S,

128
00:06:34,000 --> 00:06:37,000
dolaze tek nakon njega,

129
00:06:37,000 --> 00:06:39,000
tada smo mogli napisao preko dijelu T.

130
00:06:39,000 --> 00:06:41,000
Ajmo pokrenuti ovaj kod.

131
00:06:41,000 --> 00:06:43,000
Pogledajte što se dogodilo.

132
00:06:43,000 --> 00:06:47,000
Žice smo pohranjeni u našim spremišta blokova obje pojavili su tiskani ispravno.

133
00:06:47,000 --> 00:06:49,000
Ništa se čini u redu uopće.

134
00:06:49,000 --> 00:06:52,000
Međutim, vratimo se u naš kod i

135
00:06:52,000 --> 00:06:55,000
komentirati out liniju gdje smo kopirati cs50 stijene

136
00:06:55,000 --> 00:06:59,000
u drugom memorijskom bloku, istaknuo da su t.

137
00:06:59,000 --> 00:07:02,000
Sada, kada smo pokrenuti ovaj kod trebamo

138
00:07:02,000 --> 00:07:06,000
vidjeti samo sadržaj prve memorijske bloka isprintati.

139
00:07:06,000 --> 00:07:09,000
Opa, iako nismo str kopija

140
00:07:09,000 --> 00:07:12,000
bilo znakova u drugom hrpa bloka, jedan je istaknuo da je T,

141
00:07:12,000 --> 00:07:15,000
smo dobili ispis.

142
00:07:15,000 --> 00:07:18,000
Doista, niz mi punjena u našem prvom bloku

143
00:07:18,000 --> 00:07:21,000
pregazili prvi blok i u drugom bloku,

144
00:07:21,000 --> 00:07:23,000
čineći sve izgleda normalno.

145
00:07:23,000 --> 00:07:26,000
Valgrind, međutim, govori nam istinitu priču.

146
00:07:26,000 --> 00:07:28,000
Tu ćemo ići.

147
00:07:28,000 --> 00:07:32,000
Svi oni valjan čita i piše.

148
00:07:32,000 --> 00:07:36,000
>> Pogledajmo primjer druge vrste pogreške.

149
00:07:36,000 --> 00:07:39,000
Ovdje ćemo nešto napraviti, a nesretni.

150
00:07:39,000 --> 00:07:41,000
Mi zgrabite prostor za int na hrpi,

151
00:07:41,000 --> 00:07:45,000
i mi inicijalizirati pokazivač int - p - da pokazuje na tom prostoru.

152
00:07:45,000 --> 00:07:48,000
Međutim, dok je naš pokazivač inicijaliziran,

153
00:07:48,000 --> 00:07:52,000
podaci da je upućuju na upravo ono što je junk u tom dijelu hrpi.

154
00:07:52,000 --> 00:07:55,000
Dakle, kada smo učitali te podatke u int i,

155
00:07:55,000 --> 00:07:57,000
mi smo tehnički ja inicijalizirati,

156
00:07:57,000 --> 00:08:00,000
ali mi to učiniti s junk podataka.

157
00:08:00,000 --> 00:08:03,000
Poziv potvrditi, koji je zgodan za ispravljanje pogrešaka makro

158
00:08:03,000 --> 00:08:06,000
definirana u podesno zove tvrde knjižnici,

159
00:08:06,000 --> 00:08:09,000
će se prekinuti program ako je njegov ispitni uvjet ne uspije.

160
00:08:09,000 --> 00:08:11,000
To je, ako ja ne 0.

161
00:08:11,000 --> 00:08:14,000
Ovisno o tome što je u heap prostora, istaknuo p,

162
00:08:14,000 --> 00:08:18,000
ovaj program mogao raditi ponekad i uspjeti u drugim vremenima.

163
00:08:18,000 --> 00:08:20,000
Ako to radi, mi smo samo dobivanje sretan.

164
00:08:20,000 --> 00:08:24,000
Prevodilac neće uhvatiti tu pogrešku, ali Valgrind sigurni da će.

165
00:08:24,000 --> 00:08:28,000
Tu vidimo pogrešku koja proizlazi iz naše korištenje tog junk podataka.

166
00:08:28,000 --> 00:08:32,000
>> Kada izdvojiti hrpa memorije, ali ne drukčije pridijeliti ili ga osloboditi,

167
00:08:32,000 --> 00:08:34,000
koja se zove curenja.

168
00:08:34,000 --> 00:08:37,000
Za male, kratkotrajne programa koji traje i odmah izlaze,

169
00:08:37,000 --> 00:08:39,000
curi su prilično bezopasno,

170
00:08:39,000 --> 00:08:42,000
ali za projekt većih dimenzija i / ili dugovječnost,

171
00:08:42,000 --> 00:08:46,000
čak i mala curenja mogu udružiti u nešto duru.

172
00:08:46,000 --> 00:08:49,000
Za CS50, mi očekujemo da

173
00:08:49,000 --> 00:08:51,000
voditi brigu o oslobađanju sve hrpa memorije koju dodjeljujete,

174
00:08:51,000 --> 00:08:54,000
jer želimo izgraditi vještine za pravilno rukovanje postupkom ručnog

175
00:08:54,000 --> 00:08:56,000
zahtijeva C.

176
00:08:56,000 --> 00:08:59,000
Da biste to učinili, vaš program bi trebao imati točan

177
00:08:59,000 --> 00:09:03,000
jedan-na-jedan prepiska između malloc i besplatne pozive.

178
00:09:03,000 --> 00:09:06,000
Srećom, Valgrind može vam pomoći s memorijskim curenja previše.

179
00:09:06,000 --> 00:09:09,000
Ovdje je curi program koji se zove leak.c da dodijeli

180
00:09:09,000 --> 00:09:13,000
prostor na hrpi, piše na njega, ali ga ne oslobodi.

181
00:09:13,000 --> 00:09:16,000
Mi ga sastaviti sa Provjerite i pokrenite ga pod Valgrind,

182
00:09:16,000 --> 00:09:18,000
i vidimo da, dok nemamo memorijske pogreške,

183
00:09:18,000 --> 00:09:20,000
mi imamo jedan curenja.

184
00:09:20,000 --> 00:09:23,000
Postoji 16 bajtova definitivno izgubljena,

185
00:09:23,000 --> 00:09:27,000
što znači da je kazaljka na tom memorije nije bio u opsegu kada je program izašao.

186
00:09:27,000 --> 00:09:30,000
Sada, Valgrind ne daju nam tonu informacija o curenja,

187
00:09:30,000 --> 00:09:35,000
ali ako ćemo slijediti ovaj mali na umu da to daje dolje prema dnu svom izvješću

188
00:09:35,000 --> 00:09:38,000
na reprizu s - curenja provjerite = puni

189
00:09:38,000 --> 00:09:41,000
vidjeti sve pojedinosti o curenju memorije,

190
00:09:41,000 --> 00:09:44,000
ćemo dobiti više informacija.

191
00:09:44,000 --> 00:09:46,000
Sada, u heap sažetku,

192
00:09:46,000 --> 00:09:50,000
Valgrind nam govori gdje je memorija koja je izgubila prvobitno dodijeljena.

193
00:09:50,000 --> 00:09:52,000
Baš kao što znamo iz gleda u izvornom kodu,

194
00:09:52,000 --> 00:09:55,000
Valgrind nas obavještava da smo procurila memoriju

195
00:09:55,000 --> 00:09:58,000
dodjeljuje pozivom na malloc na liniji 8 od leak.c

196
00:09:58,000 --> 00:10:00,000
u glavnom funkciji.

197
00:10:00,000 --> 00:10:02,000
Prilično divan.

198
00:10:02,000 --> 00:10:04,000
>> Valgrind kategorizira curenja pomoću ove uvjete:

199
00:10:04,000 --> 00:10:07,000
Definitivno izgubili - to je gomila dodijeljena memorija

200
00:10:07,000 --> 00:10:10,000
na koje program više nema pokazivač.

201
00:10:10,000 --> 00:10:14,000
Valgrind zna da ste nekad imali pokazivač, ali od tada su izgubili pojam o tome.

202
00:10:14,000 --> 00:10:17,000
Ova memorija je definitivno procurila.

203
00:10:17,000 --> 00:10:20,000
Indirektno izgubili - to je gomila dodijeljena memorija

204
00:10:20,000 --> 00:10:24,000
na koje se samo upućuje na njega su također izgubili.

205
00:10:24,000 --> 00:10:27,000
Na primjer, ako ste izgubili svoj pokazivač na prvi čvor povezane liste,

206
00:10:27,000 --> 00:10:30,000
tada prvi čvor sama bi definitivno biti izgubljen,

207
00:10:30,000 --> 00:10:34,000
dok sve naknadne čvorovi bi posredno biti izgubljen.

208
00:10:34,000 --> 00:10:37,000
Možda izgubili - to je gomila dodijeljena memorija

209
00:10:37,000 --> 00:10:41,000
na koje Valgrind ne može biti siguran da li je pokazivač ili ne.

210
00:10:41,000 --> 00:10:44,000
Ipak dostupna je hrpa dodijeljena memorija

211
00:10:44,000 --> 00:10:47,000
na koje se program i dalje ima pokazivač na izlazu,

212
00:10:47,000 --> 00:10:50,000
što obično znači da je globalna varijabla ukazuje na to.

213
00:10:50,000 --> 00:10:53,000
Za provjeru tih curenja, također ćete morati uključiti opciju

214
00:10:53,000 --> 00:10:55,000
- Još uvijek dostupna = yes

215
00:10:55,000 --> 00:10:58,000
u zazivanjem Valgrind.

216
00:10:58,000 --> 00:11:01,000
>> Ti različiti slučajevi mogu zahtijevati različite strategije za njihovo čišćenje,

217
00:11:01,000 --> 00:11:05,000
ali curi bi trebao biti eliminiran.

218
00:11:05,000 --> 00:11:08,000
Nažalost, popravljajući curenje može biti teško za napraviti,

219
00:11:08,000 --> 00:11:11,000
od pogrešnih poziva na besplatno može raznijeti svoj program.

220
00:11:11,000 --> 00:11:14,000
Na primjer, ako gledamo invalid_free.c,

221
00:11:14,000 --> 00:11:18,000
vidimo primjer lošeg pamćenja deallocation.

222
00:11:18,000 --> 00:11:21,000
Što bi trebao biti jedan poziv da oslobodi cijeli blok

223
00:11:21,000 --> 00:11:24,000
memorije je istaknuo da po int_block,

224
00:11:24,000 --> 00:11:27,000
je umjesto postala pokušaj da se oslobodi svaki int veličine odjeljak

225
00:11:27,000 --> 00:11:29,000
sjećanja pojedinačno.

226
00:11:29,000 --> 00:11:32,000
To će uspjeti katastrofalno.

227
00:11:32,000 --> 00:11:34,000
Bum! Što pogreška.

228
00:11:34,000 --> 00:11:36,000
To definitivno nije dobro.

229
00:11:36,000 --> 00:11:39,000
Ako ste zapeli s tom vrstom pogreške, ipak, i vi ne znate gdje se mogu pogledati,

230
00:11:39,000 --> 00:11:41,000
padne natrag na svoj novi najbolji prijatelj.

231
00:11:41,000 --> 00:11:44,000
Pogodili ste - Valgrind.

232
00:11:44,000 --> 00:11:47,000
Valgrind, kao i uvijek, točno zna što je gore.

233
00:11:47,000 --> 00:11:50,000
U alloc i bez računa ne podudaraju.

234
00:11:50,000 --> 00:11:52,000
Imamo jednog alloc i 4 oslobađa.

235
00:11:52,000 --> 00:11:55,000
I Valgrind nam također govori gdje je prvi loš besplatan poziv -

236
00:11:55,000 --> 00:11:58,000
onaj koji pokreću Blowup - dolazi iz -

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

238
00:12:00,000 --> 00:12:03,000
Kao što možete vidjeti, loši pozivi za free su stvarno loše,

239
00:12:03,000 --> 00:12:05,000
pa preporučujemo ostavljajući svoju programsku curenja

240
00:12:05,000 --> 00:12:08,000
dok radite na dobivanje funkcionalnost točne.

241
00:12:08,000 --> 00:12:12,000
Početak u potrazi za curenje tek nakon vaš program radi ispravno,

242
00:12:12,000 --> 00:12:14,000
bez ikakvih drugih pogrešaka.

243
00:12:14,000 --> 00:12:16,000
>> I to je sve što imam za ovaj video.

244
00:12:16,000 --> 00:12:18,000
Sada ono što čekate?

245
00:12:18,000 --> 00:12:21,000
Idi pokrenuti Valgrind na vašim programima upravo sada.

246
00:12:21,000 --> 00:12:25,000
Moje ime je Nate Hardison. Ovo je CS50. [CS50.TV]