1
00:00:00,000 --> 00:00:02,860
[Powered by Google Translate] [週5]

2
00:00:02,860 --> 00:00:04,860
[デビッド·J·マラン - ハーバード大学]

3
00:00:04,860 --> 00:00:07,260
[これはCS50です。 -  CS50.TV]

4
00:00:07,260 --> 00:00:09,740
>> これは、CS50、週5です。

5
00:00:09,740 --> 00:00:12,900
今日、今週​​、我々は、科学捜査の世界を少しご紹介

6
00:00:12,900 --> 00:00:14,850
問題の文脈で4を設定します。

7
00:00:14,850 --> 00:00:18,480
ここで特別なイベントがその後そこだから今日は短縮された講義となります。

8
00:00:18,480 --> 00:00:21,940
だから我々は覗いてみることにしましょう​​、今日学生や両親をいじめる

9
00:00:21,940 --> 00:00:24,600
地平線上にあるいくつかのものを持つ。

10
00:00:24,600 --> 00:00:29,050
>> その中でも、月曜日の時点では、さらにいくつかのクラスメートを持つことになります。

11
00:00:29,050 --> 00:00:32,980
EDX、オープンコースウェアおよび多くのためにハーバードとMITの新しいオンラインイニシアチブ、

12
00:00:32,980 --> 00:00:36,730
来る月曜日つまり、月曜日にハーバード大学のキャンパス内に発射される

13
00:00:36,730 --> 00:00:40,930
あなたは、最後のカウントのように、追加の86000クラスメートになります

14
00:00:40,930 --> 00:00:43,680
CS50の講義とセクションと一緒に次のようになります誰

15
00:00:43,680 --> 00:00:45,890
やチュートリアルと問題セット。

16
00:00:45,890 --> 00:00:51,870
さらに、本研究の一部として、あなたはCS50、今CS50xの就任のクラスのメンバになります。

17
00:00:51,870 --> 00:00:56,150
その一環として、今だけでなく、いくつかの五分五分があると理解できます。

18
00:00:56,150 --> 00:01:00,620
学生の膨大な数のために、このための準備をするには、

19
00:01:00,620 --> 00:01:03,820
、我々は108のTFとCAを持っているにもかかわらずことを言えば十分だろう

20
00:01:03,820 --> 00:01:07,560
私たちは学生の80,000ヒット後、それは非常に最高の学生教師の比率ではありません。

21
00:01:07,560 --> 00:01:09,830
我々は、手動で設定しますので、多くの問題を採点するつもりはない

22
00:01:09,830 --> 00:01:13,050
そう問題セットで今週導入は、CS50チェックされます

23
00:01:13,050 --> 00:01:15,410
アプライアンス内のコマンドラインユーティリティであることを行っている

24
00:01:15,410 --> 00:01:17,880
後でこの週末にそれを更新したら、買ってあげること。

25
00:01:17,880 --> 00:01:21,030
あなた自身のpsetでコマンド、check50を実行することができるでしょう、

26
00:01:21,030 --> 00:01:24,770
そして、あなたのプログラムが正しいか、間違っているかどうかについて即座にフィードバックを得るだろう

27
00:01:24,770 --> 00:01:27,980
我々が提供してきた様々な設計仕様に応じて。

28
00:01:27,980 --> 00:01:30,310
問題セットの仕様ではこれについて。

29
00:01:30,310 --> 00:01:34,220
CS50x同級生もこれを使用することになります。

30
00:01:34,220 --> 00:01:36,170
>> 問題セット4は、すべての科学捜査についてです

31
00:01:36,170 --> 00:01:38,630
そしてこのpsetには、実際にいくつか現実のものに触発されました

32
00:01:38,630 --> 00:01:41,210
それによって、私は大学院にいたとき、私はしばらくの間、抑留

33
00:01:41,210 --> 00:01:45,270
ミドルセックス郡の地方検事のオフィスと法医学の仕事をして

34
00:01:45,270 --> 00:01:47,660
そのリードフォレンジック調査官を持つ。

35
00:01:47,660 --> 00:01:50,280
私は数週間過去言及思うように何がこれは、額

36
00:01:50,280 --> 00:01:52,720
、州警察や他の人が入ってくるであろうミサです

37
00:01:52,720 --> 00:01:56,150
彼らは、ハードドライブ、CDやフロッピーディスクなどのような物事をオフにドロップします

38
00:01:56,150 --> 00:01:58,770
その後フォレンジック事務所の目標は把握することでした

39
00:01:58,770 --> 00:02:01,470
そこにあったか、または何らかの証拠はなかったかどうかを指定します。

40
00:02:01,470 --> 00:02:04,730
これは、特別捜査ユニットだったので、ホワイトカラー犯罪だった。

41
00:02:04,730 --> 00:02:10,949
それが犯罪の多くの厄介なソート、デジタルメディアのいくつかの種類を含むものであった。

42
00:02:10,949 --> 00:02:16,450
それは多くの人々が言っ​​てメールを書いていないことを、 "私はそれをしなかった"ことが判明

43
00:02:16,450 --> 00:02:20,490
だから、かなり頻繁に、これらのフォレンジック検索は、すべてのその多くの実を上げていなかった

44
00:02:20,490 --> 00:02:22,820
時には人々はそのようなメールを書くでしょう。

45
00:02:22,820 --> 00:02:25,240
だから時々、努力が報われた。

46
00:02:25,240 --> 00:02:31,210
>> しかし、この法医学のpsetに至るまでに、我々はpset4でグラフィックのビットを導入することになります。

47
00:02:31,210 --> 00:02:35,410
このごろ -  JPEGファイル、GIFファイルなど - あなたはおそらく当たり前のこれらの事を取る。

48
00:02:35,410 --> 00:02:38,320
しかし、あなたが本当に考えてみれば、イメージ、はるかにロブの顔のような、

49
00:02:38,320 --> 00:02:41,270
ドットまたはピクセルのシーケンスとしてモデル化することができます。

50
00:02:41,270 --> 00:02:43,380
ロブの顔の場合には、色のすべての種類が、あります

51
00:02:43,380 --> 00:02:46,760
そして我々は、そうでない場合はピクセルと呼ばれる個々のドットを、見始め

52
00:02:46,760 --> 00:02:48,610
かつて我々はズームインし始め

53
00:02:48,610 --> 00:02:54,660
しかし、我々は世界を少し簡略化し、ただ、これはここで黒と白でロブであると言うならば、

54
00:02:54,660 --> 00:02:57,490
白と黒を表現するために、我々は単なるバイナリを使用することができます。

55
00:02:57,490 --> 00:03:01,660
我々はバイナリ、1または0を使用するつもりなら、私達はこれと同じ画像を表現することができます

56
00:03:01,660 --> 00:03:06,140
このビットのパターンを持つロブの笑顔の。

57
00:03:06,140 --> 00:03:12,100
11000011は、白、白、黒、黒、黒、黒、白、白を表します。

58
00:03:12,100 --> 00:03:16,150
そしてそれは、色鮮やかな写真の話を開始するために、次に大きな飛躍ではありません

59
00:03:16,150 --> 00:03:18,600
あなたがFacebook上で見たり、デジタルカメラで撮影したいという事。

60
00:03:18,600 --> 00:03:21,410
しかし、確かにそれは色に来るとき、あなたはより多くのビットを必要としています。

61
00:03:21,410 --> 00:03:25,690
や写真の世界では非常に一般的ではなく、1ビットカラーを使用することです

62
00:03:25,690 --> 00:03:29,560
このように示唆しているが、実際に数百万色を取得し、24ビットカラー、。

63
00:03:29,560 --> 00:03:32,250
だから我々はロブの目にズームイン場合のように、

64
00:03:32,250 --> 00:03:36,370
それはまた別のカラフルな可能性の数百万の任意の数であった。

65
00:03:36,370 --> 00:03:39,040
だから我々は、チュートリアルで同様に4を設定して問題でこれを紹介します

66
00:03:39,040 --> 00:03:43,370
なぜならここで金曜日の講演のいつもの2時30分の代わりに3:30に今日される。

67
00:03:43,370 --> 00:03:46,620
しかし、ビデオは明日いつものようにオンラインになります。

68
00:03:46,620 --> 00:03:48,820
>> 我々はまた、別のファイル形式をご紹介します。

69
00:03:48,820 --> 00:03:51,270
これは意図的に、最初は威圧的に見えることを意図している

70
00:03:51,270 --> 00:03:55,670
しかし、これはC言語の構造体のためのちょうどいくつかのドキュメントです。

71
00:03:55,670 --> 00:03:58,940
これは、Microsoftの年前に、このフォーマットの普及を助けていることが判明

72
00:03:58,940 --> 00:04:05,150
ビットマップファイル形式は、BMP、これは超シンプルでカラフルなグラフィカルなファイル形式だったと呼ばれる

73
00:04:05,150 --> 00:04:10,150
それはかなりの時間のために使用され、時には、まだデスクトップの壁紙用にしました。

74
00:04:10,150 --> 00:04:14,760
あなたは、Windows XPとなだらかな丘と青空に戻ってと思われる場合は、

75
00:04:14,760 --> 00:04:17,170
それは一般的にbmpまたはビットマップイメージでした。

76
00:04:17,170 --> 00:04:19,959
彼らはもう少し複雑さを持っているので、ビットマップは、私たちにとって楽しいです。

77
00:04:19,959 --> 00:04:22,610
それは0と1のこのグリッドとしてはかなり簡単ではない。

78
00:04:22,610 --> 00:04:27,510
代わりに、ファイルの先頭にヘッダのようなものを持っている。

79
00:04:27,510 --> 00:04:31,990
だから、他の言葉で、内部のbmpファイルの、0と1の全体の束である

80
00:04:31,990 --> 00:04:34,910
しかし、そこにいくつかの追加の0と1があります。

81
00:04:34,910 --> 00:04:38,220
そして、それは何年も前から当たり前の我々は、おそらく撮影したことが判明 - 

82
00:04:38,220 --> 00:04:45,170
。docまたは。xlsファイルやMP3、のMP4などのファイル形式、どんなファイル形式

83
00:04:45,170 --> 00:04:48,480
あなたが精通していること - それも、ファイル形式であることが何を意味するのでしょうか

84
00:04:48,480 --> 00:04:52,480
一日の終わりにこれらのファイルのすべては、我々だけで、0と1を持って使用しているからです。

85
00:04:52,480 --> 00:04:56,810
そして、おそらくそれらは0と1のASCIIを通じて、ABC等を表す

86
00:04:56,810 --> 00:04:58,820
しかし、一日の終わりに、それはまだちょうど0と1です。

87
00:04:58,820 --> 00:05:02,100
だから、人間はただ時折新しいファイル形式を発明することを決定

88
00:05:02,100 --> 00:05:06,420
彼らはどこのビットパターンが実際に意味するものを標準化しています。

89
00:05:06,420 --> 00:05:09,220
そしてこの場合にはここで、ビットマップファイル形式を設計した人々

90
00:05:09,220 --> 00:05:15,620
そのビットマップファイルの非常に最初のバイトでは、オフセットが0で示すように、言った

91
00:05:15,620 --> 00:05:18,940
bfTypeと呼ばれるいくつかの暗号のような名前の変数があるように起こっている、

92
00:05:18,940 --> 00:05:23,080
ただビットマップファイルの種類を表している、ビットマップファイルの種類はこれです。

93
00:05:23,080 --> 00:05:27,700
あなたはオフセット2番目の行から、おそらく推測することができ、バイト数は2、

94
00:05:27,700 --> 00:05:33,740
何を表して、0と1のパターンを持っている？何かのサイズ。

95
00:05:33,740 --> 00:05:35,310
そして、そこから上に行く。

96
00:05:35,310 --> 00:05:37,410
だから問題セット4に、あなたはこれらの事のいくつかを歩いたことでしょう。

97
00:05:37,410 --> 00:05:39,520
我々はそれらのすべてを気になってしまうことはありません。

98
00:05:39,520 --> 00:05:47,510
しかし、それはバイト54の周り面白くなって開始に気づく：rgbtBlue、緑、および赤。

99
00:05:47,510 --> 00:05:52,110
あなたが今まで聞いたことがある場合頭字語のRGB  - 赤、緑、青 - これはそれへの参照です

100
00:05:52,110 --> 00:05:54,610
それは結局のためには、虹のすべての色をペイントすることができます

101
00:05:54,610 --> 00:05:58,180
赤と青と緑のいくつかの組み合わせを持つ。

102
00:05:58,180 --> 00:06:03,320
そして、実際には、部屋の中で親が早いプロジェクターのいくつかを思い出すかもしれない。

103
00:06:03,320 --> 00:06:05,890
これらの日、あなたはただ、一つの明るい光がレンズから出て来るのを見る

104
00:06:05,890 --> 00:06:09,800
しかし、戻って一日では、赤レンズ、青レンズ、緑のレンズを持っていた

105
00:06:09,800 --> 00:06:13,380
と一緒に、彼らは画面を目的とした、カラフルな画像を形成した。

106
00:06:13,380 --> 00:06:16,270
そして、かなり頻繁に、中学校と高校はこれらのレンズを持っているでしょう

107
00:06:16,270 --> 00:06:19,720
ほんの少し傾いているので、ダブル、トリプルの画像を見ての一種だった。

108
00:06:19,720 --> 00:06:24,100
しかし、それはアイデアだった。あなたは絵を描いて、赤と緑と青の光を持っていた。

109
00:06:24,100 --> 00:06:26,590
そして、その同じ原理をコンピュータで使用されています。

110
00:06:26,590 --> 00:06:30,230
>> だから問題セット4のあなたのためのその後の課題のうちいくつかのものになるだろうしている。

111
00:06:30,230 --> 00:06:34,800
一つは、実際には0と1のパターンで取るために、画像のサイズを変更することである

112
00:06:34,800 --> 00:06:40,200
、0と1の塊がこのような構造で何を表しているかを把握

113
00:06:40,200 --> 00:06:43,630
赤、青、緑 - そして、ピクセルを複製する方法を見つけ出す - 

114
00:06:43,630 --> 00:06:46,660
内側になるように絵が最初にこのように見えたとき、

115
00:06:46,660 --> 00:06:49,210
それは、その後、代わりに次のようになります。

116
00:06:49,210 --> 00:06:53,640
あまりにもあなたがフォレンジックイメージを手渡されるだろうことになるだろう他の課題のうち、

117
00:06:53,640 --> 00:06:56,030
デジタルカメラからの実際のファイルの。

118
00:06:56,030 --> 00:06:58,960
そして、そのカメラで、かつては写真の全体の束だった。

119
00:06:58,960 --> 00:07:03,760
問題は、我々は誤って消去するか、またはイメージが何らかの理由で破損していたされています。

120
00:07:03,760 --> 00:07:05,750
悪い事は、デジタルカメラで発生。

121
00:07:05,750 --> 00:07:09,150
そして、我々はすぐにあなたのために、そのカードの0と1をオフをすべてコピーし、

122
00:07:09,150 --> 00:07:13,610
セット4つの大きなファイルにそれらをすべて保存してから、私たちは問題にあなたにそれらを渡します

123
00:07:13,610 --> 00:07:19,320
ので、理想的には、それらのJPEGファイルのすべてを回復させると、C言語でプログラムを書くことができます。

124
00:07:19,320 --> 00:07:23,330
そしてそれは彼らが多少複雑なファイル形式のいるにもかかわらず、そのJPEGを判明 - 

125
00:07:23,330 --> 00:07:26,360
彼らははるかに複雑なここでこの笑顔だより - 

126
00:07:26,360 --> 00:07:31,160
それはすべてJPEGは0と1の同じパターンで始まっていることが判明した。

127
00:07:31,160 --> 00:07:35,630
だから、最終的には、ループまたは類似のために、whileループまたは使用して、

128
00:07:35,630 --> 00:07:38,880
あなたは、このフォレンジックイメージ内のすべての0と1を反復処理することができます

129
00:07:38,880 --> 00:07:43,150
とすると、問題のセット仕様で定義されている特殊なパターンを見るたびに、

130
00:07:43,150 --> 00:07:47,880
あなたは、非常に高い確率で、JPEGのスタートですここで想定することができます。

131
00:07:47,880 --> 00:07:51,230
バイト数とするとすぐに同じパターンを見つけるように、いくつかの数

132
00:07:51,230 --> 00:07:55,430
またはキロバイトまたはメガバイト後で、あなたがここに仮定することができ、第二JPEGです

133
00:07:55,430 --> 00:07:57,380
私は最初の1の後に撮った写真。

134
00:07:57,380 --> 00:08:01,370
私はそのファイルを最初に読むのをやめましょう、この新しいものを書き始める

135
00:08:01,370 --> 00:08:06,310
とpset4のためのあなたのプログラムの出力は、最大50のJPEGファイルであることを行っている。

136
00:08:06,310 --> 00:08:09,270
それが50 JPEGファイルではない場合や、ループのビットを持っている。

137
00:08:09,270 --> 00:08:12,490
あなたはJPEGファイルの数を無限に持っている場合は、無限ループを持っています。

138
00:08:12,490 --> 00:08:14,910
だから、それはあまりにも非常に一般的なケースとなります。

139
00:08:14,910 --> 00:08:16,600
だからそれは地平線上にあるものだ。

140
00:08:16,600 --> 00:08:21,310
>> 、常に両方に満足している人々が存在することを私のメールにつき実現する、私達の後ろ0クイズ

141
00:08:21,310 --> 00:08:23,640
中立、クイズの周り悲しい0時間のソート。

142
00:08:23,640 --> 00:08:26,800
と頭TF Zamyla、独自のTF、私に手を差し伸べるようにしてください

143
00:08:26,800 --> 00:08:31,180
あなたは物事が行った方法を議論したい場合は、あなたが知っているCAのうちの一つであるか。

144
00:08:31,180 --> 00:08:35,539
>> だから部屋で両親を感動させる、CS50ライブラリは何ですか？

145
00:08:36,429 --> 00:08:40,390
[笑い]グッドジョブ。

146
00:08:40,390 --> 00:08:48,340
CS50ライブラリとは何ですか？うん。 >> [生徒]それは[聞こえない]コードのあらかじめ記述されたセットです

147
00:08:48,340 --> 00:08:49,750
さて、良い。

148
00:08:49,750 --> 00:08:53,240
それは、我々スタッフが書いたコードのあらかじめ記述されたセットです、私たちは、あなたに提供する

149
00:08:53,240 --> 00:08:55,030
それは、いくつかの一般的な機能を提供し、

150
00:08:55,030 --> 00:08:59,020
ここに記載されている機能のすべて - 私に文字列を取得するようなものは、私にint型を取得します。

151
00:08:59,020 --> 00:09:02,260
>> 今から我々は実際にこれらの補助輪を脱いで開始します。

152
00:09:02,260 --> 00:09:05,050
私たちはあなたから文字列を奪うために開始するつもりだ、

153
00:09:05,050 --> 00:09:08,870
そのリコールは、まさに実際のデータ·タイプの同義語だったのですか？ >> [複数の学生]はchar *。

154
00:09:08,870 --> 00:09:12,730
char *型。両親のために、それはおそらく[なるシューという音]であった。それは良いことだ。

155
00:09:12,730 --> 00:09:17,550
char *で我々は、我々の語彙から文字列を削除するとすべてのそれ以上のスクリーン上で見ることから始めましょう

156
00:09:17,550 --> 00:09:19,730
実際にコードを書くことに来る少なくともとき。

157
00:09:19,730 --> 00:09:22,840
同様に、我々ははるかにこれらの機能のいくつかを使用して停止します

158
00:09:22,840 --> 00:09:25,280
我々のプログラムは、より洗練され得ようとしているからです。

159
00:09:25,280 --> 00:09:28,480
だけではなく、プロンプトが点滅してそこに座ってプログラムを書く

160
00:09:28,480 --> 00:09:31,870
で何かを入力するように、ユーザーを待って、あなたは他の場所からの入力を取得します。

161
00:09:31,870 --> 00:09:35,490
たとえば、ローカルのハードドライブ上、一連のビットからそれらを得るでしょう。

162
00:09:35,490 --> 00:09:38,580
かわりに、ネットワーク接続から将来的にそれらを買ってあげる

163
00:09:38,580 --> 00:09:40,230
どこかのウェブサイト。

164
00:09:40,230 --> 00:09:44,110
>> だから初めてこの層バックはがしてみましょうとCS50アプライアンスをプルアップ

165
00:09:44,110 --> 00:09:49,010
あなたは＃何週間も含めてきたcs50.hと呼ばれ、このファイルを、

166
00:09:49,010 --> 00:09:51,140
しかし、ここでは実際にこれの中身を見てみましょう。

167
00:09:51,140 --> 00:09:54,430
青色でファイルの先頭にはコメントだけの全体の束です：

168
00:09:54,430 --> 00:09:57,050
保証情報とライセンス。

169
00:09:57,050 --> 00:09:59,050
これは、ソフトウェアの共通のパラダイムの一種である

170
00:09:59,050 --> 00:10:01,580
ソフトウェアの多くは、これらの日は、オープンソースと呼ばれるものであるため、

171
00:10:01,580 --> 00:10:05,220
これは、誰かがコードを書いて、それが自由に利用できるようになったことを意味します

172
00:10:05,220 --> 00:10:10,470
だけではなく、実行すると使用することが、実際に読んで、変えると自分の仕事に統合する。

173
00:10:10,470 --> 00:10:14,660
だから、それはあなたが非常に小さい形ではあるが、オープンソースソフトウェアを使用してきたものだ。

174
00:10:14,660 --> 00:10:18,560
私はコメントを過ぎて下にスクロールすると、しかし、我々はいくつかのより身近なものを見ることから始めましょう。

175
00:10:18,560 --> 00:10:25,010
cs50.hファイルはヘッダファイルの全体の束が含まれていることをここで一番上にあることに注目してください。

176
00:10:25,010 --> 00:10:28,560
これらのほとんどは、我々は前に見ていないが、1は精通している。

177
00:10:28,560 --> 00:10:32,270
これらのうちどれが、我々はこれまで、簡単にではあるが、見たことがありますか？ >> [生徒]標準ライブラリ。

178
00:10:32,270 --> 00:10:35,810
うん、標準ライブラリ。 stdlib.hは、malloc関数を持っています。

179
00:10:35,810 --> 00:10:38,320
かつて我々は、動的メモリ割り当てについて話し始め

180
00:10:38,320 --> 00:10:41,650
我々も来週に戻ってくるその、我々は、そのファイルを含む開始。

181
00:10:41,650 --> 00:10:46,640
それはboolとtrueとfalseは実際にC自体には存在しないことが判明

182
00:10:46,640 --> 00:10:49,440
あなたはここで、このファイルをインクルードする場合は除きます。

183
00:10:49,440 --> 00:10:52,710
我々は数週間stdbool.hを含むされている

184
00:10:52,710 --> 00:10:55,620
ので、あなたはbool、trueまたはfalseの概念を使用することができます。

185
00:10:55,620 --> 00:10:58,620
これがなければ、偽のそれからソートし、intを使用しなければならないでしょう

186
00:10:58,620 --> 00:11:02,610
とだけ任意に0がfalse、1がtrueであることを前提としています。

187
00:11:02,610 --> 00:11:07,150
我々はさらに下にスクロールすると、ここに文字列の私達の定義である。

188
00:11:07,150 --> 00:11:11,390
それは、この星がどこにあるか本当に問題ではないことを、我々は前に言ったように、判明した。

189
00:11:11,390 --> 00:11:13,720
あなたも、すべての周りの空間を持つことができます。

190
00:11:13,720 --> 00:11:16,740
我々はこの学期を明確にするために、このようにそれを推進してきました

191
00:11:16,740 --> 00:11:18,620
星は型に関係していること、

192
00:11:18,620 --> 00:11:21,700
もう少し一般的ではありませんしかし、もし、同じように一般的な実現

193
00:11:21,700 --> 00:11:24,430
そこにそれを置くことですが、機能的には同じことだ。

194
00:11:24,430 --> 00:11:27,720
我々はさらに下読めば、しかし、今、のは場合、getIntを見てみましょう

195
00:11:27,720 --> 00:11:32,190
我々は何この学期を前に、おそらく最初に使用するためです。

196
00:11:32,190 --> 00:11:37,440
ここでgetIntはある。これは何ですか？ >> [生徒]プロトタイプ。 >>これはただのプロトタイプです。

197
00:11:37,440 --> 00:11:41,410
多くの場合、我々は、我々のcファイルのてっぺんでプロトタイプを入れている

198
00:11:41,410 --> 00:11:46,690
しかし、あなたはまた、ヘッダファイルでプロトタイプを置くことができますここでこのようなhファイルには、

199
00:11:46,690 --> 00:11:50,840
ので、あなたは他の人が使用できるようにしたいいくつかの関数を記述するときに、

200
00:11:50,840 --> 00:11:53,550
これは、正確にCS50ライブラリの場合と

201
00:11:53,550 --> 00:11:57,040
あなたは、cs50.cのようなもので自分の関数を実装していないだけ

202
00:11:57,040 --> 00:12:02,790
あなたもいないそのファイルの先頭に、ヘッダファイルの先頭にプロトタイプを置く。

203
00:12:02,790 --> 00:12:07,170
次に、ヘッダーファイルは友人や同僚が含まれるものであること

204
00:12:07,170 --> 00:12:09,760
と＃は独自のコードに含まれています。

205
00:12:09,760 --> 00:12:12,210
だから、すべてのこの時間は、あなたがこれらのプロトタイプのすべてを含めてきたが​​、

206
00:12:12,210 --> 00:12:16,580
効果的にあなたのファイルの先頭にあるが、これは、＃includeメカニズムを介して、

207
00:12:16,580 --> 00:12:20,070
その本質的にコピーして、あなた自身にこのファイルを貼り付けます。

208
00:12:20,070 --> 00:12:23,070
ここではいくつかのかなり詳細な資料になります。

209
00:12:23,070 --> 00:12:25,640
場合、getIntはintを取得することを当然のことと私たちはかなり撮影した、

210
00:12:25,640 --> 00:12:27,640
それはいくつかのコーナーケースがありますが判明した。

211
00:12:27,640 --> 00:12:31,810
何京、あまりにも大きいの数のユーザーがタイプであれば、

212
00:12:31,810 --> 00:12:35,490
それはただのint型の内側に収まることができないのですか？予想される動作とは何ですか？

213
00:12:35,490 --> 00:12:38,020
理想的には、それは予測可能です。

214
00:12:38,020 --> 00:12:40,280
したがって、このケースでは、実際には、細かい活字を読む場合

215
00:12:40,280 --> 00:12:44,500
あなたが実際にその行を読み取ることができない場合は、この返しINT_MAXが表示されます。

216
00:12:44,500 --> 00:12:48,320
我々はこのことについて話したが、その総額に基づいたことがない、それはおそらく、何ですか？

217
00:12:48,320 --> 00:12:50,640
[学生]は定数。 >>それは定数です。

218
00:12:50,640 --> 00:12:54,770
それはおそらく、これらのヘッダーファイルのいずれかで宣言されているいくつかの特殊な定数です

219
00:12:54,770 --> 00:13:00,090
、ファイル内でより高いことだし、INT_MAXはおそらくほぼ20億のようなものです

220
00:13:00,090 --> 00:13:04,990
我々は何とかしてその何かを意味する必要があるため、という考えは間違っていた、

221
00:13:04,990 --> 00:13:10,700
与えるか、または取る、20億までに-2000000000：我々は、はい、私達の処分で40億番号を持っています。

222
00:13:10,700 --> 00:13:14,710
さて、どのようなプログラミングでは一般的であることは、あなたがちょうどそれらのいずれかの番号を盗むです

223
00:13:14,710 --> 00:13:18,920
多分多分0、多分2億円、-2000000000、

224
00:13:18,920 --> 00:13:23,280
あなたは世界にコミットできるようので、あなたの可能な値の1を過ごす

225
00:13:23,280 --> 00:13:26,820
何かがうまくいかない場合に、私はこの極度の大きい値を返します。

226
00:13:26,820 --> 00:13:31,030
しかし、あなたは、ユーザーが234のような不可解な何かを入力したくない...、本当に大きな数。

227
00:13:31,030 --> 00:13:34,060
あなたは、定数として代わりにそれを一般化する。

228
00:13:34,060 --> 00:13:38,060
だから本当に、あなたが過去数週間肛門されていた場合は、場合、getInt呼ばいつでも、

229
00:13:38,060 --> 00:13:42,900
あなたはINT_MAXの条件がなかった場合は、ユーザーのタイプに確認されている必要があり、

230
00:13:42,900 --> 00:13:46,590
または、より具体的には、それがなかった場合ので、場合、getIntリターンINT_MAXをした、

231
00:13:46,590 --> 00:13:51,830
それは、実際に彼らはそれを入力しなかったことを意味します。何かは、このケースではうまくいかなかった。

232
00:13:51,830 --> 00:13:56,080
だから、これは一般的に、単に特別な意味センチネル値、として知られているものです。

233
00:13:56,080 --> 00:13:58,120
>> 今cファイルに変身してみましょう。

234
00:13:58,120 --> 00:14:01,340
Cファイルはいくつかの時間のためのアプライアンスに存在しています。

235
00:14:01,340 --> 00:14:06,840
そして、実際には、アプライアンスが、それは、我々は、オブジェクト·コードと呼ばれるものにするために事前にコンパイルされている

236
00:14:06,840 --> 00:14:09,540
システムは知っているので、それがどこにあるが、それだけであなたには関係ありません

237
00:14:09,540 --> 00:14:11,730
この場合、それはどこにある：アプライアンス。

238
00:14:11,730 --> 00:14:17,400
すべてのこの時間をgetIntおよび場合、getIntが取り組んできたかを見るために今までスクロールダウンしてみましょう。

239
00:14:17,400 --> 00:14:19,460
ここでは、以前から同様のコメントがあります。

240
00:14:19,460 --> 00:14:21,660
私はちょうどコード部分にズームインすることができます。

241
00:14:21,660 --> 00:14:23,900
そして、私たちが持っている場合、getIntため以下の通りです。

242
00:14:23,900 --> 00:14:25,700
それは入力を取りません。

243
00:14:25,700 --> 00:14:29,510
、それは（真）中に、intを返しますので、我々は意図的に無限ループを持っている

244
00:14:29,510 --> 00:14:33,180
しかし、おそらく、我々は何らかの形でこのから抜け出すか、この内から戻ります。

245
00:14:33,180 --> 00:14:34,870
>> これがどのように機能するかを見てみましょう。

246
00:14:34,870 --> 00:14:39,240
我々は166、ループ内でこの最初の行にGetStringを使用するように見える。

247
00:14:39,240 --> 00:14:43,780
どのような状況下でGetStringメソッドが返す可能性があるので、これは今は良い習慣です

248
00:14:43,780 --> 00:14:47,660
特殊なキーワードNULL？ >> [生徒]何か間違っている場合。

249
00:14:47,660 --> 00:14:51,630
何かが間違っている場合。そして、あなたがGetStringメソッドのようなものを呼び出したときに間違って行くことができるか？

250
00:14:54,960 --> 00:14:57,640
うん。 >> [生徒] mallocがそれをint型を与えるために失敗します。

251
00:14:57,640 --> 00:14:59,150
うん。たぶんmallocが失敗します。

252
00:14:59,150 --> 00:15:03,190
どこかのフードの下には、GetStringはメモリを割り当てmallocを、呼んでいる

253
00:15:03,190 --> 00:15:06,020
これは、文字のすべてのコンピュータストアをすることができます

254
00:15:06,020 --> 00:15:07,750
そのキーボードにユーザーがタイプ。

255
00:15:07,750 --> 00:15:11,590
そして、例えば、ユーザが自由時間の全体の多くを持っていたし、それ以上の入力したと仮定

256
00:15:11,590 --> 00:15:16,160
コンピュータより多くの文字、2億文字よりもRAMを内蔵しています。

257
00:15:16,160 --> 00:15:19,250
GetStringメソッドは、あなたにそれを示すことができなければなりません。

258
00:15:19,250 --> 00:15:22,560
これは、超、超珍しいコーナーケースであっても、

259
00:15:22,560 --> 00:15:24,340
それは、何らかの形でこれを扱うことができなければなりません

260
00:15:24,340 --> 00:15:28,750
我々は戻って、そのドキュメントを読む場合などGetStringメソッド、実際の戻り値がNULLでない。

261
00:15:28,750 --> 00:15:34,460
GetStringメソッドがNULLを返すことによって、失敗した場合、だから今、getIntはINT_MAXを返して失敗しようとしている

262
00:15:34,460 --> 00:15:37,690
ちょうどセンチネルとして。これらは、ちょうど人間の慣習です。

263
00:15:37,690 --> 00:15:41,450
あなたはこのような場合は知っているだろう唯一の方法は、ドキュメントを読んでいます。

264
00:15:41,450 --> 00:15:45,040
>> intは実際に頂いている場所までスクロールダウンしてみましょう。

265
00:15:45,040 --> 00:15:51,160
私はもう少し下にスクロールすると、ライン170で、我々はこれらの行上記のコメントを持っています。

266
00:15:51,160 --> 00:15:55,100
我々は172でint n、およびchar型、c、および、この新しい関数を宣言する

267
00:15:55,100 --> 00:15:58,930
そのあなた方のうちの何人かは、sscanf関数の前に偶然見つけました。

268
00:15:58,930 --> 00:16:00,870
これは、文字列のscanfの略です。

269
00:16:00,870 --> 00:16:05,700
言い換えれば、私に文字列を与えると私は、関心のある情報の断片のためにそれをスキャンします。

270
00:16:05,700 --> 00:16:07,360
どういう意味ですか？

271
00:16:07,360 --> 00:16:11,800
私はキーボードで、文字通りに123を入力し、Enterキーを打っていると仮定します。

272
00:16:11,800 --> 00:16:16,470
GetStringメソッドによって返された123のデータ型は何ですか？ >> [生徒]文字列。

273
00:16:16,470 --> 00:16:18,380
それは右、明らかに文字列ですか？私は、文字列を得た。

274
00:16:18,380 --> 00:16:23,220
だから123はそれの終わりに\ 0で、俗に言う、本当に123です。

275
00:16:23,220 --> 00:16:27,110
つまり、int型ではありません。それは数字ではありません。これは、数字のように見えますが、実際にはありません。

276
00:16:27,110 --> 00:16:29,080
だから何getIntはしなければならないのでしょうか？

277
00:16:29,080 --> 00:16:35,750
123 \ 0  -   - それは左から右へと、その文字列をスキャンしていると何とか実際の整数に変換します。

278
00:16:35,750 --> 00:16:37,850
あなたがこれを行う方法を見つけ出すことができます。

279
00:16:37,850 --> 00:16:41,450
あなたはpset2に戻ってと思われる場合は、おそらくシーザーと少し快適になった

280
00:16:41,450 --> 00:16:44,820
またはVigenereので、文字列を反復処理することができます、あなたはintに文字を変換することができます。

281
00:16:44,820 --> 00:16:46,710
しかし、一体、それは仕事の全体の多くのです。

282
00:16:46,710 --> 00:16:49,860
なぜあなたのためにそれを行いますsscanf関数のような関数を呼び出しませんか？

283
00:16:49,860 --> 00:16:54,230
このケースではラインと呼ばれる、文字列です - のでsscanfは引数を期待します。

284
00:16:54,230 --> 00:17:01,840
次に、あなたがこの文字列に表示されるはず何、printf関数と非常によく似て、引用符で囲んで指定します。

285
00:17:01,840 --> 00:17:09,000
と私がここで言ったんだけど、私は多分進数と文字を参照してくださいと思っているものです。

286
00:17:09,000 --> 00:17:12,000
これはただの一瞬でその理由と我々が表示されます。

287
00:17:12,000 --> 00:17:15,869
そしてそれは、この表記法は、我々が話を始め今のものを彷彿とさせることが判明

288
00:17:15,869 --> 00:17:17,619
ちょうど一週間以上前。

289
00:17:17,619 --> 00:17:21,740
＆nと＆Cここで私たちのためにやっては何ですか？ >> [生徒] nのアドレスとcのアドレス。

290
00:17:21,740 --> 00:17:25,400
うん。それは私にcのnとアドレスのアドレスを与えている。なぜそれが重要なのでしょうか？

291
00:17:25,400 --> 00:17:30,220
あなたは、Cの関数で、あなたは常にすべての値または値を返すことができることを知っています。

292
00:17:30,220 --> 00:17:34,530
あなたは、int、文字列型、float型、char型、何か、あなたはvoidを返すことができますが、返すことができます

293
00:17:34,530 --> 00:17:38,030
しかし、あなたは唯一最大限に一つのことを返すことができます。

294
00:17:38,030 --> 00:17:42,760
しかし、ここではsscanfが多分int型、10進数を私に返すようにしたい

295
00:17:42,760 --> 00:17:46,220
また、char型、そしてなぜ瞬間のchar私が説明しましょう​​。

296
00:17:46,220 --> 00:17:51,460
あなたが効果的にsscanfは二つのことを返すようにしたいが、それはCでだけ可能ではありません

297
00:17:51,460 --> 00:17:55,200
あなたは、2つのアドレスを渡すことによって、その回避することができます

298
00:17:55,200 --> 00:17:57,370
なぜならできるだけ早くあなたが関数に二つのアドレスを渡すと、

299
00:17:57,370 --> 00:18:00,470
その関数は彼らと何ができるのでしょうか？ >> [生徒]それらのアドレスに書き込みます。

300
00:18:00,470 --> 00:18:02,010
それは、それらのアドレスに書き込むことができます。

301
00:18:02,010 --> 00:18:05,770
あなたはスター操作を使用し、それらのアドレスのそれぞれに、そこに行くことができます。

302
00:18:05,770 --> 00:18:11,260
それがこのバックドア機構の一種が、非常に一般的な変数の値を変更するための

303
00:18:11,260 --> 00:18:14,870
このケースでは、2  -  1か所だけ以上。

304
00:18:14,870 --> 00:18:21,340
今私は== 1をチェックしてから、それは、実際には、trueと評価されない場合は、nを返すよ気づく。

305
00:18:21,340 --> 00:18:26,170
だから何が起こっているのですか？技術的には、我々は本当に場合、getIntで発生するすべてのはこれです。

306
00:18:26,170 --> 00:18:30,740
俗に言う123  - 私たちは、いわば、解析したい、我々は文字列を読み込みたい - 

307
00:18:30,740 --> 00:18:34,560
そして数は我々がしなければならsscanf関数を言っているのか、そこがあるように見える場合

308
00:18:34,560 --> 00:18:38,190
私のためにこの変数nに -  123  - その数字を入れています。

309
00:18:38,190 --> 00:18:42,090
それではどうして私は実際にこれは、同様にありましたか？

310
00:18:42,090 --> 00:18:48,220
あなたもここに文字を得るかもしれないと言ってsscanfの役割は何ですか？

311
00:18:48,220 --> 00:18:53,470
[聞こえない学生の応答は] >>小数点実際に動作することができます。

312
00:18:53,470 --> 00:18:56,330
しばらく考えているのが保持しましょう​​。他に何が？

313
00:18:56,330 --> 00:18:59,270
[学生]は、NULLである可能性があります。 >>良いと思った。それがヌル文字である可能性があります。

314
00:18:59,270 --> 00:19:01,660
それは、このケースでは実際にはありません。うん。 >> [生徒]アスキー。

315
00:19:01,660 --> 00:19:04,340
アスキー。または私はさらに一般化することができます。

316
00:19:04,340 --> 00:19:06,640
そこ％cは単にエラーチェックのためのものです。

317
00:19:06,640 --> 00:19:09,300
私たちは、数字の後に文字があるようにしたくない

318
00:19:09,300 --> 00:19:11,870
しかし、何これは私が行うことができます以下の通りです。

319
00:19:11,870 --> 00:19:18,210
それはsscanfは、ここに、この例ではnとcの値を格納する以外に、判明

320
00:19:18,210 --> 00:19:24,890
それはまた、変数の数を返しているそれは何インチの値を入力する

321
00:19:24,890 --> 00:19:30,260
あなただけの123に入力した場合、そうだとすれば、唯一の％dが一致しようとしている、

322
00:19:30,260 --> 00:19:33,880
とだけnは、123のような値で保存される

323
00:19:33,880 --> 00:19:35,640
そして、何もCに入れて傷つきません。

324
00:19:35,640 --> 00:19:37,620
Cは、いわば、ゴミ値のまま - 

325
00:19:37,620 --> 00:19:40,730
それはいくつかの値に初期化されたことがないているのでゴミ。

326
00:19:40,730 --> 00:19:45,520
私は、これらのポインタの1を移入ので、だからその場合、sscanfは1を返します。

327
00:19:45,520 --> 00:19:50,190
偉大な、その場合、私はラインがメモリを解放する解放するようにint型を持っている

328
00:19:50,190 --> 00:19:54,000
そのGetStringメソッドは、実際に割り当てられたし、私は、nを返す

329
00:19:54,000 --> 00:19:58,500
他にその文を再試行してくださいどこにあなたが今まで疑問に思った場合は、から来ている、それはまさにここから来ている。

330
00:19:58,500 --> 00:20:04,390
そうだとすればこれとは対照的に、私は123fooに入力 - テキストのほんのいくつかのランダムシーケンス - 

331
00:20:04,390 --> 00:20:08,490
sscanfは、数値、数値、数値、fを、見に行くされている

332
00:20:08,490 --> 00:20:16,410
それがnに123を置くために起こっている、それはcでfを入れて、2を返すために起こっている。

333
00:20:16,410 --> 00:20:20,640
だから我々はちょうどsscanf関数の振る舞い​​、非常に単純な方法の基本的な定義を使用して、持っている - 

334
00:20:20,640 --> 00:20:23,900
よく、一目見ただけではなくその日はかなり単純な機構の終わりに複雑な - 

335
00:20:23,900 --> 00:20:28,320
言うのがあるintであり、そうだとすれば、それは私が見つけた唯一のことなのですか？

336
00:20:28,320 --> 00:20:29,860
そして、ここの空白は意図的なものだ。

337
00:20:29,860 --> 00:20:34,000
あなたはsscanf関数のドキュメントを読めば、それはあなたが空白の部分が含まれている場合があることを伝えます

338
00:20:34,000 --> 00:20:38,810
先頭または末尾に、sscanfはあまりにも、どんな理由であれ、ユーザーを許可します

339
00:20:38,810 --> 00:20:41,860
スペースバー123をヒットすると、それが正当であろう。

340
00:20:41,860 --> 00:20:44,150
彼らは、スペースバーを叩くという理由だけでは、ユーザー怒鳴らないでしょう

341
00:20:44,150 --> 00:20:48,640
ほんの少し、よりユーザーフレンドリーな先頭または末尾にある。

342
00:20:48,640 --> 00:20:52,300
>> 場合、getIntで次に何か質問はありますか？うん。 >> [生徒]あなただけのchar型に入れたら？

343
00:20:52,300 --> 00:20:54,030
良い質問です。

344
00:20:54,030 --> 00:20:59,890
何がちょうどfのようなchar型で入力し、これまで123を入力せずにEnterを叩いたら？

345
00:20:59,890 --> 00:21:02,420
あなたは、このコード行の振る舞い​​は次のようになりますどう思いますか？

346
00:21:02,420 --> 00:21:04,730
[聞き取れない生徒の応答]

347
00:21:04,730 --> 00:21:08,790
その場合には、それはNまたはCを埋めるために行くわけではないので、ええ、そうsscanfは、あまりにもカバーすることができます。

348
00:21:08,790 --> 00:21:15,310
その代わり、私もそのシナリオをキャッチしています、その場合に0を返すために起こっている

349
00:21:15,310 --> 00:21:18,750
私が欲しいの期待値が1であるため。

350
00:21:18,750 --> 00:21:22,000
私だけ充填される1つだけの事をしたい。良い質問です。

351
00:21:22,000 --> 00:21:24,290
>> その他？かしこまりました。

352
00:21:24,290 --> 00:21:26,250
>> ここでのすべての機能を通過するのをやめましょう、

353
00:21:26,250 --> 00:21:29,500
しかし、残りの関心多分思われるものはgetStringで

354
00:21:29,500 --> 00:21:32,790
それはGetLongLong、getFloatは、場合、getIntは、getDoubleはことが判明しているため

355
00:21:32,790 --> 00:21:36,260
すべてのパントGetStringメソッドにそれらの機能がたくさん。

356
00:21:36,260 --> 00:21:39,750
それでは、彼はここでどのように実装されるかを見てみましょう。

357
00:21:39,750 --> 00:21:43,630
この1つは少し複雑に見えますが、それは同じファンダメンタルズを使用しています

358
00:21:43,630 --> 00:21:45,670
我々は先週の話を始めた。

359
00:21:45,670 --> 00:21:49,490
GetStringメソッドでは、これはここまでボイドに従って引数をとりません

360
00:21:49,490 --> 00:21:53,730
そしてそれは私が明らかにバッファと呼ばれる文字列を宣言するのですが、文字列を返します。

361
00:21:53,730 --> 00:21:56,270
私は本当にそれがまだのために使用されるように何が起こっているのかわからないが、我々が表示されます。

362
00:21:56,270 --> 00:21:58,390
容量はデフォルトは0であるように見えます。

363
00:21:58,390 --> 00:22:01,350
これはnがまだのために使用されようとしているのかわからない、どこに行っているか全くわからない、

364
00:22:01,350 --> 00:22:03,590
しかし、今ではもう少し面白くなってきている。

365
00:22:03,590 --> 00:22:06,520
ライン243で、我々は、int、cを宣言します。

366
00:22:06,520 --> 00:22:08,800
これは愚かなディテールの一種である。

367
00:22:08,800 --> 00:22:15,820
charは8ビットであり、8ビットがどのように多くの異なる値を格納できますか？ >> [学生] 256。 >> 256。

368
00:22:15,820 --> 00:22:20,730
あなたがそこにいる256種類のASCII文字を使用したい場合の問題は、

369
00:22:20,730 --> 00:22:23,340
あなたが戻って思えば - これは暗記するものではありません。

370
00:22:23,340 --> 00:22:25,710
あなたはその大きなASCIIチャートに戻ってと思われる場合しかし、我々は数週間前にあったが、

371
00:22:25,710 --> 00:22:30,600
128または256のASCII文字は、その場合にはあった。

372
00:22:30,600 --> 00:22:32,940
我々は、0と1までの全てのパターンを使用していました。

373
00:22:32,940 --> 00:22:36,210
あなたがエラーを検出することができるようにしたい場合は、それが問題だ

374
00:22:36,210 --> 00:22:40,190
あなたはすでにあなたの文字のために256の値を使用している場合ので、

375
00:22:40,190 --> 00:22:43,050
今あなたが言っ手段を持っていないため、あなたは本当に、事前に計画を立てていなかった

376
00:22:43,050 --> 00:22:46,270
これは合法的な文字ではありません、これはいくつかの誤ったメッセージです。

377
00:22:46,270 --> 00:22:50,270
それでは世界が行うことは、彼らが次の最大値は、intのようなものを使用している

378
00:22:50,270 --> 00:22:54,720
あなたは40億の可能な値に対して、ビット、32のクレイジーな数を持っているように、

379
00:22:54,720 --> 00:22:58,860
あなたは単に、本質的に257それらを使うのをやめてしまうことができるように

380
00:22:58,860 --> 00:23:01,720
の1は、エラーのようないくつかの特別な意味を持っています。

381
00:23:01,720 --> 00:23:03,120
>> それでは、どのようにこの作品を見てみましょう。

382
00:23:03,120 --> 00:23:07,760
ライン246で、私は、fgetc関数を呼んでいるこの大きなwhileループを持っている

383
00:23:07,760 --> 00:23:11,090
fの意味はファイルなので、getcにしてから、標準入力。

384
00:23:11,090 --> 00:23:15,520
それはこれがちょうどキーボードからの入力を読み取るというのがより正確な方法であると判明。

385
00:23:15,520 --> 00:23:19,300
標準入力がキーボードを意味し、標準出力には、スクリーンを意味

386
00:23:19,300 --> 00:23:23,310
そして我々はpset4でわかる標準誤差は、スクリーンを意味

387
00:23:23,310 --> 00:23:27,490
しかし、それは実際の出力と画面の特別な部分を融合していないように

388
00:23:27,490 --> 00:23:30,750
あなたが印刷することを意図した。将来的にはその上が、より多くの。

389
00:23:30,750 --> 00:23:34,440
だから、fgetcは、単にキーボードから1文字を読み、どこに保管して意味ですか？

390
00:23:34,440 --> 00:23:37,350
それをcに格納します。

391
00:23:37,350 --> 00:23:41,360
その後チェック - ので、私はちょうどここにいくつかのブール論理積を使用している - 

392
00:23:41,360 --> 00:23:46,000
それが等しくないことを確認してください -  \ nは、ユーザが入力してヒットしている、我々はその時点で停止したい場合は、

393
00:23:46,000 --> 00:23:49,850
ループの終了 - と我々はまた、特別な定数EOFをチェックしたい場合は、

394
00:23:49,850 --> 00:23:53,610
あなたが知っているか推測した場合、それは何をどちらの略ですか？ファイルの>> [生徒]終了。ファイルの>>終わり。

395
00:23:53,610 --> 00:23:56,560
私はキーボードで入力している場合ので、これは無意味なの一種である

396
00:23:56,560 --> 00:23:58,870
これに関与していないファイルは、実際にはありません

397
00:23:58,870 --> 00:24:01,150
しかし、これは単に意味するために使用される一般的な用語のようなものです

398
00:24:01,150 --> 00:24:04,220
その何もない、人間の指から来ています。

399
00:24:04,220 --> 00:24:06,460
EOF  - ファイルの終わり。

400
00:24:06,460 --> 00:24:09,920
余談ですが、あなたがこれまでには至っていないだろうと、あなたのキーボードでコントロールDをしないヒットした場合 - 

401
00:24:09,920 --> 00:24:15,230
あなたは、Ctrl + Cを打ちました - コントロールDは、この特別な定数と呼ばれるEOFを送ります。

402
00:24:15,230 --> 00:24:19,850
だから今我々はいくつかの動的なメモリ割り当てを持っている。

403
00:24:19,850 --> 00:24:23,440
>> そうだとすれば（N + 1>容量）。今、私はnを説明しましょう​​。

404
00:24:23,440 --> 00:24:26,100
Nは、バッファ内で現在どれだけ多くのバイトです

405
00:24:26,100 --> 00:24:28,620
あなたは現在、ユーザーから構築していることを文字列。

406
00:24:28,620 --> 00:24:33,450
あなたは、バッファの容量を持っているよりもあなたのバッファ内の多くの文字を持っている場合

407
00:24:33,450 --> 00:24:37,410
直感的に私たちが次に何をする必要があるか、より多くの容量を割り当てています。

408
00:24:37,410 --> 00:24:43,330
だから私はここに算数の一部を上に流し読みしてここでしかこの機能に集中するつもりです。

409
00:24:43,330 --> 00:24:46,070
あなたは、malloc関数が何であるかを知っているか、少なくとも一般的によく知られている。

410
00:24:46,070 --> 00:24:48,970
reallocは何をするかを推測するため。 >> [学生]は、メモリを追加します。

411
00:24:48,970 --> 00:24:52,920
それは非常にメモリを追加するわけではありません。それは次のようにメモリを再割り当てします。

412
00:24:52,920 --> 00:24:57,220
あなたにそのメモリをより多く与えるために文字列の末尾の余地はまだあるとすれば

413
00:24:57,220 --> 00:25:00,000
それはもともとあなたを与えるよりも、あなたはその追加のメモリを取得します。

414
00:25:00,000 --> 00:25:03,460
それで、あなたはちょうど背中合わせにし、背中合わせに文字列の文字を入れておくことができます。

415
00:25:03,460 --> 00:25:05,830
それがそうではない場合しかし、あなたはあまりにも長い間待っていたので、

416
00:25:05,830 --> 00:25:07,940
とランダムな何かがあり、メモリにそのまま流してしまった

417
00:25:07,940 --> 00:25:10,290
しかし、余分なメモリがここにあり、それは大丈夫です。

418
00:25:10,290 --> 00:25:13,100
reallocはあなたのためにすべての力仕事をやろうとすると、

419
00:25:13,100 --> 00:25:16,750
あなたがこれまでここからで読んだ文字列を移動し、そこにそれを置く、

420
00:25:16,750 --> 00:25:19,460
そして、その時点であなたにいくつかのより多くの滑走路を与える。

421
00:25:19,460 --> 00:25:22,550
>> だから手を振って、私は何GetStringメソッドが何をしているとしましょう

422
00:25:22,550 --> 00:25:26,330
それは、小さなバッファで多分1つの文字を始めており、

423
00:25:26,330 --> 00:25:30,820
2文字でユーザがタイプした場合と、GetStringメソッドは、呼び出しreallocをしてしまうと言う

424
00:25:30,820 --> 00:25:33,150
1文字では十分ではありませんでした。私に2つの文字を与える。

425
00:25:33,150 --> 00:25:35,950
あなたは、ループのロジックを通読したとすればそれから、それは言おうとしている

426
00:25:35,950 --> 00:25:39,600
3文字で入力したユーザーが、今2を私に与えるものではないが、4文字、

427
00:25:39,600 --> 00:25:42,320
その後、私に8を得、その後、私に16と32を与える。

428
00:25:42,320 --> 00:25:45,000
私は能力を毎回倍増しているという事実

429
00:25:45,000 --> 00:25:48,570
バッファはゆっくりと成長するつもりはないことを意味し、それは超高速の成長になるだろう。

430
00:25:48,570 --> 00:25:51,380
そして、何がその利点になるのでしょうか？

431
00:25:51,380 --> 00:25:54,600
なぜ私は、バッファのサイズを倍増しています

432
00:25:54,600 --> 00:25:58,020
ユーザは単にキーボードから1余分な文字が必要な場合でも？

433
00:25:58,020 --> 00:26:01,750
[聞き取れない生徒の応答] >>これは何ですか？ >> [生徒]あなたはできるだけ頻繁にそれを成長させる必要はありません。

434
00:26:01,750 --> 00:26:03,300
その通りです。あなたは、しばしば、それを成長させる必要はありません。

435
00:26:03,300 --> 00:26:05,510
そして、これはあなたがここにあなたの賭けをヘッジしているだけの種類ですが、

436
00:26:05,510 --> 00:26:10,850
あなたはそれが遅くなる傾向があるため、reallocの多くを呼び出すにしたくないという考え。

437
00:26:10,850 --> 00:26:12,910
あなたは、メモリ用のオペレーティングシステムを尋ねるいつでも

438
00:26:12,910 --> 00:26:16,990
あなたはすぐに将来の問題セットで説明するように、それはいくつかの時間がかかる傾向にある。

439
00:26:16,990 --> 00:26:20,010
だから、あなたには、いくつかのスペースを無駄にしている場合であっても、その時間を最小限に抑える

440
00:26:20,010 --> 00:26:21,900
良いことになる傾向がある。

441
00:26:21,900 --> 00:26:24,060
>> しかし、我々はここでGetStringメソッドの最後の部分を通読したとすれば - 

442
00:26:24,060 --> 00:26:27,950
そして再びここで一つ一つの行を理解することが、今日はそれほど重要ではありません - 

443
00:26:27,950 --> 00:26:30,530
それが最終的に再びmalloc関数を呼び出していることがわかり

444
00:26:30,530 --> 00:26:33,880
それが文字列のために必要として、それは多くのバイトとまったく同じように割り当て

445
00:26:33,880 --> 00:26:38,060
フリー過度に大きなバッファを呼び出すことによって、その後捨てる

446
00:26:38,060 --> 00:26:40,080
それは確かにあまりにも多くの時間を倍増してしまった場合。

447
00:26:40,080 --> 00:26:42,730
だから簡単に言えば、それがGetStringメソッドは、このすべての時間を働いている方法です。

448
00:26:42,730 --> 00:26:47,060
すべてのそれは、何度も何度も、一度に1つの文字を読まれない

449
00:26:47,060 --> 00:26:50,750
それはいくつかの追加のメモリが必要になるたび、それはそれのためにオペレーティング·システムを尋ねる

450
00:26:50,750 --> 00:26:53,670
reallocを呼び出すことによって。

451
00:26:53,670 --> 00:26:57,890
>> 何か質問？かしこまりました。

452
00:26:57,890 --> 00:26:59,270
>> 攻撃。

453
00:26:59,270 --> 00:27:04,060
今、私たちは、ポインタを理解するか、少なくともポインタを持つますます精通していること、

454
00:27:04,060 --> 00:27:06,700
全世界が崩壊し始める方法を検討してみましょう

455
00:27:06,700 --> 00:27:10,030
あなたは非常に敵対的なユーザに対して防御しない場合、

456
00:27:10,030 --> 00:27:11,850
お使いのシステムに侵入しようとしている人々、

457
00:27:11,850 --> 00:27:16,890
いくつかのレジストレーションコードを回避することによって、ソフトウェアを盗もうとしている人

458
00:27:16,890 --> 00:27:19,090
彼らはそうしないとインチ入力が必要になる場合がありますことを

459
00:27:19,090 --> 00:27:22,990
>> ここでは、この例を見てみましょう、下部の主な機能を持っているだけでCのコードである

460
00:27:22,990 --> 00:27:26,380
それは、関数fooを呼び出す。そして、何それはfooに渡しているか？

461
00:27:26,380 --> 00:27:29,680
[学生]単一の引数。 >> [マラン]単一の引数。

462
00:27:29,680 --> 00:27:33,450
ユーザーは、コマンドラインで入力した最初の単語を意味だからargv [1]に、

463
00:27:33,450 --> 00:27:36,360
a.outまたはものは何でもした後にプログラムが呼び出されます。

464
00:27:36,360 --> 00:27:41,680
だから上部にあるfooはchar *型を取り込む。しかし、char *はちょうど何ですか？ >> [生徒]文字列。

465
00:27:41,680 --> 00:27:43,350
[マラン]文字列、何も新しいものはここにありませんので。

466
00:27:43,350 --> 00:27:45,420
その文字列は任意にバーと呼ばれている。

467
00:27:45,420 --> 00:27:51,430
この行では、ここではchar cを[12];半技術英語の並べ替えでは、この行は何をやっている？

468
00:27:51,430 --> 00:27:55,220
の>>配列 - 配列[学生]？ >> [生徒]キャラクター。 >>文字。

469
00:27:55,220 --> 00:27:58,870
私に12文字の配列を与える。だから我々は、このバッファと呼ぶかもしれない。

470
00:27:58,870 --> 00:28:02,920
それは技術的にはCと呼ばれますが、プログラミングのバッファは単にスペースの束を意味している

471
00:28:02,920 --> 00:28:04,800
あなたはいくつかのものをインチ置くことができる

472
00:28:04,800 --> 00:28:07,940
それから最後に、memcpyを我々の前に使用されていませんでしたが、おそらくそれが何をするかを推測することができます。

473
00:28:07,940 --> 00:28:10,480
これは、メモリをコピーします。それは何をしますか？

474
00:28:10,480 --> 00:28:19,270
どうやらこれは、cに、その入力、バーをコピーしますが、唯一のアップバーの長さになります。

475
00:28:19,270 --> 00:28:24,930
しかし、ここでバグがあります。 >> [生徒]あなたは、sizeof文字を必要としています。オーケー。>>

476
00:28:24,930 --> 00:28:30,860
技術的には、私たちは本当に（バー）*はsizeof（char型））をstrlenを行う必要があります。それは正しいです。

477
00:28:30,860 --> 00:28:33,930
しかし、ここでは最悪の場合には、みましょうそれthat'sを想定 - 

478
00:28:33,930 --> 00:28:35,950
オーケー。その後、2つのバグがあります。

479
00:28:35,950 --> 00:28:39,160
だから、はsizeof（char型））;

480
00:28:39,160 --> 00:28:41,290
これは少し広い作ってみましょう。

481
00:28:41,290 --> 00:28:44,910
だから今何かのバグが、まだあります？ >> [聞こえない学生の応答]

482
00:28:44,910 --> 00:28:46,990
何をチェックしますか？ >> [学生]はNULLかどうかをチェックします。

483
00:28:46,990 --> 00:28:50,270
悪いことが起こるので、我々は一般的にnullをチェックすべきである

484
00:28:50,270 --> 00:28:53,200
あなたはそこに行くに終わるかもしれないので、あなたのポインタがNULLの場合、

485
00:28:53,200 --> 00:28:57,630
そしてあなたは今までスター演算子とそれを間接参照してNULLに行くべきではありません。

486
00:28:57,630 --> 00:29:01,050
だからそれは良いことだ。そして、我々は他に何をやっている？論理的には、欠陥があまりにもここにあります。

487
00:29:01,050 --> 00:29:04,450
[学生] argcが> =〜2であるかどうかをチェックします。

488
00:29:04,450 --> 00:29:10,550
argcが> = 2であればそれで確認してください。さて、ここでこのプログラムの3つのバグがあります。

489
00:29:10,550 --> 00:29:16,630
ユーザが実際のargv [1]に何を入力した場合我々は今チェックしています。グッド。

490
00:29:16,630 --> 00:29:20,950
この三番目のバグは何ですか？うん。 >> [生徒] Cの大きさが十分ではないかもしれません。

491
00:29:20,950 --> 00:29:23,320
グッド。我々は、1つのシナリオをチェックしました。

492
00:29:23,320 --> 00:29:29,520
暗黙のうちにチェック私たちはバーの長さを超えてしまうよりも多くのメモリをコピーしないでください。

493
00:29:29,520 --> 00:29:32,510
だから、文字列で入力した場合、ユーザが10文字の長さ、

494
00:29:32,510 --> 00:29:36,020
これは10文字だけコピーを言っている。そして、それは大丈夫です。

495
00:29:36,020 --> 00:29:39,940
ユーザが20文字の単語のようにプロンプ​​トに入力した単語が、どうでしょう？

496
00:29:39,940 --> 00:29:44,900
これは、20文字バーからのものにコピーを言っている？

497
00:29:44,900 --> 00:29:49,750
あなただけのデータを書いたことを意味しそうでなければ我々のバッファと呼ばれるC、A、

498
00:29:49,750 --> 00:29:52,540
あなたが所有していない8バイトの場所に、

499
00:29:52,540 --> 00:29:54,870
そしてあなたがそれらを割り当てられることはないという意味で、それらを所有していない。

500
00:29:54,870 --> 00:30:00,370
だから、これは一般的にバッファオーバーフロー攻撃やバッファオーバーラン攻撃として知られているものです。

501
00:30:00,370 --> 00:30:05,580
そして、それは、ユーザーまたはユーザーの関数を呼び出しているプログラムがあればという意味で攻撃だ

502
00:30:05,580 --> 00:30:10,490
実際に実際には非常に悪いかもしれません次に何が起こるのか、悪意を持ってこれをやっている。

503
00:30:10,490 --> 00:30:12,450
>> それでは、ここでこの絵を見てみましょう。

504
00:30:12,450 --> 00:30:16,060
この画像は、メモリのスタックを表します。

505
00:30:16,060 --> 00:30:19,580
関数を呼び出すたびにスタック上のこの小さなフレームを取得することを思い出してください

506
00:30:19,580 --> 00:30:21,520
その後、別の後、もう一つを。

507
00:30:21,520 --> 00:30:24,300
そしてこれまで、我々はこれらの四角形としてだけの種類抽象化しました

508
00:30:24,300 --> 00:30:26,290
ボード上またはここに画面上のいずれか。

509
00:30:26,290 --> 00:30:30,580
しかし、我々はあなたが関数fooを呼び出すときに、これらの矩形の一つにズームインした場合、

510
00:30:30,580 --> 00:30:35,880
その四角形の中にそのフレームのスタック内部の詳細があることが判明

511
00:30:35,880 --> 00:30:40,060
より我々はスワップの話でしたと同じように、xとyとaとb、。

512
00:30:40,060 --> 00:30:44,410
これは、いくつかの低レベルの詳細は、返信先のアドレスが、中でもがあることが判明した。

513
00:30:44,410 --> 00:30:49,550
メインは、fooを呼び出したときにだからそれは結局、メインは、fooを通知しなければならない

514
00:30:49,550 --> 00:30:53,520
何をメインのアドレスをコンピュータのメモリ内にある

515
00:30:53,520 --> 00:30:57,770
そうしないとするので、できるだけ早くfooとして、ここでは、この場合のように、実行が終了

516
00:30:57,770 --> 00:31:00,830
一度、fooの終わりにこの閉じ波括弧を達成

517
00:31:00,830 --> 00:31:05,310
プログラムの制御が行くことになっている場所fooは一体どのようにして知るのでしょうか？

518
00:31:05,310 --> 00:31:08,970
それは、その質問への答えがここにこの赤い四角形の中にあることが判明した。

519
00:31:08,970 --> 00:31:12,670
これは、ポインタを表し、それが一時的に格納するためにコンピュータにかかっている

520
00:31:12,670 --> 00:31:17,030
いわゆるスタック上でそのようにすぐにfooのようなメインのアドレスは、実行が終了すると、

521
00:31:17,030 --> 00:31:21,120
コンピュータはどこに戻ってメインのどの行を知っています。

522
00:31:21,120 --> 00:31:23,940
保存されたフレーム·ポインタは、これに同様に関する。

523
00:31:23,940 --> 00:31:26,310
ここでのchar *バーは何を表して？

524
00:31:26,310 --> 00:31:31,350
今ここにこの青セグメントは、fooのフレームです。バーとは何ですか？

525
00:31:31,570 --> 00:31:35,010
バーは単にfoo関数の引数である。

526
00:31:35,010 --> 00:31:37,500
だから今我々は、おなじみの絵のようなものに戻っています。

527
00:31:37,500 --> 00:31:39,850
画面上でより多くのものや、その他の気晴らしは、あります

528
00:31:39,850 --> 00:31:43,380
しかし、この水色のセグメントはちょうど私達が黒板に描いてきたものです

529
00:31:43,380 --> 00:31:45,790
スワップのような何かのために。それはfooのフレームです。

530
00:31:45,790 --> 00:31:51,490
そしてその中に唯一のものは、今すぐこのパラメータであるバーです。

531
00:31:51,490 --> 00:31:55,220
しかし、ほかに何かここでは、このコードに応じてスタックにあるべきですか？

532
00:31:55,220 --> 00:31:57,760
[学生] char cを[12]。 >> [マラン] char cを[12]。

533
00:31:57,760 --> 00:32:02,810
我々はまた、cという変数に割り当てられたメモリの12乗が表示されるはずです

534
00:32:02,810 --> 00:32:04,970
と確かに我々は、画面上にそれを持っている。

535
00:32:04,970 --> 00:32:08,480
この図のc [0]、その後、著者はそこにある非常にトップ

536
00:32:08,480 --> 00:32:11,850
正方形のすべてを描く気にしますが、12は、そこに確かに存在していなかった

537
00:32:11,850 --> 00:32:16,590
なぜならあなたは右下を見れば、C [11]あなたは0から数えると12日、このようなバイトです。

538
00:32:16,590 --> 00:32:18,400
しかし、ここが問題なのです。

539
00:32:18,400 --> 00:32:22,390
どの方向にcが成長しているのか？

540
00:32:22,390 --> 00:32:27,080
トップダウンの並べ替え、それが一番上から開始して、下方に大きくなってしまった場合。

541
00:32:27,080 --> 00:32:30,110
それはここにすべての私達が私達自身をはるかに滑走路を左のように見えない。

542
00:32:30,110 --> 00:32:32,090
私達は種類の隅に自分自身を描いた、

543
00:32:32,090 --> 00:32:36,940
とすることは、c [11]、[保存されたフレームポインタに対して右にあるバーに対して右にある

544
00:32:36,940 --> 00:32:39,960
これは、リターンアドレスに対して右のアップです。以上の余地はありません。

545
00:32:39,960 --> 00:32:42,810
あなたが台無しにしそうだとすれば意味は、その後何

546
00:32:42,810 --> 00:32:46,500
そしてあなたは、12バイトのバッファに20バイトを読んでみてください？

547
00:32:46,500 --> 00:32:50,060
どこでそれらの追加の8バイトは行くつもりですか？ >> [生徒]インサイド - 

548
00:32:50,060 --> 00:32:53,200
他のすべての内部では、そのうちのいくつかは超重要です。

549
00:32:53,200 --> 00:32:57,260
そして最も重要なことは、潜在的に、そこに赤いボックス、リターンアドレスです

550
00:32:57,260 --> 00:33:03,560
なぜなら、あなたはどちらかが誤ってまたはadversariallyそれらの4バイトが上書きされることを仮定する

551
00:33:03,560 --> 00:33:07,260
ゴミではなく番号を持つだけでなく、そのポインタアドレスは、

552
00:33:07,260 --> 00:33:09,810
それは、メモリ内に実際のアドレスを表すために起こります。

553
00:33:09,810 --> 00:33:13,880
論理的含意は、何ですか？ >> [生徒]機能は、別の場所に戻るために起こっている。

554
00:33:13,880 --> 00:33:15,250
その通りです。

555
00:33:15,250 --> 00:33:19,170
ときにfooが戻ると中括弧、プログラムを続行しようとしていることをヒット

556
00:33:19,170 --> 00:33:25,060
メインに戻らない、それはその赤いボックスにあるもののアドレスに戻すために起こっている。

557
00:33:25,060 --> 00:33:28,600
>> ソフトウェアの登録を回避する場合には、

558
00:33:28,600 --> 00:33:32,260
に戻されているアドレスが正常に呼び出される関数である場合はどうでしょう

559
00:33:32,260 --> 00:33:35,690
後には、ソフトウェアの代金を払った登録コードを入力してきた？

560
00:33:35,690 --> 00:33:39,870
あなたは、ここに行くのではなくここに上がっていませんだましのコンピュータを並べ替えることができます。

561
00:33:39,870 --> 00:33:45,100
あなたが本当に賢いなら、または、敵は実際には、例えば、キーボードから入力することもできます

562
00:33:45,100 --> 00:33:50,690
はなく、実際の単語ではなく、20文字が、彼または彼女は、実際にタイプであるとし

563
00:33:50,690 --> 00:33:52,770
コー​​ドを表すいくつかの文字。

564
00:33:52,770 --> 00:33:55,320
そして、それはCコードであることを行っていない、それは実際に文字になるだろう

565
00:33:55,320 --> 00:33:59,290
それは0と1のバイナリマシンコードを表しています。

566
00:33:59,290 --> 00:34:01,290
しかし、彼らはそれを行うのに十分賢いと仮定している

567
00:34:01,290 --> 00:34:06,500
どうにかして、本質的に、コンパイルされたコードですGetStringメソッドプロンプト何かに貼り付けるには、

568
00:34:06,500 --> 00:34:09,980
そして最後の4バイトには、そのリターンアドレスを上書きします。

569
00:34:09,980 --> 00:34:13,360
そして、その入力は、どのようなアドレスをしますか？

570
00:34:13,360 --> 00:34:18,630
これは、実際にこの赤い四角形でバッファの先頭バイトのアドレスを格納します。

571
00:34:18,630 --> 00:34:23,070
だから、あなたは本当に賢いことがあり、これはそこに悪い人のために多くの試行錯誤です

572
00:34:23,070 --> 00:34:25,639
しかし、あなたは、このバッファがどの程度の大き把握することができます

573
00:34:25,639 --> 00:34:28,820
入力の最後の数バイトはプログラムに提供するよう

574
00:34:28,820 --> 00:34:33,540
あなたのバッファの先頭のアドレスに相当することが起こる、あなたはこれを行うことができます。

575
00:34:33,540 --> 00:34:39,320
我々は通常、helloと\ 0と言うなら、それはバッファで終わるものだ。

576
00:34:39,320 --> 00:34:44,420
しかし、我々はもっと巧妙なていると我々は我々が一般的に攻撃コードを呼んでいるもので、そのバッファを埋める場合 - 

577
00:34:44,420 --> 00:34:48,860
AAA、攻撃、攻撃、攻撃 - これはちょうど悪い何かを何かである、

578
00:34:48,860 --> 00:34:51,820
あなたが本当に賢いなら何が起こるか、あなたはこれを行うことがあります。

579
00:34:51,820 --> 00:34:58,610
80、C0、35、08  - ここに赤いボックスに数字のシーケンスです。

580
00:34:58,610 --> 00:35:01,610
それがここまでの番号と一致していることに注意してください。

581
00:35:01,610 --> 00:35:04,430
それは逆の順序でですが、そのいくつかの他の時間について。

582
00:35:04,430 --> 00:35:08,140
このリターンアドレスは故意に変更されていることに注意してください

583
00:35:08,140 --> 00:35:12,020
ここにアドレスを等しくなるように、メインのアドレスではなく。

584
00:35:12,020 --> 00:35:17,500
悪者がスーパースマートがないような場合は、彼または彼女は、その攻撃コードに含めるとしている

585
00:35:17,500 --> 00:35:20,930
ユーザのすべてのファイルを削除したり、パスワードをコピーするようなもの

586
00:35:20,930 --> 00:35:24,680
全く何の関係 - または私はその後にログインできるユーザアカウントを作成してください。

587
00:35:24,680 --> 00:35:26,950
>> そして、これは危険とCの電力の両方です

588
00:35:26,950 --> 00:35:29,840
あなたは、ポインタを介して、メモリへのアクセスを持っているので、

589
00:35:29,840 --> 00:35:32,520
そしてあなたは、したがって、コンピュータのメモリに必要な何かを書くことができます

590
00:35:32,520 --> 00:35:35,080
あなたは、コンピュータがあなたがしたいことは何でも作ることができる

591
00:35:35,080 --> 00:35:39,550
単にそれが自分のメモリ空間内で飛び回る持っていることによって。

592
00:35:39,550 --> 00:35:44,650
それで、この日に多くのプログラムや危険にさらされますので、多くのウェブサイトがそう

593
00:35:44,650 --> 00:35:46,200
これを活用して人々になるまで煮詰める。

594
00:35:46,200 --> 00:35:50,760
そして、これは超洗練された攻撃のように思えるかもしれないが、それは常にそのように起動しません。

595
00:35:50,760 --> 00:35:53,560
現実には、何が悪いの人は一般的に尽くすことであるということです

596
00:35:53,560 --> 00:35:58,200
それは、コマンドラインまたはGUIのプログラムやウェブサイトでのプログラムであるかどうか、

597
00:35:58,200 --> 00:35:59,940
あなただけのナンセンスの提供を開始。

598
00:35:59,940 --> 00:36:03,980
あなたは、検索フィールドに本当に大きなワードに入力し、Enterキーを打つ

599
00:36:03,980 --> 00:36:05,780
そしてあなたは、ウェブサイトがクラッシュした場合に参照するのを待つ

600
00:36:05,780 --> 00:36:09,990
またはプログラムは、いくつかのエラーメッセージを表示したときはを参照するのを待つ

601
00:36:09,990 --> 00:36:14,330
あなたが悪者のように幸運を得るとした場合には、いくつかのクレイジーな入力を提供するため、

602
00:36:14,330 --> 00:36:18,980
つまり、プログラマがあなたの悪い行動を予想していなかったことを意味し、プログラムをクラッシュ

603
00:36:18,980 --> 00:36:23,630
これは、あなたが十分な努力、十分な裁判とエラーでおそらくできることを意味し、

604
00:36:23,630 --> 00:36:26,650
より正確な攻撃を遂行する方法を見つけ出す。

605
00:36:26,650 --> 00:36:31,410
セキュリティのために、多くの部分はちょうど完全に、これらの攻撃を回避されていません

606
00:36:31,410 --> 00:36:34,100
しかし、それらを検出して、実際にログを見る

607
00:36:34,100 --> 00:36:36,780
と狂気の入力があなたのウェブサイトに入力された人々を持っているものを見て、

608
00:36:36,780 --> 00:36:38,960
どんな検索語があなたのウェブサイトに人々を入力した

609
00:36:38,960 --> 00:36:42,870
いくつかのバッファがオーバーフローした場合の期待インチ

610
00:36:42,870 --> 00:36:45,500
そして、このつまるところ配列に何のシンプルな基本に

611
00:36:45,500 --> 00:36:49,080
そして何でメモリを割り当てて使用することを意味しません。

612
00:36:49,080 --> 00:36:51,710
>> その後、あまりにこれはに関連していた。

613
00:36:51,710 --> 00:36:54,280
もう一度だけまだハードドライブの内部に一瞥してみましょう。

614
00:36:54,280 --> 00:36:58,440
あなたは、あなたのごみ箱またはごみ箱にファイルをドラッグすると、その一週間か二週間前からリコール

615
00:36:58,440 --> 00:37:03,710
何が起こるか？ >> [生徒]ありません。 >>絶対に何も、右か？

616
00:37:03,710 --> 00:37:05,740
最終的には、ディスク容量が不足する場合は、

617
00:37:05,740 --> 00:37:08,190
WindowsやMac OSはあなたのためのファイルの削除が開始されます。

618
00:37:08,190 --> 00:37:10,390
あなたはそこに何かをドラッグした場合しかし、それはすべて安全ではありません。

619
00:37:10,390 --> 00:37:13,800
すべてのあなたのルームメイトや友人や家族がしなければならないことは、ダブルクリックすると、ほら、さ

620
00:37:13,800 --> 00:37:16,310
削除しようとしたすべての大ざっぱなファイルがあります。

621
00:37:16,310 --> 00:37:19,590
私たちのほとんどは、少なくとも、あなたは右クリックをクリックするか、コントロールしなければならないことを知っている

622
00:37:19,590 --> 00:37:22,310
やゴミまたはそのような何かを空にします。

623
00:37:22,310 --> 00:37:25,000
しかし、それでもかなりのトリックをしようとしないこと

624
00:37:25,000 --> 00:37:28,010
あなたのハードドライブ上のファイルを持っているときに何が起こるので、

625
00:37:28,010 --> 00:37:32,770
、それはいくつかのWord文書やJPEGの一部を表し、これは、あなたのハードドライブを表す

626
00:37:32,770 --> 00:37:35,350
としてみましょうここでは、このスライバーは、そのファイルを表すと言う

627
00:37:35,350 --> 00:37:38,390
そしてそれは0と1の全体の束で構成さている。

628
00:37:38,390 --> 00:37:42,470
あなただけでなく、缶やごみ箱ごみ箱にそのファイルをドラッグしたときに何が起こる

629
00:37:42,470 --> 00:37:48,020
だけでなく、それを空にする？何の並べ替え。

630
00:37:48,020 --> 00:37:49,640
それが今では絶対に何もしないではありません。

631
00:37:49,640 --> 00:37:54,290
少し何かがこの表の形で行われるため、今ではただ何もない。

632
00:37:54,290 --> 00:37:58,370
だから、コンピュータのメモリの内部データベースまたはテーブルのいくつかの種類があり

633
00:37:58,370 --> 00:38:03,850
それは本質的に、ファイルごとに1つの列の名前とファイルごとに1つの列 'の場所を持っている

634
00:38:03,850 --> 00:38:07,720
これはどこの場所123、ただの乱数かもしれない。

635
00:38:07,720 --> 00:38:14,560
だから我々はx.jpegと位置123のような何かを持っているかもしれません。

636
00:38:14,560 --> 00:38:18,800
あなたが実際にあなたのゴミ箱を空にすると次に何が起こる？

637
00:38:18,800 --> 00:38:20,330
消えている。

638
00:38:20,330 --> 00:38:23,610
しかし、どのようななくならないことは、0と1です。

639
00:38:23,610 --> 00:38:26,270
>> だからpset4への接続は、次に何ですか？

640
00:38:26,270 --> 00:38:31,240
さて、pset4で、ちょうど我々は誤ってコンパクトフラッシュカードを消去してきたので、

641
00:38:31,240 --> 00:38:35,750
これらの写真のすべてを持っていたか、それは不運によって破損したからといって、その

642
00:38:35,750 --> 00:38:38,000
0と1が残っていないことを意味するものではありません。

643
00:38:38,000 --> 00:38:40,410
何かが壊れてしまったので、たぶん、それらのいくつかは失われ

644
00:38:40,410 --> 00:38:43,320
いくつかの0が1秒になったと1が0になったという意味で。

645
00:38:43,320 --> 00:38:47,240
バギーソフトウェアまたはハードウェアの欠陥のために悪いことが起こる可能性があります。

646
00:38:47,240 --> 00:38:50,370
しかし、それらの100％であっても多分、これらのビットの多くがまだ残っている。

647
00:38:50,370 --> 00:38:55,050
それはJPEG1が出発したところパソコンやカメラが知らないだけだ

648
00:38:55,050 --> 00:38:56,910
どこJPEG2が開始されました。

649
00:38:56,910 --> 00:39:01,070
しかし、あなたならば、プログラマは、それらのJPEGファイルである精通のビットを知っている

650
00:39:01,070 --> 00:39:06,010
またはどのような彼らはあなたが0と1を分析して、JPEG、JPEGを言うことができるので、次のようになり、

651
00:39:06,010 --> 00:39:09,440
あなたの仕事は、基本的にforやwhileループを使用してプログラムを書くことができます

652
00:39:09,440 --> 00:39:12,820
それは、それらのファイルのそれぞれを回復します。

653
00:39:12,820 --> 00:39:16,030
レッスンは、その後しっかりとあなたのファイルの消去を開始することであるので、

654
00:39:16,030 --> 00:39:18,340
あなたは完全にこの問題を回避したい場合。はい。

655
00:39:18,340 --> 00:39:21,010
>> [学生]どのように来る、それはあなたのコンピュータ上で言う

656
00:39:21,010 --> 00:39:23,550
あなたは以前よりも多くのメモリを持っている？

657
00:39:23,550 --> 00:39:27,820
あなたが前にしたよりも多くのメモリを持っている -  >>【学生】より利用可能なメモリ。

658
00:39:27,820 --> 00:39:29,630
ああ。良い質問です。

659
00:39:29,630 --> 00:39:32,360
それではどうしてゴミ箱を空にした後、コンピュータはあなたを教えてくれません

660
00:39:32,360 --> 00:39:34,910
あなたは以前よりも多くの空き容量があることを？

661
00:39:34,910 --> 00:39:36,770
一言で言えば、それは嘘をついているからです。

662
00:39:36,770 --> 00:39:40,740
より技術的に、あなたが今あなたが言っているので、より多くのスペースを持っている

663
00:39:40,740 --> 00:39:43,680
そのファイルは、かつて他のものを置くことができます。

664
00:39:43,680 --> 00:39:45,450
しかし、それは、ビットが離れて行くという意味ではありません

665
00:39:45,450 --> 00:39:48,590
そしてそれは、ビットは、例えば、すべて0に変更されているという意味ではありません

666
00:39:48,590 --> 00:39:50,150
あなたの保護のため。

667
00:39:50,150 --> 00:39:54,640
だからこれとは対照的に、ファイルを安全に消去するか、デバイスを物理的に破壊する場合、

668
00:39:54,640 --> 00:39:57,300
それは本当にその周りに時々唯一の方法です。

669
00:39:57,300 --> 00:40:02,020
>> では、なぜ我々はその半怖いノートに残していない、と我々は月曜日にお会いしましょう​​。

670
00:40:02,020 --> 00:40:07,000
[拍手]

671
00:40:07,780 --> 00:40:10,000
>> [CS50.TV]