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, Universiti Harvard]

3
00:00:05,000 --> 00:00:07,000
Ini adalah CS50, CS50.TV]

4
00:00:07,000 --> 00:00:10,000
Beberapa bug yang paling sukar dalam program C

5
00:00:10,000 --> 00:00:13,000
datang dari penyalah urusan ingatan.

6
00:00:13,000 --> 00:00:15,000
Terdapat sejumlah besar cara untuk skru perkara,

7
00:00:15,000 --> 00:00:17,000
termasuk memperuntukkan jumlah memori yang salah,

8
00:00:17,000 --> 00:00:20,000
lupa untuk memulakan pembolehubah,

9
00:00:20,000 --> 00:00:23,000
bertulis sebelum atau selepas akhir penampan,

10
00:00:23,000 --> 00:00:25,000
dan membebaskan menyimpan pelbagai memori kali.

11
00:00:25,000 --> 00:00:28,000
Gejala terdiri daripada kemalangan sekejap

12
00:00:28,000 --> 00:00:30,000
kepada nilai misteri ditimpa,

13
00:00:30,000 --> 00:00:34,000
selalunya di tempat-tempat dan masa yang jauh dari kesilapan asal.

14
00:00:34,000 --> 00:00:37,000
Mengesan masalah diperhatikan kembali kepada punca asas

15
00:00:37,000 --> 00:00:39,000
boleh mencabar,

16
00:00:39,000 --> 00:00:42,000
tetapi mujurlah ada satu program yang membantu dipanggil Valgrind

17
00:00:42,000 --> 00:00:44,000
yang boleh melakukan banyak untuk membantu.

18
00:00:44,000 --> 00:00:47,000
>> Anda menjalankan program bawah Valgrind untuk membolehkan

19
00:00:47,000 --> 00:00:50,000
pemeriksaan luas peruntukan memori timbunan dan mengakses.

20
00:00:50,000 --> 00:00:53,000
Apabila Valgrind mengesan masalah, ia memberikan anda serta-merta,

21
00:00:53,000 --> 00:00:56,000
maklumat langsung yang membolehkan anda untuk

22
00:00:56,000 --> 00:00:58,000
lebih mudah mencari dan menyelesaikan masalah.

23
00:00:58,000 --> 00:01:01,000
Valgrind juga laporan mengenai isu-isu memori yang kurang maut,

24
00:01:01,000 --> 00:01:04,000
seperti kebocoran memori, memperuntukkan memori timbunan,

25
00:01:04,000 --> 00:01:07,000
dan lupa untuk membebaskan.

26
00:01:07,000 --> 00:01:10,000
Seperti pengkompil kami, dilafaz, penyahpepijat kami, GDB,

27
00:01:10,000 --> 00:01:14,000
Valgrind adalah perisian bebas, dan ia dipasang pada perkakas.

28
00:01:14,000 --> 00:01:16,000
Valgrind berjalan pada laku perduaan anda,

29
00:01:16,000 --> 00:01:20,000
tidak c anda atau h kod fail sumber,

30
00:01:20,000 --> 00:01:23,000
jadi pastikan anda telah kumpulkan salinan up-to-tarikh program anda

31
00:01:23,000 --> 00:01:25,000
menggunakan dilafaz atau Buat.

32
00:01:25,000 --> 00:01:28,000
Kemudian, menjalankan program anda di bawah Valgrind boleh

33
00:01:28,000 --> 00:01:32,000
semudah hanya awalan arahan program standard dengan Valgrind perkataan,

34
00:01:32,000 --> 00:01:35,000
yang bermula Valgrind dan menjalankan program di dalamnya.

35
00:01:35,000 --> 00:01:38,000
Apabila bermula, Valgrind melakukan beberapa kompleks

36
00:01:38,000 --> 00:01:41,000
jiggering untuk mengkonfigurasi executable untuk cek memori,

37
00:01:41,000 --> 00:01:44,000
supaya ia boleh mengambil sedikit untuk bangun dan berjalan.

38
00:01:44,000 --> 00:01:48,000
Program ini kemudiannya akan melaksanakan biasanya, ia lebih perlahan,

39
00:01:48,000 --> 00:01:52,000
dan apabila ia selesai, Valgrind akan mencetak ringkasan penggunaan memori.

40
00:01:52,000 --> 00:01:58,000
Jika semua berjalan lancar, ia akan kelihatan seperti ini:

41
00:01:58,000 --> 00:02:01,000
Dalam kes ini, / clean_program

42
00:02:01,000 --> 00:02:04,000
adalah laluan kepada program yang saya mahu untuk menjalankan.

43
00:02:04,000 --> 00:02:06,000
Dan manakala yang satu ini tidak mengambil apa-apa hujah,

44
00:02:06,000 --> 00:02:09,000
jika ia tidak saya mahu hanya jelujur mereka ke akhir arahan seperti biasa.

45
00:02:09,000 --> 00:02:12,000
Program bersih adalah hanya satu program bodoh sedikit saya mencipta

46
00:02:12,000 --> 00:02:15,000
yang memperuntukkan ruang untuk blok ints pada timbunan,

47
00:02:15,000 --> 00:02:19,000
meletakkan beberapa nilai di dalam mereka, dan membebaskan keseluruhan blok.

48
00:02:19,000 --> 00:02:23,000
Ini adalah apa yang anda menembak, tiada kesilapan dan tiada kebocoran.

49
00:02:23,000 --> 00:02:27,000
>> Satu lagi metrik penting ialah jumlah bait yang diperuntukkan.

50
00:02:27,000 --> 00:02:32,000
Bergantung kepada program, jika peruntukan anda berada dalam megabait atau lebih tinggi,

51
00:02:32,000 --> 00:02:34,000
anda mungkin melakukan sesuatu yang salah.

52
00:02:34,000 --> 00:02:37,000
Adakah anda tidak perlu menyimpan salinan?

53
00:02:37,000 --> 00:02:40,000
Adakah anda menggunakan timbunan untuk penyimpanan, apabila ia akan menjadi lebih baik untuk menggunakan timbunan?

54
00:02:40,000 --> 00:02:43,000
Jadi, kesilapan memori boleh menjadi benar-benar jahat.

55
00:02:43,000 --> 00:02:46,000
Orang-orang yang lebih terang-terangan menyebabkan kemalangan yang menakjubkan,

56
00:02:46,000 --> 00:02:49,000
tetapi walaupun begitu ia masih boleh menjadi sukar untuk menentukan

57
00:02:49,000 --> 00:02:51,000
apa sebenarnya membawa kepada kemalangan.

58
00:02:51,000 --> 00:02:54,000
Lebih insidiously, program dengan kesilapan memori

59
00:02:54,000 --> 00:02:56,000
masih boleh menyusun rapi

60
00:02:56,000 --> 00:02:58,000
dan masih boleh kelihatan untuk bekerja dengan betul

61
00:02:58,000 --> 00:03:01,000
kerana anda berjaya untuk mendapatkan bertuah kebanyakan masa.

62
00:03:01,000 --> 00:03:04,000
Selepas beberapa "hasil yang berjaya,"

63
00:03:04,000 --> 00:03:07,000
anda mungkin berfikir bahawa kemalangan adalah kebetulan komputer,

64
00:03:07,000 --> 00:03:10,000
tetapi komputer tidak pernah salah.

65
00:03:10,000 --> 00:03:13,000
>> Running Valgrind boleh membantu anda mengesan punca kesilapan memori dilihat

66
00:03:13,000 --> 00:03:18,000
serta mencari mengintai kesilapan anda tidak lagi tahu tentang.

67
00:03:18,000 --> 00:03:22,000
Setiap kali Valgrind mengesan masalah, ia mencetak maklumat tentang apa yang ia diperhatikan.

68
00:03:22,000 --> 00:03:24,000
Setiap item adalah agak rapi -

69
00:03:24,000 --> 00:03:27,000
garis sumber arahan bersalah, apa isu,

70
00:03:27,000 --> 00:03:30,000
dan maklumat sedikit tentang memori yang terlibat -

71
00:03:30,000 --> 00:03:34,000
tetapi selalunya ia adalah maklumat yang cukup untuk mengarahkan perhatian anda ke tempat yang betul.

72
00:03:34,000 --> 00:03:37,000
Berikut adalah contoh Valgrind berjalan pada program kereta

73
00:03:37,000 --> 00:03:40,000
yang tidak membaca tidak sah memori timbunan.

74
00:03:40,000 --> 00:03:49,000
Kami melihat tidak ada kesilapan atau amaran dalam kompilasi.

75
00:03:49,000 --> 00:03:53,000
Uh-oh, ringkasan ralat mengatakan bahawa terdapat dua kesilapan -

76
00:03:53,000 --> 00:03:56,000
dua reads tidak sah daripada 4 saiz - bait, iaitu.

77
00:03:56,000 --> 00:04:01,000
Kedua-dua buruk berbunyi berlaku dalam fungsi utama invalid_read.c,

78
00:04:01,000 --> 00:04:04,000
pertama pada 16 baris dan kedua pada 19 baris.

79
00:04:04,000 --> 00:04:06,000
Mari kita lihat pada kod.

80
00:04:06,000 --> 00:04:11,000
Kelihatan seperti panggilan pertama untuk printf cuba untuk membaca satu int lalu akhir blok ingatan kita.

81
00:04:11,000 --> 00:04:13,000
Jika kita melihat kembali pada output Valgrind,

82
00:04:13,000 --> 00:04:16,000
kita lihat bahawa Valgrind memberitahu kita tepat.

83
00:04:16,000 --> 00:04:19,000
Alamat kita sedang cuba untuk membaca bermula 0 bytes

84
00:04:19,000 --> 00:04:22,000
lepas akhir blok saiz 16 bait -

85
00:04:22,000 --> 00:04:25,000
empat 32-bit ints bahawa kita memperuntukkan.

86
00:04:25,000 --> 00:04:29,000
Iaitu, alamat kita cuba membaca bermula tepat pada akhir blok kami,

87
00:04:29,000 --> 00:04:32,000
hanya seperti yang kita lihat dalam panggilan buruk printf kami.

88
00:04:32,000 --> 00:04:36,000
Sekarang, tidak sah dibaca mungkin tidak kelihatan seperti yang besar perjanjian,

89
00:04:36,000 --> 00:04:39,000
tetapi jika anda menggunakan data untuk mengawal aliran program anda -

90
00:04:39,000 --> 00:04:42,000
sebagai contoh, sebagai sebahagian daripada jika pernyataan atau gelung -

91
00:04:42,000 --> 00:04:45,000
kemudian perkara senyap boleh pergi buruk.

92
00:04:45,000 --> 00:04:47,000
Watch bagaimana saya boleh menjalankan program invalid_read

93
00:04:47,000 --> 00:04:50,000
dan apa-apa yang luar biasa berlaku.

94
00:04:50,000 --> 00:04:52,000
Menakutkan, kan?

95
00:04:52,000 --> 00:04:56,000
>> Sekarang, mari kita lihat di beberapa lagi jenis kesilapan yang mungkin anda temui di dalam kod anda,

96
00:04:56,000 --> 00:04:59,000
dan kita akan melihat bagaimana Valgrind mengesan mereka.

97
00:04:59,000 --> 00:05:01,000
Kami hanya melihat satu contoh invalid_read satu,

98
00:05:01,000 --> 00:05:04,000
jadi sekarang mari kita menyemak invalid_write.

99
00:05:04,000 --> 00:05:09,000
Sekali lagi, tiada kesilapan atau amaran dalam kompilasi.

100
00:05:09,000 --> 00:05:12,000
Okay, Valgrind mengatakan bahawa terdapat dua kesilapan dalam program ini -

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

102
00:05:15,000 --> 00:05:18,000
Mari kita menyemak kod ini.

103
00:05:18,000 --> 00:05:21,000
Kelihatan seperti kita telah mendapat satu contoh daripada strlen klasik ditambah satu pepijat.

104
00:05:21,000 --> 00:05:24,000
Kod tidak malloc bait tambahan ruang

105
00:05:24,000 --> 00:05:26,000
untuk watak / 0,

106
00:05:26,000 --> 00:05:30,000
jadi apabila salinan str pergi untuk menulis di ssubstrlen "cs50 batu!"

107
00:05:30,000 --> 00:05:33,000
ia menulis 1 bait lepas akhir blok kami.

108
00:05:33,000 --> 00:05:36,000
Invalid_read datang apabila kita membuat panggilan kami untuk printf.

109
00:05:36,000 --> 00:05:40,000
Printf berakhir membaca memori tidak sah apabila ia membaca / 0 aksara

110
00:05:40,000 --> 00:05:43,000
kerana ia kelihatan pada akhir rentetan E ini ia percetakan.

111
00:05:43,000 --> 00:05:45,000
Tetapi tidak seorang pun daripada ini melarikan diri Valgrind.

112
00:05:45,000 --> 00:05:48,000
Kita lihat bahawa ia ditangkap invalid_write sebagai sebahagian daripada salinan str

113
00:05:48,000 --> 00:05:51,000
pada 11 barisan utama, dan invalid_read adalah sebahagian daripada printf.

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

115
00:05:54,000 --> 00:05:57,000
Sekali lagi, ini tidak mungkin kelihatan seperti perjanjian yang besar.

116
00:05:57,000 --> 00:06:00,000
Kita boleh menjalankan program ini berulang luar Valgrind

117
00:06:00,000 --> 00:06:03,000
dan tidak melihat sebarang tanda-tanda kesilapan.

118
00:06:03,000 --> 00:06:06,000
>> Walau bagaimanapun, mari kita melihat sedikit perbezaan ini untuk melihat

119
00:06:06,000 --> 00:06:09,000
bagaimana perkara boleh mendapatkan benar-benar buruk.

120
00:06:09,000 --> 00:06:14,000
Jadi, yang diberikan, kita menyalahgunakan perkara yang lebih daripada hanya sedikit dalam kod ini.

121
00:06:14,000 --> 00:06:17,000
Kami hanya memperuntukkan ruang pada timbunan selama dua rentetan

122
00:06:17,000 --> 00:06:19,000
panjang cs50 batu,

123
00:06:19,000 --> 00:06:22,000
masa ini, mengingat / 0 watak.

124
00:06:22,000 --> 00:06:25,000
Tetapi kemudian kita buang dalam rentetan super-panjang ke dalam blok memori

125
00:06:25,000 --> 00:06:27,000
S menunjuk ke.

126
00:06:27,000 --> 00:06:30,000
Apa kesan akan yang mempunyai blok memori yang menunjukkan T?

127
00:06:30,000 --> 00:06:34,000
Nah, jika mata T memori yang hanya bersebelahan S,

128
00:06:34,000 --> 00:06:37,000
datang hanya selepas ia,

129
00:06:37,000 --> 00:06:39,000
maka kita mungkin telah ditulis lebih sebahagian T.

130
00:06:39,000 --> 00:06:41,000
Mari kita menjalankan kod ini.

131
00:06:41,000 --> 00:06:43,000
Lihatlah apa yang berlaku.

132
00:06:43,000 --> 00:06:47,000
Rentetan kita disimpan dalam blok timbunan kami kedua-dua muncul telah dicetak dengan betul.

133
00:06:47,000 --> 00:06:49,000
Tiada apa-apa seolah-olah salah pada semua.

134
00:06:49,000 --> 00:06:52,000
Walau bagaimanapun, mari kita kembali ke dalam kod kami dan

135
00:06:52,000 --> 00:06:55,000
mengulas garis mana kita menyalin cs50 batu

136
00:06:55,000 --> 00:06:59,000
ke dalam blok memori yang kedua, menunjukkan oleh t.

137
00:06:59,000 --> 00:07:02,000
Sekarang, apabila kita menjalankan kod ini kita harus

138
00:07:02,000 --> 00:07:06,000
hanya melihat kandungan blok memori pertama mencetak keluar.

139
00:07:06,000 --> 00:07:09,000
Wah, walaupun kita tidak melakukan salinan str

140
00:07:09,000 --> 00:07:12,000
mana-mana aksara ke dalam blok timbunan kedua, satu menunjuk oleh T,

141
00:07:12,000 --> 00:07:15,000
kita dapat mencetak keluar.

142
00:07:15,000 --> 00:07:18,000
Malah, tali kita disumbat ke dalam blok pertama kita

143
00:07:18,000 --> 00:07:21,000
Mekah blok pertama dan ke blok kedua,

144
00:07:21,000 --> 00:07:23,000
membuat segala-galanya kelihatan normal.

145
00:07:23,000 --> 00:07:26,000
Valgrind, walaupun, memberitahu kita cerita benar.

146
00:07:26,000 --> 00:07:28,000
Terdapat kita pergi.

147
00:07:28,000 --> 00:07:32,000
Semua orang-orang yang tidak sah membaca dan menulis.

148
00:07:32,000 --> 00:07:36,000
>> Mari kita lihat pada contoh jenis lain kesilapan.

149
00:07:36,000 --> 00:07:39,000
Di sini kita melakukan sesuatu yang agak malang.

150
00:07:39,000 --> 00:07:41,000
Kami merebut ruang untuk int pada timbunan,

151
00:07:41,000 --> 00:07:45,000
dan kami memulakan penunjuk int - p - untuk menunjukkan ruang yang.

152
00:07:45,000 --> 00:07:48,000
Walau bagaimanapun, manakala penunjuk kami dimulakan,

153
00:07:48,000 --> 00:07:52,000
data yang ia menunjuk kepada hanya apa jua ringan adalah di bahagian timbunan.

154
00:07:52,000 --> 00:07:55,000
Jadi apabila kita memuatkan bahawa data ke dalam int i,

155
00:07:55,000 --> 00:07:57,000
kita teknikal memulakan i,

156
00:07:57,000 --> 00:08:00,000
tetapi kita berbuat demikian dengan data sampah.

157
00:08:00,000 --> 00:08:03,000
Panggilan untuk menegaskan, yang merupakan makro debugging berguna

158
00:08:03,000 --> 00:08:06,000
ditakrifkan dalam perpustakaan yang dinamakan menegaskan,

159
00:08:06,000 --> 00:08:09,000
akan membatalkan program jika keadaan ujian gagal.

160
00:08:09,000 --> 00:08:11,000
Iaitu, jika saya tidak adalah 0.

161
00:08:11,000 --> 00:08:14,000
Bergantung pada apa yang berada di ruang timbunan itu, menunjukkan oleh p,

162
00:08:14,000 --> 00:08:18,000
program ini mungkin bekerja dan kadang-kadang gagal pada masa yang lain.

163
00:08:18,000 --> 00:08:20,000
Jika ia berfungsi, kita hanya mendapat bertuah.

164
00:08:20,000 --> 00:08:24,000
Pengkompil tidak akan menangkap kesilapan ini, tetapi Valgrind kehendak pasti.

165
00:08:24,000 --> 00:08:28,000
Ada kita lihat kesilapan yang berpunca daripada penggunaan kami bahawa data sampah.

166
00:08:28,000 --> 00:08:32,000
>> Apabila anda memperuntukkan memori timbunan tetapi tidak deallocate atau membebaskannya,

167
00:08:32,000 --> 00:08:34,000
yang dipanggil kebocoran.

168
00:08:34,000 --> 00:08:37,000
Untuk kecil, program singkat yang berjalan dan segera keluar,

169
00:08:37,000 --> 00:08:39,000
kebocoran yang agak tidak berbahaya,

170
00:08:39,000 --> 00:08:42,000
tetapi untuk projek saiz yang lebih besar dan / atau panjang umur,

171
00:08:42,000 --> 00:08:46,000
walaupun kebocoran kecil boleh mengkompaun menjadi sesuatu yang utama.

172
00:08:46,000 --> 00:08:49,000
Bagi CS50, kami mengharapkan anda untuk

173
00:08:49,000 --> 00:08:51,000
menjaga membebaskan semua memori timbunan bahawa anda memperuntukkan,

174
00:08:51,000 --> 00:08:54,000
kerana kami ingin anda untuk membina kemahiran untuk betul mengendalikan proses manual

175
00:08:54,000 --> 00:08:56,000
dikehendaki oleh C.

176
00:08:56,000 --> 00:08:59,000
Untuk berbuat demikian, program anda harus mempunyai yang tepat

177
00:08:59,000 --> 00:09:03,000
satu-satu surat-menyurat antara malloc dan panggilan percuma.

178
00:09:03,000 --> 00:09:06,000
Mujurlah, Valgrind boleh membantu anda dengan kebocoran memori juga.

179
00:09:06,000 --> 00:09:09,000
Berikut adalah program bocor dipanggil leak.c yang memperuntukkan

180
00:09:09,000 --> 00:09:13,000
ruang pada timbunan, menulis kepadanya, tetapi tidak membebaskan.

181
00:09:13,000 --> 00:09:16,000
Kami menyusun dengan Membuat dan menjalankan di bawah Valgrind,

182
00:09:16,000 --> 00:09:18,000
dan kita lihat bahawa, sementara kita tidak mempunyai ralat memori,

183
00:09:18,000 --> 00:09:20,000
kita mempunyai satu kebocoran.

184
00:09:20,000 --> 00:09:23,000
Terdapat 16 bytes pasti hilang,

185
00:09:23,000 --> 00:09:27,000
bermakna bahawa penunjuk kepada memori yang tidak berada dalam skop apabila program keluar.

186
00:09:27,000 --> 00:09:30,000
Sekarang, Valgrind tidak memberikan kita satu tan maklumat tentang kebocoran,

187
00:09:30,000 --> 00:09:35,000
tetapi jika kita mengikuti nota ini sedikit bahawa ia memberikan ke arah bahagian bawah laporan

188
00:09:35,000 --> 00:09:38,000
untuk memutarkan lagi dengan kebocoran menyemak = penuh

189
00:09:38,000 --> 00:09:41,000
untuk melihat butiran penuh memori bocor,

190
00:09:41,000 --> 00:09:44,000
kita akan mendapatkan maklumat lanjut.

191
00:09:44,000 --> 00:09:46,000
Sekarang, dalam ringkasan timbunan,

192
00:09:46,000 --> 00:09:50,000
Valgrind memberitahu kita di mana memori yang hilang pada mulanya diperuntukkan.

193
00:09:50,000 --> 00:09:52,000
Sama seperti kita tahu dari melihat dalam kod sumber,

194
00:09:52,000 --> 00:09:55,000
Valgrind memberitahu kita bahawa kita bocor memori

195
00:09:55,000 --> 00:09:58,000
yang diperuntukkan dengan panggilan malloc on line 8 daripada leak.c

196
00:09:58,000 --> 00:10:00,000
dalam fungsi utama.

197
00:10:00,000 --> 00:10:02,000
Cukup bagus.

198
00:10:02,000 --> 00:10:04,000
>> Valgrind mengkategorikan kebocoran menggunakan istilah-istilah ini:

199
00:10:04,000 --> 00:10:07,000
Pasti hilang - ini adalah memori timbunan diperuntukkan

200
00:10:07,000 --> 00:10:10,000
yang program ini tidak lagi mempunyai penunjuk.

201
00:10:10,000 --> 00:10:14,000
Valgrind tahu bahawa anda pernah penunjuk tetapi telah sejak hilang mengesan ia.

202
00:10:14,000 --> 00:10:17,000
Memori ini pasti bocor.

203
00:10:17,000 --> 00:10:20,000
Secara tidak langsung hilang - ini adalah memori timbunan diperuntukkan

204
00:10:20,000 --> 00:10:24,000
yang petunjuk sahaja ia juga hilang.

205
00:10:24,000 --> 00:10:27,000
Sebagai contoh, jika anda kehilangan penunjuk anda untuk nod pertama senarai berkaitan,

206
00:10:27,000 --> 00:10:30,000
maka nod pertama itu sendiri akan pasti hilang,

207
00:10:30,000 --> 00:10:34,000
semasa mana-mana nod berikutnya akan secara tidak langsung hilang.

208
00:10:34,000 --> 00:10:37,000
Mungkin hilang - ini adalah memori timbunan diperuntukkan

209
00:10:37,000 --> 00:10:41,000
yang Valgrind tidak boleh pasti sama ada terdapat penunjuk atau tidak.

210
00:10:41,000 --> 00:10:44,000
Masih dicapai memori timbunan diperuntukkan

211
00:10:44,000 --> 00:10:47,000
yang program ini masih mempunyai penunjuk di bahagian keluar,

212
00:10:47,000 --> 00:10:50,000
yang biasanya bermaksud bahawa mata global yang berubah-ubah untuk ia.

213
00:10:50,000 --> 00:10:53,000
Untuk memeriksa kebocoran ini, anda juga akan mempunyai termasuk pilihan

214
00:10:53,000 --> 00:10:55,000
- Masih dikunjungi = ya

215
00:10:55,000 --> 00:10:58,000
dalam doa anda Valgrind.

216
00:10:58,000 --> 00:11:01,000
>> Kes-kes yang berbeza mungkin memerlukan strategi yang berbeza untuk membersihkan mereka,

217
00:11:01,000 --> 00:11:05,000
tetapi kebocoran hendaklah dihapuskan.

218
00:11:05,000 --> 00:11:08,000
Malangnya, menetapkan kebocoran boleh menjadi sukar untuk dilakukan,

219
00:11:08,000 --> 00:11:11,000
sejak panggilan tidak betul untuk bebas boleh meletupkan program anda.

220
00:11:11,000 --> 00:11:14,000
Sebagai contoh, jika kita melihat di invalid_free.c,

221
00:11:14,000 --> 00:11:18,000
kita lihat satu contoh deallocation memori buruk.

222
00:11:18,000 --> 00:11:21,000
Apa yang perlu panggilan tunggal untuk membebaskan seluruh blok

223
00:11:21,000 --> 00:11:24,000
memori menunjukkan oleh int_block,

224
00:11:24,000 --> 00:11:27,000
sebaliknya telah menjadi satu cubaan untuk membebaskan setiap seksyen int bersaiz

225
00:11:27,000 --> 00:11:29,000
memori individu.

226
00:11:29,000 --> 00:11:32,000
Ini akan gagal catastrophically.

227
00:11:32,000 --> 00:11:34,000
Boom! Apa ralat.

228
00:11:34,000 --> 00:11:36,000
Ini memang tidak baik.

229
00:11:36,000 --> 00:11:39,000
Jika anda terjebak dengan jenis ini kesilapan, walaupun, dan anda tidak tahu di mana untuk melihat,

230
00:11:39,000 --> 00:11:41,000
jatuh kembali pada rakan baru anda yang terbaik.

231
00:11:41,000 --> 00:11:44,000
Anda fikirkan - Valgrind.

232
00:11:44,000 --> 00:11:47,000
Valgrind, seperti biasa, tahu apa terpulang.

233
00:11:47,000 --> 00:11:50,000
Tuduhan alloc dan bebas tidak sepadan.

234
00:11:50,000 --> 00:11:52,000
Kami telah mendapat 1 alloc dan 4 membebaskan.

235
00:11:52,000 --> 00:11:55,000
Dan Valgrind juga memberitahu kita di mana panggilan pertama percuma buruk -

236
00:11:55,000 --> 00:11:58,000
satu yang mencetuskan blowup - datang dari -

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

238
00:12:00,000 --> 00:12:03,000
Seperti yang anda lihat, panggilan buruk untuk membebaskan adalah benar-benar buruk,

239
00:12:03,000 --> 00:12:05,000
jadi kami cadangkan membiarkan kebocoran program anda

240
00:12:05,000 --> 00:12:08,000
semasa anda sedang berusaha untuk mendapatkan fungsi betul.

241
00:12:08,000 --> 00:12:12,000
Mula mencari kebocoran hanya selepas program anda berfungsi dengan betul,

242
00:12:12,000 --> 00:12:14,000
tanpa apa-apa kesilapan lain.

243
00:12:14,000 --> 00:12:16,000
>> Dan itu semua kita telah mendapat untuk video ini.

244
00:12:16,000 --> 00:12:18,000
Sekarang apa yang anda tunggu?

245
00:12:18,000 --> 00:12:21,000
Pergi berjalan Valgrind pada program anda sekarang.

246
00:12:21,000 --> 00:12:25,000
Nama saya adalah Nate Hardison. Ini adalah CS50. [CS50.TV]