1
00:00:00,000 --> 00:00:10,970
>> [音楽再生]

2
00:00:10,970 --> 00:00:12,536
>> DAVID J.マラン：すべての権利。

3
00:00:12,536 --> 00:00:13,392
>> [笑い]

4
00:00:13,392 --> 00:00:14,240
>> お帰りなさい。

5
00:00:14,240 --> 00:00:14,990
これはCS50です。

6
00:00:14,990 --> 00:00:16,890
そして、今週5の終わり。

7
00:00:16,890 --> 00:00:20,020
そして、今まで、我々はほとんどをしました
当たり前の服用しているそこに

8
00:00:20,020 --> 00:00:23,480
あなたがしたこのコンパイラ、Clangのは、存在している
これにより自されて

9
00:00:23,480 --> 00:00:27,100
他のツールは、その何とかしてくださいと呼ばれる
魔法のようにソースコードを変換します

10
00:00:27,100 --> 00:00:31,350
オブジェクトコード、0と1に
そのコンピュータのCPU、中央

11
00:00:31,350 --> 00:00:33,410
処理装置、実際に理解しています。

12
00:00:33,410 --> 00:00:36,770
の番号があるうちが、それは変わり
でボンネットの下で起こって

13
00:00:36,770 --> 00:00:38,690
入力と出力の間である。

14
00:00:38,690 --> 00:00:41,800
>> そして、私は我々が肉を提案したいと思います
にもう少し詳細にその出

15
00:00:41,800 --> 00:00:45,130
これらの4つのステップ、と呼ばれるものを持っている
前処理、何か

16
00:00:45,130 --> 00:00:48,300
我々が見てきたコンパイル、、と呼ばれる
何かが組み立てと呼ばれ、

17
00:00:48,300 --> 00:00:49,420
何かは、リンクと呼ばれる。

18
00:00:49,420 --> 00:00:53,270
だから今まで、我々の一部で
プログラムは、我々はシャープを持っていた含まれています。

19
00:00:53,270 --> 00:00:56,650
さらに最近では我々はいくつかのシャープを持っていた
定数に定義されています。

20
00:00:56,650 --> 00:01:00,660
だから、そのそれらのものと判明
ハッシュ記号が付いているか

21
00:01:00,660 --> 00:01:04,150
シャープ記号は、プリプロセッサである
ディレクティブ。

22
00:01:04,150 --> 00:01:07,960
それはちょうどそれが言っての派手な方法だ
実際のコードの行

23
00:01:07,960 --> 00:01:12,280
前に何か他のものに変換
コンピュータも、あなたを変換しよう

24
00:01:12,280 --> 00:01:13,800
0と1にプログラム。

25
00:01:13,800 --> 00:01:19,000
>> たとえば、シャープは、標準的な含まれています
I / O。hは、かなり単に行く意味

26
00:01:19,000 --> 00:01:24,010
先に、ファイルの内容をつかむ
stdio.hに、右そこに貼り付けます。

27
00:01:24,010 --> 00:01:25,880
ない0と1だから
その時点ではまだ。

28
00:01:25,880 --> 00:01:27,470
それは本当にただ置換だ。

29
00:01:27,470 --> 00:01:30,790
そして、それは、いわゆる中に行われている
前処理段階では、ときに

30
00:01:30,790 --> 00:01:34,230
実際に特にClangのを実行したり、
ほとんどの場合にしてください。

31
00:01:34,230 --> 00:01:36,950
だから、このすべてが起こっている
最初に自動的にこれまで。

32
00:01:36,950 --> 00:01:38,800
>> その後、コンパイル手順が来る。

33
00:01:38,800 --> 00:01:40,920
しかし、我々は、単純化してきた
コンパイル。

34
00:01:40,920 --> 00:01:45,060
プログラムをコンパイルすると、本当にに意味
、C言語のようなものからそれを取る

35
00:01:45,060 --> 00:01:48,430
ソースコードは、我々がダウンして、書いてきた
アセンブリと呼ばれるものに。

36
00:01:48,430 --> 00:01:52,900
アセンブリ言語は低レベルです
ありがたいことに、私たちはしませんが、言語

37
00:01:52,900 --> 00:01:55,480
あまりする機会た
この学期を書きます。

38
00:01:55,480 --> 00:01:59,100
しかし、それは中で最低レベルだ
あなたは文字通り、書き込みを開始するという意味

39
00:01:59,100 --> 00:02:04,270
加算および減算と乗算とロード
メモリからメモリへの保存、

40
00:02:04,270 --> 00:02:08,259
非常に基本的な命令を、そのコンピュータ、
ボンネットの下に、

41
00:02:08,259 --> 00:02:09,639
実際に理解しています。

42
00:02:09,639 --> 00:02:14,930
>> 最後に、組み立ては、その言語を取り
我々がしてきたことを0と1に

43
00:02:14,930 --> 00:02:16,190
これまで記述した。

44
00:02:16,190 --> 00:02:19,270
そして本当に最後に、いわゆるあり
段階を結ぶ、その我々はよ

45
00:02:19,270 --> 00:02:22,360
組み合わせたちょっと、に表示
あなたのゼロとゼロを持つものと

46
00:02:22,360 --> 00:02:24,870
ものを他の人々の前に
あなたが作成した。

47
00:02:24,870 --> 00:02:26,660
>> だから、このスーパー簡単なプログラムを検討してください。

48
00:02:26,660 --> 00:02:27,560
これは、第1週からだった。

49
00:02:27,560 --> 00:02:29,610
それはちょうど、世界こんにちは、言った
画面上で。

50
00:02:29,610 --> 00:02:30,920
私たちは、Clangのを介してこれを実行しました。

51
00:02:30,920 --> 00:02:33,200
または我々は確認を通じてそれを実行しました
どのClangのを実行しました。

52
00:02:33,200 --> 00:02:36,170
どこで同時に出力
いくつかの0と1。

53
00:02:36,170 --> 00:02:38,100
そこうちしかし、それは変わり
中間段階。

54
00:02:38,100 --> 00:02:40,460
私はこっちに行けば - おっと、しませんでした
まだ彼を見たいと思っています。

55
00:02:40,460 --> 00:02:44,800
私はアプライアンスにこっちに行けば
と私はここに、hello.cをを開く

56
00:02:44,800 --> 00:02:46,160
その同じプログラムである。

57
00:02:46,160 --> 00:02:48,600
そして、私は私の端末でやろうとしているもの
ここでウィンドウが私はするつもりださ

58
00:02:48,600 --> 00:02:51,430
Clangのを実行するのではなく、作る、その
の4つのすべてを自動化

59
00:02:51,430 --> 00:02:52,870
私たちのためにこれらのステップ。

60
00:02:52,870 --> 00:02:58,620
そして、私は打ち鳴らす-Sを実行するつもりだと
入力しhello.cをした後。

61
00:02:58,620 --> 00:03:00,590
>> そして、私は点滅するプロンプトが表示され
再び、これは良いです。

62
00:03:00,590 --> 00:03:05,280
そして今、大きめのウィンドウで、
私はここでgeditのを開くつもりです。

63
00:03:05,280 --> 00:03:09,610
そして私は、そのファイルを開くつもりだ
これはhello.s呼ばれ、判明

64
00:03:09,610 --> 00:03:11,870
そのアセンブリ言語が含まれています
私は以前に言及した。

65
00:03:11,870 --> 00:03:15,060
そして、これは、アセンブリと呼ばれるものです。
言語、かなり低レベル

66
00:03:15,060 --> 00:03:18,470
インテルCPUその指示
または何でもそれは内部にあるということです

67
00:03:18,470 --> 00:03:19,350
理解しています。

68
00:03:19,350 --> 00:03:24,480
とmovファイルは、移動のためのものです。呼び出しは、のためである
、非常に低レベル関数を呼び出す。

69
00:03:24,480 --> 00:03:26,380
サブは、減算のためのものです。

70
00:03:26,380 --> 00:03:30,370
>> ですから、内部特定のCPUを持っているとき
お使いのコンピュータから、何がそれを作る

71
00:03:30,370 --> 00:03:34,300
上の明瞭なのに対し、他のCPU
市場では、されている命令をそれ

72
00:03:34,300 --> 00:03:39,460
それは理解し、多くの場合、どのように効率的な
それはいくつかを実行するにはどのように高速であり、

73
00:03:39,460 --> 00:03:40,380
これらの命令の。

74
00:03:40,380 --> 00:03:45,150
これについての詳細のために今、あなたが取ることができます
大学で次の秋CS61。

75
00:03:45,150 --> 00:03:48,170
しかし、ここでは、例えば、いくつかを持っている
見覚えがあるかもしれない識別子。

76
00:03:48,170 --> 00:03:50,150
hello.cのは、プログラムの名前です。

77
00:03:50,150 --> 00:03:51,070
>> 。テキスト - 

78
00:03:51,070 --> 00:03:54,190
関心の多くはそこではありません
ちょうど今、そのテキストをリコール

79
00:03:54,190 --> 00:03:59,190
どこでセグメントは、月曜日の時点で、ある
メモリは、プログラムが実際に終わる。

80
00:03:59,190 --> 00:04:01,330
だから、少なくとも漠然とだ
そこにおなじみ。

81
00:04:01,330 --> 00:04:03,730
ここでは、当然のことながら、記載され
私たちの主な機能の。

82
00:04:03,730 --> 00:04:07,220
下にスクロールし、これらは物事を参照してください
レジスタと呼ばれる、非常に小さなチャンク

83
00:04:07,220 --> 00:04:09,190
あなたの実際のCPUの内部メモリ。

84
00:04:09,190 --> 00:04:12,930
と私も下にスクロールした場合
さらに、私はいくつかの並べ替えを参照してください

85
00:04:12,930 --> 00:04:14,240
ASCIIの間接的な言及。

86
00:04:14,240 --> 00:04:17,120
そして、確かに、その文字列があり、
こんにちは、カンマ、世界。

87
00:04:17,120 --> 00:04:20,079
>> だから長い話短い、これはされてい
、自動的にあなたのために何が起こって

88
00:04:20,079 --> 00:04:22,140
ボンネットの下に、このすべての時間。

89
00:04:22,140 --> 00:04:26,450
そして、一度で本当に何が起こっている
あなたは、またはの方法でClangのを実行した

90
00:04:26,450 --> 00:04:29,150
は、最初に取得している、してください
ソースコードから、

91
00:04:29,150 --> 00:04:30,700
いわゆるアセンブリ言語。

92
00:04:30,700 --> 00:04:35,210
次にClangのこのアセンブリに変換されます
ダウンして0と1に言語。

93
00:04:35,210 --> 00:04:38,340
そして、これは我々が開始したことをスライドで
上の0週での議論 - 

94
00:04:38,340 --> 00:04:39,840
その後に週1。

95
00:04:39,840 --> 00:04:44,030
そして最後に、これらの0と1
0と1と組み合わせて

96
00:04:44,030 --> 00:04:47,190
私たちが取ってきたこれらのライブラリから
標準I / O等を付与するため

97
00:04:47,190 --> 00:04:50,010
文字列ライブラリ、あるいは
CS50ライブラリ。

98
00:04:50,010 --> 00:04:54,200
>> だから、もっとこの絵を描くために
視覚的に、我々はhello.cを持っている。

99
00:04:54,200 --> 00:04:57,220
それは、もちろん、printfのを使用して
言うべき機能、こんにちは世界。

100
00:04:57,220 --> 00:05:01,810
コンパイルのステップはそれを取る
そのファイル我々だけであっても、hello.sを見た

101
00:05:01,810 --> 00:05:04,290
一般的に削除されたことだけど
自動的にあなたのために。

102
00:05:04,290 --> 00:05:06,050
しかし、それはアセンブリコードです
途中工程において

103
00:05:06,050 --> 00:05:09,750
そして、我々は、アセンブリを組み立てるとき
いわば言語、、あなたです

104
00:05:09,750 --> 00:05:10,830
これらの0と1を取得します。

105
00:05:10,830 --> 00:05:13,920
だから私たちは、今日効果的にズームしました
我々は当然のことと取ってきたもの、

106
00:05:13,920 --> 00:05:16,430
ソースコードに行く意味
コー​​ドをオブジェクトに提供します。

107
00:05:16,430 --> 00:05:18,850
>> しかし、最後に、今では同じ画像 - 
それを上に突き出すましょう

108
00:05:18,850 --> 00:05:20,020
左側。

109
00:05:20,020 --> 00:05:22,880
そして、そこのトップであることに注意してください
私はstdio.hに言及した。

110
00:05:22,880 --> 00:05:25,030
それは我々が含まれてきたファイルだ
ほとんどすべての内

111
00:05:25,030 --> 00:05:26,250
我々が書いたプログラム。

112
00:05:26,250 --> 00:05:28,830
そして、それは、その内容、ファイルの
コピー貼り付けを取得、

113
00:05:28,830 --> 00:05:30,350
効果的にあなたのコードの上に。

114
00:05:30,350 --> 00:05:34,170
しかし、それは、コンピュータ上で判明
システムのどこか、おそらくそこ

115
00:05:34,170 --> 00:05:39,150
誰かが年書いたstdio.cファイル
前のすべてを実装する

116
00:05:39,150 --> 00:05:41,870
宣言された機能
stdio.hにした。

117
00:05:41,870 --> 00:05:45,465
>> 今、現実にはでないでしょう
あるいは中にお使いのMacまたはPC

118
00:05:45,465 --> 00:05:47,660
CS50アプライアンスは、生のCコードです。

119
00:05:47,660 --> 00:05:52,710
誰かがすでにそれをコンパイルし、含まれている
。Oオブジェクトコードのファイルまたは。

120
00:05:52,710 --> 00:05:56,020
共有ライブラリを参照するファイル、
それは、プリインストールされていると

121
00:05:56,020 --> 00:05:57,240
あなたのためにプリコンパイル。

122
00:05:57,240 --> 00:06:01,950
しかし、確かに存在すると仮定
並行して、当社のコンピュータstdio.c上

123
00:06:01,950 --> 00:06:02,650
Clangのと。

124
00:06:02,650 --> 00:06:04,960
あなたのコードがコンパイルされている
と組み立て。

125
00:06:04,960 --> 00:06:09,200
stdio.cのコードがコンパイルされており、
組み立てられたので、この非常に最後の

126
00:06:09,200 --> 00:06:13,730
ステップは、ダウンしてここで、私たちは何とかしなければならない
リンク、いわば、あなたの0と1

127
00:06:13,730 --> 00:06:18,430
一つに彼または彼女の0と1との
最終的には、単純なプログラム

128
00:06:18,430 --> 00:06:20,540
こんにちはだけ呼ばれる。

129
00:06:20,540 --> 00:06:23,340
>> だからです魔法のすべてです
これまで起こって。

130
00:06:23,340 --> 00:06:26,430
そして、これらを取るしていきます
付与するためのプロセスですが、実現する

131
00:06:26,430 --> 00:06:28,750
ジューシーな詳細の多くはあり
そこの下に行く。

132
00:06:28,750 --> 00:06:31,920
そして、これはあなたが作るものです
インテルの内側を備えたコンピュータ

133
00:06:31,920 --> 00:06:33,940
特に異なる。

134
00:06:33,940 --> 00:06:37,020
>> だから、そのノートに、あなたがしたい場合
今週の金曜日にランチにご参加、行くのですか

135
00:06:37,020 --> 00:06:41,570
いつもの場所のcs50.net/rsvpに、
13:15今週の金曜日。

136
00:06:41,570 --> 00:06:43,400
そして今、いくつかの発表。

137
00:06:43,400 --> 00:06:44,670
だから我々はいくつかの良いニュースを持っている。

138
00:06:44,670 --> 00:06:45,970
そして、私たちはいくつかの悪いニュースがある。

139
00:06:45,970 --> 00:06:47,260
ここでいくつかの良いニュースを開始します。

140
00:06:47,260 --> 00:06:52,038

141
00:06:52,038 --> 00:06:54,510
>> [うめき]を

142
00:06:54,510 --> 00:06:54,710
>> わかりました。

143
00:06:54,710 --> 00:06:56,670
まあ、それはそう、技術的には休日だ
それはそんなに私たちからの贈り物ではありません。

144
00:06:56,670 --> 00:06:58,030
もちろん、しかし、その後、悪いニュース。

145
00:06:58,030 --> 00:07:00,550

146
00:07:00,550 --> 00:07:01,880
>> [うめき]を

147
00:07:01,880 --> 00:07:03,530
>> 私は多くの時間を費やし
これらのアニメーションに。

148
00:07:03,530 --> 00:07:04,690
>> [笑い]

149
00:07:04,690 --> 00:07:07,000
>> レビューセッションがあります
これは月曜日来る。

150
00:07:07,000 --> 00:07:08,340
それは17:30になるだろう。

151
00:07:08,340 --> 00:07:11,210
我々は、すべてのこれらの詳細を思い出させます
当然の上で電子メール経由で

152
00:07:11,210 --> 00:07:13,470
日の時間だけのカップルでWebサイト。

153
00:07:13,470 --> 00:07:16,610
これは、撮影し利用できるようになります
その後まもなく。

154
00:07:16,610 --> 00:07:19,200
あなたはその月曜日作ることができないのであれば
夜のスロットは、心配しないでください。

155
00:07:19,200 --> 00:07:22,270
のセクションでは、この来週にもなります
クイズのためにレビューに焦点を当てています。

156
00:07:22,270 --> 00:07:25,670
あなたのセクションでは、ある月曜日にある場合
確かに大学の休日、我々は

157
00:07:25,670 --> 00:07:26,920
まだセクションで会う。

158
00:07:26,920 --> 00:07:28,890
あなたは、単にそれを作ることができない場合
あなたが行っているため、節

159
00:07:28,890 --> 00:07:29,860
離れて、それは大丈夫です。

160
00:07:29,860 --> 00:07:33,710
日曜日または火曜日セクションに出席したり
チューンでジェイソンのセクションに、そのある

161
00:07:33,710 --> 00:07:35,110
オンラインで利用できる。

162
00:07:35,110 --> 00:07:37,490
>> だから、より多くの悪いニュース。

163
00:07:37,490 --> 00:07:41,960
だからシラバスによると、
我々は次の金曜日の講義を持っている。

164
00:07:41,960 --> 00:07:43,690
しかし、良いニュース - 

165
00:07:43,690 --> 00:07:44,860
明らかに、私はこの上であまりにも多くの時間を費やした。

166
00:07:44,860 --> 00:07:45,280
>> [笑い]

167
00:07:45,280 --> 00:07:47,140
>> 私たちは、次の金曜日の講義を取り消すでしょう。

168
00:07:47,140 --> 00:07:50,590
だから、私たちへの贈り物になりますので、
本当にでの素敵な休息を持つことができます

169
00:07:50,590 --> 00:07:52,990
今週ひいては二週間の間に。

170
00:07:52,990 --> 00:07:57,460
無講義来週、ほんのそう
あなたがあるべきために少しクイズ、

171
00:07:57,460 --> 00:07:59,030
ますます興奮。

172
00:07:59,030 --> 00:08:03,870
>> だから今に目を向けるみましょう
確かに、より視覚的な何か

173
00:08:03,870 --> 00:08:06,990
とよりエキサイティングとステージを設定する
地平線上になるだろう何のために

174
00:08:06,990 --> 00:08:08,420
週時間だけのカップルである。

175
00:08:08,420 --> 00:08:12,160
最初のクイズの後、我々は回します
我々の問題の焦点は別のものに設定します

176
00:08:12,160 --> 00:08:16,710
ドメイン固有の問題、その
より一般的に科学捜査やセキュリティ。

177
00:08:16,710 --> 00:08:19,550
>> 実際には、この問題と伝統
セットには、私のための一つである

178
00:08:19,550 --> 00:08:24,850
歩いて渡るために仲間やCAを教える
いくつかの写真を撮るキャンパス

179
00:08:24,850 --> 00:08:29,450
特定できるが、非自明人、
場所や物事、その後毎年I

180
00:08:29,450 --> 00:08:34,520
何とか誤って削除するには、管理
またはデジタルメディアカードが乱れる

181
00:08:34,520 --> 00:08:35,720
それが私たちのカメラの中だ。

182
00:08:35,720 --> 00:08:36,860
しかし、大したことない。

183
00:08:36,860 --> 00:08:39,200
私が先に行くとプラグインすることができます
私のコンピュータにその。

184
00:08:39,200 --> 00:08:43,010
私は、それのフォレンジックイメージを作ることができる
ゼロをコピーすることによって、話すことと

185
00:08:43,010 --> 00:08:46,830
そのメモリカードのものから、どうか
そのSDカードやコンパクトフラッシュカードまたは

186
00:08:46,830 --> 00:08:48,100
あなたが精通している何でも。

187
00:08:48,100 --> 00:08:49,300
そして、我々はそれを配ることができます。

188
00:08:49,300 --> 00:08:53,190
>> そして、他の間で先に挑戦、
あなたのためのものは、書くことになります

189
00:08:53,190 --> 00:08:58,630
の全体の束を回復Cコード
私と明らかにしたためのJPEGファイルは次のようになります

190
00:08:58,630 --> 00:09:00,190
それらの人々、場所、または物事。

191
00:09:00,190 --> 00:09:03,340
そして、我々はまた、この問題では、話しましょう
設定し、日に来て、約

192
00:09:03,340 --> 00:09:04,440
より一般的なグラフィック。

193
00:09:04,440 --> 00:09:06,140
我々は、もちろん、それらを使用してきました
抜け出すために。

194
00:09:06,140 --> 00:09:09,080
しかし、あなたは、ソートの付与のために撮影した
これらの高レベルの概念が存在する

195
00:09:09,080 --> 00:09:10,680
長方形や楕円形の。

196
00:09:10,680 --> 00:09:12,450
しかし、ボンネットの下に
ピクセルがあります。

197
00:09:12,450 --> 00:09:14,370
そして、あなたが開始しなければならなかった
それらについて考える。

198
00:09:14,370 --> 00:09:18,800
それともあなたは、p-4セットで考える必要があります
あなたの煉瓦の間のギャップについて、どのように

199
00:09:18,800 --> 00:09:21,990
迅速にボールが渡って動いている
抜け出すための画面が表示されます。

200
00:09:21,990 --> 00:09:24,830
だから、この概念があります
画面上のドットです

201
00:09:24,830 --> 00:09:26,290
すでに遊びに来る。

202
00:09:26,290 --> 00:09:29,430
>> 今、あなたは何を参照してください、しかし、何ですか
あなたは、コンピュータの画面上に取得します。

203
00:09:29,430 --> 00:09:33,680
あなたは今まで、いくつかの良いかを見てきた場合
悪いテレビ、オッズは、彼らはかなりある

204
00:09:33,680 --> 00:09:36,280
最新技術のような聴衆を扱う
誰が本当にない

205
00:09:36,280 --> 00:09:37,630
コンピューティングについて多くを知っている。

206
00:09:37,630 --> 00:09:40,840
そしてそれは、警察のために非常に簡単です
と言って探偵、次のことができます

207
00:09:40,840 --> 00:09:41,710
私にとってそれをクリーンアップ？

208
00:09:41,710 --> 00:09:42,710
または右に、強化？

209
00:09:42,710 --> 00:09:45,550
強化で話題の単語のようなものです
ほとんどすべての犯罪関連のshow。

210
00:09:45,550 --> 00:09:49,240
あなたは非常にを取る場合と現実です
やって容疑者のぼやけた画像

211
00:09:49,240 --> 00:09:51,620
何か悪いことは、することはできません
ちょうどそれを高める。

212
00:09:51,620 --> 00:09:53,080
あなたは、無限にズームすることはできません。

213
00:09:53,080 --> 00:09:56,350
あなたが誰かのの輝きに見ることができない
というコミット目

214
00:09:56,350 --> 00:09:59,860
もかかわらず、特定の犯罪、
テレビでこれの有病率。

215
00:09:59,860 --> 00:10:04,110
>> そしてましょうがそれを動機とすること
今後の問題はで垣間見るで設定

216
00:10:04,110 --> 00:10:05,765
あなたといくつかのショー
慣れているかもしれません。

217
00:10:05,765 --> 00:10:06,500
>> [ビデオの再生]

218
00:10:06,500 --> 00:10:07,835
>> -OK。

219
00:10:07,835 --> 00:10:09,956
さて、あなたをよく見ましょう。

220
00:10:09,956 --> 00:10:17,060

221
00:10:17,060 --> 00:10:17,766
>> それをホールド。

222
00:10:17,766 --> 00:10:18,658
そのバックを実行します。

223
00:10:18,658 --> 00:10:19,550
>> 分を待ちます。

224
00:10:19,550 --> 00:10:21,580
右に行く。

225
00:10:21,580 --> 00:10:21,800
>>  - あり。

226
00:10:21,800 --> 00:10:22,690
それを凍結。

227
00:10:22,690 --> 00:10:23,692
>>  - フルスクリーン。

228
00:10:23,692 --> 00:10:23,846
>> -OK。

229
00:10:23,846 --> 00:10:24,154
それを凍結。

230
00:10:24,154 --> 00:10:25,140
>> その上で締め、屋だろうか？

231
00:10:25,140 --> 00:10:27,090
>> その男に、インベクトル
後輪で。

232
00:10:27,090 --> 00:10:29,730
>> この場で右ここでズーム。

233
00:10:29,730 --> 00:10:33,700
>>  - で適切な機器、画像化された
拡大してシャープすることができます。

234
00:10:33,700 --> 00:10:34,490
>>  - どのようなそれはだ？

235
00:10:34,490 --> 00:10:35,870
>>  - それは強化プログラムです。

236
00:10:35,870 --> 00:10:36,793
>>  - できる何かそれまでをクリア？

237
00:10:36,793 --> 00:10:38,560
>>  - 私は知らない。

238
00:10:38,560 --> 00:10:39,090
それを強化しましょう​​。

239
00:10:39,090 --> 00:10:41,690
>> セクション6  - 強化。

240
00:10:41,690 --> 00:10:43,510
>> -Iは、ディテールを強化して - 

241
00:10:43,510 --> 00:10:44,456
>> -Iは、強化するために十分だと思う。

242
00:10:44,456 --> 00:10:45,402
私の画面にそれを解放。

243
00:10:45,402 --> 00:10:47,300
>> 彼女の目に反射を強化。

244
00:10:47,300 --> 00:10:49,330
>> のこれを介して実行しましょう​​ - 
ビデオエンハンスメント。

245
00:10:49,330 --> 00:10:50,340
>>  - エドガー、あなたはこれを強化することができますか？

246
00:10:50,340 --> 00:10:52,320
>> オンハング。

247
00:10:52,320 --> 00:10:54,290
>>  - 私は、この反省に取り組んでき。

248
00:10:54,290 --> 00:10:55,560
>>  - 誰かの反射。

249
00:10:55,560 --> 00:10:56,440
>> 反射。

250
00:10:56,440 --> 00:10:57,940
>> 反射は、あります
男の顔の。

251
00:10:57,940 --> 00:10:58,860
>> 反射。

252
00:10:58,860 --> 00:10:59,710
>>  - そこ反射です。

253
00:10:59,710 --> 00:11:00,900
>> ミラー上でズーム。

254
00:11:00,900 --> 00:11:03,500
>>  - あなたは反射を見ることができます。

255
00:11:03,500 --> 00:11:04,700
>>  - できるここからイメージを高める？

256
00:11:04,700 --> 00:11:05,700
>>  - できるあなたは正しいここで彼を高める？

257
00:11:05,700 --> 00:11:06,500
>>  - できるあなたはそれを向上させる？

258
00:11:06,500 --> 00:11:07,380
>>  - できるあなたはそれを向上させる？

259
00:11:07,380 --> 00:11:08,190
>>  - できる我々はこれを強化する？

260
00:11:08,190 --> 00:11:08,940
>>  - できるあなたはそれを向上させる？

261
00:11:08,940 --> 00:11:10,280
>> 第二にホールド、私は強化するだろう。

262
00:11:10,280 --> 00:11:11,570
>> ドアの上にズーム。

263
00:11:11,570 --> 00:11:12,180
>> -X10。

264
00:11:12,180 --> 00:11:13,052
>> ズーム。

265
00:11:13,052 --> 00:11:13,197
>> [笑い]

266
00:11:13,197 --> 00:11:14,360
>> インチ-MOVE

267
00:11:14,360 --> 00:11:15,100
>> 停止、ウェイト。

268
00:11:15,100 --> 00:11:15,740
>> ·停止します。

269
00:11:15,740 --> 00:11:16,290
>> それを一時停止。

270
00:11:16,290 --> 00:11:19,390
>> 周りに75度回転させる
垂直方向でお願いします。

271
00:11:19,390 --> 00:11:19,886
>> [笑い]

272
00:11:19,886 --> 00:11:24,350
>> 部分にバック停止し、
ドアについて再び。

273
00:11:24,350 --> 00:11:26,330
>> ·ガットイメージエンハンサー
それはビットマップできますか？

274
00:11:26,330 --> 00:11:28,990
>>  - 多分、我々はプラディープセンを使用することができます
ウィンドウに参照するための方法。

275
00:11:28,990 --> 00:11:30,680
>>  - このソフトウェアは、芸術の状態です。

276
00:11:30,680 --> 00:11:31,676
>> ·アイコンの値はoffです。

277
00:11:31,676 --> 00:11:34,166
>>  - で正しい組み合わせ
アルゴリズムの。

278
00:11:34,166 --> 00:11:38,399
>>  - 彼は次のように照明アルゴリズムを取ってきて
次のレベルと私はそれらを使用することができます

279
00:11:38,399 --> 00:11:38,648
この写真を向上させる。

280
00:11:38,648 --> 00:11:42,050
>> オンロックとz軸を拡大。

281
00:11:42,050 --> 00:11:42,760
>>  - 強化。

282
00:11:42,760 --> 00:11:43,060
>>  - 強化。

283
00:11:43,060 --> 00:11:43,760
>>  - 強化。

284
00:11:43,760 --> 00:11:45,010
>> 凍結と高める。

285
00:11:45,010 --> 00:11:47,470

286
00:11:47,470 --> 00:11:47,910
>> [ENDビデオ再生]

287
00:11:47,910 --> 00:11:51,470
>> DAVID J.マラン：だから問題セット
図5は、先にそこにあるものです。

288
00:11:51,470 --> 00:11:55,260
だから我々はすぐに理解を得るだろう
いつ、なぜあなたは缶の

289
00:11:55,260 --> 00:11:57,300
と私たちはそのように向上させることはできません。

290
00:11:57,300 --> 00:12:00,090
しかし、最初のが我々の注意を返しましょう
我々はよビルディングブロックの一部に

291
00:12:00,090 --> 00:12:02,250
その話をできるようにする必要があります。

292
00:12:02,250 --> 00:12:05,580
>> だから我々は、この絵を描いたことを思い出してください
月曜日と少し先週。

293
00:12:05,580 --> 00:12:09,970
そして、これは物事のレイアウトを記述
お使いのコンピュータのメモリ内のとき

294
00:12:09,970 --> 00:12:11,000
いくつかのプログラムを実行する。

295
00:12:11,000 --> 00:12:14,310
トップまでハイテクセグメント、リコールは、参照
実際の0と1に

296
00:12:14,310 --> 00:12:16,000
それは、プログラムを構成する。

297
00:12:16,000 --> 00:12:19,340
あり、その下に、いくつかのだが初期化または
どの一般的に初期化されていないデータ、

298
00:12:19,340 --> 00:12:22,910
や定数のようなものを指します
文字列や持っているグローバル変数

299
00:12:22,910 --> 00:12:24,200
事前に宣言されて。

300
00:12:24,200 --> 00:12:26,500
そこヒープですが、我々は来る
バックビットのものと。

301
00:12:26,500 --> 00:12:27,410
>> そしてスタックがあります。

302
00:12:27,410 --> 00:12:30,660
多くはでトレイの積み重ねのような
メモリが取得する場所カフェテリアは、これは

303
00:12:30,660 --> 00:12:33,610
いつレイヤーとレイヤー
あなたは、プログラムの中で何をすべきか？

304
00:12:33,610 --> 00:12:36,380

305
00:12:36,380 --> 00:12:37,730
のスタックの使用とは何ですか？

306
00:12:37,730 --> 00:12:39,320
>> うん？

307
00:12:39,320 --> 00:12:40,000
>> 関数の呼び出し。

308
00:12:40,000 --> 00:12:42,890
関数を呼び出す任意の時間、それは
そのため、メモリのスライバーに与え

309
00:12:42,890 --> 00:12:45,020
ローカル変数やパラメータ。

310
00:12:45,020 --> 00:12:48,810
と画像で、私たちは、それぞれのことを参照してください
連続的な時関数は、呼び出さ

311
00:12:48,810 --> 00:12:52,520
通話B呼C呼び出しD、それら
スタックに重ね得る。

312
00:12:52,520 --> 00:12:55,630
およびそれらのスライスの各々の中
メモリは、基本的にユニークなスコープです

313
00:12:55,630 --> 00:12:58,590
その機能のために、その、もちろん、
あなたが手にする場合は問題がある

314
00:12:58,590 --> 00:13:01,850
一つの関数から別の部分へ
あなたがそれをするデータの

315
00:13:01,850 --> 00:13:03,500
突然変異または変更します。

316
00:13:03,500 --> 00:13:08,060
>> だから有効にする私たちのソリューションは何だった
つのスタックに代表される機能

317
00:13:08,060 --> 00:13:11,390
メモリを内部で変更するフレーム
別のスタックフレームの？

318
00:13:11,390 --> 00:13:14,590
どのようにお互いにこれら二つの話をしますか？

319
00:13:14,590 --> 00:13:18,510
だからポインタまたはアドレスの方法によって、
どこのどの、再び、単に記述

320
00:13:18,510 --> 00:13:22,280
特定の方法でメモリ、
一口番号、特定の

321
00:13:22,280 --> 00:13:23,830
値を求めることができる。

322
00:13:23,830 --> 00:13:26,860
だからあまりにも私たちが続けて最後の時間を思い出す
でストーリーと見た

323
00:13:26,860 --> 00:13:28,280
かなりバギープログラム。

324
00:13:28,280 --> 00:13:32,900
そして、このプログラムは、いくつかのためのバギーです
理由が、ほとんど気になる1つは

325
00:13:32,900 --> 00:13:34,620
それは何をチェックするために失敗したから？

326
00:13:34,620 --> 00:13:39,111

327
00:13:39,111 --> 00:13:40,450
>> ええ、それは入力をチェックするために失敗した。

328
00:13:40,450 --> 00:13:41,870
申し訳ありませんが？

329
00:13:41,870 --> 00:13:43,880
>> それは、12文字以上なら。

330
00:13:43,880 --> 00:13:47,260
だから、非常にスマートに、memcopyを呼び出すときに、
ただその、名前が示すように、

331
00:13:47,260 --> 00:13:50,630
その第二引数からコピーがメモリ
最初の引数に。

332
00:13:50,630 --> 00:13:54,730
三番目の引数は、非常にスマートであり、
そうでないことを確認するためにチェック

333
00:13:54,730 --> 00:13:59,400
長さは、この場合には、より多くのコピー
バー、文字数、

334
00:13:59,400 --> 00:14:03,810
これで先に
配列C.しかし、問題はである何

335
00:14:03,810 --> 00:14:07,230
C自体は十分な大きさでない場合
それを処理する？

336
00:14:07,230 --> 00:14:09,900
あなたの番号をコピーするつもりだ
あなたが与えられてきたことバイト。

337
00:14:09,900 --> 00:14:13,040
しかし、あなたは実際にもっと何がありますか
あなたのための部屋を持っているよりもバイト？

338
00:14:13,040 --> 00:14:16,770
>> さて、このプログラムは非常に愚かにだけ
やみくもにそれはどんな取るに進み

339
00:14:16,770 --> 00:14:20,650
与えられた、ハローバックスラッシュ0です
文字列が短い場合は偉大

340
00:14:20,650 --> 00:14:22,040
十分に、5文字のような。

341
00:14:22,040 --> 00:14:26,470
しかし、それは実際に12文字以上の場合
1,200文字、我々は最後の時間を見た

342
00:14:26,470 --> 00:14:29,380
あなただけの完全にしようとしている
メモリを上書きしている

343
00:14:29,380 --> 00:14:30,470
あなたに属していません。

344
00:14:30,470 --> 00:14:34,390
最悪の場合には、上書きした場合、その
そこに我々はと呼ばれる赤い部分

345
00:14:34,390 --> 00:14:35,380
アドレスを返す - 

346
00:14:35,380 --> 00:14:38,370
これは単にどこにコンピュータ
自動的に、あなたのために、後ろに

347
00:14:38,370 --> 00:14:43,130
離れるシーン、タック32ビット値その
それがどうあるべきかのアドレスにそれを思い出させる

348
00:14:43,130 --> 00:14:47,080
戻ったときにfooに、この他の機能、
実行中に行われます。

349
00:14:47,080 --> 00:14:49,320
それはある種のパン粉だ
、それを返します。

350
00:14:49,320 --> 00:14:52,490
、潜在的に、あなたがそれを上書きした場合
あなたが悪い男なら、可能性ができます

351
00:14:52,490 --> 00:14:54,750
潜在的に引き継ぐ
誰かのコンピューター。

352
00:14:54,750 --> 00:14:58,020
そして、あなたが最も確かによ
ほとんどの場合、それをクラッシュ。

353
00:14:58,020 --> 00:15:01,690
>> 今、この問題は、唯一悪化しました
我々は、メモリの話を始めた

354
00:15:01,690 --> 00:15:03,010
より一般的に管理。

355
00:15:03,010 --> 00:15:07,150
そしてmallocが、メモリの割り当てのために、ある
我々は割り当てに使用できる関数

356
00:15:07,150 --> 00:15:11,260
我々は事前にはわからないメモリ
我々はいくつかを必要とするかもしれない。

357
00:15:11,260 --> 00:15:13,960
だから、例えば、私は戻って行けば
ここでアプライアンスに。

358
00:15:13,960 --> 00:15:21,010
そして、私は、前回のhello2.cから開く
見て、ここでこのプログラムを、リコール

359
00:15:21,010 --> 00:15:23,500
このように少し何か、
わずか3行 - 

360
00:15:23,500 --> 00:15:27,940
、あなたの名前、文字列名を明記
左側に、GetStringメソッドと等しい。

361
00:15:27,940 --> 00:15:29,690
そして、我々は、それをプリントアウト
ユーザの名前。

362
00:15:29,690 --> 00:15:31,170
>> だから、これは超シンプルなプログラムでした。

363
00:15:31,170 --> 00:15:34,870
明確にするために、私が先に行かせて
とハロー2メイク。

364
00:15:34,870 --> 00:15:36,680
私はドットスラッシュこんにちは-2をやるつもりです。

365
00:15:36,680 --> 00:15:37,750
自分の名前を述べる - 

366
00:15:37,750 --> 00:15:38,140
デビッド。

367
00:15:38,140 --> 00:15:38,840
入力します。

368
00:15:38,840 --> 00:15:39,540
デビッドこんにちは。

369
00:15:39,540 --> 00:15:41,060
これは、[OK]を動作するように思われる。

370
00:15:41,060 --> 00:15:43,140
しかし、何が本当に起こっている
ボンネットの下にここに？

371
00:15:43,140 --> 00:15:44,670
最初みましょういくつかの層に戻って皮をむく。

372
00:15:44,670 --> 00:15:48,380
文字列は、ちょうど私達がした同義語です
何のために実現？

373
00:15:48,380 --> 00:15:49,110
シャアスター。

374
00:15:49,110 --> 00:15:52,740
だから、もう少し難解な作ってみましょう
しかし、より技術的に正しいこのこと

375
00:15:52,740 --> 00:15:55,570
ことを意味してcharの星であり、
名前、はい、変数です。

376
00:15:55,570 --> 00:15:59,920
しかし、どのような名前を格納するのアドレスです
少し奇妙な感じのchar、

377
00:15:59,920 --> 00:16:01,050
私は文字列を取り戻すことだから。

378
00:16:01,050 --> 00:16:03,580
私は戻って複数取得しています
文字char型ではない。

379
00:16:03,580 --> 00:16:07,400
>> しかし、もちろん、あなただけの最初が必要
覚えておくべきシャアアドレス

380
00:16:07,400 --> 00:16:08,870
全体の文字列は、なぜためです？

381
00:16:08,870 --> 00:16:12,700
あなたはどのように把握するかどこの終わり
文字列は、先頭を知っていますか？

382
00:16:12,700 --> 00:16:13,630
バックスラッシュゼロ。

383
00:16:13,630 --> 00:16:17,260
だから、見つけ出すそれら二つの手がかりと
始まりと終わりの前に

384
00:16:17,260 --> 00:16:20,280
任意の文字列には、あまりにも長い間、彼らはしているようであり、
適切にそのヌルを形成し

385
00:16:20,280 --> 00:16:22,110
ターミネータ、そのバックスラッシュゼロ。

386
00:16:22,110 --> 00:16:24,520
>> しかし、これはGetStringメソッドを呼び出している。

387
00:16:24,520 --> 00:16:28,020
そしてそれはそのGetStringメソッドが判明
すべてのこの時間は、種のでした

388
00:16:28,020 --> 00:16:28,820
私たちのために不正行為。

389
00:16:28,820 --> 00:16:32,460
それは、確かに、この労働をやっている、
ユーザから文字列を取得。

390
00:16:32,460 --> 00:16:34,580
しかし、メモリはどこだ
から来て？

391
00:16:34,580 --> 00:16:38,440
我々はここで絵に戻った場合と
だけから定義を適用

392
00:16:38,440 --> 00:16:42,610
一瞬前に、スタックがどこにあること
関数が呼び出されたときにメモリが行く

393
00:16:42,610 --> 00:16:45,370
そのロジックでは、GetStringメソッドを呼び出したとき、
そして私はを入力

394
00:16:45,370 --> 00:16:50,900
どこにあるD--V-I-D D-A-V-I-D、入力
に基づいて保存されたバックスラッシュゼロ、

395
00:16:50,900 --> 00:16:53,480
話我々ははるかに私たちに語ってきた？

396
00:16:53,480 --> 00:16:55,190
>> それはであるように思えるでしょう
スタック、右？

397
00:16:55,190 --> 00:16:58,120
あなたは文字列を取得呼び出すときに取得
スタック上のメモリの少しスライス。

398
00:16:58,120 --> 00:17:01,630
だから、D-A-V-I-Dその理にかなって
スラッシュゼロが格納され

399
00:17:01,630 --> 00:17:02,770
そこにスタックした。

400
00:17:02,770 --> 00:17:07,680
しかし、GetStringメソッドを返しちょっと待って
を意味し、その文字列、いわば、

401
00:17:07,680 --> 00:17:11,700
それは食堂からトレイです
スタックから取得されます。

402
00:17:11,700 --> 00:17:14,560
そして、私たちはそのできるだけ前回述べた
関数が戻ると、あなたはそれを取る

403
00:17:14,560 --> 00:17:20,109
スタックからトレイ、いわば、何
あなたは、の残骸について仮定することができます

404
00:17:20,109 --> 00:17:21,819
そのメモリ？

405
00:17:21,819 --> 00:17:25,160
私は、ソートの疑問符としてそれらを直した
彼らは効果的になるため

406
00:17:25,160 --> 00:17:26,250
未知の値。

407
00:17:26,250 --> 00:17:29,500
ときに、いくつかの彼らは再利用することができます
次の関数が呼び出されます。

408
00:17:29,500 --> 00:17:31,870
>> 換言すれば、我々は起こる場合
保存する - 

409
00:17:31,870 --> 00:17:34,350
私は迅速な絵を描くよ
ここでスタック。

410
00:17:34,350 --> 00:17:38,690
我々はボトムを描くことが起こる場合
私のメモリセグメントの、我々は言うだろう

411
00:17:38,690 --> 00:17:42,230
これはメモリの場所であること
メインと多分argをCとによって占め

412
00:17:42,230 --> 00:17:46,790
引数vおよびプログラムで何、
GetStringメソッドが呼び出されたときに、

413
00:17:46,790 --> 00:17:51,120
おそらく、GetStringメソッドを取得します
ここでメモリの塊。

414
00:17:51,120 --> 00:17:53,940
そして、D-A-V-I-D何とか
この関数の中で終わる。

415
00:17:53,940 --> 00:17:55,320
そして、私は極端に単純つもりです。

416
00:17:55,320 --> 00:18:00,050
しかしみましょうそのD-A-V-I-Dと仮定し
スラッシュゼロ。

417
00:18:00,050 --> 00:18:03,500
したがって、この多くのバイトがで使用されている
GetStringメソッドのためのフレーム。

418
00:18:03,500 --> 00:18:08,270
>> しかし、すぐにGetStringメソッドを返すように、我々
最後の時間によると、上のこのメモリ

419
00:18:08,270 --> 00:18:11,340
ここで全てになります - オエーッと吐く！ - 

420
00:18:11,340 --> 00:18:14,270
すべては事実上消去となります。

421
00:18:14,270 --> 00:18:17,220
そして、私たちは疑問として今、この考えることができます
マークを知っているので

422
00:18:17,220 --> 00:18:18,720
何がそのメモリになるだろう。

423
00:18:18,720 --> 00:18:22,130
確かに、私は非常に頻繁に関数を呼び出す
GetStringメソッド以外。

424
00:18:22,130 --> 00:18:24,750
とすぐに、私はいくつかの他のを呼ぶように
GetStringメソッドより機能、そうでないかもしれないで

425
00:18:24,750 --> 00:18:28,860
私たちはただ見て、この特定のプログラム
しかし、いくつかの他、確かにいくつかの他に

426
00:18:28,860 --> 00:18:34,180
この関数は、与えられて終わるかもしれない
スタック内のこの次のスポット。

427
00:18:34,180 --> 00:18:39,410
>> だから、そのGetStringメソッドを格納することはできません
スタック上のD-A-V-I-D、私はなるので

428
00:18:39,410 --> 00:18:41,040
すぐにそれにアクセスできなくなります。

429
00:18:41,040 --> 00:18:43,720
しかし、我々は、彼らが知っているGetStringメソッド
ものだけを返す？

430
00:18:43,720 --> 00:18:47,220
それはに戻っていない
私の6文字。

431
00:18:47,220 --> 00:18:51,090
それは本当に何をしたの返して
我々は最後の時間を締結？

432
00:18:51,090 --> 00:18:52,480
最初のアドレス。

433
00:18:52,480 --> 00:18:56,650
だから何とか、あなたがGetStringメソッド呼び出されたときに、
それはのためにメモリのチャンクを割り当てている

434
00:18:56,650 --> 00:18:59,620
文字列、ユーザーのタイプと
それのアドレスを返す。

435
00:18:59,620 --> 00:19:02,930
そしてそれはあなたがしたときにしたいことが判明
これでメモリを割り当てるための機能

436
00:19:02,930 --> 00:19:08,390
と呼ばれる人への道とリターン
その関数のアドレス

437
00:19:08,390 --> 00:19:11,870
メモリのチャンクは、絶対に
でスタックにそれを置くことができません

438
00:19:11,870 --> 00:19:14,750
機能的にはそれだけだからボトム、
非常にあなたにならないようにしよう

439
00:19:14,750 --> 00:19:17,800
すぐに、そうあなたはおそらく推測できる場所
我々は、おそらくそれを投げるつもり

440
00:19:17,800 --> 00:19:20,130
代わりに、いわゆるヒープ。

441
00:19:20,130 --> 00:19:25,290
>> だからあなたのメモリのの底部との間
レイアウトとメモリの上部の

442
00:19:25,290 --> 00:19:26,820
レイアウトはセグメントの全体の束である。

443
00:19:26,820 --> 00:19:29,270
一つは、スタック、右
その上ヒープです。

444
00:19:29,270 --> 00:19:33,680
とヒープは、ちょうど別の塊です
機能のために使用されていないのメモリ

445
00:19:33,680 --> 00:19:34,770
それらは呼ばれるしているとき。

446
00:19:34,770 --> 00:19:38,100
それは、時、長期的記憶のために使われてい
あなたには、いくつかをつかむために一つの関数にしたい

447
00:19:38,100 --> 00:19:42,700
メモリとそれにハングアップすることができる
それ以上の制御を失うことなく。

448
00:19:42,700 --> 00:19:45,550
>> 今、あなたは、おそらくすぐにできた
これではないことがわかり

449
00:19:45,550 --> 00:19:48,060
完璧なデザインは必ずしも。

450
00:19:48,060 --> 00:19:51,350
あなたのプログラムは、上のメモリが割り当てられたよう
スタック、またはお電話としてより

451
00:19:51,350 --> 00:19:55,540
より多くの機能、または割り当てとして
としてオフmalloc関数でヒープ上のメモリ

452
00:19:55,540 --> 00:20:00,690
GetStringメソッドは何明らかに、やっている
避けられない問題であると思われる？

453
00:20:00,690 --> 00:20:00,860
>> 右。

454
00:20:00,860 --> 00:20:03,150
これらの矢印のように、その事実
お互いを指している

455
00:20:03,150 --> 00:20:04,380
良い前兆ではあ​​りません。

456
00:20:04,380 --> 00:20:08,630
そして実際、我々は非常に迅速にクラッシュする可能性が
任意の数の方法でプログラム。

457
00:20:08,630 --> 00:20:12,050
実際、私は我々が持っているかもしれないと思う
この偶然に一度行わ。

458
00:20:12,050 --> 00:20:14,020
またはされていない場合、それを行うみましょう
意図的に今。

459
00:20:14,020 --> 00:20:21,330
私が先に行くとすぐにスーパー書いてみましょう
プログラムはdontdothis.c呼んだ。

460
00:20:21,330 --> 00:20:26,730
そして今、私はここに行くよと
シャープは、stdio.hのを含んでください。

461
00:20:26,730 --> 00:20:32,620
関数fooが取る宣言してみましょう
ある引数がない、ない

462
00:20:32,620 --> 00:20:34,040
ボイドによって同様に示される。

463
00:20:34,040 --> 00:20:37,830
>> とfooがやろうとしている唯一の事はある
おそらくないコールfooを、

464
00:20:37,830 --> 00:20:39,100
賢いアイデアですが、そのためである。

465
00:20:39,100 --> 00:20:40,490
耳鼻咽喉科メイン無効。

466
00:20:40,490 --> 00:20:45,270
今メイン唯一の事は起こっている
実行すると、同様にfoo 'を呼び出すだけです。

467
00:20:45,270 --> 00:20:51,050
そして、ちょうどキックのために、私は行くつもりです
先にこことからこんにちは "printfを言う

468
00:20:51,050 --> 00:20:52,340
fooの。 "

469
00:20:52,340 --> 00:20:52,890
>> OK。

470
00:20:52,890 --> 00:21:00,160
だから私は、どんなミスをしなかった場合、
dontdothisドットスラッシュを作る。

471
00:21:00,160 --> 00:21:01,960
とのは、大きなウィンドウでそれをやらせる - 

472
00:21:01,960 --> 00:21:03,210
ドットスラッシュ、dontdothis。

473
00:21:03,210 --> 00:21:07,590

474
00:21:07,590 --> 00:21:08,840
さあ。

475
00:21:08,840 --> 00:21:10,940

476
00:21:10,940 --> 00:21:11,890
ああええと。

477
00:21:11,890 --> 00:21:13,100
どうやら、あなたはこれを行うことができます。

478
00:21:13,100 --> 00:21:15,190
畜生。

479
00:21:15,190 --> 00:21:16,190
OK。

480
00:21:16,190 --> 00:21:16,580
待って。

481
00:21:16,580 --> 00:21:17,370
スタンバイ。

482
00:21:17,370 --> 00:21:18,270
我々がした - 

483
00:21:18,270 --> 00:21:20,110
我々は作るとそれを使用しました。

484
00:21:20,110 --> 00:21:22,050
>> [ため息]

485
00:21:22,050 --> 00:21:25,110
>> 私は知っているが、私は我々だと思います
ちょうどそれを削除した。

486
00:21:25,110 --> 00:21:28,410
ええと、ええ。

487
00:21:28,410 --> 00:21:30,660
畜生。

488
00:21:30,660 --> 00:21:32,640
このロブを解決します。

489
00:21:32,640 --> 00:21:34,678
何？

490
00:21:34,678 --> 00:21:35,928
それは非常に簡単です。

491
00:21:35,928 --> 00:21:43,820

492
00:21:43,820 --> 00:21:47,360
ええ、私たちは、最適化をオフにした。

493
00:21:47,360 --> 00:21:48,970
OK、さようなら立つ。

494
00:21:48,970 --> 00:21:49,950
今、私は良い感じ。

495
00:21:49,950 --> 00:21:51,390
OK。

496
00:21:51,390 --> 00:21:51,780
わかりました。

497
00:21:51,780 --> 00:21:53,430
>> だから、これをコンパイルしてみましょう - 

498
00:21:53,430 --> 00:21:55,880
あなたはdontdothis作る。

499
00:21:55,880 --> 00:22:00,090
あなたは、この名前を変更する必要がある場合があります
一瞬でdothis.c。

500
00:22:00,090 --> 00:22:00,710
そうしよう。

501
00:22:00,710 --> 00:22:01,240
ありがとう。

502
00:22:01,240 --> 00:22:02,050
OK。

503
00:22:02,050 --> 00:22:05,480
だから私は、印刷されたという事実
外に何かがただ実際にあった

504
00:22:05,480 --> 00:22:08,150
によって我々のプロセスを遅くする
その点に到達したであろう。

505
00:22:08,150 --> 00:22:08,510
OK。

506
00:22:08,510 --> 00:22:08,870
ふーっ！

507
00:22:08,870 --> 00:22:11,180
>> だから何が実際に起こっている？

508
00:22:11,180 --> 00:22:14,440
ただ余談として、そこに理由は、、です
入力の面で何かをやって

509
00:22:14,440 --> 00:22:17,270
出力が遅くなる傾向にあるので、あなた
に文字を記述する必要があります

510
00:22:17,270 --> 00:22:18,600
画面には、それはスクロールする必要があります。

511
00:22:18,600 --> 00:22:21,720
だから長い話短い、私は実際に持っていた
そうせっかち起こった、我々は持っているでしょう

512
00:22:21,720 --> 00:22:23,260
同様にこの最終結果見。

513
00:22:23,260 --> 00:22:26,220
今、私はプリントアップの乗り心地を得たこと、
我々はすぐにそれを参照してください。

514
00:22:26,220 --> 00:22:28,410
では、なぜこれが起こっている。

515
00:22:28,410 --> 00:22:31,300
まあ、もちろん簡単な説明、
fooはおそらくならないことがある

516
00:22:31,300 --> 00:22:32,500
自分自身を呼び出すこと。

517
00:22:32,500 --> 00:22:34,470
>> 今、一般的な用語で、
これは再帰です。

518
00:22:34,470 --> 00:22:36,970
そして、私たちは数週間考え
前に再帰的な良いです。

519
00:22:36,970 --> 00:22:40,330
再帰は、この魔法のような方法です
簡潔スーパー自身を表現。

520
00:22:40,330 --> 00:22:41,400
そして、それだけで動作します。

521
00:22:41,400 --> 00:22:45,060
しかし、全ての主要な機能があります
私たちが話した再帰プログラム

522
00:22:45,060 --> 00:22:48,260
約これまでを見て、どの
彼らは何を持っていたことでしたか？

523
00:22:48,260 --> 00:22:52,610
いくつかのハードコーディングされたベースケース、
いくつかの状況で述べている場合

524
00:22:52,610 --> 00:22:56,210
明らかにあるfooという、呼び出すことはありません
ここではそうではありません。

525
00:22:56,210 --> 00:22:58,920
>> だから、本当に何が起こっている
この写真の面で？

526
00:22:58,920 --> 00:23:01,790
まあ、時メインfooに、それを呼び出します
メモリのスライスを取得します。

527
00:23:01,790 --> 00:23:04,150
fooはfooのを呼び出すと、それを取得します
メモリのスライス。

528
00:23:04,150 --> 00:23:06,430
fooはfooのを呼び出すと、それは、スライスを取得します。

529
00:23:06,430 --> 00:23:07,080
これは、スライスを取得します。

530
00:23:07,080 --> 00:23:08,120
これは、スライスを取得します。

531
00:23:08,120 --> 00:23:09,460
fooが復帰されることはありませんので。

532
00:23:09,460 --> 00:23:12,160
我々は、これらのいずれかを消去することはありませんしている
スタックからフレーム。

533
00:23:12,160 --> 00:23:15,930
だから私たちは、ヒープ介さず吹いている
誰が他に何を知っている、と言及する

534
00:23:15,930 --> 00:23:19,600
我々は我々の範囲を逸脱している
メモリのセグメントいわゆる。

535
00:23:19,600 --> 00:23:21,790
エラーは、セグメンテーションが偽行く。

536
00:23:21,790 --> 00:23:24,110
>> だから、そこに解決策はある
明らかにこれを行わない。

537
00:23:24,110 --> 00:23:28,830
しかし、もっと大きな意味合いは、はい、です
絶対にいくつかの制限があり、

538
00:23:28,830 --> 00:23:32,470
それはよくする方法として、定義されていない場合でも、
あなたが呼び出すことができる多くの機能

539
00:23:32,470 --> 00:23:34,970
プログラムは、何回機能
自分自身を呼び出すことができます。

540
00:23:34,970 --> 00:23:38,430
私たちは、再帰を説教しましたので、あっても
この潜在的に魔法のものとして

541
00:23:38,430 --> 00:23:41,870
シグマのため数週間前
機能、ときに我々がデータを取得する

542
00:23:41,870 --> 00:23:45,270
構造とCS50、他のを見ることができます
そのためのアプリケーションが、そうではありません

543
00:23:45,270 --> 00:23:46,500
必ずしも最高のもの。

544
00:23:46,500 --> 00:23:50,070
この関数は、それ自身を呼び出している場合なので、
ベースがある場合であっても、自分自身を呼び出す

545
00:23:50,070 --> 00:23:54,860
場合、あなたはそのベースケースをヒットしていない場合
1,000通話または10,000コールに対して、バイ

546
00:23:54,860 --> 00:23:58,800
あなたは部屋を使い果たしたかもしれないその時
あなたのいわゆるスタックとヒットに

547
00:23:58,800 --> 00:24:00,400
メモリのいくつかの他のセグメント。

548
00:24:00,400 --> 00:24:03,950
だから、それはあまりにも設計のトレードオフです
エレガンスの間との間で

549
00:24:03,950 --> 00:24:06,920
あなたの特定の堅牢
実装。

550
00:24:06,920 --> 00:24:10,780
>> だから、別の欠点やはあり
私たちがしたものに別の落とし穴

551
00:24:10,780 --> 00:24:11,720
これまで行ってき。

552
00:24:11,720 --> 00:24:12,980
私がGetStringメソッドと呼ばれるとき - 

553
00:24:12,980 --> 00:24:15,120
私がhello-2に戻ってみましょう。

554
00:24:15,120 --> 00:24:18,170
、私は、GetStringメソッドを呼び出していることに注意してください
これは、アドレスを返している。

555
00:24:18,170 --> 00:24:20,730
そして、私たちは今日の主張そのアドレス
ヒープからです。

556
00:24:20,730 --> 00:24:24,480
そして今、私はプリントアウトしています
そのアドレスの文字列。

557
00:24:24,480 --> 00:24:27,000
しかし、我々は呼ばれたことがない
GetStringメソッドの反対。

558
00:24:27,000 --> 00:24:30,850
我々のような機能をcalllしなければならなかったことがない
あなたが手背中ungetstring、

559
00:24:30,850 --> 00:24:31,610
そのメモリ。

560
00:24:31,610 --> 00:24:33,250
しかし、率直に言って、我々はおそらく、
されている必要があります。

561
00:24:33,250 --> 00:24:37,390
ので、我々はコンピュータを求め続ければ
のような誰かの記憶のために、別の方法

562
00:24:37,390 --> 00:24:40,830
GetStringメソッドは、しかし確実に、それをお返しすることはありません
それもにつながるためにバインドされて

563
00:24:40,830 --> 00:24:42,970
我々は、メモリが不足することにより、問題​​が。

564
00:24:42,970 --> 00:24:46,140
>> 実際に、我々はこれらを探すことができます
用法新しいツールの問題

565
00:24:46,140 --> 00:24:47,640
入力するのは少し不可解です。

566
00:24:47,640 --> 00:24:50,960
しかし、私が先に行くとそれを飛散させ
一瞬で画面上に。

567
00:24:50,960 --> 00:24:56,940
私が先に行くと、Valgrindのを実行するつもりです
その最初のコマンドパラメータを使用して

568
00:24:56,940 --> 00:25:00,260
ライン引数名です
そのプログラムハロー2。

569
00:25:00,260 --> 00:25:02,650
そして残念なことにそれは
出力はatrociouslyです

570
00:25:02,650 --> 00:25:04,290
理由もなく複雑。

571
00:25:04,290 --> 00:25:06,280
だから我々はすべてのその混乱を参照してください。

572
00:25:06,280 --> 00:25:07,530
ダビデは私の名前の状態です。

573
00:25:07,530 --> 00:25:09,760
だからプログラムです
実際に実行されている。

574
00:25:09,760 --> 00:25:11,180
そして今、我々はこの出力を得る。

575
00:25:11,180 --> 00:25:13,400
>> だからValgrindのも同様です
精神GDBへ。

576
00:25:13,400 --> 00:25:14,950
それはそれ自体デバッガではありません。

577
00:25:14,950 --> 00:25:16,270
しかし、それはメモリチェッカーです。

578
00:25:16,270 --> 00:25:20,140
それはあなたを実行するプログラムです
プログラムは、あなたが要求された場合を教えてくれ

579
00:25:20,140 --> 00:25:23,860
メモリ用のコンピュータとそれを手渡したことがない
バックすることにより、あなたが持っていることを意味

580
00:25:23,860 --> 00:25:24,570
メモリリーク。

581
00:25:24,570 --> 00:25:26,240
とメモリリークが悪くなる傾向があります。

582
00:25:26,240 --> 00:25:29,120
そして、あなたは、コンピュータのユーザーが持っている
おそらくこれはあなたが持っているかどうか、と感じた

583
00:25:29,120 --> 00:25:30,300
MacやPC。

584
00:25:30,300 --> 00:25:33,730
あなたは今までお使いのコンピュータを使用している
といくつかの再起動ではないながら、

585
00:25:33,730 --> 00:25:36,820
日、またはあなただけのたくさん持っている
実行中のプログラム、そしてこいつ

586
00:25:36,820 --> 00:25:42,360
研削停止に遅く、または少なくとも
ので、それは、使用する超迷惑なんだ

587
00:25:42,360 --> 00:25:44,350
すべてはただのスーパーが遅くなった。

588
00:25:44,350 --> 00:25:46,260
>> 今では、理由をいくつでも指定できます。

589
00:25:46,260 --> 00:25:49,600
これは、無限ループのバグかもしれません
誰かのコード、または、もっと簡単に、それ

590
00:25:49,600 --> 00:25:53,250
あなたがより多くを使っていることを意味するかもしれない
あなたのよりメモリ、またはしようとすると、

591
00:25:53,250 --> 00:25:54,920
コンピュータが実際に持っています。

592
00:25:54,920 --> 00:25:57,770
そして、おそらく、いくつかのプログラムにバグはあり
メモリを求めておくこと。

593
00:25:57,770 --> 00:26:02,480
年間のブラウザはために悪名高いでした
これは、より多くのメモリを要求する

594
00:26:02,480 --> 00:26:03,870
が、それを戻って渡すことはありません。

595
00:26:03,870 --> 00:26:07,220
きっと、あなただけの有限のを持っている場合
メモリの量は、あなたが求めることができません

596
00:26:07,220 --> 00:26:09,990
無限に多くの回
そのメモリの一部。

597
00:26:09,990 --> 00:26:13,070
>> そしてあなたもかかわらず、ここで何を参照してください
再びValgrindのの出力がある

598
00:26:13,070 --> 00:26:17,490
一瞥することが不必要に複雑
最初に、これは面白い部分です。

599
00:26:17,490 --> 00:26:18,890
ヒープ - 

600
00:26:18,890 --> 00:26:20,060
出口で使用中です。

601
00:26:20,060 --> 00:26:22,810
だからここにどのくらいのメモリだっただ
でヒープ内の使用されている

602
00:26:22,810 --> 00:26:24,300
時間は、私のプログラムが終了した - 

603
00:26:24,300 --> 00:26:27,280
一つのブロックで明らかに6バイト。

604
00:26:27,280 --> 00:26:28,710
だから私は私の手を振るつもりだ
何でブロックです。

605
00:26:28,710 --> 00:26:31,270
より多くの、それだけで塊です考える
チャンクのための技術的な単語。

606
00:26:31,270 --> 00:26:33,140
しかし、6バイト - 

607
00:26:33,140 --> 00:26:36,870
その6バイトは何ですか
まだ使用されていましたか？

608
00:26:36,870 --> 00:26:37,390
>> まさに。

609
00:26:37,390 --> 00:26:41,520
D--V-I-Dスラッシュゼロ、5文字
名とヌル終端文字。

610
00:26:41,520 --> 00:26:46,350
したがって、このプログラムは、私がいることに気づいvalgrindの
で、どうやら、6バイトを求め

611
00:26:46,350 --> 00:26:48,950
GetStringメソッドのように、決して
それらを与えた。

612
00:26:48,950 --> 00:26:52,030
実際に、これはそうではないかもしれません
私のプログラムは、次の3つではない明らかな場合

613
00:26:52,030 --> 00:26:53,590
行が、それは300行です。

614
00:26:53,590 --> 00:26:56,920
だから私たちは、実際に別のコマンドを与えることができます
へのvalgrindライン引数

615
00:26:56,920 --> 00:26:58,290
それより冗長にします。

616
00:26:58,290 --> 00:26:59,760
それは覚えて少し迷惑なんだ。

617
00:26:59,760 --> 00:27:01,580
しかし、私がしなければ - 

618
00:27:01,580 --> 00:27:01,930
見てみましょう。

619
00:27:01,930 --> 00:27:03,540
リーク - 

620
00:27:03,540 --> 00:27:05,030
それが漏れていた - 

621
00:27:05,030 --> 00:27:07,580
でも、私は覚えていません
それは手から何か。

622
00:27:07,580 --> 00:27:08,550
>>  - リークチェックが完全に等しくなります。

623
00:27:08,550 --> 00:27:10,180
うん、ありがとうございました。

624
00:27:10,180 --> 00:27:12,520
 - リークチェックが完全に等しくなります。

625
00:27:12,520 --> 00:27:13,800
入力します。

626
00:27:13,800 --> 00:27:14,940
同じプログラムが実行されています。

627
00:27:14,940 --> 00:27:16,180
再びデビッドを入力します。

628
00:27:16,180 --> 00:27:17,660
今私は、もう少し詳細を参照してください。

629
00:27:17,660 --> 00:27:20,890
しかし、ヒープの要約以下、その
4と同じです - ああ、

630
00:27:20,890 --> 00:27:22,120
これはいいの一種である。

631
00:27:22,120 --> 00:27:25,460
今、Valgrindのは、実際に探しています
私のコードで少し難しい。

632
00:27:25,460 --> 00:27:29,580
そしてそれは、明らかに、それを言っている
ラインでのmalloc  - 

633
00:27:29,580 --> 00:27:30,580
私たちは、ズームアウト。

634
00:27:30,580 --> 00:27:31,980
ラインで - 

635
00:27:31,980 --> 00:27:32,930
我々はそれが何であるかのラインは表示されません。

636
00:27:32,930 --> 00:27:35,110
しかし、malloc関数は、最初の原因です。

637
00:27:35,110 --> 00:27:38,630
malloc関数でブログがあります。

638
00:27:38,630 --> 00:27:39,810
>> 大丈夫？

639
00:27:39,810 --> 00:27:40,450
いや、OK。

640
00:27:40,450 --> 00:27:40,940
右？

641
00:27:40,940 --> 00:27:42,520
私がGetStringメソッドと呼ばれる。

642
00:27:42,520 --> 00:27:44,460
GetStringメソッドは明らかにmalloc関数を呼び出します。

643
00:27:44,460 --> 00:27:47,800
それでは、コードの行は、明らかです。
持つための障害で

644
00:27:47,800 --> 00:27:49,050
このメモリを割り当てられた？

645
00:27:49,050 --> 00:27:51,560

646
00:27:51,560 --> 00:27:55,540
誰でも、mallocを書いたと仮定してみましょう
十分な長さ、それがだと回避されている

647
00:27:55,540 --> 00:27:56,390
ではない彼らの障害。

648
00:27:56,390 --> 00:27:57,520
だから、それはおそらく私です。

649
00:27:57,520 --> 00:28:02,000
cs50.cにGetStringメソッド - だそう
コンピュータ上でファイルのどこか - 

650
00:28:02,000 --> 00:28:05,210
ライン286の犯人であると思われる。

651
00:28:05,210 --> 00:28:08,140
今CS50がされていることを前提としてみましょう
時間のまともな量のために周りにいるので、

652
00:28:08,140 --> 00:28:09,720
我々はあまりにも無謬である。

653
00:28:09,720 --> 00:28:14,080
そしてそれはGetStringメソッドはおそらくありません
バグがあるのではなく、内にあること

654
00:28:14,080 --> 00:28:17,810
ハロー2.Cライン18。

655
00:28:17,810 --> 00:28:20,670
>> それでは見てみましょう
そのライン18は何だったの。

656
00:28:20,670 --> 00:28:21,130
ああ。

657
00:28:21,130 --> 00:28:27,130
どういうわけか、この行は必ずしもない
バギー、それ自体が、それが理由です

658
00:28:27,130 --> 00:28:28,630
そのメモリリークの背後に。

659
00:28:28,630 --> 00:28:32,140
だからスーパー単に、何が直感的だろう
ここに解決策になる？

660
00:28:32,140 --> 00:28:34,710
我々はメモリを求めている場合は、決してなかった
それを恩返し、それがあると思われる

661
00:28:34,710 --> 00:28:37,940
時間をかけて私のコンピュータなぜなら問題
メモリが不足する可能性があり、遅くなるかもしれません

662
00:28:37,940 --> 00:28:42,110
ダウン、悪いことは、まあ、起こるかもしれない
シンプルで直感的な解決策は何ですか？

663
00:28:42,110 --> 00:28:43,140
ちょうどそれをお返し。

664
00:28:43,140 --> 00:28:44,770
>> あなたどのようにメモリを解放するのですか？

665
00:28:44,770 --> 00:28:49,970
まあ、ありがたいことに、それは非常に簡単です
ただ自由に名前を言うように。

666
00:28:49,970 --> 00:28:51,260
そして、私たちは前にこれをやったことがない。

667
00:28:51,260 --> 00:28:55,890
しかし、あなたは本質的に考えることができます
malloc関数の逆のように自由。

668
00:28:55,890 --> 00:28:58,030
無料の反対です
メモリを割り当てる。

669
00:28:58,030 --> 00:28:59,540
だから今、私はこれをコンパイルしましょう​​。

670
00:28:59,540 --> 00:29:02,050
こんにちは-2を作る。

671
00:29:02,050 --> 00:29:04,620
私は再びそれを実行してみましょう。ハロー2デビッド。

672
00:29:04,620 --> 00:29:07,290
だから、で動作するように思われる
まったく同じ方法。

673
00:29:07,290 --> 00:29:11,180
しかし、私はValgrindはに戻って、再実行した場合
私の新たに上に同じコマンド

674
00:29:11,180 --> 00:29:14,720
コンパイルされたプログラムで、次のように入力
以前のように私の名前で - 

675
00:29:14,720 --> 00:29:15,370
素敵。

676
00:29:15,370 --> 00:29:16,760
ヒープの要約 - 

677
00:29:16,760 --> 00:29:17,740
出口で使用されている - 

678
00:29:17,740 --> 00:29:19,370
ゼロブロックでゼロバイト。

679
00:29:19,370 --> 00:29:21,840
そして、これは超素敵な、すべてである
ヒープブロックが解放された。

680
00:29:21,840 --> 00:29:23,480
漏れはできません。

681
00:29:23,480 --> 00:29:27,200
>> そうではなく、問題のセット4で、間近に迫って
しかし、問題セット5、フォレンジックと

682
00:29:27,200 --> 00:29:30,740
以降、これもなろう
自分の正しさの尺度

683
00:29:30,740 --> 00:29:33,630
あなたが持っているかどうかをプログラム、
またはメモリリークがありません。

684
00:29:33,630 --> 00:29:36,900
しかし、ありがたいことに、あなたは、推論することができますだけでなく、
その直感、それを通して

685
00:29:36,900 --> 00:29:40,430
小さなプログラムのために簡単に、間違いなく、ある
しかし、大規模なプログラムのために難しく、

686
00:29:40,430 --> 00:29:43,860
、それらの大規模なプログラムのために、Valgrindは
あなたが特定するのに役立ちます

687
00:29:43,860 --> 00:29:45,360
特定の問題。

688
00:29:45,360 --> 00:29:47,500
>> しかし、もう一つ問題があり
それが発生する可能性があります。

689
00:29:47,500 --> 00:29:51,245
、である、私はここで、このファイルを開いてみましょう
再び、やや簡単な例。

690
00:29:51,245 --> 00:29:53,760
しかしみましょう、何に焦点を当て
このプログラムではありません。

691
00:29:53,760 --> 00:29:55,190
これはmemory.cのと呼ばれています。

692
00:29:55,190 --> 00:29:58,380
我々は、この後の今日投稿します
今日のソースコードのzipファイル。

693
00:29:58,380 --> 00:30:01,610
そして、私はと呼ばれる機能を持っていることに気付く
引数を取りませんfと

694
00:30:01,610 --> 00:30:02,800
何も返しません。

695
00:30:02,800 --> 00:30:07,240
20行目では、私は明らかに宣言しています
int型とX呼び出しへのポインタ。

696
00:30:07,240 --> 00:30:09,570
私は割り当ててるリターンです
malloc関数の値。

697
00:30:09,570 --> 00:30:14,590
そして、ちょうど午前何バイト、明確にすること
私はおそらくmalloc関数から戻ってき

698
00:30:14,590 --> 00:30:17,080
この状況で？

699
00:30:17,080 --> 00:30:18,040
>> おそらく40。

700
00:30:18,040 --> 00:30:18,840
あなたどこそこから入手できますか？

701
00:30:18,840 --> 00:30:22,410
さて、あなたはint型が頻繁にあることを思い出している場合
4バイト、少なくともそれが入っている

702
00:30:22,410 --> 00:30:25,110
アプライアンス、10回4は明らかに40です。

703
00:30:25,110 --> 00:30:28,920
だから、malloc関数は、アドレスを返している
メモリのチャンクと保管その

704
00:30:28,920 --> 00:30:30,800
Xで最終的に解決する。

705
00:30:30,800 --> 00:30:32,570
だから、何を明確にする
その後、何が起こっている？

706
00:30:32,570 --> 00:30:34,990
まあ、私は戻って切り替えることができ
ここで私たちの絵に。

707
00:30:34,990 --> 00:30:38,150
私はちょうど私の下を引くないようにしましょう
コンピュータのメモリは、私が先に行かせてと

708
00:30:38,150 --> 00:30:42,990
全体の矩形を描画している
私のRAMのすべてを表しています。

709
00:30:42,990 --> 00:30:44,790
>> 私たちは、スタックと言うでしょう
底にある。

710
00:30:44,790 --> 00:30:47,010
とテキストセグメントであり
初期化されていないデータ。

711
00:30:47,010 --> 00:30:49,880
しかし、私は単なる抽象的なものに行くよ
ドットドットドットとして離れて他の事。

712
00:30:49,880 --> 00:30:53,470
私はちょうどこれを参照するつもりです
上部にヒープとして。

713
00:30:53,470 --> 00:30:57,070
そして、この絵の下部にある、
メインを表現するために、私は行くよ

714
00:30:57,070 --> 00:30:59,880
それをスライスメモリを与えるために
スタック上。

715
00:30:59,880 --> 00:31:03,150
Fの場合、私はそれをスライスを与えるつもりだ
スタック上のメモリ。

716
00:31:03,150 --> 00:31:05,140
さて、私は私に相談するようになった
再びソースコード。

717
00:31:05,140 --> 00:31:07,170
メインのローカル変数は何ですか？

718
00:31:07,170 --> 00:31:10,710
どうやら何もないので、そのスライスである
効果的に空かなくても同じ大きさ

719
00:31:10,710 --> 00:31:11,600
私はそれを描かれてきたように。

720
00:31:11,600 --> 00:31:15,730
しかし、Fで、私は、ローカル変数を持っている
それはXと呼ばれています。

721
00:31:15,730 --> 00:31:20,410
だから私は先に行くとfを与えるつもりだ
それX呼び出しメモリのチャンク、。

722
00:31:20,410 --> 00:31:24,680
>> 10回4のそして今のmalloc、
そののmalloc 40、だから

723
00:31:24,680 --> 00:31:25,430
メモリはから来る？

724
00:31:25,430 --> 00:31:27,530
私たちは、絵を描かれていませんでした
前にこれが好き。

725
00:31:27,530 --> 00:31:31,140
しかし、のは、それが効果的だと仮定してみましょう
、ここから来ているので、1

726
00:31:31,140 --> 00:31:33,170
2個、3個、4個、5個。

727
00:31:33,170 --> 00:31:34,680
そして今、私はこれらのうちの40が必要です。

728
00:31:34,680 --> 00:31:37,540
だから、僕は提案するドット、ドット、ドットをやる
さらに多くのメモリががあること

729
00:31:37,540 --> 00:31:39,350
ヒープから戻ってくる。

730
00:31:39,350 --> 00:31:40,710
今のアドレスは何ですか？

731
00:31:40,710 --> 00:31:42,620
Let 'sは、私たちの任意を選択
いつものように対処 - 

732
00:31:42,620 --> 00:31:46,310
それはおそらく起こっているにもかかわらずOx123、
完全に異なるものになるように。

733
00:31:46,310 --> 00:31:50,420
それは最初のバイトのアドレスです
私は、mallocを求めていることをメモリ。

734
00:31:50,420 --> 00:31:53,630
>> だから短い、一度ラインに20が、実行
文字通り何ですか

735
00:31:53,630 --> 00:31:57,170
ここで、xの内部に格納されて？

736
00:31:57,170 --> 00:31:58,730
Ox123。

737
00:31:58,730 --> 00:32:00,370
Ox123。

738
00:32:00,370 --> 00:32:01,550
そして牛は面白くないさ。

739
00:32:01,550 --> 00:32:03,200
それだけだここで意味
進数。

740
00:32:03,200 --> 00:32:06,490
しかし、どのようなキーだと、私は店をしました何かということです
ローカル変数はx、である。

741
00:32:06,490 --> 00:32:10,260
再びしかし、そのデータ型、
int型のアドレスです。

742
00:32:10,260 --> 00:32:12,710
まあ、私はOx123を保存するつもりです。

743
00:32:12,710 --> 00:32:16,610
しかし、再び、それはあまりにも少ないのであれば
私はスクロールすると、不必要に複雑に

744
00:32:16,610 --> 00:32:21,490
背中、私たちは、この離れて抽象的なことができ非常に
合理的に、ちょうどxがあると言う

745
00:32:21,490 --> 00:32:23,910
メモリのチャンクへのポインタ。

746
00:32:23,910 --> 00:32:24,070
>> OK。

747
00:32:24,070 --> 00:32:26,230
手元に今の質問
次のようになります - 

748
00:32:26,230 --> 00:32:29,910
21行目は、それが判明した、バグがある。

749
00:32:29,910 --> 00:32:31,160
なぜですか？

750
00:32:31,160 --> 00:32:34,890

751
00:32:34,890 --> 00:32:36,930
>> 申し訳ありませんが？

752
00:32:36,930 --> 00:32:38,640
それは持っていません - 

753
00:32:38,640 --> 00:32:40,390
もう一度のことを言う。

754
00:32:40,390 --> 00:32:41,240
まあ、それは無料ではありません。

755
00:32:41,240 --> 00:32:42,350
だから、第二だが。

756
00:32:42,350 --> 00:32:45,000
だから、他の1が、特にはあり
21行で。

757
00:32:45,000 --> 00:32:49,480

758
00:32:49,480 --> 00:32:50,040
>> まさに。

759
00:32:50,040 --> 00:32:54,980
このコードのシンプルなラインだけである
バッファオーバーフロー、バッファオーバーラン。

760
00:32:54,980 --> 00:32:57,050
バッファは、単にメモリの塊を意味している。

761
00:32:57,050 --> 00:33:01,520
しかし、メモリのチャンクサイズである
我々ば意味10、10の整数、

762
00:33:01,520 --> 00:33:05,350
糖衣構文を使用してそれへのインデックス
配列表記、正方形の

763
00:33:05,350 --> 00:33:09,220
は、へのアクセスをブラケットを持っている
Xブラケット0 Xブラケット×1、

764
00:33:09,220 --> 00:33:10,390
ブラケットドット、ドット、ドット。

765
00:33:10,390 --> 00:33:13,270
Xブラケット9は最大のものです。

766
00:33:13,270 --> 00:33:17,680
だから私はXブラケット10、どこを行う場合
私は実際にメモリ上に行くよ？

767
00:33:17,680 --> 00:33:19,120
>> まあ、私は10 int型を持っている場合 - 

768
00:33:19,120 --> 00:33:21,070
実際にすべてを描画してみましょう
これらのうち、ここで。

769
00:33:21,070 --> 00:33:22,700
だから最初の5つでした。

770
00:33:22,700 --> 00:33:24,660
ここでは他の5のintです。

771
00:33:24,660 --> 00:33:29,580
だからXブラケット0はここにある。 Xブラケット1は
ここに。 Xブラケット9はここにある。 Xブラケット

772
00:33:29,580 --> 00:33:37,960
10は、私が語っていることを意味し、ここにある
ライン21において、コンピュータは置くために

773
00:33:37,960 --> 00:33:39,400
番号どこ？

774
00:33:39,400 --> 00:33:42,010
番号0？

775
00:33:42,010 --> 00:33:43,380
まあ、それは、はい0です。

776
00:33:43,380 --> 00:33:45,460
しかし、単に事実その0
偶然のようなものです。

777
00:33:45,460 --> 00:33:47,140
それは数字かもしれません
50、我々は気にすべてのために。

778
00:33:47,140 --> 00:33:50,480
しかし、我々はXブラケットでそれを置くことをしようとしている
これは10、

779
00:33:50,480 --> 00:33:53,700
疑問符は、描画される
良いことではありません。

780
00:33:53,700 --> 00:33:57,070
このプログラムは非常によくかもしれない
結果としてクラッシュ。

781
00:33:57,070 --> 00:33:59,400
>> それでは、先に行くと、この場合を見てみましょう
何が起こるか、確かに、ある。

782
00:33:59,400 --> 00:34:02,600
ファイルから、メモリを作る
memory.cのと呼ばれています。

783
00:34:02,600 --> 00:34:05,950
Let 'sは、先に行くと実行
プログラムメモリ。

784
00:34:05,950 --> 00:34:08,239
だから我々は幸運、実際に、それは思われる。

785
00:34:08,239 --> 00:34:09,340
我々は幸運。

786
00:34:09,340 --> 00:34:11,060
しかし、我々は今、Valgrindのを実行した場合見てみましょう。

787
00:34:11,060 --> 00:34:14,170
一見すると、私のプログラムは、かもしれない
完全に正しいと思われる。

788
00:34:14,170 --> 00:34:18,010
しかしでValgrindは私が実行してみましょう
 - 漏れチェックは、メモリ上で完全に等しい。

789
00:34:18,010 --> 00:34:20,110
>> そして今、私はこれを実行したときに - 

790
00:34:20,110 --> 00:34:21,030
興味深い。

791
00:34:21,030 --> 00:34:26,800
無効でサイズ4の書き込み
memory.cのの21行。

792
00:34:26,800 --> 00:34:29,284
memory.cのの21行目はどちらでしょうか？

793
00:34:29,284 --> 00:34:30,340
ああ、面白い。

794
00:34:30,340 --> 00:34:31,080
しかし、待ってください。

795
00:34:31,080 --> 00:34:32,389
サイズ4を参照することは何ですか？

796
00:34:32,389 --> 00:34:34,969
私は、1件のみが書いた
しかし、それはサイズ4のだ。

797
00:34:34,969 --> 00:34:36,889
なぜそれが4？

798
00:34:36,889 --> 00:34:39,280
それはint型だから、だた
、再び、4バイトです。

799
00:34:39,280 --> 00:34:42,510
だから、私はそのバグを見つけましたvalgrindの
私のコードをちらっと見、しませんでした。

800
00:34:42,510 --> 00:34:45,040
そして多分あなたのTFは、でしょうかではないでしょう。

801
00:34:45,040 --> 00:34:48,469
何でも、ことがわかった確かにValgrindは
私たちも、そこに間違いがあった

802
00:34:48,469 --> 00:34:52,719
我々は幸運だ、とでもコンピュータ
決めた、ええ、私はクラッシュするつもりはない

803
00:34:52,719 --> 00:34:57,470
あなたは1バイト、1に触れたという理由だけで
あなたはしませんでしたメモリのint型の価値

804
00:34:57,470 --> 00:34:58,550
実際に自分自身。

805
00:34:58,550 --> 00:35:00,380
>> さて、ここでバギーほかに何かある。

806
00:35:00,380 --> 00:35:01,180
アドレス - 

807
00:35:01,180 --> 00:35:03,190
これはクレイジー見てアドレスです
進した。

808
00:35:03,190 --> 00:35:06,890
ただどこかにヒープ内であることを意味すること
サイズ40のブロックの後にゼロバイト

809
00:35:06,890 --> 00:35:07,620
割り当てられている。

810
00:35:07,620 --> 00:35:10,610
私はここにズームアウトした場合を見てみましょう
これは、もう少し便利です。

811
00:35:10,610 --> 00:35:11,410
興味深い。

812
00:35:11,410 --> 00:35:15,600
40バイトは間違いなく失われ
1の損失レコード1インチ

813
00:35:15,600 --> 00:35:17,840
繰り返しになりますが、より多くの言葉はここに便利です。

814
00:35:17,840 --> 00:35:21,350
しかし、強調表示された行に基づいて
ここで私はおそらく私が焦点を当てるべきである

815
00:35:21,350 --> 00:35:24,070
別のバグのために注目？

816
00:35:24,070 --> 00:35:26,570
memory.cのの20行目のように見えます。

817
00:35:26,570 --> 00:35:30,990
>> 我々は、20行目に戻るのであれば、それはだ
以前に識別1。

818
00:35:30,990 --> 00:35:33,030
そしてそれは必ずしもバグではありません。

819
00:35:33,030 --> 00:35:35,160
しかし、我々は、これはその効果を逆転した。

820
00:35:35,160 --> 00:35:38,790
それでは、どのように私は、少なくとも修正か
それらの過ちの一つ？

821
00:35:38,790 --> 00:35:42,240
私は、21行目の後に何ができますか？

822
00:35:42,240 --> 00:35:47,110
私は、Xの自由され行うことができます
そのメモリをお返しします。

823
00:35:47,110 --> 00:35:49,230
そして、どのように私は、このバグを修正するのですか？

824
00:35:49,230 --> 00:35:52,120
私は間違いなく行くべき
ない遠く0より。

825
00:35:52,120 --> 00:35:53,670
だから私はこれを試してみて、再実行してみましょう。

826
00:35:53,670 --> 00:35:56,080
申し訳ありませんが、間違いなく行く
ない遠く9より。

827
00:35:56,080 --> 00:35:57,510
メモリを作る。

828
00:35:57,510 --> 00:36:00,650
私はValgrindのを再実行してみましょう
大きなウィンドウに表示されます。

829
00:36:00,650 --> 00:36:01,580
そして今見て。

830
00:36:01,580 --> 00:36:02,250
ニース。

831
00:36:02,250 --> 00:36:03,270
すべてのヒープブロックが解放された。

832
00:36:03,270 --> 00:36:04,270
漏れはできません。

833
00:36:04,270 --> 00:36:07,520
とここまで、上記の言及はありません
無効な右のいずれかより。

834
00:36:07,520 --> 00:36:09,820
>> ただ貪欲得る、としてみましょうする
別のデモかどうかを確認

835
00:36:09,820 --> 00:36:11,050
意図したとおりにいかない - 

836
00:36:11,050 --> 00:36:12,560
私は一瞬前に幸運でした。

837
00:36:12,560 --> 00:36:15,530
これが0であるという事実は、おそらくある
不必要な誤解を招く。

838
00:36:15,530 --> 00:36:20,650
わずか50、ある程度任意の操作を行いましょう
数、メモリドットスラッシュメモリを作る - 

839
00:36:20,650 --> 00:36:21,410
まだ幸運を得る。

840
00:36:21,410 --> 00:36:22,510
何もクラッシュするでしょう。

841
00:36:22,510 --> 00:36:26,150
私は本当に何かをすると仮定し
愚かな、私は100を行う。

842
00:36:26,150 --> 00:36:30,360
、私は記憶をリメイクしましょう
ドットスラッシュメモリ - 

843
00:36:30,360 --> 00:36:31,075
再び幸運。

844
00:36:31,075 --> 00:36:32,800
どのように約1,000？

845
00:36:32,800 --> 00:36:35,370
超え整数、大体、
私はどこにあるべきか？

846
00:36:35,370 --> 00:36:37,410
メモリを作る - 

847
00:36:37,410 --> 00:36:38,570
畜生。

848
00:36:38,570 --> 00:36:39,920
>> [笑い]

849
00:36:39,920 --> 00:36:41,270
>> OK。

850
00:36:41,270 --> 00:36:43,920
もう周りに台無しにしないでみましょう。

851
00:36:43,920 --> 00:36:45,120
メモリを再実行してください。

852
00:36:45,120 --> 00:36:45,840
そうしよう。

853
00:36:45,840 --> 00:36:46,410
わかりました。

854
00:36:46,410 --> 00:36:52,500
だから、明らかにあなたは、インデックス10万整数を
あなたにされているべき場所を越えて

855
00:36:52,500 --> 00:36:54,410
メモリ、悪いことが起こる。

856
00:36:54,410 --> 00:36:56,430
だから、これは明らかではない
硬い、速いルール。

857
00:36:56,430 --> 00:36:58,190
私はトライアルを使ってのようなものだった
とエラーが発生したを取得する。

858
00:36:58,190 --> 00:37:02,230
しかし、これは、長い話短いからである
コンピュータのメモリにも分かれています

859
00:37:02,230 --> 00:37:03,580
これらの事にセグメントと呼ばれる。

860
00:37:03,580 --> 00:37:07,260
そして、時には、コンピュータが実際
あなたに少しより多くのメモリを与えている

861
00:37:07,260 --> 00:37:08,400
あなたが求めるより。

862
00:37:08,400 --> 00:37:12,170
しかし、効率のために、それにだけ簡単だ
より多くのメモリを得るだけを教えてくれ

863
00:37:12,170 --> 00:37:13,780
あなたはそれの一部を取得していること。

864
00:37:13,780 --> 00:37:16,370
>> そして、あなたは時々幸運を得る場合には、
したがって、あなたが触れることができるかもしれない

865
00:37:16,370 --> 00:37:17,795
あなたに属していないメモリ。

866
00:37:17,795 --> 00:37:21,860
あなたは、その何か価値保証はありません
あなたは、そこに滞在します置くので

867
00:37:21,860 --> 00:37:25,080
コンピュータはまだそれがないと考えている
あなたが、それは必ずしもないだろう

868
00:37:25,080 --> 00:37:29,910
メモリの別のセグメントをヒットする
コンピュータとミスを誘発するような

869
00:37:29,910 --> 00:37:31,710
ここでこの1。

870
00:37:31,710 --> 00:37:32,060
わかりました。

871
00:37:32,060 --> 00:37:37,240
その後、メモリ上の任意の質問は？

872
00:37:37,240 --> 00:37:37,590
>> わかりました。

873
00:37:37,590 --> 00:37:40,610
で、その後、のはここで見てみましょう
我々が取ってきたもの

874
00:37:40,610 --> 00:37:48,361
かなりの時間が与えられ、その
cs50.h.と呼ばれるこのファイルにある

875
00:37:48,361 --> 00:37:49,420
だから、これはファイルです。

876
00:37:49,420 --> 00:37:51,130
これらは全体の集まりです
トップまでのコメント。

877
00:37:51,130 --> 00:37:53,900
そして、あなたは、この場合を見たかもしれない
アプライアンス上で周りに突き。

878
00:37:53,900 --> 00:37:57,000
しかし、それは、そのすべての時間が判明
我々は次のように文字列を使用するために使用される場合

879
00:37:57,000 --> 00:38:01,130
同義語、我々は宣言するための手段
その同義語はこれであった

880
00:38:01,130 --> 00:38:03,990
型定義のtypedefキーワード。

881
00:38:03,990 --> 00:38:07,500
そして、我々は本質的に言っている、メイク
charの星のシノニムを文字列。

882
00:38:07,500 --> 00:38:11,190
によってスタックを意味すること
として知られているこれらの補助輪を作成しました

883
00:38:11,190 --> 00:38:12,040
文字列。

884
00:38:12,040 --> 00:38:14,830
>> 今ここにはただのプロトタイプだ
getchar関数のために。

885
00:38:14,830 --> 00:38:17,350
我々は前にそれを見たかもしれないが、それはだ
確かにそれが何をするか。 getchar関数

886
00:38:17,350 --> 00:38:19,070
引数を取らない、charが返されます。

887
00:38:19,070 --> 00:38:21,340
getDoubleはは、引数をとりません
二重を返します。

888
00:38:21,340 --> 00:38:24,440
getFloatは、引数なし、戻りを受け取り
フロートなどが挙げられる。

889
00:38:24,440 --> 00:38:27,270
場合、getIntがここにあります。 getlonglong
ここにあります。

890
00:38:27,270 --> 00:38:28,820
とGetStringメソッドがここにあります。

891
00:38:28,820 --> 00:38:29,420
そして、それはそれだ。

892
00:38:29,420 --> 00:38:33,080
この紫の線は、他のプリプロセッサです
ためのディレクティブ

893
00:38:33,080 --> 00:38:35,550
その冒頭ハッシュタグ。

894
00:38:35,550 --> 00:38:35,870
>> わかりました。

895
00:38:35,870 --> 00:38:38,380
だから今私はcs50.c.に手放す

896
00:38:38,380 --> 00:38:40,400
そして、私たちはこれに長すぎる話はありません。

897
00:38:40,400 --> 00:38:43,280
しかし、あなたに何を垣間見るを与えるために
このすべてが起こってき

898
00:38:43,280 --> 00:38:46,434
時間は、私に行こう - 

899
00:38:46,434 --> 00:38:48,250
getchar関数行うみましょう。

900
00:38:48,250 --> 00:38:51,050
だからgetchar関数はほとんどのコメントである。

901
00:38:51,050 --> 00:38:52,060
しかし、それはこのようになります。

902
00:38:52,060 --> 00:38:54,800
だから、これは実際の関数である
我々がしてきたことをgetchar関数

903
00:38:54,800 --> 00:38:56,055
当たり前の取ることは存在しています。

904
00:38:56,055 --> 00:38:59,370
そして、我々はこのいずれかを使用していないにもかかわらず、
かつてなら、多くの場合、それは、少なくともだという

905
00:38:59,370 --> 00:39:00,470
比較的簡単。

906
00:39:00,470 --> 00:39:02,580
だから、取って価値がある
ここで簡単に見。

907
00:39:02,580 --> 00:39:06,540
>> だからgetchar関数は、無限ループを持っている
意図的にそう明らかに。

908
00:39:06,540 --> 00:39:10,050
その後、呼び出し - これはのようなものです
私達は私達自身が書いたコードの再利用をニース。

909
00:39:10,050 --> 00:39:11,220
これは、GetStringメソッドを呼び出します。

910
00:39:11,220 --> 00:39:12,460
それを何ので
char型を取得する意味ですか？

911
00:39:12,460 --> 00:39:14,730
さて、あなたは同様に取得しようとするかもしれません
ユーザーからのテキストの行全体と

912
00:39:14,730 --> 00:39:16,940
そしてちょうど1を見て
それらの文字の。

913
00:39:16,940 --> 00:39:19,170
60行目では、ここで少しだ
健全性チェックのビット。

914
00:39:19,170 --> 00:39:21,610
GetStringメソッドがnullを返した場合は、
続行のないようにしましょう​​。

915
00:39:21,610 --> 00:39:22,820
何かが間違っていた。

916
00:39:22,820 --> 00:39:28,120
>> さて、これは多少面倒ですが、
おそらくC. charの最大値で、従来

917
00:39:28,120 --> 00:39:29,960
何を表しているかだけ
その名前に基づいて？

918
00:39:29,960 --> 00:39:31,670
それは一定です。

919
00:39:31,670 --> 00:39:36,040
それは数値のようなものだ
あなたと表すことができる最大のchar

920
00:39:36,040 --> 00:39:40,370
おそらく数です一口、
最大の数はあなたです255、

921
00:39:40,370 --> 00:39:42,720
、8ビットを表す
ゼロから始まる。

922
00:39:42,720 --> 00:39:47,460
だから私は、ときに、この関数では、これを使用しました
理由だけで、このコードを書く

923
00:39:47,460 --> 00:39:51,753
何かがgetchar関数でうまくいかない場合が、
生活の中でその目的は返すことです

924
00:39:51,753 --> 00:39:54,830
char型は、何とかできるようにする必要があります
そのユーザに通知する

925
00:39:54,830 --> 00:39:55,840
何かが間違っていた。

926
00:39:55,840 --> 00:39:56,970
我々は、nullを返すことはできません。

927
00:39:56,970 --> 00:39:58,480
それはヌルポインタであることが判明した。

928
00:39:58,480 --> 00:40:01,030
そして再び、getchar関数は持って
char型を返します。

929
00:40:01,030 --> 00:40:04,760
>> だから規則は、何かになった場合
間違った、またはで、プログラマ、あなたです

930
00:40:04,760 --> 00:40:08,160
この場合、私にライブラリと、私が持っていた
場合だけ、任意に決める

931
00:40:08,160 --> 00:40:12,230
何かがうまくいかない、私はするつもりです
本当にある数字255を返す

932
00:40:12,230 --> 00:40:17,240
我々は、ユーザが入力することはできませんができないことを意味
で表現される文字

933
00:40:17,240 --> 00:40:21,410
我々が持っていたので、番号255はそれを盗む
いわゆるセンチネル値としての

934
00:40:21,410 --> 00:40:23,410
問題を表しています。

935
00:40:23,410 --> 00:40:27,010
今では判明しているキャラクター255
あなたが入力できるものではありません

936
00:40:27,010 --> 00:40:28,380
あなたのキーボードは、ので、それは大したことではありません。

937
00:40:28,380 --> 00:40:30,910
ユーザーが気付かないこと
私はこの文字を盗んだ。

938
00:40:30,910 --> 00:40:34,620
しかし、あなたはこれまでのmanページに表示される場合
コンピュータシステムには、いくつかの基準

939
00:40:34,620 --> 00:40:38,560
一定のこのようなすべてのキャップと言い、
エラーの場合、この定数は、かもしれない

940
00:40:38,560 --> 00:40:42,720
すべてのいくつかの人間だと、返された
数年前に任意に決定されました

941
00:40:42,720 --> 00:40:45,680
この特別な値を返し、
それに一定の場合に呼び出す

942
00:40:45,680 --> 00:40:46,840
何かがうまくいかない。

943
00:40:46,840 --> 00:40:48,580
>> 今、マジックはここダウンが起こる。

944
00:40:48,580 --> 00:40:52,600
まず、私は67行で宣言しています
二つの文字、C1とC2。

945
00:40:52,600 --> 00:40:57,080
そして68行目で、実際にそこ
を彷彿とさせるのコード行

946
00:40:57,080 --> 00:41:01,140
そのことを考えるとprintfの私たちの友人、
引用符でCsの割合を持っていません。

947
00:41:01,140 --> 00:41:06,490
しかし、ここで何が起こっているかに気づく。
sscanf関数は、文字列のスキャンを意味します - 

948
00:41:06,490 --> 00:41:11,690
フォーマットされたスキャンを意味します
文字列、エルゴsscanf関数。

949
00:41:11,690 --> 00:41:12,590
どういう意味ですか？

950
00:41:12,590 --> 00:41:16,310
それはあなたが文字列をsscanf関数に渡すことを意味します。

951
00:41:16,310 --> 00:41:18,420
とラインが何である
ログインユーザーの種類

952
00:41:18,420 --> 00:41:23,520
あなたのような形式の文字列をsscanf関数に渡す
何ですscanf関数を伝え、この

953
00:41:23,520 --> 00:41:25,870
あなたは、ユーザーがログイン入力したことを望んで

954
00:41:25,870 --> 00:41:29,730
その後、合格イン2のアドレス
この場合のメモリの塊、、

955
00:41:29,730 --> 00:41:31,150
私には2つのプレースホルダを持っているからです。

956
00:41:31,150 --> 00:41:34,610
だから私はそれにアドレスを与えるつもりだ
C1とC2のアドレス。

957
00:41:34,610 --> 00:41:37,700
>> そして、あなたが機能を与えることを思い出してください
いくつかの変数のアドレス、何

958
00:41:37,700 --> 00:41:38,950
意味合い？

959
00:41:38,950 --> 00:41:41,400

960
00:41:41,400 --> 00:41:45,050
その関数は、結果として何ができる
それのアドレスを与える

961
00:41:45,050 --> 00:41:48,170
変数とは対照的に
変数そのもの？

962
00:41:48,170 --> 00:41:49,450
それは右、それを変更することができますか？

963
00:41:49,450 --> 00:41:53,250
あなたは、物理的に誰かマップを持っていた場合
アドレスは、彼らはそこに行くと何ができる

964
00:41:53,250 --> 00:41:54,750
彼らはそのアドレスで好き。

965
00:41:54,750 --> 00:41:55,800
ここで同じ考え。

966
00:41:55,800 --> 00:41:59,950
我々はsscanf関数、2のアドレスに渡す場合
メモリのチャンクも、これらの小さな

967
00:41:59,950 --> 00:42:03,585
メモリ、C1、C2の少しの塊が、
我々はそれにそれらのアドレスを教えて

968
00:42:03,585 --> 00:42:05,170
sscanf関数は、それを変更することができます。

969
00:42:05,170 --> 00:42:08,530
>> 人生のsscanf関数の目的はそう、私たちが読む場合
manページには、読むこととは何か

970
00:42:08,530 --> 00:42:13,420
で入力したユーザーは、あるユーザの希望
多分文字で入力し、

971
00:42:13,420 --> 00:42:16,470
別の文字、そしてどのようなユーザ
入力された、最初の文字が行く

972
00:42:16,470 --> 00:42:19,310
ここで、第二の文字はここに行く。

973
00:42:19,310 --> 00:42:22,470
さて、余談ですが、この、あなたはでしょう
のみ、ドキュメントからこれを知っている

974
00:42:22,470 --> 00:42:25,570
私はそこに空白を入れているという事実
ちょうど私があれば気にしないことを意味します

975
00:42:25,570 --> 00:42:28,440
ユーザーは、いくつかのスペースバーを打つ
彼または彼女は取り回前

976
00:42:28,440 --> 00:42:30,400
文字、私は無視するつもりです
空白。

977
00:42:30,400 --> 00:42:32,510
ように、私が知っているから
マニュアルを参照してください。

978
00:42:32,510 --> 00:42:36,570
>> 第二％cはそこだという事実
空白が続くが、実際に

979
00:42:36,570 --> 00:42:37,410
意図的。

980
00:42:37,410 --> 00:42:41,190
私は、検出できるようにしたい場合は、ユーザー
めちゃくちゃか協力していませんでした。

981
00:42:41,190 --> 00:42:45,630
だから私は、ユーザーが入力しただけで期待している
一文字で、従って私は願っています

982
00:42:45,630 --> 00:42:50,640
そのsscanf関数のみを返すために起こっている
値1は、私が読んでいる場合は、再度、なぜなら

983
00:42:50,640 --> 00:42:55,400
ドキュメンテーション、sscanf関数の目的で
寿命は数に戻すことです

984
00:42:55,400 --> 00:42:59,170
充填した変数
ユーザー入力を持つ。

985
00:42:59,170 --> 00:43:02,270
>> 私は、2つの変数で渡さ
アドレス、C1とC2。

986
00:43:02,270 --> 00:43:06,420
私の唯一のことは、しかし、願っています
彼らは殺されるためならsscanf関数

987
00:43:06,420 --> 00:43:11,130
2を返し、おそらく何
論理的に含意？

988
00:43:11,130 --> 00:43:14,600
ユーザーは、ちょうど私1を与えていないこと
文字のように私は彼に言ったまたは彼女。

989
00:43:14,600 --> 00:43:17,860
彼らはおそらくで入力
少なくとも2文字。

990
00:43:17,860 --> 00:43:22,430
だから私は、代わりに第二を持っていなかった場合
％cは、私はちょうど、ものを持っていた

991
00:43:22,430 --> 00:43:25,370
率直に言って、より直感的になります
アプローチ、私は一目見ただけだと思い、

992
00:43:25,370 --> 00:43:30,220
あなたを検出できるようにするつもりはない
ユーザーがより多くのことを与えている場合に

993
00:43:30,220 --> 00:43:31,780
あなたが実際に望んでも入力。

994
00:43:31,780 --> 00:43:34,100
だから、これは暗黙の形です
エラーチェックの。

995
00:43:34,100 --> 00:43:35,640
>> しかし、私がここで何をすべきかに気づく。

996
00:43:35,640 --> 00:43:39,970
かつて私は、ユーザーが私に1を与えたと確信している
キャラクターは、私がやって、ラインを解放

997
00:43:39,970 --> 00:43:44,450
GetStringメソッドの反対、どの順番に
malloc関数を使用していますし、私は戻ります

998
00:43:44,450 --> 00:43:51,030
C1、私が期待している文字
ユーザーが提供する、唯一の提供。

999
00:43:51,030 --> 00:43:54,680
だから速いだけ垣間見たが、
getchar関数の質問？

1000
00:43:54,680 --> 00:43:57,450

1001
00:43:57,450 --> 00:43:59,590
私たちは他人のいくつかに戻ってくる。

1002
00:43:59,590 --> 00:44:03,770
>> まあ、私が先に行くと、これをやらせる - 
ちょうど私たちのやる気を引き出すために、今、仮定

1003
00:44:03,770 --> 00:44:08,910
週プラス時間の議論、この
structs.hと呼ばれるファイルです。

1004
00:44:08,910 --> 00:44:11,440
そして再び、これはただの味です
待ち受けている何かの。

1005
00:44:11,440 --> 00:44:13,090
しかし予告その多く
これのコメントです。

1006
00:44:13,090 --> 00:44:17,440
だから私は唯一のハイライト表示さ​​せ
今のところ面白い部分。

1007
00:44:17,440 --> 00:44:18,020
typedefは - 

1008
00:44:18,020 --> 00:44:19,700
同じキーワードが再びあり。

1009
00:44:19,700 --> 00:44:23,100
typedefは、文字列を宣言するために使用
特殊なデータ型である。

1010
00:44:23,100 --> 00:44:27,490
あなたは、新しいブランドを作成するためにtypedefを使用することができます
存在していなかったデータ型

1011
00:44:27,490 --> 00:44:28,570
Cが発明されました。

1012
00:44:28,570 --> 00:44:32,520
例えば、int型はC.イワナが付属しています
C.二重に付属しているC.が付属していますしかし、

1013
00:44:32,520 --> 00:44:34,000
学生の概念はありません。

1014
00:44:34,000 --> 00:44:37,230
そしてまだそれがあることが非常に有用であろう
格納するプログラムを書くことができる

1015
00:44:37,230 --> 00:44:40,440
変数に、学生のID番号、
自分の名前、そして彼らの家。

1016
00:44:40,440 --> 00:44:42,890
言い換えれば、三枚で
int型などのデータの

1017
00:44:42,890 --> 00:44:44,420
文字列と別の文字列。

1018
00:44:44,420 --> 00:44:48,220
>> typedefを使用すると、何はかなり強力です
このとのキーワードsturctについて

1019
00:44:48,220 --> 00:44:53,660
構造は、、2013年にプログラマー、
実際にあなた自身を定義することができます

1020
00:44:53,660 --> 00:44:57,530
年間存在していなかったデータ型
前にそれはあなたの目的に合わせ。

1021
00:44:57,530 --> 00:45:01,910
そしてここで、行19〜13で、
我々は次のように、新しいデータ型を宣言している

1022
00:45:01,910 --> 00:45:04,320
int型が、学生呼び出し。

1023
00:45:04,320 --> 00:45:09,310
そして、この変数の内部がために起こっている
int型、文字列、 - 三つのことである

1024
00:45:09,310 --> 00:45:09,930
と文字列。

1025
00:45:09,930 --> 00:45:13,040
だから、あなたは本当に何を考えることができます
この場合でも、ここで起こっ

1026
00:45:13,040 --> 00:45:17,160
今日のための簡素化のビット、
学生は基本的に起こっている

1027
00:45:17,160 --> 00:45:19,450
このように見える。

1028
00:45:19,450 --> 00:45:22,580
そのはの塊になるだろう
IDを持つメモリ、名前

1029
00:45:22,580 --> 00:45:25,580
フィールド、および社内フィールド。

1030
00:45:25,580 --> 00:45:30,670
そして、私たちはそれらのチャンクを使用することができるでしょう
メモリ、それらを以下のようにアクセスします。

1031
00:45:30,670 --> 00:45:38,870
>> 私はstruct0.cに行けば、ここにある
比較的長いが、以下の

1032
00:45:38,870 --> 00:45:42,630
コー​​ドのパターンは、その
この新たなトリックを使用しています。

1033
00:45:42,630 --> 00:45:45,790
だから最初に、私はあなたの注意を引くましょう
トップまでの興味深い部分へ。

1034
00:45:45,790 --> 00:45:49,670
シャープは、学生3が定義され、宣言
定数と呼ばれる学生および譲受人

1035
00:45:49,670 --> 00:45:53,450
それだけで任意に番号3、
ので、私は3人の学生を使っています

1036
00:45:53,450 --> 00:45:54,830
今のところこのプログラム。

1037
00:45:54,830 --> 00:45:55,960
ここでメインが来る。

1038
00:45:55,960 --> 00:45:58,860
と通知は、どのように私は宣言しない
学生の配列？

1039
00:45:58,860 --> 00:46:00,480
まあ、私はちょうど同じ構文を使用します。

1040
00:46:00,480 --> 00:46:02,110
単語の学生は明らかに新しく追加されました。

1041
00:46:02,110 --> 00:46:04,790
しかし、学生、クラス、ブラケットの学生。

1042
00:46:04,790 --> 00:46:06,720
>> だから、残念ながら多くはあり
ここで用語の再利用。

1043
00:46:06,720 --> 00:46:07,660
これはただの数字です。

1044
00:46:07,660 --> 00:46:09,040
だから、これは、3つを言うようなものです。

1045
00:46:09,040 --> 00:46:11,430
クラスは、私が何をしたいだけです
変数を呼び出すことができます。

1046
00:46:11,430 --> 00:46:12,840
私はそれを生徒呼び出すことができます。

1047
00:46:12,840 --> 00:46:15,880
しかしクラスは、これはでクラスではありません
道のオブジェクト指向のJava一種。

1048
00:46:15,880 --> 00:46:17,220
それはちょうど学生のクラスです。

1049
00:46:17,220 --> 00:46:20,590
そして、すべての要素のデータ型
その配列の学生です。

1050
00:46:20,590 --> 00:46:23,040
だから、これは少々異なっています
と何かを言ってから

1051
00:46:23,040 --> 00:46:25,250
このように、それだけだ - 

1052
00:46:25,250 --> 00:46:29,500
私は私に3人の学生を与えて言っている
その配列クラスを呼び出します。

1053
00:46:29,500 --> 00:46:29,800
>> わかりました。

1054
00:46:29,800 --> 00:46:30,680
今ここには、4つのループです。

1055
00:46:30,680 --> 00:46:33,480
この男の精通 - 反復
アップでゼロから3まで。

1056
00:46:33,480 --> 00:46:35,160
そしてここでは、構文の新しい部分です。

1057
00:46:35,160 --> 00:46:37,710
このプログラムは、私を促すために起こっている
それを生徒に与えるために人間、

1058
00:46:37,710 --> 00:46:39,200
intでID、。

1059
00:46:39,200 --> 00:46:44,650
そしてここでは、あなたがすることができるとの構文だ
で、IDフィールドに何かを保存する

1060
00:46:44,650 --> 00:46:48,630
場所クラスブラケットI.だから
この構文は、新しいものではありません。

1061
00:46:48,630 --> 00:46:51,450
これはちょうど私に八を与えることを意味し
クラスの生徒。

1062
00:46:51,450 --> 00:46:52,940
しかし、このシンボルは、新しく追加されました。

1063
00:46:52,940 --> 00:46:56,320
今まで、我々は、ドットを使用していないことができました
少なくともこのようなコードである。

1064
00:46:56,320 --> 00:47:01,490
これはとして知られている構造体に行くことを意味し
学生とそこに何かを置く。

1065
00:47:01,490 --> 00:47:05,670
同様に、この次の行に、31、行く
先とどのようなユーザーがタイプを置く

1066
00:47:05,670 --> 00:47:10,530
ここに名前のために、どのような彼らが行う
家、同じことが、先に行くと、

1067
00:47:10,530 --> 00:47:13,230
。家の中にそれを置く。

1068
00:47:13,230 --> 00:47:15,955
>> したがって、このプログラムが何をし
最終的にでしょうか？

1069
00:47:15,955 --> 00:47:17,220
あなたはそこに少しのティーザーを見ることができます。

1070
00:47:17,220 --> 00:47:24,780
私が先に行くと構造0を作るのですかしましょう
ドットスラッシュ構造体0、学生のID 1、

1071
00:47:24,780 --> 00:47:28,250
デビッド·メイザー、学生のID 2と言う。

1072
00:47:28,250 --> 00:47:32,070
ロブカークランド、学生ID 3。

1073
00:47:32,070 --> 00:47:35,010
ローレンLeverit  - 

1074
00:47:35,010 --> 00:47:38,380
このプログラムはやった唯一の事、
これは、単に完全に任意です

1075
00:47:38,380 --> 00:47:40,980
私は、このデータを使って何かをやってみたかった
私はどのように教えてくれたことを今

1076
00:47:40,980 --> 00:47:43,450
構造体を使用し、私は持っていたです
ここに、この余分なループ。

1077
00:47:43,450 --> 00:47:45,260
私は学生の配列を反復。

1078
00:47:45,260 --> 00:47:49,170
私は今、おそらく、おなじみの友人たちのを使用した、
文字列は、に、stircompを比較

1079
00:47:49,170 --> 00:47:53,780
チェックは、第8回学生の家です
メイザーに等しい？

1080
00:47:53,780 --> 00:47:56,760
そしてもしそうならば、単に何かを印刷
任意に好きな、はい、それはです。

1081
00:47:56,760 --> 00:47:59,430
しかし、再び、ちょうど私にチャンスを与える
使用して再利用し、

1082
00:47:59,430 --> 00:48:02,270
この新しいドット表記を再利用します。

1083
00:48:02,270 --> 00:48:03,250
>> だから、誰が右、気に？

1084
00:48:03,250 --> 00:48:06,270
学生のプログラムを考え出すことです。
ある程度任意、それが判明した

1085
00:48:06,270 --> 00:48:09,800
私たちは便利で物事を行うことができます
これは、例えば以下の通りである。

1086
00:48:09,800 --> 00:48:14,600
これは、はるかに複雑構造体です
Cでこれは、ダース以上のフィールドを持っている

1087
00:48:14,600 --> 00:48:15,880
多少ひそか名前。

1088
00:48:15,880 --> 00:48:20,110
しかし、あなたはこれまでグラフィックスのことを聞いてしまった場合
ビットマップと呼ばれるファイル形式、BMP、それ

1089
00:48:20,110 --> 00:48:22,830
ビットマップファイルの形式が判明
かなりこのことのように見えます。

1090
00:48:22,830 --> 00:48:24,200
それは愚かな少しスマイリーフェイスです。

1091
00:48:24,200 --> 00:48:27,840
それは私がにズームしたことを小さな画像だ
かなり大きなに私はそれぞれを見ることができるように

1092
00:48:27,840 --> 00:48:30,410
各ドットまたはピクセル。

1093
00:48:30,410 --> 00:48:33,800
我々は表すことができますうちさて、それは回り
番号0、と言うと黒のドット。

1094
00:48:33,800 --> 00:48:35,520
番号1と白のドット。

1095
00:48:35,520 --> 00:48:39,140
>> だから、他の言葉で、あなたが描きたい場合
スマイリーフェイスとでその画像を保存する

1096
00:48:39,140 --> 00:48:42,680
コンピュータ、それがゼロを格納するために十分であると
このように見えるものは、どこで、

1097
00:48:42,680 --> 00:48:45,250
再び、ものは白です
そしてゼロは黒です。

1098
00:48:45,250 --> 00:48:48,290
と一緒に、あなたが効果的に持っている場合
1と0の身構える、あなたが持っている

1099
00:48:48,290 --> 00:48:51,030
ピクセルのグリッド、あなたが横たわっていた場合
それらのうち、あなたはかわいいを持って

1100
00:48:51,030 --> 00:48:52,560
少しスマイリーフェイス。

1101
00:48:52,560 --> 00:48:58,150
ここで、ビットマップファイルフォーマット、BMPである
効果的にそのフードの下に、

1102
00:48:58,150 --> 00:49:00,970
しかし、より多くのピクセルSOTでそのあなた
実際に色を表すことができます。

1103
00:49:00,970 --> 00:49:05,170
>> しかし、あなたはより洗練されているとき
BMPやJPEGやGIFなどのファイル形式

1104
00:49:05,170 --> 00:49:09,360
これであなたは、それらのおなじみのかもしれない
ディスク上のファイルだけでなく、一般的に

1105
00:49:09,360 --> 00:49:13,760
画素に対して0と1を持っているが、
彼らは同様にいくつかのメタデータを持っている - 

1106
00:49:13,760 --> 00:49:16,960
実際にはない意味でメタ
データは、それが持っていると便利です。

1107
00:49:16,960 --> 00:49:21,370
だからここに、これらのフィールドが示唆され、
我々はP-セットで詳細にこれを表示されます

1108
00:49:21,370 --> 00:49:25,810
5、その0と1その前に
、画像内の画素を表す

1109
00:49:25,810 --> 00:49:29,110
メタデータの束のようにあり
画像のサイズと

1110
00:49:29,110 --> 00:49:30,250
画像の幅。

1111
00:49:30,250 --> 00:49:32,910
そして、私はいくつかをオフに摘採よ気づく
ここで任意のもの - 

1112
00:49:32,910 --> 00:49:34,260
幅と高さ。

1113
00:49:34,260 --> 00:49:36,160
ビット数といくつか他のもの。

1114
00:49:36,160 --> 00:49:37,840
だから、ファイル内のいくつかのメタデータはあり。

1115
00:49:37,840 --> 00:49:41,470
>> しかし、ファイルが配置されてどのように理解することによって
このように外に、あなたが実際にすることができます

1116
00:49:41,470 --> 00:49:45,890
その後、画像を操作、イメージを回復する
ディスクから、画像のサイズを変更します。

1117
00:49:45,890 --> 00:49:47,560
しかし、あなたは必ずしもできません
それらを強化する。

1118
00:49:47,560 --> 00:49:48,480
私は写真を必要としていました。

1119
00:49:48,480 --> 00:49:52,840
だから私はあなたが見た人は、ここでRJに戻った
画面上でかなりの時間前。

1120
00:49:52,840 --> 00:49:57,160
私はここで基調講演を開く場合には、これは
あなたがして拡大しようとすると何が起こる

1121
00:49:57,160 --> 00:49:59,380
RJを高める。

1122
00:49:59,380 --> 00:50:01,480
彼は本当に任意の良くなっていない。

1123
00:50:01,480 --> 00:50:06,240
今基調はぼかしの一種である
少しだけをごまかすため

1124
00:50:06,240 --> 00:50:11,040
RJは特に取得していないという事実
あなたはズームイン強化

1125
00:50:11,040 --> 00:50:13,310
そして、このようにそれを行う場合、
正方形を参照してください？

1126
00:50:13,310 --> 00:50:15,490
うん、あなたは間違いなく見ることができます
プロジェクタの正方形。

1127
00:50:15,490 --> 00:50:17,690
>> それはあなたが強化したときにあなたが得るものです。

1128
00:50:17,690 --> 00:50:22,570
しかし、理解する上でどのように我々のRJまたは
スマイリーフェイスは、私たちにできるようになる実装されています

1129
00:50:22,570 --> 00:50:24,950
実際に操作するコードを記述する
これらの事。

1130
00:50:24,950 --> 00:50:29,970
そして私はと、私はこの調子で終わるだろうと思っていた
の55秒高めだが、

1131
00:50:29,970 --> 00:50:31,230
私はむしろ誤解を招くと言う、あえて。

1132
00:50:31,230 --> 00:50:32,990
>> [ビデオの再生]

1133
00:50:32,990 --> 00:50:34,790
>>  - 彼が横たわっている。

1134
00:50:34,790 --> 00:50:38,310
かについて、私は知らない。

1135
00:50:38,310 --> 00:50:41,200
>>  - だから、私たちは何を知っていますか？

1136
00:50:41,200 --> 00:50:45,280
>> 9時15分レイSantoyaアットそれ
ATMにあった。

1137
00:50:45,280 --> 00:50:47,830
>>  - だから、質問は何ですか
彼は9時16でやっていた？

1138
00:50:47,830 --> 00:50:50,750
>> シューティング9ミリメートル
何かで。

1139
00:50:50,750 --> 00:50:52,615
たぶん彼は、狙撃兵を見た。

1140
00:50:52,615 --> 00:50:54,760
>>  - または彼と一緒に働いていた。

1141
00:50:54,760 --> 00:50:56,120
>>  - 待って。

1142
00:50:56,120 --> 00:50:57,450
1戻る。

1143
00:50:57,450 --> 00:50:58,700
>>  - あなたは何を見ていますか？

1144
00:50:58,700 --> 00:51:05,530

1145
00:51:05,530 --> 00:51:09,490
>> 、フルスクリーンで彼の顔をアップ持参。

1146
00:51:09,490 --> 00:51:09,790
>>  - 彼のメガネ。

1147
00:51:09,790 --> 00:51:11,040
>>  - そこ反射です。

1148
00:51:11,040 --> 00:51:21,790

1149
00:51:21,790 --> 00:51:23,520
>>  - それはNeuvitas野球チームです。

1150
00:51:23,520 --> 00:51:24,530
それは彼らのロゴです。

1151
00:51:24,530 --> 00:51:27,040
>>  - そして、彼は誰のに話している
そのジャケットを着て。

1152
00:51:27,040 --> 00:51:27,530
>> [ENDビデオ再生]

1153
00:51:27,530 --> 00:51:29,180
>> DAVID J.マラン：これは意志
問題セット5である。

1154
00:51:29,180 --> 00:51:30,720
私たちは、来週お会いしましょう​​。

1155
00:51:30,720 --> 00:51:32,330
>> 男性話者：次のCS50で。

1156
00:51:32,330 --> 00:51:39,240
>> [CRICKETSはさえずり]

1157
00:51:39,240 --> 00:51:41,270
>> [音楽再生]