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, Harvardin yliopisto]

3
00:00:05,000 --> 00:00:07,000
Tämä on CS50, CS50.TV]

4
00:00:07,000 --> 00:00:10,000
Jotkut vaikeimmista bugeja C ohjelmissa

5
00:00:10,000 --> 00:00:13,000
tulevat huonosta muistista.

6
00:00:13,000 --> 00:00:15,000
On olemassa valtava määrä tapoja ruuvi asioita,

7
00:00:15,000 --> 00:00:17,000
lukien jakaminen väärän muistin määrä

8
00:00:17,000 --> 00:00:20,000
unohtamatta alustaa muuttujat,

9
00:00:20,000 --> 00:00:23,000
kirjallisesti ennen tai sen jälkeen loppuun puskuria,

10
00:00:23,000 --> 00:00:25,000
ja vapauttaa pitää muistissa useita kertoja.

11
00:00:25,000 --> 00:00:28,000
Oireet vaihtelevat kaatumiset

12
00:00:28,000 --> 00:00:30,000
ja salaperäisesti päälle arvoja,

13
00:00:30,000 --> 00:00:34,000
usein paikoissa ja aikoina kaukana alkuperäisestä virhe.

14
00:00:34,000 --> 00:00:37,000
Jäljitys havaittu ongelma takaisin taustalla syynä

15
00:00:37,000 --> 00:00:39,000
voi olla haastavaa,

16
00:00:39,000 --> 00:00:42,000
mutta onneksi siellä on hyödyllinen ohjelma nimeltä Valgrind

17
00:00:42,000 --> 00:00:44,000
jotka voivat tehdä paljon auttaakseen.

18
00:00:44,000 --> 00:00:47,000
>> Voit suorittaa ohjelman nojalla Valgrind jotta

19
00:00:47,000 --> 00:00:50,000
laaja tarkastaminen kasan muistin jakaminen ja vierailuja.

20
00:00:50,000 --> 00:00:53,000
Kun Valgrind havaitsee ongelman, se antaa sinulle välittömästi,

21
00:00:53,000 --> 00:00:56,000
suoraa tietoa, jonka avulla voit

22
00:00:56,000 --> 00:00:58,000
helpommin löytää ja korjata ongelman.

23
00:00:58,000 --> 00:01:01,000
Valgrind myös raportit vähemmän tappava muistiongelmia,

24
00:01:01,000 --> 00:01:04,000
kuten muistivuotoja, jakaminen keon muistia,

25
00:01:04,000 --> 00:01:07,000
ja unohtaa sen vapauttamiseksi.

26
00:01:07,000 --> 00:01:10,000
Kuten meidän kääntäjä, clang, meidän debuggeri, GDB,

27
00:01:10,000 --> 00:01:14,000
Valgrind on ilmainen ohjelmisto, ja se on asennettu laitteeseen.

28
00:01:14,000 --> 00:01:16,000
Valgrind toimii teidän suoritettavassa,

29
00:01:16,000 --> 00:01:20,000
ei sinun. c tai. h lähdekooditiedostoihin,

30
00:01:20,000 --> 00:01:23,000
joten varmista, että olet koonnut ajan tasalla kopion ohjelmasta

31
00:01:23,000 --> 00:01:25,000
käyttäen clang tai Make.

32
00:01:25,000 --> 00:01:28,000
Sitten, suorittaa ohjelma alle Valgrind voidaan

33
00:01:28,000 --> 00:01:32,000
niin yksinkertainen kuin vain edeltävällä vakio ohjelman komento sana Valgrind,

34
00:01:32,000 --> 00:01:35,000
joka käynnistyy Valgrind ja käynnistää ohjelman sisälle.

35
00:01:35,000 --> 00:01:38,000
Kun aloitat, Valgrind ei monimutkaisia

36
00:01:38,000 --> 00:01:41,000
jiggering määrittää suoritettavan varten muistin tarkastuksia,

37
00:01:41,000 --> 00:01:44,000
joten se voi kestää hieman päästä vauhtiin.

38
00:01:44,000 --> 00:01:48,000
Ohjelma sitten suorittaa normaalisti, on se paljon hitaammin,

39
00:01:48,000 --> 00:01:52,000
ja kun se päättyy, Valgrind tulostaa yhteenvedon sen muistin käyttöä.

40
00:01:52,000 --> 00:01:58,000
Jos kaikki menee hyvin, se näyttää tältä:

41
00:01:58,000 --> 00:02:01,000
Tässä tapauksessa. / Clean_program

42
00:02:01,000 --> 00:02:04,000
on polku ohjelmaan haluan ajaa.

43
00:02:04,000 --> 00:02:06,000
Ja vaikka tämä ei ole mitään perusteluja,

44
00:02:06,000 --> 00:02:09,000
jos se ei olisin vain tack ne loppuun komennon normaalisti.

45
00:02:09,000 --> 00:02:12,000
Clean-ohjelma on vain typerä pieni ohjelma Loin

46
00:02:12,000 --> 00:02:15,000
joka jakaa tilaa lohko ints kasaan,

47
00:02:15,000 --> 00:02:19,000
laittaa arvot itseensä, ja vapauttaa koko korttelin.

48
00:02:19,000 --> 00:02:23,000
Tämä on mitä kuvaat varten, ei virheitä eikä vuotoja.

49
00:02:23,000 --> 00:02:27,000
>> Toinen tärkeä metriikka on tavujen kokonaismäärä jaetaan.

50
00:02:27,000 --> 00:02:32,000
Riippuen ohjelmasta, jos määrärahat ovat megatavuina tai uudempi,

51
00:02:32,000 --> 00:02:34,000
olet luultavasti jotain väärin.

52
00:02:34,000 --> 00:02:37,000
Oletko turhaan varastointiin kaksoiskappaleet?

53
00:02:37,000 --> 00:02:40,000
Käytätkö kasan varastointiin, jolloin se olisi parempi käyttää pino?

54
00:02:40,000 --> 00:02:43,000
Joten, muisti virheitä voi olla todella paha.

55
00:02:43,000 --> 00:02:46,000
Avoimempi niistä aiheuttaa näyttäviä kaatumisia,

56
00:02:46,000 --> 00:02:49,000
mutta silloinkin se voi silti olla vaikea paikantaa

57
00:02:49,000 --> 00:02:51,000
mitä johti kaatua.

58
00:02:51,000 --> 00:02:54,000
Enemmän salakavalasti, ohjelman muistin virhe

59
00:02:54,000 --> 00:02:56,000
voi vielä koota siististi

60
00:02:56,000 --> 00:02:58,000
ja voi silti tunnu toimivan oikein

61
00:02:58,000 --> 00:03:01,000
koska olet onnistunut saamaan onnekas suurimman osan ajasta.

62
00:03:01,000 --> 00:03:04,000
Kun useita "onnistuneita tuloksia"

63
00:03:04,000 --> 00:03:07,000
saatat ajatella, että onnettomuudessa on onnenpotku tietokoneen,

64
00:03:07,000 --> 00:03:10,000
mutta tietokone ei ole koskaan väärässä.

65
00:03:10,000 --> 00:03:13,000
>> Juoksu Valgrind avulla voit jäljittää syy näkyvän muistinloppumisvirheitä

66
00:03:13,000 --> 00:03:18,000
sekä löytää väijyvä virheitä et edes vielä tiedä.

67
00:03:18,000 --> 00:03:22,000
Aina Valgrind havaitsee ongelman, se tulostaa tiedot siitä, mitä havaitaan.

68
00:03:22,000 --> 00:03:24,000
Jokainen tuote on melko niukkasanainen -

69
00:03:24,000 --> 00:03:27,000
lähde linja rikkoneen opetusta, mikä ongelma on,

70
00:03:27,000 --> 00:03:30,000
ja vähän tietoa muistin mukana -

71
00:03:30,000 --> 00:03:34,000
mutta usein se on tarpeeksi tietoa ohjata huomiota oikeaan paikkaan.

72
00:03:34,000 --> 00:03:37,000
Tässä on esimerkki Valgrind käynnissä viallisista ohjelman

73
00:03:37,000 --> 00:03:40,000
että ei kelpaa lukea kasan muistia.

74
00:03:40,000 --> 00:03:49,000
Emme näe mitään virheitä tai varoituksia kokoelma.

75
00:03:49,000 --> 00:03:53,000
Uh-oh, virhe yhteenvedon mukaan on olemassa kaksi virhettä -

76
00:03:53,000 --> 00:03:56,000
kaksi virheellinen luettu joiden koko oli 4 - tavua, että on.

77
00:03:56,000 --> 00:04:01,000
Molemmat huono lukee tapahtunut päätehtävä invalid_read.c,

78
00:04:01,000 --> 00:04:04,000
ensimmäisellä rivillä 16 ja toisella rivillä 19.

79
00:04:04,000 --> 00:04:06,000
Katsotaanpa koodi.

80
00:04:06,000 --> 00:04:11,000
Näyttää ensimmäisen puhelun printf yrittää lukea yksi int ohi lopussa meidän muisti estää.

81
00:04:11,000 --> 00:04:13,000
Jos katsomme taaksepäin Valgrind tuotokseen,

82
00:04:13,000 --> 00:04:16,000
näemme, että Valgrind kertoi meille juuri sitä.

83
00:04:16,000 --> 00:04:19,000
Osoite yritämme lukea käynnistyy 0 tavua

84
00:04:19,000 --> 00:04:22,000
pään ohi lohkon koko 16 tavua -

85
00:04:22,000 --> 00:04:25,000
neljään 32-bittinen ints että me myönnetty.

86
00:04:25,000 --> 00:04:29,000
Eli osoite yritimme lukea alkaa aivan lopussa meidän lohkon,

87
00:04:29,000 --> 00:04:32,000
kuten näemme huono printf puhelun.

88
00:04:32,000 --> 00:04:36,000
Nyt kelpaa luettu ei ehkä kuulosta kovin iso juttu,

89
00:04:36,000 --> 00:04:39,000
mutta jos käytät että tietoja virtausta ohjelma -

90
00:04:39,000 --> 00:04:42,000
esimerkiksi osana jos ilmoitus tai silmukka -

91
00:04:42,000 --> 00:04:45,000
Sitten asiat voivat äänettömästi mennä huonosti.

92
00:04:45,000 --> 00:04:47,000
Katso, miten voin ajaa invalid_read ohjelma

93
00:04:47,000 --> 00:04:50,000
eikä mitään tavallisuudesta tapahtuu.

94
00:04:50,000 --> 00:04:52,000
Pelottava, eikö?

95
00:04:52,000 --> 00:04:56,000
>> Nyt, katsotaanpa hieman erilaisia ​​virheitä, joita saattaa esiintyä koodissa,

96
00:04:56,000 --> 00:04:59,000
ja näemme kuinka Valgrind tunnistaa ne.

97
00:04:59,000 --> 00:05:01,000
Näimme esimerkin invalid_read,

98
00:05:01,000 --> 00:05:04,000
joten nyt mennään tarkistaa invalid_write.

99
00:05:04,000 --> 00:05:09,000
Jälleen, ei virheitä tai varoituksia kokoelma.

100
00:05:09,000 --> 00:05:12,000
Okei, Valgrind sanoo, että on olemassa kaksi virhettä tässä ohjelmassa -

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

102
00:05:15,000 --> 00:05:18,000
Katsotaanpa tarkistaa tätä koodia.

103
00:05:18,000 --> 00:05:21,000
Näyttää meillä esiintymän klassinen strlen plus yksi bugi.

104
00:05:21,000 --> 00:05:24,000
Koodi ei malloc ylimääräistä tavun tilaa

105
00:05:24,000 --> 00:05:26,000
varten / 0 luonnetta,

106
00:05:26,000 --> 00:05:30,000
joten kun str kopio meni kirjoittamaan sitä ssubstrlen "cs50 rocks!"

107
00:05:30,000 --> 00:05:33,000
se kirjoitti 1 tavu ohi lopussa meidän lohko.

108
00:05:33,000 --> 00:05:36,000
Invalid_read tulee, kun teemme puhelun printf.

109
00:05:36,000 --> 00:05:40,000
Printf päätyy lukemalla kelpaa muistia, kun se lukee / 0 hahmo

110
00:05:40,000 --> 00:05:43,000
koska se näyttää lopussa tämän E-kieli on tulostuksen.

111
00:05:43,000 --> 00:05:45,000
Mutta mikään tästä pakeni Valgrind.

112
00:05:45,000 --> 00:05:48,000
Näemme, että pyydetty invalid_write osana str kopion

113
00:05:48,000 --> 00:05:51,000
rivillä 11 tärkeimpien 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älleen kerran, tämä ei ehkä tunnu iso juttu.

116
00:05:57,000 --> 00:06:00,000
Voimme ajaa ohjelman uudestaan ​​ja uudestaan ​​ulkopuolella Valgrind

117
00:06:00,000 --> 00:06:03,000
eikä näe mitään virhettä oireita.

118
00:06:03,000 --> 00:06:06,000
>> Kuitenkin Katsotaanpa hieman vaihtelua tämän nähdä

119
00:06:06,000 --> 00:06:09,000
miten asiat voidaan saada todella huono.

120
00:06:09,000 --> 00:06:14,000
Joten, myönnetään, olemme väärin asioita enemmän kuin vain hieman tätä koodia.

121
00:06:14,000 --> 00:06:17,000
Olemme vain jakaa tilaa kasaan kaksi jousille

122
00:06:17,000 --> 00:06:19,000
pituus cs50 kiviä,

123
00:06:19,000 --> 00:06:22,000
tällä kertaa, muistaa / 0 luonnetta.

124
00:06:22,000 --> 00:06:25,000
Mutta sitten heittää erittäin pitkä merkkijono muistilohkoon

125
00:06:25,000 --> 00:06:27,000
että S on osoittaa.

126
00:06:27,000 --> 00:06:30,000
Mitä vaikutuksia tällä on muistin lohko, T viittaa?

127
00:06:30,000 --> 00:06:34,000
No, jos T viittaa muistia on vain vieressä S-

128
00:06:34,000 --> 00:06:37,000
tulossa vain sen jälkeen,

129
00:06:37,000 --> 00:06:39,000
Sitten olisimme kirjoittaneet yli osan T.

130
00:06:39,000 --> 00:06:41,000
Katsotaanpa suorittaa tämän koodin.

131
00:06:41,000 --> 00:06:43,000
Katsokaa mitä tapahtui.

132
00:06:43,000 --> 00:06:47,000
Strings me varastoituu kasaan korttelin molemmat näytti tulostaa oikein.

133
00:06:47,000 --> 00:06:49,000
Mikään ei näytä väärin ollenkaan.

134
00:06:49,000 --> 00:06:52,000
Kuitenkin, mennään takaisin meidän koodi ja

135
00:06:52,000 --> 00:06:55,000
kommentti, rivi, jossa me kopioida cs50 kiviä

136
00:06:55,000 --> 00:06:59,000
toiseen muistiin lohko, viittasi t.

137
00:06:59,000 --> 00:07:02,000
Nyt, kun otamme tämän koodin meidän pitäisi

138
00:07:02,000 --> 00:07:06,000
vain nähdä sisällön ensimmäisen muistilohkon tulostaa.

139
00:07:06,000 --> 00:07:09,000
Hei, vaikka emme str kopiota

140
00:07:09,000 --> 00:07:12,000
merkkejä toiseen kasaan lohko, joka huomautti T,

141
00:07:12,000 --> 00:07:15,000
saamme tulostaa.

142
00:07:15,000 --> 00:07:18,000
Itse merkkijono me tungetaan ensimmäinen lohko

143
00:07:18,000 --> 00:07:21,000
levisivät ensimmäinen lohko ja toiseen lohkoon,

144
00:07:21,000 --> 00:07:23,000
tekee kaiken näyttämään normaalia.

145
00:07:23,000 --> 00:07:26,000
Valgrind kuitenkin kertoo tositapahtumiin.

146
00:07:26,000 --> 00:07:28,000
Siellä mennään.

147
00:07:28,000 --> 00:07:32,000
Kaikki nämä virheellinen lukee ja kirjoittaa.

148
00:07:32,000 --> 00:07:36,000
>> Katsotaanpa esimerkki toisenlaisen virheen.

149
00:07:36,000 --> 00:07:39,000
Täällä teemme jotakin melko ikävää.

150
00:07:39,000 --> 00:07:41,000
Me napata tilaa int kasaan,

151
00:07:41,000 --> 00:07:45,000
ja me alustaa int osoitin - p - osoittamaan, että tilaa.

152
00:07:45,000 --> 00:07:48,000
Kuitenkin, kun taas meidän osoitin on alustettu,

153
00:07:48,000 --> 00:07:52,000
tiedot, että se on suunnattu vain on mitä roskaa on, että osa kasaan.

154
00:07:52,000 --> 00:07:55,000
Joten kun lataat että dataa int i,

155
00:07:55,000 --> 00:07:57,000
Olemme teknisesti alustaa i,

156
00:07:57,000 --> 00:08:00,000
mutta teemme niin roskaa tietoihin.

157
00:08:00,000 --> 00:08:03,000
Puhelun puolustamaan, joka on kätevä virheenkorjaus makro

158
00:08:03,000 --> 00:08:06,000
määritelty osuvasti nimetty väittävät kirjasto,

159
00:08:06,000 --> 00:08:09,000
tulee keskeyttää ohjelman, jos sen testiolosuhteissa epäonnistuu.

160
00:08:09,000 --> 00:08:11,000
Toisin sanoen, jos i ei ole 0.

161
00:08:11,000 --> 00:08:14,000
Riippuen siitä, mitä oli kasaan avaruudessa, huomautti P,

162
00:08:14,000 --> 00:08:18,000
tämä ohjelma voisi toimia joskus ja epäonnistua muina aikoina.

163
00:08:18,000 --> 00:08:20,000
Jos se toimii, me vain saada onnekas.

164
00:08:20,000 --> 00:08:24,000
Kääntäjä ei kiinni tämän virheen, mutta Valgrind varma tahtoa.

165
00:08:24,000 --> 00:08:28,000
Siellä näemme virhe johtuvat käytämme tätä roskaa tietoja.

166
00:08:28,000 --> 00:08:32,000
>> Kun jakaa keon muistia, mutta älä deallocate sitä tai vapauttaa sen,

167
00:08:32,000 --> 00:08:34,000
että kutsutaan vuoto.

168
00:08:34,000 --> 00:08:37,000
Pienelle, lyhytaikainen ohjelma, joka toimii ja heti ulos,

169
00:08:37,000 --> 00:08:39,000
vuodot ovat melko harmittomia,

170
00:08:39,000 --> 00:08:42,000
mutta hankkeen suuremman koon ja / tai pitkäikäisyyttä,

171
00:08:42,000 --> 00:08:46,000
pienikin vuoto voi pahentaa osaksi jotain suurta.

172
00:08:46,000 --> 00:08:49,000
Sillä CS50 Emme odota teidän

173
00:08:49,000 --> 00:08:51,000
huolehtia vapauttaa kaikki keon muistin että voit jakaa,

174
00:08:51,000 --> 00:08:54,000
koska haluamme rakentaa taitoja kunnolla käsittelemään manuaalisia

175
00:08:54,000 --> 00:08:56,000
edellyttämät C.

176
00:08:56,000 --> 00:08:59,000
Voit tehdä ohjelma olisi tarkka

177
00:08:59,000 --> 00:09:03,000
yksi-yhteen vastaavuus välillä malloc ja ilmaiset puhelut.

178
00:09:03,000 --> 00:09:06,000
Onneksi Valgrind voi auttaa sinua muistivuotoja liikaa.

179
00:09:06,000 --> 00:09:09,000
Tässä on vuotava ohjelma nimeltä leak.c joka jakaa

180
00:09:09,000 --> 00:09:13,000
tilaa kasaan, kirjoittaa siihen, mutta ei vapauttaa sen.

181
00:09:13,000 --> 00:09:16,000
Laadimme sitä Merkki ja suorita sille Valgrind,

182
00:09:16,000 --> 00:09:18,000
ja näemme, että vaikka meillä ei ole muistia virheitä,

183
00:09:18,000 --> 00:09:20,000
meillä on yksi vuoto.

184
00:09:20,000 --> 00:09:23,000
On 16 tavua menettänyt lopullisesti,

185
00:09:23,000 --> 00:09:27,000
siten, että osoitin, että muisti ei ole laajuudeltaan, kun ohjelma poistutaan.

186
00:09:27,000 --> 00:09:30,000
Nyt, Valgrind ei anna meille ton tietoa vuotaa,

187
00:09:30,000 --> 00:09:35,000
mutta jos noudatamme tätä pikku merkille, että se antaa pohjaa vasten sen raportin

188
00:09:35,000 --> 00:09:38,000
ja uusintana kanssa - vuoto-check = täysin

189
00:09:38,000 --> 00:09:41,000
nähdä täydelliset tiedot vuotanut muistia,

190
00:09:41,000 --> 00:09:44,000
saamme enemmän tietoa.

191
00:09:44,000 --> 00:09:46,000
Nyt kasaan yhteenveto,

192
00:09:46,000 --> 00:09:50,000
Valgrind kertoo jos muistia hävisi alunperin jaettu.

193
00:09:50,000 --> 00:09:52,000
Aivan kuten tiedämme katsomalla lähdekoodia,

194
00:09:52,000 --> 00:09:55,000
Valgrind kertoo meille, että me vuotanut muistia

195
00:09:55,000 --> 00:09:58,000
kohdennetaan puhelun malloc rivillä 8 leak.c

196
00:09:58,000 --> 00:10:00,000
in päätehtävä.

197
00:10:00,000 --> 00:10:02,000
Aika näppärä.

198
00:10:02,000 --> 00:10:04,000
>> Valgrind luokittelee vuodot näillä hakusanoilla:

199
00:10:04,000 --> 00:10:07,000
Ehdottomasti menetetty - tämä on kasa jaettu muisti

200
00:10:07,000 --> 00:10:10,000
jolle ohjelma ei enää ole osoitinta.

201
00:10:10,000 --> 00:10:14,000
Valgrind tietää, että olet kerran ollut osoitin, mutta on sittemmin kadottaa sen.

202
00:10:14,000 --> 00:10:17,000
Tämä muisti on varmasti vuotanut.

203
00:10:17,000 --> 00:10:20,000
Välillisesti menetetty - tämä on kasa jaettu muisti

204
00:10:20,000 --> 00:10:24,000
johon ainoastaan ​​osoittimia se myös menetetään.

205
00:10:24,000 --> 00:10:27,000
Esimerkiksi, jos olet menettänyt osoitin ensimmäiseen solmuun linkitetty lista,

206
00:10:27,000 --> 00:10:30,000
Sitten ensimmäinen solmu itse olisi varmasti menetetty,

207
00:10:30,000 --> 00:10:34,000
taas myöhemmin solmuja olisi epäsuorasti menetetty.

208
00:10:34,000 --> 00:10:37,000
Mahdollisesti menetetty - tämä on kasa jaettu muisti

209
00:10:37,000 --> 00:10:41,000
jonka Valgrind ei voi olla varma, onko osoitin tai ei.

210
00:10:41,000 --> 00:10:44,000
Edelleen tavoitettavissa on kasa jaettu muisti

211
00:10:44,000 --> 00:10:47,000
jonka ohjelma on vielä osoitin exit

212
00:10:47,000 --> 00:10:50,000
mikä yleensä tarkoittaa, että globaali muuttuja osoittaa sen.

213
00:10:50,000 --> 00:10:53,000
Voit tarkistaa nämä vuodot, sinun on myös sisällytettävä mahdollisuus

214
00:10:53,000 --> 00:10:55,000
- Yhä tavoitettavissa = kyllä

215
00:10:55,000 --> 00:10:58,000
oman vetoaminen Valgrind.

216
00:10:58,000 --> 00:11:01,000
>> Nämä eri tapaukset saattavat vaatia erilaisia ​​strategioita puhdistamiseen niitä,

217
00:11:01,000 --> 00:11:05,000
mutta vuodot olisi poistettava.

218
00:11:05,000 --> 00:11:08,000
Valitettavasti vahvistamisesta vuodot voi olla vaikea tehdä,

219
00:11:08,000 --> 00:11:11,000
koska väärä puhelut ilmaiseksi voi räjäyttää ohjelman.

220
00:11:11,000 --> 00:11:14,000
Esimerkiksi, jos katsomme invalid_free.c,

221
00:11:14,000 --> 00:11:18,000
näemme esimerkki huonosta muistista deallocation.

222
00:11:18,000 --> 00:11:21,000
Mikä olisi yksittäinen puhelu vapauttaa koko korttelin

223
00:11:21,000 --> 00:11:24,000
muistin huomautti by int_block,

224
00:11:24,000 --> 00:11:27,000
on sen sijaan tullut yritys vapauttaa jokaisen INT-kokoinen kappale

225
00:11:27,000 --> 00:11:29,000
ja muistin erikseen.

226
00:11:29,000 --> 00:11:32,000
Tämä epäonnistuu katastrofaalisesti.

227
00:11:32,000 --> 00:11:34,000
Boom! Mikä virhe.

228
00:11:34,000 --> 00:11:36,000
Tämä ei todellakaan ole hyvä.

229
00:11:36,000 --> 00:11:39,000
Jos olet juuttunut tällaista virhettä, vaikka, ja et tiedä mistä etsiä,

230
00:11:39,000 --> 00:11:41,000
pudota takaisin uusi paras ystävä.

231
00:11:41,000 --> 00:11:44,000
Arvasit oikein - Valgrind.

232
00:11:44,000 --> 00:11:47,000
Valgrind, kuten aina, tietää tarkalleen, mitä on tekeillä.

233
00:11:47,000 --> 00:11:50,000
Alloc ja vapaa määrä eivät täsmää.

234
00:11:50,000 --> 00:11:52,000
Meillä 1 alloc ja 4 Frees.

235
00:11:52,000 --> 00:11:55,000
Ja Valgrind myös kertoo meille, missä ensimmäinen huono free-puhelun -

236
00:11:55,000 --> 00:11:58,000
joka laukaisi räjähdys - on lähtöisin -

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

238
00:12:00,000 --> 00:12:03,000
Kuten näette, huono puhelut vapauttaa ovat todella huonoja,

239
00:12:03,000 --> 00:12:05,000
niin suosittelemme kerroit ohjelma vuoto

240
00:12:05,000 --> 00:12:08,000
kun olet työskennellyt saamaan toiminnallisuus oikea.

241
00:12:08,000 --> 00:12:12,000
Alkaa etsiä vuotoja vasta sen jälkeen, kun ohjelma toimii oikein,

242
00:12:12,000 --> 00:12:14,000
ilman muita virheitä.

243
00:12:14,000 --> 00:12:16,000
>> Ja se on kaikki mitä minulla tämän videon.

244
00:12:16,000 --> 00:12:18,000
Nyt mitä sinä odotat?

245
00:12:18,000 --> 00:12:21,000
Mene ajaa Valgrind sinun ohjelmia juuri nyt.

246
00:12:21,000 --> 00:12:25,000
Nimeni on Nate Hardison. Tämä on CS50. [CS50.TV]