1
00:00:00,000 --> 00:00:03,381
>> [音楽再生]

2
00:00:03,381 --> 00:00:10,626

3
00:00:10,626 --> 00:00:11,610
>> [ビデオ再生]

4
00:00:11,610 --> 00:00:13,640
>> -HEが横たわっています。

5
00:00:13,640 --> 00:00:14,380
>> -何について？

6
00:00:14,380 --> 00:00:17,182
>> -知りません。

7
00:00:17,182 --> 00:00:19,990
>> 私たちは何を知っていますか-SO？

8
00:00:19,990 --> 00:00:23,145
>> 9時15分、レイで - つまり
Santoyaは、ATMにありました。

9
00:00:23,145 --> 00:00:23,644
-Yeah。

10
00:00:23,644 --> 00:00:27,030
そこで問題は、何ですか
彼は9:16でやっていましたか？

11
00:00:27,030 --> 00:00:29,720
>> 何かで9ミリメートルを-Shooting。

12
00:00:29,720 --> 00:00:31,540
たぶん彼は狙撃兵を見ました。

13
00:00:31,540 --> 00:00:33,412
>> -orは彼と一緒に仕事をしていました。

14
00:00:33,412 --> 00:00:34,340
>> -待つ。

15
00:00:34,340 --> 00:00:36,200
1に戻ります。

16
00:00:36,200 --> 00:00:36,975
>> あなたは - 何を見ていますか？

17
00:00:36,975 --> 00:00:44,400

18
00:00:44,400 --> 00:00:47,805
>> 全画面までの彼の顔を-Bring。

19
00:00:47,805 --> 00:00:48,680
>> -Hisメガネ。

20
00:00:48,680 --> 00:00:50,060
>> 反射が-Thereです。

21
00:00:50,060 --> 00:01:00,455

22
00:01:00,455 --> 00:01:02,280
>>  - それはヌエビタス野球チームです。

23
00:01:02,280 --> 00:01:03,110
それは彼らのロゴです。

24
00:01:03,110 --> 00:01:05,820
>>  - そして彼がに話しています
誰がそのジャケットを着ています。

25
00:01:05,820 --> 00:01:06,670
>> [END再生]

26
00:01:06,670 --> 00:01:07,628
>> DAVIDマラン：すべての権利。

27
00:01:07,628 --> 00:01:11,210
これはCS50であり、これはもう少しです
[聞こえない]これであなたをしています

28
00:01:11,210 --> 00:01:12,890
問題に手を染めには、4つを設定します。

29
00:01:12,890 --> 00:01:16,606
今日はもう少し見て開始します
深くポインタと呼ばれるこれらの事で、

30
00:01:16,606 --> 00:01:18,480
それはだにもかかわらず、これ
かなり難解な話題、

31
00:01:18,480 --> 00:01:20,813
それが起こっていることが判明
我々手段であることが

32
00:01:20,813 --> 00:01:24,320
構築し、組み立て開始することができます
はるかに洗練されたプログラム。

33
00:01:24,320 --> 00:01:28,150
しかし、我々は最後の水曜日にそれをやりました
最初のいくつかのクレイメーションを介して。

34
00:01:28,150 --> 00:01:30,190
これは、リコールがあり、
Binkyと我々は彼を使用しました

35
00:01:30,190 --> 00:01:33,148
そのプログラムを見てみます
本当に面白い何もしませんでした、

36
00:01:33,148 --> 00:01:34,950
しかし、それはいくつかの問題を明らかにしました。

37
00:01:34,950 --> 00:01:38,570
では、なぜ私たちが歩いていない、今日を開始します
すぐにこれらのステップのいくつかを経て、

38
00:01:38,570 --> 00:01:41,920
人間の言葉の中に蒸留してみてください
まさにここで起こっています

39
00:01:41,920 --> 00:01:45,410
そしてなぜこれが悪いですし、その後に移動します
そして実際に何かの構築を開始

40
00:01:45,410 --> 00:01:46,309
この技術では？

41
00:01:46,309 --> 00:01:48,350
したがって、これらが最初でした
このプログラム内の2つのライン

42
00:01:48,350 --> 00:01:51,340
そして、素人の観点から、どのような
これらの2行はやっているの？

43
00:01:51,340 --> 00:01:55,600
合理的に快適な誰か
画面上で宣言されているものと？

44
00:01:55,600 --> 00:01:58,340

45
00:01:58,340 --> 00:02:00,120
これらの2行は何をしているのか？

46
00:02:00,120 --> 00:02:02,070
それはすべてのことではありません
1週間は異なります、

47
00:02:02,070 --> 00:02:03,611
しかし、いくつかの新しい特別なシンボルがあります。

48
00:02:03,611 --> 00:02:04,152
うん？

49
00:02:04,152 --> 00:02:05,628
そこに戻って。

50
00:02:05,628 --> 00:02:07,092
>> 聴衆：ポインタを宣言？

51
00:02:07,092 --> 00:02:08,050
DAVIDマランは：もう一度言って？

52
00:02:08,050 --> 00:02:08,860
聴衆：ポインタを宣言？

53
00:02:08,860 --> 00:02:11,776
DAVIDマラン：宣言ポインタと
それでは、もう少しそれを改良してみましょう。

54
00:02:11,776 --> 00:02:14,050
聴衆：[聞こえません]
アドレスxとyのその後。

55
00:02:14,050 --> 00:02:15,300
DAVIDマラン：そして取り組みます。

56
00:02:15,300 --> 00:02:18,550
だから、特に私たちがやっていること
我々は2つ​​の変数を宣言しているされています。

57
00:02:18,550 --> 00:02:21,252
これらの変数は、しかし、行っています
int型のスターであることが、これ

58
00:02:21,252 --> 00:02:23,210
より具体的な手段
彼らは店に行くされています

59
00:02:23,210 --> 00:02:26,450
int型のアドレス、
それぞれ、x及びy。

60
00:02:26,450 --> 00:02:27,660
今、任意の値があるのですか？

61
00:02:27,660 --> 00:02:32,621
これらのいずれかの実際のアドレスがあります
この時点での二つの変数？

62
00:02:32,621 --> 00:02:33,120
いいえ。

63
00:02:33,120 --> 00:02:35,030
それはちょうど、いわゆるゴミ値です。

64
00:02:35,030 --> 00:02:38,120
あなたが実際に割り当てない場合
RAMにあったものは何でも変数、

65
00:02:38,120 --> 00:02:42,224
以前にゼロを埋めるために起こっています
そして、のものそれらの変数の両方。

66
00:02:42,224 --> 00:02:44,140
しかし、我々はまだ知りません
彼らは何をしている、それはです

67
00:02:44,140 --> 00:02:47,060
なぜBinkyの鍵になるだろう
先週彼の頭を失いました。

68
00:02:47,060 --> 00:02:49,980
>> だから、これはクレイメーションました
このの化身

69
00:02:49,980 --> 00:02:53,580
あなただけの2つの変数を持っていることによって、
粘土の小さな円形の部分、

70
00:02:53,580 --> 00:02:57,330
それは変数を格納するが、のようなことができます
包ま矢印が示唆します、

71
00:02:57,330 --> 00:03:00,640
彼らは実際には向いていません
どこでもそれ自体知られています。

72
00:03:00,640 --> 00:03:03,670
だから我々は、この行があったが、この
新しい先週は、メモリ用のmallocました

73
00:03:03,670 --> 00:03:07,130
ただ派手な方法で割り当て、
オペレーティングシステムを伝える、Linuxの

74
00:03:07,130 --> 00:03:09,750
またはMac OSやWindows、
ちょっと、私にいくつかのメモリを与え、

75
00:03:09,750 --> 00:03:11,780
あなたが持っているすべてを伝えるために
オペレーティング・システム

76
00:03:11,780 --> 00:03:14,699
メモリのためにそれを要求するときにするものです。

77
00:03:14,699 --> 00:03:16,990
それは何を気にするつもりはありません
あなたはそれをどうするつもりです、

78
00:03:16,990 --> 00:03:19,786
しかし、あなたは、動作を指示する必要があります
何malloc関数を介してシステム。

79
00:03:19,786 --> 00:03:20,286
うん？

80
00:03:20,286 --> 00:03:21,078
>> 聴衆：どのくらい？

81
00:03:21,078 --> 00:03:21,994
DAVIDマラン：どのくらい？

82
00:03:21,994 --> 00:03:25,280
どのくらいのバイトで、そのため、この、再び、
不自然な例は、単に言っています、

83
00:03:25,280 --> 00:03:27,360
私はint型の大きさを与えます。

84
00:03:27,360 --> 00:03:30,550
int型の今、サイズ
4バイトまたは32ビットです。

85
00:03:30,550 --> 00:03:32,850
だから、これはただの方法であります
言って、ちょっと、オペレーティングシステム、

86
00:03:32,850 --> 00:03:37,290
私は4バイトのメモリを与えます
私は自由に使用することができ、

87
00:03:37,290 --> 00:03:40,560
具体的には、何を
mallocの戻り

88
00:03:40,560 --> 00:03:41,795
4バイトのそのチャンクに？

89
00:03:41,795 --> 00:03:44,110

90
00:03:44,110 --> 00:03:44,860
聴衆：住所？

91
00:03:44,860 --> 00:03:45,901
DAVIDマラン：アドレス。

92
00:03:45,901 --> 00:03:47,580
4バイトのチャンクのアドレス。

93
00:03:47,580 --> 00:03:48,190
その通りです。

94
00:03:48,190 --> 00:03:51,430
そしてそうそれは最終的に保存されているものです
xのと私たちは本当にない理由です

95
00:03:51,430 --> 00:03:55,240
気にどのようなことの数
アドレスは、OX1またはOX2だか、あります

96
00:03:55,240 --> 00:03:57,110
またはいくつかの不可解な16進アドレス。

97
00:03:57,110 --> 00:03:59,850
私達はちょうど絵ケア
その変数xは今であること

98
00:03:59,850 --> 00:04:01,630
メモリのチャンクを指します。

99
00:04:01,630 --> 00:04:05,570
だから、矢印はポインタを表し、または
より具体的には、メモリアドレス。

100
00:04:05,570 --> 00:04:09,120
しかし、再び、私たちは一般的に気にしません
それらの実際のアドレスが何でありますか。

101
00:04:09,120 --> 00:04:11,780
さて、この行は述べています
何普通の言葉で？

102
00:04:11,780 --> 00:04:14,330
スターxは42セミコロンを取得します。

103
00:04:14,330 --> 00:04:17,390
これは何を意味するのでしょうか？

104
00:04:17,390 --> 00:04:18,200
あなたが行きたいですか？

105
00:04:18,200 --> 00:04:20,102
あなたの首に傷を付けないでください。

106
00:04:20,102 --> 00:04:22,360
>> 聴衆：xのアドレスは42です。

107
00:04:22,360 --> 00:04:24,300
>> DAVIDマラン：xのアドレスは42です。

108
00:04:24,300 --> 00:04:25,190
全くありません。

109
00:04:25,190 --> 00:04:28,485
とても近く、しかしかなり、ありますので、
このXの前に付けるのスター。

110
00:04:28,485 --> 00:04:29,860
だから我々は少しを微調整する必要があります。

111
00:04:29,860 --> 00:04:31,032
うん？

112
00:04:31,032 --> 00:04:36,044
>> 聴衆：値
ポインタxが42であるために指しています。

113
00:04:36,044 --> 00:04:36,710
DAVIDマラン：OK。

114
00:04:36,710 --> 00:04:40,840
ポインタxがあると値
指し、42でなければならない、のは言わせて、

115
00:04:40,840 --> 00:04:44,165
または別の方法で、星を置きます
xは任意のアドレスに行く、と言います

116
00:04:44,165 --> 00:04:48,340
それは1オックスフォードだかどうか、Xであり、
ストリートまたは33オックスフォードストリート

117
00:04:48,340 --> 00:04:51,850
またはOX1またはox33、何でも
その数値アドレスであり、

118
00:04:51,850 --> 00:04:54,380
スターxはxの逆参照です。

119
00:04:54,380 --> 00:04:57,297
だから、そのアドレスに移動し、
そこ番号42を置きます。

120
00:04:57,297 --> 00:04:59,380
だからだろう
そう言うのと同等の方法。

121
00:04:59,380 --> 00:05:01,860
だから、すべての罰金だとその後
我々は、画像を表すことになります

122
00:05:01,860 --> 00:05:05,370
我々が追加した場合は、次のように
4のそのチャンクへ42

123
00:05:05,370 --> 00:05:09,370
右側のバイトが、
物事がゆがんでどこに行ったこのラインはありました

124
00:05:09,370 --> 00:05:11,120
そして、Binkyの頭がポップ
この時点でオフ、

125
00:05:11,120 --> 00:05:15,290
悪いことが起こるときのため
あなたごみ値を間接参照

126
00:05:15,290 --> 00:05:18,210
無効な間接参照したり
ポインタは、と私は無効と言います

127
00:05:18,210 --> 00:05:21,020
この時点で理由
物語、Yの内側に何ですか？

128
00:05:21,020 --> 00:05:24,440
ベースyの値は何ですか
過去数ステップの？

129
00:05:24,440 --> 00:05:25,360
うん？

130
00:05:25,360 --> 00:05:26,115
あれは何でしょう？

131
00:05:26,115 --> 00:05:26,990
>> 聴衆：アドレス。

132
00:05:26,990 --> 00:05:28,460
DAVIDマラン：アドレス。

133
00:05:28,460 --> 00:05:31,910
それはアドレスでなければなりません
しかし、私はそれを初期化していますか？

134
00:05:31,910 --> 00:05:32,800
だから私はまだ持っていません。

135
00:05:32,800 --> 00:05:35,430
だから何がそこにあることが知られていますか？

136
00:05:35,430 --> 00:05:37,590
それだけでいくつかのゴミ値です。

137
00:05:37,590 --> 00:05:41,500
それは、ゼロからの任意のアドレスになります
20億あなたがRAMの2ギグを持っている場合、

138
00:05:41,500 --> 00:05:44,289
またはゼロ億4にあなたがしている場合
RAMの4ギガバイトを得ました。

139
00:05:44,289 --> 00:05:46,080
これは、いくつかのゴミ値です
しかし、問題があります

140
00:05:46,080 --> 00:05:48,200
オペレーティングシステムなお、
それはあなたが与えられていない場合

141
00:05:48,200 --> 00:05:51,140
メモリのチャンク、具体的
あなたが行くようにしようとしていることを、

142
00:05:51,140 --> 00:05:54,650
それは一般的に何を引き起こすことが起こっています
私たちは、セグメンテーションフォールトとして見てきました。

143
00:05:54,650 --> 00:05:57,810
だから実際には、すべてのあなたの持っている人
営業時間での問題で苦戦

144
00:05:57,810 --> 00:06:00,393
以上だ問題で
一般的に把握しようと

145
00:06:00,393 --> 00:06:02,150
セグメンテーションフォールト、
それは一般的な手段

146
00:06:02,150 --> 00:06:05,017
あなたはのセグメントに触れています
あなたがすべきではないメモリ。

147
00:06:05,017 --> 00:06:07,350
あなたは、メモリに触れていること
オペレーティングシステムがない持っています

148
00:06:07,350 --> 00:06:10,450
それはだかどうか、あなたが触れることを許さ
あなたの配列にすぎ行くことによって

149
00:06:10,450 --> 00:06:12,870
かどうか、今始まります
あなたが触れているので、それはです

150
00:06:12,870 --> 00:06:14,780
単にいくつかのゴミ値であるメモリ。

151
00:06:14,780 --> 00:06:18,230
>> そこでここではスターxをされてい
未定義の動作の一種。

152
00:06:18,230 --> 00:06:22,030
オッズので、あなたはそれを行うべきではありません
、プログラムだけでクラッシュするだろうし、

153
00:06:22,030 --> 00:06:24,050
あなたが言っているので、
このアドレスに行きます

154
00:06:24,050 --> 00:06:27,000
あなたはどこ見当がつかない
そのアドレスが実際にあります。

155
00:06:27,000 --> 00:06:30,300
だから、オペレーティングシステムがそうです
あなたのプログラムをクラッシュさせるつもり

156
00:06:30,300 --> 00:06:33,840
結果として、実際、それはです
何がBinkyにそこに起こりました。

157
00:06:33,840 --> 00:06:37,210
だから最終的に、Binkyは固定します
これでこの問題。

158
00:06:37,210 --> 00:06:38,909
だから、そのプログラム自体は欠陥ました。

159
00:06:38,909 --> 00:06:41,450
しかし、あなたは、ソートの押し進める場合
その代わりに、この行を実行し、

160
00:06:41,450 --> 00:06:45,580
yは、xがちょうど何を意味等しいです
アドレスは、xである、また、Yに入れます。

161
00:06:45,580 --> 00:06:48,740
>> だから絵、我々はしました
2矢印でこれを表現

162
00:06:48,740 --> 00:06:51,570
Xからとyのポインティングから
同じ場所へ。

163
00:06:51,570 --> 00:06:55,760
だから、意味的には、xは等しく、
yにあるため、それらの両方

164
00:06:55,760 --> 00:07:00,300
同じように保存しています
アドレスは、エルゴは、42を指し

165
00:07:00,300 --> 00:07:04,910
そして今、あなたは星を言うとき
yは、yのアドレスに移動、

166
00:07:04,910 --> 00:07:06,790
これは興味深い副作用を有しています。

167
00:07:06,790 --> 00:07:10,320
だから、yのアドレスです
xのアドレスと同じもの。

168
00:07:10,320 --> 00:07:15,060
ですから、アドレスに行くと言えば
yに13に値を変更し、

169
00:07:15,060 --> 00:07:17,140
他の人に影響を与えているのですか？

170
00:07:17,140 --> 00:07:21,100
Xは、D点で、いわば
同様に影響を受けるべきです。

171
00:07:21,100 --> 00:07:24,340
>> そしてニックはこの絵を描いた確かに、どのように
クレイメーションでまさにそれでした。

172
00:07:24,340 --> 00:07:28,665
我々はポインタをたどるにもかかわらず
yは、我々は、同じ場所で終わりました

173
00:07:28,665 --> 00:07:32,780
そして私たちは、印刷した場合
xまたはyのポインティング先出、

174
00:07:32,780 --> 00:07:35,720
その後、我々は13の値を参照してくださいだろう。

175
00:07:35,720 --> 00:07:37,927
今、私は指示先があることを言います
ビデオと一致しました。

176
00:07:37,927 --> 00:07:39,760
私のプログラマ、
知識、決して実際に

177
00:07:39,760 --> 00:07:42,460
単語指示先を言って、
尖っているもの

178
00:07:42,460 --> 00:07:44,650
ではなく、一貫性のために
ビデオを実現

179
00:07:44,650 --> 00:07:47,520
それがあったことすべてです
そのような状況で意味しました。

180
00:07:47,520 --> 00:07:54,190
クレイメーションのそうご質問
またはポインタやmalloc関数まだ？

181
00:07:54,190 --> 00:07:54,850
なし？

182
00:07:54,850 --> 00:07:55,470
大丈夫。

183
00:07:55,470 --> 00:07:58,560
>> だから、さらになし
ADO、のは見てみましょう

184
00:07:58,560 --> 00:08:00,700
これが実際に有している場合に
しばらくの間使用されて。

185
00:08:00,700 --> 00:08:03,580
だから我々は、このCS50ライブラリを持っていました
それは、これらの機能をすべて持っています。

186
00:08:03,580 --> 00:08:06,810
私たちは、GetIntでたくさん、のGetStringを使用しました
おそらく以前GetLongLong

187
00:08:06,810 --> 00:08:09,840
私のPSET内の1つまたはそうが、
実際に何が起こっているされていますか？

188
00:08:09,840 --> 00:08:12,920
さて、簡単に見てみましょう
そのプログラムではフードの下に

189
00:08:12,920 --> 00:08:17,017
私たちはあなたにCS50を与える理由を鼓舞
ライブラリ、および実際に先週のように、

190
00:08:17,017 --> 00:08:18,850
我々は、これらのを取り始め
補助輪オフ。

191
00:08:18,850 --> 00:08:21,080
だから、これは今ソートされます
何の死後の

192
00:08:21,080 --> 00:08:23,690
続いています
CS50ライブラリ内には、

193
00:08:23,690 --> 00:08:27,250
我々は今、移動を開始しますにもかかわらず、
それから離れてほとんどのプログラムで。

194
00:08:27,250 --> 00:08:29,460
>> だから、これはscanfの0と呼ばれるプログラムです。

195
00:08:29,460 --> 00:08:30,510
それは超短いです。

196
00:08:30,510 --> 00:08:33,909
それはちょうどこれらの行を持っていますが、それ
scanf関数と呼ばれる関数を紹介します

197
00:08:33,909 --> 00:08:36,909
我々は、実際に表示しようとしていること
CS50ライブラリの内部瞬間、

198
00:08:36,909 --> 00:08:38,600
わずかに異なる形ではあるが。

199
00:08:38,600 --> 00:08:41,330
ライン16上のため、このプログラム
変数xを宣言しています。

200
00:08:41,330 --> 00:08:43,150
だから、私はint型のための4つのバイトを与えます。

201
00:08:43,150 --> 00:08:45,750
これは、ユーザーが言っています
数お願いし、その後

202
00:08:45,750 --> 00:08:49,010
これは興味深い行であること
実際に先週結びつけます

203
00:08:49,010 --> 00:08:49,790
これ。

204
00:08:49,790 --> 00:08:53,230
scanfの、その後はそれが取る気づきます
書式文字列、ちょうどprintfのような、

205
00:08:53,230 --> 00:08:57,480
％私はint型を意味し、それがかかります
少し見える二番目の引数

206
00:08:57,480 --> 00:08:58,260
ファンキー。

207
00:08:58,260 --> 00:09:01,880
それはアンパサンドXの、と思い出して、
我々は、最後の週に一度これを見ました。

208
00:09:01,880 --> 00:09:03,465
アンパサンドxは何を表しているのでしょうか？

209
00:09:03,465 --> 00:09:06,210

210
00:09:06,210 --> 00:09:08,450
アンパサンドは、C言語で何をしますか？

211
00:09:08,450 --> 00:09:08,950
うん？

212
00:09:08,950 --> 00:09:10,024
>> 聴衆：のアドレス。

213
00:09:10,024 --> 00:09:11,190
DAVIDマラン：のアドレス。

214
00:09:11,190 --> 00:09:13,190
だから、反対です
スター演算子の、

215
00:09:13,190 --> 00:09:17,270
スターオペレータが言うのに対し、に行きます
このアドレス、アンパサンド演算子

216
00:09:17,270 --> 00:09:20,280
把握、言います
この変数のアドレス、

217
00:09:20,280 --> 00:09:23,530
ので、これは、鍵となります
生活の中でのscanfの目的

218
00:09:23,530 --> 00:09:26,320
利用者をスキャンすることです
キーボードからの入力、

219
00:09:26,320 --> 00:09:29,970
どのような彼または彼女に依存
タイプは、その後、そのユーザの入力を読み取ります

220
00:09:29,970 --> 00:09:32,970
変数に、しかし、我々
過去2週間で見ました

221
00:09:32,970 --> 00:09:36,080
我々そのスワップ機能その
実装する難なくみました

222
00:09:36,080 --> 00:09:37,110
ちょうど壊れていました。

223
00:09:37,110 --> 00:09:42,470
スワップ機能でそれを思い出し、
私たちはint型としてAとBを宣言した場合、

224
00:09:42,470 --> 00:09:47,040
我々が正常に交換しました
スワップの内側に二つの変数

225
00:09:47,040 --> 00:09:50,080
ちょうどミルクとOJと同じように、
しかし、すぐにスワップが返されます、

226
00:09:50,080 --> 00:09:55,200
結果何でした
xとyに、元の値？

227
00:09:55,200 --> 00:09:55,700
何もありません。

228
00:09:55,700 --> 00:09:56,200
うん。

229
00:09:56,200 --> 00:09:59,754
何もするので、その時間を起こりませんでした
スワップは、唯一のローカルコピーを変更します

230
00:09:59,754 --> 00:10:01,670
すべて、言うことです
私たちがきたときには、この時、

231
00:10:01,670 --> 00:10:04,010
引数を渡すされて
関数に、私たちはしています

232
00:10:04,010 --> 00:10:05,939
単にこれらの引数のコピーを渡します。

233
00:10:05,939 --> 00:10:07,980
あなたはそれを行うことができます
あなたも一緒にやりたいです、

234
00:10:07,980 --> 00:10:10,890
しかし、彼らはありません必要があるとしています
元の値への影響。

235
00:10:10,890 --> 00:10:13,650
あなたのであればこれは問題があります
scanf関数のような機能を持つようにしたいです

236
00:10:13,650 --> 00:10:17,170
生活の中で、その目的は、スキャンすることです
キーボードからのユーザーの入力

237
00:10:17,170 --> 00:10:22,010
そしてそのようにし、空白を埋めます
話す、つまり、Xのような変数を与えます

238
00:10:22,010 --> 00:10:25,410
値、私がされたかのために
ただscanf関数xを渡すには、

239
00:10:25,410 --> 00:10:28,790
あなたが最後の論理を考慮すれば、
週、scanf関数は、それが望んでいるものは何でも行うことができます

240
00:10:28,790 --> 00:10:33,100
xのコピーで、それができませんでした
私たちは与えない限り、永久にXを変更

241
00:10:33,100 --> 00:10:37,120
宝の地図のscanf、いわば、
xはスポットをマークどこで、これにより、

242
00:10:37,120 --> 00:10:41,860
私たちはそのようにxのアドレスを渡します
scanf関数は、そこに行くと、実際に変更することができます

243
00:10:41,860 --> 00:10:42,920
xの値。

244
00:10:42,920 --> 00:10:45,080
だから確かに、すべての
このプログラムがないこと

245
00:10:45,080 --> 00:10:53,180
私は私の元に、scanfの0を加えた場合
5メートルディレクトリ、scanfの0を行い、

246
00:10:53,180 --> 00:10:57,730
ドットスラッシュscanf関数、数
50 50、感謝をしてください。

247
00:10:57,730 --> 00:11:01,020
>> だから、すべてが面白いではありません
しかし、実際に何が起こっています

248
00:11:01,020 --> 00:11:04,820
すぐに私が呼んでいることです
scanf関数ここで、xの値

249
00:11:04,820 --> 00:11:06,410
恒久的に変更されています。

250
00:11:06,410 --> 00:11:08,335
さて、これは素敵なようで、
良い、と実際には、それ

251
00:11:08,335 --> 00:11:11,200
私たちは本当に必要はありませんように思えます
もうまったくCS50ライブラリ。

252
00:11:11,200 --> 00:11:13,960
たとえば、のは、実行してみましょう
ここで、この一回以上。

253
00:11:13,960 --> 00:11:15,750
私は第二のためにそれを再び開くましょう。

254
00:11:15,750 --> 00:11:20,600
番号をお願いしてみましょうと
代わりに前のように50というのは、

255
00:11:20,600 --> 00:11:22,810
ちょうどノーと言うてみましょう。

256
00:11:22,810 --> 00:11:24,000
[OK]を、それは少し奇妙なことです。

257
00:11:24,000 --> 00:11:25,270
OK。

258
00:11:25,270 --> 00:11:28,680
そして、ここではいくつかのナンセンス。

259
00:11:28,680 --> 00:11:31,170
だから、していないようです
誤った状況を扱います。

260
00:11:31,170 --> 00:11:33,620
だから我々はスタートを最小限にする必要があります
いくつかのエラーチェックを追加

261
00:11:33,620 --> 00:11:37,460
ユーザーが持っていることを確認します
50のような実際の数で入力し、

262
00:11:37,460 --> 00:11:40,720
明らかに単語を入力するため、
問題が検出されません、

263
00:11:40,720 --> 00:11:42,020
しかし、それはおそらくする必要があります。

264
00:11:42,020 --> 00:11:46,450
>> それでは、それはだ、このバージョンを見てみましょう
GetStringを再実装する私の試み。

265
00:11:46,450 --> 00:11:48,437
scanf関数は、このすべてを持っている場合
に組み込まれた機能、

266
00:11:48,437 --> 00:11:51,270
なぜ私たちは、これらに手を染めてきました
GetStringなどの補助輪？

267
00:11:51,270 --> 00:11:55,450
さて、ここでは、おそらく自分で
GetStringの簡易版

268
00:11:55,450 --> 00:12:00,766
これにより一週間前、私は言ったかもしれません、
私は文字列を与えるとバッファを呼び出します。

269
00:12:00,766 --> 00:12:03,390
今日、私はちょうど開始するつもりです
char型のスターを言って、これは、リコール、

270
00:12:03,390 --> 00:12:04,400
それだけでは同義です。

271
00:12:04,400 --> 00:12:06,629
それは恐ろしい見えますが、それはです
まったく同じこと。

272
00:12:06,629 --> 00:12:09,420
だから、私はバッファと呼ばれる変数を与えます
それは文字列を格納するために起こっています、

273
00:12:09,420 --> 00:12:12,780
ユーザー文字列をしてください教えて、
し、その後、直前のように、

274
00:12:12,780 --> 00:12:17,760
それでは、このレッスンを借りてみましょうのscanf
％sのこの時間と、バッファに渡します。

275
00:12:17,760 --> 00:12:19,310
さて、迅速な健全性チェック。

276
00:12:19,310 --> 00:12:22,120
なぜ私は言っていないです
アンパサンドは、この時間をバッファ？

277
00:12:22,120 --> 00:12:25,190

278
00:12:25,190 --> 00:12:26,625
前の例から推測します。

279
00:12:26,625 --> 00:12:28,000
聴衆：チャースターはポインタです。

280
00:12:28,000 --> 00:12:29,920
DAVIDマラン：その通り、
この時、文字のため

281
00:12:29,920 --> 00:12:34,080
星は、既にポインタ、アドレスであります
そこにいるその星の定義によって。

282
00:12:34,080 --> 00:12:37,530
やscanfがアドレスを想定している場合、
それだけでバッファに渡すのに十分です。

283
00:12:37,530 --> 00:12:39,260
私はアンパサンドバッファを言う必要はありません。

284
00:12:39,260 --> 00:12:42,177
好奇心のために、あなたは可能性
このような何かを。

285
00:12:42,177 --> 00:12:43,510
それは別の意味を持っているでしょう。

286
00:12:43,510 --> 00:12:47,240
これは、あなたのポインタを与えるだろう
実際にポインタへ

287
00:12:47,240 --> 00:12:50,050
C言語ではなく、ために有効なもの
それでは、それをシンプルに維持させます

288
00:12:50,050 --> 00:12:51,750
そして、一貫性のある話を続けます。

289
00:12:51,750 --> 00:12:54,100
私は渡すつもりです
緩衝液およびそれが正しいのです。

290
00:12:54,100 --> 00:12:56,487
問題は、しかし、このです。

291
00:12:56,487 --> 00:12:58,820
私が先に行くと、これを実行してみましょう
それをコンパイル後のプログラム。

292
00:12:58,820 --> 00:13:00,902
scanfの1を作ります。

293
00:13:00,902 --> 00:13:02,610
くそそれは、私のコンパイラの
私のエラーをキャッチ。

294
00:13:02,610 --> 00:13:04,090
私は一秒を与えます。

295
00:13:04,090 --> 00:13:05,460
クラン。

296
00:13:05,460 --> 00:13:06,990
それでは、scanfの-1.Cを言ってみましょう。

297
00:13:06,990 --> 00:13:10,880

298
00:13:10,880 --> 00:13:11,380
OK。

299
00:13:11,380 --> 00:13:12,720
そうしよう。

300
00:13:12,720 --> 00:13:14,280
それが必要。

301
00:13:14,280 --> 00:13:16,750
CS50のIDを有し、様々な
構成設定

302
00:13:16,750 --> 00:13:18,280
それは自分自身に対してあなたを守ります。

303
00:13:18,280 --> 00:13:21,300
私はによってそれらを無効にするために必要な
手動でこの時間を打ち鳴らすを実行しています。

304
00:13:21,300 --> 00:13:22,140
だから、文字列下さい。

305
00:13:22,140 --> 00:13:25,560
私が先に行くと入力するつもりです
私の好きな​​ハロー世界インチ

306
00:13:25,560 --> 00:13:26,490
ヌル、[OK]をクリックします。

307
00:13:26,490 --> 00:13:27,700
それは私が入力した内容ではありません。

308
00:13:27,700 --> 00:13:29,690
だから、の指標です
何かが間違っています。

309
00:13:29,690 --> 00:13:33,920
私が先に行くと入力してみましょう
本当に長い文字列です。

310
00:13:33,920 --> 00:13:37,210
ヌルのためのおかげで、私は知りません
場合、私はそれをクラッシュできるようにするつもりです。

311
00:13:37,210 --> 00:13:40,240
のは少しコピーをしてみましょう
貼り付け、このことができますかどうかを確認します。

312
00:13:40,240 --> 00:13:43,290
ただ、このたくさんのを貼り付けます。

313
00:13:43,290 --> 00:13:47,310
それは間違いなく大きいです
通常よりも文字列。

314
00:13:47,310 --> 00:13:51,450
ちょうど実際にそれを書いてみましょう。

315
00:13:51,450 --> 00:13:51,950
いいえ。

316
00:13:51,950 --> 00:13:52,650
畜生。

317
00:13:52,650 --> 00:13:53,480
コマンドが見つかりません。

318
00:13:53,480 --> 00:13:54,550
だから、無関係なの​​です。

319
00:13:54,550 --> 00:13:56,440
私が貼り付けられているためです
一部の不正な文字、

320
00:13:56,440 --> 00:13:59,780
これが判明仕事に行くされていません。

321
00:13:59,780 --> 00:14:03,510
>> それでは、もう一度、これを試してみましょう、ので、
我々は実際にそれをクラッシュ場合には、より楽しいです。

322
00:14:03,510 --> 00:14:09,116
それでは、これを入力してみましょう、今、私はよ
本当に長い文字列をコピーしようとして

323
00:14:09,116 --> 00:14:10,990
そして今、我々場合を見てみましょう
この事をクラッシュさせることができます。

324
00:14:10,990 --> 00:14:14,235
私はスペースを省略し、注意してください
新しい行やセミコロン

325
00:14:14,235 --> 00:14:16,035
そして、すべてのファンキーな文字。

326
00:14:16,035 --> 00:14:16,535
入力します。

327
00:14:16,535 --> 00:14:21,090

328
00:14:21,090 --> 00:14:22,880
そして今、ネットワークが遅いだけです。

329
00:14:22,880 --> 00:14:27,460
私は明らかに、長すぎるコマンド+ Vを押し続けます。

330
00:14:27,460 --> 00:14:28,190
畜生！

331
00:14:28,190 --> 00:14:29,260
コマンドが見つかりません。

332
00:14:29,260 --> 00:14:29,780
>> OK。

333
00:14:29,780 --> 00:14:32,240
まあ、ポイントがあります
それにもかかわらず、以下の通りです。

334
00:14:32,240 --> 00:14:36,910
だから、実際に何が起こっているのか
この宣言での

335
00:14:36,910 --> 00:14:39,240
ライン16上の文字スターバッファの？

336
00:14:39,240 --> 00:14:41,820
だから私は何を取得しています
私はポインタを宣言するとき？

337
00:14:41,820 --> 00:14:47,440
私が得ているすべては、4バイトの値であり、
バッファと呼ばれるが、その中に何が

338
00:14:47,440 --> 00:14:49,540
現時点では？

339
00:14:49,540 --> 00:14:50,930
それだけでいくつかのゴミ値です。

340
00:14:50,930 --> 00:14:54,170
いつでもあるので、あなたは変数を宣言
C言語で、それは単にいくつかのゴミ値です、

341
00:14:54,170 --> 00:14:56,220
我々はに開始しています
この現実を超える旅。

342
00:14:56,220 --> 00:14:59,720
今、私はscanf関数を教えたときに、
このアドレスに行きます

343
00:14:59,720 --> 00:15:01,520
とにどのようなユーザータイプを置きます。

344
00:15:01,520 --> 00:15:06,400
ユーザーがハローであれば
世界は、よく、どこに私がそれを置くのですか？

345
00:15:06,400 --> 00:15:07,750
バッファは、ガベージ値です。

346
00:15:07,750 --> 00:15:11,510
>> だから、一種の矢印のようなものです
それがどこに知っている指しています。

347
00:15:11,510 --> 00:15:13,880
多分それは向いています
右ここで私の記憶です。

348
00:15:13,880 --> 00:15:16,560
そしてそうするときにユーザー
ハロー世界で種類、

349
00:15:16,560 --> 00:15:22,380
プログラムは入れしようとします
文字列のhello worldバックスラッシュ0

350
00:15:22,380 --> 00:15:23,910
メモリのチャンクインチ

351
00:15:23,910 --> 00:15:27,070
しかし、高い確率ではなく、
明確ではない100％の確率、

352
00:15:27,070 --> 00:15:30,440
次いで、コンピュータは、クラッシュしようとしています
プログラムこれではありませんので、

353
00:15:30,440 --> 00:15:32,490
メモリ私は触れないように許可する必要があります。

354
00:15:32,490 --> 00:15:36,330
だから要するに、このプログラムがあります
まさにその理由で欠陥。

355
00:15:36,330 --> 00:15:38,070
私は基本的に何をやっていませんよ？

356
00:15:38,070 --> 00:15:42,366
どのような手順私は同じように、省略されています
我々はBinkyの最初の例では省略しましたか？

357
00:15:42,366 --> 00:15:42,866
うん？

358
00:15:42,866 --> 00:15:43,710
>> 対象：メモリの割り当て？

359
00:15:43,710 --> 00:15:45,001
>> DAVIDマラン：メモリの割り当て。

360
00:15:45,001 --> 00:15:48,400
私は実際に割り当てられていません
その文字列の任意のメモリ。

361
00:15:48,400 --> 00:15:50,270
だから我々はいくつかの方法でこの問題を解決することができます。

362
00:15:50,270 --> 00:15:52,700
一、私たちはそれをシンプルに保つことができます
実際には、今あなたがしています

363
00:15:52,700 --> 00:15:55,116
ボケを見に開始する予定
何の間の行の

364
00:15:55,116 --> 00:15:58,520
配列は、文字列が何であるか、何Aであります
char型の星は、文字のどのような配列であります

365
00:15:58,520 --> 00:15:59,020
です。

366
00:15:59,020 --> 00:16:02,450
ここで第二の例を示します
文字列との通知を含みます

367
00:16:02,450 --> 00:16:05,690
すべての私はライン上に行ってきました
16の代わりにというのが、あります

368
00:16:05,690 --> 00:16:09,530
そのバッファは、charになるだろう
星、メモリのチャンクへのポインタ、

369
00:16:09,530 --> 00:16:14,057
私は非常に積極的に提供するつもりです
自分の16文字のバッファ、

370
00:16:14,057 --> 00:16:16,390
実際には、あなたが精通している場合
用語のバッファリングと、

371
00:16:16,390 --> 00:16:20,570
おそらく、ビデオの世界から、
ビデオがバッファリング、バッファリングであり、

372
00:16:20,570 --> 00:16:21,175
バッファリング。

373
00:16:21,175 --> 00:16:22,550
さて、ここでの接続は何ですか？

374
00:16:22,550 --> 00:16:24,960
まあ、YouTubeの内部
およびビデオプレーヤーの内部

375
00:16:24,960 --> 00:16:27,200
一般的に配列です
それが16より大きいです。

376
00:16:27,200 --> 00:16:30,340
それは、サイズ1の配列であるかもしれません
メガバイト、多分10メガバイト、

377
00:16:30,340 --> 00:16:34,330
その配列にブラウザを行います
バイトの全体の束をダウンロードし、

378
00:16:34,330 --> 00:16:37,500
のメガバイトの全体の束
ビデオ、ビデオプレーヤー、

379
00:16:37,500 --> 00:16:40,930
YouTubeのか誰だ、開始
その配列からバイトを読み込みます、

380
00:16:40,930 --> 00:16:43,530
あなたが見るといつでも
ワードバッファリング、バッファリング、

381
00:16:43,530 --> 00:16:46,350
それはプレイヤーが持っている意味します
その配列の末尾に頂いております。

382
00:16:46,350 --> 00:16:50,430
ネットワークは、それがない持っているように遅いです
より多くのバイトの配列を再充填

383
00:16:50,430 --> 00:16:55,610
そのため、あなたはビットの外出します
ユーザに表示します。

384
00:16:55,610 --> 00:16:59,430
>> それでバッファはaptの用語は、ここにあります
それはちょうど、アレイ、メモリの塊です。

385
00:16:59,430 --> 00:17:02,530
そして、これはそれを修正します
それが判明したため、

386
00:17:02,530 --> 00:17:07,410
あなたがあるかのように配列を扱うことができること
彼らも、バッファが、アドレスであります

387
00:17:07,410 --> 00:17:10,710
それはだ、ただの記号であります
文字のシーケンス、バッファ、

388
00:17:10,710 --> 00:17:14,760
それは私のために便利です、プログラマー、
あなたの周りにその名前を渡すことができます

389
00:17:14,760 --> 00:17:17,079
それはであるかのように
ポインタとして、それにもかかわらず

390
00:17:17,079 --> 00:17:21,000
チャンクのアドレスでした
16文字のメモリー。

391
00:17:21,000 --> 00:17:24,530
それは言うことですので、私は渡すことができます
scanfのまさにその単語

392
00:17:24,530 --> 00:17:30,670
そして今、私はこのプログラムを作る場合は、
、scanf関数2、ドットスラッシュscanfの2を作ります

393
00:17:30,670 --> 00:17:35,386
そして、のHello Worldを入力し、
、そのtime--を入力してください

394
00:17:35,386 --> 00:17:37,590
>> うーん、何が起こったのか？

395
00:17:37,590 --> 00:17:39,340
文字列下さい。

396
00:17:39,340 --> 00:17:41,430
私は間違って何をしましたか？

397
00:17:41,430 --> 00:17:43,800
こんにちは、バッファ。

398
00:17:43,800 --> 00:17:44,705
こんにちは世界。

399
00:17:44,705 --> 00:17:48,201

400
00:17:48,201 --> 00:17:49,420
ああ、私はそれがやっているか知っています。

401
00:17:49,420 --> 00:17:49,920
OK。

402
00:17:49,920 --> 00:17:51,628
だから、最大読んでいます
最初のスペースまで。

403
00:17:51,628 --> 00:17:55,680
それでは、ちょっとカンニングしましょう​​と
私はちょうど何かを入力したいと言います

404
00:17:55,680 --> 00:18:01,408
本当に長いこれは長文であるように
それは、1つ、2つ、3つ、4つ、5です

405
00:18:01,408 --> 00:18:04,420
6、7、8、9、
10、11、12、13、14、15、16。

406
00:18:04,420 --> 00:18:05,300
OK。

407
00:18:05,300 --> 00:18:07,600
それは確かに長い文です。

408
00:18:07,600 --> 00:18:10,710
したがって、この文はあります
16文字より長いです

409
00:18:10,710 --> 00:18:13,670
そして私は、Enterキーを押したとき
何が起こるだろうか？

410
00:18:13,670 --> 00:18:16,940
さて、この場合、
話、私は宣言していたバッファ

411
00:18:16,940 --> 00:18:22,190
実際には配列であることに
行く準備ができて16文字で。

412
00:18:22,190 --> 00:18:27,426
そのように、一つ、二つ、三つ、四つ、五つ、六つ、
7個、8個、9、10、11、12、13、14、

413
00:18:27,426 --> 00:18:29,440
15、16。

414
00:18:29,440 --> 00:18:34,410
だから16文字、そして今、ときに私
このような何かで読ん長いです

415
00:18:34,410 --> 00:18:43,950
文、何が起こるために起こっていることです
私はこれで読むつもりだということは、長いです

416
00:18:43,950 --> 00:18:49,660
S-E-N-T-E-N-C-E、文。

417
00:18:49,660 --> 00:18:52,270
>> だから、これは意図的です
私は悪いことでは

418
00:18:52,270 --> 00:18:55,060
超えて書き込みを続けます
私の配列の境界、

419
00:18:55,060 --> 00:18:56,660
私のバッファの境界を越えて。

420
00:18:56,660 --> 00:19:00,100
私は幸運を得るとプログラムができました
気に走行を続けるとしません、

421
00:19:00,100 --> 00:19:03,450
一般的に、これを話します
確かに私のプログラムがクラッシュします、

422
00:19:03,450 --> 00:19:06,440
そしてそれは私のバグです
コー​​ド私が足を踏み入れた瞬間

423
00:19:06,440 --> 00:19:08,576
境界を越えて
その配列の、私のため

424
00:19:08,576 --> 00:19:10,450
それはだかどうかを知りません
必ずしもクラッシュに行きます

425
00:19:10,450 --> 00:19:12,120
または私はちょうど幸運取得するつもりだ場合。

426
00:19:12,120 --> 00:19:15,750
だから、これはであるため問題です
この場合は、それが動作するようには思えません

427
00:19:15,750 --> 00:19:20,931
とのにもかかわらず、ここで運命を誘惑しましょう
IDEはかなり耐えているようです

428
00:19:20,931 --> 00:19:21,430
of--

429
00:19:21,430 --> 00:19:22,040
>> そうしよう。

430
00:19:22,040 --> 00:19:23,240
最後に。

431
00:19:23,240 --> 00:19:26,470
だから私はこれを見ることができる唯一の​​人です。

432
00:19:26,470 --> 00:19:29,630
だから、僕は楽しいタイピングがたくさんあり​​ました
本当に長い実際のフレーズアウト

433
00:19:29,630 --> 00:19:32,800
それは確かに超えていること
16バイト、私のため

434
00:19:32,800 --> 00:19:38,050
このクレイジーな長い複数行で入力
フレーズ、次に何が起こったのかがわかります。

435
00:19:38,050 --> 00:19:41,110
プログラムは、それを印刷してみました
して、セグメンテーションフォールトを得ました

436
00:19:41,110 --> 00:19:44,430
そして、セグメンテーションフォールトがあるとき
このような何かが起こります

437
00:19:44,430 --> 00:19:47,650
およびオペレーティング・システムは述べています
いいえ、そのメモリに触れることができません。

438
00:19:47,650 --> 00:19:49,570
私たちは殺すつもりです
完全プログラム。

439
00:19:49,570 --> 00:19:51,180
>> だから、これは問題と思われます。

440
00:19:51,180 --> 00:19:54,540
私はプログラムすることによりを向上させました
少なくともいくつかのメモリを持っています、

441
00:19:54,540 --> 00:19:58,000
これは閉じ込めるように思われます
取得への関数のGetString

442
00:19:58,000 --> 00:20:00,780
いくつかの有限長16の文字列。

443
00:20:00,780 --> 00:20:04,200
だから、長くサポートしたい場合は
16文字以上の文章、

444
00:20:04,200 --> 00:20:04,880
職業はなんですか？

445
00:20:04,880 --> 00:20:07,970
さて、あなたは増やすことができます
32に、このバッファのサイズ

446
00:20:07,970 --> 00:20:09,190
またはその種の短いようです。

447
00:20:09,190 --> 00:20:12,260
なぜ私たちはしないでください
それ千しかし押し戻します。

448
00:20:12,260 --> 00:20:17,100
直感の応答は何ですか
ちょうどすることによってこの問題を回避すること

449
00:20:17,100 --> 00:20:20,660
千文字のような、大きな私のバッファ？

450
00:20:20,660 --> 00:20:23,470
このようにはgetString実装することにより。

451
00:20:23,470 --> 00:20:27,130
ここで良いか悪いかは何ですか？

452
00:20:27,130 --> 00:20:28,033
うん？

453
00:20:28,033 --> 00:20:30,574
聴衆：あなたは多くをバインドする場合
スペースの、あなたはそれを使用しないでください、

454
00:20:30,574 --> 00:20:33,500
あなたはそのスペースを再割り当てすることはできません。

455
00:20:33,500 --> 00:20:34,500
DAVIDマラン：もちろんです。

456
00:20:34,500 --> 00:20:38,480
あなたがいないかのように限り無駄です
実際にそれらのバイトの900を必要とします

457
00:20:38,480 --> 00:20:41,057
まだあなたが求めています
とにかく、合計1,000、

458
00:20:41,057 --> 00:20:44,140
あなただけのより多くのメモリを消費しています
あなたがする必要があるよりも、ユーザーのコンピュータ、

459
00:20:44,140 --> 00:20:45,740
の、すべての後に、いくつかの
あなたは既に遭遇しました

460
00:20:45,740 --> 00:20:47,620
あなたがしていることを生活の中で
プログラムの多くを実行しています

461
00:20:47,620 --> 00:20:50,470
そして、彼らは、多くのメモリを食べています
これは実際にパフォーマンスに影響を与える可能性が

462
00:20:50,470 --> 00:20:52,220
ユーザの経験
コンピューター上で。

463
00:20:52,220 --> 00:20:56,090
だから、怠惰な解決策のようなものです
確かに、逆に、

464
00:20:56,090 --> 00:21:00,140
それだけでなく、無駄だし、何の問題
まだ私は私のバッファを行う場合であっても、残っています

465
00:21:00,140 --> 00:21:02,100
千？

466
00:21:02,100 --> 00:21:02,600
うん？

467
00:21:02,600 --> 00:21:04,475
>> 観客：文字列の長さが1001です。

468
00:21:04,475 --> 00:21:05,350
DAVIDマラン：その通り。

469
00:21:05,350 --> 00:21:08,280
あなたの文字列の長さが1001である場合には、
あなたは正確に同じ問題を抱えています、

470
00:21:08,280 --> 00:21:10,705
そして、私の議論によって、私は希望
ちょうどその2000行い、

471
00:21:10,705 --> 00:21:12,830
しかし、あなたはで知りません
それがどうあるべきか、大きな前進、

472
00:21:12,830 --> 00:21:16,890
まだ、私は私のプログラムをコンパイルする必要があります
人々は使用せ前とダウンロード

473
00:21:16,890 --> 00:21:17,390
それ。

474
00:21:17,390 --> 00:21:21,490
だから、これはまさにの一種であります
スタッフCS50ライブラリ試行します

475
00:21:21,490 --> 00:21:24,750
で私たちを助け、私たちは一目よします
基本となる実装の一部で

476
00:21:24,750 --> 00:21:29,790
ここでは、これはCS50ドットC.です
CS50 IDEにされていたファイルです

477
00:21:29,790 --> 00:21:31,420
あなたが使用してきたこれらのすべての週。

478
00:21:31,420 --> 00:21:34,280
これは、事前にコンパイルだとあなたはしました
自動的にそれを使用して

479
00:21:34,280 --> 00:21:38,780
持っていることの本質的
打ち鳴らすとダッシュのL CS50フラグ、

480
00:21:38,780 --> 00:21:42,300
しかし私は、のすべてを下にスクロールした場合
これらの機能は、ここでのGetStringです、

481
00:21:42,300 --> 00:21:44,636
ちょうどあなた与えるために
何が起こっているの味、

482
00:21:44,636 --> 00:21:46,760
それでは、簡単に見てみましょう
相対的な複雑。

483
00:21:46,760 --> 00:21:48,870
それは超ロングではありません
機能が、我々はしませんでした

484
00:21:48,870 --> 00:21:52,530
すべてのハードについて考える必要があります
どのように文字列を得ることについて移動します。

485
00:21:52,530 --> 00:21:55,660
>> だからここに私のバッファと私です
明らかにNULLに初期化します。

486
00:21:55,660 --> 00:21:57,990
これは、もちろん、あります
char型の星と同じこと、

487
00:21:57,990 --> 00:22:00,585
私はで決めました
CS50ライブラリを実装

488
00:22:00,585 --> 00:22:02,460
我々がしようとしている場合に
完全に動的であること、

489
00:22:02,460 --> 00:22:05,770
私は、どのように大きな事前に知っていません
文字列のユーザーが取得したいとしています。

490
00:22:05,770 --> 00:22:08,140
だから私は開始するつもりです
ちょうど空の文字列

491
00:22:08,140 --> 00:22:11,507
私はできるだけ多くを構築するつもりです
メモリ私は、ユーザーの文字列に合わせて必要があるとして、

492
00:22:11,507 --> 00:22:13,340
私は持っていない場合
十分、私がお願いするつもりです

493
00:22:13,340 --> 00:22:15,010
より多くのメモリは、オペレーティング・システム。

494
00:22:15,010 --> 00:22:17,510
私は彼らの文字列を移動するつもりです
メモリの大きなチャンクへ

495
00:22:17,510 --> 00:22:21,847
私は解放または解放するつもりです
メモリの不十分大きな塊

496
00:22:21,847 --> 00:22:23,680
そして私達はちょうどつもりです
反復これを実行します。

497
00:22:23,680 --> 00:22:25,570
>> だからチラッ、
ここだけの変数です

498
00:22:25,570 --> 00:22:28,780
これで私が追跡するつもりです
私のバッファの容量の。

499
00:22:28,780 --> 00:22:30,071
私はどのように多くのバイトを収めることができますか？

500
00:22:30,071 --> 00:22:32,070
ここで、変数nです
これは私が維持するつもりです

501
00:22:32,070 --> 00:22:36,200
実際にあるバイト数のトラック
バッファまたはユーザが入力したこと。

502
00:22:36,200 --> 00:22:39,900
あなたは、この前に見ていないしている場合
int型のような、その変数を指定することができます

503
00:22:39,900 --> 00:22:46,370
名前が示唆するように、署名され、
それは非負だし、なぜだろうことを意味

504
00:22:46,370 --> 00:22:50,590
私が今までに指定を気にしたいです
intはint型だけではないこと、

505
00:22:50,590 --> 00:22:52,540
それはunsigned int型ですか？

506
00:22:52,540 --> 00:22:55,064
これは、負でない整数です。

507
00:22:55,064 --> 00:22:56,355
[聞こえない]とはどういう意味ですか？

508
00:22:56,355 --> 00:22:58,910
>> 観客：それは量を記述しています
[聞き取れない]ことができるメモリの。

509
00:22:58,910 --> 00:22:59,660
>> DAVIDマラン：うん。

510
00:22:59,660 --> 00:23:03,710
私は、符号なしと言うのであれば、これは実際にあります
あなたに余分なメモリの1ビットを与えます

511
00:23:03,710 --> 00:23:07,440
それは一種の愚かなようだが、あなたの場合
追加のメモリの1ビットを持っていること

512
00:23:07,440 --> 00:23:09,940
あなたが二倍のを持っていることを意味し
あなたが表現できる値は、

513
00:23:09,940 --> 00:23:11,570
それは、0または1であることができるからです。

514
00:23:11,570 --> 00:23:14,660
だから、デフォルトで、int型は、およそすることができます
負の20億のすべての方法

515
00:23:14,660 --> 00:23:16,030
正の20億まで。

516
00:23:16,030 --> 00:23:18,540
これらは大きな範囲ですが、
それはまだ種類の無駄です

517
00:23:18,540 --> 00:23:21,280
あなただけ心配している場合
ただ直感的なサイズ、

518
00:23:21,280 --> 00:23:24,620
非負でなければなりませんか
正または0、よくして、

519
00:23:24,620 --> 00:23:28,884
なぜあなたは20億を無駄にしています
負の数の可能な値

520
00:23:28,884 --> 00:23:30,300
あなたがそれらを使用するつもりはありませんしている場合は？

521
00:23:30,300 --> 00:23:35,350
符号なしと言ってだから、今、私のINTができます
0とおよそ40億の間であること。

522
00:23:35,350 --> 00:23:39,280
>> だからここに理由のためだけでint型のCです
私たちは今のように得ることはありません

523
00:23:39,280 --> 00:23:42,280
それは代わりにint型だ理由
チャーのが、ここにあります

524
00:23:42,280 --> 00:23:44,630
何が起こっているの要旨
あなたの、そしていくつかの

525
00:23:44,630 --> 00:23:48,340
例えば、使用している場合があります、
でもPSET 4でのfgetc関数

526
00:23:48,340 --> 00:23:51,580
またはその後、我々はそれを参照してくださいよ
再び問題に5を設定し、

527
00:23:51,580 --> 00:23:55,410
fgetc関数が原因の名前としていいです
種類の、一種のarcanely示唆しています、

528
00:23:55,410 --> 00:23:57,940
その関数です
、文字を取得しますので、

529
00:23:57,940 --> 00:24:00,690
根本的に異なる何
私たちはのGetStringでやっていることについて

530
00:24:00,690 --> 00:24:03,110
私たちが使用していないです
同じ方法でのscanf。

531
00:24:03,110 --> 00:24:07,550
私達はちょうどステップバイステップに沿って忍び寄るされています
何を介してユーザが入力した中で、

532
00:24:07,550 --> 00:24:10,970
私たちは常に1を割り当てることができるため、
char型、そして私たちは常に安全にすることができます

533
00:24:10,970 --> 00:24:15,599
一度に一つの文字を見て、
マジックはここに起こることを開始します。

534
00:24:15,599 --> 00:24:17,890
私はまでスクロールするつもりです
この関数の途中

535
00:24:17,890 --> 00:24:20,360
ただ簡単にこの機能を導入します。

536
00:24:20,360 --> 00:24:22,670
多くありますように
malloc関数は、あります

537
00:24:22,670 --> 00:24:27,740
realloc関数のrealloc
あなたは、メモリのチャンクを再割り当てすることができます

538
00:24:27,740 --> 00:24:29,570
それが大きくなったり小さくします。

539
00:24:29,570 --> 00:24:33,060
だから、長い話短いとと
今日は私の手の波、

540
00:24:33,060 --> 00:24:35,620
その何のGetStringを知っています
やっている、それは一種ですで

541
00:24:35,620 --> 00:24:39,720
魔法の成長または
ユーザーとしてのバッファを縮小

542
00:24:39,720 --> 00:24:41,440
彼または彼女の文字列内の型。

543
00:24:41,440 --> 00:24:43,962
>> もしそうであれば、ユーザーの種類
短い文字列、このコード

544
00:24:43,962 --> 00:24:45,920
十分なだけを割り当て
文字列に合わせてメモリ。

545
00:24:45,920 --> 00:24:48,086
ユーザーが入力を続ける場合
私は何度も何度もそれをやったとして

546
00:24:48,086 --> 00:24:50,330
そして再び、よく、場合
バッファの最初に、この大きな

547
00:24:50,330 --> 00:24:53,310
プログラムはに、実現します
私は宇宙の外だけど、ちょっと待って、

548
00:24:53,310 --> 00:24:55,410
それは倍増するだろう
バッファのサイズ

549
00:24:55,410 --> 00:24:59,110
そして、バッファのサイズを2倍
そして、倍増を実行するコード、

550
00:24:59,110 --> 00:25:03,170
我々はここでそれを見れば、それはです
ちょうどこの賢いワンライナー。

551
00:25:03,170 --> 00:25:06,830
あなたはこの構文を見たことがない可能性があります
前、しかし、あなたは星が等しいと言えば、

552
00:25:06,830 --> 00:25:10,470
これは同じものです
容量2倍を言って。

553
00:25:10,470 --> 00:25:13,390
だから、ちょうど倍増し続けます
バッファの容量

554
00:25:13,390 --> 00:25:17,480
して、与えることのreallocを伝えます
自身その多くのメモリ。

555
00:25:17,480 --> 00:25:19,720
>> さて、余談ですが、そこのように
その他の機能は、ここにあります

556
00:25:19,720 --> 00:25:23,680
我々はすべての詳細に見ていないということ
GetIntでに表示する以外に、

557
00:25:23,680 --> 00:25:26,150
私たちは、GetIntで中のGetStringを使用しています。

558
00:25:26,150 --> 00:25:28,192
我々はそれがないことを確認してください
ヌル、これは、リコール、

559
00:25:28,192 --> 00:25:30,400
その特別な値です
何かが間違っていたことを意味します。

560
00:25:30,400 --> 00:25:31,233
私たちは、メモリが不足しています。

561
00:25:31,233 --> 00:25:32,310
より良いことを確認してください。

562
00:25:32,310 --> 00:25:33,710
そして、我々はセンチネル値を返します。

563
00:25:33,710 --> 00:25:37,850
しかし、私はのようなコメントに従います
なぜ、我々はscanf関数のこのいとこを使用

564
00:25:37,850 --> 00:25:42,100
sscanf関数と呼ばれ、それが判明
そのsscanf関数、または文字列のscanf、

565
00:25:42,100 --> 00:25:45,310
あなたがその行を見てみましょう
ユーザーは、で入力し、あなたを聞かせています

566
00:25:45,310 --> 00:25:49,610
基本的にそれを分析し、私は何を
ここで行って、私はsscanf関数を言っているが、

567
00:25:49,610 --> 00:25:54,440
ユーザーが持っているどのような分析
入力し、確認してください％の私を作ります、

568
00:25:54,440 --> 00:25:59,250
そこでの整数であり、私たちはしません
あります正確な理由今日に入ります

569
00:25:59,250 --> 00:26:03,760
一言で言えば％のここでC、それが可能に
私たちユーザーが入力したかどうかを検出します

570
00:26:03,760 --> 00:26:06,050
番号の後に偽のものです。

571
00:26:06,050 --> 00:26:11,766
だから理由はGetIntでとのGetString
再試行、再試行するように指示、再試行

572
00:26:11,766 --> 00:26:13,640
理由のすべてであります
私たちが書いたそのコード、

573
00:26:13,640 --> 00:26:17,900
それは種類のユーザーの入力を見ています
確認することで、それは完全に数値です

574
00:26:17,900 --> 00:26:21,700
またはそれは、実際の浮動です
ポイント値等

575
00:26:21,700 --> 00:26:24,233
どのような値に応じて
あなたが使用している機能。

576
00:26:24,233 --> 00:26:25,060
>> やれやれ。

577
00:26:25,060 --> 00:26:25,710
OK。

578
00:26:25,710 --> 00:26:27,592
それは一口ました
しかし、ここでのポイントは、

579
00:26:27,592 --> 00:26:29,550
私達が持っていた理由は
これらの補助輪の

580
00:26:29,550 --> 00:26:32,880
なぜなら最低レベルであり、
それだけで非常に多くのものがあります

581
00:26:32,880 --> 00:26:35,674
我々が望んでいたことを間違って行くことができます
先制処理します

582
00:26:35,674 --> 00:26:38,090
確かにそれらのもので
クラスの初期の数週間、

583
00:26:38,090 --> 00:26:42,230
今PSET 4とPSET 5とし、
越えてあなたはそれがわたしの多くはでていることがわかります

584
00:26:42,230 --> 00:26:45,570
あなたも、あなたはより多くのことが可能です
問題のこれらの種類を解決します

585
00:26:45,570 --> 00:26:47,180
自分自身。

586
00:26:47,180 --> 00:26:51,770
GetStringまたはGetIntでのご質問？

587
00:26:51,770 --> 00:26:52,630
うん？

588
00:26:52,630 --> 00:26:55,130
>> 聴衆：なぜあなたは倍増します
バッファの容量

589
00:26:55,130 --> 00:26:57,630
だけではなく増加
それ正確な量だけ？

590
00:26:57,630 --> 00:26:58,100
>> DAVIDマラン：良い質問。

591
00:26:58,100 --> 00:27:00,474
なぜ我々は能力を倍増します
対照的に、バッファの

592
00:27:00,474 --> 00:27:02,800
それを増加させることに
いくつかの定数値で？

593
00:27:02,800 --> 00:27:03,900
これは、設計上の決定でした。

594
00:27:03,900 --> 00:27:08,590
私達はちょうどそれがする傾向があるためと判断しました
時間的に高価な少し依頼すること

595
00:27:08,590 --> 00:27:10,440
オペレーティング・システム
メモリのために、私たちはしませんでした

596
00:27:10,440 --> 00:27:13,210
なってしまうしたいです
大きな文字列の状況

597
00:27:13,210 --> 00:27:14,960
我々は求めていたこと
何度も何度もOS

598
00:27:14,960 --> 00:27:17,500
そして、何度も何度もで
メモリの矢継ぎ早。

599
00:27:17,500 --> 00:27:20,387
だから我々は単に多少、決定しました
任意に我々は合理的に願って、

600
00:27:20,387 --> 00:27:22,720
それは、あなたが、してみましょう知っています
先に自分の取得しようとします

601
00:27:22,720 --> 00:27:25,520
ちょうどようにそれを倍に保ちます
我々は倍の量を最小限に抑えます

602
00:27:25,520 --> 00:27:29,010
我々はmalloc関数を呼び出す必要がありますか
reallocのが、総合判定

603
00:27:29,010 --> 00:27:31,820
知っての不存在下で呼び出します
どのユーザーが入力する必要がある場合があります。

604
00:27:31,820 --> 00:27:33,600
どちらの方法は、議論の余地がある可能性があります。

605
00:27:33,600 --> 00:27:35,430
間違いなく良いです。

606
00:27:35,430 --> 00:27:39,240
>> それでは、カップルを見てみましょう
メモリの他の副作用の、

607
00:27:39,240 --> 00:27:41,610
間違って行くことができるもの
およびツールのことができます。

608
00:27:41,610 --> 00:27:43,880
ミスのこれらの種類をキャッチするために使用します。

609
00:27:43,880 --> 00:27:47,800
それにもかかわらず、あなたのすべてが判明
check50は、同じくらいあなたに言っていません

610
00:27:47,800 --> 00:27:50,050
バギーを書いています
1週間以降のコード、

611
00:27:50,050 --> 00:27:53,630
すべてcheck50のテストがある場合でも、
渡され、場合でも、あなたとあなたのTF

612
00:27:53,630 --> 00:27:56,010
その超自信を持っています
意図したとおりに、あなたのコードが動作します。

613
00:27:56,010 --> 00:27:59,190
あなたのコードにバグがされていますか
あなたのすべてに欠陥、

614
00:27:59,190 --> 00:28:02,540
CS50ライブラリを使用して、
メモリリークされています。

615
00:28:02,540 --> 00:28:06,040
あなたは、オペレーティングシステムを求めてきました
プログラムのほとんどのメモリのための

616
00:28:06,040 --> 00:28:08,850
あなたが書いたが、あなたはしました
実際にそれをバック与えられたことはありません。

617
00:28:08,850 --> 00:28:12,110
あなたはのGetStringと呼ばれてきました
GetIntでとはGetFloatと、

618
00:28:12,110 --> 00:28:15,270
しかしのGe​​tStringで、あなたはしました
unGetStringまたは与えると呼ばれることはありません

619
00:28:15,270 --> 00:28:19,890
文字列バックなどが、私たちは見てきました
GetStringは、メモリを割り当てないこと

620
00:28:19,890 --> 00:28:22,810
malloc関数の方法またはこれによります
ちょうどである関数のrealloc、

621
00:28:22,810 --> 00:28:25,670
精神が非常に類似し、
まだ、我々がしてきました

622
00:28:25,670 --> 00:28:28,629
オペレーティングシステムに依頼
メモリとメモリ、何度も何度も

623
00:28:28,629 --> 00:28:29,670
しかし、それをバック与えることはありません。

624
00:28:29,670 --> 00:28:33,550
>> さて、余談として、それはことが判明
プログラムは、メモリのすべてを終了したとき

625
00:28:33,550 --> 00:28:34,870
自動的に解放されます。

626
00:28:34,870 --> 00:28:36,150
だから、大きな問題となっていません。

627
00:28:36,150 --> 00:28:38,590
それは破ることはないだろう
IDEまたは遅くします、

628
00:28:38,590 --> 00:28:40,670
しかし、プログラムが行うとき
一般に、メモリリークが発生

629
00:28:40,670 --> 00:28:42,170
そして、彼らは長い時間のために実行しています。

630
00:28:42,170 --> 00:28:45,640
あなたは愚かな少しを見てきた場合
MacのOSや砂時計のビーチボール

631
00:28:45,640 --> 00:28:51,160
それは一種のだWindows上で
減速や思考や思考

632
00:28:51,160 --> 00:28:53,770
または本当に開始
クロールに遅くします、

633
00:28:53,770 --> 00:28:56,960
それは非常に可能性があることができ
メモリリークの結果。

634
00:28:56,960 --> 00:28:59,970
書いたプログラマー
あなたが使用しているソフトウェア

635
00:28:59,970 --> 00:29:03,570
メモリは、オペレーティングシステムに依頼
数分ごと、時間ごと。

636
00:29:03,570 --> 00:29:05,570
しかし、あなたが実行している場合
それはだ場合であっても、ソフトウェア、

637
00:29:05,570 --> 00:29:08,680
お使いのコンピュータに最小化
最後の数時間から数日のために、

638
00:29:08,680 --> 00:29:11,980
あなたはより多くを求めることがあります
メモリと、実際にそれを使用することはありません

639
00:29:11,980 --> 00:29:15,180
ので、あなたのコードがあること、または可能性があります
プログラムは、メモリリーク可能性があります

640
00:29:15,180 --> 00:29:18,350
あなたがメモリリークが発生し始めた場合、
他のプログラムのための少ないメモリがあると、

641
00:29:18,350 --> 00:29:21,220
効果はです
すべてが遅くなります。

642
00:29:21,220 --> 00:29:23,600
>> さて、これは断然の1であります
最も残虐なプログラム

643
00:29:23,600 --> 00:29:26,350
あなたは機会を持つことになります
CS50で実行する限り、

644
00:29:26,350 --> 00:29:31,650
その出力はよりもさらに難解であるとして、
打ち鳴らすのか、のをするか、またはコマンドのいずれか

645
00:29:31,650 --> 00:29:35,930
私たちは前に実行したラインプログラムが、
ありがたいことに、その出力に埋め込まれました

646
00:29:35,930 --> 00:29:39,810
いくつかの超便利なヒントであります
いずれかのpset 4のために有用であろう

647
00:29:39,810 --> 00:29:41,510
または確かに5をPSET。

648
00:29:41,510 --> 00:29:44,250
だから、valgrindのツールです
それを見るために使用することができ

649
00:29:44,250 --> 00:29:46,930
あなたのプログラムでメモリリークのため。

650
00:29:46,930 --> 00:29:48,570
これは、実行するのは比較的簡単です。

651
00:29:48,570 --> 00:29:51,420
あなたも、valgrindの、次に実行します
それは少し冗長ですけれども、

652
00:29:51,420 --> 00:29:54,440
ダッシュダッシュリークチェック
ドットその後完全に等しく、

653
00:29:54,440 --> 00:29:56,320
スラッシュとあなたのプログラムの名前。

654
00:29:56,320 --> 00:30:00,010
だから、valgrindのは、あなたのプログラムを実行します
そしてあなたのプログラムの最後に

655
00:30:00,010 --> 00:30:02,240
それが終了する前に実行し、
あなたに別のプロンプトを与え、

656
00:30:02,240 --> 00:30:04,980
それはあなたを分析するために起こっています
プログラムは実行されている間

657
00:30:04,980 --> 00:30:07,740
あなたが漏れたことを伝えます
いっその任意のメモリと、

658
00:30:07,740 --> 00:30:10,610
あなたはそのメモリに触れませんでした
あなたに属していたのですか？

659
00:30:10,610 --> 00:30:13,700
それはすべてをキャッチすることはできませんが、それはです
ほとんどのものをキャッチでかなり良いです。

660
00:30:13,700 --> 00:30:19,700
>> だからここに私の持つランの例を示します。
このプログラムは、実行valgrindのを持ちます、

661
00:30:19,700 --> 00:30:21,470
呼ばれるプログラムに
メモリ、私は行きますよ

662
00:30:21,470 --> 00:30:24,730
ある行を強調表示します
最終的に私たちに興味のあります。

663
00:30:24,730 --> 00:30:27,690
だから、さらに気晴らしがあります
私は、スライドから削除したこと。

664
00:30:27,690 --> 00:30:30,930
しかしちょうど何これを見てみましょう
プログラムは、私たちに伝えることが可能です。

665
00:30:30,930 --> 00:30:34,800
それは私たちのことを伝えることが可能です
サイズ4の無効な書き込みなどがあります。

666
00:30:34,800 --> 00:30:38,020
つまり、あなたがメモリに触れる場合には、
メモリの特に4バイト

667
00:30:38,020 --> 00:30:40,350
あなたが持っているべきではないと、
valgrindのはあなたにそれを伝えることができます。

668
00:30:40,350 --> 00:30:41,660
サイズ4の不正な書き込み。

669
00:30:41,660 --> 00:30:43,640
あなたは4バイトに触れました
あなたが持っているべきではないこと。

670
00:30:43,640 --> 00:30:44,840
あなたはそれをどこで行うのですか？

671
00:30:44,840 --> 00:30:45,900
これは美しさです。

672
00:30:45,900 --> 00:30:50,000
どこメモリドットC線21があります
めちゃくちゃ、それは便利です理由です。

673
00:30:50,000 --> 00:30:53,410
多くのGDBのように、それは助けることができます
実際のエラーであなたをポイントします。

674
00:30:53,410 --> 00:30:57,170
>> さて、これはもう少しです
冗長な、そうでない場合は混乱を招きます。

675
00:30:57,170 --> 00:31:01,307
1ブロック内の40バイトは間違いなくあります
1の損失レコード1で失われました。

676
00:31:01,307 --> 00:31:02,140
どういう意味ですか？

677
00:31:02,140 --> 00:31:05,920
まあ、それはちょうどあなたが尋ねたことを意味します
40バイトと、あなたはそれを返したことはありません。

678
00:31:05,920 --> 00:31:08,930
あなたは、malloc関数と呼ばれるか、と呼ばれます
GetStringおよびオペレーティングシステム

679
00:31:08,930 --> 00:31:12,450
あなたに40バイトを与えたが、あなたは決して
解放されたか、そのメモリを解放し、

680
00:31:12,450 --> 00:31:15,400
かつ公正であることを、我々は示したことがありません
あなたはどのようにメモリをお返しします。

681
00:31:15,400 --> 00:31:17,910
判明スーパーがあります
シンプルな機能は無料と呼ばれます。

682
00:31:17,910 --> 00:31:21,170
一つの引数、ものを取り
あなたは、解放するかお返ししたいです

683
00:31:21,170 --> 00:31:23,430
しかし、40バイト、明らかに、
このプログラムで

684
00:31:23,430 --> 00:31:27,300
ラインで失われています
メモリドットcの20。

685
00:31:27,300 --> 00:31:28,650
>> それでは、このプログラムを見てみましょう。

686
00:31:28,650 --> 00:31:31,020
これは、スーパー無用です。

687
00:31:31,020 --> 00:31:33,980
それが唯一の実証します
この特定のエラー。

688
00:31:33,980 --> 00:31:34,920
それでは、見てみましょう。

689
00:31:34,920 --> 00:31:39,920
ここでは、メインとメインで、気づく、呼び出し
関数をfと呼ばれ、その後、戻ります。

690
00:31:39,920 --> 00:31:41,550
だから、すべてが面白くありません。

691
00:31:41,550 --> 00:31:42,664
fは何をするのでしょうか？

692
00:31:42,664 --> 00:31:44,330
私はプロトタイプを気にしませんでした注意してください。

693
00:31:44,330 --> 00:31:46,520
私は、コードを維持したいです
できるだけ最小限。

694
00:31:46,520 --> 00:31:49,530
だから私は、メインの上にFを入れて、
それは確かに、大丈夫です、

695
00:31:49,530 --> 00:31:51,500
このような短いプログラムのため。

696
00:31:51,500 --> 00:31:56,910
だから、fは何も返していません。
何かを取るが、それはこれを実行しません。

697
00:31:56,910 --> 00:31:59,620
それは多くのと同じように、宣言します
Binkyの例では、

698
00:31:59,620 --> 00:32:02,682
起こっているXと呼ばれるポインタ
int型のアドレスを格納します。

699
00:32:02,682 --> 00:32:03,890
だから、左側です。

700
00:32:03,890 --> 00:32:07,230
英語では、何があります
右辺はやって？

701
00:32:07,230 --> 00:32:09,770
誰ですか？

702
00:32:09,770 --> 00:32:13,665
これは私たちのために何をしているのですか？

703
00:32:13,665 --> 00:32:14,651
うん？

704
00:32:14,651 --> 00:32:16,623
>> 聴衆：[聞こえません]
回int型のサイズ

705
00:32:16,623 --> 00:32:19,175
である10倍[聞こえません]

706
00:32:19,175 --> 00:32:20,800
DAVIDマラン：良いと私はまとめてみましょう。

707
00:32:20,800 --> 00:32:25,480
だから10の整数のための十分なスペースを割り当てます
または10、int型のサイズは何ですか、

708
00:32:25,480 --> 00:32:29,340
それがされている4バイトなので、10回4
40、私はきたように右側

709
00:32:29,340 --> 00:32:33,930
ハイライトされた私に40バイトを与えるとあります
最初のバイトのアドレスを格納

710
00:32:33,930 --> 00:32:34,940
Xへ。

711
00:32:34,940 --> 00:32:38,380
そして今、最後に、ここどこです
このプログラムは、バグが、何

712
00:32:38,380 --> 00:32:41,540
そのロジックに基づいて、ライン21と間違って？

713
00:32:41,540 --> 00:32:45,197

714
00:32:45,197 --> 00:32:46,280
何がライン21と間違っていますか？

715
00:32:46,280 --> 00:32:46,780
うん？

716
00:32:46,780 --> 00:32:49,550
聴衆：あなたがすることはできません
Xへのインデックス[聞こえません]。

717
00:32:49,550 --> 00:32:50,300
DAVIDマラン：うん。

718
00:32:50,300 --> 00:32:52,270
私はそのようなXのインデックスいけません。

719
00:32:52,270 --> 00:32:53,850
だから構文的に、それは大丈夫です。

720
00:32:53,850 --> 00:32:56,990
何すてきなのははるかにあなたのように、あります
配列の名前を扱うことができます

721
00:32:56,990 --> 00:33:01,080
それは同様に、ポインタだかのように
それはだかのように、あなたはポインタを扱うことができます

722
00:33:01,080 --> 00:33:06,425
アレイと、私は構文的にすることができます
Xブラケット何かを言う、XブラケットI、

723
00:33:06,425 --> 00:33:07,800
しかし10には問題があります。

724
00:33:07,800 --> 00:33:09,096
なぜ？

725
00:33:09,096 --> 00:33:10,910
>> 観客：それは内部にはありませんので。

726
00:33:10,910 --> 00:33:12,390
>> DAVIDマラン：それはありません
メモリのチャンク内部。

727
00:33:12,390 --> 00:33:15,306
最大値は、私は何をする必要があります
これらの角括弧内に入れてこと？

728
00:33:15,306 --> 00:33:16,870
9、0〜9。

729
00:33:16,870 --> 00:33:18,160
ゼロのインデックス作成のため。

730
00:33:18,160 --> 00:33:20,190
だから、0〜9は大丈夫だと思います。

731
00:33:20,190 --> 00:33:23,960
ブラケット10が良好でないと
しかし、しかし毎回思い出します

732
00:33:23,960 --> 00:33:27,017
私はCS50 IDEを作ってみるように見えます
偽の値を入力してクラッシュ、

733
00:33:27,017 --> 00:33:29,100
それは常に、協力しません
実際に、あなたのことが多いです

734
00:33:29,100 --> 00:33:31,460
幸運を得るという理由だけで
オペレーティングシステムがありません

735
00:33:31,460 --> 00:33:35,467
予告ほんの少しあなた
メモリーの一部のチャンクを渡し、

736
00:33:35,467 --> 00:33:38,300
あなたが技術的に内滞在理由
あなたのセグメントが、よりその上

737
00:33:38,300 --> 00:33:40,940
オペレーティング・システムのクラスで、
ので、このような何か

738
00:33:40,940 --> 00:33:43,000
非常に簡単に検出されない行くことができます。

739
00:33:43,000 --> 00:33:48,120
あなたのプログラムがクラッシュするつもりはありませんです
一貫多分一度しばらくインチ

740
00:33:48,120 --> 00:33:50,610
>> そしてそうのはvalgrindのを試してみましょう
このため、ここでの上

741
00:33:50,610 --> 00:33:52,870
ここで、我々は圧倒されるだろう
出力によって一瞬。

742
00:33:52,870 --> 00:34:00,810
だから、メモリvalgrindのリークチェックを行います
フルドットスラッシュメモリに等しいです。

743
00:34:00,810 --> 00:34:03,040
私は約束する理由そして、ここです
これは圧倒だろう。

744
00:34:03,040 --> 00:34:05,700
ここでvalgrindの、ここで何だ何です
プログラマ、何年かago-

745
00:34:05,700 --> 00:34:08,469
それは良いでしょうことを決めました
出力は次のようにするため。

746
00:34:08,469 --> 00:34:09,750
それでは、この感覚を作ってみましょう。

747
00:34:09,750 --> 00:34:13,120
左側のだからすべての方法
正当な理由なくするための側面

748
00:34:13,120 --> 00:34:16,620
プログラムのプロセスIDであります
私たちは、一意の識別子を実行

749
00:34:16,620 --> 00:34:18,030
プログラムのため、私たちはただ走りました。

750
00:34:18,030 --> 00:34:19,738
我々は、からそれを削除しました
スライドが、そこ

751
00:34:19,738 --> 00:34:22,190
ここでいくつかの有用な情報があります。

752
00:34:22,190 --> 00:34:24,684
>> のは非常にトップまでスクロールしてみましょう。

753
00:34:24,684 --> 00:34:25,600
私たちが始めたのはここです。

754
00:34:25,600 --> 00:34:27,040
だから、すべてがはるかに出力されないのです。

755
00:34:27,040 --> 00:34:30,429
ここでは、無効な書き込みです
ライン21上のサイズ4の。

756
00:34:30,429 --> 00:34:31,760
まあ、ライン21は何でしたか？

757
00:34:31,760 --> 00:34:34,500
21行目は、正確でした
この、それは理にかなっています

758
00:34:34,500 --> 00:34:37,290
私は正当にいること
私はだから4バイトを書きます

759
00:34:37,290 --> 00:34:40,389
この整数を入れしようとすると、
これは何もすることができ、

760
00:34:40,389 --> 00:34:42,370
それだけであることを起こります
ゼロが、私はしようとしています

761
00:34:42,370 --> 00:34:44,940
場所でそれを置くために
それは私に属していません。

762
00:34:44,940 --> 00:34:50,900
また、ダウンここでは、1で40バイト
ブロックは、間違いなく、レコード1に失われます。

763
00:34:50,900 --> 00:34:56,500
私はmalloc関数を呼び出すときからです
ここで、私が実際にメモリを解放することはありません。

764
00:34:56,500 --> 00:34:58,140
>> では、どのように我々はこの問題を解決することができますか？

765
00:34:58,140 --> 00:35:02,970
私が先に行くと少しより安全であるとします
そしてそこに9を行うと、ここで無料のxをさせて頂きます。

766
00:35:02,970 --> 00:35:04,820
これは、今日のための新しい機能です。

767
00:35:04,820 --> 00:35:11,520
私は今、メモリドットスラッシュを作る再実行すると、
、のは、再びその上でValgrindは実行してみましょう

768
00:35:11,520 --> 00:35:14,990
私のウィンドウを最大化し、Enterキーを押します。

769
00:35:14,990 --> 00:35:16,900
さて、それは良いことです。

770
00:35:16,900 --> 00:35:19,590
彼らは良いニュースを埋めます
この出力のすべてインチ

771
00:35:19,590 --> 00:35:20,810
すべてのヒープブロックは自由でした。

772
00:35:20,810 --> 00:35:23,604
私たちは、どのようなヒープに戻ってきます
ですが、漏れはできません。

773
00:35:23,604 --> 00:35:25,520
だから、これはただのです
あなたのツールキットのためのツール

774
00:35:25,520 --> 00:35:30,220
これであなたは、に開始することができます
今そのようなエラーを見つけます。

775
00:35:30,220 --> 00:35:34,532
>> しかし、それでは、何を見てみましょう
もっと間違ってここに行くことができます。

776
00:35:34,532 --> 00:35:38,890
今までの移行をしてみましょう
実際に問題を解決します。

777
00:35:38,890 --> 00:35:42,440
余談として、これが緩和する場合
混乱や緊張を少し、

778
00:35:42,440 --> 00:35:43,430
これは今面白いです。

779
00:35:43,430 --> 00:35:46,400

780
00:35:46,400 --> 00:35:46,900
うん。

781
00:35:46,900 --> 00:35:49,040
これはかなり良いです。

782
00:35:49,040 --> 00:35:50,890
ポインタであるため
アドレスとアドレス

783
00:35:50,890 --> 00:35:53,098
慣例により、一般的に
進で書かれました。

784
00:35:53,098 --> 00:35:54,650
ハ、ハ、これは今面白いです。

785
00:35:54,650 --> 00:35:58,390
とにかく、今してみましょう
実際に問題を解決します。

786
00:35:58,390 --> 00:36:00,840
これは、超となっています
これまでの超低レベル​​、

787
00:36:00,840 --> 00:36:03,950
私たちは実際に便利を行うことができます
これらの低レベルの詳細との事。

788
00:36:03,950 --> 00:36:06,710
>> だから我々は数週間を導入しました
前配列の概念。

789
00:36:06,710 --> 00:36:09,177
配列は良かったので、
それは私たちのコードをクリーンアップするのは難しいです

790
00:36:09,177 --> 00:36:11,760
私たちが書きたい場合のため
複数の学生とプログラム

791
00:36:11,760 --> 00:36:15,270
または複数の名前と家と
寮や大学とすべてのこと、

792
00:36:15,270 --> 00:36:19,430
我々はより多くのすべてを記憶することができます
きれいに配列の内部。

793
00:36:19,430 --> 00:36:23,039
しかし、一つの欠点を提案
配列のこれまで。

794
00:36:23,039 --> 00:36:26,080
あなたはそれを自分で苦しんでいませんでした場合でも、
プログラムで、ただ本能的に、

795
00:36:26,080 --> 00:36:30,870
悪いことは何ですか
配列については、おそらく？

796
00:36:30,870 --> 00:36:32,337
私はいくつかの雑音が聞こえます。

797
00:36:32,337 --> 00:36:34,170
観客：それは難しいです
サイズを変更します。

798
00:36:34,170 --> 00:36:36,128
DAVIDマラン：それは難しいです
サイズを変更します。

799
00:36:36,128 --> 00:36:38,660
あなたは、サイズを変更することはできません
配列の、実際には、それ自体

800
00:36:38,660 --> 00:36:43,040
Cであなたは他の配列を割り当てることができ、
古いものからすべてを移動します

801
00:36:43,040 --> 00:36:45,380
新しい、およびへ
いくつかの余分なスペースを持って、

802
00:36:45,380 --> 00:36:47,469
それはようではありません
JavaやPythonのような言語

803
00:36:47,469 --> 00:36:49,760
または他の任意の数
言語あなたのいくつかの

804
00:36:49,760 --> 00:36:52,070
どこに精通しているかもしれません
物事を追加し続けることができます

805
00:36:52,070 --> 00:36:53,930
配列の最後にうんざり。

806
00:36:53,930 --> 00:36:57,880
あなたはの配列を持っている場合
そのサイズでサイズ6、

807
00:36:57,880 --> 00:37:01,970
そして、考え、以前のようなので、多くの
特定のサイズのバッファを有します

808
00:37:01,970 --> 00:37:05,940
あなたは、ゲートの外に推測する必要が
どのようなサイズ、あなたはそれになりたいですか？

809
00:37:05,940 --> 00:37:07,880
あなたが大きすぎる推測した場合、
あなたは、スペースを無駄にしています。

810
00:37:07,880 --> 00:37:10,950
あなたが小さすぎる推測した場合、
少なくとも、そのデータを格納することはできません

811
00:37:10,950 --> 00:37:12,940
より多くの作業をせずに。

812
00:37:12,940 --> 00:37:18,180
>> だから、今日、ポインタのおかげで、我々はできます
一緒に私たちの独自のカスタムステッチ開始

813
00:37:18,180 --> 00:37:20,989
データ構造などで
実際、ここで何かあります

814
00:37:20,989 --> 00:37:23,030
それがもう少し見えます
一見不可解な、

815
00:37:23,030 --> 00:37:26,440
しかし、これは我々がリンクを呼ぶものです
リスト、そしてまとめたもので、その名前の種類

816
00:37:26,440 --> 00:37:26,940
それ。

817
00:37:26,940 --> 00:37:29,550
これは、番号のリストです、またはで
この場合、番号のリスト、

818
00:37:29,550 --> 00:37:33,480
それが何のリストではなく、可能性
それは、一緒に矢印によって連結されたです

819
00:37:33,480 --> 00:37:36,380
ちょうど推測を取ります
どの技術に

820
00:37:36,380 --> 00:37:38,310
我々ができるようにするつもりされています
一緒にステッチするために、

821
00:37:38,310 --> 00:37:42,540
ソートの糸でポップコーンのように、
リンクされたリストはここに長方形？

822
00:37:42,540 --> 00:37:43,936
その数字？

823
00:37:43,936 --> 00:37:45,560
基本となる言語機能とは何ですか？

824
00:37:45,560 --> 00:37:46,350
>> 聴衆：ポインタ。

825
00:37:46,350 --> 00:37:47,308
>> DAVIDマラン：ポインタ。

826
00:37:47,308 --> 00:37:51,700
そこでここではこれらの矢印のそれぞれが表します
ポインタやアドレスだけ。

827
00:37:51,700 --> 00:37:54,590
だから、他の言葉で、私がしたい場合
番号のリストを格納します、

828
00:37:54,590 --> 00:37:59,040
私がしたい場合、私はそれを格納することはできません
成長し、縮小する機能

829
00:37:59,040 --> 00:38:00,990
配列内の私のデータ構造。

830
00:38:00,990 --> 00:38:03,000
だから私は少しを持っている必要があります
より洗練され、

831
00:38:03,000 --> 00:38:05,720
しかし、このことに気づきます
画像種類の示唆

832
00:38:05,720 --> 00:38:08,650
あなたはほんの少しのスレッドを持っている場合に
一緒にすべてを接続し、

833
00:38:08,650 --> 00:38:13,100
おそらく、スペースを作るために、その難しいことではありません
これらの長方形の二つの間にあります

834
00:38:13,100 --> 00:38:16,750
それらのノードまたは2つ、私たちは始めましょうとして
新しいノードに入れ、それらを呼び出すと、

835
00:38:16,750 --> 00:38:19,547
して、いくつかの新しいスレッドと、ちょうど
一緒に3つのノードを捨てます、

836
00:38:19,547 --> 00:38:22,880
最初の、最後の、そして1
あなただけの途中に挿入していること。

837
00:38:22,880 --> 00:38:26,000
>> そして実際にリンクされたリスト、
配列とは異なり、動的です。

838
00:38:26,000 --> 00:38:27,840
それは、成長することができ、それがすることができます
縮小し、あなたはしないでください

839
00:38:27,840 --> 00:38:32,434
どのように、事前に知っているか気にする必要があります
多くのデータは、あなたが保存することになるだろう、

840
00:38:32,434 --> 00:38:35,600
しかし、それは我々が少しでなければならない判明します
これを実装する方法については慎重に。

841
00:38:35,600 --> 00:38:39,070
したがって、最初の我々は実装方法考えてみましょう
これらの小さな長方形の一つ。

842
00:38:39,070 --> 00:38:40,690
これは、int型を実装するのは簡単です。

843
00:38:40,690 --> 00:38:44,000
あなたはちょうどそのint型nと言います
あなたはint型のために4バイトを取得し、

844
00:38:44,000 --> 00:38:49,089
しかし、どのように私はint型を得るのですか、それを呼び出すnは、
して、ポインタは、のは次のことを呼びましょう。

845
00:38:49,089 --> 00:38:50,880
我々は、これらを呼び出すことができます
私たちが望むものを何でも

846
00:38:50,880 --> 00:38:53,590
私は、カスタムデータ構造を必要としています。

847
00:38:53,590 --> 00:38:54,257
うん？

848
00:38:54,257 --> 00:38:57,020
>> 聴衆：アンパサンド[聞こえません]。

849
00:38:57,020 --> 00:39:00,940
>> DAVIDマラン：だから私たちはアンパサンドに使用します。
潜在的にノードのアドレスを取得します。

850
00:39:00,940 --> 00:39:02,740
しかし、我々は別のものを必要とします
順序でCの特徴

851
00:39:02,740 --> 00:39:06,700
私に作成する能力を与えるために
このカスタム四角形、このカスタム

852
00:39:06,700 --> 00:39:08,919
メモリ内の変数あなたがする場合は、。

853
00:39:08,919 --> 00:39:09,710
聴衆：構造体。

854
00:39:09,710 --> 00:39:10,626
DAVIDマラン：構造体。

855
00:39:10,626 --> 00:39:14,310
先週から思い出して、我々が導入しました
構造体、この比較的単純なキーワード

856
00:39:14,310 --> 00:39:16,254
それは、私たちはこのようなものを行うことができます。

857
00:39:16,254 --> 00:39:18,420
Cは、データが付属していませんでした
構造は、学生と呼ばれます。

858
00:39:18,420 --> 00:39:22,190
これは、int型とfloatと文字とが付属しています
このような、それは学生が付属していません、

859
00:39:22,190 --> 00:39:26,750
私たちは、生徒データ型を作成することができ、
この構文を使用して学生の構造、

860
00:39:26,750 --> 00:39:27,250
ここに。

861
00:39:27,250 --> 00:39:28,350
そして、あなたは何度も何度もこれを見ることができます。

862
00:39:28,350 --> 00:39:30,426
だから、心配しないでください
キーワードを記憶します、

863
00:39:30,426 --> 00:39:33,300
しかし、重要なのキーワードがあります
我々が言っていることだけで事実構造体

864
00:39:33,300 --> 00:39:37,590
し、我々はそれを学生と呼ばれ、内部
学生の名前と家でした

865
00:39:37,590 --> 00:39:39,390
または寮など。

866
00:39:39,390 --> 00:39:41,980
>> そして今、今日、のはこのことを提案してみましょう。

867
00:39:41,980 --> 00:39:45,240
私はいくつかの単語を追加しましたが、私はしたい場合
だこの四角形を実装します

868
00:39:45,240 --> 00:39:48,440
int型との両方を持って
ポインタ、あなたは私は何を知っています、

869
00:39:48,440 --> 00:39:51,540
ノードと呼ばれる構造体を宣言するだろう。

870
00:39:51,540 --> 00:39:55,630
私も、その中に、と言うつもりです
ノード、この長方形は、int型を持っていること

871
00:39:55,630 --> 00:39:59,730
そして我々はそれを呼ぶnおよび
それは次のポインタを有しています。

872
00:39:59,730 --> 00:40:02,540
そして、これは、少し冗長です
しかし、あなたはそれについて考える場合、

873
00:40:02,540 --> 00:40:07,300
絵にあった矢印
一瞬前にどのようなデータ型ですか？

874
00:40:07,300 --> 00:40:12,330
これらの矢印のそれぞれが指している場所
データ構造のどのタイプか？

875
00:40:12,330 --> 00:40:14,332
それだけで、それ自体はint型を指していません。

876
00:40:14,332 --> 00:40:16,165
それはを指しています
全体の長方形のもの

877
00:40:16,165 --> 00:40:18,720
その長方形のもの、
我々はノードと呼ばれ、言いました。

878
00:40:18,720 --> 00:40:21,720
そして、私たちは一種のに持っています
再帰的にこのようなを定義

879
00:40:21,720 --> 00:40:26,270
ノードことを、我々は言うものとし、
nはint型と呼ばれるが含まれています

880
00:40:26,270 --> 00:40:31,070
次のと呼ばれ、ポインタ
データ構造の種類

881
00:40:31,070 --> 00:40:35,770
そのポインタは明らかです
構造体のノードになるだろう。

882
00:40:35,770 --> 00:40:41,550
>> だから、これはうるさく冗長です
ちょうど衒学的であるために、

883
00:40:41,550 --> 00:40:44,100
なぜ私たちができない理由
ただこれは率直に言って、これを言います

884
00:40:44,100 --> 00:40:46,860
、多くのより読みやすくなります
読んCのためのリコールであります

885
00:40:46,860 --> 00:40:48,710
物事は、上から下、左から右へ。

886
00:40:48,710 --> 00:40:54,120
私たちは、セミコロンを得るまでそれではありません
キーワードのノードが実際に存在していること。

887
00:40:54,120 --> 00:40:57,980
だから我々は、この種のを持っているしたい場合
データの内部循環参照

888
00:40:57,980 --> 00:41:02,120
構造、我々はこれを行うには、どこに
私たちは、一番上にある構造体のノードを言います

889
00:41:02,120 --> 00:41:06,770
私たちはこれを記述する長い方法を提供します
事は、その後の内部に我々は構造体のノードを言います、

890
00:41:06,770 --> 00:41:09,560
して、非常に最後の行に
私たちが言う、すべての権利、C、方法によって、

891
00:41:09,560 --> 00:41:12,060
ちょうどこの全体の気を呼び出します
事のノードと停止

892
00:41:12,060 --> 00:41:14,360
完全にキーワード構造体を使用して。

893
00:41:14,360 --> 00:41:18,030
だから、これはただ一種の構文的です
最終的に私たちが作成することができますトリック

894
00:41:18,030 --> 00:41:21,370
まさにこのようなもの。

895
00:41:21,370 --> 00:41:25,010
>> 私たちは今、仮定した場合、我々はできるように
C言語でこのことを実現します、

896
00:41:25,010 --> 00:41:28,040
実際にどのように行う我々
これを横断を開始？

897
00:41:28,040 --> 00:41:32,360
まあ、実際には、我々がしなければならないすべては、
左から右に繰り返すだけ

898
00:41:32,360 --> 00:41:35,960
種類のノードを挿入したり、ノードを削除します
私たちが好きな場所や物事を検索し、

899
00:41:35,960 --> 00:41:39,560
これを行うには、のは先に行くとしましょう
物事もう少し本当このため、

900
00:41:39,560 --> 00:41:42,560
これまでの超低レベル​​となっています。

901
00:41:42,560 --> 00:41:45,700
誰もが文字通り最初になりたいですか？

902
00:41:45,700 --> 00:41:46,200
OK。

903
00:41:46,200 --> 00:41:47,092
アップさあ。

904
00:41:47,092 --> 00:41:47,800
あなたの名前は何ですか？

905
00:41:47,800 --> 00:41:48,499
>> DAVID：デビッド。

906
00:41:48,499 --> 00:41:49,290
DAVIDマラン：デビッド。

907
00:41:49,290 --> 00:41:49,998
始めまして。

908
00:41:49,998 --> 00:41:50,960
私も。

909
00:41:50,960 --> 00:41:52,450
大丈夫。

910
00:41:52,450 --> 00:41:53,990
そして、我々は数9が必要です。

911
00:41:53,990 --> 00:41:55,240
最初ほど良好ではない、多分。

912
00:41:55,240 --> 00:41:56,430
[OK]を、数9。

913
00:41:56,430 --> 00:41:59,667
数17、お願いします。

914
00:41:59,667 --> 00:42:01,000
私は少し遠く戻りましょう。

915
00:42:01,000 --> 00:42:03,980
ナンバー22、してください、と
方法については遠くバック

916
00:42:03,980 --> 00:42:06,344
私は手を見ることができれば
すべての光で、あるいはまったく。

917
00:42:06,344 --> 00:42:08,010
誰かがすぐ​​そこにボランティアとして参加しているです。

918
00:42:08,010 --> 00:42:08,968
あなたが思い付くしたいですか？

919
00:42:08,968 --> 00:42:10,450
あなたの前腕を強制的に上がっています。

920
00:42:10,450 --> 00:42:12,340
[OK]を、17。

921
00:42:12,340 --> 00:42:13,690
22。

922
00:42:13,690 --> 00:42:15,120
26はダウン来ています。

923
00:42:15,120 --> 00:42:18,450
誰にもしたいと思います
forcefully--までさあ。

924
00:42:18,450 --> 00:42:21,030
実際のボランティア。

925
00:42:21,030 --> 00:42:23,330
>> だから非常に迅速に、もし
君たち手配ができ

926
00:42:23,330 --> 00:42:26,550
同じように自分
画面上のノード。

927
00:42:26,550 --> 00:42:27,510
ありがとう。

928
00:42:27,510 --> 00:42:29,234
そして、あなたは26になるだろう。

929
00:42:29,234 --> 00:42:30,650
すべての権利および迅速な導入。

930
00:42:30,650 --> 00:42:32,139
だから私はデビッドだとあなたもですか？

931
00:42:32,139 --> 00:42:32,680
DAVID：デビッド。

932
00:42:32,680 --> 00:42:33,721
DAVIDマラン：そして、あなたはありますか？

933
00:42:33,721 --> 00:42:34,229
JAKE：ジェイク。

934
00:42:34,229 --> 00:42:34,729
SUE：スー。

935
00:42:34,729 --> 00:42:35,229
ALEX：アレックス。

936
00:42:35,229 --> 00:42:36,475
RAPHAEL：ラファエル。

937
00:42:36,475 --> 00:42:37,100
TAYLOR：テイラー。

938
00:42:37,100 --> 00:42:37,466
DAVIDマラン：テイラー。

939
00:42:37,466 --> 00:42:37,590
優れています。

940
00:42:37,590 --> 00:42:39,810
したがって、これらは私たちのボランティアです
今日のためにと先に行きます

941
00:42:39,810 --> 00:42:43,090
そして、そのように少しシフト
ちょうど先に行くと維持

942
00:42:43,090 --> 00:42:47,024
あなたがそうであるようにあなたの番号を保持したり、
最初の兆候と左手を使用して、

943
00:42:47,024 --> 00:42:48,940
先に行くと、ちょうど実装
これらの矢印は、ちょうど

944
00:42:48,940 --> 00:42:51,360
左手は文字通りあるように
あなたが指している必要があり何を指し

945
00:42:51,360 --> 00:42:54,610
で、そのように自分自身にいくつかの余地を与えます
我々は、視覚的に、実際にあなたの腕を見ることができます

946
00:42:54,610 --> 00:42:58,120
ポインティング、そしてあなただけ指すことができます
ソートのグラウンドで結構です。

947
00:42:58,120 --> 00:43:03,040
>> そこでここでは、一つのリンクリストを持っています、
最初に2つ、3つ、4つ、5つのノード、

948
00:43:03,040 --> 00:43:05,860
私たちはこの特別なを持って気付きます
だ先頭のポインタ

949
00:43:05,860 --> 00:43:09,770
キー我々は追跡する必要があるため
全長リストの何とか。

950
00:43:09,770 --> 00:43:13,590
彼らが残っているにもかかわらずこれらの人、
右に、背中合わせにメモリで、

951
00:43:13,590 --> 00:43:15,950
彼らは実際にどこでもすることができます
コンピュータのメモリインチ

952
00:43:15,950 --> 00:43:18,240
だから、これらの人はかもしれません
ステージ上の任意の場所に立って

953
00:43:18,240 --> 00:43:20,960
それはあまりにも長い間、彼らがしているように、大丈夫です
実際にお互いを指し、

954
00:43:20,960 --> 00:43:22,770
しかし、物事を維持します
クリーンでシンプルな、我々はよ

955
00:43:22,770 --> 00:43:25,728
ちょうどそれらを描くことのように左から右へ
これは、しかし、大規模なギャップがあるかもしれません

956
00:43:25,728 --> 00:43:26,790
それらのノード間のインチ

957
00:43:26,790 --> 00:43:30,710
>> 今、私は実際にいくつかを挿入する場合
新しい値は、のは先に行くと、これを実行してみましょう。

958
00:43:30,710 --> 00:43:33,720
私たちは今機会を持っています
別のノードを選択します。

959
00:43:33,720 --> 00:43:39,820
55をmallocingから始めてみましょうと言います。

960
00:43:39,820 --> 00:43:41,320
誰かがmalloc関数であることを気にしませんか？

961
00:43:41,320 --> 00:43:42,280
[OK]を、アップに来ます。

962
00:43:42,280 --> 00:43:42,992
あなたの名前は何ですか？

963
00:43:42,992 --> 00:43:43,700
RAINBOW：虹。

964
00:43:43,700 --> 00:43:44,050
DAVIDマラン：レインボー？

965
00:43:44,050 --> 00:43:44,810
大丈夫。

966
00:43:44,810 --> 00:43:46,600
mallocの虹。

967
00:43:46,600 --> 00:43:47,450
アップさあ。

968
00:43:47,450 --> 00:43:51,610
だから今、私たちは自問する必要があります
アルゴリズムどこに55を入れることができます。

969
00:43:51,610 --> 00:43:53,610
だから、私たちのすべてが知っています、
明らかに、ここで彼女はおそらく

970
00:43:53,610 --> 00:43:55,401
我々がしようとしている場合に属し
保つためにこれをソート

971
00:43:55,401 --> 00:43:58,299
そしてあなたたちはいずれかを取ることができれば
我々が落下しないようにバックステップ

972
00:43:58,299 --> 00:43:59,590
ステージは、それは素晴らしいことです。

973
00:43:59,590 --> 00:44:01,420
そこで実際に、レインボー、
私と一緒にここでやり直します、

974
00:44:01,420 --> 00:44:04,200
コンピュータとして、我々はできるようになりましたので、
一度に一つの変数を参照してください。

975
00:44:04,200 --> 00:44:05,190
だから、これは最初のノードである場合。

976
00:44:05,190 --> 00:44:07,160
、彼はノードではありません注意してください
彼はただのポインタですが、

977
00:44:07,160 --> 00:44:10,270
彼はあることが描かれている理由、それはです
ポインタのサイズのみではなく、

978
00:44:10,270 --> 00:44:11,780
それらの完全な四角形の一つ。

979
00:44:11,780 --> 00:44:16,650
だから私たちは、それぞれにチェックするつもりです
繰り返しは9より55少ないのですか？

980
00:44:16,650 --> 00:44:17,150
いいえ。

981
00:44:17,150 --> 00:44:19,060
17以上55以下ですか？

982
00:44:19,060 --> 00:44:19,720
いいえ。

983
00:44:19,720 --> 00:44:20,800
22未満？

984
00:44:20,800 --> 00:44:22,020
26未満？

985
00:44:22,020 --> 00:44:23,390
34未満？

986
00:44:23,390 --> 00:44:25,890
そして今、明らかに
レインボーは、最後に属します。

987
00:44:25,890 --> 00:44:27,270
だから明確にすると、何します
あなたの名前、テイラーでしたか？

988
00:44:27,270 --> 00:44:27,895
>> TAYLOR：テイラー。

989
00:44:27,895 --> 00:44:32,510
DAVIDマラン：だからテイラーの間で
左手とここに虹の手、

990
00:44:32,510 --> 00:44:38,324
その手はに何を指すように必要
このリストに55を挿入するため？

991
00:44:38,324 --> 00:44:39,240
私たちは何をする必要がありますか？

992
00:44:39,240 --> 00:44:39,700
うん？

993
00:44:39,700 --> 00:44:41,140
>> 聴衆：テイラーの手
左を指している必要があります。

994
00:44:41,140 --> 00:44:41,680
>> DAVIDマラン：その通り。

995
00:44:41,680 --> 00:44:43,800
だから、ノードを挿入します
リストの最後に

996
00:44:43,800 --> 00:44:47,140
非常に単純ですので、テイラーだけ
地上での代わりに、ポイントする必要があります

997
00:44:47,140 --> 00:44:49,640
または私達はそれがnull電話しますよ、
nullが不在の一種であります

998
00:44:49,640 --> 00:44:51,640
ポインタまたは特別の
ゼロポインタ、あなたがしています

999
00:44:51,640 --> 00:44:53,740
左手でポイントになるだろう
手レインボーして、レインボーで、

1000
00:44:53,740 --> 00:44:55,910
あなたの場所を残しする必要があります
手はおそらくポイント？

1001
00:44:55,910 --> 00:44:56,570
ダウン。

1002
00:44:56,570 --> 00:45:00,140
彼女の手がソートされている場合は良いではありません
ここでオフ指し示すのか、いずれかの並べ替え

1003
00:45:00,140 --> 00:45:00,640
どちら。

1004
00:45:00,640 --> 00:45:02,407
すなわち、と考えられます
ごみ値、

1005
00:45:02,407 --> 00:45:04,240
しかし、彼女はを指している場合
いくつかの既知の値は、我々はよ

1006
00:45:04,240 --> 00:45:07,360
ゼロまたはNULLそれを呼び出す、それは大丈夫です
我々はこの中の用語を持っているので、

1007
00:45:07,360 --> 00:45:09,390
我々はリストが完成しました知っています。

1008
00:45:09,390 --> 00:45:11,550
>> だから、別のは何です
比較的単純な場合？

1009
00:45:11,550 --> 00:45:13,125
我々は5をmallocできますか？

1010
00:45:13,125 --> 00:45:14,010
アップさあ。

1011
00:45:14,010 --> 00:45:14,782
あなたの名前は何ですか？

1012
00:45:14,782 --> 00:45:15,490
TIFFANY：ティファニー。

1013
00:45:15,490 --> 00:45:16,000
DAVIDマラン：ごめんなさい！

1014
00:45:16,000 --> 00:45:16,470
TIFFANY：ティファニー。

1015
00:45:16,470 --> 00:45:16,880
DAVIDマラン：ティファニー。

1016
00:45:16,880 --> 00:45:17,110
大丈夫。

1017
00:45:17,110 --> 00:45:19,071
ティファニーは、mallocされています
値5を持ちます。

1018
00:45:19,071 --> 00:45:19,570
アップさあ。

1019
00:45:19,570 --> 00:45:23,820
この1つは、あまりにも比較的容易だが、
それでは、操作の順序を考えてみましょう。

1020
00:45:23,820 --> 00:45:25,820
それはかなり簡単でした
テイラーと最後に。

1021
00:45:25,820 --> 00:45:30,302
数5は、もちろん9未満であります
そのため、我々は、我々は、ティファニーのデビッド持っています

1022
00:45:30,302 --> 00:45:31,260
あなたの名前は何でしたか？

1023
00:45:31,260 --> 00:45:31,680
>> JAKE：ジェイク。

1024
00:45:31,680 --> 00:45:32,470
>> DAVIDマラン：ジェイク。

1025
00:45:32,470 --> 00:45:34,300
ティファニー、ジェイク、とデビッド。

1026
00:45:34,300 --> 00:45:36,580
誰の手が最初に更新すべきですか？

1027
00:45:36,580 --> 00:45:39,260

1028
00:45:39,260 --> 00:45:40,590
何がここに何をしたいですか？

1029
00:45:40,590 --> 00:45:45,244
カップル可能な方法は、ありますが、
一つ以上の間違った方法もあります。

1030
00:45:45,244 --> 00:45:46,620
>> 対象：一番左から開始します。

1031
00:45:46,620 --> 00:45:47,800
>> DAVIDマラン：一番左から開始します。

1032
00:45:47,800 --> 00:45:49,008
誰がその後、ここ一番左ですか？

1033
00:45:49,008 --> 00:45:49,700
聴衆：ファースト。

1034
00:45:49,700 --> 00:45:50,366
>> DAVIDマラン：OK。

1035
00:45:50,366 --> 00:45:53,781
したがって、最初から始めて、どこで行います
デビッドの手があることを更新したいですか？

1036
00:45:53,781 --> 00:45:54,780
聴衆：5に向けて。

1037
00:45:54,780 --> 00:45:55,446
DAVIDマラン：OK。

1038
00:45:55,446 --> 00:45:59,026
5時ダビデ、ポイント
またはティファニーここで、今？

1039
00:45:59,026 --> 00:46:01,072
>> 聴衆：ティファニーは9を指しますか？

1040
00:46:01,072 --> 00:46:04,030
DAVIDマラン：パーフェクト、Binkyさんを除きます
頭はちょうど種類の右側、落ちましたか？

1041
00:46:04,030 --> 00:46:06,820
と間違って何ので、
この絵は、文字通り？

1042
00:46:06,820 --> 00:46:08,070
観客：何も指していません。

1043
00:46:08,070 --> 00:46:09,945
DAVIDマラン：何もありません
今ジェイクを指します。

1044
00:46:09,945 --> 00:46:13,360
我々は文字通り9孤立しました
17、私たちは文字通りました

1045
00:46:13,360 --> 00:46:18,450
によってので、このメモリのすべてを漏らし
最初のダビデの手を更新する、それはです

1046
00:46:18,450 --> 00:46:21,660
それは正しくな限り罰金
今ティファニーを指し、

1047
00:46:21,660 --> 00:46:25,410
誰もが持っていない場合
ジェイクの点に先見性、

1048
00:46:25,410 --> 00:46:27,490
その後、我々が失ってしまいました
そのリストの全体。

1049
00:46:27,490 --> 00:46:28,200
それでは、元に戻すましょう。

1050
00:46:28,200 --> 00:46:30,950
だから、に良いことでした
以上の旅行が、今度は修正してみましょう。

1051
00:46:30,950 --> 00:46:33,624
私たちは、代わりに最初に行う必要がありますか？

1052
00:46:33,624 --> 00:46:34,124
うん？

1053
00:46:34,124 --> 00:46:35,791
>> 観客：ティファニーは9を指し示す必要がありますか？

1054
00:46:35,791 --> 00:46:37,582
DAVIDマラン：私はできません
あなたにその近くを取得します。

1055
00:46:37,582 --> 00:46:38,720
9で誰を指している必要がありますか？

1056
00:46:38,720 --> 00:46:39,220
>> 聴衆：ティファニー。

1057
00:46:39,220 --> 00:46:39,390
>> DAVIDマラン：すべての権利。

1058
00:46:39,390 --> 00:46:41,200
だから、ティファニーは、最初の9時にポイントする必要があります。

1059
00:46:41,200 --> 00:46:43,550
だから、ティファニーは取る必要があります
同一の値に

1060
00:46:43,550 --> 00:46:45,820
ダビデに、それはそうです
一瞬のために冗長、

1061
00:46:45,820 --> 00:46:48,820
それは、第二のために今も元気です
ステップ、私たちはダビデの手を更新することができます

1062
00:46:48,820 --> 00:46:52,680
ティファニーで、次に場合を指すように
私たちだけの種類のきれいな物事

1063
00:46:52,680 --> 00:46:55,740
これはバネ状の一種であるかのように、
今それは正しい挿入です。

1064
00:46:55,740 --> 00:46:56,700
だから、優れました。

1065
00:46:56,700 --> 00:46:57,970
だから今、私たちはほとんどがしています。

1066
00:46:57,970 --> 00:47:01,075
それでは、最後に1を挿入してみましょう
値20のような値。

1067
00:47:01,075 --> 00:47:03,010
我々は最後に1つのボランティアををmallocことができれば？

1068
00:47:03,010 --> 00:47:04,140
アップさあ。

1069
00:47:04,140 --> 00:47:06,224
したがって、この1はもう少しトリッキーです。

1070
00:47:06,224 --> 00:47:08,390
しかし、実際に、コード我々はしています
書き込み、口頭ではあるが、

1071
00:47:08,390 --> 00:47:10,610
ちょうど束を持っているようなものです
今の状態であればの、右？

1072
00:47:10,610 --> 00:47:12,318
我々は条件を持っていました
それが属しているかどうかをチェックします

1073
00:47:12,318 --> 00:47:13,840
最後に、多分開始。

1074
00:47:13,840 --> 00:47:15,940
我々は、ループのいくつかの種類を必要とします
途中で場所を見つけます。

1075
00:47:15,940 --> 00:47:17,400
それでは、あなたの名前は何でそれをやらせますか？

1076
00:47:17,400 --> 00:47:17,700
>> ERIC：エリック。

1077
00:47:17,700 --> 00:47:18,340
>> DAVIDマラン：エリック？

1078
00:47:18,340 --> 00:47:18,660
エリック。

1079
00:47:18,660 --> 00:47:19,368
始めまして。

1080
00:47:19,368 --> 00:47:20,490
だから我々は20を持っています。

1081
00:47:20,490 --> 00:47:21,220
5未満？

1082
00:47:21,220 --> 00:47:21,530
いいえ。

1083
00:47:21,530 --> 00:47:22,160
9未満？

1084
00:47:22,160 --> 00:47:22,410
いいえ。

1085
00:47:22,410 --> 00:47:23,050
17未満？

1086
00:47:23,050 --> 00:47:23,550
いいえ。

1087
00:47:23,550 --> 00:47:23,740
OK。

1088
00:47:23,740 --> 00:47:25,701
彼はここに属しており、
あなたの名前は再びですか？

1089
00:47:25,701 --> 00:47:26,200
SUE：スー。

1090
00:47:26,200 --> 00:47:26,880
DAVIDマラン：スー。

1091
00:47:26,880 --> 00:47:27,379
ALEX：アレックス。

1092
00:47:27,379 --> 00:47:28,790
DAVIDマラン：スー、アレックス、と？

1093
00:47:28,790 --> 00:47:29,290
ERIC：エリック。

1094
00:47:29,290 --> 00:47:30,120
DAVIDマラン：エリック。

1095
00:47:30,120 --> 00:47:32,140
誰の手が最初に更新されますする必要がありますか？

1096
00:47:32,140 --> 00:47:32,930
>> 者：エリック。

1097
00:47:32,930 --> 00:47:33,429
OK。

1098
00:47:33,429 --> 00:47:35,200
だから、エリックのはどこを指す必要がありますか？

1099
00:47:35,200 --> 00:47:35,930
22時。

1100
00:47:35,930 --> 00:47:36,430
良い。

1101
00:47:36,430 --> 00:47:38,180
そして今、次は何？

1102
00:47:38,180 --> 00:47:40,800
スーはその後、エリックで指すことができます
そして今、もしあなたたちだけ

1103
00:47:40,800 --> 00:47:44,077
微細でいくつかの部屋を作ります
視覚的に、今、私たちは挿入​​を行ってきました。

1104
00:47:44,077 --> 00:47:47,160
それでは、今の質問を考えてみましょうが、
ボランティアありがとうございました。

1105
00:47:47,160 --> 00:47:48,090
非常によくやりました。

1106
00:47:48,090 --> 00:47:50,831
あなたが好きな場合は、それらを維持することができます。

1107
00:47:50,831 --> 00:47:54,140
そして、私たちは素敵な別れの贈り物の場合があります
あなたはそれぞれのストレスボールを取りたいと思います。

1108
00:47:54,140 --> 00:47:56,030
私はちょうどこれを伝承してみましょう。

1109
00:47:56,030 --> 00:47:58,430
だから、これをお持ち帰りは何ですか？

1110
00:47:58,430 --> 00:48:02,430
これは驚くべきであると思われます
我々は今持っているものであれば、

1111
00:48:02,430 --> 00:48:06,360
の代替を導入
そのように限定されない配列

1112
00:48:06,360 --> 00:48:07,780
いくつかの固定サイズの配列へ。

1113
00:48:07,780 --> 00:48:09,380
彼らは、動的に成長することができます。

1114
00:48:09,380 --> 00:48:13,220
>> しかし、我々のような多くは数週間で見てきました
過去には、我々は、自由のための何かを得ることはありません

1115
00:48:13,220 --> 00:48:15,740
確かにトレードオフがここにありますように。

1116
00:48:15,740 --> 00:48:18,890
リンクの利点とそう
リストには、このダイナミズムのですか？

1117
00:48:18,890 --> 00:48:21,590
率直に成長し、この能力、
我々は、削除したかもしれません

1118
00:48:21,590 --> 00:48:23,570
必要に応じて、我々は縮小ができます。

1119
00:48:23,570 --> 00:48:24,710
私たちはどのような価格を払っていますか？

1120
00:48:24,710 --> 00:48:28,510

1121
00:48:28,510 --> 00:48:30,340
2倍のスペースとして、すべての最初の。

1122
00:48:30,340 --> 00:48:34,010
あなたが絵を見れば、もはや
私は整数のリストを格納しています。

1123
00:48:34,010 --> 00:48:36,740
私はのリストを格納しています
整数プラスポインタ。

1124
00:48:36,740 --> 00:48:38,240
だから私は、スペースの量を倍増しています。

1125
00:48:38,240 --> 00:48:40,740
今、多分それは、ありません
大した4バイト、8バイト、

1126
00:48:40,740 --> 00:48:43,160
それは確かに追加することができます
大規模なデータセットのためにアップ。

1127
00:48:43,160 --> 00:48:45,570
別の欠点は何ですか？

1128
00:48:45,570 --> 00:48:46,070
うん？

1129
00:48:46,070 --> 00:48:48,010
>> 観客：我々がする必要があります
それらを一つ一つを通過します。

1130
00:48:48,010 --> 00:48:48,760
DAVIDマラン：うん。

1131
00:48:48,760 --> 00:48:50,260
私たちはそれらを一つ一つを横断する必要があります。

1132
00:48:50,260 --> 00:48:53,860
あなたは私たちがこのスーパーをあきらめたものを、知っています
角括弧の便利な機能

1133
00:48:53,860 --> 00:48:57,240
より適切に表記、
ランダムアクセスとして知られています、

1134
00:48:57,240 --> 00:48:59,280
私たちはジャンプできる場所
個々の要素に

1135
00:48:59,280 --> 00:49:01,470
しかし、今私はまだ持っていた場合
ここに私のボランティア、

1136
00:49:01,470 --> 00:49:04,660
私が検索する場合
数22、私はできません

1137
00:49:04,660 --> 00:49:06,620
ブラケット何か何かにジャンプします。

1138
00:49:06,620 --> 00:49:10,530
私はずっと、リスト上で見ています
直線的に私たちの検索例のように、

1139
00:49:10,530 --> 00:49:12,260
番号22を検索します。

1140
00:49:12,260 --> 00:49:14,340
だから我々はそこに価格を支払っているように見えます。

1141
00:49:14,340 --> 00:49:16,430
しかし、我々はそれにもかかわらずことができます
他の問題を解決します。

1142
00:49:16,430 --> 00:49:18,587
>> 実際には、私が紹介しましょう
ビジュアルだけのカップル。

1143
00:49:18,587 --> 00:49:20,920
だから、ダウンをしてきた場合
最近メイザーのダイニングホール、

1144
00:49:20,920 --> 00:49:23,320
あなたはそれらのことを思い出します
このようなトレーのスタック、

1145
00:49:23,320 --> 00:49:26,300
私たちは、からこれらを借りました
クラスの前にアネンバーグ。

1146
00:49:26,300 --> 00:49:28,930
だから、トレイのこのスタックは、しかし、
代表者は、実際には

1147
00:49:28,930 --> 00:49:30,860
コンピュータサイエンスのデータ構造の。

1148
00:49:30,860 --> 00:49:32,910
データ構造があります
コンピュータサイエンスの

1149
00:49:32,910 --> 00:49:38,010
非常にうまくスタックとして知られています
まさにこの視覚的に自分自身を貸します。

1150
00:49:38,010 --> 00:49:41,380
したがって、これらのトレイの各々ではない場合
番号のような、私は望んでいたトレイが、

1151
00:49:41,380 --> 00:49:45,010
数値を格納するために、私
ここで1ダウンを置くことができ、

1152
00:49:45,010 --> 00:49:48,320
私は、ここに別のものを置くことができ
数字を積み重ね続けます

1153
00:49:48,320 --> 00:49:53,180
互いに、そして何の上に
このことについて、潜在的に役立ちます

1154
00:49:53,180 --> 00:49:55,450
何が含意であるということです
このデータ構造の？

1155
00:49:55,450 --> 00:49:58,045
私は、どの番号引き出すことができます
最初に最も便利？

1156
00:49:58,045 --> 00:50:00,640

1157
00:50:00,640 --> 00:50:03,030
そこに置かれ、最近1。

1158
00:50:03,030 --> 00:50:06,430
>> だから、これは私たちが呼ぶものです
コンピュータサイエンスLIFOデータ構造。

1159
00:50:06,430 --> 00:50:08,070
最後の、最初のうち。

1160
00:50:08,070 --> 00:50:10,800
そして、私たちは長い間、なぜ前に表示されます
それが有用であるが、今のところかもしれません、

1161
00:50:10,800 --> 00:50:12,200
単にプロパティを検討します。

1162
00:50:12,200 --> 00:50:15,158
あなたが考える場合、それは一種の愚かです
食堂はそれをしない方法について。

1163
00:50:15,158 --> 00:50:17,910
彼らはトレイをきれいにするたびにと
上に新鮮なものを入れて、

1164
00:50:17,910 --> 00:50:22,160
以前クリーンを持つことができます
しかし、最終的には非常に汚れて埃っぽいです

1165
00:50:22,160 --> 00:50:24,360
一番下のトレイ
よろしければ決して実際に

1166
00:50:24,360 --> 00:50:26,820
その底に取得します
スタック、あなたのためだけ

1167
00:50:26,820 --> 00:50:29,380
新しいを入れておくと、
その上にきれいなもの。

1168
00:50:29,380 --> 00:50:31,840
同じことが起こる可能性があります
スーパーであまりにも。

1169
00:50:31,840 --> 00:50:35,450
あなたは、ディスプレイケースを持っている場合
牛乳と毎回のCVS

1170
00:50:35,450 --> 00:50:37,610
以上のミルクを取得します誰でも、
あなただけのミルクを突き出します

1171
00:50:37,610 --> 00:50:39,880
すでにバックに持っており、
あなたは、アップフロント新しいものを置きます

1172
00:50:39,880 --> 00:50:43,088
あなたには、いくつかのはかなり厄介な必要があるとしています
データ構造の終わりに、ミルク、

1173
00:50:43,088 --> 00:50:46,390
それが底に常にだからか
等価的に、それは背面に常にです。

1174
00:50:46,390 --> 00:50:50,407
>> しかし、考えるための別の方法があります
データを並べて、インスタンスのために、この。

1175
00:50:50,407 --> 00:50:53,490
あなたが好きその一人なら
アップルストアの外に整列します

1176
00:50:53,490 --> 00:50:55,610
ときに、新しい製品が来ます
アウト、あなたはおそらくしています

1177
00:50:55,610 --> 00:50:58,780
スタックデータを使用していません
構造あなたのため

1178
00:50:58,780 --> 00:51:03,070
ある他の皆を遠ざけることになります
いくつかの新しいおもちゃを購入するために並びます。

1179
00:51:03,070 --> 00:51:06,610
むしろ、あなたはおそらく使用しています
データ構造の種類

1180
00:51:06,610 --> 00:51:10,050
またはシステムの種類
現実の世界では？

1181
00:51:10,050 --> 00:51:13,493
うまくいけば、それが行だ、以上
正しく以上の英国のような、キュー。

1182
00:51:13,493 --> 00:51:17,700
そしてそれは、キューでもあり判明します
コンピュータサイエンスのデータ構造、

1183
00:51:17,700 --> 00:51:19,700
しかし、キューは非常にされてい
別のプロパティ。

1184
00:51:19,700 --> 00:51:20,820
それはLIFOではありません。

1185
00:51:20,820 --> 00:51:21,990
最後の、最初のうち。

1186
00:51:21,990 --> 00:51:22,800
神は禁止します。

1187
00:51:22,800 --> 00:51:24,280
それは代わりに、FIFOです。

1188
00:51:24,280 --> 00:51:26,110
まず最初に、インチ

1189
00:51:26,110 --> 00:51:27,970
そして、それは良いことです
公正」ために

1190
00:51:27,970 --> 00:51:30,428
確かにライニングしているとき
午前中に超早起き。

1191
00:51:30,428 --> 00:51:33,400
あなたが最初にそこに到達した場合、
同様に最初に取得したいです。

1192
00:51:33,400 --> 00:51:35,880
>> だからこれらのデータのすべて
構造、キューとスタック

1193
00:51:35,880 --> 00:51:39,220
その他の房、あなたが判明
単にアレイと考えることができます。

1194
00:51:39,220 --> 00:51:41,820
これは多分、配列であります
固定サイズの4、それがしたいです

1195
00:51:41,820 --> 00:51:44,990
我々だけでパイルができればちょっといいかも
ほぼ無限に背の高い私たちの場合、トレイ

1196
00:51:44,990 --> 00:51:46,780
その多くのトレイまたは数字を持っています。

1197
00:51:46,780 --> 00:51:48,840
だから多分私達がしたいです
ここにリンクされたリストを使用し、

1198
00:51:48,840 --> 00:51:51,800
しかし、トレードオフがあることを行っています
潜在的に、我々はより多くのメモリを必要とすること、

1199
00:51:51,800 --> 00:51:55,930
我々はもう少し時間がかかりますが、
スタックの高さを制限するものではありません、

1200
00:51:55,930 --> 00:51:59,550
メイザーの陳列ケースのような多くの
スタックのサイズが制限される場合があります、

1201
00:51:59,550 --> 00:52:03,117
そのためこれらは、設計上の決定またはあります
最終的に私たちに利用可能なオプション。

1202
00:52:03,117 --> 00:52:04,950
これらのデータとそう
構造は、我々が開始しました

1203
00:52:04,950 --> 00:52:09,360
潜在的に新しい上限​​を見て
以前に超高速のあったものに

1204
00:52:09,360 --> 00:52:11,260
そしてどこに残しておきます
今日オフと場所

1205
00:52:11,260 --> 00:52:13,200
我々は、に到達するために願っています
水曜日に、我々はよ

1206
00:52:13,200 --> 00:52:15,740
データを見るために開始
私たちが検索できます構造

1207
00:52:15,740 --> 00:52:18,260
ログ終了時刻のデータを介して、再び。

1208
00:52:18,260 --> 00:52:21,470
そして、我々は、0週目に、リコール、ことを見ました
バイナリ検索や除算と一

1209
00:52:21,470 --> 00:52:22,180
そして征服します。

1210
00:52:22,180 --> 00:52:26,240
それは、まだ戻って、より良い来ます
この水曜日のための聖杯

1211
00:52:26,240 --> 00:52:29,510
を思い付くことになります
本当に実行されるデータ構造

1212
00:52:29,510 --> 00:52:32,070
または理論的で
一定時間、これにより、

1213
00:52:32,070 --> 00:52:34,760
それはどのように多くの問題ではありません。
何百万人や物事の十億

1214
00:52:34,760 --> 00:52:38,470
我々は、データ構造を持っている、それは意志
私たちに一定の時間がかかる、多分一歩

1215
00:52:38,470 --> 00:52:41,387
または2ステップまたは10ステップ、
しかし、ステップの一定数

1216
00:52:41,387 --> 00:52:42,970
そのデータ構造を検索します。

1217
00:52:42,970 --> 00:52:46,300
それは確かに聖杯になります
しかし、もっとその上で水曜日に。

1218
00:52:46,300 --> 00:52:49,045
その後、屋を参照してください。

1219
00:52:49,045 --> 00:52:53,704
>> [音楽再生]

1220
00:52:53,704 --> 00:56:08,448