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
私たちのデバッガで、コンパイラ、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
ないあなた。cまたはHのソースコードファイル、

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
、メモリチェック用の実行ファイルを設定する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
そして、この1つの任意の引数を取りませんが、

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
それは、ヒープ上にint型のブロックのためのスペースを割り当て

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
おっと、エラー·サマリには、2つのエラーがあることを言う - 

76
00:03:53,000 --> 00:03:56,000
サイズ4の2つの無効な読み取り - バイトです。

77
00:03:56,000 --> 00:04:01,000
両方悪いが、invalid_read.cのメイン機能で問題が発生して読み取り、

78
00:04:01,000 --> 00:04:04,000
16行目と19行目の2番目の最初の。

79
00:04:04,000 --> 00:04:06,000
コー​​ドを見てみましょう。

80
00:04:06,000 --> 00:04:11,000
printfの私たちのメモリブロックの末尾を超えて1 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
我々は割り当てた4つの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
if文やループの一部として、例えば - 

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はこのプログラムで2つのエラーがあることを言う - 

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のプラス1バグのインスタンスを持っているように見えます。

104
00:05:21,000 --> 00:05:24,000
コー​​ドはmallocスペースの余分なバイトをしません

105
00:05:24,000 --> 00:05:26,000
文字/ 0のため、

106
00:05:26,000 --> 00:05:30,000
ので、strコピーがssubstrlenでそれを書くために行ったとき、 "CS50岩！"

107
00:05:30,000 --> 00:05:33,000
それは私たちのブロックの終わりを超えて1バイトを書いた。

108
00:05:33,000 --> 00:05:36,000
我々は、printfに我々の呼び出しを行ったときinvalid_readが来る。

109
00:05:36,000 --> 00:05:40,000
それは/ 0の文字を読み取るときにprintfの無効なメモリを読み終わる

110
00:05:40,000 --> 00:05:43,000
それがこのE列の端で見えるようになり、印刷です。

111
00:05:43,000 --> 00:05:45,000
しかし、これのどれもValgrindのを免れない。

112
00:05:45,000 --> 00:05:48,000
我々は、それがstrのコピーの一部として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
我々は唯一の2つの文字列のヒープで領域を割り当てている

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
まあ、Sにちょうど隣接のメモリへのTポイントであれば、

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
第2のメモリブロックには、tが指す。

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
おっと、我々は、strコピーしなかったにもかかわらず、

140
00:07:09,000 --> 00:07:12,000
第二ヒープブロックに任意の文字が、1は、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
第一ブロックと第2ブロックにし、オーバーラン

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
そのスペースを指すように -  P  - と我々はint型のポインタを初期化します。

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
我々は、技術的には、iを初期化

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
iが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
>> あなたはヒープメモリを割り当て、それを解放するか、それを解放しない場合、

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
mallocとfreeの呼び出しの間に1対1に対応。

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
leak.cの8行目に呼び出されたmallocで割り当てられ

196
00:09:58,000 --> 00:10:00,000
main関数インチ

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
ブーム！どのようなエラー。

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]