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

2
00:00:02,000 --> 00:00:05,000
[Nate Хардісон, Гарвардський університет]

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
Подобається наш компілятор, Clang, на наш відладчик, 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
не ваш. або с. ч. файлів вихідного коду,

30
00:01:20,000 --> 00:01:23,000
так що ви зібрали останню дату копії вашої програми

31
00:01:23,000 --> 00:01:25,000
використанням Clang або зробити.

32
00:01:25,000 --> 00:01:28,000
Потім запустити програму під Valgrind може бути

33
00:01:28,000 --> 00:01:32,000
так простий, як тільки префікс стандартної команди програми зі словом 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
перетасовують налаштувати виконуваний файл для перевірки пам'яті,

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
що виділяє місце для блоку цілими в купі,

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, а другий на лінії 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-розрядних цілих чисел, що ми виділили.

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
Rock On, 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
Який ефект буде, що є на блок пам'яті, що T вказує на?

127
00:06:30,000 --> 00:06:34,000
Ну, якщо T вказує на пам'ять, що просто поруч з S,

128
00:06:34,000 --> 00:06:37,000
майбутні тільки після цього,

129
00:06:37,000 --> 00:06:39,000
Потім ми могли б написано над частиною T.

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 я,

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
В залежності від того, що було в купі простір, на яке вказує р,

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
>> При виділенні динамічної пам'яті, але не звільняє його або звільнити його,

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
потрібно C.

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
ми бачимо приклад поганого звільнення пам'яті.

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
Boom! Які помилки.

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
Ідентифікатор і безкоштовно розраховує не збігаються.

234
00:11:50,000 --> 00:11:52,000
Ми отримали 1 ідентифікатор і 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
Мене звати Нейт Хардісон. Це CS50. [CS50.TV]