1
00:00:00,000 --> 00:00:11,242
>> [音楽再生]

2
00:00:11,242 --> 00:00:16,630
>> DAVID J.マラン：すべての権利、これはCS50です
これは週5の始まりです。

3
00:00:16,630 --> 00:00:21,480
だから、今日、あなたのシートクッションの下に、
あなたは何を見つけることができません。

4
00:00:21,480 --> 00:00:24,790
しかし、上記の、あなたは、これらを見つける必要があります
私たちの感謝の少しトークン

5
00:00:24,790 --> 00:00:26,970
あなたが入れた仕事のすべて
フィフティーンのゲームに。

6
00:00:26,970 --> 00:00:30,290
単純に少し円を削除する
ために再生を開始するためのボトム

7
00:00:30,290 --> 00:00:31,680
クラスの残りの部分。

8
00:00:31,680 --> 00:00:38,930
>> だからを思い出す、または設定した問題を知っている
この週末に出か​​けた4、

9
00:00:38,930 --> 00:00:40,340
別のゲームを書くことが含まれます。

10
00:00:40,340 --> 00:00:43,740
それは使用することを含むが、今回
実際のグラフィカル·ユーザー·インターフェースではなく、

11
00:00:43,740 --> 00:00:46,310
のようなテキストインターフェース
フィフティーンのゲームだった。

12
00:00:46,310 --> 00:00:50,210
あなたの前に位置しており、ゲーム、
あなたは、まだこの次を見ていないした場合、

13
00:00:50,210 --> 00:00:52,310
このような小さなものが見えます。

14
00:00:52,310 --> 00:00:55,170
私はターミナルに行くつもりです
ここでGDBの窓。

15
00:00:55,170 --> 00:00:58,600
そして、私は先に行くと実行するつもりだ
あなたがアクセスできるスタッフソリューション、

16
00:00:58,600 --> 00:01:01,010
いつものようにアップデート50を実行した後。

17
00:01:01,010 --> 00:01:04,090
>> しかし、私は少しにそれを置くつもりです
シークレットモードでは、少しイースターエッグ、

18
00:01:04,090 --> 00:01:08,480
によって、神モード、いわゆる
argv1で神を置く。

19
00:01:08,480 --> 00:01:12,920
そして、私は自分の指示に従わなければならない、
私自身でそれを実行している

20
00:01:12,920 --> 00:01:14,220
問題は、ディレクトリを設定します。

21
00:01:14,220 --> 00:01:19,190
だから今は、完全なバージョンを参照してください
ブレイクアウトのゲームの。

22
00:01:19,190 --> 00:01:21,090
実際には、これは非手モードである。

23
00:01:21,090 --> 00:01:24,850
だから、実際にだ - 

24
00:01:24,850 --> 00:01:26,470
でも沸かせてかもしれない - 

25
00:01:26,470 --> 00:01:30,850
で神のモードを実装するのはかなり些細
ブレイクアウト、フィフティーンのゲームとは異なり、

26
00:01:30,850 --> 00:01:33,590
そのあなたのいくつかは、取り組んでたかもしれない
ハッカーエディションの。

27
00:01:33,590 --> 00:01:37,890
>> ブレイクアウトでは、神に十分である
モードは単純に、何を行うには

28
00:01:37,890 --> 00:01:41,220
直感的にパドルを持つ？

29
00:01:41,220 --> 00:01:45,630
ただ、何にそれを等しくする
水平位置はボールである。

30
00:01:45,630 --> 00:01:49,220
そして限り、あなたはロックステップでこれを行うように
このゲームを移動するボールが意志を持つ

31
00:01:49,220 --> 00:01:53,100
、これまで、これまでに、ボールを見逃すことはありません
そして、あなたは毎回勝つ。

32
00:01:53,100 --> 00:01:55,430
>> しかし、今週のハッカー版で
ただ神モードよりはあり。

33
00:01:55,430 --> 00:01:56,720
他の機能の数があります。

34
00:01:56,720 --> 00:01:58,140
中でも、レーザー。

35
00:01:58,140 --> 00:02:01,070
だから、あなたが本当にせっかち得れば
レンガを撃墜起動することができます

36
00:02:01,070 --> 00:02:02,120
といくつかの他。

37
00:02:02,120 --> 00:02:04,560
としたいのです人のために
標準対ハッカーを校正

38
00:02:04,560 --> 00:02:08,750
版は、私が見ることができ、今週の
ハッカー版は意図的である

39
00:02:08,750 --> 00:02:12,830
神よりも、言って、もう少しなんとか
モードは、フィフティーンのゲームであった。

40
00:02:12,830 --> 00:02:15,300
>> あなたはストレッチを探しているのであればと
あなたには、いくつかの付加的な楽しみのために探している

41
00:02:15,300 --> 00:02:18,400
特徴は、関心のある場合でのダイビングを行う。

42
00:02:18,400 --> 00:02:21,280
今より実用的に、私が指摘してみましょう
外に一つのことだけでなく。

43
00:02:21,280 --> 00:02:24,780
GDB、あなたのいくつかは、まだしていない可能性があり
罰金である、個人的に触れた。

44
00:02:24,780 --> 00:02:28,530
しかし、今は本当に慣れるための時間です
このツールを使ってこれで快適に

45
00:02:28,530 --> 00:02:31,510
それはあなたの生活を行いますので
はるかに簡単に、本当に。

46
00:02:31,510 --> 00:02:34,900
>> GDBでロブの講演カップルパー
週間前に、リコール

47
00:02:34,900 --> 00:02:36,810
そのGDBデバッガです。

48
00:02:36,810 --> 00:02:41,230
それはあなたを実行できるようにするツールだ
プログラムが、それはステップ、ラインバイステップで実行

49
00:02:41,230 --> 00:02:45,680
線で、あなたの周り突くことができるように、
ので、物事が起こって表示されるので、

50
00:02:45,680 --> 00:02:47,310
あなたは、プリントアウトすることができます
変数の値。

51
00:02:47,310 --> 00:02:50,580
要するに、それはあなたにそんなに多くを提供します
printDefより力がありません。

52
00:02:50,580 --> 00:02:52,900
>> 今確かに、インタフェース
かなり難解です。

53
00:02:52,900 --> 00:02:55,180
黒と白のテキストインターフェース
ほとんどの部分。

54
00:02:55,180 --> 00:02:57,400
コマンドはやや厳しいです
最初に覚えておくべき。

55
00:02:57,400 --> 00:03:01,230
しかし、それはあなたの半分を取る場合でも
時間、時間、その先行を配置する

56
00:03:01,230 --> 00:03:02,940
そこに時間の投資は、私を信頼しています。

57
00:03:02,940 --> 00:03:06,440
確かに学期の終わりまでに、それは保存されます
あなたより一桁

58
00:03:06,440 --> 00:03:07,600
それよりも時間。

59
00:03:07,600 --> 00:03:09,200
>> インチ週間のダイビングでとても早い

60
00:03:09,200 --> 00:03:13,200
とブレイクアウトの観点から、あなたのことを知っている
あなたが持っている限り、これを行うことができます

61
00:03:13,200 --> 00:03:18,230
流通コードや独自のコード
あなたのPst4ディレクトリ内の進行である。

62
00:03:18,230 --> 00:03:21,680
あなたは、GDBを実行することができることを知っている。/ブレイクアウト。

63
00:03:21,680 --> 00:03:23,490
>> これは、開くために起こっている
このようなウィンドウが表示されます。

64
00:03:23,490 --> 00:03:25,530
私はもっ​​と自分自身を挙げてみましょう
ターミナルウィンドウの。

65
00:03:25,530 --> 00:03:27,770
そして、私が先に行くつもりです何
とやる、それだけでそれを実行していない。

66
00:03:27,770 --> 00:03:30,690
私が最初にブレークポイントを設定するつもりだ
一時停止をすることができますリコール、

67
00:03:30,690 --> 00:03:32,500
特定の場所で実行。

68
00:03:32,500 --> 00:03:35,750
>> ちょうど私が行くよ物事をシンプルに保つために
だけ入力して、行1で破る

69
00:03:35,750 --> 00:03:37,000
ナンバーワン。

70
00:03:37,000 --> 00:03:40,080

71
00:03:40,080 --> 00:03:43,250
私は実際にこのウィンドウを再度開きましょう
それはなってきたので、

72
00:03:43,250 --> 00:03:45,700
そこに少し小さい。

73
00:03:45,700 --> 00:03:53,270
それでは、私は今ここで行うつもりであることは
私はターミナルウィンドウを開く場合。

74
00:03:53,270 --> 00:03:53,910
そこに我々が行って、さあ。

75
00:03:53,910 --> 00:03:59,850
>> だから今、私はDropboxの、Pst4に戻った場合
とGDBを実行します。/ブレイクアウトは、次のコマンドを入力します気付く

76
00:03:59,850 --> 00:04:02,600
私が設定するために、1つを破るつもりだ
行1にブレークポイント。

77
00:04:02,600 --> 00:04:04,840
そして今、私は行くつもりです
先に、実行を入力します。

78
00:04:04,840 --> 00:04:07,370
そして、私が行うとき、何も気づかない
起こるようです。

79
00:04:07,370 --> 00:04:08,120
>> ないポップアップはありません。

80
00:04:08,120 --> 00:04:09,790
グラフィカルなはありません
まだユーザーインターフェース。

81
00:04:09,790 --> 00:04:13,340
私はだからしかし、それは理解できるだ
文字通りラインで私のプログラムの1つの。

82
00:04:13,340 --> 00:04:17,110
そして、私は早送りしたことに気づく
特に今62に、すべての理由

83
00:04:17,110 --> 00:04:20,600
このファイルの先頭にあるものがある
コメントや定数のようなものと

84
00:04:20,600 --> 00:04:22,460
今のものを面白くない。

85
00:04:22,460 --> 00:04:25,840
>> だから今、私は、メインの内側だ
それは、ライン62で、と思われる。

86
00:04:25,840 --> 00:04:27,960
そして、これは単にディストリビューションです
コー​​ド、リコール。

87
00:04:27,960 --> 00:04:33,810
私は、同様に、行くことによってこれまでを開く場合
Pst4に私のドロップボックスディレクトリに、

88
00:04:33,810 --> 00:04:35,450
breakout.cに。

89
00:04:35,450 --> 00:04:40,670
そして、私は下にスクロールしてダウンしてダウンしている場合は、
と私は先に行くと、オンにせ

90
00:04:40,670 --> 00:04:44,990
私の行番号。

91
00:04:44,990 --> 00:04:50,300
>> 私はダウンにスクロールすると、私は、何が表示されます
ライン62は、まさに行であることを

92
00:04:50,300 --> 00:04:50,910
我々はに一時停止しました。

93
00:04:50,910 --> 00:04:53,720
この行は、ここで、62になるように
我々がしようとしているところ。

94
00:04:53,720 --> 00:04:57,470
だから今GDBで、私が先に行くとタイプする場合
今次、それが起こっている入力

95
00:04:57,470 --> 00:04:58,450
その行を実行します。

96
00:04:58,450 --> 00:05:00,610
と出来上がり、我々は持っている
グラムウィンドウいわゆる。

97
00:05:00,610 --> 00:05:02,800
何GWindowに不慣れであれば
心配しないように、です。

98
00:05:02,800 --> 00:05:05,740
スペックは次のように、それを紹介します
よくチュートリアルビデオの数など

99
00:05:05,740 --> 00:05:06,830
スペックに包埋した。

100
00:05:06,830 --> 00:05:08,610
>> しかし、今この作ってみましょう
もう少し面白い。

101
00:05:08,610 --> 00:05:10,960
私は、このウィンドウ上を移動しましょう
側へ少し。

102
00:05:10,960 --> 00:05:13,480
私は窓を少し作ってみよう
大きなので、私はより多くを見ることができます。

103
00:05:13,480 --> 00:05:16,140
>> そして今、私は先に行かせて
そして再び次やる。

104
00:05:16,140 --> 00:05:17,550
そして、私のレンガがあります。

105
00:05:17,550 --> 00:05:20,490
私は再び次の入力した場合
今私は、ボールを参照してください。

106
00:05:20,490 --> 00:05:23,520
そして、私は再び次を入力した場合
今私はパドルを参照してください。

107
00:05:23,520 --> 00:05:26,690
>> そして、幸いにもこのgeditのではありません
本当に私を示すことによって、協力

108
00:05:26,690 --> 00:05:27,660
私が望むすべて。

109
00:05:27,660 --> 00:05:30,820
しかし、今、私は再び次の行う場合、
次再び、私はちょうどよ

110
00:05:30,820 --> 00:05:32,260
いくつかの変数を宣言する。

111
00:05:32,260 --> 00:05:34,750
そして、私はいずれかを印刷することができます
外にこれらの人の。

112
00:05:34,750 --> 00:05:37,170
プリントレンガ、版画に住んでいます。

113
00:05:37,170 --> 00:05:39,910
>> そして今、私は続けてやっていくと
次、私はだろうことに気付く

114
00:05:39,910 --> 00:05:40,870
そのループの内側。

115
00:05:40,870 --> 00:05:43,380
しかし、コードが実行されるために起こっている
まさに私が期待どおり。

116
00:05:43,380 --> 00:05:45,810
だから私はこの機能を打ったとき、待って
クリックのために、それを行うために起こっている

117
00:05:45,810 --> 00:05:46,830
それは文字通りその。

118
00:05:46,830 --> 00:05:48,870
だから私はコントロールを失っているように見えた
プログラム上。

119
00:05:48,870 --> 00:05:50,480
>> GDBは私に別のプロンプトを与えていません。

120
00:05:50,480 --> 00:05:51,500
しかし、心配しない。

121
00:05:51,500 --> 00:05:53,720
私のゲームに移動し、どこかをクリックします。

122
00:05:53,720 --> 00:05:56,270
>> と出来上がりには、今ではライン86へ進む。

123
00:05:56,270 --> 00:05:59,460
だから、再び、それは最終的に、非常に貴重だし、
問題をデバッグするための。

124
00:05:59,460 --> 00:06:03,050
あなたは、文字通りステップスルーできますので
コー​​ド、アウトとはるかにプリントもの、

125
00:06:03,050 --> 00:06:03,640
ずっと、もっと。

126
00:06:03,640 --> 00:06:07,210
独りしかし今のところ、これらのツール
かなり遠くにあなたを取得する必要があります。

127
00:06:07,210 --> 00:06:10,050
>> だから私たちは、もちろん、外観を取っている
今のグラフィックで、突然。

128
00:06:10,050 --> 00:06:12,350
そして今、私たちの世界は少しを取得
もっと面白い。

129
00:06:12,350 --> 00:06:15,680
そして、あなたはいくつかのから、多分、知っている
我々はこれらを持っていることをオンラインビデオ

130
00:06:15,680 --> 00:06:18,280
あなたが見てきたこと短パン
問題セットの一部として。

131
00:06:18,280 --> 00:06:20,460
>> そして、彼らは、意図的に、撮影してきた
白の背景に。

132
00:06:20,460 --> 00:06:23,380
そのうちのいくつかは、教育を持っている
上のいくつかのテキストを描画するフェロー

133
00:06:23,380 --> 00:06:25,490
オーバーレイの画面
それらの側面にある。

134
00:06:25,490 --> 00:06:27,760
もちろん、これはすべてのことはありません
現実の世界で興味深い。

135
00:06:27,760 --> 00:06:30,520
これはただで講堂です
大きな白い画面と背景。

136
00:06:30,520 --> 00:06:33,330
そして、私たちの素晴らしい制作チームのソート
すべてが美しく見えるの

137
00:06:33,330 --> 00:06:36,620
外トリミングによって事後
または何かをオーバーレイ

138
00:06:36,620 --> 00:06:37,840
私たちは何かしたくない。

139
00:06:37,840 --> 00:06:41,560
>> 今ちょうど今週やる気にさせると
本当に、あなたが行くことができるところ、最終的には、

140
00:06:41,560 --> 00:06:42,560
コンピュータサイエンスと。

141
00:06:42,560 --> 00:06:44,260
だけではなく、問題が発生した後4を設定します。

142
00:06:44,260 --> 00:06:48,240
しかし、後に別のコースや全体
カリキュラム、それは何をすることができます驚くべきことだ

143
00:06:48,240 --> 00:06:51,090
の観点から、これらの日を行う
特にグラフィック。

144
00:06:51,090 --> 00:06:53,440
>> 皆さんの中にはこれを見たかもしれない
オンラインの周りを流れる。

145
00:06:53,440 --> 00:06:56,240
しかし、私はちょうどのために、私はあなたが表示しようと思いました
数分、何かを垣間見る

146
00:06:56,240 --> 00:07:01,890
コンピュータ技術とどのようなCGI、
コンピュータグラフィックスは、これらの日を行うことができ

147
00:07:01,890 --> 00:07:04,510
おなじみの歌で
そしておそらく映画。

148
00:07:04,510 --> 00:07:05,760
>> [MUSIC  -  LANA DEL RAY、
"若くて美しい]

149
00:07:05,760 --> 00:10:50,270

150
00:10:50,270 --> 00:10:52,470
>> SPEAKER 1：それはほんの少しだ
驚くべきは、おそらく、どれだけ

151
00:10:52,470 --> 00:10:52,857
遍在する - 

152
00:10:52,857 --> 00:10:57,040
>> [拍手]

153
00:10:57,040 --> 00:10:59,230
>> SPEAKER 1：私はちょうどそれをダウンロード。

154
00:10:59,230 --> 00:11:02,920
しかし、それはただ、私が思うに、本当に驚くべきことだ
遍在するソフトウェアコードと方法

155
00:11:02,920 --> 00:11:04,230
このようなツールは、実際にある。

156
00:11:04,230 --> 00:11:07,685
だから方向の味だ
ているあなたは行くことができます。

157
00:11:07,685 --> 00:11:10,620
ああ、これ以上のアプライアンス今日。

158
00:11:10,620 --> 00:11:14,640
まあ、それは実際に悲劇的なタイミングだ
ポイント与えられた私はちょうど作ってみました。

159
00:11:14,640 --> 00:11:18,670
>> すべての権利、それでは起動してみましょう
再び融合。

160
00:11:18,670 --> 00:11:20,800
後で私に思い出させる。

161
00:11:20,800 --> 00:11:24,190
大丈夫、あなたが持っているはず
あなたが取得しなかった場合はさておきとして、電子メール

162
00:11:24,190 --> 00:11:25,460
そのように気付く。

163
00:11:25,460 --> 00:11:29,940
すべての権利、その結果先週リコール
我々は戻って皮これに開始

164
00:11:29,940 --> 00:11:31,380
後で文字列として知られている。

165
00:11:31,380 --> 00:11:34,700
>> 文字列ですデータ型をリコール
CS50ライブラリで宣言された。

166
00:11:34,700 --> 00:11:37,740
そしてそれは補助輪の一部だ
それは現在、離陸を開始します。

167
00:11:37,740 --> 00:11:41,280
それは早い段階で有用な概念であった。

168
00:11:41,280 --> 00:11:43,750
しかし、今、それは多くを得るために起こっている
興味深く、より強力な

169
00:11:43,750 --> 00:11:48,330
実際には、フードの下のことを参照してください
文字列はただ何か、我々は言ったのですか？

170
00:11:48,330 --> 00:11:50,500
>> ええ、そう、それは、いわゆるchar *型です。

171
00:11:50,500 --> 00:11:53,860
そして、そこに*がありことを示し
アドレスのいくつかの種類が関係する。

172
00:11:53,860 --> 00:11:58,690
そしてあなたは、char *を言うときあなただけ意味
データ型がある変数

173
00:11:58,690 --> 00:11:59,290
今ポインタ。

174
00:11:59,290 --> 00:12:01,770
そこに星があるという事実
ちょうどあなたが宣言されていることを意味

175
00:12:01,770 --> 00:12:03,020
ポインタいわゆる。

176
00:12:03,020 --> 00:12:06,220
そして、そのポインタが明らかに起こっている
アドレスの、のを保存

177
00:12:06,220 --> 00:12:07,810
もちろん、イワナ。

178
00:12:07,810 --> 00:12:08,960
>> 今、なぜこれが意味をなさない？

179
00:12:08,960 --> 00:12:11,200
さて、何が文字列である
ボンネットの下に？

180
00:12:11,200 --> 00:12:15,130
まあ、我々が言ってきたいくつかの時間のために
ボンネットの下に文字列があることを

181
00:12:15,130 --> 00:12:18,460
ただ、H-E-L-L-O、例えば。

182
00:12:18,460 --> 00:12:21,585
>> しかし、我々はこのようにについて説明しました
、本質的に、配列されて。

183
00:12:21,585 --> 00:12:25,410
と配列はその後少しなり
これらの各々は、このような多くの

184
00:12:25,410 --> 00:12:26,460
一口を取って。

185
00:12:26,460 --> 00:12:28,710
そして、我々はそこだと言ってきた
ここに戻って何か特別なもの、

186
00:12:28,710 --> 00:12:31,270
バックスラッシュ0、またはnullターミネータ。

187
00:12:31,270 --> 00:12:35,230
>> ここだからすべてのこの時間、この
文字列となっています。

188
00:12:35,230 --> 00:12:38,320
しかし、実際には、文字列です
実際にアドレス。

189
00:12:38,320 --> 00:12:43,210
そして我々が見るようにアドレスは、しばしば
慣例により0Xで始まる。

190
00:12:43,210 --> 00:12:44,540
0Xは何を意味するのでしょうか？

191
00:12:44,540 --> 00:12:45,970
誰でも知っていますか？

192
00:12:45,970 --> 00:12:47,320
>> だからそれだけで進を意味します。

193
00:12:47,320 --> 00:12:52,360
だから、pstファイルから、実際に、思い出すかもしれません
1、私は信じて、ウォームアップの一つ

194
00:12:52,360 --> 00:12:55,740
実際に約ある質問
に加えて進表記

195
00:12:55,740 --> 00:12:57,100
バイナリと小数。

196
00:12:57,100 --> 00:13:00,460
そしてここで動機はつまり
進数では16を持って

197
00:13:00,460 --> 00:13:01,770
あなたの処分での数字。

198
00:13:01,770 --> 00:13:07,900
続い0、1、2、3、4、5、6、7、8、9、
A、B、C、D、E、Fによる。

199
00:13:07,900 --> 00:13:10,430
>> そして、あなたはそれらのすべての最高を数えた場合、
あなたは16の合計を取得します。

200
00:13:10,430 --> 00:13:13,200
だから、これはとは対照的である
我々は10を持っている10進数、

201
00:13:13,200 --> 00:13:14,690
数字、9 0〜。

202
00:13:14,690 --> 00:13:17,750
これは、バイナリとは対照的だ
我々だけで0と1を持っているところ。

203
00:13:17,750 --> 00:13:21,450
>> しかし、あなただけのことができ、一日の終わりに
同じ数字を表しますが、

204
00:13:21,450 --> 00:13:22,500
多少異なる。

205
00:13:22,500 --> 00:13:25,840
と16進数が一般的であるようなので、
それが判明した - そして、我々はこれを表示されます

206
00:13:25,840 --> 00:13:28,790
後でコースで - さえ我々は得るとき
のコンテキストでWebプログラミングへ

207
00:13:28,790 --> 00:13:32,100
HTMLおよびカラーコード、
進はいいです。

208
00:13:32,100 --> 00:13:36,390
各桁なので、判明
完全に4ビットを表します。

209
00:13:36,390 --> 00:13:39,280
きれいにラインのだからそれだけで一種
として我々は、最終的に表示されます。

210
00:13:39,280 --> 00:13:44,720
だから、これはOx123か何かかもしれない
示すアドレス123、そのような

211
00:13:44,720 --> 00:13:47,050
どこかの中に私の
コンピュータのメモリ。

212
00:13:47,050 --> 00:13:50,600
>> もちろん、いくつかの問題が生じる
このため、基礎となるの

213
00:13:50,600 --> 00:13:51,520
実装。

214
00:13:51,520 --> 00:13:55,930
そして、私はで刺しを取ったことを思い出してください
このような機能を実現 - 

215
00:13:55,930 --> 00:14:00,260
先週ダッシュ0点Cを比較し、その
それがあったようにそれが見えていても

216
00:14:00,260 --> 00:14:04,270
右、それは単に比較しませんでした
二つの文字列を正しく。

217
00:14:04,270 --> 00:14:07,470
>> 私は離れてメイン投げてきたが、私が投げてきた
離れてのコメントは、ちょうど上に集中する

218
00:14:07,470 --> 00:14:08,970
ここで興味深いのコード。

219
00:14:08,970 --> 00:14:10,660
それはバグだから、それは赤でだ。

220
00:14:10,660 --> 00:14:11,670
どのような理由のために？

221
00:14:11,670 --> 00:14:15,890
>> まあ、そこに一番上に私は宣言したとき
本当に何が起こっていたか文字列、

222
00:14:15,890 --> 00:14:17,260
ボンネットの下に？

223
00:14:17,260 --> 00:14:19,530
まあ、私が上に行こう
ここで画面のことを描く。

224
00:14:19,530 --> 00:14:23,230
だから私は、再び、宣言
文字列s GetStringメソッド。

225
00:14:23,230 --> 00:14:26,640
>> だから私は今、先に行くつもりだと
それが本当に何のためにSを描く。

226
00:14:26,640 --> 00:14:28,590
それはここで、正方形になるだろう。

227
00:14:28,590 --> 00:14:30,490
と私は主張するつもりだ
それが32ビットだ。

228
00:14:30,490 --> 00:14:32,890
少なくともそれは通常、
少なくともCS50で

229
00:14:32,890 --> 00:14:34,520
コンピュータの多くでアプライアンス。

230
00:14:34,520 --> 00:14:35,980
私はそれの呼ぶつもりです。

231
00:14:35,980 --> 00:14:39,070
>> しかし、今我々思い出す
GetStringメソッドと呼ばれる。

232
00:14:39,070 --> 00:14:41,430
だからGetStringメソッドを返し、
もちろん、文字列。

233
00:14:41,430 --> 00:14:45,790
H-E-L-L-Oにおけるユーザタイプが入力した場合
文字列は、こんにちは返されます。

234
00:14:45,790 --> 00:14:51,010
その文字列は、先ほど言ったように、終了
までどこかに、コンピュータのメモリ内

235
00:14:51,010 --> 00:14:53,240
最後にバックスラッシュ0と。

236
00:14:53,240 --> 00:14:56,650
私は、配列のようにこれを描くよ - または
文字の連続した​​ブロック - 

237
00:14:56,650 --> 00:14:58,330
それは実際にあること。

238
00:14:58,330 --> 00:15:01,790
>> そして今、getStringをされているもの
実際に戻って？

239
00:15:01,790 --> 00:15:04,340
何が戻ってきましたGetStringメソッド
この時間のすべて？

240
00:15:04,340 --> 00:15:07,520
さて、私たちは、前の週には、言う
それは、文字列を返します。

241
00:15:07,520 --> 00:15:10,250
しかし、もっと技術的には、何をし
明らかにリターンをGetStringメソッド？

242
00:15:10,250 --> 00:15:11,610
>> 読者：アドレス。

243
00:15:11,610 --> 00:15:12,600
>> SPEAKER 1：アドレス。

244
00:15:12,600 --> 00:15:16,630
具体的には、のアドレスを返します
それが何であれ、非常に最初の一口、。

245
00:15:16,630 --> 00:15:18,830
ただ一つ、二つ、三つを使用し続ける
それは便利だから。

246
00:15:18,830 --> 00:15:21,380
>> これは、最初のアドレスを返します
文字列内の文字。

247
00:15:21,380 --> 00:15:23,510
そして、私たちは先週言った
それは十分である。

248
00:15:23,510 --> 00:15:26,710
我々は常に把握することができますので、どこ
文字列の末尾だけで

249
00:15:26,710 --> 00:15:30,150
用で、多分、それを反復する
ループまたはwhileループか何かのような

250
00:15:30,150 --> 00:15:34,990
つまり、単に "スラッシュ0"を探して、
特殊センチネル文字。

251
00:15:34,990 --> 00:15:37,220
>> そして、我々は知っている文字列
長さであることを起こる - 

252
00:15:37,220 --> 00:15:37,980
このケースでは - 

253
00:15:37,980 --> 00:15:38,670
5。

254
00:15:38,670 --> 00:15:43,800
だから技術的にGetStringメソッドが何をするか
それは、この場合にOx123を返しています。

255
00:15:43,800 --> 00:15:53,670
そして技術的にその後何が起こるかです
ことを私たちは、Sの中、Ox123を格納します。

256
00:15:53,670 --> 00:15:56,460
一日の終わりには、たとえこの
新しいコンセプトは、ポインタである、彼らがしている

257
00:15:56,460 --> 00:15:57,350
ただ変数。

258
00:15:57,350 --> 00:16:00,440
しかし、彼らはビットを格納しているために起こる
総称してアドレスを表しています。

259
00:16:00,440 --> 00:16:03,700
だから技術的にすべてのそれらを取得します
Sに保存されていることOx123です。

260
00:16:03,700 --> 00:16:04,680
>> 人間としてではなく、我々 - 

261
00:16:04,680 --> 00:16:06,020
 - 今日以降含む

262
00:16:06,020 --> 00:16:09,290
実際、一般的に、気にするつもりはありません
実際のアドレスは何ですか

263
00:16:09,290 --> 00:16:10,520
メモリのいくつかのチャンクの。

264
00:16:10,520 --> 00:16:14,040
それだけに細部の低レベルにだ
知的に興味深いものになる。

265
00:16:14,040 --> 00:16:15,440
だから私はこれを元に戻すつもりです。

266
00:16:15,440 --> 00:16:19,810
その代わりに、より高いレベル、ただ言う
我々は、ポインタの話をしているとき

267
00:16:19,810 --> 00:16:22,170
私はちょうどより多くを描くつもりだ
伝えてユーザーフレンドリーな矢印

268
00:16:22,170 --> 00:16:26,060
離れて同じアイデアと抄録
実際何の細目

269
00:16:26,060 --> 00:16:27,700
基本的なアドレスです。

270
00:16:27,700 --> 00:16:33,290
>> 我々はコードに戻って今ならば、どのような
我々は文字列tを持っている場合は、最後の週に起こった

271
00:16:33,290 --> 00:16:34,510
GetStringメソッドに等しい？

272
00:16:34,510 --> 00:16:38,630
こんにちはでまあ、私は再び場合、タイプ
私が手にするつもりだ、この時間

273
00:16:38,630 --> 00:16:40,460
メモリの別のチャンク。

274
00:16:40,460 --> 00:16:44,820
H-E-L-L-Oバックスラッシュ0。

275
00:16:44,820 --> 00:16:48,320
>> しかし、私はGetStringメソッドと呼ばれるので、
二回目 - 

276
00:16:48,320 --> 00:16:51,100
と私は見てからこれを知っている
GetStringメソッドのソースコード - さえ

277
00:16:51,100 --> 00:16:54,350
それがこんにちはだった偶然だけれども
二回で入力し、GetStringメソッドではありません

278
00:16:54,350 --> 00:16:55,890
最適化しようとするつもり
と賢いこと。

279
00:16:55,890 --> 00:16:58,550
それはちょうど別のチャンクを取得するために起こっている
あるコンピュータからメモリ

280
00:16:58,550 --> 00:16:59,640
別のアドレスにするつもり。

281
00:16:59,640 --> 00:17:02,330
任意にだけ456を言ってみましょう。

282
00:17:02,330 --> 00:17:04,079
>> そしてそれは何を返すために起こっている？

283
00:17:04,079 --> 00:17:08,030
それは456を返すように起こっている
とtに保管してください。

284
00:17:08,030 --> 00:17:12,010
だから何が本当にに、起こっている
左側は、私は別のチャンクを持っている

285
00:17:12,010 --> 00:17:14,260
メモリの、一般的に32ビット。

286
00:17:14,260 --> 00:17:16,720
そしてそこにOx456に行く予定です​​。

287
00:17:16,720 --> 00:17:20,140
しかし、再び、私はこれらに興味がないんだけど
もはや特定の数字。

288
00:17:20,140 --> 00:17:23,069
私はただ抽象的にするつもりです
矢印としてそれを描く。

289
00:17:23,069 --> 00:17:25,202
>> だから、これは今、新しい説明です。

290
00:17:25,202 --> 00:17:28,735
しかし、それはだまったく同じ考えだ
すべてのこの時間を起きて。

291
00:17:28,735 --> 00:17:33,150
そして理由は、次に、この最初の
比較のバージョンはバグだった

292
00:17:33,150 --> 00:17:34,480
先週はなぜですか？

293
00:17:34,480 --> 00:17:38,000
sが等しい等しい場合は、実行すると
あなたが本当に何であるT

294
00:17:38,000 --> 00:17:40,550
フードは比較の下に？

295
00:17:40,550 --> 00:17:41,910
>> あなたがアドレスを比較している。

296
00:17:41,910 --> 00:17:47,950
そして、ちょうど直感的に、はっきりと、Ox123
等しいOx456するつもりはない。

297
00:17:47,950 --> 00:17:49,380
これらの数字は、これらのビット
ただ異なっている。

298
00:17:49,380 --> 00:17:53,220
>> そして一貫して、先週、それは言った
あなたもあれば、異なるものを入力

299
00:17:53,220 --> 00:17:55,360
言葉はそのまま同じであった。

300
00:17:55,360 --> 00:17:58,770
だから我々は、これを修正。

301
00:17:58,770 --> 00:18:00,120
素人の面では、修正は何でしたか？

302
00:18:00,120 --> 00:18:02,110
>> 読者：関数を使用します。

303
00:18:02,110 --> 00:18:02,870
>> SPEAKER 1：関数を使用します。

304
00:18:02,870 --> 00:18:05,190
または星が間違いなく関与している、
しかし、何をするための関数を使用するのか？

305
00:18:05,190 --> 00:18:05,962
>> 読者：文字列を比較する。

306
00:18:05,962 --> 00:18:07,390
>> SPEAKER 1：文字列を比較する。

307
00:18:07,390 --> 00:18:11,030
だからここに根本的な問題があった
私はちょうど検討していたことを

308
00:18:11,030 --> 00:18:15,870
によって定義される文字列の品質
そのアドレスの比較。

309
00:18:15,870 --> 00:18:18,540
そして、明らかに、それはかつて今ちょうどダムだ
あなたは、何が起こっているか理解する

310
00:18:18,540 --> 00:18:19,510
ボンネットの下に。

311
00:18:19,510 --> 00:18:23,270
本当に見て文字列を比較する場合
彼らは人間のように等しいだ

312
00:18:23,270 --> 00:18:26,680
等しくなるように2つの文字列を検討する
我々はのためにそれらの文字を比較する必要が

313
00:18:26,680 --> 00:18:28,070
文字の文字。

314
00:18:28,070 --> 00:18:30,020
>> 今、私は行って可能性がある
この非常にうんざりするほど。

315
00:18:30,020 --> 00:18:32,240
しかし親しく、私たちはしている
forループを使用。

316
00:18:32,240 --> 00:18:36,050
そして、ちょうどSブラケットを比較
Tブラケット私に対して私。

317
00:18:36,050 --> 00:18:39,590
Tブラケットに対してSブラケットiのプラス1
iのプラス1など、内部

318
00:18:39,590 --> 00:18:40,580
ループのいくつかの種類。

319
00:18:40,580 --> 00:18:44,950
そして、私はその任意の2文字を見つけた場合
異なる、または私はoohのことを認識した場合、sがある

320
00:18:44,950 --> 00:18:48,410
tよりtより短いか長い
私はすぐに偽と言うことができ、

321
00:18:48,410 --> 00:18:49,390
それらは同じじゃない。

322
00:18:49,390 --> 00:18:55,370
>> しかし、私はsとtを介して取得し、言うなら
と同じ、同じ、同じ、同じ、同じ、終わり

323
00:18:55,370 --> 00:18:58,520
両方の文字列は、私が言うことができる
本当、彼らは等しくなります。

324
00:18:58,520 --> 00:19:01,040
まあ、ありがたいことに、数年前に誰か
私たちのためにそのコードを書いた。

325
00:19:01,040 --> 00:19:03,790
>> そして、彼らはそれStrComp関数と呼ばれる
文字列を比較します。

326
00:19:03,790 --> 00:19:11,900
そして、それは少しカウンタのにもかかわらず
それらの場合、直感的、StrComp関数は0を返します

327
00:19:11,900 --> 00:19:14,520
二つの文字列、s及びtは同じである。

328
00:19:14,520 --> 00:19:18,090
しかし、それは負の値を返した場合の
またはtアルファベットの前に来る必要があります

329
00:19:18,090 --> 00:19:20,610
それは来るべきか正の値
Tアルファベットの後。

330
00:19:20,610 --> 00:19:24,030
>> だから、あなたがこれまでに何かをソートする場合、
それは、StrComp関数が有用であることが判明。

331
00:19:24,030 --> 00:19:26,660
それだけで言っていませんので、
yesまたはno、等しいかどうか。

332
00:19:26,660 --> 00:19:30,440
それはあなたの順序の感覚を与える
辞書威力が好きです。

333
00:19:30,440 --> 00:19:33,770
だからStrComp関数、Sコンマtが等しい
が0に等しい

334
00:19:33,770 --> 00:19:35,200
文字列は本当に等しい。

335
00:19:35,200 --> 00:19:38,680
誰でも、この関数を書いたので、
数年前、おそらくループに使用

336
00:19:38,680 --> 00:19:42,840
そのようなまたはwhileループか何か
再び文字を超える統合する

337
00:19:42,840 --> 00:19:45,270
と何度も何度も。

338
00:19:45,270 --> 00:19:47,300
>> しかし、問題の二人はここで起こりました。

339
00:19:47,300 --> 00:19:48,750
これはcopy0.cだった。

340
00:19:48,750 --> 00:19:51,680
と赤の2つのです
それは欠陥だから。

341
00:19:51,680 --> 00:19:52,800
そして、我々はここで何をしましたか？

342
00:19:52,800 --> 00:19:54,310
さて、最初に私がGetStringメソッドと呼ばれる。

343
00:19:54,310 --> 00:19:56,255
と私は、s内の戻り値を格納されている。

344
00:19:56,255 --> 00:20:00,260
だからほとんど同じだ
画像のこの上部。

345
00:20:00,260 --> 00:20:01,490
>> しかし、何がそれの後に来る？

346
00:20:01,490 --> 00:20:04,980
まあ、私が先に行くと取り除くう
これの全体の束の。

347
00:20:04,980 --> 00:20:09,650
我々はどこに私たちだけの時間に巻き戻します
現在と一致するのを持っている

348
00:20:09,650 --> 00:20:10,940
そこに1を並べる。

349
00:20:10,940 --> 00:20:11,400
>> 私がチェックします。

350
00:20:11,400 --> 00:20:13,450
sが等しい場合は0に等しい。

351
00:20:13,450 --> 00:20:18,670
さて、クイックサイドノート、時
GetStringメソッドは0を返すことがあります？

352
00:20:18,670 --> 00:20:19,580
十分なメモリがありません。

353
00:20:19,580 --> 00:20:19,880
右？

354
00:20:19,880 --> 00:20:22,310
>> それは、これが起こるために起こっていることはまれです
確かのコンピュータ上

355
00:20:22,310 --> 00:20:24,740
またはメガバイトの数百を持って
RAMのさえギグ。

356
00:20:24,740 --> 00:20:27,080
しかし、それは、理論的には、返すことができます
特に場合は0、

357
00:20:27,080 --> 00:20:28,080
ユーザーが協力しない。

358
00:20:28,080 --> 00:20:31,640
あなたがいないようなふりをする方法があります
入力された何とトリック

359
00:20:31,640 --> 00:20:34,100
復帰にGetStringメソッド
効果的に0。

360
00:20:34,100 --> 00:20:35,470
>> だから、それをチェックするために起こっている。

361
00:20:35,470 --> 00:20:39,430
あなたがたのうちに開始している場合があるため
、既に、セグメンテーションフォルトを得る - 

362
00:20:39,430 --> 00:20:42,280
これは、おそらく源となっている
いくつかの不満 - 

363
00:20:42,280 --> 00:20:46,150
それらはほとんどの結果である
メモリ関連のエラー。

364
00:20:46,150 --> 00:20:50,440
どういうわけかあなたがに関してめちゃくちゃ
あなたは気づいていなかった場合であってもポインタ、

365
00:20:50,440 --> 00:20:51,530
ポインタがありました。

366
00:20:51,530 --> 00:20:55,260
だから、セグメンテーションを誘発したかもしれない
使用して週1早けれ障害

367
00:20:55,260 --> 00:21:02,100
ループまたはしばらくの間のようなもの
行き過ぎによって、ループと配列

368
00:21:02,100 --> 00:21:05,900
いくつかの配列の境界、過去
あなたは、で週2で、宣言

369
00:21:05,900 --> 00:21:06,690
特に。

370
00:21:06,690 --> 00:21:09,220
>> あなたも、問題でそれを行っているかもしれない
ブレイクアウトを持つ4つを設定します。

371
00:21:09,220 --> 00:21:12,910
あなたはおそらく見ていないにもかかわらず、
の配布コード内の任意の星

372
00:21:12,910 --> 00:21:17,410
ブレイクアウト、それはそれらのGRectことが判明
とGOvalおよび他のそのようなもの、

373
00:21:17,410 --> 00:21:19,650
それらは実際にはポインタである
ボンネットの下に。

374
00:21:19,650 --> 00:21:23,430
>> 私たちのようなしかし、スタンフォード、皮革の一種
そのライブラリの少なくともディテール

375
00:21:23,430 --> 00:21:26,540
はるかに私たちが行うような目的、
文字列とchar *のために。

376
00:21:26,540 --> 00:21:30,060
しかしGRectとGOval、それらのすべて
君たちはあるか、ものは使用することになります

377
00:21:30,060 --> 00:21:32,630
今週は、最終的にある
メモリアドレス。

378
00:21:32,630 --> 00:21:33,650
あなたはそれを知らない。

379
00:21:33,650 --> 00:21:37,240
>> だから、おそらく、その後驚くことではありません
あなたには、いくつかの上旅行かもしれないこと

380
00:21:37,240 --> 00:21:38,580
セグメンテーションフォルト。

381
00:21:38,580 --> 00:21:41,290
しかし、今ここで面白いものだ、
我々は我々が行う0をチェックした後であれば

382
00:21:41,290 --> 00:21:43,460
文字列tが秒を取得します。

383
00:21:43,460 --> 00:21:44,690
まあ、私がtを宣言してみましょう。

384
00:21:44,690 --> 00:21:47,730
私は、広場としてそれを描くつもりだ
32ビット、それをTと呼ぶ。

385
00:21:47,730 --> 00:21:49,740
そして、私は何をするつもりだと、秒を取得します。

386
00:21:49,740 --> 00:21:51,130
>> まあ、それはどういう意味ですか？

387
00:21:51,130 --> 00:21:53,280
まあ、それは考えることは少し難しい
賢明それについて絵。

388
00:21:53,280 --> 00:21:55,025
しかしみましょう考える
Xの中に何ですか？

389
00:21:55,025 --> 00:21:59,430
この変数は内部で文字通り何ですか？

390
00:21:59,430 --> 00:22:01,500
値Ox123。

391
00:22:01,500 --> 00:22:05,815
>> ちょうどので、私が言うとき文字列tがSを取得し、その
文字通り数を取ることを意味し

392
00:22:05,815 --> 00:22:10,070
年代に、それはOx123でありOx123を置く。

393
00:22:10,070 --> 00:22:13,740
または画像で、のであれば私は一種の抽象
離れてそれが持っているそのディテールから

394
00:22:13,740 --> 00:22:16,600
文字通り何の効果
これだけでなく、。

395
00:22:16,600 --> 00:22:22,110
>> だから今は、最後の週に戻って考えるとき
私たちは、資本主義T. Iに進ん

396
00:22:22,110 --> 00:22:23,800
Tブラケット0でした。

397
00:22:23,800 --> 00:22:27,150
まあ、Tブラケットそれはあっても0、
ポインタは、あるかのように扱うことができ

398
00:22:27,150 --> 00:22:29,220
それは、正方形で、アレイの
ブラケット表記。

399
00:22:29,220 --> 00:22:31,550
>> だからTブラケット0がどこにあるのでしょうか？

400
00:22:31,550 --> 00:22:32,990
まあ、それは時間だ。

401
00:22:32,990 --> 00:22:36,800
そして我々はそのコード行を使用する場合、
そのC type.hにある2つの上部、

402
00:22:36,800 --> 00:22:38,460
のヘッダファイル、
それが宣言された。

403
00:22:38,460 --> 00:22:44,410
このHを生かししかしのだ
、それはだと同じ正確な時間のコースです

404
00:22:44,410 --> 00:22:46,540
Sの中、いわば。

405
00:22:46,540 --> 00:22:51,930
そして今、あなたは変更されているか
オリジナルと両方大文字

406
00:22:51,930 --> 00:22:53,120
いわゆるコピー。

407
00:22:53,120 --> 00:22:56,620
あなたは、コピーをしなかったので、
人間はそれになりたいという方法。

408
00:22:56,620 --> 00:22:59,710
>> だからここに修正は、何だった
copy1.c先週？

409
00:22:59,710 --> 00:23:03,070

410
00:23:03,070 --> 00:23:05,580
関数なので、我々は実際にできた
文字列をコピーします。

411
00:23:05,580 --> 00:23:08,700
そして根本的に、我々はには何が必要ですか
文字列をコピーするためにですか？

412
00:23:08,700 --> 00:23:12,070
>> さて、この緑色のバージョンでは、ここで私は
それはかなり低いレベルにするつもり。

413
00:23:12,070 --> 00:23:14,260
関数が実際にあります
彼らはこれを助けることができる。

414
00:23:14,260 --> 00:23:17,710
しかし、一つの最も基本的な、そして最も
おなじみの1は、少なくとも、すぐになります

415
00:23:17,710 --> 00:23:19,600
私たちにおなじみの、以下の通りです - 

416
00:23:19,600 --> 00:23:21,910
そう、最初の行に1つ
緑のコードの今。

417
00:23:21,910 --> 00:23:23,970
>> 私はただのchar *としてSを書き直し。

418
00:23:23,970 --> 00:23:25,250
全く機能的ではありません
そこの違い。

419
00:23:25,250 --> 00:23:28,790
私はちょうどCS50ライブラリを捨てたと
私は、char *、それが何であるか、それを呼んでいる。

420
00:23:28,790 --> 00:23:31,640
>> さてドット、ドット、ドット、あったので
ではありませんいくつかのエラーチェック

421
00:23:31,640 --> 00:23:33,200
再び話は興味深い。

422
00:23:33,200 --> 00:23:34,710
だから今tが宣言されています。

423
00:23:34,710 --> 00:23:35,780
それはあまりにもchar *型です。

424
00:23:35,780 --> 00:23:38,280
だから私は、上の小さな広場を描いた
前のような画面が表示されます。

425
00:23:38,280 --> 00:23:41,870
>> しかし、右側に、malloc関数、
我々は、メモリが割り当てていると述べた。

426
00:23:41,870 --> 00:23:44,130
だからメモリの一部のチャンクを割り当てます。

427
00:23:44,130 --> 00:23:48,830
そして、私たちは実際にどのように多くのバイトを行う
割り当てたい、それが見えるのでしょうか？

428
00:23:48,830 --> 00:23:50,340
>> まあ、Sの文字列の長さ。

429
00:23:50,340 --> 00:23:52,310
もしそうなら、それはだこんにちはだ
5になるだろう。

430
00:23:52,310 --> 00:23:53,950
我々は、H-E-L-L-Oと言うでしょう。

431
00:23:53,950 --> 00:23:55,090
だから5バイト。

432
00:23:55,090 --> 00:23:57,960
>> しかし、その後に1を加え、なぜ1？

433
00:23:57,960 --> 00:23:58,830
0文字。

434
00:23:58,830 --> 00:24:03,640
私たちは、この男たちのための余地を残していない場合
誤って状況を作り出すかもしれない

435
00:24:03,640 --> 00:24:05,600
文字列がある場合、H-E-L-L-O。

436
00:24:05,600 --> 00:24:08,470
そして次回GetStringメソッドです
、と呼ばれ、私は、例えば、を入力

437
00:24:08,470 --> 00:24:14,020
デビッド、D-A-V-I-D、コンピューターが起こっている
sが実際にあることを考える

438
00:24:14,020 --> 00:24:18,900
H-E-L-L-O-D-A-V-I-Dそこだから
それらの単語の間に壊れるません。

439
00:24:18,900 --> 00:24:19,810
>> だから我々は休憩が必要。

440
00:24:19,810 --> 00:24:20,720
だから我々は、5つのを望んでいない。

441
00:24:20,720 --> 00:24:22,100
我々は6バイトをしたい。

442
00:24:22,100 --> 00:24:23,110
>> とバイト私は言う。

443
00:24:23,110 --> 00:24:25,220
しかし、それは本当に、charの時のサイズです。

444
00:24:25,220 --> 00:24:28,040
技術的にはcharがほとんどです
常に単一バイト。

445
00:24:28,040 --> 00:24:31,030
>> しかし、単に我々のコードは移植性を高めるために、
そう、それは上で動作するように、話すこと

446
00:24:31,030 --> 00:24:33,750
別のコンピュータであっても、彼らは可能性がある場合
下に多少異なる場合が

447
00:24:33,750 --> 00:24:36,590
フードは、私は一般的に行くよ
ようにchar型のサイズを言う

448
00:24:36,590 --> 00:24:37,660
私のコードは常に働く。

449
00:24:37,660 --> 00:24:40,610
そして、私はちょうどそれを再コンパイルする必要はありません
私は自分のコンピュータをアップグレードするか、使用しているため、

450
00:24:40,610 --> 00:24:42,140
いくつかの異なったプラットフォーム。

451
00:24:42,140 --> 00:24:45,300
>> だから私は、6倍の大きさを持っている
1であることを起こるのchar、。

452
00:24:45,300 --> 00:24:47,440
だから、malloc関数ができたことを意味
私に6バイトを与える。

453
00:24:47,440 --> 00:24:49,140
実際にやっていることは何ですか？

454
00:24:49,140 --> 00:24:52,810
まあ、私はここで時間にロールバックさせて
我々は物語のどこにいるかに。

455
00:24:52,810 --> 00:24:57,620
>> 私はここに戻って行くのであれば、私は宣言した
Tと呼ばれるchar *型。

456
00:24:57,620 --> 00:25:00,280
私は今、6バイトのために、mallocを呼んでいる。

457
00:25:00,280 --> 00:25:06,400
そして今、私はそれらの6を描くつもりだ
ただ配列以前のようなバイト。

458
00:25:06,400 --> 00:25:10,570
しかし、私は実際に何かわからない
この配列の内側。

459
00:25:10,570 --> 00:25:14,640
>> あなたがメモリを割り当てる場合には、判明している
あなたには、いくつかがあることを信頼することはできません

460
00:25:14,640 --> 00:25:15,810
そこに既知の値。

461
00:25:15,810 --> 00:25:18,400
それは何かによって使用されている可能性が
さもなければ、いくつかの他の機能、いくつかの他の

462
00:25:18,400 --> 00:25:19,630
あなたが書いたコード行。

463
00:25:19,630 --> 00:25:22,870
だから我々は一般的に、これらのごみを呼ぶことにします
値ととしては、おそらく、それらを描く

464
00:25:22,870 --> 00:25:26,170
疑問符、ちょうどそれを示す我々
そこに実際に何かわからない。

465
00:25:26,170 --> 00:25:30,390
そして、それはあまりにも長い間、私たちのように大したことない
それらを上書きするのに十分スマートです

466
00:25:30,390 --> 00:25:34,550
ごみ番号の値または
我々は気にしている文字。

467
00:25:34,550 --> 00:25:36,340
>> したがって、この場合には、私は何をするつもりです？

468
00:25:36,340 --> 00:25:38,670
まあ、私のラインは、コード
次、私は4を持っている。

469
00:25:38,670 --> 00:25:41,350
iが0、nは取得する取得int型
Sの文字列の長さ。

470
00:25:41,350 --> 00:25:42,750
forループはおなじみだから。

471
00:25:42,750 --> 00:25:45,875
私は、より小さいまたはnに等しい
これは、通常以上である。

472
00:25:45,875 --> 00:25:47,500
>> しかし、この時間は、それは意図的なのです。

473
00:25:47,500 --> 00:25:51,890
私は+ +、そして私は単にやる
Tブラケット私はSを取得します。

474
00:25:51,890 --> 00:25:56,320
私の絵はで、次のようになりますので、
Tに格納されているこの瞬間は、ある

475
00:25:56,320 --> 00:25:59,530
メモリのランダムチャンクのアドレス
値が不明である。

476
00:25:59,530 --> 00:26:03,030
しかし、すぐに私はTブラケットを行うように
私をここに置きます0。

477
00:26:03,030 --> 00:26:07,430
>> そして、何までそこに描かれてき終了？

478
00:26:07,430 --> 00:26:08,740
我々は時間をかけてしまう。

479
00:26:08,740 --> 00:26:11,170
それがSブラケット0であるものだからです。

480
00:26:11,170 --> 00:26:14,300
その後も同じこと
電子、およびl、およびl、およびo。

481
00:26:14,300 --> 00:26:17,930
>> nは、なぜ私が通って行きました
nに等しい？

482
00:26:17,930 --> 00:26:19,200
0文字のために。

483
00:26:19,200 --> 00:26:23,580
私は実際にあれば、これだけ、その後、明確にする
消去どんなこれらのごみ

484
00:26:23,580 --> 00:26:28,870
値であり、その後、実際に描く
私は何を期待、これはSブラケット1、2、です

485
00:26:28,870 --> 00:26:32,440
3、4、加えてそれが末尾だ
新しいキャラクター。

486
00:26:32,440 --> 00:26:36,080
>> そして今、私たちは、ドットを過ぎて継続した場合
この正しいバージョンのドット、ドット

487
00:26:36,080 --> 00:26:41,930
私はだろうと大文字Tブラケット0の
コー​​スは、まさにこれを活用すること

488
00:26:41,930 --> 00:26:47,050
ここで男、概念的に、
最終的な目標だった。

489
00:26:47,050 --> 00:26:48,040
だから、すべてのポインタということですだ。

490
00:26:48,040 --> 00:26:51,430
>> そして、あなたは数週間のためにそれらを使用してきた
今の文字列の文脈である。

491
00:26:51,430 --> 00:26:53,530
しかし、ボンネットの下に、彼らはしている
少し複雑。

492
00:26:53,530 --> 00:26:57,520
しかし、あなたはこれでそれらを考えれば
私は、彼らがしていることを提案する絵フォーム

493
00:26:57,520 --> 00:27:01,720
彼らのように、おそらくすべてのこと怖くない
まず、一見思われるかもしれません

494
00:27:01,720 --> 00:27:04,730
特に、新しい構文で。

495
00:27:04,730 --> 00:27:07,290
ポインタに関するご質問、
文字列、または文字？

496
00:27:07,290 --> 00:27:07,580
うん？

497
00:27:07,580 --> 00:27:09,252
>> 読者：あなたが戻って行くことができます
[聞こえない]に？

498
00:27:09,252 --> 00:27:10,502
>> SPEAKER 1：確かに。

499
00:27:10,502 --> 00:27:14,058

500
00:27:14,058 --> 00:27:19,525
>> 読者：あなたの一番最後に来る、どのよう
ラインは、あなたは、* Tラインを持っていない

501
00:27:19,525 --> 00:27:21,513
と* Sラインで？

502
00:27:21,513 --> 00:27:23,004
あなたへの参照を持っていない - 

503
00:27:23,004 --> 00:27:24,640
>> SPEAKER 1：ああ、本当に良い質問。

504
00:27:24,640 --> 00:27:26,800
なぜ* tと* Sを持っていないのですか？

505
00:27:26,800 --> 00:27:30,340
なぜなら私たちのように簡潔に、先週、
機能を入れ替え、私はそのとき言いました

506
00:27:30,340 --> 00:27:33,350
あなたはによってポインタ手段を持っている
我々がしたように、あなたはそこに行くどの

507
00:27:33,350 --> 00:27:36,590
物理的にステージ上で、実際にあった
スター演算子を使用します。

508
00:27:36,590 --> 00:27:40,570
>> これは角括弧ことが判明
表記法は、我々は構文呼ぶだろうものです

509
00:27:40,570 --> 00:27:44,190
だけのセクシーな方法である砂糖、
のためにそれの簡単な表記法を言って

510
00:27:44,190 --> 00:27:45,950
正確に記述しているもの。

511
00:27:45,950 --> 00:27:49,385
しかし、それはもう少し直感的だ。

512
00:27:49,385 --> 00:27:53,510
と意思の​​危険にさらされて、これはより多くのように見える
、それは必要以上に複雑に

513
00:27:53,510 --> 00:27:56,990
何が本当にここで起こっている
次のようになります - 

514
00:27:56,990 --> 00:28:01,450
私はに行くことを意味* tを言うなら
Tに格納されているアドレス。

515
00:28:01,450 --> 00:28:04,350
>> だから文字通り、保管tがされた場合
そのHのアドレス

516
00:28:04,350 --> 00:28:07,300
当初は、* tはここに行くことを意味します。

517
00:28:07,300 --> 00:28:10,730
さて、Tブラケット0は何を意味するのでしょうか？

518
00:28:10,730 --> 00:28:11,560
まったく同じもの。

519
00:28:11,560 --> 00:28:13,510
それはちょうどもう少しユーザーズ
書くことが優しい。

520
00:28:13,510 --> 00:28:14,430
>> しかし、私はまだいないよ。

521
00:28:14,430 --> 00:28:17,800
私はちょうど* tは* Sを取得すると言うことはできません。

522
00:28:17,800 --> 00:28:19,440
ので、私はその後、何をやっているでしょうか？

523
00:28:19,440 --> 00:28:22,950
I hは、H、H、H、Hを入れていまし
全部を通して。

524
00:28:22,950 --> 00:28:22,995
右？

525
00:28:22,995 --> 00:28:26,020
>> * tがあるのでTのアドレスにアクセスしてください。

526
00:28:26,020 --> 00:28:27,580
しかし、我々はループの内側です。

527
00:28:27,580 --> 00:28:32,150
そして、私は、何の値をインクリメントしています
もちろん、各反復で？

528
00:28:32,150 --> 00:28:32,690
私。

529
00:28:32,690 --> 00:28:34,590
>> しかし、機会があり
ここで、右？

530
00:28:34,590 --> 00:28:37,870
それはなってきたように、これは感じているにもかかわらず
もう少し洗練された

531
00:28:37,870 --> 00:28:40,730
角括弧表記より
我々はいくつかの時間を使用してきました - 

532
00:28:40,730 --> 00:28:43,840
私はそこに私の時間の変更を取り消しさせて - 

533
00:28:43,840 --> 00:28:48,870
これは今少しを取得しているにもかかわらず
* Tであれば、基本的な考え方、手の込んだ

534
00:28:48,870 --> 00:28:53,630
ここで意味すると* tはただです
T内のアドレスにアクセスしてください。

535
00:28:53,630 --> 00:28:54,990
>> しかし、Tのアドレス何でしたか？

536
00:28:54,990 --> 00:28:56,850
我々が使用し続ける数？

537
00:28:56,850 --> 00:29:00,540
Ox456と同様に、そのバックを持ってみましょう
単に議論のために。

538
00:29:00,540 --> 00:29:05,380
まあ、私は内の電子を取得したい場合
Tの文字列は、私はちょうど、に行きたい

539
00:29:05,380 --> 00:29:06,460
本質的には、456。

540
00:29:06,460 --> 00:29:09,230
>> というか、457。

541
00:29:09,230 --> 00:29:10,590
私はちょうど1を追加する必要があります。

542
00:29:10,590 --> 00:29:11,790
しかし、私は右、それを行うことができますか？

543
00:29:11,790 --> 00:29:14,680
tは、私が図面を保つにもかかわらずので
矢印として、それは今では、それだけだ

544
00:29:14,680 --> 00:29:16,570
番号、Ox456。

545
00:29:16,570 --> 00:29:21,400
そして、私はそれに1を追加した場合、またはそれ以上
一般的に、私は私にできることに私を追加した場合

546
00:29:21,400 --> 00:29:24,350
私が欲しい場所を正確に、実際に取得します。

547
00:29:24,350 --> 00:29:26,260
だから私は実際にこれを行う場合 - 

548
00:29:26,260 --> 00:29:28,970
そしてこれは今と呼ばれるものです。
ポインタ演算 - 

549
00:29:28,970 --> 00:29:30,375
私は、この行を削除することができます。

550
00:29:30,375 --> 00:29:33,550
率直に言って、どちらが、私はより明確と思う
読みもう少しユーザーフレンドリー。

551
00:29:33,550 --> 00:29:35,970
しかし、これは劣ら正しいではありません。

552
00:29:35,970 --> 00:29:38,570
>> このコード行は、今使用している
ポインタ演算。

553
00:29:38,570 --> 00:29:40,920
これは、に行くと言っています
次のアドレス - 

554
00:29:40,920 --> 00:29:44,670
Tの開始が何であれ、その
当初はTプラス私、です

555
00:29:44,670 --> 00:29:45,730
素晴らしいですが、これは0である。

556
00:29:45,730 --> 00:29:49,280
それは、Tの始まりを意味するので、
プラス1、プラス2、プラス3などが挙げられる。

557
00:29:49,280 --> 00:29:51,030
sのと同じ契約。

558
00:29:51,030 --> 00:29:52,750
>> このためだから糖衣構文。

559
00:29:52,750 --> 00:29:55,900
本当に何が起こっているのかしかし、理解
ボンネットの下に、私は主張するだろう

560
00:29:55,900 --> 00:29:57,410
それ自体との実際に有用です。

561
00:29:57,410 --> 00:30:00,620
それが今ではそこにはないことを意味しているので
起こってはるか魔法

562
00:30:00,620 --> 00:30:01,620
ボンネットの下に。

563
00:30:01,620 --> 00:30:03,920
多くのことをそこに行くされていません
私たちはあなたのために皮をバックアップできる層。

564
00:30:03,920 --> 00:30:04,810
これはc。

565
00:30:04,810 --> 00:30:06,410
そして、これはプログラミングされています。

566
00:30:06,410 --> 00:30:08,002
質問本当に良い。

567
00:30:08,002 --> 00:30:11,570
>> すべての権利なので、これはそのバグだった
私は以前に言及されたプログラム。

568
00:30:11,570 --> 00:30:12,650
スワップが欠陥だった。

569
00:30:12,650 --> 00:30:14,070
場合は、動作するように思えました。

570
00:30:14,070 --> 00:30:17,390
ただミルクで好きなことを思い出してください
オレンジジュース - 私が始め

571
00:30:17,390 --> 00:30:18,660
今日のデモを飲む。

572
00:30:18,660 --> 00:30:22,220
だからオレンジジュースと同様と
牛乳は、我々は使用する必要がなかった

573
00:30:22,220 --> 00:30:26,200
保持する一時変数、TMP、
一時的に、我々はそれからできること

574
00:30:26,200 --> 00:30:28,820
Bを更新し、その値を変更して。

575
00:30:28,820 --> 00:30:32,870
>> しかし、この機能は、我々が言った、またはこの
この関数があったているプログラム

576
00:30:32,870 --> 00:30:35,670
書かれたことは間違っており、欠陥だった、なぜですか？

577
00:30:35,670 --> 00:30:38,870

578
00:30:38,870 --> 00:30:39,090
はい？

579
00:30:39,090 --> 00:30:42,471
>> 読者：[聞こえない]。

580
00:30:42,471 --> 00:30:44,940
>> SPEAKER 1：その通り、時
あなたは、スワップを呼ぶ - 

581
00:30:44,940 --> 00:30:47,820
より一般的には、ときに
ほとんどの任意の関数を呼び出す - 

582
00:30:47,820 --> 00:30:51,210
その関数への引数は、ある場合に
原始的な、いわば、intと文字

583
00:30:51,210 --> 00:30:56,740
とダブル、山車、物事なし
星、あなたはのコピーを渡している

584
00:30:56,740 --> 00:30:57,540
引数。

585
00:30:57,540 --> 00:31:01,580
xが1であったとyが2であったのであれば、起こっている
1であることが、bは2になるだろう。

586
00:31:01,580 --> 00:31:05,250
しかし、彼らは別のチャンクことになるだろう
のビットは、異なるチャンクの

587
00:31:05,250 --> 00:31:07,540
保存することが起こるメモリ
同じ値。

588
00:31:07,540 --> 00:31:12,160
>> だから、このコードは超完璧です
aとbを交換で。

589
00:31:12,160 --> 00:31:13,850
スワッピングでは良いことだん - 

590
00:31:13,850 --> 00:31:15,290
先週の例では - 

591
00:31:15,290 --> 00:31:16,390
xおよびy。

592
00:31:16,390 --> 00:31:18,780
再び、彼らはだから
間違った範囲である。

593
00:31:18,780 --> 00:31:21,310
>> さて、我々はこれを修正する方法についてでしたか？

594
00:31:21,310 --> 00:31:23,140
我々は、関数をしなければならなかった
少し醜いに見える。

595
00:31:23,140 --> 00:31:25,250
しかし、再び、何を考える
これは単なる意味。

596
00:31:25,250 --> 00:31:27,840

597
00:31:27,840 --> 00:31:31,500
>> そして、実際に、一貫性を保つために、私を聞かせて
それはと同じですので、一つのことを変更する

598
00:31:31,500 --> 00:31:33,200
先ほどやった。

599
00:31:33,200 --> 00:31:35,690
私が先週述べたように、それがない
それがどこに行くかは問題で。

600
00:31:35,690 --> 00:31:38,120
実際には、一般的には入れるでしょう
変数名の横にある星。

601
00:31:38,120 --> 00:31:40,750
しかし、私はそれが少し楽になると思います
隣に*を検討する

602
00:31:40,750 --> 00:31:44,910
それはポインタの意味として、データ·タイプ
この場合はintへ。

603
00:31:44,910 --> 00:31:46,270
>> だから私はここで何をやっている？

604
00:31:46,270 --> 00:31:49,590
私は私にint型を与えていない言っている
別のint型に続いて、

605
00:31:49,590 --> 00:31:50,810
それらのaとbを呼び出す。

606
00:31:50,810 --> 00:31:52,460
私にint型のアドレスを与える。

607
00:31:52,460 --> 00:31:53,960
私に別のint型のアドレスを与える。

608
00:31:53,960 --> 00:31:56,330
aとbそれらのアドレスを呼び出します。

609
00:31:56,330 --> 00:32:00,860
>> そして*表記を使用してダウン
以下に、それらのアドレスのそれぞれに行く

610
00:32:00,860 --> 00:32:05,290
どちらを取得するために、必要に応じて
またはその値を設定します。

611
00:32:05,290 --> 00:32:07,400
しかし、ここでは例外があります。

612
00:32:07,400 --> 00:32:11,130
なぜ私はtmpに隣に*を持っていないのですか？

613
00:32:11,130 --> 00:32:15,070
なぜ私は、例えば、これをしない？

614
00:32:15,070 --> 00:32:19,370
私はすべてに行く必要がありますようにそれは感じている
アウトと全部を修正します。

615
00:32:19,370 --> 00:32:19,752
うん？

616
00:32:19,752 --> 00:32:21,002
>> 読者：[聞こえない]。

617
00:32:21,002 --> 00:32:23,280

618
00:32:23,280 --> 00:32:25,480
>> SPEAKER 1：私は宣言していない
文字列としてtmpに。

619
00:32:25,480 --> 00:32:28,830

620
00:32:28,830 --> 00:32:34,950
従ってこれは、この場合には、宣言する
tmpがint型のアドレスになるように。

621
00:32:34,950 --> 00:32:37,380
しかし、それは、私が欲しいものはかなりありません
いくつかの理由のために。

622
00:32:37,380 --> 00:32:38,616
>> 聴衆：あなたはそれらを交換する必要はありません。

623
00:32:38,616 --> 00:32:41,800
>> SPEAKER 1：その通り、私は交換したくない
tmpを使って何。 tmpがただです

624
00:32:41,800 --> 00:32:42,790
週1のもの。

625
00:32:42,790 --> 00:32:45,150
私が欲しいのは変数です
いくつかの数字を格納する。

626
00:32:45,150 --> 00:32:47,330
私もアドレスを気にしない
現時点では。

627
00:32:47,330 --> 00:32:50,530
>> 私はちょうど32ビットを必要とするか、または
そうint型を格納する。

628
00:32:50,530 --> 00:32:56,690
そして、私はそれらの32ビットに入れたい
どんないわば、ではありませんが、

629
00:32:56,690 --> 00:33:01,260
ただより正確に、でたものです。

630
00:33:01,260 --> 00:33:06,420
アドレスである場合、*を意味しますので、
そこに行くと値1を取得します。

631
00:33:06,420 --> 00:33:10,560
たとえば、先週の例で
または、bの場合には、2の値を取得する。

632
00:33:10,560 --> 00:33:11,750
>> だから何が本当に起こっているの？

633
00:33:11,750 --> 00:33:15,070
私は意志ここで絵を描いてみましょう
今日だけの一部を離れていじめる。

634
00:33:15,070 --> 00:33:18,580
しかし、これは表示されていきます
かなりの時間のために。

635
00:33:18,580 --> 00:33:22,430
>> これは、私が主張し、何をお使いのコンピュータのある
メモリは、あなたが実行したときのように見える

636
00:33:22,430 --> 00:33:24,060
プログラムは、任意のプログラム。

637
00:33:24,060 --> 00:33:28,340
あなたは非常に上部にプログラムを実行すると
コンピュータのRAMの - そう考える

638
00:33:28,340 --> 00:33:33,530
あなたのように、本当にこの長方形、
コンピュータのRAMやメモリ、全101

639
00:33:33,530 --> 00:33:36,920
それの億バイト、すべての20億
バイト、それのすべて2ギガバイト、

640
00:33:36,920 --> 00:33:39,910
あなたが持っている量があるものは何でも、
それは長方形として描画してみましょう。

641
00:33:39,910 --> 00:33:43,260
そして、私はあなたがプログラムを実行するときと主張
Microsoft WordやChromeのような

642
00:33:43,260 --> 00:33:49,220
またはそのような何か、そのビット
MicrosoftまたはそのGoogleが書いた - 

643
00:33:49,220 --> 00:33:50,910
これらのプログラムの場合で - 

644
00:33:50,910 --> 00:33:54,490
コンピュータのメモリにロードされ
それらは、より実行することができる

645
00:33:54,490 --> 00:33:57,520
迅速かつ供給CPUに、どの
コンピュータの頭脳である。

646
00:33:57,520 --> 00:34:00,940
>> とTAMに彼らは非常に格納されている
あなたのプログラムの先頭には、いわば。

647
00:34:00,940 --> 00:34:03,300
つまり、これはチャンクである場合
メモリには、ダブルクリックしたとき

648
00:34:03,300 --> 00:34:05,740
Microsoft Wordの、ビットが来る
ハードドライブをオフにします。

649
00:34:05,740 --> 00:34:06,680
これらはRAMにロードされ。

650
00:34:06,680 --> 00:34:10,330
そして、我々は非常に上部にそれらを突き出すよ
この長方形の概念的。

651
00:34:10,330 --> 00:34:13,010
>> さて、あなたのメモリの残りの部分はある
さまざまなことに使用されます。

652
00:34:13,010 --> 00:34:16,460
一番上には、初期化を参照してください
データとデータの初期化を解除。

653
00:34:16,460 --> 00:34:20,500
これはと共に、大部分は、関係している
定数やグローバル変数

654
00:34:20,500 --> 00:34:21,340
それは値を有する。

655
00:34:21,340 --> 00:34:22,980
それらの別の時間ではなく、もっと。

656
00:34:22,980 --> 00:34:25,150
>> その後は、ヒープを持っている
我々はに戻ってくるでしょう。

657
00:34:25,150 --> 00:34:28,420
しかし、一番下にあるの一部である
特に今は密接。

658
00:34:28,420 --> 00:34:30,210
それは、いわゆるスタックだ。

659
00:34:30,210 --> 00:34:33,850
だからここでほとんどすべてのDホールで好き
キャンパスは、それらのトレイを持っている

660
00:34:33,850 --> 00:34:37,210
わずかに互いの上にスタック
あなたは、食品やその他もろもろを置くことができます。

661
00:34:37,210 --> 00:34:40,139
コンピュータシステム内のスタック
非常によく似ています。

662
00:34:40,139 --> 00:34:42,679
我々が使用するように、トレイのに対し除く
食堂は、もちろん、意味している

663
00:34:42,679 --> 00:34:45,710
物事をトレイを運ぶために
またはフレーム - 

664
00:34:45,710 --> 00:34:49,469
我々は彼らを呼ぶことにしますように - コンピュータの中
メモリが保持するために使用され

665
00:34:49,469 --> 00:34:51,610
変数と値。

666
00:34:51,610 --> 00:34:53,929
>> だから、本当に何が起こっ
ボンネットの下に？

667
00:34:53,929 --> 00:34:55,820
まあ、私は裏返してみましょう
ここで画面に。

668
00:34:55,820 --> 00:34:58,370
とにだけ焦点を当ててみましょう
瞬間のために底部。

669
00:34:58,370 --> 00:35:02,770
これは私の一番下の部分である場合
コンピュータのメモリは、それが判明したとき、私

670
00:35:02,770 --> 00:35:05,350
関数main呼び出し - 
それは、率直に言って、どうなる

671
00:35:05,350 --> 00:35:06,950
自動的に私のために - 

672
00:35:06,950 --> 00:35:10,510
私は、メモリのチャンクを取得
いわば私のRAMの一番下。

673
00:35:10,510 --> 00:35:13,390
どこだメインとこれは
ローカル変数は行く。

674
00:35:13,390 --> 00:35:16,770
どこのargcとargvは多分それはだ
移動して、任意の変数I

675
00:35:16,770 --> 00:35:18,170
メインの内側を宣言します。

676
00:35:18,170 --> 00:35:20,260
彼らは、底に終わる
私のコンピュータのRAMの。

677
00:35:20,260 --> 00:35:25,040
>> 今ではメインの呼び出し機能を仮定
スワップのような、それは先週やったような？

678
00:35:25,040 --> 00:35:30,620
さて、私たちは本質的に、新しいトレイを置く
メモリの私の塊の上に新しいフレーム、。

679
00:35:30,620 --> 00:35:34,160
そして、私はこのように記述するつもりです
スワップ機能に属する。

680
00:35:34,160 --> 00:35:35,770
>> 今、スワップの内側は何ですか？

681
00:35:35,770 --> 00:35:39,240
さて、先週のプログラムに基づいており、
先ほどからの抜粋を見て1、

682
00:35:39,240 --> 00:35:46,590
スワップの枠の内側、またはスワップのオン
トレイ、どの変数がありますか？

683
00:35:46,590 --> 00:35:47,970
さて、aとb。

684
00:35:47,970 --> 00:35:51,850
それらは、その地方の引数であったため、
プラス三、TMP。

685
00:35:51,850 --> 00:35:54,470
だから本当に、私はこれを描くことができ
もう少しきれいに。

686
00:35:54,470 --> 00:35:56,680
私が先に行くとラベルを取り消しましょう​​。

687
00:35:56,680 --> 00:35:58,520
そして、私はあなたが何を知っていることを主張させて？

688
00:35:58,520 --> 00:36:00,560
>> おそらくここで終わるだろう。

689
00:36:00,560 --> 00:36:02,160
Bはここで終わるだろう。

690
00:36:02,160 --> 00:36:03,810
とtmpがここで終わるとしている。

691
00:36:03,810 --> 00:36:05,160
さて、順序はかもしれない
多少異なる場合が。

692
00:36:05,160 --> 00:36:06,840
しかし、概念的には、これはアイデアです。

693
00:36:06,840 --> 00:36:11,490
>> そして、ちょうど集合的に、これは何ですか
私たちは、スワップの枠を呼び出す、またはよ

694
00:36:11,490 --> 00:36:12,136
ダイニングホールトレイ。

695
00:36:12,136 --> 00:36:13,150
メインで、同じ取引。

696
00:36:13,150 --> 00:36:14,040
しかし、私はそれを再描画しません。

697
00:36:14,040 --> 00:36:17,810
しかし、それはどこのargcとargvと任意のだ
xとyのように、そのローカル変数の

698
00:36:17,810 --> 00:36:18,940
同様かもしれない。

699
00:36:18,940 --> 00:36:22,170
>> だから今は本当に何が起こっているかを検討
あなたはスワップを呼び出すとき。

700
00:36:22,170 --> 00:36:26,370
次のようなコードを実行して、スワップを呼び出すとき
これは、中に渡している

701
00:36:26,370 --> 00:36:30,670
バギーバージョン、aとb
xとyのコピーである。

702
00:36:30,670 --> 00:36:34,300
私は今、これを描くんであれば
画面上で - 

703
00:36:34,300 --> 00:36:36,700
これで良くなるようになった - 

704
00:36:36,700 --> 00:36:40,850
私は自分自身に言っていた話はそう
、このバギーバージョンにあったときに、私たち

705
00:36:40,850 --> 00:36:46,130
文字通り、aとbを渡すスワップ呼び出す
整数として、何が本当に起きているのでしょうか？

706
00:36:46,130 --> 00:36:48,250
>> まあ、これは本当に起こっているのです。

707
00:36:48,250 --> 00:36:52,850
私が先に行くとだけアンドゥう
ここにいくつかのスペースをクリアします。

708
00:36:52,850 --> 00:36:54,720
だから、これは私のコンピュータのメモリである。

709
00:36:54,720 --> 00:36:57,510
>> 私が持っているのであれば、例えば - 

710
00:36:57,510 --> 00:36:58,910
実際のは、このようにそれをやらせる - 

711
00:36:58,910 --> 00:37:02,690
私は、これは保管、Xであることを主張する場合
ちょうど先週のような値1。

712
00:37:02,690 --> 00:37:05,930
そして、これは値を格納する、yと
ちょうど先週のように2。

713
00:37:05,930 --> 00:37:11,370
そして、これは、私がスワップを呼び出すときに、メインである
それによって、自分自身へのアクセスを与え、

714
00:37:11,370 --> 00:37:15,150
bおよびtmpが、私はそれを主張するつもりだ
これは、これは1である。

715
00:37:15,150 --> 00:37:16,080
>> これは、bは。

716
00:37:16,080 --> 00:37:17,010
これは2である。

717
00:37:17,010 --> 00:37:18,370
これはTMPと呼ばれています。

718
00:37:18,370 --> 00:37:23,360
>> そして、最初に、それはいくつかのゴミの値を有する
私は実際にそれに格納されるまで、

719
00:37:23,360 --> 00:37:24,450
これは、1です。

720
00:37:24,450 --> 00:37:28,320
それから私は先に行くと変更
何のことですか？

721
00:37:28,320 --> 00:37:29,720
Bの値。

722
00:37:29,720 --> 00:37:31,980
>> そして今、私はここで2つを持っている。

723
00:37:31,980 --> 00:37:34,050
そして、我々は、bはTMPを得ると述べた。

724
00:37:34,050 --> 00:37:37,670
繰り返しますが、単に健全性チェックとして、第三
ここでコードの行は、単にこれです

725
00:37:37,670 --> 00:37:39,440
1、bはTMPを取得します。

726
00:37:39,440 --> 00:37:41,730
>> そして最後に、私は何をすればよいですか？

727
00:37:41,730 --> 00:37:46,800
私が先に行くとどんなことをBに変更
TMPの値が1である、である。

728
00:37:46,800 --> 00:37:48,390
私は再びtmpには触れないでください。

729
00:37:48,390 --> 00:37:54,100
>> しかし、今、問題は、すぐに交換のようになります。
を返し、それは手渡しではないので

730
00:37:54,100 --> 00:37:57,540
いくつかの値をバックアップし、ノーリターンではありません
文は、その中に明示的に。

731
00:37:57,540 --> 00:37:59,080
実際に何が起きているのでしょうか？

732
00:37:59,080 --> 00:38:03,480
まあ、基本的にすべてこのメモリ - 

733
00:38:03,480 --> 00:38:07,410
[OK]を、明らかに消しゴムは好き
同時に複数の指 - 

734
00:38:07,410 --> 00:38:08,180
ただ消える。

735
00:38:08,180 --> 00:38:10,070
>> 今、現実にはそうではありません
どこでも行く。

736
00:38:10,070 --> 00:38:11,810
しかし、あなたはそれについて考えることができます
今疑問符として。

737
00:38:11,810 --> 00:38:14,040
それはもはやいないので
実際に使用中です。

738
00:38:14,040 --> 00:38:17,470
そして、何もそれらの値で行われていません。

739
00:38:17,470 --> 00:38:21,920
>> だから緑のバージョンの場合
このコードは、代わりに何がされている

740
00:38:21,920 --> 00:38:24,640
スワップに渡される？

741
00:38:24,640 --> 00:38:25,770
だから、対処しています。

742
00:38:25,770 --> 00:38:28,520
だから、xのアドレスと
yのアドレス。

743
00:38:28,520 --> 00:38:35,790
我々は、もしそうなら、この物語最後の再伝える
時間、私は実際に、再びスワップを描く

744
00:38:35,790 --> 00:38:44,620
しかしポインタで、これは、このている
Bであること、そしてこのことtmpの、何ですか

745
00:38:44,620 --> 00:38:49,080
実際にこの緑に格納
私が渡している私のコードのバージョン

746
00:38:49,080 --> 00:38:52,110
アドレスに？

747
00:38:52,110 --> 00:38:53,780
>> これは、Xへのポインタになるだろう。

748
00:38:53,780 --> 00:38:54,890
だから私は、矢印を描くことができます。

749
00:38:54,890 --> 00:38:57,310
しかしみましょう、同じ任意を使う
以前のように例。

750
00:38:57,310 --> 00:39:01,220
Let 'sは、これがあると言う
Ox123のようなもの。

751
00:39:01,220 --> 00:39:04,970
そして、これはOx127であることを行っているので、
それはだから、それは4バイト離れてい

752
00:39:04,970 --> 00:39:07,370
int型なので、Ox127。

753
00:39:07,370 --> 00:39:09,080
>> そして再び、私はいくつかの自由を取っている
番号を持つ。

754
00:39:09,080 --> 00:39:11,430
彼らは場合よりもはるかに小さいです
実際には別の順序であると。

755
00:39:11,430 --> 00:39:14,350
しかし、それはどのように絵だ
今とは異なります。

756
00:39:14,350 --> 00:39:19,060
>> しかし、私は、この緑色のコードを使用するとき
と私はint型tmpが*入手できますか。

757
00:39:19,060 --> 00:39:25,010
は、次の操作を行い取る*手段
でのアドレスとそれに行く、

758
00:39:25,010 --> 00:39:26,190
これは、1です。

759
00:39:26,190 --> 00:39:28,480
そして、それは私はその後tmpに入れたものだ。

760
00:39:28,480 --> 00:39:32,480
一方、コードの次の行に
ここで、* Bを取得し、それが何を意味するのでしょうか？

761
00:39:32,480 --> 00:39:36,910
>> さて、*ので、ここに行くを取得* B、
これは、そこに行くことを意味します。

762
00:39:36,910 --> 00:39:39,310
そして、そこに価値を置くことを意味します。

763
00:39:39,310 --> 00:39:43,670
最後に、コードの最後の行
単に* bはTMPを得ると述べた。

764
00:39:43,670 --> 00:39:48,900
>> だからbがそこに行くとそれを上書きすると言う
起こっている、この場合には、TMP

765
00:39:48,900 --> 00:39:51,520
、再度、1とする。

766
00:39:51,520 --> 00:39:54,920
そして、これが理由の緑バージョンです
我々のコードは、赤のに対し、働く

767
00:39:54,920 --> 00:39:56,010
バージョンはことはなかった。

768
00:39:56,010 --> 00:39:59,020
どのようにダウンして、それをすべてちょうど沸騰
メモリが管理され、それはどこにされて

769
00:39:59,020 --> 00:40:02,580
実際に配置され
コンピュータのRAM。

770
00:40:02,580 --> 00:40:07,270
そして今のところ、それは物事の一つだ
スタックが使用されていること。

771
00:40:07,270 --> 00:40:09,225
>> レイアウトに関する質問？

772
00:40:09,225 --> 00:40:10,380
ポインタか？

773
00:40:10,380 --> 00:40:11,630
またはスワップに？

774
00:40:11,630 --> 00:40:13,740

775
00:40:13,740 --> 00:40:17,043
>> すべての権利なので、malloc関数、リコール、
このような何かをした。

776
00:40:17,043 --> 00:40:18,260
これは超簡単な例でした。

777
00:40:18,260 --> 00:40:20,550
そして、これは1つだったBinkyの
とはいえ、非常に、私たちを導入

778
00:40:20,550 --> 00:40:21,870
すぐに、クラスの終わりに。

779
00:40:21,870 --> 00:40:24,480
くそ、そこに我々は再び行く。

780
00:40:24,480 --> 00:40:28,780
>> だから、これは例であったことを思い出している
Binkyのはいえ、私たちを導入

781
00:40:28,780 --> 00:40:30,360
やや素早くクラスの終わりに。

782
00:40:30,360 --> 00:40:33,640
そして、ここで私たちは本当に、mallocを使用
二度目の。

783
00:40:33,640 --> 00:40:37,330
初めてなので、我々はそれを使用
十分なRAMを割り当て、十分なRAMを作成する

784
00:40:37,330 --> 00:40:38,340
文字列を格納する。

785
00:40:38,340 --> 00:40:40,250
>> 今回はBinkyのそれはシンプルに保つ。

786
00:40:40,250 --> 00:40:42,465
だからそれだけで保存するためだ
int型、明らかに。

787
00:40:42,465 --> 00:40:43,510
そして、それは完全に大丈夫です。

788
00:40:43,510 --> 00:40:46,560
それはに、率直に、少し奇妙なことだ
1 int型を割り当てるためにmalloc関数を使用しています。

789
00:40:46,560 --> 00:40:50,650
しかし、ニックのクレイメーションのポイントだった
本当にただ何の話をする

790
00:40:50,650 --> 00:40:53,830
起こるとき、または発生しません
あなたは、メモリを虐待。

791
00:40:53,830 --> 00:40:56,520
>> したがって、この場合には、このプログラム
いくつかのことをやった。

792
00:40:56,520 --> 00:41:01,580
ここで最初のケースでは、それを宣言
intにXと呼ばれるポインタ。

793
00:41:01,580 --> 00:41:04,480
その後、ポインタを宣言しています
intにYと呼ばれる。

794
00:41:04,480 --> 00:41:06,150
その後、Xに何を格納？

795
00:41:06,150 --> 00:41:07,110
今、他の誰か。

796
00:41:07,110 --> 00:41:09,685
に係るXに格納されるもの
このプログラムの3行目？

797
00:41:09,685 --> 00:41:12,380
>> 読者：[聞こえない]。

798
00:41:12,380 --> 00:41:14,130
>> SPEAKER 1：まあ、かなり
言うあたりのバイト、。

799
00:41:14,130 --> 00:41:16,760
今より正確に。

800
00:41:16,760 --> 00:41:18,325
Xには何が格納される？

801
00:41:18,325 --> 00:41:21,000

802
00:41:21,000 --> 00:41:22,060
アドレスは、私はそれを聞いたと思います。

803
00:41:22,060 --> 00:41:23,570
>> だから、malloc関数は何を返すのでしょうか？

804
00:41:23,570 --> 00:41:26,030
mallocの行動を割り当て
メモリのチャンク。

805
00:41:26,030 --> 00:41:27,850
しかし、どのようにそれはあなたがそれにアクセスできるようにしますか？

806
00:41:27,850 --> 00:41:29,460
それは何を返す？

807
00:41:29,460 --> 00:41:32,000
最初のバイトのアドレス
メモリの塊である。

808
00:41:32,000 --> 00:41:33,020
>> さて、これは超簡単です。

809
00:41:33,020 --> 00:41:35,380
それだけを意味し、1バイト、だ
我々は戻って取得しているアドレスです

810
00:41:35,380 --> 00:41:37,300
全部のアドレス。

811
00:41:37,300 --> 00:41:42,070
それではXに保存されている、アドレスです
メモリのチャンクの。

812
00:41:42,070 --> 00:41:43,400
その間、何が次に起こる？

813
00:41:43,400 --> 00:41:45,890
だから実際には、のは先に行こうと
これを本当の高速を描く。

814
00:41:45,890 --> 00:41:52,490
>> だから私たちは、ここで画面の所へ行く場合
我々はこれをプレイするint型* xとint型* Y

815
00:41:52,490 --> 00:41:53,740
私のために何をするつもりか？

816
00:41:53,740 --> 00:41:58,280
私はそれだけで行うために起こっていることを主張する
このような何か、それXと呼び、

817
00:41:58,280 --> 00:42:00,010
これとはyを呼ぶ。

818
00:42:00,010 --> 00:42:03,110
一方、コードの3行目です
int型のサイズを割り当てるつもり、

819
00:42:03,110 --> 00:42:06,160
申し訳ありませんが、私が言ったら - それはであることを起こる
私は1つのint型を意味する前に、1  - 

820
00:42:06,160 --> 00:42:08,280
典型的なコンピュータ上の4バイト。

821
00:42:08,280 --> 00:42:09,720
少なくともCS50アプライアンスと。

822
00:42:09,720 --> 00:42:11,490
>> だから、これは割り当てるために起こっている
それは、誰が知っている？

823
00:42:11,490 --> 00:42:12,800
どこかここに。

824
00:42:12,800 --> 00:42:15,780
これは一部に格納されている
アドレス牛、知っている？

825
00:42:15,780 --> 00:42:18,330
しかし、何が返されるために起こっている
そのアドレスです。

826
00:42:18,330 --> 00:42:22,270
しかし、我々は絵で、これを描くよ
としてそのようなただ矢印。

827
00:42:22,270 --> 00:42:25,430
>> 今、次の行の*×42を取得します。

828
00:42:25,430 --> 00:42:29,400
* xが普通の言葉で何を意味するのでしょうか？

829
00:42:29,400 --> 00:42:30,040
ただ、そこに行く。

830
00:42:30,040 --> 00:42:30,960
そのアドレスに移動します。

831
00:42:30,960 --> 00:42:35,900
換言すれば、フォロー
矢印とそこに42を置く。

832
00:42:35,900 --> 00:42:38,140
しかし、その後、何か悪いことが起こった
Binkyのに対して、右？

833
00:42:38,140 --> 00:42:43,950
>> * Yが取得する、ここでそのライン5を思い出す
13、確かに不吉な数、

834
00:42:43,950 --> 00:42:44,760
私たちのために何をした？

835
00:42:44,760 --> 00:42:47,320
まあ、* yはそこに行くことを意味します。

836
00:42:47,320 --> 00:42:50,460
まあ、これは与えられていない
まだ値、右？

837
00:42:50,460 --> 00:42:54,090
コー​​ドは、yがあることはありません
何に初期化。

838
00:42:54,090 --> 00:42:56,120
我々はX初期化されていた
アドレスへ。

839
00:42:56,120 --> 00:42:57,640
しかし、yが上部まで宣言されました。

840
00:42:57,640 --> 00:43:00,250
しかし、その後、セミコロン、値なし
実際にそれに入れた。

841
00:43:00,250 --> 00:43:02,330
だから、これを呼び出すために公正である
ゴミ値。

842
00:43:02,330 --> 00:43:03,430
誰が何を知っている？

843
00:43:03,430 --> 00:43:07,160
これは、使用されたビットの残党だ
のコードのいくつかの前の行で

844
00:43:07,160 --> 00:43:08,300
私のプログラム。

845
00:43:08,300 --> 00:43:13,250
>> 私はそこに行くと言うのであれば、これは、のようなである
私は、この矢印は見当がつかない

846
00:43:13,250 --> 00:43:14,490
終わるつもり。

847
00:43:14,490 --> 00:43:17,720
ときに、通常、そして、それはだ
セグメンテーションフォールトを取得します。

848
00:43:17,720 --> 00:43:22,430
あなたが誤って逆参照した場合、そうする
話すかどうかのアドレスに行く

849
00:43:22,430 --> 00:43:25,400
実際に合法的なアドレス、
悪いことが起こる。

850
00:43:25,400 --> 00:43:27,550
>> そして、それは起こったことがまさにそれだ
Binkyのだと思います。

851
00:43:27,550 --> 00:43:31,060
だから、ニックだったことその話思い出す
ここで伝えることは同じ考えだったかのように

852
00:43:31,060 --> 00:43:34,050
私の錯覚で描かれてきた
そこにボード上のチョーク。

853
00:43:34,050 --> 00:43:35,960
XとYは、宣言されています。

854
00:43:35,960 --> 00:43:39,690
>> その後、我々はサイズを割り当て
int型とXでそれを保存。

855
00:43:39,690 --> 00:43:42,130
その後、我々が行った次の行* X。

856
00:43:42,130 --> 00:43:46,070
これはニックの魔法の杖だった
間接参照の。

857
00:43:46,070 --> 00:43:49,780
すなわち、メモリ42に入れ
xで指摘した。

858
00:43:49,780 --> 00:43:51,600
>> しかし、これはあるもの
恐ろしく間違っていた。

859
00:43:51,600 --> 00:43:51,820
右？

860
00:43:51,820 --> 00:43:53,550
我々はデリファレンスyに試してみました。

861
00:43:53,550 --> 00:43:55,620
しかし、yは右、いくつかの偽の値を持っていた？

862
00:43:55,620 --> 00:43:57,720
>> 左下でその矢印
コー​​ナーではない

863
00:43:57,720 --> 00:43:58,950
実際には何を指している。

864
00:43:58,950 --> 00:44:01,520
それは何をやって私のようなものだ
ボード上でここにしました。

865
00:44:01,520 --> 00:44:05,900
だから、悪いことが起こる、セグメンテーション
この場合の故障、またはBinkyの障害、。

866
00:44:05,900 --> 00:44:10,800
>> しかし、我々はその後、xを実行していることを修正した場合
yは取得する方法ストーリー変化していますか？

867
00:44:10,800 --> 00:44:15,760
まあ、私はXを行う場合の、yを取得します
と言うように効果的に同じ

868
00:44:15,760 --> 00:44:19,235
これが何であれ、牛か
、ここで同じことを行っている

869
00:44:19,235 --> 00:44:20,080
牛何か。

870
00:44:20,080 --> 00:44:22,970
または絵で我々は、矢印を描画します。

871
00:44:22,970 --> 00:44:25,530
>> だからここBinkyのとオンボード、
の次の行で

872
00:44:25,530 --> 00:44:28,350
コー​​ド、* yはそこに行くことを意味します。

873
00:44:28,350 --> 00:44:29,400
そこどこですか？

874
00:44:29,400 --> 00:44:30,820
それはこっちを意味します。

875
00:44:30,820 --> 00:44:36,050
>> そして、我々は13になることを更新するとき
それだけで行くと関与

876
00:44:36,050 --> 00:44:39,470
今ここに13を書く。

877
00:44:39,470 --> 00:44:44,130
ので、おそらく完全ではない
一見単純明快。

878
00:44:44,130 --> 00:44:47,740
しかし、要約すると、同じ専門用語を使用するように
Binkyのがここで使用していたので、

879
00:44:47,740 --> 00:44:50,485
最初の二つは、ポインタを割り当てる
xとyはなく、指示先。

880
00:44:50,485 --> 00:44:54,750
と指示先ではありません
一般の用語を使用していました。

881
00:44:54,750 --> 00:44:56,120
しかし、ポインタは絶対です。

882
00:44:56,120 --> 00:44:59,200
しかし、それは指摘されているものだ
Binkyのの命名でで。

883
00:44:59,200 --> 00:45:01,660
>> もちろん、この次の行、
int型ポインタの指示先を割り当てます。

884
00:45:01,660 --> 00:45:04,840
だからメモリの塊 - 私は上のように描い
右手そこ側 - とセット

885
00:45:04,840 --> 00:45:06,470
それを指すように等しいX。

886
00:45:06,470 --> 00:45:11,350
この間接参照xは42に格納する
それを指しているメモリ。

887
00:45:11,350 --> 00:45:13,380
そしてこれは、もちろん、
悪いものだった。

888
00:45:13,380 --> 00:45:15,600
yが指していませんでしたので、
まだ何で。

889
00:45:15,600 --> 00:45:16,530
これは、それを修正します。

890
00:45:16,530 --> 00:45:18,240
だから、これはまだバグのプログラムです。

891
00:45:18,240 --> 00:45:21,580
我々は吹き抜けるいるという理由だけで
コー​​ド行ずつと言って、まあ、

892
00:45:21,580 --> 00:45:22,690
それはそこにクラッシュすることができます。

893
00:45:22,690 --> 00:45:23,420
それは悪いことだ。

894
00:45:23,420 --> 00:45:26,790
オッズは、プログラムだけに起こっているのです
そのラインで完全に中止。

895
00:45:26,790 --> 00:45:30,550
削除した場合でも、クラッシュ
ラインと最後の二つと交換

896
00:45:30,550 --> 00:45:32,470
割り当てるそこ行 - 

897
00:45:32,470 --> 00:45:35,310
Y  - ポインタの割り当てを使用して
点tのようにXを指すように。

898
00:45:35,310 --> 00:45:39,280
そしてあなたは間接参照
非常に安全な方法でY。

899
00:45:39,280 --> 00:45:41,520
>> だからここで、これは私たちを残していない？

900
00:45:41,520 --> 00:45:45,350
さて、フードの下のことを判明
CS50ライブラリに、ポインタです

901
00:45:45,350 --> 00:45:46,320
全体で使用される。

902
00:45:46,320 --> 00:45:48,910
そして、私たちは実際に皮に始めましょう
ずっと前に戻ってそのレイヤー。

903
00:45:48,910 --> 00:45:51,740
しかし、それは、あまりにもその式を回す
あなたのいくつかは、精通しているかもしれません

904
00:45:51,740 --> 00:45:54,580
特に、より快適な、
非常に人気のあることは実際にある

905
00:45:54,580 --> 00:45:56,390
ウェブサイト、またはスタックオーバーフロー、
このごろ。

906
00:45:56,390 --> 00:45:58,720
>> しかし、これは実際には非常に持って
技術的な意味。

907
00:45:58,720 --> 00:46:00,160
我々は今、スタックが何であるかを知っている。

908
00:46:00,160 --> 00:46:02,550
これは、トレイの積み重ねのようなものだ
ダイニングホールの内部。

909
00:46:02,550 --> 00:46:05,140
>> または内部のコンピュータの数
メモリはこれらのフレーム

910
00:46:05,140 --> 00:46:06,900
それは、関数で使用されています。

911
00:46:06,900 --> 00:46:10,760
まあ、それはそのせいであることが判明
の非常に単純な実装

912
00:46:10,760 --> 00:46:14,970
メモリと、いわゆるオンフレーム
スタックには、実際に制御を取ることができます

913
00:46:14,970 --> 00:46:17,050
コンピュータシステムのかなり容易。

914
00:46:17,050 --> 00:46:22,180
人いる場合は、システムに侵入することができます
私たちのように私たちのコードを書いていない

915
00:46:22,180 --> 00:46:23,300
特によく。

916
00:46:23,300 --> 00:46:26,670
>> 私たちのような人々は、チャンクを使用する場合
メモリまたは使用のアレイ - 

917
00:46:26,670 --> 00:46:27,810
さらに一般的に - 

918
00:46:27,810 --> 00:46:31,800
時にはチェックアウトすることを忘れ
我々の配列の境界あなたはともかくとして

919
00:46:31,800 --> 00:46:38,470
自分は時々持っている、と反復
あまりに遠端配列過去の方法。

920
00:46:38,470 --> 00:46:40,520
最良のケースでは、あなたのプログラム
ただクラッシュする可能性があります。

921
00:46:40,520 --> 00:46:42,280
セグメンテーションフォールト、一種
恥ずかしいの。

922
00:46:42,280 --> 00:46:45,480
素晴らしいではありませんが、それは必ずしもありません
非常に悪いこと。

923
00:46:45,480 --> 00:46:49,480
>> しかし、あなたのプログラムは、実際に実際にある場合
それは実行している場合、ユーザーのコンピュータ、

924
00:46:49,480 --> 00:46:53,070
ウェブサイト上で、実際のランダムな人々
インターネット上させる、ヒットしている

925
00:46:53,070 --> 00:46:56,690
人々はあなたのコードに悪いことを誘発され
なぜなら一般的には良いこと

926
00:46:56,690 --> 00:46:59,930
それは取る機会を意味
コンピュータの制御。

927
00:46:59,930 --> 00:47:01,350
そして、これは見に行くさ
少し不可解。

928
00:47:01,350 --> 00:47:04,570
しかし、私はあなたを怖がらせるとしようと思いました
ここではこの最後の例。

929
00:47:04,570 --> 00:47:05,650
>> ここでは、コードの例です。

930
00:47:05,650 --> 00:47:07,370
そして、良いウィキペディアはあり
を歩く記事

931
00:47:07,370 --> 00:47:08,530
さらに詳細にこれ。

932
00:47:08,530 --> 00:47:13,890
私は底の通話のメイン持っている
1のARGVを渡しfooを、。

933
00:47:13,890 --> 00:47:15,750
そして、それはちょうどので、あなたができることです
プログラムを実行し、合格

934
00:47:15,750 --> 00:47:17,080
任意の入力。

935
00:47:17,080 --> 00:47:20,180
>> そして、fooが上部まで宣言されています
文字列を受け入れ、以上と

936
00:47:20,180 --> 00:47:21,700
正確には、char *型。

937
00:47:21,700 --> 00:47:23,860
その後、文字の配列を宣言します。

938
00:47:23,860 --> 00:47:27,130
より一般的には、バッファ呼ぶ
サイズ12の。

939
00:47:27,130 --> 00:47:30,900
だから、12文字は内に収まることができます
Cと呼ばれるその配列の。

940
00:47:30,900 --> 00:47:33,510
>> そして、それは、この新機能を使用しています
新しいなくするのは難しいされていない

941
00:47:33,510 --> 00:47:34,930
、メモリコピーを理解しています。

942
00:47:34,930 --> 00:47:39,290
それはあった、バーからメモリにコピー
可変過去nを、どんな

943
00:47:39,290 --> 00:47:42,080
CにARGV 1に入力されたユーザ。

944
00:47:42,080 --> 00:47:43,090
何バイト？

945
00:47:43,090 --> 00:47:44,260
バーの文字列の長さ。

946
00:47:44,260 --> 00:47:48,380
>> そう換言すれば、ユーザは種類のif
H-E-L-L-O入力文字列の長さ

947
00:47:48,380 --> 00:47:49,260
こんにちは5つです。

948
00:47:49,260 --> 00:47:52,790
だから、それらのバイトの5人が取得する予定です
Cと呼ばれる配列にコピーした

949
00:47:52,790 --> 00:47:54,110
サイズ12である。

950
00:47:54,110 --> 00:47:58,710
しかし、はるかに長いのユーザーが、タイプ
13文字または14の言葉

951
00:47:58,710 --> 00:48:01,250
文字や100文字以上？

952
00:48:01,250 --> 00:48:02,660
>> 彼らはどこに行くつもりですか？

953
00:48:02,660 --> 00:48:06,090
まあ、そのフレームは、そのトレイ
ダイニングホールスタック内の、

954
00:48:06,090 --> 00:48:06,930
彼らはそこに行くつもりです。

955
00:48:06,930 --> 00:48:10,080
そしてそれは単に上書き始めるために起こっている
すでにだ他のもの

956
00:48:10,080 --> 00:48:12,880
そのスタックに、あふれ
スタックは、いわば。

957
00:48:12,880 --> 00:48:14,780
>> だから画像で、それをこの方法を考える。

958
00:48:14,780 --> 00:48:17,970
これはただのカラフルバージョンです
絵は、我々は描画してきた。

959
00:48:17,970 --> 00:48:20,060
下部には、メインである、と言ってみましょう。

960
00:48:20,060 --> 00:48:24,690
その上に、あなたは今何を見ている
ために、今ではコード化されたフレーム、カラーです

961
00:48:24,690 --> 00:48:26,090
fooという関数です。

962
00:48:26,090 --> 00:48:30,170
しかしについてはこちら面白いものだ
fooが、ここでそのフレームであるということです。

963
00:48:30,170 --> 00:48:32,860
だから、それはちょうど私のように描かれています
しかし水色でやった。

964
00:48:32,860 --> 00:48:35,220
そして今、これはどこにある
Cブラケット0が入ります。

965
00:48:35,220 --> 00:48:37,410
ここで、cブラケットとこれは
11が終わるとしている。

966
00:48:37,410 --> 00:48:39,670
>> 換言すれば、に起こる
正方形として表される。

967
00:48:39,670 --> 00:48:42,320
しかし、あなたは単にバイトをplopping続ければ
ダウン - または文字 - 彼らは終了するつもりだ

968
00:48:42,320 --> 00:48:46,070
最高の場所で0までのすべての方法
11それがインデックス0であるため。

969
00:48:46,070 --> 00:48:49,170
>> しかし、13日の文字はどこにある
終わるつもり？

970
00:48:49,170 --> 00:48:50,310
14日はどこにありますか。

971
00:48:50,310 --> 00:48:52,430
50番目の文字はどこにあります
終わるつもり？

972
00:48:52,430 --> 00:48:54,070
>> それがダウンし続けるために起こっている。

973
00:48:54,070 --> 00:48:57,350
私たちが描かれたにも関わらず、そのため
育っスタック絵、

974
00:48:57,350 --> 00:48:59,920
アドレスは、結局のところ、から行く
小さな小さなアドレス、

975
00:48:59,920 --> 00:49:01,830
大きなアドレスへのポインタ。

976
00:49:01,830 --> 00:49:03,540
だから、ちょうど行くと最新の状態に保ちます。

977
00:49:03,540 --> 00:49:05,660
>> だから、ユーザーのタイプの場合
こんにちは、それは素晴らしいことだ。

978
00:49:05,660 --> 00:49:08,650
いいえバグなし、問題、皆の安全。

979
00:49:08,650 --> 00:49:11,940
しかし、我々はよ何でユーザーがタイプなら
表され、敵対コードを呼び出す

980
00:49:11,940 --> 00:49:16,040
一般的に、攻撃、攻撃など、
攻撃、攻撃、何が起こるでしょうか？

981
00:49:16,040 --> 00:49:19,760
>> まあ、もし入力のすべてがユーザ
に入力しただけでいくつかの友好的ではない

982
00:49:19,760 --> 00:49:21,540
の文字または文字列攻撃。

983
00:49:21,540 --> 00:49:24,050
これは、実際に一連の文字です
そのあなたがそれをコンパイルした場合、

984
00:49:24,050 --> 00:49:26,050
それは実際にコードです。

985
00:49:26,050 --> 00:49:29,570
たぶんそれはコードだとすべて削除
あなたのハードドライブ上のファイルやスパム送信

986
00:49:29,570 --> 00:49:30,810
そのような、または何か。

987
00:49:30,810 --> 00:49:35,110
キーはここで何だということに気づくと、そのある
悪い男がするのに十分幸運場合

988
00:49:35,110 --> 00:49:37,830
メモリの赤い塊を上書き - 

989
00:49:37,830 --> 00:49:41,080
私は自分の絵で描きませんでしたが、
ここでは、このWikipediaの画像持っている - 

990
00:49:41,080 --> 00:49:42,890
そのいわゆるリターンアドレス。

991
00:49:42,890 --> 00:49:47,470
>> ときに食べ物を返し、スワップリターン、
コンピュータがから行く方法を知っていない

992
00:49:47,470 --> 00:49:49,790
ここまでダウンしてここまで？

993
00:49:49,790 --> 00:49:52,920
または最大上記のハイテク部門で、どのように
それはスワップから行くように知っていますか

994
00:49:52,920 --> 00:49:54,870
コー​​ド -  0と1
それはスワップを構成する - 

995
00:49:54,870 --> 00:49:56,020
メインページに戻る？

996
00:49:56,020 --> 00:50:00,450
いわゆるリターンアドレスがあります
に、その同じスタックフレームに格納されている

997
00:50:00,450 --> 00:50:02,140
同じカフェテリアトレイ。

998
00:50:02,140 --> 00:50:06,080
>> 悪い男がするのに十分賢いですのであれば
攻撃コードを入れて、攻撃コード、攻撃

999
00:50:06,080 --> 00:50:07,960
コー​​ド、幸運を得る - 

1000
00:50:07,960 --> 00:50:11,630
しばしば試行錯誤 - へ
、その赤いリターンアドレスを上書きする

1001
00:50:11,630 --> 00:50:14,360
アドレスと通知と
非常にトップ。

1002
00:50:14,360 --> 00:50:16,830
0835C080に注目してください。

1003
00:50:16,830 --> 00:50:20,650
これは、後方のトップを書かれている
理由は、私たちは、おそらく再訪よ。

1004
00:50:20,650 --> 00:50:22,050
これはその数です。

1005
00:50:22,050 --> 00:50:25,790
>> 悪い男は幸運になるのであれば、または
赤を上書きするのに十分スマートです

1006
00:50:25,790 --> 00:50:29,480
のアドレスを持つメモリのストリップ
彼または彼女は何とか持っているコード

1007
00:50:29,480 --> 00:50:34,980
お使いのコンピュータに注入、その推測
コー​​ドはに戻されるために起こっている

1008
00:50:34,980 --> 00:50:38,260
fooが実行中に行われるとすぐに？

1009
00:50:38,260 --> 00:50:39,440
>> 悪者のコード。

1010
00:50:39,440 --> 00:50:43,610
再び、AAA、この攻撃コードは、そう、かもしれない
スパムを送信する、すべてのファイルを削除する可能性が

1011
00:50:43,610 --> 00:50:44,500
あなたのハードドライブ上の。

1012
00:50:44,500 --> 00:50:48,740
しかし、それはどのような本当にスタックオーバーフローです
であるか、バッファオーバーラン、または

1013
00:50:48,740 --> 00:50:51,060
バッファオーバーフロー攻撃。

1014
00:50:51,060 --> 00:50:54,400
>> そしてそれは信じられない、信じられないほど一般的です
で書かれたプログラムを使用してこの日に

1015
00:50:54,400 --> 00:50:58,220
C、C + +、さらにいくつかの他の言語。

1016
00:50:58,220 --> 00:51:02,275
その恐ろしいノートでは、我々はよ
冗談で終わる。

1017
00:51:02,275 --> 00:51:03,230
>> [笑い]

1018
00:51:03,230 --> 00:51:04,550
>> 水曜日にお会いしましょう​​。

1019
00:51:04,550 --> 00:51:07,920

1020
00:51:07,920 --> 00:51:10,310
次CS50で - 

1021
00:51:10,310 --> 00:51:15,920
だから私は、今日のディスクランプのすべてのアウトだけど
待って、無脂肪牛乳、半分電話

1022
00:51:15,920 --> 00:51:17,850
本、オレンジジュース
今日は飲んだ。

1023
00:51:17,850 --> 00:51:20,370

1024
00:51:20,370 --> 00:51:22,780
USBケーブル、レンチ。

1025
00:51:22,780 --> 00:51:24,800
>> [音楽再生]