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

2
00:00:02,000 --> 00:00:05,000
[Нејт Hardison, Универзитетот Харвард]

3
00:00:05,000 --> 00:00:07,000
Ова е CS50, CS50.TV]

4
00:00:07,000 --> 00:00:10,000
Некои од најтешките грешки во C програми

5
00:00:10,000 --> 00:00:13,000
доаѓаат од запоставување на меморија.

6
00:00:13,000 --> 00:00:15,000
Постојат голем број на начини да завртка работите,

7
00:00:15,000 --> 00:00:17,000
вклучувајќи доделување на погрешен износ на меморија,

8
00:00:17,000 --> 00:00:20,000
заборавајќи да се иницијализира променливи,

9
00:00:20,000 --> 00:00:23,000
писмена форма пред или по завршувањето на тампон,

10
00:00:23,000 --> 00:00:25,000
и ослободување задржи мемориската повеќе пати.

11
00:00:25,000 --> 00:00:28,000
Симптомите варираат од наизменичното блокира

12
00:00:28,000 --> 00:00:30,000
да мистериозно препишани вредности,

13
00:00:30,000 --> 00:00:34,000
често на места и времиња далеку од оригиналниот грешка.

14
00:00:34,000 --> 00:00:37,000
По трагите на набљудуваните проблем назад на основната коренот

15
00:00:37,000 --> 00:00:39,000
може да биде предизвик,

16
00:00:39,000 --> 00:00:42,000
но за среќа има корисни програма наречена Valgrind

17
00:00:42,000 --> 00:00:44,000
дека може да направи многу за да им помогне.

18
00:00:44,000 --> 00:00:47,000
>> Ќе ја стартувате програмата под Valgrind за да се овозможи

19
00:00:47,000 --> 00:00:50,000
обемна проверка на грамада меморија алокации и пристапи.

20
00:00:50,000 --> 00:00:53,000
Кога Valgrind детектира проблем, тоа ви дава веднаш,

21
00:00:53,000 --> 00:00:56,000
директни информации што ви овозможува да

22
00:00:56,000 --> 00:00:58,000
повеќе лесно да најдете и да ја поправите проблемот.

23
00:00:58,000 --> 00:01:01,000
Valgrind исто така извештаи за помалку смртоносен меморија прашања,

24
00:01:01,000 --> 00:01:04,000
како меморија протекување, распределба на грамада меморија,

25
00:01:04,000 --> 00:01:07,000
и заборавање за да се ослободи.

26
00:01:07,000 --> 00:01:10,000
Се допаѓа нашиот компајлер, ѕвекот, во нашата дебагерот, GDB,

27
00:01:10,000 --> 00:01:14,000
Valgrind е слободен софтвер, и е инсталиран на уредот.

28
00:01:14,000 --> 00:01:16,000
Valgrind работи на вашиот бинарна извршна,

29
00:01:16,000 --> 00:01:20,000
не твојот. C или. ж изворниот код на датотеки,

30
00:01:20,000 --> 00:01:23,000
па бидете сигурни дека имате подготвено up-to-date копија на вашата програма

31
00:01:23,000 --> 00:01:25,000
користење ѕвекот или создавам.

32
00:01:25,000 --> 00:01:28,000
Потоа, трчање вашата програма под Valgrind може да биде

33
00:01:28,000 --> 00:01:32,000
едноставно како само prefixing на стандардна програма командата со зборот Valgrind,

34
00:01:32,000 --> 00:01:35,000
која ќе почне со Valgrind и работи на програмата во него.

35
00:01:35,000 --> 00:01:38,000
При стартување, Valgrind прави некои сложени

36
00:01:38,000 --> 00:01:41,000
jiggering да одбереш извршна за меморија проверки,

37
00:01:41,000 --> 00:01:44,000
па тоа може да потрае малку да се нагоре и трчање.

38
00:01:44,000 --> 00:01:48,000
Програмата тогаш ќе се извршува нормално, тоа да биде многу побавно,

39
00:01:48,000 --> 00:01:52,000
и кога ќе заврши, Valgrind ќе печати резиме на употребата на меморијата.

40
00:01:52,000 --> 00:01:58,000
Ако се оди добро, тоа ќе изгледа нешто како ова:

41
00:01:58,000 --> 00:02:01,000
Во овој случај,. / Clean_program

42
00:02:01,000 --> 00:02:04,000
е патот до програмата Сакам да се кандидира.

43
00:02:04,000 --> 00:02:06,000
И додека ова не се преземат какви било аргументи,

44
00:02:06,000 --> 00:02:09,000
ако тоа го правеше Би само да ги тактика за да на крајот на командната како и обично.

45
00:02:09,000 --> 00:02:12,000
Чиста програмата е само глупо малку програма Јас создаде

46
00:02:12,000 --> 00:02:15,000
што издвојува простор за блок од ints на грамада,

47
00:02:15,000 --> 00:02:19,000
стави некои вредности во внатрешноста на нив, и ослободува целиот блок.

48
00:02:19,000 --> 00:02:23,000
Ова е она што се снима за, без грешки и без протекување.

49
00:02:23,000 --> 00:02:27,000
>> Друга важна метрички е вкупниот број на бајти распределени.

50
00:02:27,000 --> 00:02:32,000
Зависно од програмата, ако вашиот средства се во мегабајти или повисоко,

51
00:02:32,000 --> 00:02:34,000
ти си веројатно се прават нешто погрешно.

52
00:02:34,000 --> 00:02:37,000
Дали сте непотребно чување на дупликати?

53
00:02:37,000 --> 00:02:40,000
Дали сте користење на грамада за складирање, кога тоа ќе биде подобро да се користи магацинот?

54
00:02:40,000 --> 00:02:43,000
Значи, меморија грешки може да биде навистина зло.

55
00:02:43,000 --> 00:02:46,000
Повеќе отворена оние предизвика спектакуларни несреќи,

56
00:02:46,000 --> 00:02:49,000
но дури и тогаш тоа сепак може да биде тешко да ги лоцирам

57
00:02:49,000 --> 00:02:51,000
што точно довело до несреќата.

58
00:02:51,000 --> 00:02:54,000
Повеќе подмолно, програма со меморија грешка

59
00:02:54,000 --> 00:02:56,000
уште може да собере чисто

60
00:02:56,000 --> 00:02:58,000
и уште може да изгледа да се работи правилно

61
00:02:58,000 --> 00:03:01,000
затоа што успеа да добиете среќа поголемиот дел од времето.

62
00:03:01,000 --> 00:03:04,000
По неколку "успешни резултати"

63
00:03:04,000 --> 00:03:07,000
вие само може да мислат дека несреќата е среќа на компјутер,

64
00:03:07,000 --> 00:03:10,000
но компјутерот не е во ред.

65
00:03:10,000 --> 00:03:13,000
>> Вклучување Valgrind може да ви помогне да ги пратите одредување на причината на видливи меморија грешки

66
00:03:13,000 --> 00:03:18,000
како и да најдете демнат грешки дури не сеуште знаат.

67
00:03:18,000 --> 00:03:22,000
Секој пат Valgrind детектира проблем, тоа отпечатоци информации за она што го почитуваат.

68
00:03:22,000 --> 00:03:24,000
Секоја ставка е прилично изразителен -

69
00:03:24,000 --> 00:03:27,000
изворот линија на навреда настава, што на ова прашање е,

70
00:03:27,000 --> 00:03:30,000
и малку информации за меморијата вклучени -

71
00:03:30,000 --> 00:03:34,000
но често тоа е доволно информации да се насочи вниманието на вистинското место.

72
00:03:34,000 --> 00:03:37,000
Еве еден пример на Valgrind работи на кабриолет програма

73
00:03:37,000 --> 00:03:40,000
што го прави невалиден читање на грамада меморија.

74
00:03:40,000 --> 00:03:49,000
Ние не гледам грешки или предупредувања во компилација.

75
00:03:49,000 --> 00:03:53,000
Ух-Ох, грешка резиме вели дека постојат две грешки -

76
00:03:53,000 --> 00:03:56,000
две неважечки прочитано на големина 4 - бајти, тоа е.

77
00:03:56,000 --> 00:04:01,000
Двете лоши чита случи во главната функција на invalid_read.c,

78
00:04:01,000 --> 00:04:04,000
прв на линија 16, а втората on-line 19.

79
00:04:04,000 --> 00:04:06,000
Ајде да погледнеме во кодот.

80
00:04:06,000 --> 00:04:11,000
Изгледа како првиот повик на printf обидува да прочитате една int минатото крајот на нашата меморија блок.

81
00:04:11,000 --> 00:04:13,000
Ако ги погледнеме назад во производството Valgrind е,

82
00:04:13,000 --> 00:04:16,000
можеме да видиме дека Valgrind ни кажа токму тоа.

83
00:04:16,000 --> 00:04:19,000
Адреса ние се обидуваме да го прочитате почнува 0 бајти

84
00:04:19,000 --> 00:04:22,000
минатото на крајот на блокот на големина 16 бајти -

85
00:04:22,000 --> 00:04:25,000
четири 32-битен ints дека ние распределени.

86
00:04:25,000 --> 00:04:29,000
Што е, на адресата што се обидуваат да го прочитате започнува токму на крајот од наше маало,

87
00:04:29,000 --> 00:04:32,000
само како што гледаме во нашите лоши printf повик.

88
00:04:32,000 --> 00:04:36,000
Сега, неважечки прочитано не може да изгледа како толку голем договор,

89
00:04:36,000 --> 00:04:39,000
но ако сте со користење на податоците да се контролира протокот на вашата програма -

90
00:04:39,000 --> 00:04:42,000
на пример, како дел од, ако изјавата или јамка -

91
00:04:42,000 --> 00:04:45,000
тогаш работите тивко може да оди лошо.

92
00:04:45,000 --> 00:04:47,000
Види како можам да се кандидира на invalid_read програма

93
00:04:47,000 --> 00:04:50,000
и ништо од обичните случува.

94
00:04:50,000 --> 00:04:52,000
Страшно, нели?

95
00:04:52,000 --> 00:04:56,000
>> Сега, ајде да погледнеме некои повеќе видови на грешки кои може да се судрите во вашиот код,

96
00:04:56,000 --> 00:04:59,000
и ќе видиме како Valgrind ги детектира.

97
00:04:59,000 --> 00:05:01,000
Ние само видов пример за invalid_read,

98
00:05:01,000 --> 00:05:04,000
Па сега ајде да се провери од една invalid_write.

99
00:05:04,000 --> 00:05:09,000
Повторно, нема грешки или предупредувања во компилација.

100
00:05:09,000 --> 00:05:12,000
Океј, Valgrind вели дека постојат две грешки во оваа програма -

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

102
00:05:15,000 --> 00:05:18,000
Ајде проверете го овој код.

103
00:05:18,000 --> 00:05:21,000
Изгледа имаме пример на класичен strlen плус една бубачка.

104
00:05:21,000 --> 00:05:24,000
Кодексот не Примерок екстра бајт на просторот

105
00:05:24,000 --> 00:05:26,000
за / 0 карактер,

106
00:05:26,000 --> 00:05:30,000
па кога ул копија отиде да го пишувам на ssubstrlen "cs50 камења!"

107
00:05:30,000 --> 00:05:33,000
го напишал 1 бајт минатото на крајот од наше маало.

108
00:05:33,000 --> 00:05:36,000
На invalid_read доаѓа кога ќе го направи нашиот повик да printf.

109
00:05:36,000 --> 00:05:40,000
Printf завршува до читање неправилен меморија кога станува чита / 0 карактер

110
00:05:40,000 --> 00:05:43,000
како што изгледа на крајот на овој Е стринг е печатење.

111
00:05:43,000 --> 00:05:45,000
Но ништо од тоа избегна Valgrind.

112
00:05:45,000 --> 00:05:48,000
Гледаме дека фатени на invalid_write како дел од ул копија

113
00:05:48,000 --> 00:05:51,000
на линија 11 од главната и invalid_read е дел од printf.

114
00:05:51,000 --> 00:05:54,000
Рок на, Valgrind.

115
00:05:54,000 --> 00:05:57,000
Повторно, ова не може да изгледа како голема работа.

116
00:05:57,000 --> 00:06:00,000
Ние може да ја извршите оваа програма одново и надвор од Valgrind

117
00:06:00,000 --> 00:06:03,000
и не гледам никаква грешка симптоми.

118
00:06:03,000 --> 00:06:06,000
>> Сепак, ајде да погледнеме мала варијација на овој за да ја видите

119
00:06:06,000 --> 00:06:09,000
како работите може да се добие навистина лошо.

120
00:06:09,000 --> 00:06:14,000
Па, готово, ние се злоупотребува работи повеќе од само малку во овој код.

121
00:06:14,000 --> 00:06:17,000
Ние сме само распределба на простор на грамада за две низи

122
00:06:17,000 --> 00:06:19,000
должината на cs50 карпи,

123
00:06:19,000 --> 00:06:22,000
овој пат, сеќавајќи се на / 0 карактер.

124
00:06:22,000 --> 00:06:25,000
Но, тогаш ние фрли во супер-долга низа во меморискиот блок

125
00:06:25,000 --> 00:06:27,000
што S е да се покажува.

126
00:06:27,000 --> 00:06:30,000
Каков ефект ќе кои имаат за мемориски блок дека Т поени?

127
00:06:30,000 --> 00:06:34,000
Па, ако Т укажува на меморија, која е само непосредна близина до С,

128
00:06:34,000 --> 00:06:37,000
доаѓа веднаш по него,

129
00:06:37,000 --> 00:06:39,000
тогаш ние би можеле да го имаат напишано над дел од Т

130
00:06:39,000 --> 00:06:41,000
Да ја извршите оваа код.

131
00:06:41,000 --> 00:06:43,000
Погледнете што се случи.

132
00:06:43,000 --> 00:06:47,000
Жиците се чуваат во нашата грамада блокови и се појави да се испечати правилно.

133
00:06:47,000 --> 00:06:49,000
Ништо не чини погрешно на сите.

134
00:06:49,000 --> 00:06:52,000
Сепак, да се вратиме во нашиот код и

135
00:06:52,000 --> 00:06:55,000
Коментар од линијата каде што копирате cs50 карпи

136
00:06:55,000 --> 00:06:59,000
во втората мемориски блок, посочи од т.

137
00:06:59,000 --> 00:07:02,000
Сега, кога ние ја извршите оваа код ние треба да

138
00:07:02,000 --> 00:07:06,000
само ја видите содржината на првиот мемориски блок испечатите.

139
00:07:06,000 --> 00:07:09,000
Леле, иако ние не ул копија

140
00:07:09,000 --> 00:07:12,000
никакви знаци во втората грамада блок, еден укажа на T,

141
00:07:12,000 --> 00:07:15,000
добиеме испечатите.

142
00:07:15,000 --> 00:07:18,000
Всушност, низа ние полнети во нашата првиот блок

143
00:07:18,000 --> 00:07:21,000
зазедоа првиот блок и во вториот блок,

144
00:07:21,000 --> 00:07:23,000
што се чини нормално.

145
00:07:23,000 --> 00:07:26,000
Valgrind, сепак, ни кажува вистинската приказна.

146
00:07:26,000 --> 00:07:28,000
Таму ќе одиме.

147
00:07:28,000 --> 00:07:32,000
Сите оние неважечки чита и пишува.

148
00:07:32,000 --> 00:07:36,000
>> Ајде да погледнеме еден пример на друг вид на грешка.

149
00:07:36,000 --> 00:07:39,000
Еве ние се направи нешто, а жално.

150
00:07:39,000 --> 00:07:41,000
Ние го дофати простор за int на грамада,

151
00:07:41,000 --> 00:07:45,000
и ние се иницијализира на int покажувачот - P - да се укаже на тој простор.

152
00:07:45,000 --> 00:07:48,000
Сепак, додека нашите покажувачот е иницијализиран,

153
00:07:48,000 --> 00:07:52,000
податоците што тоа е што укажува на само има она што ѓубре е во тој дел на грамада.

154
00:07:52,000 --> 00:07:55,000
Значи, кога ќе се вчита податоците во int i,

155
00:07:55,000 --> 00:07:57,000
ние технички јас се иницијализира,

156
00:07:57,000 --> 00:08:00,000
но тоа го правиме со сметот на податоци.

157
00:08:00,000 --> 00:08:03,000
Повикот да тврдат, која е корисна за дебагирање макро

158
00:08:03,000 --> 00:08:06,000
дефинирани во потполност наречен тврдат библиотека,

159
00:08:06,000 --> 00:08:09,000
ќе ја прекине програмата, доколку нејзините тест состојба не успее.

160
00:08:09,000 --> 00:08:11,000
Тоа е, ако не е 0.

161
00:08:11,000 --> 00:08:14,000
Во зависност од она што беше во грамада просторот, посочи со p,

162
00:08:14,000 --> 00:08:18,000
оваа програма би можеле да работат понекогаш и не успеваат во други времиња.

163
00:08:18,000 --> 00:08:20,000
Ако тоа функционира, ние сме само добива среќа.

164
00:08:20,000 --> 00:08:24,000
На компајлерот не ќе се фати оваа грешка, но Valgrind сигурни волја.

165
00:08:24,000 --> 00:08:28,000
Има гледаме грешка произлегуваат од нашата употреба на тоа ѓубре податоци.

166
00:08:28,000 --> 00:08:32,000
>> Кога ќе одвои грамада меморија, но не го deallocate или ослободи неа,

167
00:08:32,000 --> 00:08:34,000
што се нарекува протекуваат.

168
00:08:34,000 --> 00:08:37,000
За мала, краткотрајна програма која работи и веднаш излегува,

169
00:08:37,000 --> 00:08:39,000
протекување се прилично безопасен,

170
00:08:39,000 --> 00:08:42,000
но за проект од поголема големина и / или долговечноста,

171
00:08:42,000 --> 00:08:46,000
дури и мал истекување може да соединение во нешто поголеми.

172
00:08:46,000 --> 00:08:49,000
За CS50, ние не очекуваме да

173
00:08:49,000 --> 00:08:51,000
се грижи за ослободување на сите на грамада меморија, која ви доделат,

174
00:08:51,000 --> 00:08:54,000
Бидејќи ние сакаме да се изгради вештини за правилно да се справи со рачен процес

175
00:08:54,000 --> 00:08:56,000
бара од страна на В

176
00:08:56,000 --> 00:08:59,000
Да го стори тоа, вашата програма треба да имаат точно

177
00:08:59,000 --> 00:09:03,000
еден-на-еден преписка помеѓу Примерок и бесплатни разговори.

178
00:09:03,000 --> 00:09:06,000
За среќа, Valgrind може да ви помогне со меморија протекување премногу.

179
00:09:06,000 --> 00:09:09,000
Тука е спукан програма наречена leak.c дека доделува

180
00:09:09,000 --> 00:09:13,000
простор на грамада, пишува за тоа, но не го ослободи.

181
00:09:13,000 --> 00:09:16,000
Ние го компајлирате со создавам и да ја стартувате под Valgrind,

182
00:09:16,000 --> 00:09:18,000
и гледаме дека, додека ние немаме меморија грешки,

183
00:09:18,000 --> 00:09:20,000
ние имаме една протекуваат.

184
00:09:20,000 --> 00:09:23,000
Постојат 16 бајти дефинитивно изгубени,

185
00:09:23,000 --> 00:09:27,000
што значи дека го покажувачот во тој меморијата не е во опсегот кога на програмата постоеле.

186
00:09:27,000 --> 00:09:30,000
Сега, Valgrind не ни даде еден тон на информации за течење,

187
00:09:30,000 --> 00:09:35,000
но ако ние ја следиме оваа мала забелешка дека тоа му дава надолу кон дното на извештајот

188
00:09:35,000 --> 00:09:38,000
на повторување со - протекуваат-проверка = целосна

189
00:09:38,000 --> 00:09:41,000
да ја видите комплетната детали протекоа меморија,

190
00:09:41,000 --> 00:09:44,000
ќе добиете повеќе информации.

191
00:09:44,000 --> 00:09:46,000
Сега, во грамада резиме,

192
00:09:46,000 --> 00:09:50,000
Valgrind ни кажува каде меморија, која е изгубена првично беше распределени.

193
00:09:50,000 --> 00:09:52,000
Исто како што знаеме од гледање во изворниот код,

194
00:09:52,000 --> 00:09:55,000
Valgrind нè информира дека протекоа на меморијата

195
00:09:55,000 --> 00:09:58,000
доделени со повик до Примерок на алинеја 8 од leak.c

196
00:09:58,000 --> 00:10:00,000
во главната функција.

197
00:10:00,000 --> 00:10:02,000
Убави Вешта.

198
00:10:02,000 --> 00:10:04,000
>> Valgrind категоризира протекување користење на овие термини:

199
00:10:04,000 --> 00:10:07,000
Сигурно е изгубен - ова е грамада распределени меморија

200
00:10:07,000 --> 00:10:10,000
кој на програмата веќе нема покажувач.

201
00:10:10,000 --> 00:10:14,000
Valgrind знае дека некогаш имал покажувачот но оттогаш се губеше од неа.

202
00:10:14,000 --> 00:10:17,000
Оваа меморија е дефинитивно протекоа.

203
00:10:17,000 --> 00:10:20,000
Индиректно изгубени - ова е грамада распределени меморија

204
00:10:20,000 --> 00:10:24,000
кој само совети како да се, исто така, се губат.

205
00:10:24,000 --> 00:10:27,000
На пример, ако сте ја изгубиле вашиот покажувач на првиот јазол на поврзани листа,

206
00:10:27,000 --> 00:10:30,000
тогаш првиот јазол себе ќе биде дефинитивно изгубени,

207
00:10:30,000 --> 00:10:34,000
додека сите последователни јазли ќе бидат индиректно изгубени.

208
00:10:34,000 --> 00:10:37,000
Можно е изгубена - ова е грамада распределуваат меморија

209
00:10:37,000 --> 00:10:41,000
кој Valgrind не може да биде сигурен дали постои покажувач или не.

210
00:10:41,000 --> 00:10:44,000
Сепак достапно е грамада распределени меморија

211
00:10:44,000 --> 00:10:47,000
кои на програмата се уште има покажувач на излез,

212
00:10:47,000 --> 00:10:50,000
кои обично значи дека глобалната променлива поени за тоа.

213
00:10:50,000 --> 00:10:53,000
Да се ​​провери за овие протекување, исто така, ќе мора да вклучува опција

214
00:10:53,000 --> 00:10:55,000
- Сеуште достапно = да

215
00:10:55,000 --> 00:10:58,000
во вашиот повикување на Valgrind.

216
00:10:58,000 --> 00:11:01,000
>> Овие различни случаи може да бараат различни стратегии за чистење на нив,

217
00:11:01,000 --> 00:11:05,000
но протекување треба да се отстранат.

218
00:11:05,000 --> 00:11:08,000
За жал, одредување протекување може да биде тешко да се направи,

219
00:11:08,000 --> 00:11:11,000
бидејќи неточни повици за бесплатно да ја кренат својата програма.

220
00:11:11,000 --> 00:11:14,000
На пример, ако гледаме invalid_free.c,

221
00:11:14,000 --> 00:11:18,000
можеме да видиме еден пример за лоша меморија deallocation.

222
00:11:18,000 --> 00:11:21,000
Што треба да биде еден повик за ослободување на целиот блок

223
00:11:21,000 --> 00:11:24,000
меморија посочи од int_block,

224
00:11:24,000 --> 00:11:27,000
има наместо да стане обид да се ослободи секој int големина дел

225
00:11:27,000 --> 00:11:29,000
на меморијата поединечно.

226
00:11:29,000 --> 00:11:32,000
Ова нема да успее катастрофално.

227
00:11:32,000 --> 00:11:34,000
Бум! Што грешка.

228
00:11:34,000 --> 00:11:36,000
Ова дефинитивно не е добар.

229
00:11:36,000 --> 00:11:39,000
Ако сте заглавени со овој вид на грешка, иако, и вие не знаете каде да се погледне,

230
00:11:39,000 --> 00:11:41,000
се врати на вашиот нов најдобар пријател.

231
00:11:41,000 --> 00:11:44,000
Ќе го претпоставам - Valgrind.

232
00:11:44,000 --> 00:11:47,000
Valgrind, како и секогаш, точно знае што е горе.

233
00:11:47,000 --> 00:11:50,000
На alloc и слободни точки не се совпаѓаат.

234
00:11:50,000 --> 00:11:52,000
Имаме 1 alloc и 4 ослободува.

235
00:11:52,000 --> 00:11:55,000
И Valgrind исто така ни кажува каде што првиот лошо бесплатен повик -

236
00:11:55,000 --> 00:11:58,000
оној кој предизвика скандал - доаѓа од -

237
00:11:58,000 --> 00:12:00,000
линија 16.

238
00:12:00,000 --> 00:12:03,000
Како што гледате, лоши повици за ослободување се навистина лоши,

239
00:12:03,000 --> 00:12:05,000
па ви препорачуваме овозможи вашата програма течење

240
00:12:05,000 --> 00:12:08,000
додека си работат на добивање на функционалноста точни.

241
00:12:08,000 --> 00:12:12,000
Почнете да барате протекување само по вашата програма е работи правилно,

242
00:12:12,000 --> 00:12:14,000
без какви било други грешки.

243
00:12:14,000 --> 00:12:16,000
>> И тоа е се што имам за ова видео.

244
00:12:16,000 --> 00:12:18,000
Сега што чекаш?

245
00:12:18,000 --> 00:12:21,000
Оди кандидира Valgrind на вашите програми во моментов.

246
00:12:21,000 --> 00:12:25,000
Моето име е Нејт Hardison. Ова е CS50. [CS50.TV]