1
00:00:00,000 --> 00:00:00,487

2
00:00:00,487 --> 00:00:11,210
>> [音楽再生]

3
00:00:11,210 --> 00:00:12,100
>> ROB BODEN：すべての権利。

4
00:00:12,100 --> 00:00:15,620
ビデオの最初のそのように、まず最初に、
おなじみの面から。

5
00:00:15,620 --> 00:00:22,080

6
00:00:22,080 --> 00:00:22,560
>> [ビデオ再生]

7
00:00:22,560 --> 00:00:23,370
>>  - すべての権利。

8
00:00:23,370 --> 00:00:27,150
これはCS50であり、これは
週3の始まり。

9
00:00:27,150 --> 00:00:29,980
私はあなたと一緒に存在することができませんでした申し訳ありません
今日が、私が紹介させて

10
00:00:29,980 --> 00:00:32,880
CS50自身のロブ·ボーデン。

11
00:00:32,880 --> 00:00:33,872
>> [ENDビデオ再生]

12
00:00:33,872 --> 00:00:39,340
>> [拍手と歓声]

13
00:00:39,340 --> 00:00:41,277
>> ROB BODEN：フィルモグラフィー中
そのビデオが幻想的です。

14
00:00:41,277 --> 00:00:47,280

15
00:00:47,280 --> 00:00:47,770
わかりました。

16
00:00:47,770 --> 00:00:50,960
したがって、最初、別のランチがあります。

17
00:00:50,960 --> 00:00:52,330
それが午前1時15分で明日の。

18
00:00:52,330 --> 00:00:54,480
この金曜日はランチにありません。

19
00:00:54,480 --> 00:00:55,810
それはQuoraのである。

20
00:00:55,810 --> 00:01:00,190
とトミーはまだここにいないのですが、の1
元ヘッドのCFがある人、

21
00:01:00,190 --> 00:01:01,530
トミーウィリアム。

22
00:01:01,530 --> 00:01:02,730
そこで彼は、楽しい人だ。

23
00:01:02,730 --> 00:01:04,819
あなたが来るはずです。

24
00:01:04,819 --> 00:01:05,900
>> わかりました。

25
00:01:05,900 --> 00:01:11,360
そう、先週、私たちは離れて壊し始めた
文字列が本当にあるかについて。

26
00:01:11,360 --> 00:01:14,830
我々は初めから知っていた
それは文字の列です。

27
00:01:14,830 --> 00:01:18,130
しかし先週、我々は事実を掘り下げ
実際、一連のものであること

28
00:01:18,130 --> 00:01:22,110
文字は、まあ、我々は今持っている
文字の配列。

29
00:01:22,110 --> 00:01:26,450
そして、我々は、それは、配列、文​​字列のことを知っている
文字の、最後の最後で、

30
00:01:26,450 --> 00:01:30,920
私たちはこの特別なNULLバイトを持って、この
バックスラッシュ0、すなわち端を示す

31
00:01:30,920 --> 00:01:32,230
文字列。

32
00:01:32,230 --> 00:01:36,970
>> だから文字列はの配列です
文字が、我々はより多くを持つことができます

33
00:01:36,970 --> 00:01:39,530
文字だけの配列、
我々はすべての配列を持つことができます

34
00:01:39,530 --> 00:01:40,890
私たちが望むものの種類。

35
00:01:40,890 --> 00:01:51,570
だから、あなたは先週から思い出して、
ダビデが導入された中世のプログラム

36
00:01:51,570 --> 00:01:53,560
本当にすぐ。

37
00:01:53,560 --> 00:01:57,010
私たちがやろうとしているので、最初のものです
整数をユーザーに尋ねる

38
00:01:57,010 --> 00:01:58,800
部屋の中の人々の数。

39
00:01:58,800 --> 00:02:01,260
我々はその整数を取得したら、
私たちは、配列を宣言している。

40
00:02:01,260 --> 00:02:02,890
このブラケットの構文に注目してください。

41
00:02:02,890 --> 00:02:04,540
あなたがそれに慣れるつもりだ。

42
00:02:04,540 --> 00:02:09,430
>> だから我々は、整数の配列を宣言している
年齢と呼ばれ、Nがある

43
00:02:09,430 --> 00:02:12,080
この配列内の整数。

44
00:02:12,080 --> 00:02:16,480
右ここので、このパターンは、この4 INT
私は、iがn未満であり、0に等しい私のプラス

45
00:02:16,480 --> 00:02:20,580
プラス、それはまた、パターンになるだろう
あなたは非常に慣れていること。

46
00:02:20,580 --> 00:02:24,000
それはかなりあなたがしている方法ですので、
いつもの配列を反復処理する予定。

47
00:02:24,000 --> 00:02:26,330
そう、nがあることを覚えている
私たちの配列の長さ。

48
00:02:26,330 --> 00:02:32,120
だからここでは、繰り返し求めている
部屋の中の人の私の年齢。

49
00:02:32,120 --> 00:02:36,640
>> この後、我々がダウンし、何のために
任意の理由で、我々

50
00:02:36,640 --> 00:02:40,220
彼らが行っているか、古いプリントアウト
今から年になる。

51
00:02:40,220 --> 00:02:49,980
そのプログラムを実行している、してみましょう
年齢をする、ドットスラッシュ年代。

52
00:02:49,980 --> 00:02:53,010
だから、部屋の中で人々の数、
それでは3があるとしましょう​​。

53
00:02:53,010 --> 00:02:59,880
と言って、最初の人は13で、
次の26で、最後は30です。

54
00:02:59,880 --> 00:03:05,080
だから、それは、それらの3を反復します
人々は、14から27、および31を印刷する。

55
00:03:05,080 --> 00:03:16,060
>> だから覚えている私たちは、宣言するとき
大きさnの配列で、その内のインデックス

56
00:03:16,060 --> 00:03:19,950
配列、配列は値を持ち、
インデックス0、1、2、すべての方法

57
00:03:19,950 --> 00:03:21,680
までのNマイナス1。

58
00:03:21,680 --> 00:03:26,255
だから我々が言ったとき3人があった
部屋の中、私たちはここに入れ

59
00:03:26,255 --> 00:03:29,850
この貫通最初の反復
ループは、私が0になるだろう。

60
00:03:29,850 --> 00:03:31,650
インデックス0でそう。

61
00:03:31,650 --> 00:03:34,540
我々は最初に割り当てている
ユーザーが入力した年齢。

62
00:03:34,540 --> 00:03:38,870
その後、次のいずれかで、我々は、入力している
第2のnユーザが入り、中

63
00:03:38,870 --> 00:03:40,580
2、最後のnに隣接しています。

64
00:03:40,580 --> 00:03:44,200
>> そう気づくそのサイズの配列
3は何も持っていません

65
00:03:44,200 --> 00:03:46,040
インデックス3にある。

66
00:03:46,040 --> 00:03:49,036
これは有効ではありません。

67
00:03:49,036 --> 00:03:50,250
わかりました。

68
00:03:50,250 --> 00:03:55,136
だから、ここに戻って行く。

69
00:03:55,136 --> 00:03:57,650

70
00:03:57,650 --> 00:04:01,590
だから今我々は、配列を扱ったので、
我々はいくつかの知識を持っている。

71
00:04:01,590 --> 00:04:03,780
今、私たちは、コマンドに移動するつもりだ
であることを行っているライン引数、

72
00:04:03,780 --> 00:04:05,890
この問題セットにかなり関係する。

73
00:04:05,890 --> 00:04:09,670
>> だから今までは、いつでもしました
私たちは、あなたのmain関数を宣言しました

74
00:04:09,670 --> 00:04:11,230
int型の主なボイドが言った。

75
00:04:11,230 --> 00:04:14,070
ちょうどそれを意味しますので、ボイド
我々はすべてに合格していない

76
00:04:14,070 --> 00:04:16,440
この関数の引数。

77
00:04:16,440 --> 00:04:19,190
今、私たちはその主を見ることになるだろう
いくつかの引数を取ることができます。

78
00:04:19,190 --> 00:04:22,470
ここでは、int型のargcそれらを呼び出す
と文字列ARGVブラケット。

79
00:04:22,470 --> 00:04:26,930
ブラケットは、もう一度、示す
我々は、配列を扱っていること。

80
00:04:26,930 --> 00:04:31,850
だからここに、文字列のargvブラケットは、私たちがしている
文字列の配列を扱う。

81
00:04:31,850 --> 00:04:35,360
そうARGC、それが示すことになるだろう
我々はした引数の数

82
00:04:35,360 --> 00:04:37,580
このプログラムに渡さ。

83
00:04:37,580 --> 00:04:46,050
そして、それが何を意味するのかを確認するには、
それでは、これを閉じてみましょう。

84
00:04:46,050 --> 00:04:46,490
>> [OK]をクリックします。

85
00:04:46,490 --> 00:04:50,790
だから今まで、我々は、すべて実行した
ドットスラッシュ年代のようなプログラム。

86
00:04:50,790 --> 00:04:55,250
また、コマンドラインで、過去のことができます
引数を渡す、このように、用語、コマンド

87
00:04:55,250 --> 00:04:56,550
ライン引数。

88
00:04:56,550 --> 00:04:59,760
したがって、最初の引数、ハローワールド。

89
00:04:59,760 --> 00:05:03,350
だからここに、ARGCは3になります。

90
00:05:03,350 --> 00:05:07,720
これは、引数の数だ
コマンドラインで。

91
00:05:07,720 --> 00:05:12,840
ARGCは、常に少なくとも1であることから、ドット
年齢を大幅に削減する、それ自体の1としてカウント

92
00:05:12,840 --> 00:05:14,490
コマンドライン引数。

93
00:05:14,490 --> 00:05:17,010
>> その後こんにちは最初のものです。

94
00:05:17,010 --> 00:05:20,460
ドットスラッシュ年齢はその後、ゼロ番目の場合
こんにちは初めてであり、世界がある

95
00:05:20,460 --> 00:05:22,830
番目のコマンドライン引数。

96
00:05:22,830 --> 00:05:29,490
だから、文字列argvは、我々は見ることになるだろう、
文字列は、ドットスラッシュが含まれています

97
00:05:29,490 --> 00:05:33,830
年齢、こんにちは、そして世界。

98
00:05:33,830 --> 00:05:38,945
そして、ダビデの要求によって、私たちはなるだろう
それを導入したビデオを再生します。

99
00:05:38,945 --> 00:05:42,486

100
00:05:42,486 --> 00:05:43,890
>> [ビデオ再生]

101
00:05:43,890 --> 00:05:46,240
>> 我々はしたプログラムで今までアップ
書かれた、私たちは宣言しました

102
00:05:46,240 --> 00:05:48,500
メインとしてint型の主無効。

103
00:05:48,500 --> 00:05:51,170
そしてすべてのこの時間は、その空隙があります
単純に指定され、その

104
00:05:51,170 --> 00:05:54,430
プログラムは実行されません
コマンドライン引数。

105
00:05:54,430 --> 00:05:57,750
ユーザが実行換言すれば、
プログラム、彼または彼女は、コマンドを提供することができます

106
00:05:57,750 --> 00:06:01,710
追記によるライン引数
単語やフレーズの後に、プログラムの

107
00:06:01,710 --> 00:06:03,000
プロンプトで名前を付けます。

108
00:06:03,000 --> 00:06:06,550
>> これを行うとさて、あなたはあなたのプログラムにしたい
コマンドライン引数、1またはを取る

109
00:06:06,550 --> 00:06:10,540
より多くのそのような言葉は、我々は交換する必要があります
引数のカップルと無効になる。

110
00:06:10,540 --> 00:06:12,200
それでは、それをしてみましょう。

111
00:06:12,200 --> 00:06:15,750
CS50.h.を含める

112
00:06:15,750 --> 00:06:19,360
標準io.h.を含める

113
00:06:19,360 --> 00:06:20,760
メインint型。

114
00:06:20,760 --> 00:06:26,330
そして今、その代わりにボイドの、私はするつもりだ
ARGCと呼ばれるint型、および指定

115
00:06:26,330 --> 00:06:28,780
ARGVと呼ばれる文字列の配列。

116
00:06:28,780 --> 00:06:31,820
今、argcとargvはある
単に規則。

117
00:06:31,820 --> 00:06:34,000
>> 私たちは、これらの引数と呼ばれるかもしれない
私たちが望むほとんど何でも。

118
00:06:34,000 --> 00:06:37,630
しかし、重要なのはARGCがあるということです
int型定義により、それは、なぜなら

119
00:06:37,630 --> 00:06:41,360
引数の数が含まれているとして、
合計の単語数、その

120
00:06:41,360 --> 00:06:43,380
ユーザーは自分のプロンプトで入力しています。

121
00:06:43,380 --> 00:06:47,910
ARGV、一方、引数ベクトルであり、
実際に格納し、配列になるだろう

122
00:06:47,910 --> 00:06:52,020
ユーザーが持っているすべての単語
彼または彼女のプロンプトで入力。

123
00:06:52,020 --> 00:06:54,500
>> それでは何かを進みましょう
これらのうちの1つまたは複数と

124
00:06:54,500 --> 00:06:55,660
コマンドライン引数。

125
00:06:55,660 --> 00:07:00,070
特に、のは先に行くと印刷しましょう
どのような単語のユーザータイプ

126
00:07:00,070 --> 00:07:03,960
プログラム名の後に
プロンプトで。

127
00:07:03,960 --> 00:07:04,730
開いたブラケット。

128
00:07:04,730 --> 00:07:06,240
閉じ括弧。

129
00:07:06,240 --> 00:07:10,510
printfのパーセントのバックスラッシュとコンマ。

130
00:07:10,510 --> 00:07:14,550
そして今、私は、printfどの値を指示する必要があります
そのプレースホルダにプラグインする。

131
00:07:14,550 --> 00:07:18,600
私は、ユーザーが持っている最初の単語をしたい
プログラム名の後に入力した、

132
00:07:18,600 --> 00:07:23,130
と私は指定するつもりだ
ARGVブラケット1、近い

133
00:07:23,130 --> 00:07:24,830
括弧、セミコロン。

134
00:07:24,830 --> 00:07:27,290
>> 今、なぜブラケット1としないブラケット0？

135
00:07:27,290 --> 00:07:30,990
まあ、それは自動的に保存され、判明した
ARGV 0であることを行っている

136
00:07:30,990 --> 00:07:32,620
プログラムの実際の名前。

137
00:07:32,620 --> 00:07:36,180
ユーザーがその最初の単語はそう
プログラムの名前がされた後に、バイ

138
00:07:36,180 --> 00:07:38,990
条約になるだろう
ARGV 1に格納されている。

139
00:07:38,990 --> 00:07:42,380
それではコンパイルしてみようと
このプログラムを実行する。

140
00:07:42,380 --> 00:07:47,780
>> ARGV 0、ドットスラッシュARGV 0を作成します。

141
00:07:47,780 --> 00:07:50,520
そして今、ハローのような言葉。

142
00:07:50,520 --> 00:07:51,670
入力してください。

143
00:07:51,670 --> 00:07:53,520
そしてそこに、我々はこんにちは、それを持っている。

144
00:07:53,520 --> 00:07:55,750
>> [ENDビデオ再生]

145
00:07:55,750 --> 00:07:57,000
>> ROB BODEN：すべての権利。

146
00:07:57,000 --> 00:07:59,380

147
00:07:59,380 --> 00:08:01,230
それを閉じます。

148
00:08:01,230 --> 00:08:16,730
だからそのプログラムを見てみ
私たちはただ単に、まあ、私たちに導入

149
00:08:16,730 --> 00:08:24,710
我々は0はargv印刷する場合、今、作る。表示
それは、ARGV 0、ドットスラッシュARGV 0ものです。

150
00:08:24,710 --> 00:08:30,440
だから、期待どおりに、プリントアウトだ
ARGV 0であるため、プログラムの名前

151
00:08:30,440 --> 00:08:32,970
常にあることを行って
プログラムの名前。

152
00:08:32,970 --> 00:08:35,640
しかし、ここでは何かAをやらせる
もっと面白いのビット。

153
00:08:35,640 --> 00:08:42,080
>> だから、問題はセットでは、だろう
この機能はatoiに導入。

154
00:08:42,080 --> 00:08:44,440
だから我々はのためatoi関数をどのように使うのですか？

155
00:08:44,440 --> 00:08:48,550
つまり、変換するために起こっている
整数に文字列。

156
00:08:48,550 --> 00:08:53,280
だから私は、文字列を渡すと、1 2 3、
ATOIする、それはそれを変換します

157
00:08:53,280 --> 00:08:56,910
整数、1〜2〜3。

158
00:08:56,910 --> 00:09:01,480
だから我々は、最初に変換しようとしている
整数へのコマンドライン引数、

159
00:09:01,480 --> 00:09:05,690
そして、ちょうどその整数を印刷します。

160
00:09:05,690 --> 00:09:09,680
>> そこで、基本的に、我々はちょっとね
ただ、のgetInt再実装

161
00:09:09,680 --> 00:09:12,350
整数は、コマンドで入力されている
プログラム内の行の代わりに、

162
00:09:12,350 --> 00:09:14,560
対話的に。

163
00:09:14,560 --> 00:09:23,170
それでは、ARGV 0を作る、のがしてみましょう
ここでのこと、それを閉じます。

164
00:09:23,170 --> 00:09:27,670
そうARGV 0を実行している、との、入力してみましょう
整数、1 2 3 4 1 2。

165
00:09:27,670 --> 00:09:30,840
だから、1の整数を印刷します
2 3 4 1 2。

166
00:09:30,840 --> 00:09:35,500
それをATOIするためにいくつかの微妙な点があります
それは何も気に停止されます

167
00:09:35,500 --> 00:09:39,040
有効な数値文字を超えて、
それは問題ではありません。

168
00:09:39,040 --> 00:09:42,870
>> だから、何が起こるかだと思いますか
私はこれを行う場合はどうなりますか？

169
00:09:42,870 --> 00:09:45,520

170
00:09:45,520 --> 00:09:47,050
セグメンテーションフォールト。

171
00:09:47,050 --> 00:09:50,410
だから、これはなぜですか？

172
00:09:50,410 --> 00:09:56,060
あなたは私たちのプログラムを振り返ってみると、我々はしている
ARGV 1、最初の引数に変換する

173
00:09:56,060 --> 00:09:59,610
プログラム名の後、整数に。

174
00:09:59,610 --> 00:10:03,350
しかし、渡された引数はありません
プログラム名の後。

175
00:10:03,350 --> 00:10:08,060
だからここに、我々は、これはバグがあることがわかり
プログラム、以来、我々はそれを実行しようとした場合

176
00:10:08,060 --> 00:10:10,530
引数なしで、
それだけでクラッシュします。

177
00:10:10,530 --> 00:10:16,950
>> あなたが表示されますので、他の一般的なパターン
のargcが小さい場合、のようなものである

178
00:10:16,950 --> 00:10:21,100
そこにいなかったことを示しているよりも2、
少なくとも、プログラム名とA

179
00:10:21,100 --> 00:10:29,100
最初の引数、その後、我々は何をするつもりだ
のようなprintfの、十分ではありません

180
00:10:29,100 --> 00:10:31,190
コマンドライン引数。

181
00:10:31,190 --> 00:10:33,170
それはおそらく印刷するには良いものではないですが、
それはおそらくのようなもの、だ

182
00:10:33,170 --> 00:10:35,440
あなたは、整数を入力する必要があります
コマンドラインで。

183
00:10:35,440 --> 00:10:37,450
私はちょうどそこにそれを終了します。

184
00:10:37,450 --> 00:10:39,600
して、1を返す。

185
00:10:39,600 --> 00:10:44,740
だから私たちの最後にそれを覚えている
プログラムは、我々は0を返した場合、その種の

186
00:10:44,740 --> 00:10:47,060
成功を示します。

187
00:10:47,060 --> 00:10:50,940
と主も自動的
そうしない場合は0を返します。

188
00:10:50,940 --> 00:10:55,800
>> だからここに、我々は示すために1を再チューニングしている
それは成功しないということ。

189
00:10:55,800 --> 00:11:01,000
そして、あなたはあなたが好き返すことができ、
ただ、0は成功を示し、

190
00:11:01,000 --> 00:11:03,390
何かは失敗を示します。

191
00:11:03,390 --> 00:11:04,855
それでは物事のこのバージョンを実行してみましょう。

192
00:11:04,855 --> 00:11:12,880

193
00:11:12,880 --> 00:11:16,600
だから今、私たちは、コマンドラインを入力しない場合
引数、正しく教えてあげましょう

194
00:11:16,600 --> 00:11:18,290
当方、十分なコマンドライン。

195
00:11:18,290 --> 00:11:20,610
文を終了しませんでした。

196
00:11:20,610 --> 00:11:24,950
そうでなければ、我々は実際にそれを1を渡した場合、
それは、プログラムを完了することができます。

197
00:11:24,950 --> 00:11:27,920
だから、これはあなたがARGCを使用する方法です。
の数を検証するため

198
00:11:27,920 --> 00:11:30,630
コマンドライン引数、その
実際に渡されます。

199
00:11:30,630 --> 00:11:39,360
>> それでは、もう少しこのプログラムを作ってみよう
複雑な、第二を見て

200
00:11:39,360 --> 00:11:42,180
物事の繰り返し。

201
00:11:42,180 --> 00:11:46,310
だから今、私たちは、印刷していない
最初のコマンドライン引数。

202
00:11:46,310 --> 00:11:51,210
ここでは、私のequals intから繰り返し処理をしている
0、私は、私のargc未満のプラス

203
00:11:51,210 --> 00:11:55,280
プラス、印刷ARGV、インデックスi。

204
00:11:55,280 --> 00:11:59,300
したがって、このパターンは、再び、これは同じである
代わりを除いて前とパターン、

205
00:11:59,300 --> 00:12:02,600
変数を呼び出す
Nは、ARGCを使用している。

206
00:12:02,600 --> 00:12:09,520
>> だから、これはそれぞれのインデックスを反復処理されている
アレイ内、及び各印刷

207
00:12:09,520 --> 00:12:11,910
その配列内の要素。

208
00:12:11,910 --> 00:12:20,300
だから、我々はこのプログラムを実行すると、よく、
私は、任意のコマンドラインを入力していない

209
00:12:20,300 --> 00:12:22,540
引数なので、それだけで印刷する
プログラム名。

210
00:12:22,540 --> 00:12:26,053
私は物事の束を入力すると、よ
1、独自の行の各を印刷します。

211
00:12:26,053 --> 00:12:31,213

212
00:12:31,213 --> 00:12:32,210
>> [OK]をクリックします。

213
00:12:32,210 --> 00:12:34,770
それでは、この1歩みましょう。

214
00:12:34,770 --> 00:12:38,890
代わりに、各引数を印刷
独自の行に、のは、それぞれを印刷しましょう

215
00:12:38,890 --> 00:12:42,590
各引数の文字
独自の行に。

216
00:12:42,590 --> 00:12:46,700
そうARGVであることを覚えている
文字列の配列。

217
00:12:46,700 --> 00:12:50,960
それでは、文字列ですが、
文字の配列？

218
00:12:50,960 --> 00:12:57,140
だからARGVが本当にあることを意味します
文字の配列の配列。

219
00:12:57,140 --> 00:13:04,920
だからを利用して、
それでは、これを無視してみましょう。

220
00:13:04,920 --> 00:13:08,190
ちょうど文字列のargv 0を考えてみましょう。

221
00:13:08,190 --> 00:13:14,170
>> だから我々はそれぞれのキャラクターを持って帰りたいと思う場合は、
ARGV 0独自の行には、私が欲しい

222
00:13:14,170 --> 00:13:19,500
我々が慣れているパターンを実行するために、私はある
配列の長さ未満

223
00:13:19,500 --> 00:13:23,990
ここのstrlenをしている、それはです
私はしたくないものを、文字列

224
00:13:23,990 --> 00:13:26,450
SはARGV 0に等しい。

225
00:13:26,450 --> 00:13:30,390
だから私は、私たちの長さよりも短い
この場合の配列になって、

226
00:13:30,390 --> 00:13:34,410
文字の、Iプラスプラス。

227
00:13:34,410 --> 00:13:41,040
先週見たので、それは理想的です
我々は移動する場合には、外部strlenを

228
00:13:41,040 --> 00:13:45,210
nが追加されるための条件の
Sのstrlen関数我々は行くたびに、

229
00:13:45,210 --> 00:13:47,720
ループを通して、それがだ
変えることするつもりはありません。

230
00:13:47,720 --> 00:13:50,230
だから我々は、ここを介してNに等しく設定します。

231
00:13:50,230 --> 00:13:54,260

232
00:13:54,260 --> 00:13:55,170
>> [OK]をクリックします。

233
00:13:55,170 --> 00:14:01,320
だから今、私たちは繰り返しを行なっている
配列内の各インデックス。

234
00:14:01,320 --> 00:14:05,630
だから、我々はそれぞれのを印刷したい場合は、
その配列内の文字、パーセントはC

235
00:14:05,630 --> 00:14:06,880
我々が使用するフラグ
文字の。

236
00:14:06,880 --> 00:14:10,750

237
00:14:10,750 --> 00:14:19,770
私はあることを行っている、今のブラケット
文字列、インデックス文字I、もしそうであれば

238
00:14:19,770 --> 00:14:20,970
文字列はこんにちはだった。

239
00:14:20,970 --> 00:14:27,530
そして0はH、Sブラケットになるだろうね
1は、というように、Eも、となります。

240
00:14:27,530 --> 00:14:30,800
>> だから今我々は、結合したい
これら二つのこと。

241
00:14:30,800 --> 00:14:35,440
私たちは、それぞれの文字を印刷したい
各コマンドライン引数の。

242
00:14:35,440 --> 00:14:38,950
だから我々は持っているつもりです
forループネストされた。

243
00:14:38,950 --> 00:14:47,480
従来、第一カウンタ
iは、次は、J、Nであることを行っている

244
00:14:47,480 --> 00:14:54,450
私は、ARGV私のstrlen関数になります
私プラスプラスは、n未満である。

245
00:14:54,450 --> 00:14:59,150

246
00:14:59,150 --> 00:15:06,870
そして今、代わりに印刷ARGV iのため、
私はインデックスしようとしているARGVブラケット - 

247
00:15:06,870 --> 00:15:14,280
つまり、i番目のコマンドラインになるだろう
引数、argvはI、Jをしようとしている

248
00:15:14,280 --> 00:15:16,925
j番目の文字であること
i番目の引数。

249
00:15:16,925 --> 00:15:20,580

250
00:15:20,580 --> 00:15:24,810
私は今ここにこれまで取り除くよ
私たちは、そのループに入れているので。

251
00:15:24,810 --> 00:15:33,900
だから、文字列sのequalsと同じです
ARGV I、その後、SブラケットJ。

252
00:15:33,900 --> 00:15:36,980
>> さて、私たちは宣言する必要はありません
この変数s。

253
00:15:36,980 --> 00:15:44,530
その代わりに、私たちは、これらを組み合わせます
私たちが持っていたもの、ARGV I、Jに2。

254
00:15:44,530 --> 00:15:45,780
>> スピーカ1：[聞こえない]。

255
00:15:45,780 --> 00:15:48,850

256
00:15:48,850 --> 00:15:49,680
>> ROB BODEN：良いコール。

257
00:15:49,680 --> 00:15:52,936
だから、これは壊れています。

258
00:15:52,936 --> 00:15:55,510
私は実際にそれを実行した場合、我々はだろう
このことを実現しています。

259
00:15:55,510 --> 00:16:01,210
私が気にしそうカウンター
については、この特に

260
00:16:01,210 --> 00:16:05,410
ループは、J、イテレータです。

261
00:16:05,410 --> 00:16:08,560
だから、問題に遭遇しているだろう、
おそらく無限ループ、我々の場合

262
00:16:08,560 --> 00:16:09,540
それを固定していなかった。

263
00:16:09,540 --> 00:16:12,220
我々はまた、話をしている理由です
今日デバッグについて。

264
00:16:12,220 --> 00:16:13,120
>> [OK]をクリックします。

265
00:16:13,120 --> 00:16:15,240
それでは、このプログラムを実行してみましょう。

266
00:16:15,240 --> 00:16:21,200
とのは実際には別々のprintfを追加してみましょう
ちょうどここだけ印刷されますことを

267
00:16:21,200 --> 00:16:27,480
私たち、これが意味するので、別のライン、
プログラムを実行し、空白があるだろう

268
00:16:27,480 --> 00:16:31,830
各文字の間に行
各コマンドライン引数。

269
00:16:31,830 --> 00:16:33,448
さて、私たちはそれが何を意味するかわかります。

270
00:16:33,448 --> 00:16:37,310

271
00:16:37,310 --> 00:16:37,790
OOP。

272
00:16:37,790 --> 00:16:39,870
いくつかのバグを得た。

273
00:16:39,870 --> 00:16:42,860
エラーは暗黙のうちに宣言
ライブラリ関数はstrlen。

274
00:16:42,860 --> 00:16:51,630
>> だから私は、戻って我々のプログラムに入る
string.hのを含めるハッシュのを忘れていました。

275
00:16:51,630 --> 00:16:54,240

276
00:16:54,240 --> 00:16:57,730
だから、string.hのがあることを行っている
宣言するヘッダファイル

277
00:16:57,730 --> 00:16:58,980
この関数はstrlenを。

278
00:16:58,980 --> 00:17:04,650

279
00:17:04,650 --> 00:17:06,060
[OK]を、それがコンパイルされます。

280
00:17:06,060 --> 00:17:09,109
それでは、それを実行してみましょう。

281
00:17:09,109 --> 00:17:10,930
だから、その。

282
00:17:10,930 --> 00:17:17,790
それは私たちのプリントアウトになるだろう
プログラム名、ハローワールド。

283
00:17:17,790 --> 00:17:23,510
それは、それぞれの、それぞれのものを印刷するために起こっている
独自の行の文字。

284
00:17:23,510 --> 00:17:24,540
[OK]をクリックします。

285
00:17:24,540 --> 00:17:30,625
>> それでは、実際にこれをみましょう
1歩。

286
00:17:30,625 --> 00:17:34,050

287
00:17:34,050 --> 00:17:39,700
その代わりstring.hのを使用するのではなく、みましょう
我々は我々自身を実装したいかを考える

288
00:17:39,700 --> 00:17:41,420
strlenの関数です。

289
00:17:41,420 --> 00:17:45,600
だから私はすぐにあげる
関数のシグネチャ。

290
00:17:45,600 --> 00:17:52,900
それではmy_strlenで呼ぶことにしましょう​​、それはだ
引数として文字列を取るつもり、

291
00:17:52,900 --> 00:17:57,220
そして我々は返すことを期待
その文字列の長さ。

292
00:17:57,220 --> 00:18:03,430
だから、どこにその男は、ですか？

293
00:18:03,430 --> 00:18:04,990
はい。

294
00:18:04,990 --> 00:18:06,740
[OK]をクリックします。

295
00:18:06,740 --> 00:18:12,900
だから、以前のスライドから覚えている
先週からもあったこと

296
00:18:12,900 --> 00:18:18,890
文字の配列は、よく、文字列、
それでは、これは私たちの文字列sであるとしましょう​​。

297
00:18:18,890 --> 00:18:29,870
だから、sが文字列である場合には、こんにちは、そして、
H-E-L-L-O、メモリでは、それはなるだろう

298
00:18:29,870 --> 00:18:35,610
このバックスラッシュしてもよく、
0文字。

299
00:18:35,610 --> 00:18:39,170
>> では、どのようにsの長さを得るのですか？

300
00:18:39,170 --> 00:18:43,190
さて、トリックは、このを探しています
バックラッシュ0の文字、これはnull

301
00:18:43,190 --> 00:18:44,380
ターミネータ。

302
00:18:44,380 --> 00:18:50,270
だから、このアルゴリズムは、つもりです
いくつかのようなものであると

303
00:18:50,270 --> 00:18:51,510
十分な文字こと - 

304
00:18:51,510 --> 00:18:56,180
のは、この手のいくつかを表してみましょう
カウンタ、のはこのint型の長さと呼ぶことにしましょう​​。

305
00:18:56,180 --> 00:19:00,060
だから、こっちから始めて、我々はしている
私たちの文字列を反復するために行く。

306
00:19:00,060 --> 00:19:04,100
>> だから、それは、Hの最初の文字ですが、
それはそう、バックスラッシュ0ではありません

307
00:19:04,100 --> 00:19:05,170
長さは1である。

308
00:19:05,170 --> 00:19:08,050
次の文字に繰り返し処理し、
E、およびそれがバックスラッシュ0ではありません。

309
00:19:08,050 --> 00:19:09,630
長さは2である。

310
00:19:09,630 --> 00:19:10,960
L、3。

311
00:19:10,960 --> 00:19:11,850
L、4。

312
00:19:11,850 --> 00:19:13,050
O、5。

313
00:19:13,050 --> 00:19:16,690
そして最後に、我々は、バックスラッシュを達成
0となるような手段は、よく、

314
00:19:16,690 --> 00:19:17,780
この文字列は終わった。

315
00:19:17,780 --> 00:19:20,130
それでは、5を戻してみましょう。

316
00:19:20,130 --> 00:19:33,630
>> だから実際には、まず、それを実装する
私のNの長さは、私の右手を0に等しい。

317
00:19:33,630 --> 00:19:36,088
そして、我々は繰り返し処理をするつもりだ - 

318
00:19:36,088 --> 00:19:38,000
>> スピーカ1：[聞こえない]

319
00:19:38,000 --> 00:19:38,640
>> ROB BODEN：ああ、撃つ。

320
00:19:38,640 --> 00:19:39,870
良いコール。

321
00:19:39,870 --> 00:19:42,680
ブーム。

322
00:19:42,680 --> 00:19:44,140
だから、nは長さが0に等しい。

323
00:19:44,140 --> 00:19:46,910

324
00:19:46,910 --> 00:19:58,310
だから今、しばらくの長さがない
等しくと、バックスラッシュ0。

325
00:19:58,310 --> 00:20:04,660
したがって、このバックスラッシュ0を覚えて、それがある
実際の文字、それが示している

326
00:20:04,660 --> 00:20:05,820
文字列の最後。

327
00:20:05,820 --> 00:20:09,850
同じように、また、バッ​​クスラッシュ
nは、実際の文字です。

328
00:20:09,850 --> 00:20:14,040
バックスラッシュ0かを示すために起こっている
私たちの文字列の最後。

329
00:20:14,040 --> 00:20:15,414
私はそこにそれを置くことを望んでいない。

330
00:20:15,414 --> 00:20:19,190

331
00:20:19,190 --> 00:20:25,620
と長さによってインデックスのではありませんが
ヌルターミネータに等しく、その後、

332
00:20:25,620 --> 00:20:27,130
私達はちょうどの長さをインクリメントするつもりだ。

333
00:20:27,130 --> 00:20:29,860

334
00:20:29,860 --> 00:20:34,880
さて、私たちのプログラムの最後に、
長さは、最終的に起こっている

335
00:20:34,880 --> 00:20:37,610
この場合は5であること。

336
00:20:37,610 --> 00:20:39,210
そして、我々は単に長さを返すでしょう。

337
00:20:39,210 --> 00:20:42,570

338
00:20:42,570 --> 00:20:43,530
>> [OK]をクリックします。

339
00:20:43,530 --> 00:20:48,290
だから今ここでダウン、私はしないでください
my_strlenん。

340
00:20:48,290 --> 00:20:50,700
それでは確認するためにそれをコンパイルしてみましょう
すべてがスムーズに実行されます。

341
00:20:50,700 --> 00:20:55,820

342
00:20:55,820 --> 00:20:58,210
私は2でやっていた？

343
00:20:58,210 --> 00:21:00,565
または1というでしたか？

344
00:21:00,565 --> 00:21:01,940
それは行う必要があります。

345
00:21:01,940 --> 00:21:02,690
わかりました。

346
00:21:02,690 --> 00:21:08,490
だから、これはARGV 2です。

347
00:21:08,490 --> 00:21:11,585
予想通り、動作しますが
1は、私はそれをやったということでした？

348
00:21:11,585 --> 00:21:15,060

349
00:21:15,060 --> 00:21:15,550
はい。

350
00:21:15,550 --> 00:21:16,760
[OK]をクリックします。

351
00:21:16,760 --> 00:21:21,820
物事のこのバージョンは持っていませんでした
printfの新しい後の行が、

352
00:21:21,820 --> 00:21:22,910
どちらでもよい。

353
00:21:22,910 --> 00:21:23,300
[OK]をクリックします。

354
00:21:23,300 --> 00:21:25,780
期待ほど働いていました。

355
00:21:25,780 --> 00:21:34,750
>> 今、私たちも、この一歩を組み合わせることができます
さらに、ここで、さて、ここで注意してください

356
00:21:34,750 --> 00:21:38,920
まず、ARGVのstrlen関数をつかんだ
私、そして、我々は繰り返しを行なっている

357
00:21:38,920 --> 00:21:41,450
その文字列内の各文字。

358
00:21:41,450 --> 00:21:47,480
だからではなく、それを行うのか、何であれば、私たち
ただ待っているのこのロジックを組み合わせる

359
00:21:47,480 --> 00:21:50,740
我々は、バックスラッシュ0右をヒットするまで
forループは、この中に？

360
00:21:50,740 --> 00:21:53,740

361
00:21:53,740 --> 00:22:07,490
だから私は、Jが行う、ARGVながら繰り返し処理
等しくないバックスラッシュ0。

362
00:22:07,490 --> 00:22:10,680
それでは、最初にそれを実行してみましょう。

363
00:22:10,680 --> 00:22:19,838

364
00:22:19,838 --> 00:22:21,180
>> わかりました。

365
00:22:21,180 --> 00:22:27,655
だからここに、この条件は言っている - 

366
00:22:27,655 --> 00:22:38,090

367
00:22:38,090 --> 00:22:40,060
のはそれをクリアしてみましょう。

368
00:22:40,060 --> 00:22:49,140
だから今、これが私たちのargvとする。

369
00:22:49,140 --> 00:22:55,290
だから、僕は前に、そのプログラムを実行したときに、
argvは文字列の配列です。

370
00:22:55,290 --> 00:23:03,100
だから、私は、ドットスラッシュARGVでそれを実行した場合
2、ハローワールドは、ARGV

371
00:23:03,100 --> 00:23:07,650
自体ARGVのため、長さは3である
ゼロ、こんにちは、そして世界。

372
00:23:07,650 --> 00:23:11,700

373
00:23:11,700 --> 00:23:19,660
>> これらの指標の各々の内部にあり、
それ自体、これはなるだろう、アレイ、

374
00:23:19,660 --> 00:23:23,780
ドットは、これはスラッシュになり、私は知らない
それは正しい方向だった場合、私は

375
00:23:23,780 --> 00:23:25,680
それがあったとは思わない。

376
00:23:25,680 --> 00:23:30,110
-R-Vのダッシュは、より多くのスペースを必要としています。

377
00:23:30,110 --> 00:23:32,570
それでは、この配列にカットしてみましょう。

378
00:23:32,570 --> 00:23:38,230
-R-Vダッシュ0、次にバックスラッシュ0。

379
00:23:38,230 --> 00:23:43,160
して、混乱にこんにちはとなります。

380
00:23:43,160 --> 00:23:45,910
としましょう​​、H-Eのバックスラッシュ0。

381
00:23:45,910 --> 00:23:51,130
そして最後に、W-Oバックスラッシュ0。

382
00:23:51,130 --> 00:23:59,730
>> だから、我々だけで書いたアルゴリズム、
彼らがしているもののループのためにネストされた

383
00:23:59,730 --> 00:24:07,321
ISやって、我々は最初に持っている
カウンタiとし、J。

384
00:24:07,321 --> 00:24:15,206
これは上のコードを使用して容易になるだろう
画面には、のは戻ってこれを行ってみよう。

385
00:24:15,206 --> 00:24:17,476
[OK]をクリックします。

386
00:24:17,476 --> 00:24:24,600
だから私は、の反復子であることに注意してください
各コマンドの繰り返し処理を行う

387
00:24:24,600 --> 00:24:25,610
ライン引数。

388
00:24:25,610 --> 00:24:28,870
、Jは反復子反復である
その中の各文字の上に

389
00:24:28,870 --> 00:24:30,410
コマンドライン引数。

390
00:24:30,410 --> 00:24:46,755
したがって、この最も内側のprintfが何をしているか
我々はARGV 0 0、のprintfでprintfきている

391
00:24:46,755 --> 00:24:58,680
ARGV 0 1、のprintf ARGV 0 2、0 3、0 4、0
5、0 6が、今、ARGV 0 7をしようとしている

392
00:24:58,680 --> 00:25:00,670
等しいバックスラッシュ0。

393
00:25:00,670 --> 00:25:05,730
>> それでは、我々はループのためにそれを終了し、
そして今、私は1に反復します。

394
00:25:05,730 --> 00:25:10,910
そして今、我々は、印刷しようとしている
ARGV 1 0、ARGV 1 1  - 

395
00:25:10,910 --> 00:25:17,040
さて、今、私はハロー短くカットするので、
ARGV 1 2は、再びになるだろう

396
00:25:17,040 --> 00:25:18,170
バックスラッシュ0。

397
00:25:18,170 --> 00:25:25,050
だから、私をインクリメントし続け、
というように、我々はすべてをプリントアウトするまで

398
00:25:25,050 --> 00:25:28,580
世界では、それらの3つのコマンドライン
引数、我々は外に出るよ

399
00:25:28,580 --> 00:25:31,670
最も外側のループ、および
私たちのプログラムを終了します。

400
00:25:31,670 --> 00:25:38,390

401
00:25:38,390 --> 00:25:39,640
[OK]をクリックします。

402
00:25:39,640 --> 00:25:43,903

403
00:25:43,903 --> 00:25:46,795
>> それでは、ここに戻ってみましょう。

404
00:25:46,795 --> 00:25:49,670

405
00:25:49,670 --> 00:25:52,370
だから、をもう少し詳しく知るでしょう
この上のコマンドライン引数

406
00:25:52,370 --> 00:25:54,460
特定の問題は、設定してください。

407
00:25:54,460 --> 00:25:56,630
>> 今、デバッギング。

408
00:25:56,630 --> 00:26:01,680
だから、おそらくすでにしなければならなかったしている
以前に一部のデバッグ

409
00:26:01,680 --> 00:26:03,120
問題は、設定してください。

410
00:26:03,120 --> 00:26:08,420
とデバッグの1非常に簡単な方法、
最初に、バグのあるプログラムを見てみましょう。

411
00:26:08,420 --> 00:26:20,710

412
00:26:20,710 --> 00:26:23,830
さて、このプログラムを歩いて、
私達はのためにユーザーに確認するつもりだ

413
00:26:23,830 --> 00:26:29,350
整数は、その整数をつかむし、その後、
任意に、我々は、whileループを持っている

414
00:26:29,350 --> 00:26:32,280
ただデクリメントしようとしている
私には10に等しくなるまで。

415
00:26:32,280 --> 00:26:35,820
ちょうど私が入っていると仮定しましょう
10以上の整数。

416
00:26:35,820 --> 00:26:38,700
それが10に等しくなるまで私はデクリメント。

417
00:26:38,700 --> 00:26:42,630
>> そして、我々は別のwhileループを持っている
私は0に等しいわけではありませんが、我々はしている、という

418
00:26:42,630 --> 00:26:44,540
3、iをデクリメントする予定。

419
00:26:44,540 --> 00:26:49,790
だから、バグの意図を見れば
ここで、これは私のデクリメントうことだ

420
00:26:49,790 --> 00:26:57,010
10し、このwhileループの意志であること
デクリメントI 10から、7個、4個、1に、

421
00:26:57,010 --> 00:27:02,880
、負5に、負の2の、など
負の無限大に、私がするので

422
00:27:02,880 --> 00:27:05,920
実際に0に等しいことはありません。

423
00:27:05,920 --> 00:27:08,610
次いで、このプログラムの終了時に、
私たちは、あるfooという機能を持っている

424
00:27:08,610 --> 00:27:12,130
私はそのプリントに外出。

425
00:27:12,130 --> 00:27:16,520
>> だから、これは短く、簡単なプログラムであり、
バグは明白です、

426
00:27:16,520 --> 00:27:18,790
特にちょうど私の後に
バグが何だったか言った。

427
00:27:18,790 --> 00:27:24,840
しかし、ここでの意図はよく、これはかもしれない、ある
実際にあなたのいくつかのように見える

428
00:27:24,840 --> 00:27:30,040
最後の貪欲からソリューション
問題が設定され、多分あなたはありますか

429
00:27:30,040 --> 00:27:32,800
プログラム内のいくつかの無限ループ、
あなたは全く分からない

430
00:27:32,800 --> 00:27:34,100
何がそれを引き起こしている。

431
00:27:34,100 --> 00:27:38,690
ので、非常に便利なデバッグテクニック
ただprintf出力を追加することです

432
00:27:38,690 --> 00:27:40,180
すべてのコードの上。

433
00:27:40,180 --> 00:27:49,200
>> だからここに私は外のprintfが欲しい
最初のwhileループ。

434
00:27:49,200 --> 00:27:53,155
そしてここで私は、printfをしたい、
そして私はちょうど私を印刷します。

435
00:27:53,155 --> 00:27:55,670

436
00:27:55,670 --> 00:27:58,330
私も、私の最初のwhileループをやります。

437
00:27:58,330 --> 00:28:05,130

438
00:28:05,130 --> 00:28:09,040
外では、第二のループしている。

439
00:28:09,040 --> 00:28:12,170
もう一度、内部の印刷
のここで、iの値。

440
00:28:12,170 --> 00:28:16,270

441
00:28:16,270 --> 00:28:17,520
とのこれを実行してみましょう。

442
00:28:17,520 --> 00:28:22,620

443
00:28:22,620 --> 00:28:24,800
>> だから、ドットスラッシュデバッグ。

444
00:28:24,800 --> 00:28:25,610
整数を入力します。

445
00:28:25,610 --> 00:28:28,150
それでは13をやってみましょう。

446
00:28:28,150 --> 00:28:28,760
ブーム。

447
00:28:28,760 --> 00:28:33,300
我々は無限ループしていることがわかります
第whileループの内側。

448
00:28:33,300 --> 00:28:36,305
だから今我々は、バグが何であるかを知っている。

449
00:28:36,305 --> 00:28:39,610

450
00:28:39,610 --> 00:28:45,610
しかし、printfのデバッグは完全に素晴らしいですが、
しかし、あなたのプログラムが得れば

451
00:28:45,610 --> 00:28:50,560
より長く、より複雑な、ある
より洗練されたソリューション

452
00:28:50,560 --> 00:28:51,705
物事が働いてばかり。

453
00:28:51,705 --> 00:28:52,955
それでは、これらすべてのprintf出力を削除してみましょう。

454
00:28:52,955 --> 00:29:06,242

455
00:29:06,242 --> 00:29:08,896
とのは確か私はしませんでしたしてみましょう
何を破る。

456
00:29:08,896 --> 00:29:09,850
[OK]をクリックします。

457
00:29:09,850 --> 00:29:14,180
>> だから我々が行っているプログラム
ご紹介するために呼び出されます

458
00:29:14,180 --> 00:29:16,715
GNUデバッガのGDB、。

459
00:29:16,715 --> 00:29:21,892

460
00:29:21,892 --> 00:29:27,510
さて、実際に、のためのデバッグを削除してみましょう
第二に、そして再びデバッグを行います。

461
00:29:27,510 --> 00:29:31,420

462
00:29:31,420 --> 00:29:34,440
さて、実際には最初、良い教訓
コマンドライン引数で。

463
00:29:34,440 --> 00:29:37,780
このクラングコマンドことであることに注意してください
すべてが渡されているコンパイル

464
00:29:37,780 --> 00:29:41,300
コマンドラインで、これらの
コマンドライン引数。

465
00:29:41,300 --> 00:29:46,250
あなたが使用しているとしているので、正確にどのように
我々のようなコマンドライン引数、

466
00:29:46,250 --> 00:29:51,500
以前と、あなたはPSET内のように
2、それはクラングがそれらを使用している方法です。

467
00:29:51,500 --> 00:30:00,070
>> そう気づく、この最初のフラグ、ダッシュ
ggdb3、それがあると言っているのか、クラング、

468
00:30:00,070 --> 00:30:03,790
あなたがこのファイルをコンパイルする必要があります
意図我々は最終的になること

469
00:30:03,790 --> 00:30:05,380
それをデバッグする必要があります。

470
00:30:05,380 --> 00:30:13,840
だから、限り、あなたはそのフラグを持っているように、
その後、我々は、GDBのデバッグすることができます。

471
00:30:13,840 --> 00:30:17,380
そして、それはGNUデバッガを開きます。

472
00:30:17,380 --> 00:30:22,920
>> そうなコマンドがたくさんあり​​ます
あなたがに慣れる必要があること。

473
00:30:22,920 --> 00:30:27,100
最初の1それは、おそらくよ
すぐに実行される必要があります。

474
00:30:27,100 --> 00:30:28,200
だから何をやろうとして実行されます？

475
00:30:28,200 --> 00:30:30,910
それは私たちのプログラムを起動するために起こっている。

476
00:30:30,910 --> 00:30:36,180
だから、起動プログラム、プログラムを実行する
整数、13のための私達に尋ねる。

477
00:30:36,180 --> 00:30:39,170
そしてそれは無限ループのようにだ
私は削除を除き、期待

478
00:30:39,170 --> 00:30:40,500
printfが、そのように私たちも、それが表示されません。

479
00:30:40,500 --> 00:30:43,320

480
00:30:43,320 --> 00:30:44,600
普通に終了しました。

481
00:30:44,600 --> 00:30:45,850
ああ。

482
00:30:45,850 --> 00:30:48,570

483
00:30:48,570 --> 00:30:53,640
それが包まれている可能性がありますすべての
道の周り、背中に - それを無視して。

484
00:30:53,640 --> 00:30:55,170
それが正常に終了しなかったと仮定します。

485
00:30:55,170 --> 00:30:59,500

486
00:30:59,500 --> 00:31:03,370
と複雑な答えはあります。

487
00:31:03,370 --> 00:31:07,890
>> だから今、それは非常に便利ではありません。

488
00:31:07,890 --> 00:31:11,480
だから内部の我々のプログラムを実行している
このデバッガは、いずれにも私たちを助けていません

489
00:31:11,480 --> 00:31:15,610
我々だけで行っている可能性があるための方法、
ドットは、GDBの外からのデバッグを大幅に削減する。

490
00:31:15,610 --> 00:31:21,250
だから、1コマンド、その
おそらくよ - 

491
00:31:21,250 --> 00:31:22,970
そして私はこれを終了します。

492
00:31:22,970 --> 00:31:25,850
コントロール-Dまたは、仕事の両方を終了します。

493
00:31:25,850 --> 00:31:29,550
それでは、もう一度開いてみましょう。

494
00:31:29,550 --> 00:31:31,130
>> あなたはおそらくよ別のコマンド
すぐにしたい

495
00:31:31,130 --> 00:31:33,600
に慣れるブレークです。

496
00:31:33,600 --> 00:31:37,120
だから我々は、今のところ主にへし折ってやる
そして私はそれを説明します。

497
00:31:37,120 --> 00:31:41,010

498
00:31:41,010 --> 00:31:46,370
さて、ここで私たちは、ブレークポイントを設定して参照してください。
debug.cこの行で。

499
00:31:46,370 --> 00:31:50,160
それでは、休憩の手段があるとき、私
実行]を入力し、プログラムがしようとしている

500
00:31:50,160 --> 00:31:53,560
まで実行を継続
私がブレークポイントにヒット。

501
00:31:53,560 --> 00:31:59,390
私は走りを打ったときので、プログラムが開始され、
そしてそれは、すぐにそれとして壊れる

502
00:31:59,390 --> 00:32:01,940
主な機能になります。

503
00:32:01,940 --> 00:32:06,930
メイン破ることは何かであることを行っている
あなたはかなり一般的にやる。

504
00:32:06,930 --> 00:32:11,340
>> そして今、ご紹介し
いくつかのより多くのコマンドに。

505
00:32:11,340 --> 00:32:14,330
それは我々が言っていることを、ここに注目してください
あるライン11、で壊した

506
00:32:14,330 --> 00:32:16,230
printf関数は、整数を入力します。

507
00:32:16,230 --> 00:32:21,260
ので、次のコマンドでは、どのようになるだろう
私たちは、次のコード行に移動します。

508
00:32:21,260 --> 00:32:24,810
これは、私たちはステップを可能にしようとしている
ラインによる当社のプログラムラインを介して。

509
00:32:24,810 --> 00:32:26,260
ので、次の。

510
00:32:26,260 --> 00:32:29,820
>> 今ライン12、我々は行っている
整数を取得します。

511
00:32:29,820 --> 00:32:30,450
次へ。

512
00:32:30,450 --> 00:32:34,290
あなただけの再入力をヒットした場合、それはよ
あなたがした最後のものをやり直す。

513
00:32:34,290 --> 00:32:36,480
だから私は入力する必要はありません
毎回次の。

514
00:32:36,480 --> 00:32:40,100
そう、整数、13と入力します。

515
00:32:40,100 --> 00:32:46,940
だから今、14行目、私は大きくなっている間
10よりも、私は次に何でしょう。

516
00:32:46,940 --> 00:32:48,685
そして、我々は我々が私をデクリメントするつもり参照してください。

517
00:32:48,685 --> 00:32:50,210
だから我々は再び私をデクリメントするつもりだ。

518
00:32:50,210 --> 00:32:53,620
>> だから今、別の有用な
コマンドはプリントです。

519
00:32:53,620 --> 00:32:55,750
だから、印刷プリントアウトしようとしている
変数の値。

520
00:32:55,750 --> 00:32:57,825
価値を引き出すのを聞かせて
変数iの。

521
00:32:57,825 --> 00:32:58,705
のは、私をプリントしてみましょう。

522
00:32:58,705 --> 00:33:00,910
それは私が11であると言うだろう。

523
00:33:00,910 --> 00:33:03,330
今、私たちは次の再ながら
iが10以上である。

524
00:33:03,330 --> 00:33:05,590
だから、私はまだより大きいです
10、それは11だからである。

525
00:33:05,590 --> 00:33:06,920
私マイナスマイナス。

526
00:33:06,920 --> 00:33:08,250
それでは、もう一度私をプリントしてみましょう。

527
00:33:08,250 --> 00:33:10,950
予想されるように、それは10だ。

528
00:33:10,950 --> 00:33:12,510
>> だから今、次の。

529
00:33:12,510 --> 00:33:16,250
それが戻って条件になるだろう、私はある
10を超えたが、私はそう、今10です

530
00:33:16,250 --> 00:33:20,040
それが10を超えないので、我々は期待して
それは、whileループの外に落下する。

531
00:33:20,040 --> 00:33:22,220
そして今、我々はそのコード行より下だ。

532
00:33:22,220 --> 00:33:28,750
そして別のコマンドは、リストは、まさに起こっている
前後のが表示されます

533
00:33:28,750 --> 00:33:31,240
数行のコードで
場合あなた自身を失った。

534
00:33:31,240 --> 00:33:35,420
だから我々はちょうど、このwhileループを終了しました
そして今、我々は、これを入力しました

535
00:33:35,420 --> 00:33:37,080
Whileループ、18行。

536
00:33:37,080 --> 00:33:39,860
iが0に等しくないようにしつつ。

537
00:33:39,860 --> 00:33:46,570
そして、次に、私はマイナス3に等しく、我々はよ
気づく、これは単なる続けるでしょう。

538
00:33:46,570 --> 00:33:48,270
そして、我々は私を印刷することができます。

539
00:33:48,270 --> 00:33:49,990
>> 各コマンドは、一種のショートカットがあります。

540
00:33:49,990 --> 00:33:51,720
だから、pは、印刷の略です。

541
00:33:51,720 --> 00:33:53,400
だから我々は、pにすることができます。

542
00:33:53,400 --> 00:33:57,550
ちょうどNを保持し続ける、
または[次へ]をやり続ける。

543
00:33:57,550 --> 00:33:58,340
私は再び印刷します。

544
00:33:58,340 --> 00:34:00,380
あなたは、今では167ネガティブだ参照してください。

545
00:34:00,380 --> 00:34:06,030
だから、これは永遠に続くことはありませんが、
本当に永遠に、あなただけの、それを見たので、

546
00:34:06,030 --> 00:34:09,330
実際にいくつかの時点で終了します。

547
00:34:09,330 --> 00:34:15,699
>> だから、GDBを始めています。

548
00:34:15,699 --> 00:34:19,504
しかし、ここでは、GDBにもう一つのことをやらせる。

549
00:34:19,504 --> 00:34:20,754
ええと、デバッグ。

550
00:34:20,754 --> 00:34:23,540

551
00:34:23,540 --> 00:34:28,534
したがって、この特定の場合において、
無限ループは、内部にあることを起こっ

552
00:34:28,534 --> 00:34:30,050
主な機能。

553
00:34:30,050 --> 00:34:35,779
そして今のところ、ちょうど私はそのことを受け入れ
に無限ループに移動するつもり

554
00:34:35,779 --> 00:34:37,029
fooの機能。

555
00:34:37,029 --> 00:34:40,679

556
00:34:40,679 --> 00:34:43,730
ただ、この終了時に、以下のことを覚えている
このプログラムは、まあ、これはもともと

557
00:34:43,730 --> 00:34:46,210
ちょうどだったのfooを呼び出す
私を印刷しようとして。

558
00:34:46,210 --> 00:34:51,880
しかし、今、我々はあるfooという、呼んでいる
それが0になるまで私を増減します。また、

559
00:34:51,880 --> 00:34:54,548
その変数を印刷します。

560
00:34:54,548 --> 00:34:55,469
[OK]をクリックします。

561
00:34:55,469 --> 00:34:57,970
それを保存します。

562
00:34:57,970 --> 00:35:00,175
デバッグを行います。

563
00:35:00,175 --> 00:35:03,310
そして今、GDBのデバッグ。

564
00:35:03,310 --> 00:35:04,090
[OK]をクリックします。

565
00:35:04,090 --> 00:35:10,580
>> だから私はちょうどその時、私はするつもりはない実行している場合
実際に私をステップ実行することができる

566
00:35:10,580 --> 00:35:11,730
プログラム行ずつ。

567
00:35:11,730 --> 00:35:19,820
それでは、メインで破断しましょう
[ファイル名を指定して実行を入力します。

568
00:35:19,820 --> 00:35:28,160
だから、これを通過し、printf関数は、次のように入力し
整数、整数、13を得る。

569
00:35:28,160 --> 00:35:34,180

570
00:35:34,180 --> 00:35:37,490
だから我々はデクリメントを維持するつもりだ
iが10より大きくなるまで。

571
00:35:37,490 --> 00:35:42,840
その後、我々は通って落下するつもりだ
whileループ、ラインを取得 - 

572
00:35:42,840 --> 00:35:44,364
の別のウィンドウでそれを開いてみましょう。

573
00:35:44,364 --> 00:35:48,720

574
00:35:48,720 --> 00:35:53,300
私はもはやなるまで私たちはデクリメントん
10より大きくし、私たち

575
00:35:53,300 --> 00:35:55,700
fooは、関数を呼び出した。

576
00:35:55,700 --> 00:36:01,340
>> それでは、すぐに私がヒットとして起こった
関数foo、まあ、私はfooという、および

577
00:36:01,340 --> 00:36:04,030
その後、私はもはや、GDBの制御がありませんでした。

578
00:36:04,030 --> 00:36:10,230
だから、すぐに私はこのラインで次を打つように、
これが起こったまでのことが継続し、

579
00:36:10,230 --> 00:36:12,400
が、いつ、どこでプログラムが終了しました - 

580
00:36:12,400 --> 00:36:14,450
それは最終的には存在しなかったと仮定します。

581
00:36:14,450 --> 00:36:16,390
あなたはそれが少しのために一時停止しました。

582
00:36:16,390 --> 00:36:22,040
では、なぜ私は、コントロールを失いました
その時点でのプログラム？

583
00:36:22,040 --> 00:36:27,540
私は、次の入力したときだけでなく、それはに行く
コー​​ドというの文字通りの次の行

584
00:36:27,540 --> 00:36:28,850
実行されます。

585
00:36:28,850 --> 00:36:35,950
21行目の後にそう、次のコード行
それは、22行目で実行されます

586
00:36:35,950 --> 00:36:38,520
主から出た、である。

587
00:36:38,520 --> 00:36:43,810
だから、僕は行きたくない
コー​​ドの次の行に。

588
00:36:43,810 --> 00:36:48,170
私は、関数、fooのに行ってみたい、
そして、その後もステップ実行

589
00:36:48,170 --> 00:36:49,830
コー​​ドのこれらの行。

590
00:36:49,830 --> 00:36:53,726
>> だから、我々は選択肢を持っている。

591
00:36:53,726 --> 00:36:56,770
それでは、もう一度それをやめてみましょう。

592
00:36:56,770 --> 00:36:58,020
主に折り返されます。

593
00:36:58,020 --> 00:37:00,520

594
00:37:00,520 --> 00:37:06,370
ええと、1次、次の、13次、
次に、次に、慎重に、

595
00:37:06,370 --> 00:37:09,820
我々は、ラインのfooを叩く前に。

596
00:37:09,820 --> 00:37:10,520
[OK]をクリックします。

597
00:37:10,520 --> 00:37:13,700
>> だから今、私たちは、21行目にいる
私たちは、fooのを呼ぶところ。

598
00:37:13,700 --> 00:37:17,100
我々はそのため、次の入力したくない
単に関数fooを呼び出しますし、

599
00:37:17,100 --> 00:37:18,710
コー​​ドの次の行に移動します。

600
00:37:18,710 --> 00:37:20,840
我々が使用することのステップです。

601
00:37:20,840 --> 00:37:25,690
だから、ステップ間の違いがあります
ステップは、手順に続いて、

602
00:37:25,690 --> 00:37:28,190
次の関数、および行く
機能の上。

603
00:37:28,190 --> 00:37:32,830
それだけで全体を実行
機能といっている。

604
00:37:32,830 --> 00:37:37,210
>> だから、ステップは私たちをもたらすために起こっている
関数に、fooという。

605
00:37:37,210 --> 00:37:41,160
そして、我々は今、我々が戻って、ここを参照してください
理論的には、です。このwhileループ、

606
00:37:41,160 --> 00:37:44,190
いつまで続けるつもり。

607
00:37:44,190 --> 00:37:50,420
そしてそれもないときに、ステップをヒットした場合
呼び出す関数は、それはだ

608
00:37:50,420 --> 00:37:51,720
次に同じ。

609
00:37:51,720 --> 00:37:55,320
だから、あなたがその行にいる場合にのみです
ステップ関数を呼び出している

610
00:37:55,320 --> 00:37:56,970
次とは異なるとしている。

611
00:37:56,970 --> 00:37:57,930
だから、ステップはここで私たちをもたらすでしょう。

612
00:37:57,930 --> 00:38:02,100
ステップ、ステップ、ステップ、ステップ、ステップ、ステップ、および
我々だけで無限ループは永遠よ。

613
00:38:02,100 --> 00:38:06,810
>> つまり、あなたのようにそれに慣れるかもしれません
無限ループを識別する方法、さ

614
00:38:06,810 --> 00:38:08,960
ただ、このEnterキーを保持する
あなたが動けなくなる場所を確認。

615
00:38:08,960 --> 00:38:11,610

616
00:38:11,610 --> 00:38:14,780
そこにこれを行うには良い方法がありますが、
今のところ、それは完全に十分である。

617
00:38:14,780 --> 00:38:17,967
そして文体、スタイルに適合するように
50、私はこれを行っている必要があります。

618
00:38:17,967 --> 00:38:21,550

619
00:38:21,550 --> 00:38:24,030
[OK]をクリックします。

620
00:38:24,030 --> 00:38:28,400
>> 紹介するので1最後のコマンド。

621
00:38:28,400 --> 00:38:30,810
さて、インチデバッグにgdbてみましょう

622
00:38:30,810 --> 00:38:35,580
だからではなく、私も、メインで壊す
fooの機能を知っていることもある

623
00:38:35,580 --> 00:38:39,230
問題は、私は可能性がある
代わりに、fooので破断、言った。

624
00:38:39,230 --> 00:38:42,310
の私はで破断しましょう
メインとfooの両方。

625
00:38:42,310 --> 00:38:45,390
だから、できるだけ多くのブレークポイントを設定することができます
あなたが望むように。

626
00:38:45,390 --> 00:38:49,230
私は実行]を入力すると、それが起こっている
で停止する - 

627
00:38:49,230 --> 00:38:52,180
ああ、以来、のは再コンパイルしてみましょう
私は物事を変えた。

628
00:38:52,180 --> 00:38:55,950
あなたはこの行、警告、ソースが表示されます
ファイルが実行可能よりも新しい。

629
00:38:55,950 --> 00:38:59,680
だから、私はちょうどここに行ったことを意味します
とスタイルに適合するように、これらの変更

630
00:38:59,680 --> 00:39:03,100
50、私は再コンパイルしませんでした
プログラム。

631
00:39:03,100 --> 00:39:04,870
だから、GDBはそれの私を認識します。

632
00:39:04,870 --> 00:39:10,130
私は、再びデバッグを行い、終了します
GDBのデバッグをヒット。

633
00:39:10,130 --> 00:39:10,700
[OK]をクリックします。

634
00:39:10,700 --> 00:39:12,800
>> だから今、戻って、私が何をしていたかと。

635
00:39:12,800 --> 00:39:15,720
メインブレイク、fooのを破る。

636
00:39:15,720 --> 00:39:20,680
私はプログラムを実行し、もしそうであれば、今ではだ
当たるまで続けるつもり

637
00:39:20,680 --> 00:39:21,320
ブレークポイント。

638
00:39:21,320 --> 00:39:24,680
そのブレークポイントはどうなります
メインのようなものです。

639
00:39:24,680 --> 00:39:28,630
今、代わりに次のことの、次の、次の、
次に、次に、私がfooを打つまでは、私は

640
00:39:28,630 --> 00:39:35,230
継続している、継続入力することができます
あなたが次のブレークポイントにヒットするまで。

641
00:39:35,230 --> 00:39:37,200
私が最初の整数を入力する必要があります。

642
00:39:37,200 --> 00:39:40,570
私がヒットするまで継続していきます
ということで次のブレークポイント、

643
00:39:40,570 --> 00:39:43,320
fooの機能を備えている。

644
00:39:43,320 --> 00:39:50,130
>> あなたがヒットするまでそのファイル名を指定して実行が実行されます
ブレークポイントがありますが、ときにだけ実行を入力

645
00:39:50,130 --> 00:39:54,060
あなたは、その後、プログラムを起動し、している
それ以降は、継続です。

646
00:39:54,060 --> 00:40:01,950
私は主壊した場合と
走った後、それがで破るよ

647
00:40:01,950 --> 00:40:03,670
続けて、メイン、および。

648
00:40:03,670 --> 00:40:10,050
私は、fooのにブレークポイントを持っていないので、
整数を入力して、今、私は今

649
00:40:10,050 --> 00:40:11,380
fooので破るつもりはない。

650
00:40:11,380 --> 00:40:16,318
それだけで無限になるだろう
それまでループ。

651
00:40:16,318 --> 00:40:17,568
[OK]をクリックします。

652
00:40:17,568 --> 00:40:19,500

653
00:40:19,500 --> 00:40:24,420
>> だから、GDBにイントロです。

654
00:40:24,420 --> 00:40:27,790
あなたはそれを使用して起動する必要があります
問題のセットで。

655
00:40:27,790 --> 00:40:30,550
それは非常に役立ちます
バグを特定する。

656
00:40:30,550 --> 00:40:35,280
あなたが実際には、ライン·バイ·ライン、行けば
あなたのコードを、そして何であるかを比較

657
00:40:35,280 --> 00:40:39,740
実際に何を期待して起こっている
起こること、それはきれいだ

658
00:40:39,740 --> 00:40:41,060
あなたのバグを欠場することは困難。

659
00:40:41,060 --> 00:40:45,280

660
00:40:45,280 --> 00:40:46,530
[OK]をクリックします。

661
00:40:46,530 --> 00:40:48,310

662
00:40:48,310 --> 00:40:54,040
>> だから、先週ダビデはこれを育て
秘密鍵暗号方式のもの

663
00:40:54,040 --> 00:40:59,350
我々はしたくない、初めて、
パスワードはちょうど私たちの上に格納される

664
00:40:59,350 --> 00:41:03,210
いくつかのプレーンテキストフ​​ァイル内のコンピュータ、どこ
誰かが何度だけ来ることができる

665
00:41:03,210 --> 00:41:04,660
それを開いて、それらを読んで。

666
00:41:04,660 --> 00:41:07,530
理想的には、それらが暗号化される
何らかの方法で。

667
00:41:07,530 --> 00:41:13,340
と問題セット2では、対処されます
暗号化の一方法では、

668
00:41:13,340 --> 00:41:16,520
または、よく、二つの方法が、
彼らはとても素晴らしいではありません。

669
00:41:16,520 --> 00:41:20,050
あなたはハッカー版を行う場合は、ね
また、扱うされる予定

670
00:41:20,050 --> 00:41:22,150
いくつかのことを解読する。

671
00:41:22,150 --> 00:41:29,770
>> だから問題は、現在では、としても、
我々は最強の暗号化を持っている

672
00:41:29,770 --> 00:41:34,830
世界のアルゴリズムには、選択した場合
特に貧しいパスワードは、それ

673
00:41:34,830 --> 00:41:37,720
人々以来、非常に多くのお手伝いをされません
まだそれを把握することができます。

674
00:41:37,720 --> 00:41:41,530
暗号化された文字列を見ている場合でも
それはゴミの混乱のように見えます

675
00:41:41,530 --> 00:41:44,760
彼らは場合には、彼らに何の意味もない
まだほんの数のパスワードを試してみる必要があります

676
00:41:44,760 --> 00:41:50,560
その後、それを把握する
非常に安全ではありません。

677
00:41:50,560 --> 00:41:55,890
だからビデオを見て
その点になります。

678
00:41:55,890 --> 00:41:59,587

679
00:41:59,587 --> 00:42:00,970
>> [ビデオ再生]

680
00:42:00,970 --> 00:42:02,100
>> ·ヘルメット、あなたは悪魔。

681
00:42:02,100 --> 00:42:03,370
何が起こっているの？

682
00:42:03,370 --> 00:42:05,170
あなたが私の娘に何をしているの？

683
00:42:05,170 --> 00:42:09,910
>> 輝かしいを導入するために私に許可証
若い形成外科医、博士フィリップ

684
00:42:09,910 --> 00:42:13,730
Schlotkin、最大の鼻
全体のジョブの男

685
00:42:13,730 --> 00:42:16,080
宇宙、そしてビバリーヒルズ。

686
00:42:16,080 --> 00:42:17,210
>>  - 殿下。

687
00:42:17,210 --> 00:42:18,070
>> 鼻の仕事？

688
00:42:18,070 --> 00:42:18,670
分かりません。

689
00:42:18,670 --> 00:42:20,090
彼女はすでに鼻のジョブを持ったという。

690
00:42:20,090 --> 00:42:21,910
それは甘い16存在していた。

691
00:42:21,910 --> 00:42:22,140
>>  - いいえ。

692
00:42:22,140 --> 00:42:23,690
それはあなたが考えるものではありません。

693
00:42:23,690 --> 00:42:25,420
それははるかに、はるかに悪いです。

694
00:42:25,420 --> 00:42:30,300
あなたはに私の組み合わせが得られない場合
エアシールド、博士Schlotkin意志

695
00:42:30,300 --> 00:42:34,226
彼女の古い鼻をあなたの娘を返す。

696
00:42:34,226 --> 00:42:35,476
>>  - いいえ。

697
00:42:35,476 --> 00:42:38,712

698
00:42:38,712 --> 00:42:40,516
どこでそれを手に入れたの？

699
00:42:40,516 --> 00:42:41,440
>>  - すべての権利。

700
00:42:41,440 --> 00:42:42,180
私が教えてあげましょう。

701
00:42:42,180 --> 00:42:43,381
私が教えてあげましょう。

702
00:42:43,381 --> 00:42:44,263
いいえ、パパ。

703
00:42:44,263 --> 00:42:45,590
いいえ、あなたはいけません。

704
00:42:45,590 --> 00:42:46,860
>> -あなた右、私の愛する。

705
00:42:46,860 --> 00:42:48,450
私はあなたの新しい鼻を逃してしまう。

706
00:42:48,450 --> 00:42:52,090
しかし、私は彼に組み合わせを教えてくれません、
何で。

707
00:42:52,090 --> 00:42:53,680
>>  - 非常によく。

708
00:42:53,680 --> 00:42:55,685
博士Schlotkinは、あなたの最悪を行う。

709
00:42:55,685 --> 00:42:56,914
>>  - 私の喜び。

710
00:42:56,914 --> 00:43:00,690
>> [ツールは尖って受け]

711
00:43:00,690 --> 00:43:01,910
>>  - いいえ。

712
00:43:01,910 --> 00:43:02,520
待つ。

713
00:43:02,520 --> 00:43:03,836
待つ。

714
00:43:03,836 --> 00:43:05,300
私が教えてあげましょう。

715
00:43:05,300 --> 00:43:06,880
私が教えてあげましょう。

716
00:43:06,880 --> 00:43:09,130
>>  - 私はそれを動作を知っていた。

717
00:43:09,130 --> 00:43:09,900
わかりました。

718
00:43:09,900 --> 00:43:12,850
私にそれを渡して

719
00:43:12,850 --> 00:43:16,918
>>  - 組み合わせは1です。

720
00:43:16,918 --> 00:43:17,406
>> ワン。

721
00:43:17,406 --> 00:43:18,382
>> ワン。

722
00:43:18,382 --> 00:43:19,358
>>  - 二つ。

723
00:43:19,358 --> 00:43:19,846
>>  - 二つ。

724
00:43:19,846 --> 00:43:20,822
>>  - 二つ。

725
00:43:20,822 --> 00:43:21,310
>>  - 三。

726
00:43:21,310 --> 00:43:21,798
>>  - 三。

727
00:43:21,798 --> 00:43:22,774
>>  - 三。

728
00:43:22,774 --> 00:43:23,262
>>  - 四。

729
00:43:23,262 --> 00:43:23,750
>>  - 四。

730
00:43:23,750 --> 00:43:26,150
>>  - 四。

731
00:43:26,150 --> 00:43:27,010
>> ファイブ。

732
00:43:27,010 --> 00:43:27,670
>> ファイブ。

733
00:43:27,670 --> 00:43:29,010
>> ファイブ。

734
00:43:29,010 --> 00:43:34,770
>>  - だから、組み合わせが1である、
二つ、三つ、四つ、五つ。

735
00:43:34,770 --> 00:43:37,460
それは愚かな組み合わせだ
私が今までの人生で聞いた。

736
00:43:37,460 --> 00:43:39,710
つまり、馬鹿なことのようなものだ
彼の荷物にならない。

737
00:43:39,710 --> 00:43:42,000
>> あなた、あなたの殿下を、ありがとうございました。

738
00:43:42,000 --> 00:43:43,530
>>  - 何をあなたはしましたか？

739
00:43:43,530 --> 00:43:44,490
>>  - 私は、壁をオフに。

740
00:43:44,490 --> 00:43:45,420
>>  - いいえ、あなたはしませんでした。

741
00:43:45,420 --> 00:43:45,840
あなたは、映画全体がオフになっています。

742
00:43:45,840 --> 00:43:46,930
>>  - 私が間違ったボタンを押しておく必要があります。

743
00:43:46,930 --> 00:43:48,265
>>  - さて、背面にそれを置く。

744
00:43:48,265 --> 00:43:49,110
背面にムービーを置く。

745
00:43:49,110 --> 00:43:49,510
>>  - はい、先生。

746
00:43:49,510 --> 00:43:49,917
はい、先生。

747
00:43:49,917 --> 00:43:50,324
>> それでは、アーノルドに行く - してみましょう。

748
00:43:50,324 --> 00:43:51,140
、グレッチェン来る。

749
00:43:51,140 --> 00:43:53,060
もちろん、私はまだでしょうね
このためにあなたを請求する必要があります。

750
00:43:53,060 --> 00:43:53,440
>> [ENDビデオ再生]

751
00:43:53,440 --> 00:43:54,690
>> ROB BODEN：すべての権利。

752
00:43:54,690 --> 00:43:59,690

753
00:43:59,690 --> 00:44:08,430
だから今我々はすでに話をしていることを
いくつかの点で、セキュリティ、素敵な

754
00:44:08,430 --> 00:44:16,050
少し映画のポスターなので、最近の中で
NSAとの日、これらの問題

755
00:44:16,050 --> 00:44:17,300
すべてを監視する。

756
00:44:17,300 --> 00:44:21,840

757
00:44:21,840 --> 00:44:26,930
それはあなたのように感じるように困難な場合があります
のプライバシーのいくつかの並べ替えを持っている

758
00:44:26,930 --> 00:44:34,540
オンラインの世界では、私は言うことができませんでしたが、
あなたプリズムの詳細の大部分。

759
00:44:34,540 --> 00:44:42,130
そうPRISM超えて移動、私たちはつもりはない
今、そのことについて話してする

760
00:44:42,130 --> 00:44:44,030
あなたのラップトップを考える。

761
00:44:44,030 --> 00:44:48,360
だからここまで、私は切り替えたい
私の実際のアカウントに、

762
00:44:48,360 --> 00:44:50,370
マイ·リトル·ペンギンと。

763
00:44:50,370 --> 00:44:57,310
だから私は、パスワードを設定しているし、その
パスワードは、私はそれになりたい何でもある。

764
00:44:57,310 --> 00:45:02,430
>> しかし、覚えているものを私がログインしています
そのため、このログインによる

765
00:45:02,430 --> 00:45:04,850
プロンプトで、いくつかのプログラムがある。

766
00:45:04,850 --> 00:45:07,910
それがあったいくつかのプログラムです
一部の人によって書かれた。

767
00:45:07,910 --> 00:45:13,250
だから、その人、その場合
特に悪質な、彼らは可能性

768
00:45:13,250 --> 00:45:17,780
言った、大丈夫、もしそうであれば、パスワード
私が入ることに等しく、私の

769
00:45:17,780 --> 00:45:22,800
実際のパスワード、または、同等の
いくつかの特別なパスワードに - 

770
00:45:22,800 --> 00:45:25,550
デビッドは素晴らしいか何かである - 

771
00:45:25,550 --> 00:45:27,190
それらをインチせ

772
00:45:27,190 --> 00:45:33,760
だから、悪意のあるプログラマは可能性があります
あなたのMacのすべてにアクセスするか、

773
00:45:33,760 --> 00:45:36,150
Windows、または何でも。

774
00:45:36,150 --> 00:45:41,980
>> だから、以来、懸念の多くではありません
私が意味する、これがログインプログラムである

775
00:45:41,980 --> 00:45:48,720
それは、OS Xの、何百に同梱されているの
または何千人もの人々が持っている

776
00:45:48,720 --> 00:45:50,020
このコードをレビューした。

777
00:45:50,020 --> 00:45:55,330
だから、あなたは、どこかにあなたのコードでは、IF
この文字列は、equalsに等しい場合を言う

778
00:45:55,330 --> 00:45:58,860
ダビデは、素晴らしい、ログイン後、誰かのです
になるだろう、のように、待ってください。

779
00:45:58,860 --> 00:45:59,800
これは適切ではない。

780
00:45:59,800 --> 00:46:01,790
これはここにあってはならない。

781
00:46:01,790 --> 00:46:06,650
だから、我々は物事を一つの方法だ
この種のセキュリティを確保して。

782
00:46:06,650 --> 00:46:10,300
>> それでもプログラムを考える
あなたが書くこと。

783
00:46:10,300 --> 00:46:13,000
例えば、あなたがログインプログラムを書いたとしましょう​​。

784
00:46:13,000 --> 00:46:20,440
あなたが書いたので、このログイン·プログラム、
そう、明らかに、あなたは良いです

785
00:46:20,440 --> 00:46:21,210
プログラマ。

786
00:46:21,210 --> 00:46:25,610
あなたが悪意のあるを置くつもりはない
xが等しい等しい場合デイビッドは素晴らしいです

787
00:46:25,610 --> 00:46:27,860
あなたのコードに変換する。

788
00:46:27,860 --> 00:46:31,930
しかし、このプログラムは、何をします
このプログラムをコンパイルするために使うのか？

789
00:46:31,930 --> 00:46:34,180
クラングのようなもの。

790
00:46:34,180 --> 00:46:38,460
だから何が起こった人であれば
クラングにケースに入れクラングスペシャルを書く

791
00:46:38,460 --> 00:46:44,310
のようなもの、私がコンパイルしていた場合
ログインプログラムは、このコードを入力

792
00:46:44,310 --> 00:46:49,720
と、言うのログインプログラムに
Xは、ダビデは素晴らしいです等しい等しい？

793
00:46:49,720 --> 00:46:59,890
そうではない、非常にまだ、しかし、我々は同じを持っている
ここでの問題、どこクラング、よく、

794
00:46:59,890 --> 00:47:03,790
何千人も、そうでない場合、数十万の
人々は、持っている、クラングを見てきました

795
00:47:03,790 --> 00:47:07,160
コー​​ドのその行を見て言った、
すべての権利、ここに悪いものは何もありません。

796
00:47:07,160 --> 00:47:10,680
明らかに、誰もやっていない
この悪質なもの。

797
00:47:10,680 --> 00:47:15,780
>> しかし、何と同じように、それ自体打ち鳴らすされ、
私はクラングをコンパイルする場合はどうなりますか？

798
00:47:15,780 --> 00:47:20,900
私はいくつかのコンパイラを持っている場合、その
クラングに挿入クラングをコンパイル

799
00:47:20,900 --> 00:47:25,610
言うこの特別なハック、すべての権利、
私は、クラングをコンパイルすると、その後、

800
00:47:25,610 --> 00:47:31,290
私が手に実行可能ファイルが特別になるはずです
ログインプログラムとカバーの内側

801
00:47:31,290 --> 00:47:34,230
このパスワードは、対等に等しい
Daveは素晴らしいです！

802
00:47:34,230 --> 00:47:37,990
だからあなたのコンパイラ自身ことを覚えておいてください
ある時点でコンパイルする必要があります。

803
00:47:37,990 --> 00:47:42,810
ですから、クラングをコンパイルすることを選択した場合はどう
、自身とその後、悪意がある

804
00:47:42,810 --> 00:47:45,580
全体をねじ込むことができた
ラインの下の方法。

805
00:47:45,580 --> 00:47:49,630
>> だからここでは、ケン·トンプソンを持っている
とデニスリッチー。

806
00:47:49,630 --> 00:47:53,780
だから、これは象徴的な写真です。

807
00:47:53,780 --> 00:47:55,470
デニス·リッチーは右側にあります。

808
00:47:55,470 --> 00:47:58,740
彼は大手である - 

809
00:47:58,740 --> 00:48:03,640
あなたができるので、かなりCを書いた
このクラスのために彼に感謝します。

810
00:48:03,640 --> 00:48:04,840
ケン·トムソンは左側にあります。

811
00:48:04,840 --> 00:48:07,780
二人は、基本的にUNIXを書いた。

812
00:48:07,780 --> 00:48:10,140
まあ、それは主要な貢献者だった
UNIXでは。

813
00:48:10,140 --> 00:48:11,310
いくつか他の人がいました。

814
00:48:11,310 --> 00:48:16,240
ある時点でそうケン·トンプソン、、
彼はチューリング賞を受賞。

815
00:48:16,240 --> 00:48:20,860
そしてチューリング賞は、私はいつも聞いた
それはこのように参照される、それがだ

816
00:48:20,860 --> 00:48:23,100
コンピュータ科学のノーベル賞。

817
00:48:23,100 --> 00:48:27,500
>> だから、チューリング賞で、彼はしなければならない
彼の受諾演説を与える。

818
00:48:27,500 --> 00:48:31,790
そして、彼は、この非常に有名なスピーチを与える
今、信頼するの考察と呼ばれる

819
00:48:31,790 --> 00:48:35,620
私たちがリンクされている信頼、
コー​​スのウェブサイトへ。

820
00:48:35,620 --> 00:48:41,670
この演説の中で、彼は、すべての権利を言う、
私は、UNIXを書いた、そして今、すべての

821
00:48:41,670 --> 00:48:43,320
あなたの人々は、UNIXを使用しています。

822
00:48:43,320 --> 00:48:46,960
今、Linuxがあることを今日思い出し
UNIXの直系の子孫。

823
00:48:46,960 --> 00:48:50,140
OS Xには、直接のUNIXを使用しています。

824
00:48:50,140 --> 00:48:53,810
Windowsはあまりしませんが、多くの
アイデアをUNIXから採取した。

825
00:48:53,810 --> 00:48:59,220
>> そこで彼は、舞台に上がると言う
大丈夫、私はUNIXを書いた。

826
00:48:59,220 --> 00:49:03,940
そして、ちょうどそのように皆さんが知っている、私は今
あらゆるにログインでき

827
00:49:03,940 --> 00:49:05,590
お使いのコンピュータの単一1。

828
00:49:05,590 --> 00:49:14,280
X場合、私はこれらの特別の1を置くので
等しいケントムソンは素晴らしいです等しく、

829
00:49:14,280 --> 00:49:16,350
その後、私はログインできています。

830
00:49:16,350 --> 00:49:18,370
だから人々は、よく、のようなもの
どうやってそれを行う？

831
00:49:18,370 --> 00:49:21,090
私たちは、ログインプログラムを見て
そして何もありません。

832
00:49:21,090 --> 00:49:24,700
彼はよく、私はコンパイラを変更し、のようなものだ
ログインプログラムにログインする

833
00:49:24,700 --> 00:49:30,490
ログインプログラムは、今持っているしめる
そのXはケン·トンプソンに等しい等しく

834
00:49:30,490 --> 00:49:31,700
素晴らしいです。

835
00:49:31,700 --> 00:49:33,120
>> そして、彼らはよく、それは本当ではないです、と言う。

836
00:49:33,120 --> 00:49:35,740
私たちは、コンパイラを見て、としている
コンパイラは、任意の行を持っていない

837
00:49:35,740 --> 00:49:36,400
そのようなコード。

838
00:49:36,400 --> 00:49:40,540
彼はOKのようですが、あなたはどのようなものである
コンパイラを使用してコンパイル？

839
00:49:40,540 --> 00:49:44,810
そして、彼らが思うに、彼は、よく、同じように、だ
私はあなたに、コンパイラを与えた一人です

840
00:49:44,810 --> 00:49:50,580
あなたはとても、コンパイラをコンパイルするのに使用している
あなたは、コンパイラをコンパイルしていること

841
00:49:50,580 --> 00:49:56,390
自体は悪意がある、とウィル
ログインプログラムを破る。

842
00:49:56,390 --> 00:49:59,360
そこで、基本的に、その時点で、そこ
あなたがソースを見ることができる方法ない

843
00:49:59,360 --> 00:50:02,450
ログインプログラムのコード
間違っているかを確認する。

844
00:50:02,450 --> 00:50:04,220
あなたも、に見ることができませんでした
コンパイラのソースコード

845
00:50:04,220 --> 00:50:06,790
間違っているかを確認する。

846
00:50:06,790 --> 00:50:11,940
>> あなたは、マシンを見てする必要があります
コー​​ドの実際のバイナリ

847
00:50:11,940 --> 00:50:16,760
、様子見、これらにコンパイルされたコンパイラ
コー​​ドの行はここにいるべきではありません。

848
00:50:16,760 --> 00:50:22,130
しかし、ケン·トンプソンはそれに1歩を踏み出した
さらに、よく、そこにある、と述べ

849
00:50:22,130 --> 00:50:25,980
実際にこれらの特別プログラム
あなたは、プログラムのバイナリを読み込むに役立つ、

850
00:50:25,980 --> 00:50:29,340
ので、誰かにそのプログラムを使用した場合
バイナリを読んで、彼らはこれらを見ることが

851
00:50:29,340 --> 00:50:30,490
コー​​ドの行数。

852
00:50:30,490 --> 00:50:34,020
彼はすべて、と言ってそれらのプログラムを修正
右、あなたが見ている場合は、

853
00:50:34,020 --> 00:50:38,460
コンパイラは、この特定を表示しない
バイナリのセット。

854
00:50:38,460 --> 00:50:42,830
>> そう、あなたはそのステップを取る必要がある
さらに、基本的に、それは可能性があります

855
00:50:42,830 --> 00:50:46,210
の間接撮影し、複数のレベル、
そしてある時点で、誰も実際ません

856
00:50:46,210 --> 00:50:47,990
チェックされる予定。

857
00:50:47,990 --> 00:50:52,590
だから、この話の教訓は、あなたがしている、ある
書くことにするつもりはありません

858
00:50:52,590 --> 00:50:54,340
このクラスで打ち鳴らす。

859
00:50:54,340 --> 00:50:57,020
あなたは登山を使用することになるだろう
このクラスでは多くのことを打ち鳴らす。

860
00:50:57,020 --> 00:51:00,490
あなたが知っているすべてのために、クラングは、悪意ある
あらゆる妨害されているプログラム

861
00:51:00,490 --> 00:51:03,520
つのプログラムは、これまでにまとめました。

862
00:51:03,520 --> 00:51:08,206
そして、それは非常に不吉であなたを残す
水曜日にお会いし、注意してください。

863
00:51:08,206 --> 00:51:10,030
>> [拍手]

864
00:51:10,030 --> 00:51:12,935
>> スピーカー2：次のCS50で。

865
00:51:12,935 --> 00:51:14,580
>> スピーカ3：あなたが言うあえてしないでください。

866
00:51:14,580 --> 00:51:15,930
あなたがこれを行うことができます。

867
00:51:15,930 --> 00:51:19,440
あなたはこれを行うことができ、前にこれをやった
今日、明日、これを行うことができます。

868
00:51:19,440 --> 00:51:20,930
あなたは何年もこれをやってきました。

869
00:51:20,930 --> 00:51:22,790
ちょうどそこに行くと、これを行う。

870
00:51:22,790 --> 00:51:24,310
あなたがこれを行うことができます。

871
00:51:24,310 --> 00:51:26,102
>> [音楽再生]