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
Això és CS50, CS50.TV]

4
00:00:07,000 --> 00:00:10,000
Alguns dels errors més difícils en els programes en C

5
00:00:10,000 --> 00:00:13,000
provenen de la mala gestió de la memòria.

6
00:00:13,000 --> 00:00:15,000
Hi ha un gran nombre de formes d'enredar les coses,

7
00:00:15,000 --> 00:00:17,000
incloent l'assignació de la quantitat incorrecta de la memòria,

8
00:00:17,000 --> 00:00:20,000
oblidar inicialitzar variables,

9
00:00:20,000 --> 00:00:23,000
escrit abans o després del final d'un tampó,

10
00:00:23,000 --> 00:00:25,000
i l'alliberament de mantenir els temps de memòria múltiples.

11
00:00:25,000 --> 00:00:28,000
Els símptomes van des fallades intermitents

12
00:00:28,000 --> 00:00:30,000
als valors misteriosament sobrescrits,

13
00:00:30,000 --> 00:00:34,000
sovint en llocs i temps molt allunyats de l'error original.

14
00:00:34,000 --> 00:00:37,000
Rastrejant el problema observat de nou a la causa subjacent

15
00:00:37,000 --> 00:00:39,000
pot ser un repte,

16
00:00:39,000 --> 00:00:42,000
però, afortunadament, hi ha un programa anomenat útil Valgrind

17
00:00:42,000 --> 00:00:44,000
que es pot fer molt per ajudar.

18
00:00:44,000 --> 00:00:47,000
>> Executar un programa amb Valgrind perquè

19
00:00:47,000 --> 00:00:50,000
comprovació extensa d'assignacions de memòria heap i accessos.

20
00:00:50,000 --> 00:00:53,000
Quan Valgrind detecta un problema, se li dóna immediata,

21
00:00:53,000 --> 00:00:56,000
informació directa que els permet

22
00:00:56,000 --> 00:00:58,000
més fàcilment trobar i solucionar el problema.

23
00:00:58,000 --> 00:01:01,000
Valgrind també informes sobre problemes de memòria menys mortals,

24
00:01:01,000 --> 00:01:04,000
com ara pèrdues de memòria, assignació de memòria heap,

25
00:01:04,000 --> 00:01:07,000
i oblidar-se de alliberar.

26
00:01:07,000 --> 00:01:10,000
Com el nostre compilador, Clang, en el nostre depurador GDB,

27
00:01:10,000 --> 00:01:14,000
Valgrind és programari lliure, i s'instal · la al aparell.

28
00:01:14,000 --> 00:01:16,000
Valgrind s'executa en l'executable binari,

29
00:01:16,000 --> 00:01:20,000
no teu. co. arxius d'origen h de codi,

30
00:01:20,000 --> 00:01:23,000
així que assegureu-vos que vostè hagi compilat una còpia actualitzada al dia del seu programa

31
00:01:23,000 --> 00:01:25,000
utilitzant Clang o fer.

32
00:01:25,000 --> 00:01:28,000
A continuació, executa el programa sota Valgrind pot ser

33
00:01:28,000 --> 00:01:32,000
tan simple com prefix el símbol del programa estàndard amb el Valgrind paraula,

34
00:01:32,000 --> 00:01:35,000
que s'inicia Valgrind i executa el programa a l'interior de la mateixa.

35
00:01:35,000 --> 00:01:38,000
En iniciar, Valgrind fa algun complex

36
00:01:38,000 --> 00:01:41,000
jiggering per configurar l'executable de la vigilància a la memòria,

37
00:01:41,000 --> 00:01:44,000
pel que pot trigar una mica per posar-se en marxa.

38
00:01:44,000 --> 00:01:48,000
Llavors, el programa s'executarà normalment, poden ser molt més lentament,

39
00:01:48,000 --> 00:01:52,000
i quan acaba, Valgrind imprimirà un resum del seu ús de memòria.

40
00:01:52,000 --> 00:01:58,000
Si tot va bé, es veurà alguna cosa com això:

41
00:01:58,000 --> 00:02:01,000
En aquest cas,. / Clean_program

42
00:02:01,000 --> 00:02:04,000
és la ruta d'accés al programa que voleu executar.

43
00:02:04,000 --> 00:02:06,000
I mentre això no es pren cap argument,

44
00:02:06,000 --> 00:02:09,000
si ho fes jo acabava d'ells cap a la final de l'ordre com de costum.

45
00:02:09,000 --> 00:02:12,000
Programa Clean és un programa poc ximple que he creat

46
00:02:12,000 --> 00:02:15,000
que assigna espai per a un bloc d'enters en el munt,

47
00:02:15,000 --> 00:02:19,000
posar alguns valors dins d'ells, i allibera tota la poma.

48
00:02:19,000 --> 00:02:23,000
Això és el que vostè està tirant per, sense errors i sense fuites.

49
00:02:23,000 --> 00:02:27,000
>> Una altra mètrica important és el nombre total de bytes assignats.

50
00:02:27,000 --> 00:02:32,000
Depenent del programa, si les seves assignacions estan en megabytes o més,

51
00:02:32,000 --> 00:02:34,000
vostè està probablement fent alguna cosa malament.

52
00:02:34,000 --> 00:02:37,000
Estàs innecessàriament emmagatzemar duplicats?

53
00:02:37,000 --> 00:02:40,000
Està utilitzant la pila d'emmagatzematge, quan seria millor fer servir la pila?

54
00:02:40,000 --> 00:02:43,000
Per tant, els errors de memòria poden ser veritablement malament.

55
00:02:43,000 --> 00:02:46,000
Els més evidents causar accidents espectaculars,

56
00:02:46,000 --> 00:02:49,000
però tot i així, encara pot ser difícil d'identificar

57
00:02:49,000 --> 00:02:51,000
exactament el que va conduir a la caiguda.

58
00:02:51,000 --> 00:02:54,000
Pitjor encara, un programa amb un error de memòria

59
00:02:54,000 --> 00:02:56,000
encara pot compilar netament

60
00:02:56,000 --> 00:02:58,000
i encara pot semblen funcionar

61
00:02:58,000 --> 00:03:01,000
perquè les hi va arreglar per tenir sort la major part del temps.

62
00:03:01,000 --> 00:03:04,000
Després de diversos "resultats reeixits"

63
00:03:04,000 --> 00:03:07,000
vostè podria pensar que un accident és un cop de sort de l'ordinador,

64
00:03:07,000 --> 00:03:10,000
però l'equip mai s'equivoca.

65
00:03:10,000 --> 00:03:13,000
>> Execució de Valgrind pot ajudar a localitzar la causa dels errors de memòria visibles

66
00:03:13,000 --> 00:03:18,000
així com trobar l'aguait errors que ni tan sols encara coneixem.

67
00:03:18,000 --> 00:03:22,000
Cada vegada Valgrind detecta un problema, es mostra informació sobre el que observa.

68
00:03:22,000 --> 00:03:24,000
Cada article és bastant breu -

69
00:03:24,000 --> 00:03:27,000
la línia de la font de la instrucció infractora, quin és el problema,

70
00:03:27,000 --> 00:03:30,000
i una mica d'informació sobre la memòria involucrats -

71
00:03:30,000 --> 00:03:34,000
però sovint és suficient informació per dirigir la seva atenció cap al lloc correcte.

72
00:03:34,000 --> 00:03:37,000
Aquí és un exemple de Valgrind executa en un programa defectuós

73
00:03:37,000 --> 00:03:40,000
que fa una lectura vàlida de la memòria heap.

74
00:03:40,000 --> 00:03:49,000
No veiem els errors o advertències de compilació.

75
00:03:49,000 --> 00:03:53,000
Uh-oh, el resum error diu que hi ha dos errors -

76
00:03:53,000 --> 00:03:56,000
dues lectures invàlides de mida 4 - bytes, és a dir.

77
00:03:56,000 --> 00:04:01,000
Tant dolenta llegeix produït en la funció principal de invalid_read.c,

78
00:04:01,000 --> 00:04:04,000
el primer a la línia 16 i la segona en la línia 19.

79
00:04:04,000 --> 00:04:06,000
Vegem el codi.

80
00:04:06,000 --> 00:04:11,000
Sembla que la primera trucada a printf intenta llegir un int enllà del final del nostre bloc de memòria.

81
00:04:11,000 --> 00:04:13,000
Si mirem cap enrere en la sortida de Valgrind,

82
00:04:13,000 --> 00:04:16,000
veiem que Valgrind ens va dir exactament això.

83
00:04:16,000 --> 00:04:19,000
La direcció que estem tractant de llegir comença 0 bytes

84
00:04:19,000 --> 00:04:22,000
més enllà de l'extrem del bloc de mida 16 bytes -

85
00:04:22,000 --> 00:04:25,000
quatre enters de 32-bit que ens assignen.

86
00:04:25,000 --> 00:04:29,000
És a dir, l'adreça que estàvem tractant de llegir comença just al final del nostre bloc,

87
00:04:29,000 --> 00:04:32,000
tal com veiem en la nostra crida printf dolent.

88
00:04:32,000 --> 00:04:36,000
Ara, no és vàlid lectures no sembla ser tan gran d'un acord,

89
00:04:36,000 --> 00:04:39,000
però si vostè està utilitzant aquestes dades per controlar el flux del programa -

90
00:04:39,000 --> 00:04:42,000
per exemple, com a part d'una sentència if o loop -

91
00:04:42,000 --> 00:04:45,000
llavors les coses poden anar malament en silenci.

92
00:04:45,000 --> 00:04:47,000
Mira com puc executar el programa invalid_read

93
00:04:47,000 --> 00:04:50,000
i res fora del comú passa.

94
00:04:50,000 --> 00:04:52,000
Fa por, eh?

95
00:04:52,000 --> 00:04:56,000
>> Ara, donem una ullada a alguns tipus més dels errors que poden sorgir en el codi,

96
00:04:56,000 --> 00:04:59,000
i veurem com Valgrind els detecta.

97
00:04:59,000 --> 00:05:01,000
Acabem de veure un exemple d'un invalid_read,

98
00:05:01,000 --> 00:05:04,000
de manera que ara anem a veure un invalid_write.

99
00:05:04,000 --> 00:05:09,000
Un cop més, no hi ha errors o advertències de compilació.

100
00:05:09,000 --> 00:05:12,000
Bé, Valgrind diu que hi ha dos errors en aquest programa -

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

102
00:05:15,000 --> 00:05:18,000
Anem a veure aquest codi.

103
00:05:18,000 --> 00:05:21,000
Sembla que tenim un exemple del clàssic strlen a més d'un error.

104
00:05:21,000 --> 00:05:24,000
El codi no malloc un byte extra d'espai

105
00:05:24,000 --> 00:05:26,000
pel caràcter / 0,

106
00:05:26,000 --> 00:05:30,000
així que quan str còpia va ser a escriure en ssubstrlen "CS50 rocks!"

107
00:05:30,000 --> 00:05:33,000
el va escriure un byte més enllà del final del nostre bloc.

108
00:05:33,000 --> 00:05:36,000
El invalid_read ve quan fem la nostra crida a printf.

109
00:05:36,000 --> 00:05:40,000
Printf acaba la lectura de memòria no vàlida quan es llegeix la / 0 caràcter

110
00:05:40,000 --> 00:05:43,000
com es veu a l'extrem d'aquesta cadena E és impressió.

111
00:05:43,000 --> 00:05:45,000
Però res d'això va escapar Valgrind.

112
00:05:45,000 --> 00:05:48,000
Veiem que va cridar l'invalid_write com a part de la còpia de str

113
00:05:48,000 --> 00:05:51,000
en la línia 11 de la principal, i la invalid_read és part de printf.

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

115
00:05:54,000 --> 00:05:57,000
De nou, això no sembla ser un gran problema.

116
00:05:57,000 --> 00:06:00,000
Podem executar aquest programa una i altra vegada fora de Valgrind

117
00:06:00,000 --> 00:06:03,000
i no veu cap símptoma d'error.

118
00:06:03,000 --> 00:06:06,000
>> No obstant això, anem a veure una lleugera variació d'això per veure

119
00:06:06,000 --> 00:06:09,000
com les coses poden posar-se molt malament.

120
00:06:09,000 --> 00:06:14,000
Així que, és cert, estem abusant de coses més que només una mica en aquest codi.

121
00:06:14,000 --> 00:06:17,000
Només estem assignant espai a la pila de dues cadenes

122
00:06:17,000 --> 00:06:19,000
la longitud de CS50 roques,

123
00:06:19,000 --> 00:06:22,000
aquesta vegada, recordant la / 0 caràcters.

124
00:06:22,000 --> 00:06:25,000
Però després llençar d'una cadena de super-llarga en el bloc de memòria

125
00:06:25,000 --> 00:06:27,000
S que està apuntant.

126
00:06:27,000 --> 00:06:30,000
Quin efecte tindrà això en el bloc de memòria que apunta a T?

127
00:06:30,000 --> 00:06:34,000
Bé, si els punts de T a la memòria que hi ha just al costat de S,

128
00:06:34,000 --> 00:06:37,000
ve just després d'ella,

129
00:06:37,000 --> 00:06:39,000
llavors podríem haver escrit sobre part de T.

130
00:06:39,000 --> 00:06:41,000
Anem a executar aquest codi.

131
00:06:41,000 --> 00:06:43,000
Mira el que va passar.

132
00:06:43,000 --> 00:06:47,000
Les cadenes s'emmagatzemen en els nostres blocs munt ambdós semblaven haver imprès correctament.

133
00:06:47,000 --> 00:06:49,000
Res sembla gens malament.

134
00:06:49,000 --> 00:06:52,000
No obstant això, tornem al nostre codi i

135
00:06:52,000 --> 00:06:55,000
comentar la línia on copiem CS50 roques

136
00:06:55,000 --> 00:06:59,000
en el segon bloc de memòria, a la qual apunta t.

137
00:06:59,000 --> 00:07:02,000
Ara, quan executi aquest codi hem

138
00:07:02,000 --> 00:07:06,000
només veure el contingut del primer bloc de memòria imprimir.

139
00:07:06,000 --> 00:07:09,000
Whoa, encara que nosaltres no ho vam fer str còpia

140
00:07:09,000 --> 00:07:12,000
els caràcters en el bloc munt segon, el apuntat per T,

141
00:07:12,000 --> 00:07:15,000
obtenim una impressió.

142
00:07:15,000 --> 00:07:18,000
De fet, la cadena es va ficar en el nostre primer bloc

143
00:07:18,000 --> 00:07:21,000
envair el bloc primer i en el segon bloc,

144
00:07:21,000 --> 00:07:23,000
fent que tot sembli normal.

145
00:07:23,000 --> 00:07:26,000
Valgrind, però, ens explica la història real.

146
00:07:26,000 --> 00:07:28,000
Aquí anem.

147
00:07:28,000 --> 00:07:32,000
Tots aquells invàlid llegeix i escriu.

148
00:07:32,000 --> 00:07:36,000
>> Vegem un exemple d'un altre tipus d'error.

149
00:07:36,000 --> 00:07:39,000
Aquí fem alguna cosa bastant lamentable.

150
00:07:39,000 --> 00:07:41,000
Agafem l'espai per a un sencer al heap,

151
00:07:41,000 --> 00:07:45,000
i ens inicialitzar un punter int - p - per apuntar a aquest espai.

152
00:07:45,000 --> 00:07:48,000
No obstant això, mentre que el nostre punter s'inicialitza,

153
00:07:48,000 --> 00:07:52,000
les dades que s'està apuntant a només l'ha escombraries són en aquesta part de la pila.

154
00:07:52,000 --> 00:07:55,000
Així que quan carreguem aquestes dades en int i,

155
00:07:55,000 --> 00:07:57,000
que tècnicament i inicialitzar,

156
00:07:57,000 --> 00:08:00,000
però ho fem amb dades de la ferralla.

157
00:08:00,000 --> 00:08:03,000
La crida a afirmar, que és una macro de depuració pràctic

158
00:08:03,000 --> 00:08:06,000
es defineix en el bé anomenat afirmar biblioteca,

159
00:08:06,000 --> 00:08:09,000
avortarà el programa si la seva condició de prova falla.

160
00:08:09,000 --> 00:08:11,000
És a dir, si no és 0.

161
00:08:11,000 --> 00:08:14,000
Depenent del que havia en l'espai del munt, apuntat per p,

162
00:08:14,000 --> 00:08:18,000
aquest programa pot treballar de vegades i no en altres moments.

163
00:08:18,000 --> 00:08:20,000
Si funciona, només estem tenint sort.

164
00:08:20,000 --> 00:08:24,000
El compilador no detectarà aquest error, però Valgrind voluntat segura.

165
00:08:24,000 --> 00:08:28,000
Allà veiem que l'error resultant del nostre ús d'aquestes dades no desitjats.

166
00:08:28,000 --> 00:08:32,000
>> En assignar memòria del munt, però no ho desassignar o alliberar-lo,

167
00:08:32,000 --> 00:08:34,000
que es diu una fuita.

168
00:08:34,000 --> 00:08:37,000
Per a un petit, efímer programa que s'executa i surt immediatament,

169
00:08:37,000 --> 00:08:39,000
fuites són bastant inofensius,

170
00:08:39,000 --> 00:08:42,000
però per a un projecte més gran i / o la longevitat,

171
00:08:42,000 --> 00:08:46,000
fins i tot una petita fuita pot complicar en una cosa important.

172
00:08:46,000 --> 00:08:49,000
Per CS50, esperem que

173
00:08:49,000 --> 00:08:51,000
tenir cura d'alliberar tota la memòria heap que assigni,

174
00:08:51,000 --> 00:08:54,000
ja que volem que vostè construeixi els coneixements necessaris per gestionar adequadament el procés manual

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

176
00:08:56,000 --> 00:08:59,000
Per això, el programa ha de tenir un exacte

177
00:08:59,000 --> 00:09:03,000
un-a-un correspondència entre malloc i trucades gratuïtes.

178
00:09:03,000 --> 00:09:06,000
Afortunadament, Valgrind pot ajudar amb les pèrdues de memòria també.

179
00:09:06,000 --> 00:09:09,000
Aquí hi ha un programa anomenat fugues leak.c que assigna

180
00:09:09,000 --> 00:09:13,000
espai a la pila, escriu-hi, però no l'alliberarà.

181
00:09:13,000 --> 00:09:16,000
Ens compilar amb make i executar el programa sota Valgrind,

182
00:09:16,000 --> 00:09:18,000
i veiem que, si bé no tenim errors de memòria,

183
00:09:18,000 --> 00:09:20,000
tenim una fuga.

184
00:09:20,000 --> 00:09:23,000
Hi ha 16 bytes definitivament perduts,

185
00:09:23,000 --> 00:09:27,000
el que significa que el punter a la memòria que no estava en l'àmbit quan el programa es tanca.

186
00:09:27,000 --> 00:09:30,000
Ara, Valgrind no ens dóna un munt d'informació sobre la fuga,

187
00:09:30,000 --> 00:09:35,000
però si seguim aquesta petita nota que dóna cap al fons del seu informe

188
00:09:35,000 --> 00:09:38,000
tornar a executar amb - Fuga-check = complet

189
00:09:38,000 --> 00:09:41,000
per veure els detalls complets de memòria perduda,

190
00:09:41,000 --> 00:09:44,000
obtindrem més informació.

191
00:09:44,000 --> 00:09:46,000
Ara bé, en el resum munt,

192
00:09:46,000 --> 00:09:50,000
Valgrind ens diu que la memòria que es va perdre va ser assignat inicialment.

193
00:09:50,000 --> 00:09:52,000
Així com sabem de mirar al codi font,

194
00:09:52,000 --> 00:09:55,000
Valgrind ens informa que va filtrar la memòria

195
00:09:55,000 --> 00:09:58,000
assignat amb una crida a malloc a la línia 8 de leak.c

196
00:09:58,000 --> 00:10:00,000
en la funció principal.

197
00:10:00,000 --> 00:10:02,000
Bastant enginyós.

198
00:10:02,000 --> 00:10:04,000
>> Valgrind classifica fuites usant aquests termes:

199
00:10:04,000 --> 00:10:07,000
Definitivament perdut - això és la pila de memòria assignada

200
00:10:07,000 --> 00:10:10,000
en què el programa ja no té un punter.

201
00:10:10,000 --> 00:10:14,000
Valgrind sap que un cop va tenir el punter, però des de llavors han perdut la pista.

202
00:10:14,000 --> 00:10:17,000
Aquesta memòria és, sens dubte filtrat.

203
00:10:17,000 --> 00:10:20,000
Indirectament perdut - aquesta és la pila de memòria assignada

204
00:10:20,000 --> 00:10:24,000
a la qual només els punters a què també es perden.

205
00:10:24,000 --> 00:10:27,000
Per exemple, si vostè va perdre el seu punter al primer node d'una llista enllaçada,

206
00:10:27,000 --> 00:10:30,000
llavors el primer node en si seria definitivament perdut,

207
00:10:30,000 --> 00:10:34,000
mentre que els nodes subsegüents serien indirectament perdut.

208
00:10:34,000 --> 00:10:37,000
Possiblement perdut - aquesta és la pila de memòria assignada

209
00:10:37,000 --> 00:10:41,000
a la qual Valgrind no pot estar segur si hi ha un punter o no.

210
00:10:41,000 --> 00:10:44,000
Encara és accessible la pila de memòria assignada

211
00:10:44,000 --> 00:10:47,000
en què el programa encara té un punter a la sortida,

212
00:10:47,000 --> 00:10:50,000
que significa típicament que apunta una variable global a aquesta.

213
00:10:50,000 --> 00:10:53,000
Per comprovar si aquestes filtracions, vostè també haurà d'incloure l'opció

214
00:10:53,000 --> 00:10:55,000
- Encara assolible = yes

215
00:10:55,000 --> 00:10:58,000
en la seva advocació de Valgrind.

216
00:10:58,000 --> 00:11:01,000
>> Aquests casos poden requerir diferents estratègies diferents per netejar,

217
00:11:01,000 --> 00:11:05,000
però les fuites han de ser eliminats.

218
00:11:05,000 --> 00:11:08,000
Malauradament, la fixació de les fuites poden ser difícil de fer,

219
00:11:08,000 --> 00:11:11,000
ja que les trucades incorrectes a lliure pot explotar el seu programa.

220
00:11:11,000 --> 00:11:14,000
Per exemple, si ens fixem en invalid_free.c,

221
00:11:14,000 --> 00:11:18,000
veiem un exemple de desassignació mal record.

222
00:11:18,000 --> 00:11:21,000
El que hauria de ser una sola trucada a alliberar tot el bloc

223
00:11:21,000 --> 00:11:24,000
de memòria apuntada per int_block,

224
00:11:24,000 --> 00:11:27,000
en canvi, s'ha convertit en un intent per alliberar cada secció de la mida d'int

225
00:11:27,000 --> 00:11:29,000
de la memòria individualment.

226
00:11:29,000 --> 00:11:32,000
Això fallarà catastròficament.

227
00:11:32,000 --> 00:11:34,000
Boom! Quin error.

228
00:11:34,000 --> 00:11:36,000
Això definitivament no és bo.

229
00:11:36,000 --> 00:11:39,000
Si vostè està encallat amb aquest tipus d'error, però, i vostè no sap on buscar,

230
00:11:39,000 --> 00:11:41,000
recórrer al seu nou millor amic.

231
00:11:41,000 --> 00:11:44,000
Vostè ho va endevinar - Valgrind.

232
00:11:44,000 --> 00:11:47,000
Valgrind, com sempre, sap exactament el que passa.

233
00:11:47,000 --> 00:11:50,000
Els recomptes Alloc i lliure no coincideixen.

234
00:11:50,000 --> 00:11:52,000
Tenim un Alloc i 4 lliura.

235
00:11:52,000 --> 00:11:55,000
I Valgrind també ens diu que la primera trucada gratuïta dolent -

236
00:11:55,000 --> 00:11:58,000
la que va desencadenar l'explosió - es ve -

237
00:11:58,000 --> 00:12:00,000
la línia 16.

238
00:12:00,000 --> 00:12:03,000
Com pot veure, les anomenades males per alliberar són realment dolentes,

239
00:12:03,000 --> 00:12:05,000
el que es recomana deixar que la seva fugida programa

240
00:12:05,000 --> 00:12:08,000
mentre que vostè està treballant en aconseguir el correcte funcionament.

241
00:12:08,000 --> 00:12:12,000
Comenceu a buscar fuites només després que el seu programa està funcionant correctament,

242
00:12:12,000 --> 00:12:14,000
sense altres errors.

243
00:12:14,000 --> 00:12:16,000
>> I això és tot el que tenim per aquest vídeo.

244
00:12:16,000 --> 00:12:18,000
Ara, què estàs esperant?

245
00:12:18,000 --> 00:12:21,000
Anar executar Valgrind en els seus programes en aquests moments.

246
00:12:21,000 --> 00:12:25,000
El meu nom és Nate Hardison. Això és CS50. [CS50.TV]