1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:11,261
[音楽再生]

3
00:00:11,261 --> 00:00:12,640
>> DAVID J.マラン：すべての権利。

4
00:00:12,640 --> 00:00:14,525
これはCS50である。

5
00:00:14,525 --> 00:00:16,009
そして、これは週5の開始である。

6
00:00:16,009 --> 00:00:18,050
そして、あなたは気づいている可能性がある、
材料の一部

7
00:00:18,050 --> 00:00:21,050
もう少しを得ている
複雑な、少しより高密度。

8
00:00:21,050 --> 00:00:24,560
>> そして、それは、特に場合、非常に簡単です
あなたは、いくつかの時間を習慣にしてきた

9
00:00:24,560 --> 00:00:28,600
ほとんどのダウン走り書きしようとしているように
私たちは何でも、私達はクラスで言っている。

10
00:00:28,600 --> 00:00:31,626
しかし、それはおそらくありませんが、実現
理想的な教育学的アプローチ

11
00:00:31,626 --> 00:00:34,250
この種の材料を学ぶために、
材料より一般的。

12
00:00:34,250 --> 00:00:37,250
そして、私たちはして満足している
そのCS50自身Ghengを発表

13
00:00:37,250 --> 00:00:39,780
ゴングが準備を始めている
ノートの標準的なセット

14
00:00:39,780 --> 00:00:42,100
コー​​スの希望
これは、これらは、その一つである

15
00:00:42,100 --> 00:00:44,030
だけでなく、として機能
リファレンスとリソース

16
00:00:44,030 --> 00:00:47,410
材料の見直しや行くため
バックかもしれない材料を通る

17
00:00:47,410 --> 00:00:51,230
あなたの最初の頃を免れたが、
また、ヘッドはもっとできるように

18
00:00:51,230 --> 00:00:53,740
ダウン、ときにそれをよりアップ
講義を時間が来る、

19
00:00:53,740 --> 00:00:56,960
あなたが従事する可能性がありますように
もっと思慮深く、として

20
00:00:56,960 --> 00:00:59,170
もっとscribblyに反対。

21
00:00:59,170 --> 00:01:02,510
>> ということで、あなたは何を見つける
ウェブサイトは、このようなドキュメントである。

22
00:01:02,510 --> 00:01:04,660
そして、通知は、左上にある、あります
目次だけではなく、

23
00:01:04,660 --> 00:01:06,920
だけでなく、タイムコード、その
すぐにジャンプします

24
00:01:06,920 --> 00:01:09,077
適切な部分へ
ビデオオンラインでの。

25
00:01:09,077 --> 00:01:11,410
そしてここでチャンは何を行っている
、本質的に、文書化されています

26
00:01:11,410 --> 00:01:13,340
この中で何が起こった
特定の講義。

27
00:01:13,340 --> 00:01:16,370
そして、講義の多くは、
すでにオンライン今、このURLに置き換えてください。

28
00:01:16,370 --> 00:01:20,110
そして私達は残りを掲載していきます
今週の終わりまでにそれらの、

29
00:01:20,110 --> 00:01:22,380
その結果、リソースを活用します。

30
00:01:22,380 --> 00:01:25,740
>> だから、前置きなしに、
私たちは戻って剥離し始めた

31
00:01:25,740 --> 00:01:28,180
されている層
しばらくの文字列。

32
00:01:28,180 --> 00:01:30,670
そして、私たちは、文字列を何と言った
実際に先週は何ですか？

33
00:01:30,670 --> 00:01:31,720

34
00:01:31,720 --> 00:01:32,900
だからチャースター。

35
00:01:32,900 --> 00:01:34,900
チャースター、よく、どのような
それは本当に意味した？

36
00:01:34,900 --> 00:01:37,150
さて、このすべての時間、私たちはしている場合
関数を呼び出すされて、

37
00:01:37,150 --> 00:01:40,450
のgetStringと、記憶などの
いわゆるリターン

38
00:01:40,450 --> 00:01:42,910
内のgetStringの値
それは呼ばれていますvariable--

39
00:01:42,910 --> 00:01:47,721
私たちが書いてきたstring-- Sタイプ
そこまで上記のコードの行。

40
00:01:47,721 --> 00:01:49,970
私は私を見ると、それが唯一だ
ここに拡大された手書き

41
00:01:49,970 --> 00:01:51,930
私はこれがいかに凶悪な理解ください。

42
00:01:51,930 --> 00:01:54,180
>> しかし、のはそれを想定してみましょう、
右側に

43
00:01:54,180 --> 00:01:57,070
、それにもかかわらず、合理的である
何の描写

44
00:01:57,070 --> 00:01:58,880
このすべてに起こって
のgetStringと時間。

45
00:01:58,880 --> 00:02:00,380
のgetStringは、もちろん、文字列を取得します。

46
00:02:00,380 --> 00:02:01,691
しかし、それは本当に何を意味するのでしょうか？

47
00:02:01,691 --> 00:02:04,190
それはのチャンクを取得します意味
オペレーティング·システムからメモリ

48
00:02:04,190 --> 00:02:06,040
関数を呼び出すことで、malloc関数と呼ばれる。

49
00:02:06,040 --> 00:02:07,390
しかし、もっとその上で後で。

50
00:02:07,390 --> 00:02:09,139
そしてそれは移入
メモリのチャンク

51
00:02:09,139 --> 00:02:11,764
ユーザーが持っている文字で
もちろん、続いて、タイプ入力

52
00:02:11,764 --> 00:02:14,800
null文字、またはバックスラッシュ
最後の最後でゼロ。

53
00:02:14,800 --> 00:02:18,280
>> 一方、左側の
この物語の、すべてのこの時間、

54
00:02:18,280 --> 00:02:20,850
私たちは、sのように、変数を宣言してきた。

55
00:02:20,850 --> 00:02:24,770
そして、その変数は今何をしている
ポインタを呼び出して起動します。

56
00:02:24,770 --> 00:02:29,190
それは、その内部のボックスではありません
私たちは、文字列を入れて、祈る、それ自体が、

57
00:02:29,190 --> 00:02:32,550
むしろ私たちは、その広場に置く
まさに左側のボックス？

58
00:02:32,550 --> 00:02:34,890

59
00:02:34,890 --> 00:02:35,390
うん？

60
00:02:35,390 --> 00:02:37,118
>> 聴衆：のアドレス
どこにそれがメモリ内に位置し。

61
00:02:37,118 --> 00:02:38,118
>> DAVID J.マラン：その通りです。

62
00:02:38,118 --> 00:02:40,690
祈るのアドレス
メモリ内に位置しています。

63
00:02:40,690 --> 00:02:44,650
そして、ここで祈るのすべてが配置されていない、
それ自体が、特にアドレス

64
00:02:44,650 --> 00:02:45,150
何の？

65
00:02:45,150 --> 00:02:46,311

66
00:02:46,311 --> 00:02:46,810
うん？

67
00:02:46,810 --> 00:02:47,460
>> 聴衆：最初の文字。

68
00:02:47,460 --> 00:02:50,209
>> DAVID J.マラン：最初の文字
この場合には祈る、中、

69
00:02:50,209 --> 00:02:53,820
私は任意だっ提案
そして非現実1、OX1、

70
00:02:53,820 --> 00:02:55,910
これだけのことを意味
1の16進数の数。

71
00:02:55,910 --> 00:02:57,993
しかし、それはおそらく起こっている
はるかに大きな数であるように

72
00:02:57,993 --> 00:03:01,260
私たちは引く可能性があることを
接頭辞として0xを、

73
00:03:01,260 --> 00:03:02,806
16進文字を表す。

74
00:03:02,806 --> 00:03:05,930
そして、私たちはどこに知っている必要はありませんので、
祈るの文字の残りの部分

75
00:03:05,930 --> 00:03:09,860
なぜならどんなシンプルなデザインで、ある
何年も前に作られた決断？

76
00:03:09,860 --> 00:03:10,548
うん？

77
00:03:10,548 --> 00:03:11,651
>> 聴衆：バックスラッシュ0。

78
00:03:11,651 --> 00:03:12,900
DAVID J.マラン：ええ、その通りです。

79
00:03:12,900 --> 00:03:18,100
バックスラッシュ0ではあるが、あなたを可能にする
文字列を横断する線形時間、、

80
00:03:18,100 --> 00:03:20,400
左から右に歩いて、
forループ、またはwhileと

81
00:03:20,400 --> 00:03:22,608
ループ、またはのようなもの
それは、ここで、ああ、決定する

82
00:03:22,608 --> 00:03:24,751
この特定の文字列の終端である。

83
00:03:24,751 --> 00:03:27,000
でちょうどアドレスを持つので、
文字列の先頭、

84
00:03:27,000 --> 00:03:30,290
私たちは全体にアクセスすることができます
それは、すべてのこの間のため、

85
00:03:30,290 --> 00:03:32,030
文字列はただのcharスターでした。

86
00:03:32,030 --> 00:03:36,370
>> だから、継続して使用することが確かにいいのよ
CS50ライブラリと、この抽象化、

87
00:03:36,370 --> 00:03:38,440
いわば、私たちはよする
正確に見始める

88
00:03:38,440 --> 00:03:41,230
何が起こっているされています
この全体の時間の下に。

89
00:03:41,230 --> 00:03:45,260
だから、この例を思い出すことができ、
あまりにも、前回から、0を比較し、

90
00:03:45,260 --> 00:03:47,300
これ実際に比較しませんでした。

91
00:03:47,300 --> 00:03:49,070
しかし、私たちはこれを解決し始めた。

92
00:03:49,070 --> 00:03:52,020
>> しかし、として、おそらくリフレッシュ、
私は誰かは興味があります

93
00:03:52,020 --> 00:03:54,261
ピンクのゾウ、今日、
また、チャンによる？

94
00:03:54,261 --> 00:03:55,760
どのように前のあなたは？ [聞き取れない]。

95
00:03:55,760 --> 00:03:56,660
アップさあ。

96
00:03:56,660 --> 00:03:58,740
>> そして、その間に、
あなたが出てくるように、してみましょう

97
00:03:58,740 --> 00:04:01,670
ちょっと考えるもの
このコードは、実際にやっていた。

98
00:04:01,670 --> 00:04:04,917
これは、2つの変数を宣言しています
トップ、sとtとのgetStringを呼び出す。

99
00:04:04,917 --> 00:04:08,250
これは、非常にユーザーフレンドリープログラムではありません
それはあなたを教えていないため、何をすべきか。

100
00:04:08,250 --> 00:04:10,541
しかし、ちょうど私たちがしていると仮定しましょう
ジューシーな部分に焦点を当てた。

101
00:04:10,541 --> 00:04:14,470
sが等しい場合と、私たちは、何
Tに等しく、それはprintfの言う必要があり、

102
00:04:14,470 --> 00:04:16,170
あなたが同じことを入力しました。

103
00:04:16,170 --> 00:04:16,670
こんにちは。

104
00:04:16,670 --> 00:04:17,050
あなたの名前は？

105
00:04:17,050 --> 00:04:17,779
>> JANELLE：ジャネル。

106
00:04:17,779 --> 00:04:19,529
DAVID J.マラン：ジャネル、
よろしくね。

107
00:04:19,529 --> 00:04:21,800
であなたの課題は、そう
このゾウのための手

108
00:04:21,800 --> 00:04:25,230
最初の私たちに何の絵を描画することです
これらの最初の二つで表現されている

109
00:04:25,230 --> 00:04:25,970
ライン。

110
00:04:25,970 --> 00:04:28,139
だから、sとtは次のようになります。
どのようにスクリーン上に表現？

111
00:04:28,139 --> 00:04:30,680
そして、あなたはただでそれを描くことができます
この大画面上で指。

112
00:04:30,680 --> 00:04:31,780

113
00:04:31,780 --> 00:04:34,510
>> だから、二つの半分にはありませ
その方程式の各側面。

114
00:04:34,510 --> 00:04:37,760
だから、左のsはそこだし、
その後、右側にのgetString。

115
00:04:37,760 --> 00:04:40,540
そしてtは、左側にあります
そして、右側ののgetString。

116
00:04:40,540 --> 00:04:42,630
では、どのように始めるかもしれません
その絵を描く

117
00:04:42,630 --> 00:04:46,340
何が起こっているかを表す
ここでは、メモリに、あなたは言うでしょうか？

118
00:04:46,340 --> 00:04:49,150
そして、私はあなたが説明させてみましょう
あなたが行くように、あなたは何をやっている。

119
00:04:49,150 --> 00:04:49,820
>> JANELLE：わかりました。

120
00:04:49,820 --> 00:04:58,890
さて、最初に、それは尋ねることになる
あなたが入力文字列を取得します。

121
00:04:58,890 --> 00:05:00,439
そして、それは申し訳ありませんが、ああstore--だろう。

122
00:05:00,439 --> 00:05:01,230
DAVID J.マラン：わかりました。

123
00:05:01,230 --> 00:05:01,730
グッド。

124
00:05:01,730 --> 00:05:03,330
そして、これは何と呼ばれている？

125
00:05:03,330 --> 00:05:03,950
[OK]を、ああ。

126
00:05:03,950 --> 00:05:04,450
続ける。

127
00:05:04,450 --> 00:05:05,575
私は、中断することを意味するものではありませんでした。

128
00:05:05,575 --> 00:05:07,060
JANELLE：申し訳ありません。

129
00:05:07,060 --> 00:05:14,237
だから、に入力してだろう
アドレスがわからないof--。

130
00:05:14,237 --> 00:05:17,320
私は正確に番号を覚えていないことができ、
私はそれは0から始まると考えていました。

131
00:05:17,320 --> 00:05:18,420
>> DAVID J.マラン：それはすべての権利は​​、
私は数字を作ったので、

132
00:05:18,420 --> 00:05:19,650
そう何正しい答えはありません。

133
00:05:19,650 --> 00:05:22,105
>> JANELLE：0アークで開始。

134
00:05:22,105 --> 00:05:24,000
>> DAVID J.マラン：そう、要素0。

135
00:05:24,000 --> 00:05:24,765
かしこまりました。

136
00:05:24,765 --> 00:05:28,295
>> JANELLE：そしてあったか
ちょうど二letter--様

137
00:05:28,295 --> 00:05:30,496
>> DAVID J.マラン：OK、あなたに戻って。

138
00:05:30,496 --> 00:05:33,629
>> JANELLE：だから要素0、および
その後エレメント1またはエレメント2。

139
00:05:33,629 --> 00:05:36,670
その作品のそして：DAVID J.マラン
写真は、あなたが今、描いていますか？

140
00:05:36,670 --> 00:05:37,690
のgetStringへの呼び出し？

141
00:05:37,690 --> 00:05:38,830
またはsの宣言？

142
00:05:38,830 --> 00:05:42,890
>> JANELLE：宣言
Sの、私は信じています。

143
00:05:42,890 --> 00:05:45,980
ああ、getStringで、それはなるため
各【に入力する？エリア。 ？]

144
00:05:45,980 --> 00:05:46,510
>> DAVID J.マラン：良い。

145
00:05:46,510 --> 00:05:47,051
その通り。

146
00:05:47,051 --> 00:05:49,300
効果的なのに、この
配列、リコールを返し、

147
00:05:49,300 --> 00:05:53,300
私たちは、文字列を取り戻すとき、私たちはすることができます
01および2を使用して、その文字列のインデックス。

148
00:05:53,300 --> 00:05:56,180
技術的には、これらは、おそらくです
個別のアドレスによって表される、

149
00:05:56,180 --> 00:05:57,100
それはいいのよ。

150
00:05:57,100 --> 00:06:00,170
>> 私はちょうど速くできればそう、とします
私たちは中断したところに転送

151
00:06:00,170 --> 00:06:04,320
前回、1の場合
文字列は、B型電子gであった

152
00:06:04,320 --> 00:06:10,337
それによって、ゲイブ年代を代表するバックスラッシュ0、
入力は、どのように私たちは今のを表しているのでしょうか？

153
00:06:10,337 --> 00:06:12,670
これのメモリがある場合
のgetStringにより返されていますか？

154
00:06:12,670 --> 00:06:14,415

155
00:06:14,415 --> 00:06:17,610
>> JANELLE：それは次のようになります
アークが表す？

156
00:06:17,610 --> 00:06:18,750
>> DAVID J.マラン：アークによって？

157
00:06:18,750 --> 00:06:19,130
いや、まあ。

158
00:06:19,130 --> 00:06:21,171
ちょうど絵で、としましょう​​、
私はちょうど先に行きましょう

159
00:06:21,171 --> 00:06:25,710
これはsである場合、このことを提案
のgetStringの戻り値です。

160
00:06:25,710 --> 00:06:29,482
そして、あなたはその、0、1、2として、これを描いた
われわれので、完全に合理的である

161
00:06:29,482 --> 00:06:30,940
のような文字列のインデックス、することができます。

162
00:06:30,940 --> 00:06:33,340
しかし、単にと一致しているように
前回、私が先に行かせて

163
00:06:33,340 --> 00:06:37,310
任意このことを提案する
アドレス1であり、これがアドレス2であり、

164
00:06:37,310 --> 00:06:39,597
これ等アドレス3、及びである。

165
00:06:39,597 --> 00:06:41,430
だから、ちょうどスーパーであると
明確な、何が起こっている

166
00:06:41,430 --> 00:06:44,580
その結果として、年代に行くために
コー​​ドの最初の行には、と思いますか？

167
00:06:44,580 --> 00:06:45,420
>> JANELLE：住所1？

168
00:06:45,420 --> 00:06:46,420
>> DAVID J.マラン：その通りです。

169
00:06:46,420 --> 00:06:47,190
だから、0x1の対処。

170
00:06:47,190 --> 00:06:48,220

171
00:06:48,220 --> 00:06:51,230
そしてその間、私が先に行くとしましょう
あなたがやったことの多くを複製

172
00:06:51,230 --> 00:06:52,740
そして、ここで私自身のトンを追加します。

173
00:06:52,740 --> 00:06:56,340
私はゲイブを入力した場合
再び、二度目、

174
00:06:56,340 --> 00:07:01,530
のgetStringでメッセージが表示されたら、どこで、
もちろん、ゲイブは行くつもりですか？

175
00:07:01,530 --> 00:07:02,280
さて、presumably--

176
00:07:02,280 --> 00:07:04,935

177
00:07:04,935 --> 00:07:05,975
>> JANELLE：ここでの、気に入りましたか？

178
00:07:05,975 --> 00:07:06,850
DAVID J.マラン：うん。

179
00:07:06,850 --> 00:07:08,516
JANELLE：それとも同じ箱にもですか？

180
00:07:08,516 --> 00:07:11,940
DAVID J.マラン：ええ、私は提案してみましょう、
正確には、これらの追加のボックスにそう。

181
00:07:11,940 --> 00:07:15,230
しかし、今の鍵なのはあっても、ということです
私はこれらの非常に近くに描いていますが

182
00:07:15,230 --> 00:07:18,650
0x1のtogether--、この
実際に0x2--され、

183
00:07:18,650 --> 00:07:25,750
これは現在、アドレス0x10のかもしれない
例えば、および0x11を、と0x12の、

184
00:07:25,750 --> 00:07:26,870
など。

185
00:07:26,870 --> 00:07:29,955
ですから、そのような場合、
何トンで、ここで終わるために起こっている？

186
00:07:29,955 --> 00:07:30,830
>> JANELLE：0x10を？

187
00:07:30,830 --> 00:07:31,830
DAVID J.マラン：その通りです。

188
00:07:31,830 --> 00:07:33,180
だから、0x10を。

189
00:07:33,180 --> 00:07:34,570
だから、今、最後の質問。

190
00:07:34,570 --> 00:07:37,510
あなたは、はるかに、仕事を持っていた
これまでゾウのための最も難しい。

191
00:07:37,510 --> 00:07:42,650
今では、私は、コードをプルアップした場合
再び、私が行うとき、ライン3において、

192
00:07:42,650 --> 00:07:47,630
sがtと等しい等しい場合、私は実際に何をしてい
ここで描かれたことと比較する？

193
00:07:47,630 --> 00:07:49,271
>> JANELLE：二つのアドレス？

194
00:07:49,271 --> 00:07:50,270
DAVID J.マラン：その通りです。

195
00:07:50,270 --> 00:07:53,350
だから私は、tに等しい等しくSで言っている？

196
00:07:53,350 --> 00:07:56,210
言い換えると、1〜10に等しい等しい？

197
00:07:56,210 --> 00:07:59,710
そしてもちろん、
明白な答えは今ありません、です。

198
00:07:59,710 --> 00:08:02,920
だからこのプログラムは最終的にある
何を印刷しようとして、あなたは言うでしょうか？

199
00:08:02,920 --> 00:08:05,770

200
00:08:05,770 --> 00:08:08,405
>> JANELLE：それは次のようになり、
あなたが同じことを入力した？

201
00:08:08,405 --> 00:08:11,446
>> DAVID J.マラン：もしそうであれば
sが1であり、tは10である？

202
00:08:11,446 --> 00:08:13,320
>> JANELLE：あなたは異なるものを入力しました。

203
00:08:13,320 --> 00:08:13,570
>> DAVID J.マラン：その通りです。

204
00:08:13,570 --> 00:08:14,480
あなたは、異なるものを入力しました。

205
00:08:14,480 --> 00:08:14,850
かしこまりました。

206
00:08:14,850 --> 00:08:16,714
だから、拍手、
ここで、私たちができれば。

207
00:08:16,714 --> 00:08:17,214
[拍手]

208
00:08:17,214 --> 00:08:17,708
それは苦痛だった。

209
00:08:17,708 --> 00:08:18,208
私は知っている。

210
00:08:18,208 --> 00:08:19,684
うまく行って。

211
00:08:19,684 --> 00:08:24,690
だから今私たちができない場合を見てみましょう
修正が何であったか離れていじめる。

212
00:08:24,690 --> 00:08:28,040
そしてもちろん、私たちはthis--固定時
その私が今green--で表します

213
00:08:28,040 --> 00:08:29,690
私たちはここでの機能強化のカップルをやった。

214
00:08:29,690 --> 00:08:32,409
まず、ただ正気など
私が最初にチェックしています、確認してください

215
00:08:32,409 --> 00:08:35,110
sがヌルに等しく、tはヌルに等しい場合。

216
00:08:35,110 --> 00:08:39,440
とき可能性があり、単に、明確にするために
Sまたはtがこのようなコードにnullになる？

217
00:08:39,440 --> 00:08:43,140

218
00:08:43,140 --> 00:08:44,490
ときにSまたはtがnullになる可能性があります。

219
00:08:44,490 --> 00:08:44,990
うん？

220
00:08:44,990 --> 00:08:45,990
>> 聴衆：[聞こえない]。

221
00:08:45,990 --> 00:08:49,490

222
00:08:49,490 --> 00:08:50,510
>> DAVID J.マラン：その通りです。

223
00:08:50,510 --> 00:08:52,840
文字列、ユーザーがその場合は
に入力された道が長すぎる

224
00:08:52,840 --> 00:08:56,140
メモリに収まら、またはいくつかのように
そのような奇妙なコーナーケース、

225
00:08:56,140 --> 00:08:59,010
私たちは文字通り、わかりますように、のgetString
今日、そのドキュメントの、

226
00:08:59,010 --> 00:09:02,330
それはのようにnullを返しますと言う
特別なセンチネル値、

227
00:09:02,330 --> 00:09:05,417
特殊記号のか、単に並べ替え
それは、何かが間違っていたことを意味します。

228
00:09:05,417 --> 00:09:07,500
だからかどうかを確認したい
結局のところので、その

229
00:09:07,500 --> 00:09:09,720
そのnullは非常に危険な値です。

230
00:09:09,720 --> 00:09:14,250
>> 多くの場合、あなたが何かをしようとした場合
ヌルを渡しfunction--が関与

231
00:09:14,250 --> 00:09:17,470
入力として、その機能をinstance--ため
非常にそれで、クラッシュします可能性があり、

232
00:09:17,470 --> 00:09:19,090
あなたのプログラム全体をダウンさせる。

233
00:09:19,090 --> 00:09:22,570
だから今この三行はただ正気です
あなたがする場合は、エラーチェックをチェックしてください。

234
00:09:22,570 --> 00:09:25,450
それは今のところ良い習慣だ
私たちは、いつに入るため、私たち

235
00:09:25,450 --> 00:09:28,050
その値を使用しようとする
、潜在的に、nullになる可能性があります。

236
00:09:28,050 --> 00:09:32,000
>> さて、ここでは4行目の、
「もし関数strcmp（s、t）は、「よく、

237
00:09:32,000 --> 00:09:33,180
を参照していることは何ですか？

238
00:09:33,180 --> 00:09:36,750
さて、私たちは、これは非常に簡潔に述べた
文字列比較のために指定された関数。

239
00:09:36,750 --> 00:09:40,370
そして、生活の中で、その目的は、比較することである
第二、それに対するその最初の引数、

240
00:09:40,370 --> 00:09:44,640
はなく、それらのアドレスの面で、
私たちは一瞬意図せずに行ったように

241
00:09:44,640 --> 00:09:48,270
前の赤のコードではなく
むしろこれら二つを比較する

242
00:09:48,270 --> 00:09:53,210
人間の直感的な内の文字列
このに対して、これを比較することにより、道、

243
00:09:53,210 --> 00:09:56,690
このに対して、このに対して、および
その後停止時に1 ifと

244
00:09:56,690 --> 00:09:59,590
私の指の一方または両方
バックスラッシュ0を打つ。

245
00:09:59,590 --> 00:10:04,530
だから、誰かが数年前にstrcmpを実施
私たちのための機能を実装する

246
00:10:04,530 --> 00:10:08,890
私たちが得ていることを望んだこと
ちょうど2つの単純な値を比較することによって。

247
00:10:08,890 --> 00:10:14,929
>> 今率直に言って、私は図面を保つ
これらのさまざまな数字がすべて表示されます。

248
00:10:14,929 --> 00:10:17,470
しかし、現実には、私がしてきた、ある
ずっとこれらを構成する。

249
00:10:17,470 --> 00:10:19,580
だから私はちょうど先に行くみましょう
これらを走り書き

250
00:10:19,580 --> 00:10:23,100
、最後にポイントを作るために
一日のと前進、

251
00:10:23,100 --> 00:10:30,160
私たちは本当に気にするつもりはない
何が物事が実際にアドレス

252
00:10:30,160 --> 00:10:30,790
メモリ内の。

253
00:10:30,790 --> 00:10:34,320
だから私は、これらを描画するつもりはない
もうそんなに数字の種類、

254
00:10:34,320 --> 00:10:38,970
私は離れて、この単なる抽象的なんだ
ちょうど矢印でもう少し優しい。

255
00:10:38,970 --> 00:10:42,060
>> 言い換えると、sがポインタである場合、
よく、ちょうど文字通り、それを描画しましょう​​、

256
00:10:42,060 --> 00:10:45,430
ポインタとして、矢印が指している
自身から何か他のものに、

257
00:10:45,430 --> 00:10:48,280
とについてはあまり多くを心配しないで
これらのアドレスの特徴点

258
00:10:48,280 --> 00:10:49,910
これは、もう一度、私はとにかく占めた。

259
00:10:49,910 --> 00:10:52,680
しかし、私たちはそれらのアドレスが表示されます、
時には、コードをデバッグするとき。

260
00:10:52,680 --> 00:10:56,450
>> さて一方、このプログラム
ここまでの修正はもちろん、

261
00:10:56,450 --> 00:10:58,720
比較することにより、その問題
これら二つの文字列。

262
00:10:58,720 --> 00:11:00,260
しかし、私たちは別の問題に遭遇した。

263
00:11:00,260 --> 00:11:03,180
これはコピーからでした
プログラム最後の時間、

264
00:11:03,180 --> 00:11:06,880
それによって、私は大文字にしようとしていた
文字列内のちょうど最初の文字。

265
00:11:06,880 --> 00:11:09,620
しかし、症状は何だった
私たちは時に最後の時間を見た

266
00:11:09,620 --> 00:11:14,150
値で入力したユーザーなど
sの小文字ゲイブ、、

267
00:11:14,150 --> 00:11:19,310
その後私たちは、Tへの割り当て
そこに3行目のように、

268
00:11:19,310 --> 00:11:22,900
そしてその後私はしみました
Tブラケット0を大文字？

269
00:11:22,900 --> 00:11:25,950
の効果は何だったの
ここで、Tブラケット0を変える？

270
00:11:25,950 --> 00:11:27,150
>> 聴衆：それは、sを変更しました。

271
00:11:27,150 --> 00:11:29,360
>> DAVID J.マラン：ええ、
私も、秒を変更しました。

272
00:11:29,360 --> 00:11:31,050
本当に何が起こっていたかのため？

273
00:11:31,050 --> 00:11:34,130
まあ、私はきれいにすることができるなら、私に見てみましょう
この写真をアップする、以下のように。

274
00:11:34,130 --> 00:11:41,390
>> sがある場合は、再度、単語g、
A、B、E、バックスラッシュ、0、およびs

275
00:11:41,390 --> 00:11:44,084
私たちはボックスとして描画を続けます
ここでは、ないより多くのアドレス。

276
00:11:44,084 --> 00:11:45,250
それでは物事を構成するやめよう。

277
00:11:45,250 --> 00:11:47,510
ちょうど絵を描いてみ
世界を単純化することができます。

278
00:11:47,510 --> 00:11:52,640
>> 私は、文字列tとtと宣言すると、
それは、メモリのチャンクを作成します。

279
00:11:52,640 --> 00:11:55,850
広場は32であることを起こる
ほとんどのコンピュータのビット。

280
00:11:55,850 --> 00:11:59,530
実際には、もしあなたがこれまで聞いた
コンピュータは、32ビットアーキテクチャを有する

281
00:11:59,530 --> 00:12:03,000
本当に空想話を、ちょうどその
それは32ビットのアドレスを使用することを意味します。

282
00:12:03,000 --> 00:12:05,370
そして余談技術的として、
あなたは今まで疑問に思ってしまった場合

283
00:12:05,370 --> 00:12:09,630
なぜ古いコンピュータ、実際にあなたの場合
RAMの多くが付いているスープにそれらをしようとした、

284
00:12:09,630 --> 00:12:12,360
唯一の最大値を持つことができ
RAMが4ギガバイトの、

285
00:12:12,360 --> 00:12:14,860
よくそれは文字通り、あるためですが、
古いコンピュータができる唯一の

286
00:12:14,860 --> 00:12:17,250
4という高い数える
億円、40億バイト、

287
00:12:17,250 --> 00:12:20,590
それは、32ビットを使用していたので、
アドレスには数字。

288
00:12:20,590 --> 00:12:23,260
>> しかし、いずれの場合にも、この中
たとえば、話はずっと簡単だ。

289
00:12:23,260 --> 00:12:27,250
tはちょうど別のポインタである、または
本当にチャースター、別名文字列。

290
00:12:27,250 --> 00:12:30,860
そして、どのように私はこの写真を更新しますか
今のコードの二行目で、

291
00:12:30,860 --> 00:12:31,950
ドットの後、ドット、ドット？

292
00:12:31,950 --> 00:12:35,845
私は文字列を行うとtは、sのセミコロンに等しい
この絵はどのように変化するのでしょうか？

293
00:12:35,845 --> 00:12:37,500

294
00:12:37,500 --> 00:12:38,000
うん？

295
00:12:38,000 --> 00:12:38,916
>> 聴衆：[聞こえない]。

296
00:12:38,916 --> 00:12:41,087

297
00:12:41,087 --> 00:12:42,020
>> DAVID J.マラン：うん。

298
00:12:42,020 --> 00:12:42,600
その通り。

299
00:12:42,600 --> 00:12:45,620
私はちょうどから矢を入れる
同じアドレスに対するTボックス、

300
00:12:45,620 --> 00:12:47,570
の同じ最初の文字があった。

301
00:12:47,570 --> 00:12:50,850
あるいは、技術的には、もしこの
男は、0x1のでまだあった

302
00:12:50,850 --> 00:12:53,052
私が持っていたかのようにです
こことここに0x1の0x1の。

303
00:12:53,052 --> 00:12:54,760
しかし、再び、誰が気に
アドレスはどうですか？

304
00:12:54,760 --> 00:12:56,345
それは今重要なのばかり考えです。

305
00:12:56,345 --> 00:12:57,720
だから、これは、ここで何が起こっているかである。

306
00:12:57,720 --> 00:13:02,690
もちろん、それで、あなたがtブラケットを行う場合
配列表記で0、

307
00:13:02,690 --> 00:13:05,650
のcourse--と率直に言って、それが見えます
こっちに配列がありますように、

308
00:13:05,650 --> 00:13:07,340
しかし今、この奇妙なことがあります。

309
00:13:07,340 --> 00:13:11,160
そのプログラミング言語を知っている、
Cは、あなたにこの機能を提供しています、

310
00:13:11,160 --> 00:13:14,650
これにより、tがあっても
ポインタ、またはsは、ポインタである

311
00:13:14,650 --> 00:13:18,050
あなたはまだ、そのおなじみを使用することができます
快適な角括弧

312
00:13:18,050 --> 00:13:22,520
表記法は、最初の要素に移動し、
第二の要素、または任意の要素または

313
00:13:22,520 --> 00:13:26,130
そのポインタが指していることを
それ、おそらく、理由に

314
00:13:26,130 --> 00:13:29,410
この場合のように、ある
いくつかの配列を指して。

315
00:13:29,410 --> 00:13:30,340
>> では、どのようにこれを修正しますか？

316
00:13:30,340 --> 00:13:33,660
それが持ってどこに率直に言って、これは
一見少し圧倒。

317
00:13:33,660 --> 00:13:35,340
しかし、ここで新しく改良されたバージョンです。

318
00:13:35,340 --> 00:13:37,460
>> したがって、最初、私が得ている
CS50ライブラリを取り除く、

319
00:13:37,460 --> 00:13:41,170
ただ、実際にそれがよさ露出させる
char型のスター、ちょうど同義語。

320
00:13:41,170 --> 00:13:43,540
そしてTはまた、char型の星である。

321
00:13:43,540 --> 00:13:48,290
しかし、上で何が起こっているのか
その行の右側

322
00:13:48,290 --> 00:13:49,970
tが値を割り当てられる場合、？

323
00:13:49,970 --> 00:13:50,790
>> malloc関数とは何ですか？

324
00:13:50,790 --> 00:13:51,630
それが何をstrlenをだ？

325
00:13:51,630 --> 00:13:52,547
はsizeof（char型）とは何ですか？

326
00:13:52,547 --> 00:13:54,380
なぜ一体これを行います
ラインは非常に複雑に見える？

327
00:13:54,380 --> 00:13:55,713
それは、高いレベルで何をしているのですか？

328
00:13:55,713 --> 00:13:56,482

329
00:13:56,482 --> 00:13:57,440
それがtでの保管は何ですか？

330
00:13:57,440 --> 00:13:58,646
うん？

331
00:13:58,646 --> 00:14:01,104
聴衆：それは割り当てることだ
メモリ空間の一定量。

332
00:14:01,104 --> 00:14:03,032
それは私が推測する、保存するための、
手紙[聞き取れない]。

333
00:14:03,032 --> 00:14:04,032
>> DAVID J.マラン：パーフェクト。

334
00:14:04,032 --> 00:14:04,540
パーフェクト。

335
00:14:04,540 --> 00:14:06,650
それは、特定の配分だ
メモリ空間の量

336
00:14:06,650 --> 00:14:08,940
おそらく、将来の文字を格納する。

337
00:14:08,940 --> 00:14:11,310
特に、malloc関数
したがって、何を返している？

338
00:14:11,310 --> 00:14:13,114

339
00:14:13,114 --> 00:14:14,851
>> 聴衆：[聞こえない]を返す？

340
00:14:14,851 --> 00:14:15,850
DAVID J.マラン：その通りです。

341
00:14:15,850 --> 00:14:18,850
そのメモリのアドレスを返す、
これというのがファンシーな方法ですが、

342
00:14:18,850 --> 00:14:21,640
のアドレスを返す
そのメモリの最初のバイト。

343
00:14:21,640 --> 00:14:25,460
責任は覚えて私にある
どのくらいのメモリI実際に

344
00:14:25,460 --> 00:14:27,140
割り当てられたかのためのmallocを求めた。

345
00:14:27,140 --> 00:14:28,384
>> 今ではどれくらいですか？

346
00:14:28,384 --> 00:14:30,550
まあ、ありますにもかかわらず、
ここで、括弧の多くは、

347
00:14:30,550 --> 00:14:32,970
malloc関数はただ一つの引数を取ります。

348
00:14:32,970 --> 00:14:37,250
そして、私は、sのstrlen関数を指定して、そのように得られています
私のバイト数秒であるように、

349
00:14:37,250 --> 00:14:37,800
が、1つを追加します。

350
00:14:37,800 --> 00:14:38,300
なぜ？

351
00:14:38,300 --> 00:14:39,030

352
00:14:39,030 --> 00:14:39,530
うん？

353
00:14:39,530 --> 00:14:40,840
>> 聴衆：バックスラッシュ0。

354
00:14:40,840 --> 00:14:41,840
DAVID J.マラン：その通りです。

355
00:14:41,840 --> 00:14:43,423
私たちは、少し家事を行うようになってきました。

356
00:14:43,423 --> 00:14:45,970
だから、バックスラッシュがありますので、
0、私たちはより良いことを覚えていると思います。

357
00:14:45,970 --> 00:14:47,310
そうでなければ、私たちはつもりだ
その文字列を作成するには

358
00:14:47,310 --> 00:14:49,170
その特別なターミネータを持っていません。

359
00:14:49,170 --> 00:14:52,640
>> 一方、ちょうどスーパーであると
肛門は、私は、はsizeof（char型）がある

360
00:14:52,640 --> 00:14:55,730
念のため、誰かが私を実行します
CS50アプライアンス上のコードではない、

361
00:14:55,730 --> 00:14:58,220
多分別のコンピュータ
完全に文字

362
00:14:58,220 --> 00:15:01,470
慣例により、1バイトですが、2
バイト、またはそれよりも大きなもの。

363
00:15:01,470 --> 00:15:04,490
それはちょうど、スーパーであることだが、
エラーにスーパー嫌う。

364
00:15:04,490 --> 00:15:06,940
にもかかわらず、実際には、それがだ
最も可能性の高い1になるだろう。

365
00:15:06,940 --> 00:15:11,490
>> さて、一方、私が先に行くと、コピー
文字列は、Tブラケットiは、Tブラケットsです。

366
00:15:11,490 --> 00:15:14,962
そして、私は先週のに延期します
ソースコードは、何が起こっているかを確認します。

367
00:15:14,962 --> 00:15:17,670
しかし、キー持ち帰り、および
理由は、私は、緑の中で、今のコードを入れて

368
00:15:17,670 --> 00:15:22,520
、まさにその最後の行からです
Tブラケット0は、TOUPPER等しい

369
00:15:22,520 --> 00:15:25,230
の効果を有する
活用している文字列？

370
00:15:25,230 --> 00:15:26,960
tおよび/またはs？

371
00:15:26,960 --> 00:15:29,280

372
00:15:29,280 --> 00:15:30,580
コー​​ドの最後の行。

373
00:15:30,580 --> 00:15:32,930

374
00:15:32,930 --> 00:15:35,560
>> ただ何ので、トン
今回起こった、

375
00:15:35,560 --> 00:15:41,500
私は少しその最後のステップを元に戻す場合には、
何が起こったのは、私がmalloc関数を呼び出すときに、ある、

376
00:15:41,500 --> 00:15:45,380
私は基本的にメモリのチャンクを取得
それは、オリジナルと同じサイズである、

377
00:15:45,380 --> 00:15:47,020
なぜならそれは私がやった算術だ。

378
00:15:47,020 --> 00:15:50,920
私はアドレスTに格納しています
メモリのチャンクの。

379
00:15:50,920 --> 00:15:53,370
これは良さそうに見えていても
と、かなりいいとブランク、

380
00:15:53,370 --> 00:15:56,882
現実は私たちがよ、ありますされている
ここで、呼び出しごみ値を保持します。

381
00:15:56,882 --> 00:15:59,340
メモリのチャンクは非常に可能性がある
よく前に使用されてきたが、

382
00:15:59,340 --> 00:16:00,940
数秒、数分前。

383
00:16:00,940 --> 00:16:04,410
だから、絶対に数字があるかもしれません
またはそこには、文字、ちょうど偶然。

384
00:16:04,410 --> 00:16:08,580
しかし、彼らは私になる​​まで、有効ではありません
私自身は、このメモリのチャンクを読み込む

385
00:16:08,580 --> 00:16:12,510
私のような実際の文字、と
そこに、forループという点で行います。

386
00:16:12,510 --> 00:16:13,180
すべての権利？

387
00:16:13,180 --> 00:16:16,180
>> だから今、のクライマックス
これらの三つの例

388
00:16:16,180 --> 00:16:20,730
それは、一見、前回破壊した
このスワップの例は、この関数

389
00:16:20,730 --> 00:16:23,670
感覚で働いていた
それはaとbが入れ替わっていること。

390
00:16:23,670 --> 00:16:25,620
しかし、それは他のどのような意味では機能しませんでした？

391
00:16:25,620 --> 00:16:27,616

392
00:16:27,616 --> 00:16:28,614
うん？

393
00:16:28,614 --> 00:16:29,612
>> 聴衆：[聞こえない]。

394
00:16:29,612 --> 00:16:35,600

395
00:16:35,600 --> 00:16:36,700
>> DAVID J.マラン：その通りです。

396
00:16:36,700 --> 00:16:39,530
私は、この関数を呼び出すとしたら
例えばanother--から、

397
00:16:39,530 --> 00:16:42,870
ここで、メインのような関数から
私は、私のように、変数、xとyを持っている

398
00:16:42,870 --> 00:16:46,160
先週やった、同じコード、
と私は、xとyを渡す

399
00:16:46,160 --> 00:16:49,860
交換し、次にSwap--これを呼び出すには、
もちろん、正しいバージョンである

400
00:16:49,860 --> 00:16:52,220
私たちがしようとしているものです
see--それはうまくいきませんでした。

401
00:16:52,220 --> 00:16:53,770
だから修正は何ですか？

402
00:16:53,770 --> 00:16:56,850
>> まあ、これだけであることが
明確な、私は先に行ってみよう

403
00:16:56,850 --> 00:17:05,450
and--ここに私に1秒を与え、参照してください。
私はあなたに最後の1を表示することができれば、どの

404
00:17:05,450 --> 00:17:12,464
私が見つけることができるかどうかを見てみましょうin--になります
この本物のfast-- OK、[聞こえない]。

405
00:17:12,464 --> 00:17:18,440

406
00:17:18,440 --> 00:17:19,240
[OK]を、そこにそれがある。

407
00:17:19,240 --> 00:17:21,000
だから私はちょうど入力しているコマンドを無視。

408
00:17:21,000 --> 00:17:23,780
私はそれがで取得したい
土壇場の例

409
00:17:23,780 --> 00:17:27,960
前回から、どの
今はスワップと呼ばれていません。

410
00:17:27,960 --> 00:17:30,200
>> だから何スワップ場所はありません
私たちは、前回中断した

411
00:17:30,200 --> 00:17:32,930
それによって、私は初期化さ
2対1であり、yからx。

412
00:17:32,930 --> 00:17:35,840
私は、1と2を渡して、スワップを呼び出します。

413
00:17:35,840 --> 00:17:37,930
そして、この機能
ある意味で働いていた、

414
00:17:37,930 --> 00:17:40,750
それは永久にありませんでした
xとyへの影響。

415
00:17:40,750 --> 00:17:45,430
だから手元に質問がどのように今、ある
私たちは実際にこの問題を解決するのですか？

416
00:17:45,430 --> 00:17:47,820
手元の解決策は何ですか？

417
00:17:47,820 --> 00:17:53,150
>> さて、今日は新しく追加されましたswap.c、中、
相違点がいくつかに気づく。

418
00:17:53,150 --> 00:17:54,700
xおよびyは同じである。

419
00:17:54,700 --> 00:17:57,250
しかし、何が明らかに
25行程度違うのですか？

420
00:17:57,250 --> 00:17:58,880

421
00:17:58,880 --> 00:18:01,715
あなたが覚えていれば、そこに新機能
それは第二の前にように見えたもの？

422
00:18:01,715 --> 00:18:02,565
>> 聴衆：[聞こえない]。

423
00:18:02,565 --> 00:18:03,440
>> DAVID J.マラン：うん。

424
00:18:03,440 --> 00:18:06,680
だから、アンパサンドは、新しい作品である
このプログラムだけでなく構文、

425
00:18:06,680 --> 00:18:08,560
だけでなく、より一般的にはCS50中。

426
00:18:08,560 --> 00:18:10,680
現在までに、私は考えていない
私たちはどんな例を見てきました

427
00:18:10,680 --> 00:18:14,070
あるいは本当にいずれかでそれらについて話しました
多分、プリエンプティブ以外の細部、

428
00:18:14,070 --> 00:18:16,467
セクションで、このようなアンパサンド。

429
00:18:16,467 --> 00:18:19,300
まあ、それはアンパサンドが1つであるが判明
新しい構文の最後の作品の

430
00:18:19,300 --> 00:18:20,174
私たちは学ぶつもりです。

431
00:18:20,174 --> 00:18:23,500
その意味すべてがある
いくつかの変数のアドレス。

432
00:18:23,500 --> 00:18:25,070
どのアドレスでxが住んでいますか？

433
00:18:25,070 --> 00:18:26,510
しかし、yがどのアドレスを生きるのですか？

434
00:18:26,510 --> 00:18:28,700
ので、もし
前の基本的な問題

435
00:18:28,700 --> 00:18:32,970
xとyが渡されていたということでした
私たちが本当にやりたいことのコピーなど

436
00:18:32,970 --> 00:18:38,780
宝などでスワップを提供している
実際にここで、xとyにつながるマップ

437
00:18:38,780 --> 00:18:41,910
ように、RAM内にある
スワップそのマップに従うことができます

438
00:18:41,910 --> 00:18:47,760
そしてxまたはyがスポットをマークどこに行く
そして実際の値1と2を変更する

439
00:18:47,760 --> 00:18:48,270
そこ。

440
00:18:48,270 --> 00:18:50,710
>> だから、スワップも若干変更する必要があります。

441
00:18:50,710 --> 00:18:53,760
そして、一見、この全力
char型の星に少し似ているようだ。

442
00:18:53,760 --> 00:18:54,850
そして実際、それはある。

443
00:18:54,850 --> 00:18:59,635
だから、データの型へのポインタである、
このハイライトされた部分に基づいて？

444
00:18:59,635 --> 00:19:00,810

445
00:19:00,810 --> 00:19:01,620
だから、int型です。

446
00:19:01,620 --> 00:19:04,880
>> だから、もはやint型ではない、
それはint型のアドレスです。

447
00:19:04,880 --> 00:19:07,910
同様に、bが今起こっている
int型のアドレスである。

448
00:19:07,910 --> 00:19:12,470
だから私は、今のメインのスワップを呼び出すときに、
私はスワップ1と2を与えるつもりはない。

449
00:19:12,470 --> 00:19:15,540
私のようにそれを与えるつもりだ
オックス代や牛、何か、

450
00:19:15,540 --> 00:19:19,820
つながる二つのアドレス
彼らの実際の場所へのスワップ

451
00:19:19,820 --> 00:19:21,310
私のコンピュータのメモリに。

452
00:19:21,310 --> 00:19:25,580
>> だから今、私の残りの実装
少しを変更する必要がある。

453
00:19:25,580 --> 00:19:28,650
何が今明らかに違う
次の3行のコードでの？

454
00:19:28,650 --> 00:19:31,350
これらすべてのいまいましいの星があります
場所の上、大丈夫？

455
00:19:31,350 --> 00:19:33,014
それでは、ここで起こっている？

456
00:19:33,014 --> 00:19:33,514
うん？

457
00:19:33,514 --> 00:19:35,055
>> 聴衆：それは[聞こえない]明らかだ。

458
00:19:35,055 --> 00:19:36,832

459
00:19:36,832 --> 00:19:37,990
>> DAVID J.マラン：その通りです。

460
00:19:37,990 --> 00:19:41,560
したがって、このcontext--で、これはありませんでした
最高のデザインの決定、確かに、

461
00:19:41,560 --> 00:19:42,530
何年も前

462
00:19:42,530 --> 00:19:45,110
この文脈において、
あなただけの星を持っている、

463
00:19:45,110 --> 00:19:48,240
あなたがデータ型を持っていない、
int型のような、すぐに左に、

464
00:19:48,240 --> 00:19:53,146
代わりに、あなたは明確に、等号を持っている、
この文脈では、あなたが言うときスター、

465
00:19:53,146 --> 00:19:56,980
それはに行くことを意味
内のアドレス。

466
00:19:56,980 --> 00:19:58,870
いわば、宝の地図に従ってください。

467
00:19:58,870 --> 00:20:01,720
>> そして一方で、37行中、
それは同じことを意味します。

468
00:20:01,720 --> 00:20:05,460
アドレスaに移動し、そこに何を入れる？

469
00:20:05,460 --> 00:20:09,520
にあるものは何でも
bが指定された場所。

470
00:20:09,520 --> 00:20:10,980
つまり、Bに移動します。

471
00:20:10,980 --> 00:20:12,130
その値を取得します。

472
00:20:12,130 --> 00:20:15,620
に移動し、同じあたり
サインインして代入演算子、

473
00:20:15,620 --> 00:20:17,010
そこにその値を置く。

474
00:20:17,010 --> 00:20:19,272
>> 同様に、int型の一時だけのintです。

475
00:20:19,272 --> 00:20:20,730
何も一時について変更する必要はありません。

476
00:20:20,730 --> 00:20:24,810
それはアネンバーグからわずかスペアガラスです
いくつかの牛乳やオレンジジュースのために。

477
00:20:24,810 --> 00:20:27,630
しかし、私は言ってBに行く必要があります。

478
00:20:27,630 --> 00:20:31,449
その宛先に移動し、
そこに一時に値を入れる。

479
00:20:31,449 --> 00:20:32,490
それでは、何が起こっているか？

480
00:20:32,490 --> 00:20:36,540
私は実際にスワップ今回を呼び出すと、もし
ここで、この第一のトレーメインを表し、

481
00:20:36,540 --> 00:20:42,270
この第二のトレイがスワップを表し、時
私はアンパサンドxとyのアンパサンドを渡す

482
00:20:42,270 --> 00:20:47,150
メインからわずか明確にすることが、交換すること、
このスタックフレームの受信は何ですか？

483
00:20:47,150 --> 00:20:48,700

484
00:20:48,700 --> 00:20:49,200
うん？

485
00:20:49,200 --> 00:20:50,180
>> 聴衆：[聞こえない]。

486
00:20:50,180 --> 00:20:51,180
DAVID J.マラン：その通りです。

487
00:20:51,180 --> 00:20:53,129
xとyのアドレスのアドレス。

488
00:20:53,129 --> 00:20:55,170
そして、あなたはこれらを考えることができます
郵便のアドレスのよう。

489
00:20:55,170 --> 00:20:58,772
33オックスフォードストリートと35
オックスフォード·ストリート、そしてあなた

490
00:20:58,772 --> 00:21:01,230
二つの建物を移動したい
これらの場所にあること。

491
00:21:01,230 --> 00:21:04,680
>> それはばかげたアイデアのようなものだ、
それは私たちが、アドレスの意味すべてです。

492
00:21:04,680 --> 00:21:07,000
どこの世界ですることができます
あなたはこれらの2つのintを見つける？

493
00:21:07,000 --> 00:21:09,470
どこの世界であなたができる
これら二つの建物を見つける？

494
00:21:09,470 --> 00:21:15,170
私はすべてのこの時間後に、最終的にはそうであれば
今日のソースコードにアクセスし、コンパイル

495
00:21:15,170 --> 00:21:22,110
スワップおよび実行./swap、最終的には、用
初めて私たちは実際にそれを見ていますか

496
00:21:22,110 --> 00:21:25,330
私の値は、実際に持っている
成功裏にスワップさ。

497
00:21:25,330 --> 00:21:30,860
そして今、私たちも取ることができます
この中で、たとえば、GDBをメモ。

498
00:21:30,860 --> 00:21:32,740
>> だから私は、同じファイルに行きましょう。

499
00:21:32,740 --> 00:21:35,010
私が先に行くと./swapのGDBを実行してみましょう。

500
00:21:35,010 --> 00:21:36,590

501
00:21:36,590 --> 00:21:40,547
そして今、スワップに、私は行くつもりです
先にメインにブレークポイントを設定します。

502
00:21:40,547 --> 00:21:42,630
そして今、私は行くつもりです
先に、プログラムを実行します。

503
00:21:42,630 --> 00:21:45,810
そして今、私たちは私のコードを参照してください
その行で一時停止。

504
00:21:45,810 --> 00:21:48,330
>> 私が先に行くと、印刷した場合
xが、私はここで何が表示されるはずです？

505
00:21:48,330 --> 00:21:49,314

506
00:21:49,314 --> 00:21:49,980
それは問題だ。

507
00:21:49,980 --> 00:21:51,030

508
00:21:51,030 --> 00:21:51,530
もう一度言って？

509
00:21:51,530 --> 00:21:52,295
>> 聴衆：[聞こえない]。

510
00:21:52,295 --> 00:21:53,910
>> DAVID J.マラン：だから
乱数、多分。

511
00:21:53,910 --> 00:21:56,010
たぶん私は幸運を得る、それはだ
0のような、素敵でシンプル。

512
00:21:56,010 --> 00:21:57,230
しかし、おそらくそれはいくつかの乱数です。

513
00:21:57,230 --> 00:21:58,090
この場合、私は幸運。

514
00:21:58,090 --> 00:21:59,030
それはちょうど0であることを起こる。

515
00:21:59,030 --> 00:22:00,780
しかし、それは確かに幸運であり、
ではない私まで、理由

516
00:22:00,780 --> 00:22:06,280
次の入力し、印刷xがあることがあります
コー​​ドの行、19行は、実行された。

517
00:22:06,280 --> 00:22:10,942
>> 一方、私は再び次の入力した場合、および
今のyをプリントアウトし、私は2を見に行くよ。

518
00:22:10,942 --> 00:22:13,900
私は、次の入力した場合さて、それはに起こっている
今ので、少し混乱するかもしれない、

519
00:22:13,900 --> 00:22:17,250
printfのは上の表示されるように起こっている
それがなかったような画面、。 xは1である。

520
00:22:17,250 --> 00:22:18,606
>> それでは、もう一度、これをやってみましょう。

521
00:22:18,606 --> 00:22:20,480
そして今、ここにどこだ
物事は面白く。

522
00:22:20,480 --> 00:22:21,580

523
00:22:21,580 --> 00:22:26,580
私は、スワップ、あるいはステップを呼び出す前に、
その中に、のはちょっと覗いてみましょう。

524
00:22:26,580 --> 00:22:28,980
xは、再び、1である。

525
00:22:28,980 --> 00:22:33,240
Yは、もちろん、迅速な健全である
そこにハード、チェック2、そうではない。

526
00:22:33,240 --> 00:22:35,740
しかし、アンパサンドxは何ですか？

527
00:22:35,740 --> 00:22:36,760

528
00:22:36,760 --> 00:22:39,350
回答、それは一種のファンキー探しています。

529
00:22:39,350 --> 00:22:43,500
しかし、カッコ内のintスターだけです
これを言ってのGDPの方法がアドレスです。

530
00:22:43,500 --> 00:22:48,290
それは、それはへのポインタint型ですないです
int型、またはその他のアドレスとも呼ばれます。

531
00:22:48,290 --> 00:22:49,742
>> このクレイジーなことは何ですか？

532
00:22:49,742 --> 00:22:51,825
私たちは、何かを見たことがない
かなり前にそのような。

533
00:22:51,825 --> 00:22:53,650

534
00:22:53,650 --> 00:22:58,120
だから、これは私のコンピュータの内のアドレスです
xが生きるために起こる場所のメモリ。

535
00:22:58,120 --> 00:22:59,040
それは、牛、何か。

536
00:22:59,040 --> 00:23:01,290
そして、これは率直に言って、なぜ、ある
私は、矢印を描き始めましたが、

537
00:23:01,290 --> 00:23:03,340
数値の代わりに、
誰が本当に気に理由

538
00:23:03,340 --> 00:23:06,890
あなたの整数、特にであることを
大きなことだアドレス。

539
00:23:06,890 --> 00:23:12,160
しかしbffff0c4、これらが全てです
確かに16進数、

540
00:23:12,160 --> 00:23:13,720
fを0からである。

541
00:23:13,720 --> 00:23:16,590
>> だから私たちはあまりにも住むつもりはない
それらのものが何であるかの長い。

542
00:23:16,590 --> 00:23:19,400
しかし、私は、Yをプリントアウトした場合、
もちろん、私は2を参照してください。

543
00:23:19,400 --> 00:23:22,440
しかし、アンパサンドyは、私がこのアドレスを参照してください。

544
00:23:22,440 --> 00:23:26,527
そして、好奇心のために、注意してください
どれだけ離れて、xおよびyは？

545
00:23:26,527 --> 00:23:27,985
あなたは、アドレスのほとんどを無視することができます。

546
00:23:27,985 --> 00:23:29,330

547
00:23:29,330 --> 00:23:29,920
4バイト。

548
00:23:29,920 --> 00:23:33,510
そして、それは私たちと一致してい
以前のint型どの大きさであることを主張？

549
00:23:33,510 --> 00:23:34,130
4バイト。

550
00:23:34,130 --> 00:23:37,420
だから、すべてのもののライニングアップのように見える
きれいに、あなたは、メモリ内に、願っています可能性があるため。

551
00:23:37,420 --> 00:23:40,010
>> だから今、ちょうど早送りしてみましょう
この物語の最後に。

552
00:23:40,010 --> 00:23:43,290
それでは先に行くとステップを入力してみましょう、
スワップ機能に飛び込むする。

553
00:23:43,290 --> 00:23:46,880
今私は入力した場合、それはだ、気づく
xのアドレスと同じ。

554
00:23:46,880 --> 00:23:52,130
私はBを入力すると、それは同じだ
yのアドレスへ。

555
00:23:52,130 --> 00:23:57,020
私のであれば、私は何が表示されるはずです
、アドレスに行くと言う？

556
00:23:57,020 --> 00:23:58,120
だから、スタープリントする。

557
00:23:58,120 --> 00:24:00,130
だから星はこのコンテキストでは、そこに行くことを意味します。

558
00:24:00,130 --> 00:24:02,730
アンパサンドのアドレスに何を意味します。

559
00:24:02,730 --> 00:24:05,000
だから手段1スター。

560
00:24:05,000 --> 00:24:09,590
そして、プリントスターのbは私に2を提供します。

561
00:24:09,590 --> 00:24:15,750
>> そして、私は一瞬、と仮定しましょう​​、
少なくともコードということ

562
00:24:15,750 --> 00:24:18,950
することができ、今、実行に移行する
そのように通って推論した。

563
00:24:18,950 --> 00:24:21,150
しかし、私たちはずっと前にこのアイデアを再検討します。

564
00:24:21,150 --> 00:24:23,850
スワップのため、このバージョン
今正しく、ことができます

565
00:24:23,850 --> 00:24:26,650
私たちは、この特定のデータ型を交換する。

566
00:24:26,650 --> 00:24:29,120
>> だから、ご質問、次にスワップについて？

567
00:24:29,120 --> 00:24:29,890
スターオン？

568
00:24:29,890 --> 00:24:30,690
のアドレスに？

569
00:24:30,690 --> 00:24:33,270
そして、あなたはして、表示​​されます
問題は、一種の、4セット

570
00:24:33,270 --> 00:24:37,310
が、問題は、どのようにこれらの間違いなく、5を設定
物事は有用であり、多くを得る

571
00:24:37,310 --> 00:24:39,584
結果として、彼らと快適。

572
00:24:39,584 --> 00:24:40,430
まったく何？

573
00:24:40,430 --> 00:24:40,930
かしこまりました。

574
00:24:40,930 --> 00:24:44,350
だからmalloc関数は、再び、この機能で
それはちょうど、メモリ、メモリを割り当て

575
00:24:44,350 --> 00:24:45,330
配分。

576
00:24:45,330 --> 00:24:47,024
そして、なぜこれが便利なのですか？

577
00:24:47,024 --> 00:24:48,940
さて、すべてのこの時間、
あなたはmalloc関数を使用してきた。

578
00:24:48,940 --> 00:24:52,230
あなたは今どのように考えると
作品をgetStringで、おそらく、それはだ

579
00:24:52,230 --> 00:24:56,140
のチャンクの誰かを求めて
メモリ、いつでもユーザーの種類の文字列

580
00:24:56,140 --> 00:24:59,040
中、確かに私たちのため
CS50のスタッフとして、知りませんでした、

581
00:24:59,040 --> 00:25:02,710
どのように大きなその人間これらの文字列
かもしれないと入力しようとしている。

582
00:25:02,710 --> 00:25:07,910
>> それでは、最初に、に始めましょう
ピールバック方法CS50ライブラリ作品、

583
00:25:07,910 --> 00:25:10,990
例をいくつ経由で
それはそこに私たちをリードします。

584
00:25:10,990 --> 00:25:15,300
だから私はgeditのを開く場合は、
そして、scanfの0を開く

585
00:25:15,300 --> 00:25:17,055
私たちは、次のコードを参照してくださいとしている。

586
00:25:17,055 --> 00:25:18,720

587
00:25:18,720 --> 00:25:23,530
のためのウェブサイト上で利用可能なscanf関数0、
今日、比較的少ない行数のコードを持って

588
00:25:23,530 --> 00:25:25,351
ここでは、20を経て14。

589
00:25:25,351 --> 00:25:26,600
そして、のは、それがやっているか見てみましょう。

590
00:25:26,600 --> 00:25:28,920
それは、int型と呼ばれるのxを宣言しています。

591
00:25:28,920 --> 00:25:30,850
それは数下さい、のようなものを言います。

592
00:25:30,850 --> 00:25:33,940
そして今、それはscanf関数の％I、＆X、と言います。

593
00:25:33,940 --> 00:25:35,620
だから、そこに新しいものの束があります。

594
00:25:35,620 --> 00:25:38,420
>> しかし、scanf関数は、一種の考えることができます
のprintfの反対としての。

595
00:25:38,420 --> 00:25:40,090
printfのはもちろん、画面に出力します。

596
00:25:40,090 --> 00:25:44,410
ユーザーのからのスキャンのscanf関数の並べ替え
彼または彼女がタイプしたキーボードの何か。

597
00:25:44,410 --> 00:25:46,550
>> ％iはちょうどprintfのようなものです。

598
00:25:46,550 --> 00:25:49,410
これは期待する意味
ユーザーは、int型を入力します。

599
00:25:49,410 --> 00:25:52,820
そして今、なぜあなたは私が思いますか
scanfの＆Xを渡すかもしれない？

600
00:25:52,820 --> 00:25:54,030

601
00:25:54,030 --> 00:25:57,770
scanf関数の生活の中で目的の場合
ユーザーから何かを得ることです、

602
00:25:57,770 --> 00:26:02,480
の意味は何ですか
今、それを渡し、＆X？

603
00:26:02,480 --> 00:26:02,980
うん？

604
00:26:02,980 --> 00:26:03,896
>> 聴衆：[聞こえない]。

605
00:26:03,896 --> 00:26:05,540

606
00:26:05,540 --> 00:26:06,540
DAVID J.マラン：その通りです。

607
00:26:06,540 --> 00:26:12,900
どのような私は、人間は、私の入力を入力
その場所に保存されようとしている。

608
00:26:12,900 --> 00:26:17,660
それはちょうどに、十分な、リコールではありません
私たちはすでに見てきたので、Xを渡し、

609
00:26:17,660 --> 00:26:21,630
いつでもあなたは、単なる生変数を渡す
int型のような、いくつかの他の機能に、

610
00:26:21,630 --> 00:26:25,640
確かに、それはそれを変更することができます
変数ではなく、永久に。

611
00:26:25,640 --> 00:26:27,360
それは、メインに影響を与えることはできません。

612
00:26:27,360 --> 00:26:29,420
それだけで、独自のローカルコピーを変更することができます。

613
00:26:29,420 --> 00:26:32,560
しかし、もし、その代わりに、あなたはしないでください
私に実際のint型を与え、

614
00:26:32,560 --> 00:26:36,640
しかし、あなたは私に指示を与える
そのint型、今、scanf関数であること、

615
00:26:36,640 --> 00:26:41,050
確かに、私はそれに従うことができます
対処し、そこに番号を入れる

616
00:26:41,050 --> 00:26:43,280
そうあなたにもそれにアクセスすることができます。

617
00:26:43,280 --> 00:26:45,120
>> 私はこのプログラムを実行するときに、見てみましょう。

618
00:26:45,120 --> 00:26:49,660
scanfの0ドットスラッシュ、scanf関数0にしてください。

619
00:26:49,660 --> 00:26:54,030
そして、私は今番号を入力した場合
50のおかげで、50等である。

620
00:26:54,030 --> 00:26:58,150
私は今のように数値を入力した場合
負の1のために、1負。

621
00:26:58,150 --> 00:27:04,200
私は今、HM、1.5のように数値を入力します。

622
00:27:04,200 --> 00:27:06,030
なぜ私のプログラムは私を無視したのですか？

623
00:27:06,030 --> 00:27:07,300

624
00:27:07,300 --> 00:27:09,880
さて、という理由だけで、私は言った
それだけのintを期待する。

625
00:27:09,880 --> 00:27:10,380
かしこまりました。

626
00:27:10,380 --> 00:27:11,630
だから、これのバージョンは1つです。

627
00:27:11,630 --> 00:27:16,600
のノッチ物事を見てみましょうと
これは良くないことを提案する。

628
00:27:16,600 --> 00:27:20,530
そして、ここに非常に簡単な例がある
私たちは、コードを書き始める方法の

629
00:27:20,530 --> 00:27:24,450
他の人が利用することができますか
悪いことを行うことで妥協。

630
00:27:24,450 --> 00:27:28,336
だからライン16、非常に似て
前に精神で、

631
00:27:28,336 --> 00:27:29,960
私はそれが今回はint型の宣言ではないよ。

632
00:27:29,960 --> 00:27:32,970
私はそれを文字列別名char型星を、宣言しています。

633
00:27:32,970 --> 00:27:35,190
>> しかし、それは本当に何を意味するのでしょうか？

634
00:27:35,190 --> 00:27:38,790
だから私はaddress--を指定しない場合と
私は、任意のバッファを、それを呼んでいる、

635
00:27:38,790 --> 00:27:43,370
しかし、私はあること、だ、それを呼び出すことができsimple--
そして、私は、これを行う私に説明、

636
00:27:43,370 --> 00:27:48,630
あなたは以前に基づいて、できれば
ロジック、scanfの18行目に何をしているか、

637
00:27:48,630 --> 00:27:55,000
パス％sは、バッファであれば、
アドレスはありますか？

638
00:27:55,000 --> 00:27:58,210
あなたが適用される場合、scanf関数とは何ですか
バージョン0と全く同じロジック、

639
00:27:58,210 --> 00:28:00,640
と、ここで行うようにしようとするつもり
ユーザーの種類の中で何か？

640
00:28:00,640 --> 00:28:02,630

641
00:28:02,630 --> 00:28:03,409
うん？

642
00:28:03,409 --> 00:28:04,407
>> 聴衆：[聞こえない]。

643
00:28:04,407 --> 00:28:07,401

644
00:28:07,401 --> 00:28:08,890
>> DAVID J.マラン：その通りです。

645
00:28:08,890 --> 00:28:11,577
scanf関数、ロジック以前のことで、
文字列を取るつもりされている

646
00:28:11,577 --> 00:28:13,410
人間が入力したことを
、それが今の文字列ですin--

647
00:28:13,410 --> 00:28:15,790
それは、おそらく、数ではありません
彼または彼女はcooperates--た場合

648
00:28:15,790 --> 00:28:19,310
そしてそれはそれを置くことを試みるために起こっている
どのようなアドレスのメモリ内の文字列

649
00:28:19,310 --> 00:28:20,340
バッファが指定されます。

650
00:28:20,340 --> 00:28:23,870
そして、これは、素晴らしいですバッファ理由
実際のアドレスであることを意味する。

651
00:28:23,870 --> 00:28:30,470
>> しかし、私はこのプログラムはにバグが主張
非常に深刻な方法、どのような値であるため、

652
00:28:30,470 --> 00:28:31,330
デフォルトでは、バッファ？

653
00:28:31,330 --> 00:28:33,380

654
00:28:33,380 --> 00:28:34,790
私は何をしに初期化した？

655
00:28:34,790 --> 00:28:35,770
メモリのどのチャンク？

656
00:28:35,770 --> 00:28:37,480

657
00:28:37,480 --> 00:28:38,620
私が持っていないでしょ？

658
00:28:38,620 --> 00:28:42,265
>> だから私は、割り当てられたにも関わらず、
もはやSと呼ばれていたcharスター、

659
00:28:42,265 --> 00:28:48,030
それは代わりに呼ばれていますので、buffer--
それでは、変数の名前を描いてみましょう

660
00:28:48,030 --> 00:28:53,380
私が持っていない場合は、今のようにbuffer--
ここでは、getStringまたはmalloc関数と呼ばれ、

661
00:28:53,380 --> 00:28:56,030
その効果的にことを意味します
バッファは、単にいくつかのごみ値です。

662
00:28:56,030 --> 00:28:57,030
>> 今では何を意味するのでしょうか？

663
00:28:57,030 --> 00:29:00,220
それは私がscanf関数に言ったことを意味します
ユーザーから文字列を期待する。

664
00:29:00,220 --> 00:29:01,300
そして、あなたは何を知っていますか？

665
00:29:01,300 --> 00:29:03,883
何でもこの事を指している
to--と私は疑問符を描き、

666
00:29:03,883 --> 00:29:07,060
実際には、それはなるだろう
OX1、2、3、のようなものでしょ？

667
00:29:07,060 --> 00:29:10,730
これは、いくつかの偽の値だということだけで
以前からそこにあることを起こる。

668
00:29:10,730 --> 00:29:13,440
だから、別の言い方を、それはだ
バッファはちょうどであるかのように

669
00:29:13,440 --> 00:29:16,180
メモリ内の何かを指している。

670
00:29:16,180 --> 00:29:17,610
私は何か分からない。

671
00:29:17,610 --> 00:29:24,130
>> 私は今、ゲイブに入力した場合だから、それは起こっている
そこのg-B-E / 0を入れて試してみる。

672
00:29:24,130 --> 00:29:25,530
しかし、誰がそれが何であるかを知っている？

673
00:29:25,530 --> 00:29:27,480
そして、過去に、いずれかの
私たちが触れないようにしようとした時

674
00:29:27,480 --> 00:29:29,770
属していないメモリ
私たちに、何が起こったの？

675
00:29:29,770 --> 00:29:31,020

676
00:29:31,020 --> 00:29:32,870
またはほぼ毎回。

677
00:29:32,870 --> 00:29:34,310
セグメンテーションフォルト、右か？

678
00:29:34,310 --> 00:29:37,829
>> この矢印は、私はそれがだか分からない
ポインティング。それだけでいくつかのランダムな値です。

679
00:29:37,829 --> 00:29:40,370
そしてもちろん、あなたが解釈した場合
アドレスとしてランダム値、

680
00:29:40,370 --> 00:29:42,610
あなたがに行くつもりです
いくつかのランダムな目的地。

681
00:29:42,610 --> 00:29:46,810
だから、ゲイブクラッシュ確かかもしれない
ここで、この場合の私のプログラム。

682
00:29:46,810 --> 00:29:50,600
>> だから私たちはそれがほぼ同じ悪い何ができますか？

683
00:29:50,600 --> 00:29:52,660
この第三を検討し、
scanf関数の最後の例。

684
00:29:52,660 --> 00:29:53,890

685
00:29:53,890 --> 00:29:56,870
このバージョンでは、どのような意味で良いですか？

686
00:29:56,870 --> 00:29:57,990

687
00:29:57,990 --> 00:30:01,400
あなたが慣れている場合は
前の問題は、これが優れている。

688
00:30:01,400 --> 00:30:02,250
なぜ？

689
00:30:02,250 --> 00:30:03,250
>> 聴衆：[聞こえない]。

690
00:30:03,250 --> 00:30:06,235

691
00:30:06,235 --> 00:30:07,110
DAVID J.マラン：良い。

692
00:30:07,110 --> 00:30:09,970
ライン16のしたがって、この場合
ある意味で、優れている

693
00:30:09,970 --> 00:30:12,030
私たちは、明示的にしていることを
いくつかのメモリを割り当てる。

694
00:30:12,030 --> 00:30:14,190
私たちは、malloc関数を使用していない
私たちは週に2使用している

695
00:30:14,190 --> 00:30:16,060
ただ配列を宣言するアプローチ。

696
00:30:16,060 --> 00:30:18,130
そして、私たちは、その文字列の前に言った
文字だけの配列です、

697
00:30:18,130 --> 00:30:19,690
これは完全に正当なものである。

698
00:30:19,690 --> 00:30:22,910
しかし、それはのように、当然のことながら、だ
あなたは、固定サイズ、16の点に注意してください。

699
00:30:22,910 --> 00:30:25,440
>> したがって、このプログラムです
私が入力した場合、完全に安全

700
00:30:25,440 --> 00:30:29,760
1文字の文字列では、2つの文字
文字列、15文字の文字列。

701
00:30:29,760 --> 00:30:34,970
しかし、すぐに、私は16をタイプし始めると、
17、18 1,000文字列、

702
00:30:34,970 --> 00:30:37,390
どこにその文字列が終わるつもりですか？

703
00:30:37,390 --> 00:30:39,570
これは、一部はここに終わるだろう。

704
00:30:39,570 --> 00:30:42,820
しかし、その後、誰が他に何を知っている
境界を超えている

705
00:30:42,820 --> 00:30:44,270
この特定の配列の？

706
00:30:44,270 --> 00:30:48,015
>> 私がしたかのようなものだ
ここに16のボックスを宣言した。

707
00:30:48,015 --> 00:30:49,300

708
00:30:49,300 --> 00:30:52,690
したがって、すべての16を引き出すのではなく、私たちはよ
ちょうど私が16を描いたことふりをする。

709
00:30:52,690 --> 00:30:56,540
しかし、私は、文字列を読み取るしようとした場合
これは50文字のように、はるかに長いですが、

710
00:30:56,540 --> 00:31:01,270
私は置く作業を開始するつもりだ
A、B、C、D、x、y、zの。

711
00:31:01,270 --> 00:31:04,916
そして、これはおそらくです
他のいくつかのメモリ·セグメント

712
00:31:04,916 --> 00:31:06,790
それは、再び、発生する可能性があり
クラッシュする私のプログラム、

713
00:31:06,790 --> 00:31:10,600
私はを求めていませんでしたので、
ちょうど16バイト以上のもの。

714
00:31:10,600 --> 00:31:12,260
>> だから、誰が気に？

715
00:31:12,260 --> 00:31:13,880
さて、ここでCS50ライブラリです。

716
00:31:13,880 --> 00:31:17,220
そして、これのほとんどはちょうどです
トップアップの指示などである。

717
00:31:17,220 --> 00:31:21,670
CS50ライブラリ、すべてのこの時間、
52行で、この行を持っています。

718
00:31:21,670 --> 00:31:23,680
私たちは、typedefを見たり、き
あなたはtypedefで表示されます

719
00:31:23,680 --> 00:31:27,930
ちょうど作成のpset 4、内
char型の星はもっとすることができる同義語

720
00:31:27,930 --> 00:31:29,290
単に文字列と呼ばれる。

721
00:31:29,290 --> 00:31:31,540
だから、これはの一つである
いくつかの補助輪

722
00:31:31,540 --> 00:31:34,120
私たちは、フードの下に密かに使用しました。

723
00:31:34,120 --> 00:31:36,490
>> 一方、ここにgetchar関数です。

724
00:31:36,490 --> 00:31:38,190
さて、明らかに、それへのボディはありません。

725
00:31:38,190 --> 00:31:40,273
そして、実際に、私が続ければ
スクロール、私は実際にない

726
00:31:40,273 --> 00:31:42,080
いずれの実装を参照してください。
これらの関数の。

727
00:31:42,080 --> 00:31:43,140

728
00:31:43,140 --> 00:31:45,516
健全性チェックとして、それはなぜでしょうか？

729
00:31:45,516 --> 00:31:46,795
>> 聴衆：[聞こえない]。

730
00:31:46,795 --> 00:31:47,670
DAVID J.マラン：うん。

731
00:31:47,670 --> 00:31:48,950
だから、これはヘッダファイルです。

732
00:31:48,950 --> 00:31:52,520
そして、ヘッダファイルには、プロトタイプが含まれている、
プラスいくつかの他のもの、それが思われる、

733
00:31:52,520 --> 00:31:53,780
のtypedefのような。

734
00:31:53,780 --> 00:31:56,910
しかし、私たちがしたCS50.c、中
あからさまなあなたに与えられたことはありません、

735
00:31:56,910 --> 00:32:02,100
しかし、すべてのCS50アプライアンスにされている
今回は、そのフォルダの奥深く、

736
00:32:02,100 --> 00:32:04,990
全体があることに気付く
ここでの関数の束。

737
00:32:04,990 --> 00:32:06,720
>> 実際には、のは下にスクロールしてみましょう。

738
00:32:06,720 --> 00:32:08,810
それでは、今のところ、それらのほとんどを無視しましょう​​。

739
00:32:08,810 --> 00:32:12,670
しかしgetIntはまでスクロールし
そしてgetIntは動作を確認。

740
00:32:12,670 --> 00:32:13,890
だからここgetIntはです。

741
00:32:13,890 --> 00:32:17,727
あなたが本当に気にした場合、どのように取得する
int型は、ここで、機能し、そのマニュアルである。

742
00:32:17,727 --> 00:32:19,560
そしてとりわけ、
それはそれはあなたを伝えていると言う

743
00:32:19,560 --> 00:32:21,340
何それが返すことができる値の範囲。

744
00:32:21,340 --> 00:32:24,400
それは本質的に負の20億
正の20億に、与えるか、または取る。

745
00:32:24,400 --> 00:32:26,420
>> そしてそれは、このすべてが判明
時間は、私たちは初めてだなくても

746
00:32:26,420 --> 00:32:28,570
あなたがそれをチェックしていた、
何かがうまくいかない場合には、

747
00:32:28,570 --> 00:32:30,680
それはすべてのことが判明した
今回は、getIntはがあります

748
00:32:30,680 --> 00:32:33,600
特別なを返すされてい
、ヌル、一定ではない

749
00:32:33,600 --> 00:32:36,760
むしろある、INT_MAX
ただプログラマの大会。

750
00:32:36,760 --> 00:32:38,846
なお、ここで意味特別な値です。

751
00:32:38,846 --> 00:32:41,470
ただ、これをチェックしてください
場合には、何かがうまくいかない。

752
00:32:41,470 --> 00:32:43,261
しかし、私たちは気にしたことがない
これまでのものと、

753
00:32:43,261 --> 00:32:45,200
再び、このため
簡略化することを意味する。

754
00:32:45,200 --> 00:32:46,950
>> しかし、どのようにgetIntはが実装されるのですか？

755
00:32:46,950 --> 00:32:48,450
さて、人は、それは引数を取りません。

756
00:32:48,450 --> 00:32:49,390
私たちはそれを知っている。

757
00:32:49,390 --> 00:32:50,820
これは、intを返します。

758
00:32:50,820 --> 00:32:51,950
私たちはそれを知っている。

759
00:32:51,950 --> 00:32:54,460
それでは、どのようそれはボンネットの下に動作しますか？

760
00:32:54,460 --> 00:32:58,290
>> だから、明らかに無限あります
ループ、一方の​​少なくとも外観。

761
00:32:58,290 --> 00:33:00,290
私たちはにgetStringを使用していることに注意してください。

762
00:33:00,290 --> 00:33:04,000
だから面白い。 getIntは
私たち自身の機能、のgetStringを呼び出します。

763
00:33:04,000 --> 00:33:05,645
そして今、なぜこのような場合でしょうか？

764
00:33:05,645 --> 00:33:07,400

765
00:33:07,400 --> 00:33:09,842
なぜ私は守備されるのです
ここで、ライン165内の？

766
00:33:09,842 --> 00:33:11,390

767
00:33:11,390 --> 00:33:15,639
どのようなラインで発生する可能性があります
164、ちょうど明確にするには？

768
00:33:15,639 --> 00:33:16,930
これは、前と同じ答えだ。

769
00:33:16,930 --> 00:33:18,660

770
00:33:18,660 --> 00:33:20,089
ただメモリが不足かもしれません。

771
00:33:20,089 --> 00:33:23,130
何かがのgetStringで問題が発生した、
私たちはそれを扱うことができるようになってきました。

772
00:33:23,130 --> 00:33:27,070
そして、私がnullを返さない理由は、
それは、技術的には、ヌルポインタである。

773
00:33:27,070 --> 00:33:29,120
getIntはint型を返すことがあります。

774
00:33:29,120 --> 00:33:31,060
だから私は任意にしました
基本的に、決定した、

775
00:33:31,060 --> 00:33:34,600
、20億、与えるか、または取ることが起こっている
私は決してできる特殊な値になるように

776
00:33:34,600 --> 00:33:35,970
実際にユーザから得る。

777
00:33:35,970 --> 00:33:39,930
それは私が行くよただ一つの値だ
エラーコードを表現するために無駄にする。

778
00:33:39,930 --> 00:33:41,540
>> だから今、物事は少し空想を取得します。

779
00:33:41,540 --> 00:33:44,670
そして、それは全く同じ機能ではありません
以前のように、それは非常に似ています。

780
00:33:44,670 --> 00:33:50,120
だから私はラインで、ここに宣言し、注意してください
172、int型のn及びチャーCの両方。

781
00:33:50,120 --> 00:33:53,600
そして私は、このファンキーな行を使用し、
結局のところsscanfは、

782
00:33:53,600 --> 00:33:55,990
キーボードから文字列をスキャンしません。

783
00:33:55,990 --> 00:33:59,226
これは、既存の文字列を立って、その
ユーザーは、すでに入力した。

784
00:33:59,226 --> 00:34:02,100
だから私はすでに、これにgetStringと呼ばれる
私はメモリ内の文字列があることを意味します。

785
00:34:02,100 --> 00:34:05,020
sscanfはは何をしたいです
解析関数を呼び出します。

786
00:34:05,020 --> 00:34:07,760
それは私がした文字列を見て
、文字ごとに入力した

787
00:34:07,760 --> 00:34:09,250
有用な何かをする。

788
00:34:09,250 --> 00:34:10,969
その文字列は行に格納されます。

789
00:34:10,969 --> 00:34:13,560
そして、私は唯一で行くことを知っている
[OK]を、ああ、ここと言ってバックアップし、

790
00:34:13,560 --> 00:34:15,143
私は、s今回はそれをしないと呼ばれるが、ライン。

791
00:34:15,143 --> 00:34:15,989

792
00:34:15,989 --> 00:34:18,080
>> そして今、これは少し異なります。

793
00:34:18,080 --> 00:34:22,480
しかし、これは効果的理由のために、手段
私たちは、多少、今日の私たちの手を振るよ

794
00:34:22,480 --> 00:34:26,070
私達はにチェックしていることを
ユーザーが入力したかどうかを確認

795
00:34:26,070 --> 00:34:29,909
とint型と、おそらく別の文字。

796
00:34:29,909 --> 00:34:33,610
ユーザーがintで入力した場合、それはだ
私はだから、n個に格納される予定

797
00:34:33,610 --> 00:34:36,739
アドレスで、これを渡し、
私たちが今日見てきた新しいトリック。

798
00:34:36,739 --> 00:34:41,570
また、ユーザは、入力した場合
123X等では、そのX

799
00:34:41,570 --> 00:34:45,060
結局しようとしている
文字cの文字。

800
00:34:45,060 --> 00:34:48,739
>> 今ではそのsscanfは判明
インテリジェントに、私に教えてくれます、

801
00:34:48,739 --> 00:34:54,750
sscanfはどのように多くの変数があった
埋めることに成功できる。

802
00:34:54,750 --> 00:34:58,770
このロジックによる、もしそうであれば、関数
私が実装している場合、getIntあり、

803
00:34:58,770 --> 00:35:00,900
私がチェックしています、
潜在的に、利用者のための

804
00:35:00,900 --> 00:35:04,190
int型に型指定されていると
何か他のものに続いて、

805
00:35:04,190 --> 00:35:08,580
私は、sscanfは年代何をしたいですか
戻り値は真になりますか？

806
00:35:08,580 --> 00:35:10,950
目的は、取得している場合
ユーザーからわずかint型？

807
00:35:10,950 --> 00:35:13,980

808
00:35:13,980 --> 00:35:19,300
>> もしそうであればsscanfは戻ります
2、それは何を意味するのでしょうか？

809
00:35:19,300 --> 00:35:21,660
ユーザーが入力した内
何かのように、文字通り、

810
00:35:21,660 --> 00:35:24,770
意味がない123X、。

811
00:35:24,770 --> 00:35:27,490
これは、エラー状態だし、
私はそれをチェックしたいと思います。

812
00:35:27,490 --> 00:35:32,960
>> だから、これでユーザータイプの場合、バイ
このロジック、返すSSCANF何、

813
00:35:32,960 --> 00:35:33,740
あなたは言うでしょうか？

814
00:35:33,740 --> 00:35:35,070

815
00:35:35,070 --> 00:35:39,130
だから、あるため、2を返すために起こっている
123はここに行くために起こっている、

816
00:35:39,130 --> 00:35:41,580
xは、ここで終了する予定です。

817
00:35:41,580 --> 00:35:43,970
しかし、私は、xがいっぱいにする必要はありません。

818
00:35:43,970 --> 00:35:48,580
私だけで成功するためにはsscanfしたい
その変数の最初の充填。

819
00:35:48,580 --> 00:35:52,490
だからそれが理由です、私
sscanfは1を返したい。

820
00:35:52,490 --> 00:35:55,750
>> そして、これは少し頭を超えている場合
一瞬、それは全く問題ありません。

821
00:35:55,750 --> 00:36:00,030
しかしのその1を実現
getIntはとのgetStringの値

822
00:36:00,030 --> 00:36:03,630
私たちはの一体をやっているということです
したがって、このようなエラーチェックがたくさん

823
00:36:03,630 --> 00:36:07,130
その、これまでに、あなたはかなりすることができます
あなたのキーボードから何も入力し、

824
00:36:07,130 --> 00:36:08,490
そして私たちはそれをキャッチします。

825
00:36:08,490 --> 00:36:10,592
そして、私たちは確か、
スタッフは、間違いなくしません

826
00:36:10,592 --> 00:36:13,300
あなたのバグの原因になる
私たちは守備だからプログラム、

827
00:36:13,300 --> 00:36:16,270
愚かなのすべてをチェックする
ユーザーが行う可能性があります事、

828
00:36:16,270 --> 00:36:18,900
文字列を入力と同様に、時
あなたは本当にint型を望んでいた。

829
00:36:18,900 --> 00:36:21,350
だから私たちは来るnow--用
戻ってこれまでlong--前

830
00:36:21,350 --> 00:36:23,710
しかしすべてのこの時間、
のgetStringやgetIntはを持っている

831
00:36:23,710 --> 00:36:29,950
これを使用して、ボンネットの下にあった
メモリのアドレスの基本的な考え方。

832
00:36:29,950 --> 00:36:32,580
>> だから今、Aの物事を作ってみよう
もう少しユーザーフレンドリー。

833
00:36:32,580 --> 00:36:38,740
あなたはBinky最後から、思い出してたよう
time--私のマウスはそうcooperate--する場合

834
00:36:38,740 --> 00:36:42,560
私たちは、このコードを持っていた
率直に言って、かなり無意味である。

835
00:36:42,560 --> 00:36:45,330
このコードは何も達成していない
有用な、しかしそれは一例であっ

836
00:36:45,330 --> 00:36:48,330
その教授Parlante
表すために使用さ

837
00:36:48,330 --> 00:36:51,840
何がで起こっていた
メモリに関連するプログラム。

838
00:36:51,840 --> 00:36:54,850
>> それでは、これを再び語るましょう
物語超簡単に。

839
00:36:54,850 --> 00:36:58,720
これらの最初の二行で
英語では、あなたは何を言うでしょうか？

840
00:36:58,720 --> 00:37:01,230

841
00:37:01,230 --> 00:37:05,430
ただ合理的人間が、
少し技術的な用語は、刺しを取る。

842
00:37:05,430 --> 00:37:06,346
聴衆：[聞こえない]。

843
00:37:06,346 --> 00:37:07,705

844
00:37:07,705 --> 00:37:11,080
>> DAVID J.マラン：OK、あなたが確立している
あなたのxとyの変数のアドレス。

845
00:37:11,080 --> 00:37:15,520
かなり、xおよびyはないためではない
伝統的な意味での変数。

846
00:37:15,520 --> 00:37:18,054
xおよびyはアドレスである
またはアドレスを格納します。

847
00:37:18,054 --> 00:37:19,220
それでは、もう一度、これを試してみましょう。

848
00:37:19,220 --> 00:37:21,010
悪くないスタート、しかし。

849
00:37:21,010 --> 00:37:21,510
うん？

850
00:37:21,510 --> 00:37:22,426
>> 聴衆：[聞こえない]。

851
00:37:22,426 --> 00:37:23,966

852
00:37:23,966 --> 00:37:24,840
DAVID J.マラン：良い。

853
00:37:24,840 --> 00:37:26,173
私は少しクリーナーだと思う。

854
00:37:26,173 --> 00:37:28,630
二つのポインタ、2つの整数を宣言。

855
00:37:28,630 --> 00:37:30,150
そして、私たちは彼らに、xとyを呼んでいる。

856
00:37:30,150 --> 00:37:32,790
それともならば描画する
この絵のような、再び、

857
00:37:32,790 --> 00:37:36,410
非常に単純にそのすべてを思い出す
私たちは、その最初の行でやっている

858
00:37:36,410 --> 00:37:39,690
このような箱を集めている、
その中にいくつかのごみ値で、

859
00:37:39,690 --> 00:37:41,920
してからxを呼び出して、
このような別のボックス、

860
00:37:41,920 --> 00:37:43,880
いくつかのごみ値で
その中に、yのそれを呼び出す。

861
00:37:43,880 --> 00:37:45,810
私たちは、2宣言した
ポインタその究極的

862
00:37:45,810 --> 00:37:47,860
int型のアドレスを格納します。

863
00:37:47,860 --> 00:37:49,170
だから、すべてあります。

864
00:37:49,170 --> 00:37:53,290
>> Binkyはこれをしなかったので、とき、
粘土はちょうどこのように見えた。

865
00:37:53,290 --> 00:37:55,350
そして、ニックだけの種類
矢印を終え、

866
00:37:55,350 --> 00:37:57,590
彼らはどこにも向いていないかのように
特に、彼らはただだから

867
00:37:57,590 --> 00:37:58,250
ごみ値。

868
00:37:58,250 --> 00:38:01,670
彼らは明示的に初期化していない
特にどこでも。

869
00:38:01,670 --> 00:38:03,980
>> の今すぐ次の行
コー​​ド、リコールは、このでした。

870
00:38:03,980 --> 00:38:07,510
、合理的にユーザーフレンドリーで非常に
やや技術的な英語、

871
00:38:07,510 --> 00:38:09,790
コー​​ドすることのこのラインは何ですか？

872
00:38:09,790 --> 00:38:10,391
うん？

873
00:38:10,391 --> 00:38:11,333
>> 聴衆：[聞こえない]。

874
00:38:11,333 --> 00:38:12,746

875
00:38:12,746 --> 00:38:13,950
>> DAVID J.マラン：パーフェクト。

876
00:38:13,950 --> 00:38:17,016
それは、のチャンクを割り当てるだ
int型のサイズであるメモリ。

877
00:38:17,016 --> 00:38:18,140
そして、それは半分の答​​えだ。

878
00:38:18,140 --> 00:38:20,056
あなたは正しい答え
式の半分。

879
00:38:20,056 --> 00:38:22,473
何で何が起こっている
等号の左側？

880
00:38:22,473 --> 00:38:22,972
うん？

881
00:38:22,972 --> 00:38:24,814
聴衆：および譲受人
、それを変数xに？

882
00:38:24,814 --> 00:38:27,690
>> DAVID J.マラン：そして割り当て
それを変数xに。

883
00:38:27,690 --> 00:38:31,650
要約、右側の割り当てにそう
int型を格納するのに十分なメモリ。

884
00:38:31,650 --> 00:38:34,150
しかし、malloc関数、具体的
アドレスを返す

885
00:38:34,150 --> 00:38:37,270
あなたがしたメモリのチャンクの
ただ、提案のxに格納されます。

886
00:38:37,270 --> 00:38:42,560
>> それでは、ニックはBinkyで前回やったことはある
彼はそのポインタをドラッグし、粘土、

887
00:38:42,560 --> 00:38:46,820
メモリの白いチャンクで今指すように
それは、int型のサイズと同じである。

888
00:38:46,820 --> 00:38:49,360
そして実際、それは意味だ
4バイトを表します。

889
00:38:49,360 --> 00:38:55,310
>> コー​​ドのさて、次の行
これをした、スターのxが42を取得します。

890
00:38:55,310 --> 00:38:58,530
だから42が上に簡単です
右側、人生の意味。

891
00:38:58,530 --> 00:39:00,500
左側、スターのxが何を意味する？

892
00:39:00,500 --> 00:39:01,600

893
00:39:01,600 --> 00:39:03,280
それは大丈夫ですgone--それも可能性があります。

894
00:39:03,280 --> 00:39:04,220
[OK]をクリックします。

895
00:39:04,220 --> 00:39:06,875
>> 聴衆：基本的には、
[聞き取れない]に移動します

896
00:39:06,875 --> 00:39:07,750
DAVID J.マラン：良い。

897
00:39:07,750 --> 00:39:08,760
聴衆：[聞こえない]。

898
00:39:08,760 --> 00:39:09,760
DAVID J.マラン：その通りです。

899
00:39:09,760 --> 00:39:11,979
左辺は、xに行くことを意味します。

900
00:39:11,979 --> 00:39:12,520
xはアドレスです。

901
00:39:12,520 --> 00:39:15,520
それは、33オックスフォードストリート、またはOX1のようなものだ。

902
00:39:15,520 --> 00:39:18,690
そして、スターのxはそれに行くことを意味
アドレスとそこに何を入れる？

903
00:39:18,690 --> 00:39:19,520
42。

904
00:39:19,520 --> 00:39:21,290
>> だから確かに、それはニックはまったく同じものです。

905
00:39:21,290 --> 00:39:23,740
彼は、ことで始まり
基本的に、精神的に

906
00:39:23,740 --> 00:39:26,270
指でのポインティング
矢印以下のx、

907
00:39:26,270 --> 00:39:30,670
右側の白いボックスに
側、そしてそこに数42を置く。

908
00:39:30,670 --> 00:39:34,120
しかし、その後のことが得た
少し危険な、右か？

909
00:39:34,120 --> 00:39:35,860
Binkyの頭を失うことについての。

910
00:39:35,860 --> 00:39:39,465
>> スターyは何を意味し、13、不運に等しい？

911
00:39:39,465 --> 00:39:43,620
だから、スターのyの手段がyのアドレスにアクセスしてください。

912
00:39:43,620 --> 00:39:45,630
しかし、yのアドレスは何ですか？

913
00:39:45,630 --> 00:39:47,899

914
00:39:47,899 --> 00:39:49,440
すべての権利、それが正しい、ガベージ値ですか？

915
00:39:49,440 --> 00:39:50,800
私は疑問符としてそれを描きました。

916
00:39:50,800 --> 00:39:54,850
ニックは丸くなっ矢印として描きました。

917
00:39:54,850 --> 00:39:59,600
そして、できるだけ早くあなたがしようとして
そこに行くと言って、スターyを行い、

918
00:39:59,600 --> 00:40:03,872
しかし、正当ではありません
アドレスは、いくつかの偽の立地、

919
00:40:03,872 --> 00:40:05,080
プログラムがクラッシュするだろう。

920
00:40:05,080 --> 00:40:08,580
そして、Binkyの頭が起こっている
それがなかったように、ここに飛んでいる。

921
00:40:08,580 --> 00:40:12,130
>> このプログラムは、最終的にはそう
ちょうど平らな傷だった。

922
00:40:12,130 --> 00:40:13,540
これは、バグのあるプログラムでした。

923
00:40:13,540 --> 00:40:14,760
そして、それは修正される必要がありました。

924
00:40:14,760 --> 00:40:18,260
そして、唯一の方法は、実際に、それを修正するために
例えば、このラインになり、

925
00:40:18,260 --> 00:40:21,010
私たちもに到達しなかった、なぜなら
プログラムは、あまりにも早く墜落した。

926
00:40:21,010 --> 00:40:26,170
しかし、私たちはこれを修正した場合、どのような
効果をyに等しいxは持ってやっていますか？

927
00:40:26,170 --> 00:40:30,010
まあ、それは本質的でyを指す
どのような値xで指している。

928
00:40:30,010 --> 00:40:32,430
>> だから、ニックの物語の中で、
両方またはBinkyの話、

929
00:40:32,430 --> 00:40:34,640
xおよびyは指し示すた
メモリの白チャンク、

930
00:40:34,640 --> 00:40:38,300
その結果、最終的に、ときに
yが再び13になりスターんが、

931
00:40:38,300 --> 00:40:43,080
あなたは13に入れてしまう
適切な場所。

932
00:40:43,080 --> 00:40:47,640
したがって、これらのラインの全てが完璧です
これを除いて、正当な、

933
00:40:47,640 --> 00:40:51,730
それはあなたの前に起こったとき
実際にyのいくつかの値が割り当てられています。

934
00:40:51,730 --> 00:40:54,290
>> さて、ありがたいことに、はしないでください
すべてを通して推論する必要があります

935
00:40:54,290 --> 00:40:56,560
ご自身での問題、これらの種類の。

936
00:40:56,560 --> 00:40:59,310
私が先に行くと開いてみましょう
ここでターミナルウィンドウまで

937
00:40:59,310 --> 00:41:03,050
とちょっと、開く、
スーパーショートプログラムもの

938
00:41:03,050 --> 00:41:04,360
また、ソートの無意味です。

939
00:41:04,360 --> 00:41:05,152
それは醜いです。

940
00:41:05,152 --> 00:41:06,610
それは便利な何かを達成しない。

941
00:41:06,610 --> 00:41:10,180
しかし、それは問題を示さない
メモリが、それでは見てみましょう。

942
00:41:10,180 --> 00:41:11,830
>> 超簡単、メイン。

943
00:41:11,830 --> 00:41:14,830
これは、明らかに関数を呼び出し、
fは、その後、0を返します。

944
00:41:14,830 --> 00:41:16,310
それは台無しこれまでに種のは難しい。

945
00:41:16,310 --> 00:41:18,540
だから主は、これまでのところ、かなり良いです。

946
00:41:18,540 --> 00:41:20,100
>> それでfは問題である。

947
00:41:20,100 --> 00:41:22,120
そして、ちょうど多くを入れていない
それに名前を付けるに努力

948
00:41:22,120 --> 00:41:23,990
ここでは、コードにフォーカスを維持する。

949
00:41:23,990 --> 00:41:25,740
fは2つの行を持っています。

950
00:41:25,740 --> 00:41:27,610
そして今度は、何が起こっているのか見てみましょう。

951
00:41:27,610 --> 00:41:29,840
だから、一方では
here--と私は作ってみよう

952
00:41:29,840 --> 00:41:32,680
以前、この一貫性のある
、一方ではexample--

953
00:41:32,680 --> 00:41:35,830
左側は
英語で、何をやって？

954
00:41:35,830 --> 00:41:36,493
それはis--

955
00:41:36,493 --> 00:41:37,701
聴衆：ポインタを作成します。

956
00:41:37,701 --> 00:41:40,830
DAVID J.マラン：ポインタの作成
int型であり、Xと呼ん。

957
00:41:40,830 --> 00:41:43,789
だから、これらのボックスのいずれかを作成することだ
私は、タッチスクリーン上に描画し続ける。

958
00:41:43,789 --> 00:41:45,913
そして今、右手上
側、malloc関数はもちろん、

959
00:41:45,913 --> 00:41:47,420
メモリのチャンクを割り当てて。

960
00:41:47,420 --> 00:41:49,989
そして、ちょうど明確にすることが、どのように
多くのメモリは、明らかにそれである

961
00:41:49,989 --> 00:41:52,030
ちょうどあなたと、割り当てる
種類のここで計算を行う？

962
00:41:52,030 --> 00:41:53,200

963
00:41:53,200 --> 00:41:54,040
>> だから、40バイトです。

964
00:41:54,040 --> 00:41:57,400
そして、私は私が知っているという理由だけであることを知っている
int型、CS50アプライアンス上、少なくとも、

965
00:41:57,400 --> 00:41:58,060
4バイトです。

966
00:41:58,060 --> 00:41:59,610
だから、10回4は40です。

967
00:41:59,610 --> 00:42:04,924
だから、これは、X、アドレスを記憶している
その40 intのうち最初の

968
00:42:04,924 --> 00:42:07,340
バックスペースを割り当てられている、
、背中合わせにするために、バックアップする。

969
00:42:07,340 --> 00:42:08,470
>> そして、それはmalloc関数に関する重要だものだ。

970
00:42:08,470 --> 00:42:11,261
これは、少ないメモリを取りません
ここでは、ここで少し、少しここに。

971
00:42:11,261 --> 00:42:14,220
それはあなたのメモリの一塊を与え、
連続して、営業から

972
00:42:14,220 --> 00:42:15,240
システム。

973
00:42:15,240 --> 00:42:18,500
>> 今、この約何、
Xブラケット10は0に等しい？

974
00:42:18,500 --> 00:42:19,470
コー​​ドの任意の行。

975
00:42:19,470 --> 00:42:21,100
それは便利な何かを達成しない。

976
00:42:21,100 --> 00:42:26,128
しかし、それは面白いです、
Xブラケット10--理由？

977
00:42:26,128 --> 00:42:26,628
うん？

978
00:42:26,628 --> 00:42:27,912
>> 聴衆：[聞き取れない]？

979
00:42:27,912 --> 00:42:30,500
>> DAVID J.マラン：Xブラケット
10はNULLである必要はありません。

980
00:42:30,500 --> 00:42:35,070
ヌルディテールだけで場に出る
文字列を持つ、文字列の末尾に。

981
00:42:35,070 --> 00:42:36,700
しかし、よく考えて。

982
00:42:36,700 --> 00:42:39,615
>> この配列はさらに、どのように大きいです
私は、40バイトが割り当てられてきたものの？

983
00:42:39,615 --> 00:42:42,560

984
00:42:42,560 --> 00:42:43,690
それは右、9 0〜ですか？

985
00:42:43,690 --> 00:42:45,120
それは10のint、合計です。

986
00:42:45,120 --> 00:42:48,790
40バイトが、10 int型、
0 0からインデックス付き。

987
00:42:48,790 --> 00:42:50,930
>> だからのxブラケット10は何ですか？

988
00:42:50,930 --> 00:42:53,090
それは実際にいくつかの
未知のごみ値。

989
00:42:53,090 --> 00:42:54,780
それは私に属していないメモリです。

990
00:42:54,780 --> 00:42:59,650
私はあることに触れすべきではない
バイト数は41、42、43、44。

991
00:42:59,650 --> 00:43:01,420
私はあまりにも遠く少しつもりです。

992
00:43:01,420 --> 00:43:04,490
>> そして実際、私はこれを実行した場合
プログラムは、それは非常によくクラッシュする可能性があります。

993
00:43:04,490 --> 00:43:05,790
しかし、時には、私たちは幸運取得します。

994
00:43:05,790 --> 00:43:07,706
そして、これだけ実証する
this--と率直に言って、

995
00:43:07,706 --> 00:43:11,000
あなたがあなたの前に知っていることはありません
それでは、これを実行してみましょうit--ください。

996
00:43:11,000 --> 00:43:12,480
それは実際にクラッシュしていない。

997
00:43:12,480 --> 00:43:15,032
>> しかし、私はこれを変更した場合、用
インスタンスは、1000のようになるために

998
00:43:15,032 --> 00:43:16,740
本当にこれを作る
意図的な、見てみましょう

999
00:43:16,740 --> 00:43:18,710
私たちは、この時間をクラッシュさせる得ることができます。

1000
00:43:18,710 --> 00:43:20,070
[OK]を、それがクラッシュしていない。

1001
00:43:20,070 --> 00:43:22,600
どのように約100,000？

1002
00:43:22,600 --> 00:43:25,000
のは、それをリメイクしましょう​​、そして今それを再実行します。

1003
00:43:25,000 --> 00:43:25,500
[OK]をクリックします。

1004
00:43:25,500 --> 00:43:25,960
あー。

1005
00:43:25,960 --> 00:43:26,460
かしこまりました。

1006
00:43:26,460 --> 00:43:29,090
そこで明らかに、再び、これらの
いわばメモリのセグメント、

1007
00:43:29,090 --> 00:43:32,660
私たちはできる、合理的に大きいです
何度も何度も幸運を得る。

1008
00:43:32,660 --> 00:43:36,510
しかし、最終的には、一度あなたがばかげ取得
本当に、画面上で遠くに出かける

1009
00:43:36,510 --> 00:43:39,120
あなたは、本当にメモリに触れる
本当にあなたに属していません。

1010
00:43:39,120 --> 00:43:40,870
>> しかし、率直に言って、これらの
バグの種類がしようとしている

1011
00:43:40,870 --> 00:43:43,020
難しくなるように
自分で把握できます。

1012
00:43:43,020 --> 00:43:47,880
しかし、ありがたいことに、プログラマのように、私たちは持っている
私たちは私たちのためにこれを行うためのツール。

1013
00:43:47,880 --> 00:43:50,140
だから、これは、おそらく、一つです
醜いのプログラム、

1014
00:43:50,140 --> 00:43:52,060
GDBの出力よりもさらに醜い。

1015
00:43:52,060 --> 00:43:55,670
しかし、それは常に行を持つか
超便利2アール。

1016
00:43:55,670 --> 00:44:00,310
>> Valgrindのは役立つプログラムです
あなたがプログラムをデバッグしない、それ自体、

1017
00:44:00,310 --> 00:44:03,500
が、メモリ関連の発見
問題は、具体的に。

1018
00:44:03,500 --> 00:44:07,590
それは自動的にあなたのコードを実行します
あなたと、少なくとも2つのものを探す。

1019
00:44:07,590 --> 00:44:10,680
一方、あなたが何かをしましたか
タッチメモリのような偶発

1020
00:44:10,680 --> 00:44:11,980
それはあなたに属していたのですか？

1021
00:44:11,980 --> 00:44:13,590
それはあなたがこれらのケースを見つけましょう。

1022
00:44:13,590 --> 00:44:15,710
>> そして2、それが役立つ
あなたはと呼ばれるものを見つける

1023
00:44:15,710 --> 00:44:19,270
私たちが持っているメモリリーク、
完全に無視、単純に、

1024
00:44:19,270 --> 00:44:21,380
しばらくして穏やか。

1025
00:44:21,380 --> 00:44:23,140
しかし、それはすべて、判明
今回は、いつでも

1026
00:44:23,140 --> 00:44:26,620
あなたはgetStringメソッドで呼び出されました
私たちのプログラムのように多くの、

1027
00:44:26,620 --> 00:44:28,930
あなたは営業を求めている
メモリのためのシステム、

1028
00:44:28,930 --> 00:44:32,070
しかし、あなたはどんな思い出を持っている
今までそれを与える

1029
00:44:32,070 --> 00:44:36,169
背中、UNALLOCをやったり、
自由、それは呼ばれるように。

1030
00:44:36,169 --> 00:44:37,960
いいえ、私たちは初めてだしないため、
そうするように頼んだ。

1031
00:44:37,960 --> 00:44:41,250
>> しかし、すべてのこの時間、プログラム
あなたがC言語で書いてきた

1032
00:44:41,250 --> 00:44:43,800
メモリリークされてきた、
運転を求めて

1033
00:44:43,800 --> 00:44:46,190
より多くのためのシステム
文字列やその他もろもろのためのメモリ、

1034
00:44:46,190 --> 00:44:47,870
が、それをバック渡すことはありません。

1035
00:44:47,870 --> 00:44:50,080
そして今、これは少しある
単純化の、

1036
00:44:50,080 --> 00:44:53,550
しかし、あなたがあなたのMacまたはを実行してしまった場合
かなりの時間、開放のためにPC

1037
00:44:53,550 --> 00:44:55,790
プログラムの多く、
多分、プログラムを終了

1038
00:44:55,790 --> 00:44:57,795
とにもかかわらず、あなたの
コンピュータがクラッシュしていない、

1039
00:44:57,795 --> 00:45:01,690
それは、そんなに遅いなってきた
それは本当にだかのように

1040
00:45:01,690 --> 00:45:04,290
大量のメモリを使用するか、
リソース、たとえ、

1041
00:45:04,290 --> 00:45:06,070
あなたもいないのであれば
キーボードに触れ、

1042
00:45:06,070 --> 00:45:10,430
それはalways--なかっbe--が、できませんでした
あなたが実行しているプログラムのことである

1043
00:45:10,430 --> 00:45:11,920
それ自体がメモリリークを持っている。

1044
00:45:11,920 --> 00:45:15,645
そして、彼らはますますのOSを求めておく
より多くのメモリが、それを忘れ、

1045
00:45:15,645 --> 00:45:18,470
実際に、それを使用していないが、
したがって、離れてメモリを取って

1046
00:45:18,470 --> 00:45:20,500
それをする可能性のある他のプログラムから。

1047
00:45:20,500 --> 00:45:23,940
だから、一般的な説明です。

1048
00:45:23,940 --> 00:45:25,940
今ここにどこValgrindの者です
出力は完全に

1049
00:45:25,940 --> 00:45:29,290
少ないものに凶悪な
同様に、より快適。

1050
00:45:29,290 --> 00:45:32,690
しかし、興味深いの
スタッフはここまでです。

1051
00:45:32,690 --> 00:45:37,060
それは私の無効な書き込みを語っている
サイズ4は、このプログラムに起こる

1052
00:45:37,060 --> 00:45:40,640
特に、のmemory.cの21行で。

1053
00:45:40,640 --> 00:45:45,450
>> 私はHM、そこに確かに、21行目に移動した場合
サイズ4の無効な書き込みである。

1054
00:45:45,450 --> 00:45:46,250
なぜサイズ4？

1055
00:45:46,250 --> 00:45:49,500
さて、このnumber--、それ
intでanything--である可能性があります。

1056
00:45:49,500 --> 00:45:50,450
だから、4バイトです。

1057
00:45:50,450 --> 00:45:52,550
だから私は、4バイトを入れている
どこに属していない。

1058
00:45:52,550 --> 00:45:55,080
それはどのようなValgrindのだ
実際に私に言っている。

1059
00:45:55,080 --> 00:45:57,600
さらに、それはまた、意志
私たちが見るよう、私に教えて、

1060
00:45:57,600 --> 00:46:01,490
あなたがあれば、将来のpsetでこれを実行するようにし、
あなたが実際にメモリをリークしてきたとき

1061
00:46:01,490 --> 00:46:05,300
私が呼んでいるので、私は、持っている
malloc関数が、私は実際には持っていない

1062
00:46:05,300 --> 00:46:08,010
フリー、この場合には、いわゆる
その私たちが最終的に表示されます

1063
00:46:08,010 --> 00:46:09,830
malloc関数の逆です。

1064
00:46:09,830 --> 00:46:10,860

1065
00:46:10,860 --> 00:46:12,930
>> だから今、私は、最後の例だと思います。

1066
00:46:12,930 --> 00:46:14,050

1067
00:46:14,050 --> 00:46:16,690
したがって、この1はもう少しだ
難解な、そ​​れはおそらくです

1068
00:46:16,690 --> 00:46:19,180
への最大の理由
メモリに注意して、

1069
00:46:19,180 --> 00:46:24,490
そして理由は、多くのプログラム
および/またはWebサーバも、この日に、

1070
00:46:24,490 --> 00:46:28,200
どこかで悪者に引き継がれている
何とかあるインターネット上の

1071
00:46:28,200 --> 00:46:33,390
サーバーに偽のパケットを送信する
あなたのアカウントを侵害しようとすると、

1072
00:46:33,390 --> 00:46:36,420
またはちょうどあなたのデータを取るか、
一般的にマシンを引き継ぐ。

1073
00:46:36,420 --> 00:46:38,910
バッファオーバーフローなど
名前は、手段を示唆している

1074
00:46:38,910 --> 00:46:40,740
ではないのintが、バッファのオーバーフロー。

1075
00:46:40,740 --> 00:46:43,490
そして、バッファは変わった方法である
それはメモリの束だと言っている。

1076
00:46:43,490 --> 00:46:46,710
>> そして実際、私は、文字列と呼ばれる
バッファの前に、代わりにsの。

1077
00:46:46,710 --> 00:46:49,234
それはバッファの場合にはそのため、
YouTubeの意味でのように、

1078
00:46:49,234 --> 00:46:52,400
またはビデオを監視していますいつでも、
あなたが単語のバッファリングを見たかもしれない、

1079
00:46:52,400 --> 00:46:53,040
ドットドットドット。

1080
00:46:53,040 --> 00:46:54,240
それは信じられないほど迷惑なんだ。

1081
00:46:54,240 --> 00:46:55,990
そして、それはただの手段
そのあなたのビデオプレーヤー

1082
00:46:55,990 --> 00:46:58,710
多くをダウンロードしようとしている
バイト、バイトの多くの

1083
00:46:58,710 --> 00:47:00,170
インターネットからのビデオから。

1084
00:47:00,170 --> 00:47:02,920
しかし、それは遅いですので、それはしようとしている
それらの束をダウンロードする

1085
00:47:02,920 --> 00:47:06,430
その結果、バッファ、コンテナを埋めるために
あなたはそのことが次にでき十分なバイトを持つ

1086
00:47:06,430 --> 00:47:09,174
あなたのビデオを表示、
常に一時停止せずに。

1087
00:47:09,174 --> 00:47:11,340
しかし、それはあなたができる、判明
この大きなバッファを持っています。

1088
00:47:11,340 --> 00:47:15,710
しかし、この多くのデータを配置しよう
それは、非常に悪いことが起こる可能性があります。

1089
00:47:15,710 --> 00:47:22,780
例えばそれでは、見てみましょう
例のこの最後のティーザー。

1090
00:47:22,780 --> 00:47:24,720
これは、別のプログラムであり、
その、一見、

1091
00:47:24,720 --> 00:47:26,540
超便利何もしない。

1092
00:47:26,540 --> 00:47:29,590
これは、主な機能を持っている
それをf、その関数を呼び出します。

1093
00:47:29,590 --> 00:47:36,640
そして、その関数は、fは、ここまで、あります
サイズ12のCと呼ばれる文字配列、、。

1094
00:47:36,640 --> 00:47:39,340
その後、これを使っている
新しい関数はstrncpyを呼ばれる。

1095
00:47:39,340 --> 00:47:40,430

1096
00:47:40,430 --> 00:47:45,190
>> それは、この単純で、ことが判明
コー​​ドの単純な線、わずか2行、

1097
00:47:45,190 --> 00:47:49,130
私たちは、私の全体のプログラムを行っている
そのため、私の全体のコンピュータ、

1098
00:47:49,130 --> 00:47:54,000
と私のユーザーアカウント、および私のハード
誰にも潜在的に脆弱ドライブ

1099
00:47:54,000 --> 00:47:58,170
誰が知っているし、実行するのに十分に良好である
特定のコマンドラインでこのプログラム

1100
00:47:58,170 --> 00:47:58,900
引数。

1101
00:47:58,900 --> 00:48:03,400
換言すれば、この悪いやつ
次のように入力してargvargv [1]の中に入れます

1102
00:48:03,400 --> 00:48:08,750
非常に特別な細工がされたキーボードで
文字列ではなく、ABC、123、しかし本質的に、

1103
00:48:08,750 --> 00:48:15,180
実行可​​能ファイルを表すバイナリシンボル
コー​​ド、彼または彼女が書いたプログラムを、

1104
00:48:15,180 --> 00:48:19,190
で、この単純なプログラムと
プログラムの何千人もの代表

1105
00:48:19,190 --> 00:48:23,610
、あえて言う同様に脆弱であること、
彼または彼女は最終的にすべてを削除することができます

1106
00:48:23,610 --> 00:48:26,680
私のハードドライブ上のファイルは、取得
彼または彼女ができるように、プロンプトを点滅

1107
00:48:26,680 --> 00:48:30,170
自分でコマンドを入力し、
自分自身にすべてのファイルを電子メールで送信。

1108
00:48:30,170 --> 00:48:34,660
私が何かできることは、彼
または彼女は、このコードで行うことができます。

1109
00:48:34,660 --> 00:48:36,575
>> 私たちは、非常にまだこれを解決することはできません。

1110
00:48:36,575 --> 00:48:38,700
そして、実際に、それはに起こっている
小さな画像を伴う

1111
00:48:38,700 --> 00:48:41,470
このように、私たちはすぐに来るよこれ
すべてをよりよく理解する。

1112
00:48:41,470 --> 00:48:44,480
しかし、今日のために、の上で終わらせて
うまくいけば何の、やや

1113
00:48:44,480 --> 00:48:48,360
理解できるXKCDジョーク、
私たちは次の時間を再開するまで。

1114
00:48:48,360 --> 00:48:51,100

1115
00:48:51,100 --> 00:48:51,600
かしこまりました。

1116
00:48:51,600 --> 00:48:53,446
水曜日にお会いしましょう​​。

1117
00:48:53,446 --> 00:48:54,754
>> [音楽再生]

1118
00:48:54,754 --> 00:48:57,790
>> スピーカー：そして今、深い
祈るファーナムによる思考、。

1119
00:48:57,790 --> 00:49:00,890

1120
00:49:00,890 --> 00:49:04,770
メモリがの山に飛び込むようなものです
日曜日の午後に金色の葉。

1121
00:49:04,770 --> 00:49:09,000
風あなたを投げ、吹い
ああhair--、私は日when--欠場

1122
00:49:09,000 --> 00:49:11,100

1123
00:49:11,100 --> 00:49:12,650
>> [笑い]

1124
00:49:12,650 --> 00:49:13,750