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
Ez CS50, CS50.TV]

4
00:00:07,000 --> 00:00:10,000
Néhány a legnehezebb hibákat a C programok

5
00:00:10,000 --> 00:00:13,000
származnak hűtlen emlékezet.

6
00:00:13,000 --> 00:00:15,000
Van egy hatalmas számos módon rontani a dolgokat,

7
00:00:15,000 --> 00:00:17,000
beleértve kiosztása a rossz memória,

8
00:00:17,000 --> 00:00:20,000
felejtés változók inicializálása,

9
00:00:20,000 --> 00:00:23,000
írás előtt vagy után a végén egy puffer,

10
00:00:23,000 --> 00:00:25,000
és felszabadítja tartsa memória többször.

11
00:00:25,000 --> 00:00:28,000
A tünetek terjedhet váratlan összeomlások

12
00:00:28,000 --> 00:00:30,000
A titokzatos felülíródnak értékek,

13
00:00:30,000 --> 00:00:34,000
gyakran olyan helyeken és időkben távol az eredeti hibát.

14
00:00:34,000 --> 00:00:37,000
Követése a megfigyelt problémát vissza a mögöttes kiváltó ok

15
00:00:37,000 --> 00:00:39,000
nagy kihívás lehet,

16
00:00:39,000 --> 00:00:42,000
de szerencsére van egy hasznos program neve Valgrind

17
00:00:42,000 --> 00:00:44,000
hogy sokat tehetnek, hogy segítsen.

18
00:00:44,000 --> 00:00:47,000
>> Ehhez egy programot futtatsz alapján Valgrind hogy

19
00:00:47,000 --> 00:00:50,000
kiterjedt ellenőrzése heap memóriakiosztás és hozzáférések.

20
00:00:50,000 --> 00:00:53,000
Ha Valgrind problémát észlel, akkor ad azonnali,

21
00:00:53,000 --> 00:00:56,000
közvetlen információt, amely lehetővé teszi, hogy

22
00:00:56,000 --> 00:00:58,000
könnyebben megtalálni és kijavítani a problémát.

23
00:00:58,000 --> 00:01:01,000
Valgrind is jelentéseket kevesebb halálos memória problémák,

24
00:01:01,000 --> 00:01:04,000
mint például a memória szivárgás, elosztásának kupac memória,

25
00:01:04,000 --> 00:01:07,000
és megfeledkezve arról, hogy kiszabadítsa azt.

26
00:01:07,000 --> 00:01:10,000
Mint a fordító, csenget a mi debugger, GDB,

27
00:01:10,000 --> 00:01:14,000
Valgrind szabad szoftver, és telepítve van a készülékre.

28
00:01:14,000 --> 00:01:16,000
Valgrind fut a bináris végrehajtható,

29
00:01:16,000 --> 00:01:20,000
nem az. c vagy. h forráskód fájlokat,

30
00:01:20,000 --> 00:01:23,000
úgyhogy győződjön meg róla, hogy összeállított egy up-to-date másolatot a program

31
00:01:23,000 --> 00:01:25,000
használatával csenget vagy Gyártmány.

32
00:01:25,000 --> 00:01:28,000
Ezután fut a program keretében Valgrind is lehet

33
00:01:28,000 --> 00:01:32,000
olyan egyszerű, mint csak raksz a standard program parancsot a szót Valgrind,

34
00:01:32,000 --> 00:01:35,000
amely elindul Valgrind és futtatja a programot belsejébe.

35
00:01:35,000 --> 00:01:38,000
Indításakor, Valgrind nem valami bonyolult

36
00:01:38,000 --> 00:01:41,000
jiggering beállítani végrehajtható a memória ellenőrzések

37
00:01:41,000 --> 00:01:44,000
így hogy egy kicsit, hogy kelj fel és működik.

38
00:01:44,000 --> 00:01:48,000
A program ezután végre rendesen, legyen sokkal lassabban,

39
00:01:48,000 --> 00:01:52,000
és amikor befejezi, Valgrind kiírja összefoglalót a memória használat.

40
00:01:52,000 --> 00:01:58,000
Ha minden jól megy, akkor valahogy így néz ki:

41
00:01:58,000 --> 00:02:01,000
Ebben az esetben a. / Clean_program

42
00:02:01,000 --> 00:02:04,000
a program elérési útja szeretnék futtatni.

43
00:02:04,000 --> 00:02:06,000
És amíg ez nem kerül semmilyen érvet,

44
00:02:06,000 --> 00:02:09,000
ha mégis Én csak tack őket, hogy a végén a parancs a szokásos módon.

45
00:02:09,000 --> 00:02:12,000
Clean program csak egy buta kis program általam létrehozott

46
00:02:12,000 --> 00:02:15,000
hogy osztja helyet egy blokk ints a halom,

47
00:02:15,000 --> 00:02:19,000
egy kis értékei bennük, és felszabadítja az egész blokk.

48
00:02:19,000 --> 00:02:23,000
Ez az, amit a forgatás, nem hiba és nem szivárog.

49
00:02:23,000 --> 00:02:27,000
>> Egy másik fontos metrika a bájtok számát különítettek el.

50
00:02:27,000 --> 00:02:32,000
Attól függően, hogy a program, ha a juttatások vannak a megabájt vagy magasabb,

51
00:02:32,000 --> 00:02:34,000
akkor valószínűleg csinál valamit rosszul.

52
00:02:34,000 --> 00:02:37,000
Ön feleslegesen ismétli tárolására?

53
00:02:37,000 --> 00:02:40,000
Ön használja a halom, a tárolás, amikor jobb lenne használni a stack?

54
00:02:40,000 --> 00:02:43,000
Szóval, memória hiba lehet igazán gonosz.

55
00:02:43,000 --> 00:02:46,000
Minél több nyilvánvaló is okoznak látványos összeomlik,

56
00:02:46,000 --> 00:02:49,000
de még akkor is még mindig nehéz pontosan

57
00:02:49,000 --> 00:02:51,000
hogy pontosan mi vezetett az összeomláshoz.

58
00:02:51,000 --> 00:02:54,000
Több alattomosan, a program a memória hiba

59
00:02:54,000 --> 00:02:56,000
még fordítani tisztán

60
00:02:56,000 --> 00:02:58,000
és továbbra is úgy tűnik, hogy működik helyesen

61
00:02:58,000 --> 00:03:01,000
mert sikerült szerencsés a legtöbb időt.

62
00:03:01,000 --> 00:03:04,000
Miután több "sikeres eredmények,"

63
00:03:04,000 --> 00:03:07,000
talán csak úgy gondolja, hogy egy baleset a szerencse a számítógép,

64
00:03:07,000 --> 00:03:10,000
de a számítógép soha nem téved.

65
00:03:10,000 --> 00:03:13,000
>> Futás Valgrind segítségével nyomára az oka a látható memória hiba

66
00:03:13,000 --> 00:03:18,000
valamint találta lappangó hibát nem is még tudni.

67
00:03:18,000 --> 00:03:22,000
Minden alkalommal, amikor Valgrind problémát észlel, akkor kiírja, hogy milyen is megfigyelhető.

68
00:03:22,000 --> 00:03:24,000
Minden elem meglehetősen tömör -

69
00:03:24,000 --> 00:03:27,000
a sornak a jogsértő utasítás, mi a kérdés,

70
00:03:27,000 --> 00:03:30,000
és egy kis információ a memóriában érintett -

71
00:03:30,000 --> 00:03:34,000
de gyakran elég információt irányítani a figyelmet, hogy a megfelelő helyre.

72
00:03:34,000 --> 00:03:37,000
Íme egy példa a Valgrind futó buggy programra

73
00:03:37,000 --> 00:03:40,000
amely nem érvénytelen olvasható a heap memória.

74
00:03:40,000 --> 00:03:49,000
Nem látjuk hibák és figyelmeztetések összeállítása.

75
00:03:49,000 --> 00:03:53,000
Uh-oh, a hiba összegzés azt mondja, hogy van két hiba -

76
00:03:53,000 --> 00:03:56,000
2 érvénytelen olvasás mérete 4 - bytes, hogy van.

77
00:03:56,000 --> 00:04:01,000
Mindkettő rossz beolvassa történt a fő funkciója invalid_read.c,

78
00:04:01,000 --> 00:04:04,000
Az első on line 16 és a második sorban 19.

79
00:04:04,000 --> 00:04:06,000
Nézzük meg a kódot.

80
00:04:06,000 --> 00:04:11,000
Úgy néz ki, mint az első hívást printf próbál olvasni egy int az elmúlt vége a memória blokk.

81
00:04:11,000 --> 00:04:13,000
Ha megnézzük vissza Valgrind kimeneti,

82
00:04:13,000 --> 00:04:16,000
azt látjuk, hogy Valgrind elmondta nekünk, hogy pontosan.

83
00:04:16,000 --> 00:04:19,000
A cím próbálunk olvasni kezdi 0 bájt

84
00:04:19,000 --> 00:04:22,000
múlt a végét a blokk méret 16 byte -

85
00:04:22,000 --> 00:04:25,000
4 32-bit ints hogy különítettek el.

86
00:04:25,000 --> 00:04:29,000
Ez azt jelenti, a cím igyekeztünk olvasni kezd jobbra a végén a mondat,

87
00:04:29,000 --> 00:04:32,000
ahogy látjuk, a mi rossz printf hívást.

88
00:04:32,000 --> 00:04:36,000
Most, érvénytelen olvasás talán nem tűnik olyan nagy üzlet,

89
00:04:36,000 --> 00:04:39,000
de ha használja ezeket az adatokat áramlását kontrollálják a program -

90
00:04:39,000 --> 00:04:42,000
Például részeként if vagy loop -

91
00:04:42,000 --> 00:04:45,000
akkor a dolgok csendben megy rossz.

92
00:04:45,000 --> 00:04:47,000
Nézd meg, hogyan lehet futtatni a programot invalid_read

93
00:04:47,000 --> 00:04:50,000
és semmi szokatlan történik.

94
00:04:50,000 --> 00:04:52,000
Ijesztő, mi?

95
00:04:52,000 --> 00:04:56,000
>> Most nézzük meg néhány fajta hiba, amit esetleg felmerülő a kódot,

96
00:04:56,000 --> 00:04:59,000
, és majd meglátjuk, hogyan Valgrind észleli őket.

97
00:04:59,000 --> 00:05:01,000
Most láttam egy példa egy invalid_read,

98
00:05:01,000 --> 00:05:04,000
így most nézzük meg egy invalid_write.

99
00:05:04,000 --> 00:05:09,000
Ismét nem hibák vagy figyelmeztetések összeállítása.

100
00:05:09,000 --> 00:05:12,000
Oké, Valgrind azt mondja, hogy van két hiba ebben a programban -

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

102
00:05:15,000 --> 00:05:18,000
Nézzük meg ezt a kódot.

103
00:05:18,000 --> 00:05:21,000
Úgy néz ki, most már van egy példány a klasszikus strlen plusz egy bug.

104
00:05:21,000 --> 00:05:24,000
A kód nem malloc extra byte helyet

105
00:05:24,000 --> 00:05:26,000
A / 0 karaktert,

106
00:05:26,000 --> 00:05:30,000
így amikor str másolatot elment írni azt ssubstrlen "CS50 sziklák!"

107
00:05:30,000 --> 00:05:33,000
azt írta, 1 byte az elmúlt vége a blokk.

108
00:05:33,000 --> 00:05:36,000
A invalid_read jön, amikor tesszük hívás printf.

109
00:05:36,000 --> 00:05:40,000
Printf végül olvasás érvénytelen memória, ha elolvassa a / 0 karakter

110
00:05:40,000 --> 00:05:43,000
mivel úgy néz ki, a végén az E húr ez nyomtatást.

111
00:05:43,000 --> 00:05:45,000
De mindez nem szökött Valgrind.

112
00:05:45,000 --> 00:05:48,000
Látjuk, hogy elkapta a invalid_write részeként str másolat

113
00:05:48,000 --> 00:05:51,000
on line 11 fő, és a invalid_read része printf.

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

115
00:05:54,000 --> 00:05:57,000
Ismét, ez talán nem tűnik nagy dolognak.

116
00:05:57,000 --> 00:06:00,000
Mi lehet futtatni ezt a programot, újra és újra kívül Valgrind

117
00:06:00,000 --> 00:06:03,000
és nem látok semmilyen hibát tüneteket.

118
00:06:03,000 --> 00:06:06,000
>> Azonban nézzük meg egy kis módosítás e látni

119
00:06:06,000 --> 00:06:09,000
hogy a dolgok nagyon rossz.

120
00:06:09,000 --> 00:06:14,000
Így biztosított, hogy visszaélnek a dolgokat több, mint egy kicsit ezt a kódot.

121
00:06:14,000 --> 00:06:17,000
Mi csak felosztásának a heap két húrok

122
00:06:17,000 --> 00:06:19,000
a hossza CS50 kőzetek,

123
00:06:19,000 --> 00:06:22,000
Ekkor eszébe jutott a / 0 karaktert.

124
00:06:22,000 --> 00:06:25,000
De aztán dobni egy szuper-hosszú string a memória blokk

125
00:06:25,000 --> 00:06:27,000
hogy az S mutat.

126
00:06:27,000 --> 00:06:30,000
Milyen hatása lesz, amelyek a memória blokk, hogy a T pontot?

127
00:06:30,000 --> 00:06:34,000
Nos, ha a T rámutat memória, amely csak szomszédos S,

128
00:06:34,000 --> 00:06:37,000
jön csak azt követően,

129
00:06:37,000 --> 00:06:39,000
akkor volna felülírni része T.

130
00:06:39,000 --> 00:06:41,000
Fussunk ezt a kódot.

131
00:06:41,000 --> 00:06:43,000
Nézd meg, mi történt.

132
00:06:43,000 --> 00:06:47,000
A húrok mi nálunk tárolt kupac blokkok mind úgy tűnt, hogy kinyomtatott helyesen.

133
00:06:47,000 --> 00:06:49,000
Úgy tűnik, semmi baj egyáltalán.

134
00:06:49,000 --> 00:06:52,000
Azonban, menjünk vissza a kódot, és

135
00:06:52,000 --> 00:06:55,000
megjegyzésbe a sort, ahol bemásolod CS50 sziklák

136
00:06:55,000 --> 00:06:59,000
a második memória blokk által mutatott t.

137
00:06:59,000 --> 00:07:02,000
Most, amikor ezt a kódot meg kellene

138
00:07:02,000 --> 00:07:06,000
csak látni a tartalmát az első memóriablokk kinyomtatni.

139
00:07:06,000 --> 00:07:09,000
Hú, még akkor is, nem str másolat

140
00:07:09,000 --> 00:07:12,000
karaktereket a második halom blokk, az egyik által mutatott T,

141
00:07:12,000 --> 00:07:15,000
kapunk egy nyomtatott ki.

142
00:07:15,000 --> 00:07:18,000
Valóban, a húr azt töltve az első mondatban

143
00:07:18,000 --> 00:07:21,000
lerohanták az első blokk, és a második mondatban,

144
00:07:21,000 --> 00:07:23,000
hogy mindent úgy tűnik normális.

145
00:07:23,000 --> 00:07:26,000
Valgrind, bár azt mondja, az igaz történet.

146
00:07:26,000 --> 00:07:28,000
Ott vagyunk.

147
00:07:28,000 --> 00:07:32,000
Minden e helytelenül olvas és ír.

148
00:07:32,000 --> 00:07:36,000
>> Nézzünk egy példát egy másik fajta hiba.

149
00:07:36,000 --> 00:07:39,000
Itt nem teszünk valamit, hanem szerencsétlen.

150
00:07:39,000 --> 00:07:41,000
Mi megragad hely int a halom,

151
00:07:41,000 --> 00:07:45,000
és mi inicializálni egy int pointer - p -, hogy pont ezt a helyet.

152
00:07:45,000 --> 00:07:48,000
Azonban, míg a mutató-ra,

153
00:07:48,000 --> 00:07:52,000
Az adatok, hogy ez a mutató csak a szemét, amit abban a része a kupac.

154
00:07:52,000 --> 00:07:55,000
Így, amikor betölti az adatokat figyelembe int i,

155
00:07:55,000 --> 00:07:57,000
mi technikailag initialize i,

156
00:07:57,000 --> 00:08:00,000
de mi ezt a szemét adatokat.

157
00:08:00,000 --> 00:08:03,000
A hívás állítani, ami egy praktikus hibakereső makró

158
00:08:03,000 --> 00:08:06,000
meghatározott, a találóan elnevezett állítják könyvtár,

159
00:08:06,000 --> 00:08:09,000
megszakítja a program, ha a vizsgált feltétel nem teljesül.

160
00:08:09,000 --> 00:08:11,000
Azaz, ha i nem 0.

161
00:08:11,000 --> 00:08:14,000
Attól függően, hogy mi volt a heap space, mutatott a p,

162
00:08:14,000 --> 00:08:18,000
ez a program is működik, és néha nem máskor.

163
00:08:18,000 --> 00:08:20,000
Ha ez működik, mi csak most szerencsés.

164
00:08:20,000 --> 00:08:24,000
A fordító nem fogja elkapni ezt a hibát, de a Valgrind biztos akaratát.

165
00:08:24,000 --> 00:08:28,000
Itt látjuk a hibát fakadó mi ezzel a junk adatok.

166
00:08:28,000 --> 00:08:32,000
>> Ha kiosztani heap memóriát, de nem deallocate, vagy szabad azt,

167
00:08:32,000 --> 00:08:34,000
hogy hívják a szivárgás.

168
00:08:34,000 --> 00:08:37,000
Egy kis, rövid életű program fut, és azonnal kilép,

169
00:08:37,000 --> 00:08:39,000
szivárgás meglehetősen ártalmatlan,

170
00:08:39,000 --> 00:08:42,000
de a projekt nagyobb méretű és / vagy hosszú élettartam,

171
00:08:42,000 --> 00:08:46,000
még egy kis szivárgás összetett valami nagy.

172
00:08:46,000 --> 00:08:49,000
A CS50, mi várjuk, hogy

173
00:08:49,000 --> 00:08:51,000
vigyázni felszabadítása összes halom memória, hogy osztja,

174
00:08:51,000 --> 00:08:54,000
mert azt akarjuk, hogy építeni a készséggel, hogy megfelelően kezelni a manuális folyamat

175
00:08:54,000 --> 00:08:56,000
által előírt C.

176
00:08:56,000 --> 00:08:59,000
Ehhez a program kell egy pontos

177
00:08:59,000 --> 00:09:03,000
one-to-one közötti levelezés malloc és free hívásokat.

178
00:09:03,000 --> 00:09:06,000
Szerencsére Valgrind tud segíteni memóriavesztés is.

179
00:09:06,000 --> 00:09:09,000
Itt van egy lyukas nevű program leak.c azt juttatja

180
00:09:09,000 --> 00:09:13,000
hely a heap, írja rá, de nem szabad azt.

181
00:09:13,000 --> 00:09:16,000
Mi fordítani azt gyártmánya és fuss ez alatt Valgrind,

182
00:09:16,000 --> 00:09:18,000
és látjuk, hogy míg nincs memória hiba,

183
00:09:18,000 --> 00:09:20,000
mi van egy szivárgás.

184
00:09:20,000 --> 00:09:23,000
Jelenleg 16 bájt egyértelműen elveszett,

185
00:09:23,000 --> 00:09:27,000
azt jelenti, hogy a mutatót, hogy a memória nem volt hatálya alá, amikor a program kilép.

186
00:09:27,000 --> 00:09:30,000
Most Valgrind nem ad nekünk egy csomó információt a szivárgás,

187
00:09:30,000 --> 00:09:35,000
, de ha követjük ezt a kis megjegyzést, hogy ez ad le alja felé jelentésének

188
00:09:35,000 --> 00:09:38,000
futtatni, a - szivárgás-check = teljes

189
00:09:38,000 --> 00:09:41,000
hogy a teljes részleteket szivárogtatott memória,

190
00:09:41,000 --> 00:09:44,000
szerzünk több információt.

191
00:09:44,000 --> 00:09:46,000
Most, a kupac összefoglaló

192
00:09:46,000 --> 00:09:50,000
Valgrind azt mondja, ha a memória, hogy elveszett az eredetileg kiosztott.

193
00:09:50,000 --> 00:09:52,000
Ahogy tudjuk, keresi a forráskódot,

194
00:09:52,000 --> 00:09:55,000
Valgrind tájékoztat bennünket, hogy kiszivárgott a memória

195
00:09:55,000 --> 00:09:58,000
kiosztott egy hívás malloc on line 8 A leak.c

196
00:09:58,000 --> 00:10:00,000
a fő funkciója.

197
00:10:00,000 --> 00:10:02,000
Elég klassz.

198
00:10:02,000 --> 00:10:04,000
>> Valgrind kategorizálja szivárgások használja ezeket a kifejezéseket:

199
00:10:04,000 --> 00:10:07,000
Mindenesetre vereség - ez a kupac memóriát

200
00:10:07,000 --> 00:10:10,000
amely a program már nem egy mutatót.

201
00:10:10,000 --> 00:10:14,000
Valgrind tudja, hogy egyszer volt a mutató, de azóta elvesztette követheti azt.

202
00:10:14,000 --> 00:10:17,000
Ez a memória határozottan kiszivárgott.

203
00:10:17,000 --> 00:10:20,000
Közvetetten vereség - ez a kupac memóriát

204
00:10:20,000 --> 00:10:24,000
, melyre a mutató azt is elvesznek.

205
00:10:24,000 --> 00:10:27,000
Például, ha elvesztetted a mutatót az első csomópont egy láncolt lista,

206
00:10:27,000 --> 00:10:30,000
akkor az első csomópont önmagában kell véglegesen elveszett,

207
00:10:30,000 --> 00:10:34,000
míg minden későbbi csomópontoknak közvetve elveszett.

208
00:10:34,000 --> 00:10:37,000
Valószínűleg vereség - ez a kupac memóriát

209
00:10:37,000 --> 00:10:41,000
amely Valgrind nem lehet biztos abban, hogy van egy mutató, vagy sem.

210
00:10:41,000 --> 00:10:44,000
Még mindig elérhető a kupac memóriát

211
00:10:44,000 --> 00:10:47,000
amely a programot még egy mutató a kijárat,

212
00:10:47,000 --> 00:10:50,000
ami általában azt jelenti, hogy egy globális változó mutat rá.

213
00:10:50,000 --> 00:10:53,000
Ahhoz, hogy ellenőrizze ezeket a szivárgás, akkor is tartalmaznia kell a lehetőséget

214
00:10:53,000 --> 00:10:55,000
- Még mindig elérhető = yes

215
00:10:55,000 --> 00:10:58,000
az Ön hívása Valgrind.

216
00:10:58,000 --> 00:11:01,000
>> Ezek a különböző esetekben szükség lehet különböző stratégiákat tisztító őket,

217
00:11:01,000 --> 00:11:05,000
de a szivárgást meg kell szüntetni.

218
00:11:05,000 --> 00:11:08,000
Sajnos rögzítéséről szivárog nehéz lehet csinálni,

219
00:11:08,000 --> 00:11:11,000
mivel a téves hívások ingyenesen lehet felrobbantani a program.

220
00:11:11,000 --> 00:11:14,000
Például, ha egy pillantást vetünk invalid_free.c,

221
00:11:14,000 --> 00:11:18,000
látunk példát rossz memória felszabadítás.

222
00:11:18,000 --> 00:11:21,000
Milyen legyen egy hívást, hogy kiszabadítsa az egész blokk

223
00:11:21,000 --> 00:11:24,000
memória által mutatott int_block,

224
00:11:24,000 --> 00:11:27,000
e helyett vált kísérletet, hogy kiszabadítsa az egyes int méretű szakasz

225
00:11:27,000 --> 00:11:29,000
a memória külön-külön.

226
00:11:29,000 --> 00:11:32,000
Ez nem fog sikerülni katasztrofálisan.

227
00:11:32,000 --> 00:11:34,000
Boom! Mi a hiba.

228
00:11:34,000 --> 00:11:36,000
Ez határozottan nem jó.

229
00:11:36,000 --> 00:11:39,000
Ha ragadt ilyen hiba, bár, és nem tudja, hol keresse,

230
00:11:39,000 --> 00:11:41,000
esik vissza az új legjobb barátja.

231
00:11:41,000 --> 00:11:44,000
Te találtad ki - Valgrind.

232
00:11:44,000 --> 00:11:47,000
Valgrind, mint mindig, pontosan tudja, hogy mi a helyzet.

233
00:11:47,000 --> 00:11:50,000
A alloc és ingyenes számít nem egyeznek meg.

234
00:11:50,000 --> 00:11:52,000
Van 1 alloc és 4 felszabadított.

235
00:11:52,000 --> 00:11:55,000
És Valgrind is elmondja, ha az első rossz ingyenes hívás -

236
00:11:55,000 --> 00:11:58,000
az egyik, hogy elindította a robbanás - jön -

237
00:11:58,000 --> 00:12:00,000
16 vezetéken.

238
00:12:00,000 --> 00:12:03,000
Amint látod, a rossz hívások felszabadítani nagyon rossz,

239
00:12:03,000 --> 00:12:05,000
ezért javasoljuk, bérbeadása a program szivárgás

240
00:12:05,000 --> 00:12:08,000
munka közben a szerzés a funkcionalitás helyes.

241
00:12:08,000 --> 00:12:12,000
Indítsa el a keresett szivárog után a program megfelelően működik,

242
00:12:12,000 --> 00:12:14,000
anélkül, hogy bármilyen más hibákat.

243
00:12:14,000 --> 00:12:16,000
>> És ez minden megvan ehhez a videóhoz.

244
00:12:16,000 --> 00:12:18,000
Most mit vársz?

245
00:12:18,000 --> 00:12:21,000
Tovább fut Valgrind a programokban most.

246
00:12:21,000 --> 00:12:25,000
A nevem Nate Hardison. Ez CS50. [CS50.TV]