1
00:00:00,000 --> 00:00:00,309

2
00:00:00,309 --> 00:00:02,350
[？ DAN ARMADARAS：？]こんにちは、
私は[よ？ダンArmadaras？]。

3
00:00:02,350 --> 00:00:04,410
今日、我々はするつもりです
デバッグを見ています。

4
00:00:04,410 --> 00:00:06,697
だけでなく、我々がしようとしています
いくつかのテクニックについて話します、

5
00:00:06,697 --> 00:00:09,280
だけでなく、我々が見てするつもりです
特徴のいくつかを含有

6
00:00:09,280 --> 00:00:14,170
許可CS50のIDE内で
あなたは簡単にプログラムをデバッグします。

7
00:00:14,170 --> 00:00:16,272
>> のほんの一例
間違って行くことができるもの

8
00:00:16,272 --> 00:00:18,730
それは実際に何か
我々は既に前に見たこと。

9
00:00:18,730 --> 00:00:23,200
この場合、これは、Cプログラムであります
すなわち、ユーザからの整数を受け付け

10
00:00:23,200 --> 00:00:27,580
2で除算し、提供
バックユーザに出力。

11
00:00:27,580 --> 00:00:30,610
今、私たちが見てきたものから
以前の講義で、

12
00:00:30,610 --> 00:00:34,370
私たちは、これが実際に原因となりますことを知っています
分割問題の特定のタイプ

13
00:00:34,370 --> 00:00:35,860
私たちは、奇数を持っている場合。

14
00:00:35,860 --> 00:00:40,330
>> 具体的には、私たちは捨てますよ
小数点以下のもの。

15
00:00:40,330 --> 00:00:43,170
今、私たちはこのことを知っています
ケースであることを起こります。

16
00:00:43,170 --> 00:00:47,430
そして、我々はそれを実行した場合、我々は確認することができます
コンパイルすることにより、私たちの疑惑は、まず、。

17
00:00:47,430 --> 00:00:50,460
そして、実行していることにより、
奇数番号を入力します。

18
00:00:50,460 --> 00:00:51,720
>> これは新しいものではありません。

19
00:00:51,720 --> 00:00:54,490
しかし、これは実際にあります
そのバグの例

20
00:00:54,490 --> 00:00:58,810
より大きなプログラム内に存在することができます
それがダウンして追跡することが困難になります。

21
00:00:58,810 --> 00:01:02,640
私たちはどのような問題を知っているにもかかわらず
、問題の真の核心であります

22
00:01:02,640 --> 00:01:06,250
識別しようとしている可能性があります
具体的にどこでエラーが発生し、

23
00:01:06,250 --> 00:01:09,750
何その問題を特定します
であり、そしてそれを固定します。

24
00:01:09,750 --> 00:01:14,400
だから例としてこれを提供
何かが何であるかの

25
00:01:14,400 --> 00:01:19,030
我々はすでに知っているが、埋め込むことができること
コー​​ドの他の要素の中。

26
00:01:19,030 --> 00:01:23,090
>> したがって、この他のソースを開きます
例として、コードファイル、

27
00:01:23,090 --> 00:01:27,165
この部門の問題は今あります
大きなプログラムの一部。

28
00:01:27,165 --> 00:01:29,040
まだ少しあるかもしれません
少し不自然な、と私たち

29
00:01:29,040 --> 00:01:31,076
簡単にすることができるかもしれません
特に、それを識別

30
00:01:31,076 --> 00:01:32,450
私たちはこれを議論しているからです。

31
00:01:32,450 --> 00:01:38,250
しかし、我々はこのことを把握することができます
問題は、より大きな規模で存在することができます。

32
00:01:38,250 --> 00:01:45,450
>> 私は今、これをコンパイルした場合
それを実行し、奇数番号を入力し、

33
00:01:45,450 --> 00:01:49,816
我々は正確に取得しないことがわかります
我々が期待している可能性があり、出力。

34
00:01:49,816 --> 00:01:51,690
この特定の場合において、
我々は、我々が言うかもしれません

35
00:01:51,690 --> 00:01:56,060
数字のすべてをカウントします
いくつかの特定の数まで1から。

36
00:01:56,060 --> 00:01:58,130
そして、我々は、我々を見ることができます
さまざまな問題を持っています

37
00:01:58,130 --> 00:02:03,880
ここで我々は、単純に、0を出力している場合
1私たちは5の入力を提供します。

38
00:02:03,880 --> 00:02:07,380
>> だから我々はすでに知っていること
ここでの問題があります。

39
00:02:07,380 --> 00:02:11,662
しかし、我々は正確には知らないかもしれません
この問題は、実際に存在する場合。

40
00:02:11,662 --> 00:02:13,620
今その方法の1つを
我々はこの問題を解決しようとすることができます

41
00:02:13,620 --> 00:02:15,745
私たちがきたものです
既にに導入されて。

42
00:02:15,745 --> 00:02:18,880
私達はちょうど大規模にそれを使用することができます。

43
00:02:18,880 --> 00:02:21,680
>> 14行目では、我々は持っています
このprintf関数、

44
00:02:21,680 --> 00:02:25,620
私たちは状態をプリントアウトすることを可能にします
各種情報の。

45
00:02:25,620 --> 00:02:28,880
そして、これは何かであることを
プログラム内で利用してください

46
00:02:28,880 --> 00:02:33,100
です正確に何を把握しようとします
コー​​ドの様々なラインで起こっ。

47
00:02:33,100 --> 00:02:36,350
これはない場合であっても
最終的な出力実際に我々

48
00:02:36,350 --> 00:02:39,830
外に演出したいです
このプログラム、まだ我々

49
00:02:39,830 --> 00:02:42,300
いくつかのデバッグを持っている可能性があります
ステートメントたち

50
00:02:42,300 --> 00:02:46,970
正確に何を把握しようとすることができます
我々のコードの内部で起こっています。

51
00:02:46,970 --> 00:02:51,210
>> したがって、この場合には、私は意志
デバッグタグが付けられたのprintf。

52
00:02:51,210 --> 00:02:53,540
この場合、これは
単にデバッグ文字列

53
00:02:53,540 --> 00:02:56,840
それはなるように、私はアップ入れていること
私のコードの出力は非常に明確な

54
00:02:56,840 --> 00:02:59,200
何それは私が表示したいということです。

55
00:02:59,200 --> 00:03:04,410
ここと出力数を
我々が計算されていること。

56
00:03:04,410 --> 00:03:06,800
>> この場合、私はかもしれません
正確に知りたいです

57
00:03:06,800 --> 00:03:11,380
何が前に起こっていると
いくつかの特定の演算後。

58
00:03:11,380 --> 00:03:16,224
だから私は前のprintfを使用する場合があります
そのコード行の後。

59
00:03:16,224 --> 00:03:18,640
この場合、私もできました
それはもう少し明確にします

60
00:03:18,640 --> 00:03:21,960
前にデバッグを言って
デバッグ後にそう

61
00:03:21,960 --> 00:03:26,540
私は自分自身を混同しないこと
同じに見える複数の行。

62
00:03:26,540 --> 00:03:32,290
>> 今、私たちは、このファイル名を指定して実行を再コンパイルする場合
それは、再び5のように番号を入力し、

63
00:03:32,290 --> 00:03:35,090
我々は持っていることがわかります
今の前と後の出力

64
00:03:35,090 --> 00:03:40,670
我々は明確に行っていないことがわかります
数の持つ部門またはクリア

65
00:03:40,670 --> 00:03:43,680
私たちは実際にやってみたいこと。

66
00:03:43,680 --> 00:03:48,660
今、この場合、これは
本当にクリア出力。

67
00:03:48,660 --> 00:03:52,440
それは本当に明確な結果ではないこと
我々は、この特定のプログラムの外にしたいです。

68
00:03:52,440 --> 00:03:54,427
>> そして、これは、再び、あります
少し不自然。

69
00:03:54,427 --> 00:03:57,510
しかし、おそらく、そのことの一つ
仕様が言った場合、私たちは何ができます

70
00:03:57,510 --> 00:04:01,900
私たちはすることによって、これを分割したいこと
2および他の言葉でそう1--を追加し、

71
00:04:01,900 --> 00:04:04,550
我々はその後、up--丸めます
私たちができたことを知っているかもしれません

72
00:04:04,550 --> 00:04:08,060
この場合には、その特定のことを行います。

73
00:04:08,060 --> 00:04:14,010
今ここに私たちがなることを知っています
私たちの半分の数に1を追加すること。

74
00:04:14,010 --> 00:04:16,490
>> それでは、これを再コンパイルしてみましょう
このことを確認します

75
00:04:16,490 --> 00:04:18,860
我々が望むように動作しています。

76
00:04:18,860 --> 00:04:21,980
私たちは今、前にそれを見ることができます
た、我々は数5を持っています。

77
00:04:21,980 --> 00:04:26,620
た後、我々は、数3を持っています
私たちの仕様に従っています、

78
00:04:26,620 --> 00:04:29,292
私たちがやりたいことです。

79
00:04:29,292 --> 00:04:31,000
しかし、私たちが見ている場合
ここで、出力、私たちすることができます

80
00:04:31,000 --> 00:04:33,760
私たちは別のものを持っている可能性があることがわかり
で完全にバグ、

81
00:04:33,760 --> 00:04:36,940
我々は0から我々のカウントを開始していること。

82
00:04:36,940 --> 00:04:39,390
>> 今再び、これは何かであります
我々は、過去に見てきたこと

83
00:04:39,390 --> 00:04:42,500
我々は非常に容易に修正することができます。

84
00:04:42,500 --> 00:04:44,790
しかし、この場合には、我々
また、利益を持っていました

85
00:04:44,790 --> 00:04:48,940
printf文を使用します
直接forループの内側

86
00:04:48,940 --> 00:04:52,930
正確にどこに知っています
そのエラーが発生しました。

87
00:04:52,930 --> 00:04:55,150
だからのprintf文は、
うえで非常に有用

88
00:04:55,150 --> 00:04:57,940
あなたは場所を決定、
正確にソースコードで、

89
00:04:57,940 --> 00:05:00,620
具体的なエラーが発生しています。

90
00:05:00,620 --> 00:05:03,650
>> そして、それは実現することも重要です
その、私たちはコードを書いているように、

91
00:05:03,650 --> 00:05:06,052
我々は仮定を持っている可能性があります
プログラムの状態について。

92
00:05:06,052 --> 00:05:08,510
それとも仮定を持っている可能性があります
プログラムのどの部分について

93
00:05:08,510 --> 00:05:13,020
実際に正しいか間違っているとき
後で、我々はそのプログラムに構築します

94
00:05:13,020 --> 00:05:15,950
その一部にします
複雑で大きなプログラム

95
00:05:15,950 --> 00:05:19,700
我々はそのいくつかの側面を実現すること
そのことを実際にバグがあります。

96
00:05:19,700 --> 00:05:22,680
>> printf関数を使用すると、実際に助けることができます
絞り込むと識別

97
00:05:22,680 --> 00:05:26,430
プログラムの地域ということではないかもしれません
まさに我々の方法を振る舞うこと

98
00:05:26,430 --> 00:05:29,500
私たちの仮定に基づいて、期待しています。

99
00:05:29,500 --> 00:05:31,460
しかし、他のツールがあります
利用できるだけでなく、

100
00:05:31,460 --> 00:05:34,860
それは、私たちが理解しようとすることができます
エラーが発生している場所を

101
00:05:34,860 --> 00:05:39,930
また、具体的には、どのようなもの
プログラムの内部で起こっています。

102
00:05:39,930 --> 00:05:41,990
>> だからprintf関数を使用することは非常にあり
便利なときに私たちが望みます

103
00:05:41,990 --> 00:05:45,900
の特定の領域を識別するために
いくつかのバグを持っているプログラム。

104
00:05:45,900 --> 00:05:47,730
しかし、それはまたになります
しばらくして退屈。

105
00:05:47,730 --> 00:05:50,500
この場合、これは
比較的簡単なプログラム

106
00:05:50,500 --> 00:05:52,750
ただ一つまたは二つの変数を持ちます。

107
00:05:52,750 --> 00:05:57,260
そして、それは私たちのために非常に容易になります
これらの変数の値を印刷

108
00:05:57,260 --> 00:05:59,670
より大きなプログラムのコンテキストインチ

109
00:05:59,670 --> 00:06:02,670
>> しかし、我々は異なるがあるかもしれません
多くの変数を持つプログラム。

110
00:06:02,670 --> 00:06:06,530
そして、それはかなりではないかもしれません
printfのを非常に使いやすいです

111
00:06:06,530 --> 00:06:10,120
何が起こっているかを評価しようとします
これらの変数のそれぞれに

112
00:06:10,120 --> 00:06:13,590
プログラムとして実行されています。

113
00:06:13,590 --> 00:06:16,960
存在するプログラムがあります
デバッガプログラムと呼ばれます。

114
00:06:16,960 --> 00:06:20,320
この場合、一つは、我々は、意志
使用は、GDB GNUデバッガですか、

115
00:06:20,320 --> 00:06:24,260
それは、私たちが内部を検査することができます
はるか内のプログラムの仕組み

116
00:06:24,260 --> 00:06:25,700
詳細な方法。

117
00:06:25,700 --> 00:06:28,810
>> 私たちは、実際に実行することができます
コマンドラインからGDB

118
00:06:28,810 --> 00:06:35,370
ここで、単にGDBと入力して、
我々はデバッグしたいコマンド。

119
00:06:35,370 --> 00:06:37,550
この場合、カウント。

120
00:06:37,550 --> 00:06:41,650
今、この場合には、我々はそのことを見ることができます
GDBを言うプロンプトに私たちをもたらします。

121
00:06:41,650 --> 00:06:44,020
そして、我々は実際にすることができます
GDBにコマンドを実行します

122
00:06:44,020 --> 00:06:48,260
実際の実行を開始します
プログラムは、特定の時点でそれを停止し、

123
00:06:48,260 --> 00:06:51,060
変数を評価し、
その変数を検査

124
00:06:51,060 --> 00:06:54,152
プログラム状態で存在します
その特定の瞬間に、

125
00:06:54,152 --> 00:06:55,110
などなど。

126
00:06:55,110 --> 00:06:57,240
それは、私たちに多くの電力を提供します。

127
00:06:57,240 --> 00:06:59,960
>> しかし、それはちょうどそう起こります
また、CS50 IDEは、

128
00:06:59,960 --> 00:07:05,870
GUIまたはユーザーに提供
GDBのためのインターフェースこと

129
00:07:05,870 --> 00:07:11,120
私たちが必要とすることなく、これを行うことができます
いかなるコマンドラインインターフェース

130
00:07:11,120 --> 00:07:13,560
またはまったくさえ。

131
00:07:13,560 --> 00:07:16,930
私はそれにアクセスすることができる方法
デバッグボタンを使用することです

132
00:07:16,930 --> 00:07:20,120
CS50 IDEの最上部にあります。

133
00:07:20,120 --> 00:07:24,280
今、過去に、我々は何を持っています
見我々はコマンドを使用することです

134
00:07:24,280 --> 00:07:27,660
コンパイルして、プログラムを実行するためのライン。

135
00:07:27,660 --> 00:07:29,790
>> デバッグボタンがありません
これらのステップの両方。

136
00:07:29,790 --> 00:07:34,380
しかし、それはまた、起動されます
右端のデバッガタブ

137
00:07:34,380 --> 00:07:38,280
それは、私たちは多様性を検査することができます
プログラムの特性

138
00:07:38,280 --> 00:07:40,500
それが実行されます。

139
00:07:40,500 --> 00:07:44,280
私はこの中で、デバッグをクリックすると、
場合、それが起動します

140
00:07:44,280 --> 00:07:48,230
コンソールで新しいタブ
一番下にあるウィンドウ。

141
00:07:48,230 --> 00:07:51,160
>> そして、あなたは、このタブが持っていることがわかります
非常に上部にいくつかの情報。

142
00:07:51,160 --> 00:07:52,670
そして、私たちは主にこれを無視することができます。

143
00:07:52,670 --> 00:07:54,800
しかし、物事の一つ
私たちは気づくしたいこと

144
00:07:54,800 --> 00:07:57,170
それを出力することです
その私たちは同じこと

145
00:07:57,170 --> 00:08:03,000
私たちがmakeを実行しようとした場合になるだろう
ターミナルウィンドウで、Cプログラム。

146
00:08:03,000 --> 00:08:06,230
>> ここで、我々はそれが打ち鳴らすを実行している見ることができ、
そして、それはフラグの様々なを持っています、

147
00:08:06,230 --> 00:08:12,660
そしてそれは、私たちのcount.cファイルをコンパイルしています
その時点で選択されたタブでした

148
00:08:12,660 --> 00:08:15,100
私はデバッグを打つこと。

149
00:08:15,100 --> 00:08:18,010
だから、これは非常に便利です
今、このデバッグ]ボタンを使用して、

150
00:08:18,010 --> 00:08:23,280
我々は同時に、次にコンパイルしてできます
実際に私たちのプログラムを実行

151
00:08:23,280 --> 00:08:24,460
実行したいです。

152
00:08:24,460 --> 00:08:27,880
>> あるフラグの一つ
この場合、重要なのは、

153
00:08:27,880 --> 00:08:30,190
私たちは、実際に使用してきました
最も長時間

154
00:08:30,190 --> 00:08:32,450
だけでなく、単にいくつかの手をしました
手を振っ[聞こえない]、これ

155
00:08:32,450 --> 00:08:33,820
これはここです。

156
00:08:33,820 --> 00:08:35,790
打ち鳴らすには、-ggdb3を言います。

157
00:08:35,790 --> 00:08:38,570

158
00:08:38,570 --> 00:08:41,250
この場合、私たちは何をしています
打ち鳴らす言って、私たちのコンパイラ、

159
00:08:41,250 --> 00:08:43,820
我々は我々のプログラムをコンパイルしたいということです。

160
00:08:43,820 --> 00:08:46,810
しかし、またあるものを提供
呼ばれるシンボル情報

161
00:08:46,810 --> 00:08:50,940
コンパイラは、実際にアクセスできるように
基礎となる多くの情報へ

162
00:08:50,940 --> 00:08:52,610
プログラム内に含まれます。

163
00:08:52,610 --> 00:08:55,260
>> より具体的には、数
私が持っている機能の、

164
00:08:55,260 --> 00:08:58,000
これらの関数の名前は、
変数、タイプ

165
00:08:58,000 --> 00:09:01,730
これらの変数は、と多様であることを
デバッガを助ける他のものの

166
00:09:01,730 --> 00:09:04,350
その操作を実行します。

167
00:09:04,350 --> 00:09:06,600
今何か他のものがあります
それは言及することが重要です

168
00:09:06,600 --> 00:09:10,280
我々はランニングを議論しているとき
このようにプログラム。

169
00:09:10,280 --> 00:09:13,660
>> それが実際に持っていることに注意してください
私たちのコンソールで新しいタブを育てました

170
00:09:13,660 --> 00:09:14,780
下部に沿って。

171
00:09:14,780 --> 00:09:18,600
私たちはもはや対話する必要はありません
直接ターミナルウィンドウで。

172
00:09:18,600 --> 00:09:21,420
しかし、この新しいタブがあります
実際にターミナルウィンドウ。

173
00:09:21,420 --> 00:09:26,710
それはちょうど、実行中に固有のものです
私たちが作成したプログラム。

174
00:09:26,710 --> 00:09:29,270
>> で、一番下にあることに注意してください
いくつかの出力との組合せ

175
00:09:29,270 --> 00:09:33,500
コンパイラとGDBを打ち鳴らすことにより、
これは我々が大幅に無視することができ、

176
00:09:33,500 --> 00:09:37,570
実際の出力を示します
一番下に私たちのプログラム。

177
00:09:37,570 --> 00:09:41,240
今では実現することが重要です
その実際にこの一つの窓

178
00:09:41,240 --> 00:09:43,360
あなたが表示されます
あなたのプログラムからの出力

179
00:09:43,360 --> 00:09:47,190
しかし、入力を受け入れることができます
そのプログラムの、同様に。

180
00:09:47,190 --> 00:09:49,260
>> そう言うの通知
番号を入力してください、

181
00:09:49,260 --> 00:09:53,050
これは私達が持っていた同じ出力であります
前ターミナルウィンドウでいました。

182
00:09:53,050 --> 00:09:55,510
しかし、それは今、この新しいタブに表示さです。

183
00:09:55,510 --> 00:09:56,550
私は、入力数をすることができます。

184
00:09:56,550 --> 00:10:00,900
そして、それは実際になります
我々が期待どおりに機能します

185
00:10:00,900 --> 00:10:05,890
私たちのデバッグ出力を示し、
バギーかもしれない出力、

186
00:10:05,890 --> 00:10:07,010
我々は前に見てきたように。

187
00:10:07,010 --> 00:10:10,460
そして、一番下に、それを
実際にいくつかの追加の出力を持っています

188
00:10:10,460 --> 00:10:14,550
GDPからちょうどそれを言って
このプログラムは完了しました。

189
00:10:14,550 --> 00:10:16,655
>> 今、あなたはこので見たように
特定の実行、

190
00:10:16,655 --> 00:10:19,370
それは特にありませんでした
でもために有用

191
00:10:19,370 --> 00:10:23,740
私たちが持っていたものの、デバッガメニューが来ます
アップ、これはまだ実行中のプログラムでした。

192
00:10:23,740 --> 00:10:26,790
どの時点においても、実際にそれをやりました
私たちのために実行を一時停止

193
00:10:26,790 --> 00:10:30,767
の全てを検査することができるようにします
変数は内に含まれます。

194
00:10:30,767 --> 00:10:32,850
何か他のものがあります
私たちは順番に行う必要があること

195
00:10:32,850 --> 00:10:36,910
私たちが望むことを認識することがGDBを取得します
プログラムの実行を一時停止します

196
00:10:36,910 --> 00:10:42,820
そしてちょうどそれを進行させません
通常、我々は、他の場合と同じように。

197
00:10:42,820 --> 00:10:45,530
>> 実行を一時停止するためには、
いくつかの特定の行で、

198
00:10:45,530 --> 00:10:47,830
私たちは何を作成する必要があります
ブレークポイントと呼ばれます。

199
00:10:47,830 --> 00:10:52,670
そして、ブレークポイントは、非常に簡単に作成されています
この中にあなたのマウスを取ることによって、IDEをCS50

200
00:10:52,670 --> 00:10:57,090
そして左に直接クリック
いくつかの特定の行番号の。

201
00:10:57,090 --> 00:10:59,920
私はそれを行うならば、赤い点
示しており、表示されます

202
00:10:59,920 --> 00:11:02,300
そのその行は現在のブレークポイントです。

203
00:11:02,300 --> 00:11:07,540
>> そして、私は、GDBを実行する次の時間、それを
そのブレークポイントで実行を停止します

204
00:11:07,540 --> 00:11:10,280
それは、コードのその行に到達したとき。

205
00:11:10,280 --> 00:11:12,230
さて、これは重要です
実現するもの

206
00:11:12,230 --> 00:11:16,140
それは必ずしもではないこと
ケースのコードのすべての行

207
00:11:16,140 --> 00:11:17,880
実際にアクセス可能です。

208
00:11:17,880 --> 00:11:23,780
私は関数を作成した場合
example--空隙f--ため、ここにアップ

209
00:11:23,780 --> 00:11:31,230
ちょうどこんにちはhere--印刷行を行います
私はこの関数を呼び出すことはありません場合は、world--

210
00:11:31,230 --> 00:11:34,770
その場合になります、
私はここにブレークポイントを設定した場合、

211
00:11:34,770 --> 00:11:36,220
関数が呼び出されることはありません。

212
00:11:36,220 --> 00:11:38,310
従って、この
特定のブレークポイント

213
00:11:38,310 --> 00:11:43,040
実際に一時停止することはありません
プログラムの実行。

214
00:11:43,040 --> 00:11:48,020
>> それでは、私が正しく作成することとしましょう
コー​​ドのいくつかの行にブレークポイント

215
00:11:48,020 --> 00:11:50,340
それが実際に実行されます。

216
00:11:50,340 --> 00:11:53,470
今、この場合、これは
main関数の最初の行。

217
00:11:53,470 --> 00:11:56,630
だから、それは確かにケースになります
それは、私が実行を開始するや否や、

218
00:11:56,630 --> 00:11:58,580
非常に最初の行に達することになります。

219
00:11:58,580 --> 00:12:00,230
GDBは、実行を一時停止します。

220
00:12:00,230 --> 00:12:04,100
そして、私のことができるようになります
デバッガと対話します。

221
00:12:04,100 --> 00:12:08,480
>> あなたは、複数行を設定することができます
ご希望の場合は、ブレークポイントを設定します。

222
00:12:08,480 --> 00:12:11,365
また、ラインアップを作成することができます
ここでは、コードのこのセグメントで

223
00:12:11,365 --> 00:12:12,490
それに達することはありません。

224
00:12:12,490 --> 00:12:14,744
そして、我々はまた、以下のいずれかを設定することができます。

225
00:12:14,744 --> 00:12:16,660
理由私たちは希望
我々はよこれをしたいです

226
00:12:16,660 --> 00:12:19,119
より少しに行きます
一瞬のディテール。

227
00:12:19,119 --> 00:12:21,660
だから今のところ、私はちょうど無効にしましょう
これらの追加のブレークポイント

228
00:12:21,660 --> 00:12:24,940
我々は何が起こるかを見ることができますように
私は1つの単一のブレークを持っている場合

229
00:12:24,940 --> 00:12:27,650
私のプログラム内のポイント。

230
00:12:27,650 --> 00:12:29,410
私が作ったいくつかの
このプログラムへの変更。

231
00:12:29,410 --> 00:12:30,750
だから私はそれを保存する必要があります。

232
00:12:30,750 --> 00:12:34,490
私ができるように私は、デバッグをクリックします
コンパイルを開始し、その後、

233
00:12:34,490 --> 00:12:36,880
デバッガの実行。

234
00:12:36,880 --> 00:12:40,632
>> 我々は、表示され、その瞬間、後
私たちは休憩として選択された行

235
00:12:40,632 --> 00:12:43,360
ポイントは黄色で強調表示されます。

236
00:12:43,360 --> 00:12:47,440
また、中にいることに気づくことができます
デバッグパネルの右上

237
00:12:47,440 --> 00:12:50,940
一時停止アイコンが変わったこと
少し再生アイコンに。

238
00:12:50,940 --> 00:12:54,710
これは私たちがポーズを有することを意味します
この特定の場合に実行、。

239
00:12:54,710 --> 00:12:57,840
そして、再生ボタンを打つことになります
私たちが実行を再開することができます

240
00:12:57,840 --> 00:13:00,000
その特定の時点で。

241
00:13:00,000 --> 00:13:03,240
>> 他のカップルがあることに注意してください
このデバッグパネルで使用可能なボタン、

242
00:13:03,240 --> 00:13:04,220
同様に。

243
00:13:04,220 --> 00:13:09,470
に私を可能にする、ステップオーバー
コー​​ドの1行を実行

244
00:13:09,470 --> 00:13:14,030
とにその行にステップオーバー
この場合の次の1、、、

245
00:13:14,030 --> 00:13:17,060
printfのことを意味します
ステートメントが実行されます。

246
00:13:17,060 --> 00:13:22,310
そして、それはその後、一時停止します
そうのようなライン13上での実行、。

247
00:13:22,310 --> 00:13:25,090
>> そして、ステップもあります
関数に、どの

248
00:13:25,090 --> 00:13:28,950
私は他を作成している場合に便利です
他の場所で、ソースコード内の関数。

249
00:13:28,950 --> 00:13:31,420
そして、私はにステップインしたいです
これらの関数ではなく、

250
00:13:31,420 --> 00:13:33,050
全体としてその機能を実行します。

251
00:13:33,050 --> 00:13:37,279
しかし、我々はステップでより多くのを見てみましょう
一瞬で関数に。

252
00:13:37,279 --> 00:13:40,320
今ではいくつかの他の事に気づきます
実際にこのデバッグパネル内に存在します。

253
00:13:40,320 --> 00:13:44,110
>> 私たちは、このパネルが呼び出され
私たちを示し、コールスタック、

254
00:13:44,110 --> 00:13:45,300
まさに、私たちはどこにいます。

255
00:13:45,300 --> 00:13:48,550
ここでは、内部にあります
主な機能の。

256
00:13:48,550 --> 00:13:50,880
私たちのスクリプトがcount.cと呼ばれています。

257
00:13:50,880 --> 00:13:53,820
そして、私たちは上のことが起こります
行13、列1、どの

258
00:13:53,820 --> 00:13:58,950
されている正確にどのようなハイライト領域
ソースコードのだけでなく、を示しています。

259
00:13:58,950 --> 00:14:02,435
>> 今これがまた表示されていることに気付きます
ローカル変数セクションの下

260
00:14:02,435 --> 00:14:06,710
その変数のすべて
この関数内に存在します。

261
00:14:06,710 --> 00:14:08,930
それは注意することが重要です
変数のすべてのこと

262
00:14:08,930 --> 00:14:12,580
このローカル変数に表示されます
関数内のセクション、

263
00:14:12,580 --> 00:14:14,380
それらが定義されていても前に。

264
00:14:14,380 --> 00:14:19,160
私たちは、変数を持っていることをここで見ることができます
NUMと呼ばれ、0のデフォルト値が、

265
00:14:19,160 --> 00:14:21,280
それはint型です。

266
00:14:21,280 --> 00:14:24,110
>> 今、私たちが実際に初期化する前に
これらの変数の全て、

267
00:14:24,110 --> 00:14:26,685
私たちは必ずしもじゃありません
0の値を参照することが保証。

268
00:14:26,685 --> 00:14:29,200
そして、他の実行に応じて、
あなたが実行したこと

269
00:14:29,200 --> 00:14:32,020
そしてあなたの記憶時の状態
あなたが実際にこのプログラムを実行し、

270
00:14:32,020 --> 00:14:34,605
あなたがいることを見つけるかもしれません
0の値が表示されません

271
00:14:34,605 --> 00:14:36,550
そして、その代わりに、他のいくつかのクレイジーな数字。

272
00:14:36,550 --> 00:14:38,390
>> しかし、心配しないでください。

273
00:14:38,390 --> 00:14:44,610
それはまで関連することはないだろう
あなたが実際に値を初期化します。

274
00:14:44,610 --> 00:14:49,630
今、この場合には、我々はそれを見ることができます
私はいくつかの出力を行いました。

275
00:14:49,630 --> 00:14:52,131
そして、私は、今、実行を一時停止しています。

276
00:14:52,131 --> 00:14:53,880
しかし、この場合には、どのような
私は本当にやりたいです

277
00:14:53,880 --> 00:14:58,060
今、この行をステップオーバーすることです
コー​​ドのように、私は実際にできること

278
00:14:58,060 --> 00:15:04,390
そのint型のためにユーザに問い合わせること
我々は我々のプログラムで使用します。

279
00:15:04,390 --> 00:15:07,060
>> 今、この場合には、時
私は、通知をステップオーバーヒット

280
00:15:07,060 --> 00:15:11,940
それはむしろ一時停止または再開
ボタンを押すと、この一時停止ボタンに変更されました

281
00:15:11,940 --> 00:15:14,022
このコードが実際に実行されているので。

282
00:15:14,022 --> 00:15:15,730
何が起こっている
今それがあるということです

283
00:15:15,730 --> 00:15:21,630
入力に私たちのためにいくつかの情報を待っています
私たちは、出力テキストで見ることができるように

284
00:15:21,630 --> 00:15:23,600
一番下にあります。

285
00:15:23,600 --> 00:15:25,787
>> だから、今、これは
実際に一時停止していません、

286
00:15:25,787 --> 00:15:28,620
それは、一種の、表示されるにもかかわらず、
何が起こっていないためであると。

287
00:15:28,620 --> 00:15:32,360
しかし、それはちょうどので、その中でも起こり
ライン13上の私の特定の場合、

288
00:15:32,360 --> 00:15:34,210
私は、ユーザーの入力を待っています。

289
00:15:34,210 --> 00:15:39,130
だからGDBは検査することができません
それのようなプログラムが実行されています。

290
00:15:39,130 --> 00:15:43,370
>> 私はいくつかを入力してください今すぐ次回
、私はその番号5を入力しますので、input--

291
00:15:43,370 --> 00:15:46,140
我々は見てきたように
ヒットリターンをpast--、我々

292
00:15:46,140 --> 00:15:51,430
予告、その直後に、GDBの一時停止
そして、再び、次の行を強調表示します。

293
00:15:51,430 --> 00:15:55,320
しかしとして、今ことに気づきます
私たちが値を入力した結果、

294
00:15:55,320 --> 00:15:58,930
我々は内部のその値を更新しました
これは私たちのローカル変数の

295
00:15:58,930 --> 00:16:05,560
正確に知っていることは非常に便利です
その数は、メモリに何でした。

296
00:16:05,560 --> 00:16:10,650
>> 今私は、このプログラムを継続できるようにすることができます
その実行が終了するまで演奏

297
00:16:10,650 --> 00:16:12,570
再開]を押すことで。

298
00:16:12,570 --> 00:16:16,410
我々は非常に迅速にそれを見ることができます
プログラムの仕上げは実行ん

299
00:16:16,410 --> 00:16:19,790
私たちと同じ出力を持ちます
以前と、デバッガが閉じ、

300
00:16:19,790 --> 00:16:23,170
そして今、このプログラム
完全に停止しました。

301
00:16:23,170 --> 00:16:25,320
>> 私だけのためにあることを示します
何を見ての目的

302
00:16:25,320 --> 00:16:27,280
私たちが実際に再開を打ったときに発生します。

303
00:16:27,280 --> 00:16:30,640
しかし、我々は実際に行っています
このプログラムに戻りたいです

304
00:16:30,640 --> 00:16:33,820
我々は、デバッグしようとすることができるように
正確に何が起こっているのか。

305
00:16:33,820 --> 00:16:37,980
私は、デバッガを使用していることを今、私はかもしれません
これらのデバッグのprintf文を必要としません。

306
00:16:37,980 --> 00:16:43,860
>> いただきますよう、私はそれらを削除することができ
今ちょうど私たちの単純なコードに戻ります

307
00:16:43,860 --> 00:16:45,950
私たちは一瞬前に持っていました。

308
00:16:45,950 --> 00:16:48,790
今、私は保存するとき
プログラムし、それを実行し、

309
00:16:48,790 --> 00:16:53,700
それは、再び、その初期に移動します
私は11行目に与えた点を破ります。

310
00:16:53,700 --> 00:16:57,700
そして、私は検査することができるでしょう
私の変数は私がやりたいよう。

311
00:16:57,700 --> 00:17:00,695
>> それはちょうどので、このことが起こります
部分は、非常に興味深いものではありません

312
00:17:00,695 --> 00:17:04,364
そして私は、私はつもりだことを知っています
この文を印刷します。

313
00:17:04,364 --> 00:17:05,280
番号を入力してください。

314
00:17:05,280 --> 00:17:08,099
そして、私はつもりだことを知っています
その整数をユーザーに依頼します。

315
00:17:08,099 --> 00:17:13,329
だから多分、私は実際に私を移動したいです
少しさらに下のポイントを破ります。

316
00:17:13,329 --> 00:17:16,710
>> あなたは、ブレークポイントを削除することができます
直接、もう一度、クリックして

317
00:17:16,710 --> 00:17:18,460
その行番号の左に。

318
00:17:18,460 --> 00:17:22,200
赤い点が表示されなくなります。すなわち、示します
そのブレークポイントがなくなっていること。

319
00:17:22,200 --> 00:17:24,780
今、この場合には、
実行が一時停止されています。

320
00:17:24,780 --> 00:17:27,770
そしてそれは実際に起こっていません
その特定のインスタンスで再開。

321
00:17:27,770 --> 00:17:30,210
しかし、私は休憩を設定することができます
少し後にポイントします。

322
00:17:30,210 --> 00:17:33,880
>> そして、私は今、私を再開したとき
コー​​ド、それが再開し、教えてくれます

323
00:17:33,880 --> 00:17:36,190
そのブレークポイントのポイント。

324
00:17:36,190 --> 00:17:37,374
繰り返しますが、私は再開を打ちます。

325
00:17:37,374 --> 00:17:39,040
何が起こっているように見えるしていません。

326
00:17:39,040 --> 00:17:41,450
しかし、それは私のためです
コー​​ドが入力を待っています。

327
00:17:41,450 --> 00:17:47,900
私は、数5を入力しEnterキーを押すと、なります
これで次のブレークポイントがヒットします。

328
00:17:47,900 --> 00:17:50,570
>> 今、この場合には、この
コー​​ドの行は、

329
00:17:50,570 --> 00:17:53,820
それは、前に、私たちは知っていました
バギーであることが起こりました。

330
00:17:53,820 --> 00:17:57,590
それでは、何が起こるかを評価しましょう
時間内に、この特定の時点で。

331
00:17:57,590 --> 00:18:02,620
ラインが​​強調表示された場合、この
行がまだ実行されていません。

332
00:18:02,620 --> 00:18:06,490
したがって、この場合には、我々が見ることができます
私は数を持っていることをします

333
00:18:06,490 --> 00:18:11,610
私はと呼ばれる整数を持っています
値5を有しNUM。

334
00:18:11,610 --> 00:18:15,090
そして、私は実行するつもりです
その番号にいくつかの数学。

335
00:18:15,090 --> 00:18:20,130
>> 私はそれをステップオーバーした場合、我々はできます
numのその値に気付きます

336
00:18:20,130 --> 00:18:23,780
に応じて変更されています
私たちが実際にやった算術。

337
00:18:23,780 --> 00:18:26,810
そして今、我々はしていること
このforループの内側

338
00:18:26,810 --> 00:18:29,090
または今そのループのための
自身が強調表示され、

339
00:18:29,090 --> 00:18:32,450
我々は新しいを持っていることを確認
変数iと呼ばれること

340
00:18:32,450 --> 00:18:35,370
ループのためにその中で使用されようとしています。

341
00:18:35,370 --> 00:18:38,230
>> 今では私が前に覚えています
時には、あなたがしていることに言及

342
00:18:38,230 --> 00:18:43,470
狂気のいくつかの種類を見に行きます
その番号の前にデフォルトとして数

343
00:18:43,470 --> 00:18:45,530
またはその変数があります
実際に初期化されました。

344
00:18:45,530 --> 00:18:49,040
私たちは、正確にそれを見ることができます
ここでは、この変数に

345
00:18:49,040 --> 00:18:51,345
なかった、Iと呼ばれます
まだ初期化されて

346
00:18:51,345 --> 00:18:53,560
ハイライトの時。

347
00:18:53,560 --> 00:18:57,070
しかし、我々は、それはいくつかの番号を持っていることがわかります
私たちは実際には期待していないこと。

348
00:18:57,070 --> 00:18:57,620
>> それで大丈夫です。

349
00:18:57,620 --> 00:18:59,661
ご心配なく
私たちは実際には持っていないので、

350
00:18:59,661 --> 00:19:04,970
私までその数を初期化
このラインと値をステップオーバー

351
00:19:04,970 --> 00:19:08,560
私は、値を1に初期化されています。

352
00:19:08,560 --> 00:19:11,400
だから、実際にだことを確認します
場合は、のステップオーバーしましょう​​。

353
00:19:11,400 --> 00:19:14,420
我々は今それを見ることができます
行が実行されています。

354
00:19:14,420 --> 00:19:17,000
そして、我々は今、ハイライト表示さ​​れています
このprintfのライン。

355
00:19:17,000 --> 00:19:22,230
>> そして、我々は今、どのように私たちの価値観を見ることができます
iと3は、時間の経過とともに変化しています。

356
00:19:22,230 --> 00:19:26,450
これは、実際には、行うことは非常に便利です、
繰り返し行をステップオーバーすることです。

357
00:19:26,450 --> 00:19:30,480
そして、あなたは実際に何を見つけることができます
あなたのforループの内部で起こります

358
00:19:30,480 --> 00:19:33,660
そして、何が起こるに
そのループの内部変数

359
00:19:33,660 --> 00:19:39,200
そのプログラムの実行など
一度に一つの段階で起こります。

360
00:19:39,200 --> 00:19:41,110
>> 今、この時点で、私
ちょうど十分なステップオーバー

361
00:19:41,110 --> 00:19:44,210
私は今、私のプログラムの終了時だということ。

362
00:19:44,210 --> 00:19:46,980
私はそれをステップオーバーした場合、それはなります
実際に実行を停止

363
00:19:46,980 --> 00:19:48,860
我々は、過去に見てきたように。

364
00:19:48,860 --> 00:19:52,110
そう、私は再び、これを再起動してみましょう
私が何かを指摘することができ、

365
00:19:52,110 --> 00:19:53,320
同様に。

366
00:19:53,320 --> 00:19:55,350
>> この場合には、それは
今再び、私を求めて、

367
00:19:55,350 --> 00:19:57,100
数の、どの
私は、もう一度、入力します。

368
00:19:57,100 --> 00:20:00,300
しかし、この時間は、私がに入力するつもりです
forループのように、より多く

369
00:20:00,300 --> 00:20:02,540
複数回繰り返されます。

370
00:20:02,540 --> 00:20:06,090
この場合、私は行きますよ
11の値を入力します。

371
00:20:06,090 --> 00:20:08,390
>> ここでもう一度、私は設定したいので、
15行目にブレークポイント、

372
00:20:08,390 --> 00:20:10,490
それは、その行をハイライトになるだろう。

373
00:20:10,490 --> 00:20:12,980
我々は、我々のことを見ることができます
数11は正しくあり

374
00:20:12,980 --> 00:20:15,560
私たちのローカル変数で表します。

375
00:20:15,560 --> 00:20:22,460
我々は今、その上でできるステッピング
私の私たちの価値に何が起こるか見て

376
00:20:22,460 --> 00:20:25,680
我々はループのために、この内部に進むにつれて。

377
00:20:25,680 --> 00:20:31,960
これはすべての時間、私たちをインクリメントします
そのループのトップに到達。

378
00:20:31,960 --> 00:20:35,110
>> ものの一つ今それかもしれません
実行中に行うことが有用です

379
00:20:35,110 --> 00:20:40,490
このプログラムの実際に私のためにあります
確認するために、変数の途中を変更

380
00:20:40,490 --> 00:20:42,450
何が私のプログラムに発生します。

381
00:20:42,450 --> 00:20:46,540
この場合、私は実際にすることができます
double値をクリックします。

382
00:20:46,540 --> 00:20:48,040
それがテキストフ​​ィールドになっていることに注意してください。

383
00:20:48,040 --> 00:20:50,280
>> 今私は別の入力することができます
完全値

384
00:20:50,280 --> 00:20:55,700
私のプログラムがどのように動作するか確認してください
私はその変数を変更したとき。

385
00:20:55,700 --> 00:20:59,560
今、この場合には、変数
私は今値10が含まれています。

386
00:20:59,560 --> 00:21:02,810
しかし、プログラムがまだあります
実行中に一時停止しました。

387
00:21:02,810 --> 00:21:07,610
私はステップオーバーすると、私はそれを参照してください。
私は10として入力された値I、

388
00:21:07,610 --> 00:21:12,170
NUMの値より大きくない場合、
これはすぐにループの原因

389
00:21:12,170 --> 00:21:14,240
実行を停止します。

390
00:21:14,240 --> 00:21:16,210
>> 今では唯一ではありません
理由は、あなたが希望

391
00:21:16,210 --> 00:21:19,450
場所に変数を変更したいです。

392
00:21:19,450 --> 00:21:22,210
あなたが実際にお勧めします
ので、それを修正しようとします

393
00:21:22,210 --> 00:21:24,590
あなたが続けることができること
ループの実行

394
00:21:24,590 --> 00:21:27,370
またはそのように変更することができます
その前にいくつかの値

395
00:21:27,370 --> 00:21:32,630
演算のいくつかの特定のセットに到達します
あなたが実行しようとしていること。

396
00:21:32,630 --> 00:21:36,210
>> だから今、私たちが実際に変更することを
プログラムとして、iの値は、実行していました

397
00:21:36,210 --> 00:21:39,540
それが終了するためのループを引き起こし
途中で私は、突然、理由

398
00:21:39,540 --> 00:21:42,770
値よりも大きくなるように起こりました
NUMの、そのそのループのための意味

399
00:21:42,770 --> 00:21:45,410
もはや実行する必要はありません。

400
00:21:45,410 --> 00:21:48,780
さらに、それがあることを起こっ
我々は、iの値を変更した場合

401
00:21:48,780 --> 00:21:53,270
17行が強調表示されたときに、
時点でした

402
00:21:53,270 --> 00:21:56,280
ループ実行のためにその
実際には評価されていました。

403
00:21:56,280 --> 00:22:00,210
>> 私は、の値を変更した場合
私は別の行に、19を言います

404
00:22:00,210 --> 00:22:03,360
我々は異なる見ているだろう
動作ライン19になるため

405
00:22:03,360 --> 00:22:08,310
ループの前に実行しました
条件が再評価されました。

406
00:22:08,310 --> 00:22:11,900
今、この時点で、私は、再び、
このプログラムの終わりに。

407
00:22:11,900 --> 00:22:15,707
そして、私はこれがに進むできるようにすることができます
私のプログラムが自然に終了することができます。

408
00:22:15,707 --> 00:22:18,290
しかし、物事のカップルがあります
奪うために重要であること

409
00:22:18,290 --> 00:22:19,960
この特定の議論から。

410
00:22:19,960 --> 00:22:22,490
あなたが評価する必要があります
独自の前提条件

411
00:22:22,490 --> 00:22:24,710
方法についてのコードは動作しなければなりません。

412
00:22:24,710 --> 00:22:28,220
あなたには、いくつかの作品だと思いますいつでも
あなたが知っているコードが動作するように起こるの、

413
00:22:28,220 --> 00:22:30,940
それは行くために赤い旗であるかもしれません
背中と評価し、確認してください

414
00:22:30,940 --> 00:22:33,470
あなたの仮定のこと
どのようにコードが動作しています

415
00:22:33,470 --> 00:22:38,290
それがどのように実際には真であります
ソースコードで表されます。

416
00:22:38,290 --> 00:22:41,300
>> しかし、さらにポイントにしました、
私たちは、デバッガを使用しているときに、

417
00:22:41,300 --> 00:22:43,920
あなたはにブレークポイントを置くことができます
コー​​ドの異なるライン、

418
00:22:43,920 --> 00:22:48,110
これにデバッガを引き起こします
これらの行のそれぞれで実行を一時停止

419
00:22:48,110 --> 00:22:52,210
あなたが評価できるように
でもメモリや場所に変更します。

420
00:22:52,210 --> 00:22:55,630
そして再び、あなたができることを覚えておいてください
あなたように、複数のブレークポイントを作成します

421
00:22:55,630 --> 00:23:00,390
また、実行を再開することができ、スキップ
コー​​ドの大部分の上、

422
00:23:00,390 --> 00:23:04,790
そして、それは自動的に一時停止します
次のブレークポイントで。

423
00:23:04,790 --> 00:23:07,760
>> 実際にはより高度なあります
デバッガの機能だけでなく。

424
00:23:07,760 --> 00:23:10,170
しかし、私たちはあなたを参照する必要があります
いくつかの後続の動画へ

425
00:23:10,170 --> 00:23:14,090
実際にどのように離れていじめるために
これらの特定の機能を使用しています。

426
00:23:14,090 --> 00:23:15,990
今のところ、ありがとうございました
見ための非常に。

427
00:23:15,990 --> 00:23:18,080
幸運のデバッグ。