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

2
00:00:03,269 --> 00:00:05,391

3
00:00:05,391 --> 00:00:06,640
CAMILLE REKHSON：こんにちは、誰もが。

4
00:00:06,640 --> 00:00:10,120
CS50クイズへようこそ
ゼロレビューセッション。

5
00:00:10,120 --> 00:00:10,770
私はカミーユです。

6
00:00:10,770 --> 00:00:13,140
そして、私は行くことするつもりです
あなたといくつかのトピックを超えます

7
00:00:13,140 --> 00:00:16,890
みんな、今日はあなたを助けるために
クイズの準備をします。

8
00:00:16,890 --> 00:00:20,840
だからここに私たちの非網羅的です
トピックのリストあなた

9
00:00:20,840 --> 00:00:23,210
クイズのために精通している必要があります。

10
00:00:23,210 --> 00:00:25,740
これらは、直接撮影されました
シラバスから。

11
00:00:25,740 --> 00:00:26,990
私はそれはたくさんのように思える知っています。

12
00:00:26,990 --> 00:00:30,870
しかし私を信頼し、あなたはすべてのことを学びました
過去数週間でこれらの事。

13
00:00:30,870 --> 00:00:33,210
>> だから我々は間違いなく行くことがあります
これらの今日の多くの上に。

14
00:00:33,210 --> 00:00:35,825
しかし、また、あなたにいくつかの時間がかかります
これらの事を確認する独自の。

15
00:00:35,825 --> 00:00:38,450
そして、あなたが精通していなかった場合
これらの事のいくつかは何ですか、

16
00:00:38,450 --> 00:00:42,400
あなたが私たちのいずれかを尋ねることを確認してください。

17
00:00:42,400 --> 00:00:45,985
また、公式の単語の
クイズには、このリンクにアクセスしてください。

18
00:00:45,985 --> 00:00:48,860
これは、すべての情報を持っています
どの部屋であなたが行く必要があり、

19
00:00:48,860 --> 00:00:52,960
アルファベット順に分割し、
どんな材料にもいくつかのヒント

20
00:00:52,960 --> 00:00:56,470
あなたは勉強して、どのようなする必要があります
あなたが期待できるクイズの質問。

21
00:00:56,470 --> 00:01:01,090
だからをチェックアウトしてください。

22
00:01:01,090 --> 00:01:03,810
>> あなたのためにも、いくつかのヒント
試験の準備をしています。

23
00:01:03,810 --> 00:01:05,730
紙の上でのコーディングの練習。

24
00:01:05,730 --> 00:01:09,280
私はあなたが持っていることに慣れてきた知っています
あなたのためのあなたのエラーのためのIDEのチェック、

25
00:01:09,280 --> 00:01:12,280
そして、it's--あなたはそれを入力しているとき、
それが持つよりも少し違います

26
00:01:12,280 --> 00:01:13,113
物事を書き込みます。

27
00:01:13,113 --> 00:01:14,560
だから、いくつかのコーディングをして練習します。

28
00:01:14,560 --> 00:01:17,910
練習にいくつかの良い機能
やってはSTRLENと税引後営業利益は、

29
00:01:17,910 --> 00:01:20,450
あなたが書くことができれば見て
自分でそれらのうち。

30
00:01:20,450 --> 00:01:21,970
問題セットに精通していること。

31
00:01:21,970 --> 00:01:24,200
ほとんどの年があります
関連する質問

32
00:01:24,200 --> 00:01:25,700
問題セット材料の一部に。

33
00:01:25,700 --> 00:01:30,480
だから、あなたが理解していることを確認してください
すべての問題のセットを行う方法。

34
00:01:30,480 --> 00:01:35,240
>> 古いクイズの一部をやってみてください
75分の時間の制約の下で。

35
00:01:35,240 --> 00:01:37,290
クイズの多く
種類の長さにすることができます。

36
00:01:37,290 --> 00:01:39,680
だから、与えるために良い方法です
自分でいくつかの練習、

37
00:01:39,680 --> 00:01:41,650
そしてどのくらいの時間がします
あなたを取るし、どのように

38
00:01:41,650 --> 00:01:45,360
確認するためにあなたの時間を分割する必要があります
あなたは、年末までにすべてを終えます。

39
00:01:45,360 --> 00:01:49,690
そしてまた、1つのページを取得し、
両面参照シート

40
00:01:49,690 --> 00:01:52,962
あなたは何でもあなたを書くことができること
クイズ中に使用するにしたいです。

41
00:01:52,962 --> 00:01:54,670
だから、あなたが作成しているとき
すなわち、それはまたです

42
00:01:54,670 --> 00:01:57,860
ので、勉強には本当に素晴らしい方法
あなたはこの種のものを見直すことになります

43
00:01:57,860 --> 00:01:59,610
あなたはそれを書いているよう。

44
00:01:59,610 --> 00:02:05,421
>> だからに関する一般的な質問は、
クイズ、またはそれがどのように動作しますか？

45
00:02:05,421 --> 00:02:05,921
うん。

46
00:02:05,921 --> 00:02:09,167
>> 聴衆：トピックのリストは、ウィル
あなただけの私たちに利用可能であることを示しました

47
00:02:09,167 --> 00:02:09,820
オンライン？

48
00:02:09,820 --> 00:02:12,736
>> CAMILLE REKHSON：この全体のスライド
ショーはウェブサイトに掲載されます。

49
00:02:12,736 --> 00:02:16,040
また、今日のレビューの動画
セッションは、ウェブサイト上になります。

50
00:02:16,040 --> 00:02:19,250
だから、についてはあまり心配しないでください
全体のことを書き留めます。

51
00:02:19,250 --> 00:02:20,437
これは、すべてがあります。

52
00:02:20,437 --> 00:02:21,270
その他の質問は？

53
00:02:21,270 --> 00:02:23,810

54
00:02:23,810 --> 00:02:26,960
[OK]を、ので、始めましょう。

55
00:02:26,960 --> 00:02:30,860
>> だから、一つのことがあるに精通しています
異なるデータタイプおよびサイズ

56
00:02:30,860 --> 00:02:32,486
彼らが取ること。

57
00:02:32,486 --> 00:02:35,360
これもに大きなものになるかもしれませんね
あなたの参照シートに書き留め、

58
00:02:35,360 --> 00:02:37,240
ただあなたを確認します
これらのすべてを覚えています。

59
00:02:37,240 --> 00:02:39,200
But--ので、文字は1バイトです。

60
00:02:39,200 --> 00:02:40,700
int型は4バイトです。

61
00:02:40,700 --> 00:02:44,450
基本的にはより多くのである、長い、長いです
整数のためのスペースは、8バイトです。

62
00:02:44,450 --> 00:02:46,560
フロートは4バイトです。

63
00:02:46,560 --> 00:02:50,620
基本的にはあなたを与える二重、
浮動小数点数を格納するためのより多くのスペースは、8バイトです。

64
00:02:50,620 --> 00:02:54,210
そして、ポインタはまた、8バイトです。

65
00:02:54,210 --> 00:02:56,270
これらについてのご質問？

66
00:02:56,270 --> 00:03:00,380

67
00:03:00,380 --> 00:03:05,580
>> だからバイナリは、私たちがきた別のトピックです
少しにこの学期をカバーしました。

68
00:03:05,580 --> 00:03:07,910
それでは、いくつかをやらせます
変換との練習

69
00:03:07,910 --> 00:03:10,000
バイナリと小数の間。

70
00:03:10,000 --> 00:03:13,950
だから、誰がどんな考えを持っているもの
その最初のものはでしょうか？

71
00:03:13,950 --> 00:03:32,840

72
00:03:32,840 --> 00:03:34,860
誰でも？

73
00:03:34,860 --> 00:03:36,270
ええ、それは42です。

74
00:03:36,270 --> 00:03:39,200
あなたは覚えているのであれば、各
バイナリでの場所の

75
00:03:39,200 --> 00:03:41,860
基本的には2のようなものです
その場所の電源に。

76
00:03:41,860 --> 00:03:43,750
>> だから、最初のスポットは0パワーに2です。

77
00:03:43,750 --> 00:03:46,710
そして、私たちはそこに0を持っていないので、そこには何も。

78
00:03:46,710 --> 00:03:48,700
次の場所は、最初の電源に2です。

79
00:03:48,700 --> 00:03:51,220
そして、私たちはそこに1を持っています、
そのためには、基本的には2です。

80
00:03:51,220 --> 00:03:53,642
次の場所は2であることが
4第二、。

81
00:03:53,642 --> 00:03:54,850
私たちはそこには何もありません。

82
00:03:54,850 --> 00:03:59,390
以上の次の場所は2であります
8だろう第三、。

83
00:03:59,390 --> 00:04:02,230
そして、我々はそこに1を持っています。

84
00:04:02,230 --> 00:04:03,470
そして、我々は続けます。

85
00:04:03,470 --> 00:04:07,720
それはへの遠いをlast--
我々は、32を持っている場合に左ものです。

86
00:04:07,720 --> 00:04:13,437
だから、私たちは基本的に持っています
42を取得するための32プラス8プラス2。

87
00:04:13,437 --> 00:04:14,020
質問は？

88
00:04:14,020 --> 00:04:15,820
>> 聴衆：の添え字は何ですか？

89
00:04:15,820 --> 00:04:17,399
>> CAMILLE REKHSON：添字
基本的にはバイナリです教えてくれる。

90
00:04:17,399 --> 00:04:18,230
だから、2があります。

91
00:04:18,230 --> 00:04:20,579
次の中like--があった場合
1、または我々は小数に変換しています

92
00:04:20,579 --> 00:04:24,350
バイナリに、10のことを私たちに示してあります
この数は、もともと小数です。

93
00:04:24,350 --> 00:04:25,194
>> 観客は：ありがとうございます。

94
00:04:25,194 --> 00:04:26,110
>> CAMILLE REKHSON：うん。

95
00:04:26,110 --> 00:04:28,790
その1上の任意の他の質問？

96
00:04:28,790 --> 00:04:31,110
OK、それでは、次を試してみましょう
1その後、バイナリの10進。

97
00:04:31,110 --> 00:04:35,034
だから50を取り、バイナリにそれを置きます。

98
00:04:35,034 --> 00:04:35,950
あなたはそれをどうしますか？

99
00:04:35,950 --> 00:04:44,331

100
00:04:44,331 --> 00:04:45,317
うん。

101
00:04:45,317 --> 00:04:49,754
>> 聴衆：110010。

102
00:04:49,754 --> 00:04:50,760
>> CAMILLE REKHSON：はい。

103
00:04:50,760 --> 00:04:54,410
考えるための簡単​​な方法選ぶ - だから、
バイナリに10進数からの変換

104
00:04:54,410 --> 00:04:57,950
それは多くの場合、書き出すのに役立ちますto--です
2の異なる力がありますか。

105
00:04:57,950 --> 00:05:01,460
そして、それを通過して、参照してください。
何でもそれらの最も高い1

106
00:05:01,460 --> 00:05:05,320
あなたがに置くことができるということです
その上に行くことなく、10進数を指定します。

107
00:05:05,320 --> 00:05:09,040
>> の一つが、この場合はそう
2の累乗は32です。

108
00:05:09,040 --> 00:05:10,560
だから、32は50になります。

109
00:05:10,560 --> 00:05:14,100
しかし、次のパワーアップは、64になります
これは明らかに50に適合しません。

110
00:05:14,100 --> 00:05:16,343
だから私たちが持っている最高は32​​です。

111
00:05:16,343 --> 00:05:17,343
16まで次のもの。

112
00:05:17,343 --> 00:05:20,140
そして、32プラス16は、唯一の48です。

113
00:05:20,140 --> 00:05:21,350
まだ50に収まるようにします。

114
00:05:21,350 --> 00:05:22,722
だから我々は、これらの両方に1のを持っています。

115
00:05:22,722 --> 00:05:25,180
そして、我々は、ダウンし続ける場合
私たちは左を必要とする唯一のもの

116
00:05:25,180 --> 00:05:27,510
48から50に取得する2以上です。

117
00:05:27,510 --> 00:05:31,860
それでは、私たちはその位置に1を持っています、
そして、最後の位置で0。

118
00:05:31,860 --> 00:05:35,371
何もにありませんので
0番目の場所に2。

119
00:05:35,371 --> 00:05:37,120
変換に関する質問
バイナリ10進？

120
00:05:37,120 --> 00:05:40,830

121
00:05:40,830 --> 00:05:44,100
>> だから今のは、やってみましょう
いくつかの2進加算。

122
00:05:44,100 --> 00:05:47,235
どのようにこれら二つのアップを追加すると？

123
00:05:47,235 --> 00:05:47,735
うん。

124
00:05:47,735 --> 00:05:51,130
>> 聴衆：11100。

125
00:05:51,130 --> 00:05:52,110
>> CAMILLE REKHSON：はい。

126
00:05:52,110 --> 00:05:55,540
だから、バイナリの加算を行うことはかなりあります
小数でそれをやってとほとんど同じ。

127
00:05:55,540 --> 00:05:59,390
あなたは、2つの1の幸福を持っている場合を除き、
一緒に加え、1プラス1は、2であります

128
00:05:59,390 --> 00:06:02,980
しかし、バイナリで2 1 0です。

129
00:06:02,980 --> 00:06:07,090
だから、1を運ぶために持っている、と続けます
これらのカップルの列のためにそれを運びます。

130
00:06:07,090 --> 00:06:10,260
そして、それ以外の、普通に追加します。

131
00:06:10,260 --> 00:06:13,125
その上の任意の質問？

132
00:06:13,125 --> 00:06:13,625
うん。

133
00:06:13,625 --> 00:06:16,487
>> 聴衆：申し訳ありませんが、最後の場所は何ですか？

134
00:06:16,487 --> 00:06:18,475
6つの数字があります。

135
00:06:18,475 --> 00:06:23,260
だから一番左の列、
それはどのような値ですか？

136
00:06:23,260 --> 00:06:24,760
CAMILLE REKHSON：このボトム1オン？

137
00:06:24,760 --> 00:06:26,340
対象：一番上のもので、50のために。

138
00:06:26,340 --> 00:06:27,340
CAMILLE REKHSON：50のために？

139
00:06:27,340 --> 00:06:29,040
ああ、そう左端の1は32です。

140
00:06:29,040 --> 00:06:29,760
>> 聴衆：32？

141
00:06:29,760 --> 00:06:36,770
>> CAMILLE REKHSON：ええ、それはそうだろう
その後、32、16、8、4、2、0--または1です。

142
00:06:36,770 --> 00:06:39,380
まあ、それは1である2ゼロ次、です。

143
00:06:39,380 --> 00:06:41,110
うん。

144
00:06:41,110 --> 00:06:43,834
この上の任意の他の質問？

145
00:06:43,834 --> 00:06:47,420
[OK]を、ので、我々はやろうとしています
進と少し。

146
00:06:47,420 --> 00:06:49,570
だから、これは可能性があります
あまり知ら少し、

147
00:06:49,570 --> 00:06:51,680
私が知っているので、我々が行ってきました
より多くのバイナリを持ちます。

148
00:06:51,680 --> 00:06:54,050
しかし、本当に良い方法へ
進を考えます

149
00:06:54,050 --> 00:06:57,540
バイナリを分割することです
4ビットのチャンクに数。

150
00:06:57,540 --> 00:07:00,950
の各4ビットので、
進数は基本的にあり

151
00:07:00,950 --> 00:07:04,560
16進数の1。

152
00:07:04,560 --> 00:07:07,420
>> だから我々は、この最初のものを持っている場合、
私たちは基本的に8 1のを持っています。

153
00:07:07,420 --> 00:07:08,620
だから、それらはup--分割することができます

154
00:07:08,620 --> 00:07:09,600
>> 聴衆：255。

155
00:07:09,600 --> 00:07:10,933
>> CAMILLE REKHSON：再びそれを言います。

156
00:07:10,933 --> 00:07:13,772
AUDIENCE 10進で255、
または16進数で0xFFの。

157
00:07:13,772 --> 00:07:14,980
CAMILLE REKHSON：ええ、そうです。

158
00:07:14,980 --> 00:07:18,860
だから、あなたはそれを分割する場合
2つの4ビットのチャンクに、

159
00:07:18,860 --> 00:07:20,950
私たちは基本的に1の4セットを持っています。

160
00:07:20,950 --> 00:07:22,880
どのmaximum--です
基本的には最大

161
00:07:22,880 --> 00:07:24,329
我々はバイナリの4ビットで取得することができます。

162
00:07:24,329 --> 00:07:27,120
我々が得ることができると最高
16進数で、それはF.になります

163
00:07:27,120 --> 00:07:30,290
だから我々は2つ​​のFのだろう。

164
00:07:30,290 --> 00:07:31,800
その上の任意の質問？

165
00:07:31,800 --> 00:07:32,490
うん？

166
00:07:32,490 --> 00:07:35,184
>> 観客は：あなたはそれを繰り返すことができます。

167
00:07:35,184 --> 00:07:36,100
CAMILLE REKHSON：確かに。

168
00:07:36,100 --> 00:07:39,160
そうそれぞれ、基本的には、
16進数の場所です

169
00:07:39,160 --> 00:07:42,570
バイナリーの4ビットに相当します。

170
00:07:42,570 --> 00:07:46,830
だから、これを行う最も簡単な方法です
4ビットのチャンクにそれを破壊します。

171
00:07:46,830 --> 00:07:48,690
したがって、この場合には、我々は、8つの1のを持っています。

172
00:07:48,690 --> 00:07:51,010
だから我々はそれらを分割する場合
2つの4ビットのチャンクに、

173
00:07:51,010 --> 00:07:54,350
我々は、4つの1の二組を有するであろう。

174
00:07:54,350 --> 00:07:57,181
そして、それらの各1
Fに相当します

175
00:07:57,181 --> 00:07:58,930
あなたはabout--と思うなら
私たちの脳は知っています

176
00:07:58,930 --> 00:08:00,415
種類の考えることを有線
小数を通じより、

177
00:08:00,415 --> 00:08:01,831
それは我々が慣れているものだからです。

178
00:08:01,831 --> 00:08:06,030
あなたはと考えることができるように一つの方法
4 1のは、十進数で15に等しいです。

179
00:08:06,030 --> 00:08:12,960
それはだように16進数で15はFです。
別の方法は、あなたはそれを考えることができます。

180
00:08:12,960 --> 00:08:13,459
うん。

181
00:08:13,459 --> 00:08:14,790
>> 聴衆のための：0xのは何ですか？

182
00:08:14,790 --> 00:08:18,240
>> CAMILLE REKHSONた：0x
それは16進数だことを意味します。

183
00:08:18,240 --> 00:08:21,900
だから我々はちょうどそれを置きます
通常、そこに付けます。

184
00:08:21,900 --> 00:08:24,396
その上の他の質問。

185
00:08:24,396 --> 00:08:27,100
OK、それでは、行く試してみましょう
その後、他の方法。

186
00:08:27,100 --> 00:08:28,712
このケースでは、残念have--？

187
00:08:28,712 --> 00:08:29,628
聴衆：[聞こえません]。

188
00:08:29,628 --> 00:08:32,095

189
00:08:32,095 --> 00:08:33,720
CAMILLE REKHSON：私たちは、バイナリになるだろう。

190
00:08:33,720 --> 00:08:36,039
だから、他の道を行きます。

191
00:08:36,039 --> 00:08:42,090
この場合には、我々は5を持っていると
A.私たちはこれについて考えるのであれば、

192
00:08:42,090 --> 00:08:46,260
those-- 5およびAのそれぞれがある場合
両方の4ビットのチャンクを表現しようと、

193
00:08:46,260 --> 00:08:49,003
どのようにバイナリで5を言うでしょうか？

194
00:08:49,003 --> 00:08:51,120
>> 聴衆：0101。

195
00:08:51,120 --> 00:08:53,100
>> CAMILLE REKHSON：うん、
そのためには、0101部分です。

196
00:08:53,100 --> 00:08:55,250
そして、どのようにin--を言います

197
00:08:55,250 --> 00:08:56,910
>> 聴衆：10。

198
00:08:56,910 --> 00:08:58,243
CAMILLE REKHSON：申し訳ありませんit--を言いますか？

199
00:08:58,243 --> 00:08:58,990
聴衆：10。

200
00:08:58,990 --> 00:09:02,052
CAMILLE REKHSON：うん、そう
それはそれの第二部です。

201
00:09:02,052 --> 00:09:04,010
そして、あなたが置く場合
それらの2一緒に、それはです

202
00:09:04,010 --> 00:09:06,440
あなたは完全に取得する方法
進のバイナリ。

203
00:09:06,440 --> 00:09:06,940
うん？

204
00:09:06,940 --> 00:09:10,620
>> 観客は：Aがあることを知るために
1010年、あなたはそれを暗記しなければなりませんか？

205
00:09:10,620 --> 00:09:12,460
それとも、like--ことができます

206
00:09:12,460 --> 00:09:14,380
>> CAMILLE REKHSON：もしそうであれば
そうyou-- differe--

207
00:09:14,380 --> 00:09:16,790
あなたが通過しているとき
基本的には、バイナリ、バイナリ

208
00:09:16,790 --> 00:09:20,550
0〜9、その後持っています
その16の事などからFまで。

209
00:09:20,550 --> 00:09:25,420
もし9--のすべての方法の場合は0だから、
you-- 9、次にA、基本的に

210
00:09:25,420 --> 00:09:29,640
我々は、A 10進数にそれを変換した場合
10のようになる、Bは11のようになります。

211
00:09:29,640 --> 00:09:35,616
そして、あなたが考えてみれば
バイナリ1010は、8と2であります

212
00:09:35,616 --> 00:09:37,990
それらは2つですので、
10まで追加の場所、どの

213
00:09:37,990 --> 00:09:41,820
Aは同等です正確に何です。

214
00:09:41,820 --> 00:09:45,114
だから、簡単のようなものです
それについて考えるための方法。

215
00:09:45,114 --> 00:09:46,405
進上のその他の質問。

216
00:09:46,405 --> 00:09:50,510

217
00:09:50,510 --> 00:09:56,870
>> [OK]を、今、私たちは取るつもりです
ビット演算子を見て。

218
00:09:56,870 --> 00:09:58,882
したがって、これらは間違いなくすることができます
クイズに出てきます。

219
00:09:58,882 --> 00:10:00,590
私たちは持っていない知っています
彼らと多くのことを働きました。

220
00:10:00,590 --> 00:10:02,756
しかし、我々はちょうどやろうとしています
これらの少し見直し。

221
00:10:02,756 --> 00:10:05,490
だから、うまくいけば、これらは次のようになります
少しより多くのあなたにはおなじみ。

222
00:10:05,490 --> 00:10:10,220
だから、6ビット演算子
私たちはここにリストされていること。

223
00:10:10,220 --> 00:10:13,340
そして、彼らは私たちを操作できます
個々のビット。

224
00:10:13,340 --> 00:10:16,676
だからAND演算子
単一のアンパサンドです。

225
00:10:16,676 --> 00:10:18,550
とそれを混同しないでください
二重アンパサンド、

226
00:10:18,550 --> 00:10:21,840
これは論理的であり、その
私たちは二つのことを比較することができます。

227
00:10:21,840 --> 00:10:25,860
>> シングルとは、どのように我々はできることです
ビット単位のものを操作します。

228
00:10:25,860 --> 00:10:29,910
だから、これは私たちに、両方の場合は1の結果を与えます
我々が比較している引数の

229
00:10:29,910 --> 00:10:32,440
same--又は1です。

230
00:10:32,440 --> 00:10:39,370
そして、垂直バー、ORは、与えます
米国1それらの少なくとも一方が1である場合。

231
00:10:39,370 --> 00:10:41,460
したがって、基本的に、正確に
何の言葉が意味しています。

232
00:10:41,460 --> 00:10:46,640
AND、2ビットである場合
1、1、1は私たちに1を与えます。

233
00:10:46,640 --> 00:10:51,769
しかし、ORで、それはだ場合は0または
1、または1または1のいずれかの場合において、

234
00:10:51,769 --> 00:10:53,060
我々はそれらの一つであるとして1を持っています。

235
00:10:53,060 --> 00:10:54,101
それでは、私たちは1になるだろう。

236
00:10:54,101 --> 00:10:56,320
観客：どういう意味ですか
それは1を与えると言うこと？

237
00:10:56,320 --> 00:10:58,236
>> CAMILLE REKHSON：
結果。種類の、あなたのような

238
00:10:58,236 --> 00:11:05,060
あなたは0と1、行った場合would--
その結果は、1--または0になります

239
00:11:05,060 --> 00:11:08,920
1の結果に
それは申し訳ありませんが、0になります。

240
00:11:08,920 --> 00:11:12,190
ええ、それはのようなものでした
式の結果。

241
00:11:12,190 --> 00:11:16,520
そして、このキャレット記号
XOR、または排他的論理和です。

242
00:11:16,520 --> 00:11:21,920
だから、もっぱら1または正確に意味します
2つの引数のうち一つは1に等しいです。

243
00:11:21,920 --> 00:11:24,210
そして、それはあなたに1を与えるだろう。

244
00:11:24,210 --> 00:11:27,370
>> 少し波線
NOT演算子はあります。

245
00:11:27,370 --> 00:11:31,940
だから、それらの残りの部分とは異なり、
どのビットのペアで動作し、

246
00:11:31,940 --> 00:11:34,930
NOT演算子のみがかかります
1ビット、およびそれを反転します。

247
00:11:34,930 --> 00:11:37,640
だから、あなたが行う場合は、give--場合
0ではない、それはあなたに1を与えるだろう。

248
00:11:37,640 --> 00:11:40,248
そして、あなたは1がない場合は、
それはあなたに0を与えるだろう。

249
00:11:40,248 --> 00:11:40,748
うん？

250
00:11:40,748 --> 00:11:41,150
>> 観客：違いは何ですか
1行との間、または

251
00:11:41,150 --> 00:11:41,983
OR 2と？

252
00:11:41,983 --> 00:11:44,430

253
00:11:44,430 --> 00:11:46,930
CAMILLE REKHSON：だからORで
2行は論理和です。

254
00:11:46,930 --> 00:11:52,430
だから、比較のためです
2つの完全な整数、またはtwo--

255
00:11:52,430 --> 00:11:53,730
物事が等しいかどうかを確認します。

256
00:11:53,730 --> 00:11:58,340
または、これを行うように、これに等しく、
または、これは、このタイプのものに等しいです。

257
00:11:58,340 --> 00:12:04,090
1つのバーOR一方、
物事のビット単位を行うためです。

258
00:12:04,090 --> 00:12:04,590
うん。

259
00:12:04,590 --> 00:12:06,680
>> 観客：あなたがビット単位とはどういう意味ですか？

260
00:12:06,680 --> 00:12:10,330
>> CAMILLE REKHSON：だからビット単位が機能しています
直接バイナリのビットを持ちます。

261
00:12:10,330 --> 00:12:11,596
>> 聴衆：ああ、私は参照してください。

262
00:12:11,596 --> 00:12:15,000
>> CAMILLE REKHSON：うん、そう
0と1での作業。

263
00:12:15,000 --> 00:12:18,310
我々は、このの2つの例をやります
後に、ちょうどので、それはあまりにも混乱はありません。

264
00:12:18,310 --> 00:12:20,970
そして最後の二つがあります
左シフトと右シフト。

265
00:12:20,970 --> 00:12:23,970
基本的には以上2未満であります
標識や看板よりも大きい2。

266
00:12:23,970 --> 00:12:26,294
そして、彼らはビットにシフト
場所の指定された数

267
00:12:26,294 --> 00:12:27,710
あなたは方向にそれを与えること。

268
00:12:27,710 --> 00:12:29,980
だから、どちらかそれをシフトします
左、または右に。

269
00:12:29,980 --> 00:12:30,480
うん？

270
00:12:30,480 --> 00:12:32,470
聴衆：実行するための構文は何ですか？

271
00:12:32,470 --> 00:12:33,950
>> CAMILLE REKHSON：我々はするつもりです
第二の例を通過します。

272
00:12:33,950 --> 00:12:35,680
だからうまくいけば、それが役立ちます。

273
00:12:35,680 --> 00:12:41,060
ちょうど上の任意の質問
[OK]をbefore--、ここまでです。

274
00:12:41,060 --> 00:12:43,821
だから、いくつかの例を通過します。

275
00:12:43,821 --> 00:12:45,070
のは、どれを見てみましょう。

276
00:12:45,070 --> 00:12:47,880
我々は0と1をした場合、我々は何を得るのでしょうか？

277
00:12:47,880 --> 00:12:48,899
>> 聴衆：0。

278
00:12:48,899 --> 00:12:50,690
CAMILLE REKHSON：OK、
私たちは1と1をした場合はどうなりますか？

279
00:12:50,690 --> 00:12:51,622
対象：1。

280
00:12:51,622 --> 00:12:54,490
CAMILLE REKHSON：うん、
私たちは0または1をした場合はどうなりますか？

281
00:12:54,490 --> 00:12:55,094
対象：1。

282
00:12:55,094 --> 00:12:56,510
CAMILLE REKHSON：どのように約1 OR 1？

283
00:12:56,510 --> 00:12:57,404
対象：1。

284
00:12:57,404 --> 00:13:00,410
CAMILLE REKHSON：[OK]を、どのように約0 XOR 1？

285
00:13:00,410 --> 00:13:01,380
対象：1。

286
00:13:01,380 --> 00:13:03,120
CAMILLE REKHSON：そして1 XOR 1？

287
00:13:03,120 --> 00:13:03,902
聴衆：0。

288
00:13:03,902 --> 00:13:05,360
CAMILLE REKHSON：君たちは良いです。

289
00:13:05,360 --> 00:13:06,510
どのように0ではないでしょうか？

290
00:13:06,510 --> 00:13:07,265
>> 対象：1。

291
00:13:07,265 --> 00:13:08,390
CAMILLE REKHSON：AND NOT 1？

292
00:13:08,390 --> 00:13:09,602
聴衆：0。

293
00:13:09,602 --> 00:13:12,810
CAMILLE REKHSON：[OK]をクリックし、この最後の
1はシフトと少し一つです。

294
00:13:12,810 --> 00:13:18,700
だから我々は、最初は8であることがXを設定した場合、および
次に、yはxは3左にシフトされ、

295
00:13:18,700 --> 00:13:19,760
それは、私たちに何を与えるだろうか？

296
00:13:19,760 --> 00:13:20,676
>> 聴衆：[聞こえません]。

297
00:13:20,676 --> 00:13:22,817

298
00:13:22,817 --> 00:13:24,150
CAMILLE REKHSON：再びそれを言います。

299
00:13:24,150 --> 00:13:26,740
聴衆：[聞こえません]。

300
00:13:26,740 --> 00:13:28,766
CAMILLE REKHSON：だから、この
実際に私たちに64を与えます。

301
00:13:28,766 --> 00:13:29,876
聴衆：[聞こえません]。

302
00:13:29,876 --> 00:13:32,250
CAMILLE REKHSON：だから私はちょうどよ
ここでこれを書くつもり、

303
00:13:32,250 --> 00:13:34,700
これは意味の少しになります。

304
00:13:34,700 --> 00:13:45,120
我々は0〜1、2に2を持っている場合は、
2 2に、3から2には8になるだろう。

305
00:13:45,120 --> 00:13:52,380
そして、我々はそれをさらに3ビットをシフトしたい場合は
左側に、それは、2〜4であろう

306
00:13:52,380 --> 00:13:57,270
2〜5、および2
6へ6、及び図2は、64です。

307
00:13:57,270 --> 00:13:59,920

308
00:13:59,920 --> 00:14:01,110
それは理にかなっていますか？

309
00:14:01,110 --> 00:14:05,291

310
00:14:05,291 --> 00:14:05,791
はい。

311
00:14:05,791 --> 00:14:08,725
>> 観客：それはすべて1をシフトしてい
と進数の0のはthe--します

312
00:14:08,725 --> 00:14:09,600
>> CAMILLE REKHSON：はい。

313
00:14:09,600 --> 00:14:12,150

314
00:14:12,150 --> 00:14:15,170
そして、あなたは上で心配する必要はありません
これらは負であることについてのクイズ。

315
00:14:15,170 --> 00:14:19,510
私たちは、あなたが対処することはありません
どのような方法で負にシフトします。

316
00:14:19,510 --> 00:14:24,070
これについては他の質問？

317
00:14:24,070 --> 00:14:24,570
はい。

318
00:14:24,570 --> 00:14:30,570
>> 観客：それは右にシフトしていた場合は、
その何かをwasn't--ものです

319
00:14:30,570 --> 00:14:33,220
もともと事0の一部ではありませんでしたか？

320
00:14:33,220 --> 00:14:37,110
>> CAMILLE REKHSON：ええ、あなたが希望
ちょうど元でに0を追加します。

321
00:14:37,110 --> 00:14:38,110
うん。

322
00:14:38,110 --> 00:14:41,540
>> 聴衆：だから100は何でしょう
3回右にシフト？

323
00:14:41,540 --> 00:14:43,290
CAMILLE REKHSON：100
右にシフトし、

324
00:14:43,290 --> 00:14:46,057
そのためには、すべてを取るだろう
1と0のとちょうどそれらをシフト

325
00:14:46,057 --> 00:14:48,515
何度でも右に
あなたは右にシフトします。

326
00:14:48,515 --> 00:14:50,452
>> 聴衆：[聞こえませんか]？

327
00:14:50,452 --> 00:14:53,160
CAMILLE REKHSON：まあ、100--あります
あなたは、バイナリでは約100の話

328
00:14:53,160 --> 00:14:53,910
または小数で100？

329
00:14:53,910 --> 00:14:55,750
聴衆：私は申し訳ありませんが、バイナリで100。

330
00:14:55,750 --> 00:14:58,916
>> CAMILLE REKHSON：バイナリで100、
あなたはright--にシフトした場合

331
00:14:58,916 --> 00:15:01,040
あなたが右にシフトした場合
一度、それは10となります。

332
00:15:01,040 --> 00:15:04,430
あなたが右にシフトした場合
二回、それは001となります。

333
00:15:04,430 --> 00:15:07,590
そして、あなたは再びそれをシフトすると、
あなたが種類のビットを失います。

334
00:15:07,590 --> 00:15:09,610
うん、それはただ0です。

335
00:15:09,610 --> 00:15:12,140
この上の任意の他の質問？

336
00:15:12,140 --> 00:15:12,835
はい。

337
00:15:12,835 --> 00:15:14,695
>> 観客は：だから、それは000になります。

338
00:15:14,695 --> 00:15:17,020
>> CAMILLE REKHSON：はい。

339
00:15:17,020 --> 00:15:22,150
OK、それでは見ていきましょう
アスキー数学の少し。

340
00:15:22,150 --> 00:15:25,120
だから、文字は基本的にすることができます
整数として扱われます

341
00:15:25,120 --> 00:15:28,290
そのASCII値に基づいて。

342
00:15:28,290 --> 00:15:35,250
我々はint型が座っていたのであればAが65に等しく、Bはint型
プラス1は、int型のchar型のCに等しい等しいです

343
00:15:35,250 --> 00:15:39,565
Dマイナス1、チャーDが68に等しく、
一番下に何をプリントアウトでしょうか？

344
00:15:39,565 --> 00:15:46,150

345
00:15:46,150 --> 00:15:49,720
>> そこで、印刷しています
私たちがしているyou--祝福these--

346
00:15:49,720 --> 00:15:53,520
これらのすべてを印刷
パーセントCに基づいて、文字

347
00:15:53,520 --> 00:15:56,320
だから我々は、基本的には、プリントアウトしています
すべての4つの文字値

348
00:15:56,320 --> 00:15:58,600
これらの変数。

349
00:15:58,600 --> 00:16:04,280
ヒントとして、65がASCII値であります
資本Aのたぶんそれが助けました。

350
00:16:04,280 --> 00:16:04,780
何？

351
00:16:04,780 --> 00:16:05,530
>> 聴衆：ABCD。

352
00:16:05,530 --> 00:16:07,780
>> CAMILLE REKHSON：うん、そう
これは正確にプリントアウトになります

353
00:16:07,780 --> 00:16:10,290
ABCD我々はINT Aを設定しているため
A.のASCII値に等しいです

354
00:16:10,290 --> 00:16:13,085
だから我々は、としてそれをプリントアウトした場合
文字、私たちは、大文字のAを取得します

355
00:16:13,085 --> 00:16:15,540
プラス1は、ASCIIの資本Bになります。

356
00:16:15,540 --> 00:16:19,260
Dマイナス1は、ASCIIの資本Cとなります。

357
00:16:19,260 --> 00:16:25,185
そして68は、ASCII値であります
ASCIIのD.質問の？

358
00:16:25,185 --> 00:16:25,685
はい。

359
00:16:25,685 --> 00:16:31,370
>> 聴衆：だから、二重引用符は周りマーク
、その変更AはASCIIにしますか？

360
00:16:31,370 --> 00:16:34,456
>> CAMILLE REKHSON：それはそれをuses--
Aを中心count--単一引用符

361
00:16:34,456 --> 00:16:35,330
それ文字になります。

362
00:16:35,330 --> 00:16:37,600
そして、あなたが扱っている場合
それ数のform--

363
00:16:37,600 --> 00:16:40,320
そのようにすると、この場合には、それはのような
int--として取り扱われています

364
00:16:40,320 --> 00:16:44,664
それに対処することになります
それにASCII値です。

365
00:16:44,664 --> 00:16:45,164
はい。

366
00:16:45,164 --> 00:16:50,060
>> 観客は：あなたがすることをお勧めしますか
我々は、ASCII参照表がありますか？

367
00:16:50,060 --> 00:16:51,900
>> CAMILLE REKHSON：私はthink--ません

368
00:16:51,900 --> 00:16:54,720
>> 聴衆：またはそれだけだろう
これらに対処しますか？

369
00:16:54,720 --> 00:16:56,210
>> CAMILLE REKHSON：私は、私たちを考えます
簡単な事でそれを行うだろう。

370
00:16:56,210 --> 00:16:58,168
私はそれはないと思います
多分書き留めて傷つけます

371
00:16:58,168 --> 00:17:02,653
まさに大文字のAと小文字Aであり、
何これらの範囲で始まるされています。

372
00:17:02,653 --> 00:17:05,819
しかし、私はあなたがすべてを取る必要はないと思います
全体のASCIIテーブルを置くためのスペース。

373
00:17:05,819 --> 00:17:06,803
うん。

374
00:17:06,803 --> 00:17:09,755
>> 観客：違いは何ですか
言ってint型のA及びチャーCとの間、

375
00:17:09,755 --> 00:17:12,720
あなたのような上部のですか？

376
00:17:12,720 --> 00:17:17,380
>> CAMILLE REKHSON：だからそれだけです
どのようにメモリに格納されています。

377
00:17:17,380 --> 00:17:20,010
しかし、あなたはそれのいずれかの方法で扱うことができます。

378
00:17:20,010 --> 00:17:23,274
私たちはここを参照してくださいように、私たちは、印刷を行います
文字としてのAアウト。

379
00:17:23,274 --> 00:17:24,690
聴衆：だから、同じですか？

380
00:17:24,690 --> 00:17:25,606
CAMILLE REKHSON：うん。

381
00:17:25,606 --> 00:17:28,030

382
00:17:28,030 --> 00:17:29,537
その他の質問は？

383
00:17:29,537 --> 00:17:32,022
>> 聴衆：だから、パーセントC
文字を印刷すると言っていますか？

384
00:17:32,022 --> 00:17:33,016
>> CAMILLE REKHSON：はい。

385
00:17:33,016 --> 00:17:35,501
>> 観客：Aは唯一持っている場合でも、それで
整数として定義され、

386
00:17:35,501 --> 00:17:37,569
我々は、印刷しようとした場合
65のようなチャーは、それがwould--

387
00:17:37,569 --> 00:17:40,110
CAMILLE REKHSON：それはに行くだろう
基本的には、ASCIIチャートに行きます

388
00:17:40,110 --> 00:17:42,990
そして、どのような文字を取得します
その65のASCIIチャートインチ

389
00:17:42,990 --> 00:17:43,840
>> 観客は：ありがとうございます。

390
00:17:43,840 --> 00:17:44,756
>> CAMILLE REKHSON：うん。

391
00:17:44,756 --> 00:17:45,445
はい？

392
00:17:45,445 --> 00:17:50,620
>> 聴衆：だからあなたは％の私は、％Iをした場合、
％私は、％I、それだけでprint--だろう

393
00:17:50,620 --> 00:17:52,620
CAMILLE REKHSON：うん、
あなたが行った場合、すべての4％の私の、それ

394
00:17:52,620 --> 00:17:57,170
ASCIIをプリントアウトするだろう
これらのすべての4つの値。

395
00:17:57,170 --> 00:17:59,483
その他の質問は？

396
00:17:59,483 --> 00:18:06,310
[OK]を、ので、スコープ、基本的にはこの
私たちはどこで判断するのに役立ちます

397
00:18:06,310 --> 00:18:08,450
変数は、プログラム内に存在します。

398
00:18:08,450 --> 00:18:11,910
だから我々は、異なる2について話してきました
スコープの種類、グローバルとローカル。

399
00:18:11,910 --> 00:18:14,560
>> 変数がグローバルスコープされている場合は、
それはあなたのプログラム全体を意味

400
00:18:14,560 --> 00:18:16,292
その変数にアクセスできます。

401
00:18:16,292 --> 00:18:18,000
そして、あなたの場合、グローバル
スコープ変数は、

402
00:18:18,000 --> 00:18:19,510
メインの関数の前にそれを宣言します。

403
00:18:19,510 --> 00:18:20,830
だから、それが右のバット完了です。

404
00:18:20,830 --> 00:18:22,950
そして、あなたの全体の
プログラムはそれにアクセスすることができます。

405
00:18:22,950 --> 00:18:26,070
>> それが唯一のローカルスコープの場合は、その
特定の領域に制限変数。

406
00:18:26,070 --> 00:18:29,705
だから、forループ内で宣言した場合、
それだけでは、ループのためにそれにアクセスすることができます。

407
00:18:29,705 --> 00:18:31,580
それとも、内部で宣言した場合
特定の機能、

408
00:18:31,580 --> 00:18:34,940
唯一その関数はそれにアクセスすることができます。

409
00:18:34,940 --> 00:18:38,265
スコープに関する質問。

410
00:18:38,265 --> 00:18:41,570
>> [OK]を、ので、機能プロトタイピング。

411
00:18:41,570 --> 00:18:45,360
基本的にはC、理由
それはトップダウン読み取り、コンパイルします。

412
00:18:45,360 --> 00:18:48,800
あなたは、関数を宣言すると
後半のコードで、

413
00:18:48,800 --> 00:18:51,670
コンパイラは知りません
その機能が存在していること。

414
00:18:51,670 --> 00:18:55,690
だから我々は、使用しているもののプロトタイプであり、
これは、基本的には、コンパイラに伝えます

415
00:18:55,690 --> 00:18:58,710
この機能は見に行く、存在します
そのため、後のコードです。

416
00:18:58,710 --> 00:19:00,900
だから、あなたのやり方
関数原型

417
00:19:00,900 --> 00:19:03,020
あなたが開始する正確にどのようにあります
関数を記述オフ。

418
00:19:03,020 --> 00:19:05,310
あなたは戻り値の型を与えます、
関数の名前、

419
00:19:05,310 --> 00:19:08,930
し、任意の引数
その関数が取ること。

420
00:19:08,930 --> 00:19:13,970
>> そこで、この中には、簡単な例を見て
ここで使用している私達の機能を小文字

421
00:19:13,970 --> 00:19:15,340
基本的にキューブ関数です。

422
00:19:15,340 --> 00:19:19,170
だから整数に取って、
その整数の三乗を返します。

423
00:19:19,170 --> 00:19:23,190
だから我々はそれを書いたので、
主な機能以下の機能、

424
00:19:23,190 --> 00:19:26,300
私たちは利用したいです
that--か、我々の出力

425
00:19:26,300 --> 00:19:28,630
その機能にしたいです
私たちの主な機能で、

426
00:19:28,630 --> 00:19:31,980
我々はそのプロトタイプの道を置きます
私たちのプログラムの上部にあります。

427
00:19:31,980 --> 00:19:34,460
そして、我々が呼ぶとき
それ私たちの主な機能で、

428
00:19:34,460 --> 00:19:38,800
コンパイラは、関数であることを知っています
後に書かれており、それを見に行くだろう、

429
00:19:38,800 --> 00:19:40,910
それを適切に使用します。

430
00:19:40,910 --> 00:19:45,190
プロトタイピングに関する質問？

431
00:19:45,190 --> 00:19:45,690
はい。

432
00:19:45,690 --> 00:19:46,940
>> 聴衆：だからポイントは何ですか？

433
00:19:46,940 --> 00:19:49,374

434
00:19:49,374 --> 00:19:50,915
私はプロトタイプのポイントを得ることはありません。

435
00:19:50,915 --> 00:19:52,820
なぜそこにそれを持っていませんか？

436
00:19:52,820 --> 00:19:54,903
>> CAMILLE REKHSON：まあ場合
それはときに、ここでダウン

437
00:19:54,903 --> 00:19:57,020
あなたのラインキューブを取得
あなたの主な機能でのx、

438
00:19:57,020 --> 00:19:59,495
コンパイラは考えているということ
キューブ関数が実際に存在します。

439
00:19:59,495 --> 00:20:01,310
>> 聴衆：あなたことができませんでした
ちょうど前にそれを置きますか？

440
00:20:01,310 --> 00:20:02,350
>> CAMILLE REKHSON：それは
よりよいコーディングの練習

441
00:20:02,350 --> 00:20:04,150
あなたの主な機能の下に置きます。

442
00:20:04,150 --> 00:20:06,350
なぜ我々はだろうだから、です
プロトタイピングを行います。

443
00:20:06,350 --> 00:20:07,680
ちょうどあなたの場合、理由
多くの機能を持っていました、

444
00:20:07,680 --> 00:20:10,180
それはには本当に厄介になります
これらすべての機能を読んで

445
00:20:10,180 --> 00:20:12,030
あなたはプログラムの肉に到達する前に。

446
00:20:12,030 --> 00:20:13,888
うん、あなたはq--を持っていました

447
00:20:13,888 --> 00:20:16,796
>> 聴衆：だから、宣言されました
上部にあなたの変数アップ

448
00:20:16,796 --> 00:20:18,795
あなたはそれにアクセスすることができ、
それグローバル変数にしますか？

449
00:20:18,795 --> 00:20:21,119
それは次のようなものです。
どこにそれを宣言しています

450
00:20:21,119 --> 00:20:23,660
そこに、そのことは知っているので、
それは後でそれにアクセスするために起こっています

451
00:20:23,660 --> 00:20:24,762
そして、あなたはそれを使用することができますか？

452
00:20:24,762 --> 00:20:26,146
>> CAMILLE REKHSON：うん。

453
00:20:26,146 --> 00:20:26,646
はい。

454
00:20:26,646 --> 00:20:30,414
>> 観客は：任意の追加をthe--べき
機能あなたが外のキーを作成します

455
00:20:30,414 --> 00:20:31,840
この事の、or--

456
00:20:31,840 --> 00:20:33,760
>> CAMILLE REKHSON：ええ、あなたがしている場合
他functions--メインを作成します

457
00:20:33,760 --> 00:20:36,385
自身がそうであればfunction--です
あなたは他の関数を作成しています、

458
00:20:36,385 --> 00:20:37,555
彼らは外にする必要があります。

459
00:20:37,555 --> 00:20:38,055
はい？

460
00:20:38,055 --> 00:20:39,734
>> 聴衆：パーセントDは何ですか？

461
00:20:39,734 --> 00:20:42,150
CAMILLE REKHSON：パーセントDは
パーセントI.と同じもの

462
00:20:42,150 --> 00:20:45,915
これは整数を意味します。

463
00:20:45,915 --> 00:20:47,895
はい。

464
00:20:47,895 --> 00:20:50,370
>> 聴衆：だからint型の主な事は何ですか？

465
00:20:50,370 --> 00:20:51,724
その空隙は何でしたか？

466
00:20:51,724 --> 00:20:53,890
CAMILLE REKHSON：ボイドは言います
それは、引数なしで取ります。

467
00:20:53,890 --> 00:20:55,320
聴衆：[聞こえません]。

468
00:20:55,320 --> 00:20:57,570
CAMILLE REKHSON：することができます
少し大きな声を話す、申し訳ありませんか？

469
00:20:57,570 --> 00:21:00,153
聴衆：ええ、申し訳ありませんが、なぜでした
あなたは、最初のもののために無効に入れます

470
00:21:00,153 --> 00:21:02,297
そして、第2の1の入力をint型？

471
00:21:02,297 --> 00:21:04,720

472
00:21:04,720 --> 00:21:07,470
CAMILLE REKHSON：ああ、二人
主な機能のためにdifferent--

473
00:21:07,470 --> 00:21:09,290
キューブ機能対？

474
00:21:09,290 --> 00:21:13,360
だから、主な機能で、
我々は理由があり、ボイドを使用

475
00:21:13,360 --> 00:21:16,870
に取られてはパラメータはありません。

476
00:21:16,870 --> 00:21:19,425
キューブ内の一方
機能、我々は、入力を持っています。

477
00:21:19,425 --> 00:21:22,300
それはint型を言う理由は、入力です、
私たちがしているの引数がありますので、

478
00:21:22,300 --> 00:21:24,571
私たちの関数を実行するには取ります。

479
00:21:24,571 --> 00:21:25,070
うん。

480
00:21:25,070 --> 00:21:27,770

481
00:21:27,770 --> 00:21:30,464
質問がありますか？

482
00:21:30,464 --> 00:21:34,520
>> [OK]をクリックし、すぐに
浮動小数点の不正確。

483
00:21:34,520 --> 00:21:37,200
だから我々は無限に多くの実数を持っています。

484
00:21:37,200 --> 00:21:38,950
しかし、唯一の存在
ビットの有限数

485
00:21:38,950 --> 00:21:42,880
我々は、これらの表示に使用することができます
数、およびそれらを表します。

486
00:21:42,880 --> 00:21:45,020
それでは、我々はいくつかの不正確で終わります。

487
00:21:45,020 --> 00:21:49,190
そして、あなたの数字はしません
常に非常に正確に何であります

488
00:21:49,190 --> 00:21:51,810
あなたがしているとき、彼らはあると思います
浮動小数点を扱います。

489
00:21:51,810 --> 00:21:53,650
これは知っておくとよいだけのものです。

490
00:21:53,650 --> 00:21:56,628
このに関する質問？

491
00:21:56,628 --> 00:21:59,610
はい。

492
00:21:59,610 --> 00:22:02,090
>> 観客：これは参照しています
ビットオーバーフローの考えに

493
00:22:02,090 --> 00:22:03,089
それは講義中でしたか？

494
00:22:03,089 --> 00:22:06,080
何かが分離ということでしたか？

495
00:22:06,080 --> 00:22:09,650
>> CAMILLE REKHSON：彼らはしています
完全に独立した、ええ。

496
00:22:09,650 --> 00:22:11,160
[OK]を、素晴らしいです。

497
00:22:11,160 --> 00:22:16,369

498
00:22:16,369 --> 00:22:17,452
PULAK Goyal氏：こんにちは、誰もが。

499
00:22:17,452 --> 00:22:19,872
私の名前はPulakある、と私はよ
ポインタを介して行くこと。

500
00:22:19,872 --> 00:22:23,260

501
00:22:23,260 --> 00:22:25,720
[OK]を、ので、まずは考えてみましょう
メモリがどのように見えるかについて。

502
00:22:25,720 --> 00:22:28,610
だから、ここで私たちを見ることができるように
メモリを取る、我々はそれを分割

503
00:22:28,610 --> 00:22:30,090
ブロックの束に。

504
00:22:30,090 --> 00:22:33,150
そして、私たちはそれぞれの参照
アドレスによるブロック、右？

505
00:22:33,150 --> 00:22:37,196
そして、誰もがどのようなタイプの覚えていません
表記我々はアドレスを表すために使うのか？

506
00:22:37,196 --> 00:22:38,510
>> 聴衆：16進、0X。

507
00:22:38,510 --> 00:22:39,510
>> PULAK Goyal氏：16進、右？

508
00:22:39,510 --> 00:22:41,509
だから0Xは、私たちがしていることを意味します
進の話。

509
00:22:41,509 --> 00:22:45,740

510
00:22:45,740 --> 00:22:48,360
[OK]を、ので、どのように我々は、ポインタを作成するのですか？

511
00:22:48,360 --> 00:22:51,960
だから我々は、我々の型を取ります
it--がそれにスターを追加入れ、

512
00:22:51,960 --> 00:22:53,760
し、我々は、変数名を追加します。

513
00:22:53,760 --> 00:22:59,280
だから我々が見てきた例はint型です
星のx、char型のスターyおよびフロートは、z開始します。

514
00:22:59,280 --> 00:23:01,380
だから私が言うとき、int型のスター
xは、誰かが私に言うことができます

515
00:23:01,380 --> 00:23:03,965
私はそこの話のようなものですか？

516
00:23:03,965 --> 00:23:05,710
>> 対象：ディスクの場所。

517
00:23:05,710 --> 00:23:06,890
>> PULAK Goyal氏：申し訳ありませんが、何？

518
00:23:06,890 --> 00:23:07,723
それを繰り返してくれませんか？

519
00:23:07,723 --> 00:23:09,250
対象：ディスクの場所。

520
00:23:09,250 --> 00:23:12,390
>> PULAK Goyal氏：だからactually--そう何
私は、我々はint型のスターxを持っているときである、意味しました

521
00:23:12,390 --> 00:23:14,400
我々は作成していると言っています
ポインタ、それ

522
00:23:14,400 --> 00:23:17,130
のアドレスを格納することができます
int型変数ですよね？

523
00:23:17,130 --> 00:23:21,810
char型のスターYとそう、
我々は、ポインタを作成しています

524
00:23:21,810 --> 00:23:24,220
それは、アドレスを格納することができます
シャア変数の。

525
00:23:24,220 --> 00:23:26,270
だから、皆に意味をなさない？

526
00:23:26,270 --> 00:23:29,600
うんいいね

527
00:23:29,600 --> 00:23:33,450
>> [OK]を、ポインタを持つので、あります
私たちが行うことができる2つの重要な操作。

528
00:23:33,450 --> 00:23:36,630
そこ参照だし、
参照解除があります。

529
00:23:36,630 --> 00:23:37,130
うん？

530
00:23:37,130 --> 00:23:38,760
>> 観客：あなたが行くことができます
少し遅くなりますか？

531
00:23:38,760 --> 00:23:39,510
>> PULAK Goyal氏：確かに。

532
00:23:39,510 --> 00:23:45,350
私が行くようにうん、うんso--、質問をします
you--場合に沿って何かが不明である場合。

533
00:23:45,350 --> 00:23:47,240
だから我々は参照しています
そして、逆参照。

534
00:23:47,240 --> 00:23:51,680
だから、アドレスを取得したい場合
変数の場合、アンパサンドを使用しています。

535
00:23:51,680 --> 00:23:53,620
それでは、私はどこかのint xを宣言したとしましょう​​。

536
00:23:53,620 --> 00:23:57,450
そして、私はそれのアドレスを取得したいです
私はアンパサンドXをするだろう、それを渡します。

537
00:23:57,450 --> 00:24:01,260
そして、あなたが取得したいとき
ポインタに関連付けられた値、

538
00:24:01,260 --> 00:24:04,670
あなたは間接参照を使用します
スターであるオペレータ、。

539
00:24:04,670 --> 00:24:08,570
>> だから私はint型スターxを持っていた、と言うことができます
私はそれが何かを指していました。

540
00:24:08,570 --> 00:24:13,510
私はそれが何の値を取得したい場合
指して、私はちょうど星のxを行うだろう。

541
00:24:13,510 --> 00:24:14,960
それは明らかですか？

542
00:24:14,960 --> 00:24:16,390
それについてのご質問？

543
00:24:16,390 --> 00:24:18,129
うん。

544
00:24:18,129 --> 00:24:25,275
>> 聴衆：だから、一般的に、あなたは
xと星を行うことができなくなります

545
00:24:25,275 --> 00:24:27,135
同じxを使用して、x。

546
00:24:27,135 --> 00:24:28,740
あれは正しいですか？

547
00:24:28,740 --> 00:24:31,800
xがある場合ため
変数、あなたが持っています

548
00:24:31,800 --> 00:24:35,980
それはポインタだと取得するために、xで行います。

549
00:24:35,980 --> 00:24:40,810
xがポインタである場合しかし、あなたは必要とします
変数を取得するために、スターxをすることができません。

550
00:24:40,810 --> 00:24:43,240
>> PULAK Goyal氏：はい、そう
質問は時程度でした

551
00:24:43,240 --> 00:24:45,750
我々はstar--ときに使用します
あなたは星を使用し、

552
00:24:45,750 --> 00:24:47,470
そして私たちが使用するとき
アンパサンド、と私たちすることができます

553
00:24:47,470 --> 00:24:49,160
変数の同じタイプでそれを使うのか？

554
00:24:49,160 --> 00:24:51,810
だから、通常がある場合は、
例えば、int型のx、

555
00:24:51,810 --> 00:24:55,170
あなたは、主に使用しているだろう
アンパサンドは、そのアドレスを取得します。

556
00:24:55,170 --> 00:24:58,220
それはありませんので、
Xに服従する感覚。

557
00:24:58,220 --> 00:25:04,220
一方、我々はint型のスターxを持っていた場合、
あなたは間接参照操作を使用しているだろう

558
00:25:04,220 --> 00:25:07,910
それは意味をなさない。なぜなら
その場合には、xで使用することができます。

559
00:25:07,910 --> 00:25:09,582
それは理にかなっていますか？

560
00:25:09,582 --> 00:25:13,192
>> 観客：あなたがすることはできませんので、
そして、その後、ポインタ？

561
00:25:13,192 --> 00:25:14,900
PULAK Goyal氏：だから、
技術的には、実際に

562
00:25:14,900 --> 00:25:16,870
ポインタのアンパサンドを行うことができます。

563
00:25:16,870 --> 00:25:18,984
しかし、それは外です
このクラスのスコープ。

564
00:25:18,984 --> 00:25:21,900
「あなたの男性のためのpurpose--用
目的は、いつでもあなたは、ポインタを持っています

565
00:25:21,900 --> 00:25:25,191
あなたは間接参照演算子を使用したいです
その関連付けられた値を取得します。

566
00:25:25,191 --> 00:25:27,380
そして、あなたが定期的に持っているとき
変数、int型のXのように、

567
00:25:27,380 --> 00:25:31,410
あなたはアンパサンドを使用したいです
オペレータは、そのアドレスを取得します。

568
00:25:31,410 --> 00:25:31,910
OK？

569
00:25:31,910 --> 00:25:35,670

570
00:25:35,670 --> 00:25:38,850
>> OK、それでは、ポインタを見てみましょう
そして何がフードの下で起こります。

571
00:25:38,850 --> 00:25:42,640
だから私はここに最初に行った事があります
宣言されたint型のxは5に等しいです。

572
00:25:42,640 --> 00:25:48,460
この変数のアドレス
0x04ので、値は5です。

573
00:25:48,460 --> 00:25:52,940
それでは、何が起こるか見てみましょう
次の行を持ちます。

574
00:25:52,940 --> 00:25:55,130
だから今、私たちは、ポインタを宣言します。

575
00:25:55,130 --> 00:26:01,450
そのアドレスは0x08にあり、その
値は、xのアドレスです。

576
00:26:01,450 --> 00:26:05,220
それは皆に意味がありますか？

577
00:26:05,220 --> 00:26:06,507
それについてのご質問？

578
00:26:06,507 --> 00:26:09,130

579
00:26:09,130 --> 00:26:13,080
>> [OK]を、今のは何を見てみましょう
次の行で発生します。

580
00:26:13,080 --> 00:26:18,140
したがって、この次の行では、我々は持っています
コピーのアドレスが0x10のあること、

581
00:26:18,140 --> 00:26:20,780
その値は5です。

582
00:26:20,780 --> 00:26:23,570
私たちは5を持ってそうな理由
我々は間接参照、と言われています

583
00:26:23,570 --> 00:26:26,740
我々はint型のスターを宣言したポインタ、。

584
00:26:26,740 --> 00:26:35,797
ときに我々そしてそれは、それを間接参照went--、
それは、スロットは0x04にあるもの、[OK]を、と述べました。

585
00:26:35,797 --> 00:26:36,630
そして、それはそれに行ってきました。

586
00:26:36,630 --> 00:26:40,785
そして、何のx x0--です
0x04の、その値は5です。

587
00:26:40,785 --> 00:26:41,660
それは理にかなっていますか？

588
00:26:41,660 --> 00:26:42,334
うん？

589
00:26:42,334 --> 00:26:50,090
>> 聴衆：なぜコピーのアドレス
Xポインタ上記の4バイトだけ？

590
00:26:50,090 --> 00:26:52,318
>> PULAK Goyal氏：はい、これは間違いですon--

591
00:26:52,318 --> 00:26:55,304
>> CAMILLE REKHSON：だから、はい、覚えています
この、16進数で書かれています。

592
00:26:55,304 --> 00:26:56,220
PULAK Goyal氏：ああ、うん。

593
00:26:56,220 --> 00:26:58,615
CAMILLE REKHSON：だから、この
実際には8、その後16

594
00:26:58,615 --> 00:27:00,960
我々はそれを言ったので、
ポインタは、覚えています、

595
00:27:00,960 --> 00:27:05,330
私たちのIDEで8バイト長であることを行っています。

596
00:27:05,330 --> 00:27:06,080
PULAK Goyal氏：ええ。

597
00:27:06,080 --> 00:27:09,160

598
00:27:09,160 --> 00:27:12,540
だから明確にするために、
ポインタは8バイト長です。

599
00:27:12,540 --> 00:27:14,160
intが4バイトです。

600
00:27:14,160 --> 00:27:18,380
だから理由は何を
0×04から0×08にジャンプ

601
00:27:18,380 --> 00:27:20,980
私たちがしなければならなかったからです
8バイトのジャンプを行います。

602
00:27:20,980 --> 00:27:24,396
それ以来、for--
コピーは、単にintで

603
00:27:24,396 --> 00:27:26,020
それは、8バイトの半分である4バイトです。

604
00:27:26,020 --> 00:27:29,970
だから私たちはただの0x10にジャンプし、
これは離れて0x08のから2です。

605
00:27:29,970 --> 00:27:33,100

606
00:27:33,100 --> 00:27:34,570
その他の質問は？

607
00:27:34,570 --> 00:27:36,850
[OK]を、そうlet's--？

608
00:27:36,850 --> 00:27:39,245
>> 聴衆：なぜではありません
int型のコピーの値

609
00:27:39,245 --> 00:27:45,000
それは5の代わりに0x04がある理由だけthe--？

610
00:27:45,000 --> 00:27:46,270
>> PULAK Goyal氏：OK、なぜそれがある5？

611
00:27:46,270 --> 00:27:51,600
[OK]を、ので、the--はので、最初のときましょう
種類の面でこれについて考えます。

612
00:27:51,600 --> 00:27:55,600
だから私は、int型のコピーを言っています
ポインタの星に等しいです。

613
00:27:55,600 --> 00:27:57,490
だから、ポインタの型は何ですか？

614
00:27:57,490 --> 00:27:59,310
これは、int型のスターです。

615
00:27:59,310 --> 00:28:03,850
そして、ときに私そのデリファレンス、
型はintになります。

616
00:28:03,850 --> 00:28:06,570
だから我々は、保存するために期待するもの
ここでは実際にintです。

617
00:28:06,570 --> 00:28:07,965
それは理にかなっていますか？

618
00:28:07,965 --> 00:28:09,090
聴衆：確かに、少し。

619
00:28:09,090 --> 00:28:11,465
PULAK Goyal氏：だから、通常時
あなたがタイプの観点から考えます、

620
00:28:11,465 --> 00:28:15,607
それはあなたが何であるかを理解するのに役立ちます
そこに行くべき値の型。

621
00:28:15,607 --> 00:28:17,940
だから、通常は除外することができます
これらの一般的なエラーの多く

622
00:28:17,940 --> 00:28:21,790
種類の観点で考えることもできます。

623
00:28:21,790 --> 00:28:23,612
私はもう少しスライド見ていきましょう。

624
00:28:23,612 --> 00:28:26,070
そして、我々は、質問を受けることができます
ポインタ部の終わり。

625
00:28:26,070 --> 00:28:28,910

626
00:28:28,910 --> 00:28:32,290
[OK]を、ので、ここでバグのあるプログラムを持っています。

627
00:28:32,290 --> 00:28:35,460
そしてそうanyone--は誰かを伝えることができません
私は、このプログラムの何が問題になっているのですか？

628
00:28:35,460 --> 00:28:39,000

629
00:28:39,000 --> 00:28:40,820
右、私たちはしているもの
ここで行うことを期待

630
00:28:40,820 --> 00:28:44,520
私たちが何をしたいですis--
変数xはintを取るです

631
00:28:44,520 --> 00:28:48,350
それに等しい5作るit--を回します
代わりに3のと、その印刷します。

632
00:28:48,350 --> 00:28:49,640
しかし、それは起こっていません。

633
00:28:49,640 --> 00:28:50,950
なぜ誰かが私に言うことはできますか？

634
00:28:50,950 --> 00:28:51,934
はい？

635
00:28:51,934 --> 00:28:54,840
>> 聴衆：とき機能
それが引数のようto_fiveは、xを使って

636
00:28:54,840 --> 00:28:58,130
それはx自身かかりませんが、
代わりにそれを、コピーを作成します。

637
00:28:58,130 --> 00:29:00,115
そして、それはその上の操作を形成しています。

638
00:29:00,115 --> 00:29:02,614
しかし、そのため、あなたはしないでください
xの実際の値を変更します。

639
00:29:02,614 --> 00:29:03,970
あなたは[聞こえない]しているので。

640
00:29:03,970 --> 00:29:07,950
>> PULAK Goyal氏：右、
右、私たちが呼ぶとき

641
00:29:07,950 --> 00:29:10,100
機能to_five、どのような
我々は考えてやっています、

642
00:29:10,100 --> 00:29:12,550
私のコピーを与えます
その関数に値。

643
00:29:12,550 --> 00:29:16,010
その関数は、その後、起こっています
いくつかの操作を行います。

644
00:29:16,010 --> 00:29:21,260
それは返すしかし、一度、それはアウトになりましです
ここでの主な機能の範囲。

645
00:29:21,260 --> 00:29:24,750
だからxが実際には、まだ、
3に等しく、我々は3を印刷します。

646
00:29:24,750 --> 00:29:26,445
OK、それでは、この問題が発生したか見てみましょう。

647
00:29:26,445 --> 00:29:29,430

648
00:29:29,430 --> 00:29:31,180
>> [OK]を、そう宣言したものはありません。

649
00:29:31,180 --> 00:29:34,490
次に、ここで、xは3です。

650
00:29:34,490 --> 00:29:40,820
そして今、それは位置にis--
2、aがスコープにまだありません。

651
00:29:40,820 --> 00:29:46,790
そして今、我々は、3を配置するために行きます
今3の値をとるあります。

652
00:29:46,790 --> 00:29:49,380
4で、我々は今、5に変更します。

653
00:29:49,380 --> 00:29:53,290
しかし、今、私たちが戻ってジャンプしたとき
print文である5、

654
00:29:53,290 --> 00:29:55,380
スコープ外になりました。

655
00:29:55,380 --> 00:29:57,450
xはまだ​​3に等しいです。

656
00:29:57,450 --> 00:29:59,700
これは、すべての人に意味がありますか？

657
00:29:59,700 --> 00:30:03,010
[OK]を、ので、今のは方法について話しましょう
我々はこの問題を解決するためにポインタを使用することができます。

658
00:30:03,010 --> 00:30:06,140
誰がどんな考えを持っていますどのように我々
ポインタを使用することによってこの問題を解決するだろうか？

659
00:30:06,140 --> 00:30:08,710

660
00:30:08,710 --> 00:30:11,490
>> 聴衆：あなたはint型のスターに取ります
代わりにto_fiveにintの。

661
00:30:11,490 --> 00:30:12,530
>> PULAK Goyal氏：申し訳ありませんが、あなたが発言だろうか？

662
00:30:12,530 --> 00:30:15,266
>> 聴衆：あなたはint型のスターに取ります
代わりにto_fiveにintの。

663
00:30:15,266 --> 00:30:16,140
PULAK Goyal氏：OK、はい。

664
00:30:16,140 --> 00:30:20,250
それでは、ただ渡す代わりpass--てみましょう
値は、のは、参照することにより、それを渡すことができます。

665
00:30:20,250 --> 00:30:21,690
右この新しい機能、？

666
00:30:21,690 --> 00:30:25,210
そして、私たちにアドレスを渡すことにより、
アドレスに操作を行うことができます。

667
00:30:25,210 --> 00:30:27,400
そして、私たちが実際にしています、
実際には、Xを変えます。

668
00:30:27,400 --> 00:30:30,570
それでは、それがどのように機能するかを見てみましょう。

669
00:30:30,570 --> 00:30:32,950
>> [OK]を、ので、この例では、我々はそれを修正しました。

670
00:30:32,950 --> 00:30:38,000
私たちは、署名を変更しました
int型に取るto_five

671
00:30:38,000 --> 00:30:40,540
代わりに、ここだけでint型のスター。

672
00:30:40,540 --> 00:30:45,470
その後、我々この間接参照
Aとそれに5を割り当てます。

673
00:30:45,470 --> 00:30:48,090
そして今、この意志は、実際には、5を印刷します。

674
00:30:48,090 --> 00:30:51,960
それでは、手順がここでどのように機能するかを見てみましょう。

675
00:30:51,960 --> 00:30:55,200
>> したがって、最初のステップと、
まだ宣言されたものはありません。

676
00:30:55,200 --> 00:31:00,140
そこでここでは、第二のステップと、
我々は、xが3であると述べてきました

677
00:31:00,140 --> 00:31:03,970
しかし、スコープの外にはまだです。

678
00:31:03,970 --> 00:31:08,100
今三線で、私たちは持っています
xはまだ​​3に等しいです。

679
00:31:08,100 --> 00:31:14,150
そして今、私たちは何in--合格しています
今、xのアドレスであるに格納されています。

680
00:31:14,150 --> 00:31:16,760
に意味があるかという
誰も、我々はそれを得た方法？

681
00:31:16,760 --> 00:31:21,470
右、私たちはどのようなamper--を持っています
我々は、関数にアンパサンドxを渡します

682
00:31:21,470 --> 00:31:23,040
to_five。

683
00:31:23,040 --> 00:31:30,330
そして、次の行に、どのような
我々は、我々は間接参照しています。

684
00:31:30,330 --> 00:31:36,120
>> そして参照解除によって、私たちは可能です
3から5にxの値を変更します。

685
00:31:36,120 --> 00:31:38,560
xはそのアドレスが0x12に住んでいるので。

686
00:31:38,560 --> 00:31:42,440

687
00:31:42,440 --> 00:31:45,810
そして、最後に、時
私たちは、主に戻り

688
00:31:45,810 --> 00:31:50,570
このaが外になりましたですが、
スコープ、我々は、実際には、Xを変更しました。

689
00:31:50,570 --> 00:31:51,570
そしてそれは5です。

690
00:31:51,570 --> 00:31:55,160
これについてのご質問？

691
00:31:55,160 --> 00:31:56,036
うん？

692
00:31:56,036 --> 00:31:58,185
>> 観客：あなたは私を伝えることができ
アンパサンドxは何でしたか？

693
00:31:58,185 --> 00:32:00,004
私はアンパサンドが好きだと思いました。

694
00:32:00,004 --> 00:32:03,480

695
00:32:03,480 --> 00:32:07,210
>> PULAK Goyal氏：はい、私たちは同じを使用
多くの異なった事のシンボル。

696
00:32:07,210 --> 00:32:11,470
だからここに、あなたがhave--時
この場合、あなたが持っているとき、

697
00:32:11,470 --> 00:32:19,380
私はときに、このケースではそうguess--
あなたは、ポインタを扱っています

698
00:32:19,380 --> 00:32:23,640
あなたが前にアンパサンドを置いたとき
int型変数のint型、またはcharの、

699
00:32:23,640 --> 00:32:28,609
またはフローは、あなたが何を言っています
で、私はこののアドレスを与えます。

700
00:32:28,609 --> 00:32:31,900
しかし、どのようなあなたが考えていた、ときに他の
あなたは、のは言わせているアンパサンドを使用することになり、

701
00:32:31,900 --> 00:32:33,180
if文です。

702
00:32:33,180 --> 00:32:39,256
あなたは真の持っている、といくつかの変数
それは、いくつかのブールと評価

703
00:32:39,256 --> 00:32:41,380
いくつかの他の変数
それはいくつかのブールを検証

704
00:32:41,380 --> 00:32:42,880
あなたは、そのの取得したいです。

705
00:32:42,880 --> 00:32:44,552
その後、アンパサンドを使用します。

706
00:32:44,552 --> 00:32:47,510
SPEAKER 1：うん、そうちょうど今日、私たちはしました
約3異なる用途を話しました

707
00:32:47,510 --> 00:32:48,250
アンパサンドの。

708
00:32:48,250 --> 00:32:51,040
我々は、2つのアンパサンドを、持っています
何Pulakは、今説明しました。

709
00:32:51,040 --> 00:32:53,420
私たちは、1アンパサンドを持っています
カミーユは説明するものです

710
00:32:53,420 --> 00:32:54,897
以前、1アンパサンドです。

711
00:32:54,897 --> 00:32:56,685
そしてそれは、ビット単位のANDのためです。

712
00:32:56,685 --> 00:32:59,640
そして、両方のことに注意してください
条件AND--または、申し訳ありませんが、

713
00:32:59,640 --> 00:33:04,180
論理AND演算とビット
そして、、これらの2つの数、権利を持っていますか？

714
00:33:04,180 --> 00:33:07,354
それは何かのアンパサンドました
アンパサンド何か、

715
00:33:07,354 --> 00:33:09,350
何かアンパサンド何か。

716
00:33:09,350 --> 00:33:13,862
ここで、私たちは、アンパサンドを持っている場合
何か、それが逆参照です。

717
00:33:13,862 --> 00:33:15,830
>> PULAK Goyal氏：うん、偉大な質問。

718
00:33:15,830 --> 00:33:16,677
うん。

719
00:33:16,677 --> 00:33:21,150
>> 聴衆：行でない理由
図5aとなるN / Aスター？

720
00:33:21,150 --> 00:33:25,520
なぜ彼らはちょうど種類の保持されません。
前の行と同じ値？

721
00:33:25,520 --> 00:33:28,000
>> PULAK Goyal氏：ので、
我々は、機能を終了しました。

722
00:33:28,000 --> 00:33:30,894
だから何happens--
今、私たちはしていますwhat--

723
00:33:30,894 --> 00:33:33,060
その関数の範囲のうち、
何が実際に起こります

724
00:33:33,060 --> 00:33:37,770
メモリから削除されたものです。

725
00:33:37,770 --> 00:33:38,808
うん。

726
00:33:38,808 --> 00:33:42,982
>> 対象：3〜
または4つ星Aは5に等しいです。

727
00:33:42,982 --> 00:33:43,690
PULAK Goyal氏：はい。

728
00:33:43,690 --> 00:33:45,575
観客：それは正確に何を意味するのでしょうか？

729
00:33:45,575 --> 00:33:46,950
PULAK Goyal氏：それはどういう意味？

730
00:33:46,950 --> 00:33:47,380
聴衆：うん。

731
00:33:47,380 --> 00:33:49,088
PULAK Goyal氏：だから
質問は何であるか、でした

732
00:33:49,088 --> 00:33:52,300
あなたがオンラインで何をしていますthat--
私たちが言うとき、星は5に等しいのですか？

733
00:33:52,300 --> 00:33:55,210
だから、星を覚えています
間接参照演算子。

734
00:33:55,210 --> 00:33:58,640
そのようにすると、この場合には、ポインタです。

735
00:33:58,640 --> 00:34:00,030
これは、int型のスターです。

736
00:34:00,030 --> 00:34:03,710
だから、ときに我々によって間接参照
スターを使用して、我々は何を言っています

737
00:34:03,710 --> 00:34:11,250
、で保存されているものに移動され、
そこそこtake-- A--に格納されたアドレス、

738
00:34:11,250 --> 00:34:13,280
今、いくつかを持って
それに格納されたアドレス。

739
00:34:13,280 --> 00:34:19,920
どこにそのアドレスポイントに移動し、
今では5にあるものは何でも変更します。

740
00:34:19,920 --> 00:34:20,420
うん。

741
00:34:20,420 --> 00:34:23,390
>> 聴衆：あなたが言うことができます
それより簡単な点では？

742
00:34:23,390 --> 00:34:27,360
5へのアドレスを変更します。

743
00:34:27,360 --> 00:34:31,070
>> PULAK Goyal氏：私たちではありません
5のアドレスを変更します。

744
00:34:31,070 --> 00:34:36,340
Aはそれでいくつかのアドレスを持っています
興味のある変数のアドレス。

745
00:34:36,340 --> 00:34:39,570
そして、私たちは何を言っています
我々は間接参照である場合には、

746
00:34:39,570 --> 00:34:42,630
今、私たちはchange--たい
私たちは今参照しています

747
00:34:42,630 --> 00:34:45,135
直接変数の関心。

748
00:34:45,135 --> 00:34:48,499
それは理にかなっていますか？

749
00:34:48,499 --> 00:34:52,280
>> SPEAKER 1：考えるもう一つの方法
それのアドレスですのでgo--されます。

750
00:34:52,280 --> 00:34:55,310
星はそれに行くと言います
対処し、その値を確認します。

751
00:34:55,310 --> 00:34:58,000
そして今5にその値を設定します。

752
00:34:58,000 --> 00:35:00,920
だから、に行く、と言います
xのアドレス、どの

753
00:35:00,920 --> 00:35:05,720
保存されているものになるだろう
であり、5に変更します。

754
00:35:05,720 --> 00:35:06,470
PULAK Goyal氏：ええ？

755
00:35:06,470 --> 00:35:10,817
聴衆：だから位置であります
ポインタは、アドレスが起こっています。

756
00:35:10,817 --> 00:35:14,270
しかし、値が割り当てられています
アドレスに基づく値。

757
00:35:14,270 --> 00:35:15,020
PULAK Goyal氏：ええ。

758
00:35:15,020 --> 00:35:18,076

759
00:35:18,076 --> 00:35:19,367
これについては他の質問？

760
00:35:19,367 --> 00:35:22,774

761
00:35:22,774 --> 00:35:23,940
聴衆：私は質問があります。

762
00:35:23,940 --> 00:35:25,664
PULAK Goyal氏：ええ、申し訳ありません。

763
00:35:25,664 --> 00:35:30,324
聴衆：だから、そうstore--
あなたは[聞こえない]と言っている場合。

764
00:35:30,324 --> 00:35:31,032
PULAK Goyal氏：はい。

765
00:35:31,032 --> 00:35:34,448
観客：あなたがする必要がありますか
アンパサンドを使用して、xを保存しますか？

766
00:35:34,448 --> 00:35:37,376
なぜあなただ​​けのxが言うことができません
あなたのint [聞こえない]の前に？

767
00:35:37,376 --> 00:35:40,562

768
00:35:40,562 --> 00:35:41,270
PULAK Goyal氏：So--

769
00:35:41,270 --> 00:35:42,090
聴衆：[聞こえません]。

770
00:35:42,090 --> 00:35:43,673
PULAK Goyal氏：だからあなたquestion--はOHです。

771
00:35:43,673 --> 00:35:47,160

772
00:35:47,160 --> 00:35:51,300
だからあなたの質問は、なぜwe--することはできません
機能to_fiveに、なぜ我々はできません

773
00:35:51,300 --> 00:35:52,590
ちょうど、Xを渡しますか？

774
00:35:52,590 --> 00:35:53,570
>> 聴衆：右。

775
00:35:53,570 --> 00:35:59,570
>> PULAK Goyal氏：ええ、[OK]を、ので、この再び
タイプの私達の議論に戻ります。

776
00:35:59,570 --> 00:36:06,080
だから、機能to_fiveは今
int型のスターのタイプを期待。

777
00:36:06,080 --> 00:36:07,660
だから、xの型は何ですか？

778
00:36:07,660 --> 00:36:09,800
Xは単なるintです。

779
00:36:09,800 --> 00:36:13,530
しかし、この機能
期待するint型のスターです。

780
00:36:13,530 --> 00:36:16,910
だから、その変数を期待
それに格納されたアドレスを持っています。

781
00:36:16,910 --> 00:36:20,250
だから、入れyou--方法です
アンパサンドは、ので、それはです

782
00:36:20,250 --> 00:36:22,560
どのように我々はに渡します
now--あるアドレス、

783
00:36:22,560 --> 00:36:25,120
それはと解釈
int型のスターとして、ええ。

784
00:36:25,120 --> 00:36:26,700
素晴らしい質問です。

785
00:36:26,700 --> 00:36:29,300
この上の任意の他の質問？

786
00:36:29,300 --> 00:36:29,800
うんいいね。

787
00:36:29,800 --> 00:36:32,870

788
00:36:32,870 --> 00:36:37,020
>> [OK]を、ので、今の話をしましょう
ポインタ演算について。

789
00:36:37,020 --> 00:36:40,050
だからここに、加減算
私はポインタを調整

790
00:36:40,050 --> 00:36:43,950
iの倍の大きさによって、
ポインタバイトのタイプ。

791
00:36:43,950 --> 00:36:46,170
それでは、それがどのように見えるかを見てみましょう。

792
00:36:46,170 --> 00:36:49,640
だからここに、私たちは宣言しました
int型xは5に等しいです。

793
00:36:49,640 --> 00:36:56,120
そして今、我々はポインタを宣言するつもりです
yは、そこxのアドレスを渡します。

794
00:36:56,120 --> 00:36:58,910
だから我々はそれを持っています。

795
00:36:58,910 --> 00:37:01,005
このため、xは0×04で保存されています。

796
00:37:01,005 --> 00:37:03,960
だから今yは等しいです。

797
00:37:03,960 --> 00:37:12,260
そして、誰かが、彼らが何を考えて私に言うことができます
私たちはY行うプラス1に等しいとき起こるのだろうか？

798
00:37:12,260 --> 00:37:19,100

799
00:37:19,100 --> 00:37:19,771
うん？

800
00:37:19,771 --> 00:37:24,010
>> 観客：それは0回0 8に変更しますか？

801
00:37:24,010 --> 00:37:25,342
>> PULAK Goyal氏：サイズ、およびtype--

802
00:37:25,342 --> 00:37:27,789
>> 観客は：あなたはアドレスを移動しています。

803
00:37:27,789 --> 00:37:29,080
PULAK Goyal氏：ええ、それはイエスwas--。

804
00:37:29,080 --> 00:37:31,130
So--右。

805
00:37:31,130 --> 00:37:33,110
だから、0x08のに変更されます。

806
00:37:33,110 --> 00:37:38,750
そしてbecause--ので、あなたはこれを使用したいです
式、ポインタの1倍

807
00:37:38,750 --> 00:37:42,354
ポインタはsize--です

808
00:37:42,354 --> 00:37:44,050
>> 【学生つぶやき]

809
00:37:44,050 --> 00:37:45,190
>> PULAK Goyal氏：そうです。

810
00:37:45,190 --> 00:37:46,150
>> 【学生つぶやき]

811
00:37:46,150 --> 00:37:49,230
>> SPEAKER 1：だからタイプ
ポインタはto--

812
00:37:49,230 --> 00:37:51,862
>> PULAK Goyal氏は：ええ、です、
ええ、それは4バイトです。

813
00:37:51,862 --> 00:37:53,930
>> SPEAKER 1：だからint型は4バイトです。

814
00:37:53,930 --> 00:38:01,260
>> PULAK Goyal氏：だから私たちはA--せた場合の
私たちは、私が推測する、char型を宣言したと言います。

815
00:38:01,260 --> 00:38:06,830
それでは、私たちを言わせて何をthat--う
か何かに等しい文字Xを持っています。

816
00:38:06,830 --> 00:38:14,400
そして、私たちは、0x04の時とのアドレスを持っていました
何Yだろうプラス1が今等しいですか？

817
00:38:14,400 --> 00:38:14,960
申し訳ありません、何？

818
00:38:14,960 --> 00:38:16,099
>> 聴衆：0x05を。

819
00:38:16,099 --> 00:38:17,140
PULAK Goyal氏：0x05を、右。

820
00:38:17,140 --> 00:38:18,520
誰もがそれを見るでしょうか？

821
00:38:18,520 --> 00:38:20,212
[OK]を、今のは、それがフロートだとしましょう​​。

822
00:38:20,212 --> 00:38:20,962
何が起こるのでしょうか？

823
00:38:20,962 --> 00:38:25,210

824
00:38:25,210 --> 00:38:26,130
誰でも？

825
00:38:26,130 --> 00:38:28,066
そこで山車は何バイトですか？

826
00:38:28,066 --> 00:38:28,860
>> 対象：4バイト。

827
00:38:28,860 --> 00:38:29,651
>> PULAK Goyal氏：そうです。

828
00:38:29,651 --> 00:38:32,661
だから、これと同じことになります。

829
00:38:32,661 --> 00:38:33,160
クール。

830
00:38:33,160 --> 00:38:36,230

831
00:38:36,230 --> 00:38:40,180
[OK]を、今のは話をしましょう
ポインタと配列について。

832
00:38:40,180 --> 00:38:44,210
だから、上でこれを見ました
前の2つのpセット、

833
00:38:44,210 --> 00:38:48,570
私たちはそのようにアレイをtreat--できる場所と
ポインタは同じものではありません。

834
00:38:48,570 --> 00:38:51,170
しかし、我々はポインタとして配列を扱うことができます。

835
00:38:51,170 --> 00:38:55,550
そこでここでは、我々はこの配列を持っています
ここでは、3つのスロットを有しています。

836
00:38:55,550 --> 00:38:57,570
最初slot--我々に
一、二、三を持っています。

837
00:38:57,570 --> 00:39:00,930
>> we--は私たちが割り当てることができるのであれば
言って、我々は配列を持っていること、

838
00:39:00,930 --> 00:39:02,080
その間接参照。

839
00:39:02,080 --> 00:39:04,579
そして、ときに我々は間接参照
私たちが実際にやっていること、

840
00:39:04,579 --> 00:39:05,910
同じスロットを参照しています。

841
00:39:05,910 --> 00:39:09,230
だから、星の配列が1に等しいです。

842
00:39:09,230 --> 00:39:11,020
私たちはどのようにできましたcould-
私たちは何that--書きます

843
00:39:11,020 --> 00:39:13,404
我々はそれを書くことができる別の方法はありますか？

844
00:39:13,404 --> 00:39:14,840
>> 聴衆：アレイ0に等しい1。

845
00:39:14,840 --> 00:39:17,100
>> PULAK Goyal氏：その通り、
誰もがそれを見るのでしょうか？

846
00:39:17,100 --> 00:39:18,320
ここでだから同じこと。

847
00:39:18,320 --> 00:39:24,060
だから我々は、配列を持っているとき
プラス1、我々はそうeven-- do--

848
00:39:24,060 --> 00:39:28,890
算術を覚えている私たち
ちょうど我々が行うとき、について話しましたプラス1

849
00:39:28,890 --> 00:39:32,120
または右、4バイトでそれを上に移動します。

850
00:39:32,120 --> 00:39:33,170
誰もがそれを見るでしょうか？

851
00:39:33,170 --> 00:39:35,753
そして、その辺、ときに我々は間接参照
それが、私たちは2にそれを設定することができます。

852
00:39:35,753 --> 00:39:37,710
そして、それは我々が設定方法を説明します
次のブロック2へ。

853
00:39:37,710 --> 00:39:41,640
書くためにそしてそう別の方法
それは、アレイブラケットだろう

854
00:39:41,640 --> 00:39:44,436
0ブラケットは1に等しいです。

855
00:39:44,436 --> 00:39:47,070
>> 観客：あなたが括弧を必要ですか？

856
00:39:47,070 --> 00:39:50,840
>> PULAK Goyal氏：はい、あなたはだから
全量を逆参照

857
00:39:50,840 --> 00:39:53,460
配列プラス1。

858
00:39:53,460 --> 00:39:56,829
[OK]を、配列プラス2も同じこと。

859
00:39:56,829 --> 00:39:57,870
これについてのご質問？

860
00:39:57,870 --> 00:39:58,369
うん。

861
00:39:58,369 --> 00:40:01,340
聴衆：だから配列であります
自動的に0に設定されていますか？

862
00:40:01,340 --> 00:40:03,054
>> PULAK Goyal氏：配列は申し訳ありませんis--、何？

863
00:40:03,054 --> 00:40:03,962
>> 観客：配列は0です。

864
00:40:03,962 --> 00:40:07,140
配列のアドレスは、ちょうど0です。

865
00:40:07,140 --> 00:40:10,200
>> PULAK Goyal氏：だから質問がありました、
配列のアドレスは、ちょうど0のですか？

866
00:40:10,200 --> 00:40:11,950
だから、ない、アレイは、いくつかのアドレスを持っています。

867
00:40:11,950 --> 00:40:14,930
だから、ときに我々それを間接参照、
that's--あなたはabout--考えることができます

868
00:40:14,930 --> 00:40:18,230
文字通り指し示すポインタのような
配列の先頭に。

869
00:40:18,230 --> 00:40:19,390
だから、いくつかのアドレスを持っています。

870
00:40:19,390 --> 00:40:20,580
我々は、それが何であるかを知りません。

871
00:40:20,580 --> 00:40:24,170
しかし、我々はそれを間接参照、我々が知っているとき
それは、配列の先頭です。

872
00:40:24,170 --> 00:40:25,980
そして、私たちはすることによって移動したとき
1、私たちは移動しています

873
00:40:25,980 --> 00:40:29,090
そのアドレスがあった場所からの相対。

874
00:40:29,090 --> 00:40:30,480
その他の質問は？

875
00:40:30,480 --> 00:40:31,419
うん？

876
00:40:31,419 --> 00:40:35,559
>> 観客：あなたが行うのであれば
配列ブラケットプラス1--

877
00:40:35,559 --> 00:40:37,350
PULAK Goyal氏：申し訳ありませんが、
あなたはI--を話せますか？

878
00:40:37,350 --> 00:40:41,174
聴衆：ええ、あなたがない場合
配列ブラケット[聞こえません]。

879
00:40:41,174 --> 00:40:45,227
それでは、あなたはpointer--を置く場合

880
00:40:45,227 --> 00:40:46,810
PULAK Goyal氏：申し訳ありませんが、私はあなたを聞くことはできません。

881
00:40:46,810 --> 00:40:48,100
あなたはそれもう一回言うことはできますか？

882
00:40:48,100 --> 00:40:49,470
>> 観客：あなたはOKです。

883
00:40:49,470 --> 00:40:50,870
>> PULAK Goyal氏：[OK]を、申し訳ありません。

884
00:40:50,870 --> 00:40:51,420
うんいいね。

885
00:40:51,420 --> 00:40:52,200
ええAny--。

886
00:40:52,200 --> 00:40:55,710
だから、配列ブラケットに行くとき3--

887
00:40:55,710 --> 00:40:56,570
>> PULAK Goyal氏：ええ。

888
00:40:56,570 --> 00:40:59,832
>> 観客：there--はないでしょう--isn't
それは0、1、2、および3のような4つのスポットでありますか？

889
00:40:59,832 --> 00:41:02,630
なぜそれがアレイ2をint型ではないですか？

890
00:41:02,630 --> 00:41:07,850
>> PULAK Goyal氏：いいえ、そうちょうど大会
我々は配列を宣言するときに、Cの、is--

891
00:41:07,850 --> 00:41:12,010
私たちはそこに置か数をwe--
私たちが望むどのように多くのスロットがあります。

892
00:41:12,010 --> 00:41:16,970
しかし、配列のインデックスがあります
実際には配列0、配列1、配列2。

893
00:41:16,970 --> 00:41:19,780
だから、ただ慣例です
我々は配列を宣言する方法について。

894
00:41:19,780 --> 00:41:20,880
うん、他の質問？

895
00:41:20,880 --> 00:41:21,380
うん。

896
00:41:21,380 --> 00:41:23,750
聴衆：だから我々はまだです
ポインタの話ですよね？

897
00:41:23,750 --> 00:41:24,500
PULAK Goyal氏：ええ。

898
00:41:24,500 --> 00:41:28,600
聴衆：あなたはまだ行うことができます
アレー0用の星が1に等しいですか？

899
00:41:28,600 --> 00:41:32,870
PULAK Goyal氏：いや、いや、so--
[OK]を、ので、質問があった可能性

900
00:41:32,870 --> 00:41:37,370
あなただけの星の配列ブラケットを行います
ゼロ、その後は1に等しく、その言います。

901
00:41:37,370 --> 00:41:40,000
だから、ない、私たちは何を言っています
ここで私たちがthink--ことができるということです

902
00:41:40,000 --> 00:41:42,600
我々はポインタとして配列を扱うことができます。

903
00:41:42,600 --> 00:41:44,970
だから我々は我々がしているものhave--
私たちは二つの方法がありますと言って

904
00:41:44,970 --> 00:41:47,370
今、同じブロックに参照します。

905
00:41:47,370 --> 00:41:52,270
あなたは配列ゼロを持っているのであれば、doing--
その種類は今intです。

906
00:41:52,270 --> 00:41:55,264
そして、あなたは星を取った場合に、
無効なものを取得します。

907
00:41:55,264 --> 00:41:57,680
私たちはここで言っているそうです
2つの代替方法があります

908
00:41:57,680 --> 00:41:59,100
同じブロックを参照することができます。

909
00:41:59,100 --> 00:42:01,860
あなたは配列を行うことができますどちらか
ブラケット0は1に等しいです。

910
00:42:01,860 --> 00:42:06,420
それとも、間接参照を行うことができます
0に等しい、と持っている配列。

911
00:42:06,420 --> 00:42:08,621
のだから二つの方法
同じことをやって。

912
00:42:08,621 --> 00:42:09,120
うん。

913
00:42:09,120 --> 00:42:15,270
>> 聴衆：なぜそれではありません
to--追加するint型1の大きさ

914
00:42:15,270 --> 00:42:17,650
>> PULAK Goyal氏：int型1のサイズ。

915
00:42:17,650 --> 00:42:19,900
>> 観客：それは1、オフの移動だから。

916
00:42:19,900 --> 00:42:23,620
>> PULAK Goyal氏：それはだから
Cが働くだけの方法。

917
00:42:23,620 --> 00:42:26,460
それはちょうど道のポインタです
演算が定義されます。

918
00:42:26,460 --> 00:42:27,854
これは、ポインタを取りますよ。

919
00:42:27,854 --> 00:42:30,020
そして、あなたはどんな追加
それには、それを掛けますよ

920
00:42:30,020 --> 00:42:34,770
何のサイズによって
ポインタストアはええ、です。

921
00:42:34,770 --> 00:42:35,480
うん。

922
00:42:35,480 --> 00:42:39,595
>> 聴衆：だから、私たちが扱うことができると言います
ポインタと配列と同じに、

923
00:42:39,595 --> 00:42:40,720
しかし、それらは異なっていること。

924
00:42:40,720 --> 00:42:41,950
それでは、彼らが違いますの？

925
00:42:41,950 --> 00:42:45,070
私たちは、で何を行うことはできません
1ではないが、他の？

926
00:42:45,070 --> 00:42:52,390
>> PULAK Goyal氏：この目的のために
クラス、私はyou--を何it's--を考えます

927
00:42:52,390 --> 00:42:56,270
>> SPEAKER 1：だから、[OK]をwe--、そう、ために
たとえば、あなたが割り当てた場合、メモリ

928
00:42:56,270 --> 00:42:59,680
あなたはへのポインタを持っています
例えば整数、。

929
00:42:59,680 --> 00:43:01,890
あなたが起動しようとした場合
ポインタ演算を行います

930
00:43:01,890 --> 00:43:05,890
そのメモリの量を超えました
あなたは、エラーに遭遇するだろう、割り当てられました。

931
00:43:05,890 --> 00:43:08,250
私たちは、アレイと知っています
前もって言って、[OK]を、私

932
00:43:08,250 --> 00:43:11,400
基本的にこれをallocate--したいです
私が割り当てたい、と言います

933
00:43:11,400 --> 00:43:13,490
三つの整数のための十分な部屋。

934
00:43:13,490 --> 00:43:17,820
そして今、我々はいるかのようにメモリを扱うことができます
我々は、これらの整数のすべての3つがあります。

935
00:43:17,820 --> 00:43:19,460
メイク感覚のようなものをしていますか？

936
00:43:19,460 --> 00:43:22,042
>> PULAK Goyal氏：ええ。

937
00:43:22,042 --> 00:43:22,542
うん。

938
00:43:22,542 --> 00:43:24,778
>> 聴衆：だから星
アレイは、1を割り当てることです

939
00:43:24,778 --> 00:43:26,657
配列のインデックス0に？

940
00:43:26,657 --> 00:43:27,365
PULAK Goyal氏：はい。

941
00:43:27,365 --> 00:43:31,160

942
00:43:31,160 --> 00:43:34,439
>> 観客は：だから、何をした後で
the--私の観点から次の2行

943
00:43:34,439 --> 00:43:36,980
あなたがしようとしていることを理解
ここでポインタ演算を使用するには、

944
00:43:36,980 --> 00:43:39,355
しかし、再び、私は理解していません
何ポインタ算術演算です。

945
00:43:39,355 --> 00:43:43,869
だから、配列プラス1、あなたがしています
あなたが今していることを言って

946
00:43:43,869 --> 00:43:47,540
話をするつもり
配列への最初のインデックス。

947
00:43:47,540 --> 00:43:50,050
>> PULAK Goyal氏：右、など
働く配列である理由は、

948
00:43:50,050 --> 00:43:52,970
ここで、我々はint型のスターとして考えることができます。

949
00:43:52,970 --> 00:43:56,110
だから、我々はポインタ演算を行うとき
その上で、どこに式を覚えています

950
00:43:56,110 --> 00:43:59,020
私が推測the--我々が取るものは何でも
現在のアドレスは、

951
00:43:59,020 --> 00:44:02,100
し、我々は、追加すると、
それへの1、実際に我々

952
00:44:02,100 --> 00:44:06,620
の大きさによって1を乗算
私たちが操作している事。

953
00:44:06,620 --> 00:44:09,090
したがって、この場合には、int型のサイズ。

954
00:44:09,090 --> 00:44:11,634
そして、我々はそれを移動
その分だけ転送します。

955
00:44:11,634 --> 00:44:14,419
>> SPEAKER 1：だからふり
あなたは、Bアレイスターを持っています。

956
00:44:14,419 --> 00:44:15,335
PULAK Goyal氏：ええ、[OK]をクリックします。

957
00:44:15,335 --> 00:44:16,005
SPEAKER 1：あなたの手で。

958
00:44:16,005 --> 00:44:16,505
ここに行きます。

959
00:44:16,505 --> 00:44:18,350
PULAK Goyal氏：または私はそうjust--ことができます。

960
00:44:18,350 --> 00:44:23,660
でそうhere-- OKなので、配列
始まり、ちょうどここにあります。

961
00:44:23,660 --> 00:44:29,155
だから我々は、配列を間接参照、我々があったとき
ちょうどここに最初のブロックを参照します。

962
00:44:29,155 --> 00:44:36,620
しかし、今、私は、配列プラス1を実行したときに、その
その矢印is--右今ここにあります。

963
00:44:36,620 --> 00:44:38,250
それは理にかなっていますか？

964
00:44:38,250 --> 00:44:46,690
右、このブロックがあるため、
4バイトであるサイズはint、の。

965
00:44:46,690 --> 00:44:53,540
だから、私たちがやっていることは私たちがしているです
4バイトを超えることによって、そのポインタを移動します。

966
00:44:53,540 --> 00:44:56,080
私たちは、算術演算を行うたびに
その上、それは常になります

967
00:44:56,080 --> 00:44:59,730
4バイトの単位で移動します。

968
00:44:59,730 --> 00:45:01,902
これは、int型の星のようですので。

969
00:45:01,902 --> 00:45:04,970
それは理にかなっていますか？

970
00:45:04,970 --> 00:45:05,470
OK。

971
00:45:05,470 --> 00:45:07,770
>> 聴衆：だから、配列内のもの
5バイトだった、我々は5 bytes--それを移動したいです

972
00:45:07,770 --> 00:45:10,853
>> PULAK Goyal氏：右、私たちは持っているかのように、
char型の星は、我々は1バイトで、それを移動したいです。

973
00:45:10,853 --> 00:45:13,670
だから、char型の星の場合には、
それはちょうど1によってそれを上に移動すると思います。

974
00:45:13,670 --> 00:45:15,420
観客は：取得するには
次のあなたはスターが必要です。

975
00:45:15,420 --> 00:45:18,099
PULAK Goyal氏：ええ、ええ、
それは理にかなっているのでしょうか？

976
00:45:18,099 --> 00:45:19,890
SPEAKER 1：私たちはチャットすることができます
それについての詳細後で。

977
00:45:19,890 --> 00:45:21,530
PULAK Goyal氏：ええ、ええ、確かに。

978
00:45:21,530 --> 00:45:23,214
うんいいね。

979
00:45:23,214 --> 00:45:24,630
それでは、次のセクションに移動してみましょう。

980
00:45:24,630 --> 00:45:27,182

981
00:45:27,182 --> 00:45:28,140
SPEAKER 1：ああ、[OK]をクール。

982
00:45:28,140 --> 00:45:29,205
ええ、それは私です。

983
00:45:29,205 --> 00:45:30,330
すべての権利、素晴らしいです。

984
00:45:30,330 --> 00:45:35,064
[OK]を、ので、今は少し上にクールです
メモリに関する一般的な情報。

985
00:45:35,064 --> 00:45:37,730
また、私は事実を認めます
彼らはかなり迅速に行っていました。

986
00:45:37,730 --> 00:45:40,230
これは、材料の多くが取得することです
時間半の貫通。

987
00:45:40,230 --> 00:45:42,880
しかし、どのようなトピックがある場合
深い多くを行ってみたいです、

988
00:45:42,880 --> 00:45:44,630
我々は、必要があるとしています
営業時間今週

989
00:45:44,630 --> 00:45:46,340
あなたは私たちと1対1でチャットすることができる場所。

990
00:45:46,340 --> 00:45:49,240
それとも、ただで出てくる可能性があり
終わると、私たちは物事についてチャットします。

991
00:45:49,240 --> 00:45:52,130
そしていつものように、感じます
質問をすること自由に。

992
00:45:52,130 --> 00:45:52,695
驚くばかり。

993
00:45:52,695 --> 00:45:55,820
そこでここではメモリの私たちの絵がいることです
私たちは講義で億回を見てきました。

994
00:45:55,820 --> 00:45:58,610
そして、我々は、このスタックを知っています
下から成長します

995
00:45:58,610 --> 00:46:00,214
ヒープがダウン成長します。

996
00:46:00,214 --> 00:46:03,380
そして、物事の違いは何でしょう
私たちは、ヒープとものに保つこと

997
00:46:03,380 --> 00:46:05,981
我々は、スタック上に保存しておくことを？

998
00:46:05,981 --> 00:46:07,397
誰かがそこに何かを投げます。

999
00:46:07,397 --> 00:46:10,806

1000
00:46:10,806 --> 00:46:11,780
うん。

1001
00:46:11,780 --> 00:46:14,215
>> 観客：それはスタックであります
ちょうどあるもののために

1002
00:46:14,215 --> 00:46:18,095
私たちはしている一時的変数
特定の機能を使用して宣言しますか？

1003
00:46:18,095 --> 00:46:19,220
SPEAKER 1：美しい、ええ。

1004
00:46:19,220 --> 00:46:23,007
だから、いつでも、レッツ
我々は関数にしていると言います、

1005
00:46:23,007 --> 00:46:24,590
我々はいくつかのローカル変数を持っています。

1006
00:46:24,590 --> 00:46:26,214
これらは、スタックに終わるしようとしています。

1007
00:46:26,214 --> 00:46:30,020
場合は、代わりに、私たちは、malloc関数を呼び出します
実際にメモリを割り当て、

1008
00:46:30,020 --> 00:46:32,290
それは、常にヒープから来ています。

1009
00:46:32,290 --> 00:46:35,100
だから、クールええか？

1010
00:46:35,100 --> 00:46:38,672
>> そして、その結果、任意のメモリを覚えています
あなたがmallocを使用して割り当てることを、

1011
00:46:38,672 --> 00:46:40,130
それは、ヒープ上に終わるだろう。

1012
00:46:40,130 --> 00:46:42,019
そして、あなたがすることを忘れた場合
無料のそれは、コンピュータの

1013
00:46:42,019 --> 00:46:43,810
ことを知っているつもりはありません
あなたはそれで行われています。

1014
00:46:43,810 --> 00:46:45,560
だから、ちょうどに起こっています
メモリ内に存在たむろ。

1015
00:46:45,560 --> 00:46:47,412
そして、あなたは基本的にしています
そのメモリをリークします。

1016
00:46:47,412 --> 00:46:48,120
あなたはそれを失っています。

1017
00:46:48,120 --> 00:46:51,840
あなたはコンピュータを語ったことはありませんので、
私はそれを使用して終わりだねえ、使用すること自由に感じ、

1018
00:46:51,840 --> 00:46:53,632
そこに他のものを置きます。

1019
00:46:53,632 --> 00:46:54,470
クール。

1020
00:46:54,470 --> 00:46:55,928
そこに任意の質問？

1021
00:46:55,928 --> 00:46:56,428
はい。

1022
00:46:56,428 --> 00:46:58,808
>> 聴衆：だから、どのような
メモリのスタックがありますか？

1023
00:46:58,808 --> 00:46:59,974
非動的なフィード、委任？

1024
00:46:59,974 --> 00:47:01,200
あなたはそれを何を呼ぶのでしょうか？

1025
00:47:01,200 --> 00:47:03,870
>> SPEAKER 1：確かに、あなたができるよう
ローカル変数と考えます。

1026
00:47:03,870 --> 00:47:10,137
関数への実際の呼び出し
積み重ねるしようとしています。

1027
00:47:10,137 --> 00:47:10,720
他に何か？

1028
00:47:10,720 --> 00:47:11,220
うん？

1029
00:47:11,220 --> 00:47:14,627
聴衆：どのように無料で行います
あなたがthe--するために追加メモリ

1030
00:47:14,627 --> 00:47:17,710
SPEAKER 1：確かに、そうしたときに割り当て
ヒープ上のメモリは、あなたがmalloc関数を呼び出します。

1031
00:47:17,710 --> 00:47:20,543
だから、そのバックあなたを与えます
メモリ内のいくつかのアドレスへのポインタ。

1032
00:47:20,543 --> 00:47:22,630
だから、あなたは右、そのポインタと呼ばれると言いますか？

1033
00:47:22,630 --> 00:47:24,970
次に、あなただけのフリーポインタを言います。

1034
00:47:24,970 --> 00:47:27,351
そして、それは、メモリを解放します。

1035
00:47:27,351 --> 00:47:27,850
クール。

1036
00:47:27,850 --> 00:47:28,660
その他の質問？

1037
00:47:28,660 --> 00:47:28,880
はい。

1038
00:47:28,880 --> 00:47:30,838
>> 観客：何がします
動的に割り当てられた意味？

1039
00:47:30,838 --> 00:47:32,345

1040
00:47:32,345 --> 00:47:35,381
>> SPEAKER 1：動的に割り当てられました
あなたのプログラムの過程で、意味しています。

1041
00:47:35,381 --> 00:47:37,630
だから、あなたがmalloc関数を呼び出すとき
プログラムの途中、

1042
00:47:37,630 --> 00:47:40,510
プログラムの開始時に、
割り当てられた何のメモリがありません。

1043
00:47:40,510 --> 00:47:42,600
そして、コンピュータのような
そのコードをステップ、

1044
00:47:42,600 --> 00:47:44,280
それは、メモリを割り当てるために起こっています。

1045
00:47:44,280 --> 00:47:46,507
だから、我々は動的にすることによって何を意味するかです。

1046
00:47:46,507 --> 00:47:47,090
良い質問。

1047
00:47:47,090 --> 00:47:48,309
うん？

1048
00:47:48,309 --> 00:47:50,809
観客：あなたが定義する場合
角括弧を持つ配列、

1049
00:47:50,809 --> 00:47:54,154
まだ[聞こえない]ということでしょうか？

1050
00:47:54,154 --> 00:47:55,570
SPEAKER 1：それはいい質問ですね。

1051
00:47:55,570 --> 00:48:00,320
あなたは配列を割り当てるとき、私が思うに、
それは実際にスタックにそれを置きます。

1052
00:48:00,320 --> 00:48:03,008
私は約ポジティブありませんよ
そのため、私を引用しないでください。

1053
00:48:03,008 --> 00:48:04,430
>> SPEAKER 2：私は、ええit--を考えます
それはスタック上にそれを置きます。

1054
00:48:04,430 --> 00:48:05,763
>> SPEAKER 1：スタックにそれを置きます。

1055
00:48:05,763 --> 00:48:07,044
[OK]を、クール、確認されました。

1056
00:48:07,044 --> 00:48:07,710
その他の質問？

1057
00:48:07,710 --> 00:48:08,030
うん？

1058
00:48:08,030 --> 00:48:10,946
>> 観客：あなたはmalloc関数を委任する場合、
コンピュータが自動的にしません

1059
00:48:10,946 --> 00:48:12,910
あなたの変数にメモリを割り当てますか？

1060
00:48:12,910 --> 00:48:14,660
SPEAKER 1：うん、用
あなたのローカル変数、

1061
00:48:14,660 --> 00:48:16,724
それは自動的に置きます
スタック上のメモリ。

1062
00:48:16,724 --> 00:48:18,640
聴衆：だから何です
mallocを使用してのポイント？

1063
00:48:18,640 --> 00:48:19,840
SPEAKER 1：何が
mallocを使用してのポイント？

1064
00:48:19,840 --> 00:48:22,850
だから我々は例の束を見て、
以下のような、例えば、スワップを使用して、

1065
00:48:22,850 --> 00:48:25,690
我々は、の範囲を配置したい場所
何かする変数

1066
00:48:25,690 --> 00:48:27,940
ただ、その関数呼び出しを越えて。

1067
00:48:27,940 --> 00:48:29,875
そして、私たちは何かをしたいです
私たちが周りに渡すことができます

1068
00:48:29,875 --> 00:48:31,750
我々がアクセスできます
別の場所から。

1069
00:48:31,750 --> 00:48:33,791
私たちがしたいと思いますところです
ヒープ上のメモリを置きます。

1070
00:48:33,791 --> 00:48:37,835
すべてのこれらの異なるだから
機能はそれにアクセスすることができます。

1071
00:48:37,835 --> 00:48:40,510
>> 観客は：あなたはちょうどそれを説明できますか？

1072
00:48:40,510 --> 00:48:44,770
>> SPEAKER 1：だから一つの選択肢はそうis--
質問した、ことができます私たちはallocate--

1073
00:48:44,770 --> 00:48:47,660
申し訳ありませんが、私たちが宣言することができます
グローバル変数、基本的に。

1074
00:48:47,660 --> 00:48:48,560
それは一つの選択肢です。

1075
00:48:48,560 --> 00:48:50,893
しかし、それらの多くの、それら
本当に厄介取得する傾向があります。

1076
00:48:50,893 --> 00:48:52,847
そして、我々は一般的に考えます
悪いデザインの。

1077
00:48:52,847 --> 00:48:53,821
うん。

1078
00:48:53,821 --> 00:48:56,580
クール、他の質問？

1079
00:48:56,580 --> 00:48:57,140
驚くばかり。

1080
00:48:57,140 --> 00:48:58,789
[OK]を、先に進みます。

1081
00:48:58,789 --> 00:49:00,580
だから、これは実際にあります
どのようにメモリを割り当てます。

1082
00:49:00,580 --> 00:49:02,670
我々は、この少しについて話しました。

1083
00:49:02,670 --> 00:49:04,240
私たちは、malloc関数と呼ばれるこの機能を使用します。

1084
00:49:04,240 --> 00:49:07,850
そして、あなたはどのように多くのバイト数でそれを伝えます
メモリ、ヒープ上のようにどのように多くのバイト、

1085
00:49:07,850 --> 00:49:08,610
あなたが欲しいです。

1086
00:49:08,610 --> 00:49:13,120
そして、それは、アドレスを返すために起こっています
そうへのポインタ、メモリの一部

1087
00:49:13,120 --> 00:49:14,500
ことそれはあなたのために割り当てられています。

1088
00:49:14,500 --> 00:49:17,080
だから、型はvoidスターになるだろう。

1089
00:49:17,080 --> 00:49:21,310
それはへのポインタになるだろう
何でもあなたがそこに置くことにしました。

1090
00:49:21,310 --> 00:49:23,530
あなたはいつでも呼び出します
malloc関数、我々はすでに述べました

1091
00:49:23,530 --> 00:49:25,640
あなたは私たちはそれを解放する必要があります
メモリリークがありません。

1092
00:49:25,640 --> 00:49:27,170
>> 他の事は何ですか
あなたは絶対にそれ

1093
00:49:27,170 --> 00:49:29,185
ひとつひとつをしなければなりません
時間あなたはmalloc関数を呼び出しますか？

1094
00:49:29,185 --> 00:49:31,210

1095
00:49:31,210 --> 00:49:32,210
[OK]を、あなたはそれを解放する必要があります。

1096
00:49:32,210 --> 00:49:34,010
他の事は何ですか？

1097
00:49:34,010 --> 00:49:35,890
美しい、nullを確認してください。

1098
00:49:35,890 --> 00:49:38,850
だから、ええ、それは正しいです
そこにボード上。

1099
00:49:38,850 --> 00:49:42,120
あなたが割り当てしようとする場合
メモリと、あなたは残されたメモリを持っていません、

1100
00:49:42,120 --> 00:49:44,940
コンピュータが言おうとしています、
私はあなたを与えることは何もありません。

1101
00:49:44,940 --> 00:49:47,650
そして、それはあなたに戻ってヌルを与えます。

1102
00:49:47,650 --> 00:49:48,400
その上での質問？

1103
00:49:48,400 --> 00:49:49,290
うん。

1104
00:49:49,290 --> 00:49:52,995
>> 聴衆：なぜあなたがしたいと思います
特定の型のポインタを宣言

1105
00:49:52,995 --> 00:49:56,329
ボイドスターは扱うことができるとき
とにかく、すべてのポインタ型？

1106
00:49:56,329 --> 00:49:57,370
SPEAKER 1：良い質問。

1107
00:49:57,370 --> 00:50:00,590
なぜ我々はint型のスターを言います
星を無効にするのではなく、

1108
00:50:00,590 --> 00:50:03,740
ボイドスターはすべてを扱うことができますか？

1109
00:50:03,740 --> 00:50:06,390
だから我々はこれまでにしたくありません
明示的にポインタをキャストします。

1110
00:50:06,390 --> 00:50:07,940
それはちょうど悪い習慣です。

1111
00:50:07,940 --> 00:50:11,850
しかし、我々はint型の星について話します
ただの理解として、

1112
00:50:11,850 --> 00:50:14,195
これは、整数へのポインタです。

1113
00:50:14,195 --> 00:50:14,850
>> 聴衆：[OK]をクリックします。

1114
00:50:14,850 --> 00:50:17,558
>> SPEAKER 1：うん、それが可能に
あなたはそれに値を操作します

1115
00:50:17,558 --> 00:50:18,667
整数として。

1116
00:50:18,667 --> 00:50:20,008
>> 聴衆：ああ、[OK]をクリックします。

1117
00:50:20,008 --> 00:50:22,250
ボイドスターは、あなたがそれを行うことはできないだろうか？

1118
00:50:22,250 --> 00:50:25,070
>> SPEAKER 1：それはに依存
コンテキストうん、そう心配しないでください

1119
00:50:25,070 --> 00:50:28,460
あまり心配しないでください
そこ種類について。

1120
00:50:28,460 --> 00:50:32,620
ちょうどその、一般的には、malloc関数を知っています
何かへのポインタを返します。

1121
00:50:32,620 --> 00:50:33,520
良い質問。

1122
00:50:33,520 --> 00:50:37,260
>> 聴衆：なぜあなたは掛けません
それから10倍？ [聞こえません]。

1123
00:50:37,260 --> 00:50:40,150
>> SPEAKER 1：確かに、私はちょうどでした
ここではどこにランダムな例をやって

1124
00:50:40,150 --> 00:50:42,840
私は十分に割り当てるしたいです
10の整数を格納するための部屋。

1125
00:50:42,840 --> 00:50:44,320
ただランダム選択。

1126
00:50:44,320 --> 00:50:45,250
うん。

1127
00:50:45,250 --> 00:50:45,440
うん、最大何ですか？

1128
00:50:45,440 --> 00:50:47,440
>> 観客：あなたは何を
nullをチェックすることによって意味ですか？

1129
00:50:47,440 --> 00:50:51,351
あなたがチェックしますか
nullまたはmalloc関数へのポインタ？

1130
00:50:51,351 --> 00:50:52,350
SPEAKER 1：はい、まさに。

1131
00:50:52,350 --> 00:50:54,599
そこで問題は、何でしたか
我々はヌルにより小切手で意味ですか？

1132
00:50:54,599 --> 00:50:57,880
我々はmalloc関数を呼び出すいつでもto--たい
私たちは、ポインタを返されています

1133
00:50:57,880 --> 00:51:01,110
私たちが言いたい、です
ヌルに等しいポインタ？

1134
00:51:01,110 --> 00:51:02,610
だから、文字通りPTR。

1135
00:51:02,610 --> 00:51:05,620
PTRがnullに等しいです。

1136
00:51:05,620 --> 00:51:06,958
はい。

1137
00:51:06,958 --> 00:51:08,832
観客は：だから、私は親切でした
あなたならば、不思議の

1138
00:51:08,832 --> 00:51:14,013
、malloc関数へのポインタを初期化しません
それは、malloc関数の先頭を指しますか？

1139
00:51:14,013 --> 00:51:15,097
それはarray--だ場合ので、

1140
00:51:15,097 --> 00:51:16,554
SPEAKER 1：それは素晴らしい質問です。

1141
00:51:16,554 --> 00:51:19,200
うん、あなたはmalloc関数を呼び出す場合、
のは言わせit--ポインタ、

1142
00:51:19,200 --> 00:51:21,700
そこでここでは、メモリの10バイトを割り当てます。

1143
00:51:21,700 --> 00:51:23,830
だから、私は十分に、ごめんなさい
10の整数のための部屋、

1144
00:51:23,830 --> 00:51:28,220
我々は、のアドレスを取得するつもりです
メモリの最初の作品。

1145
00:51:28,220 --> 00:51:29,880
それはいい質問ですね。

1146
00:51:29,880 --> 00:51:30,481
うん。

1147
00:51:30,481 --> 00:51:34,810
>> 聴衆：割り当てることにより
10広範囲の整数、

1148
00:51:34,810 --> 00:51:38,177
あなたが実際にそれを使用することができます
ほとんどlike--としてポインタ

1149
00:51:38,177 --> 00:51:39,372
整数の配列のような？

1150
00:51:39,372 --> 00:51:41,830
SPEAKER 1：うん、そうすることができます
整数の配列としてそれを使うのか？

1151
00:51:41,830 --> 00:51:45,970
うん、まさに、これはまさにPulakです
、あなたはカップルが前にスライドしon--示しました

1152
00:51:45,970 --> 00:51:48,680
我々はOK、これは、言うところ
本当にただの種類of--たち

1153
00:51:48,680 --> 00:51:50,805
考えることができます
10整数の配列。

1154
00:51:50,805 --> 00:51:52,222
それはちょうどヒープ上にあることを起こります。

1155
00:51:52,222 --> 00:51:54,971
聴衆：しかし、あなたはアクセスできませんでした
それ角括弧記法と？

1156
00:51:54,971 --> 00:51:58,220
SPEAKER 1：あなたが実際にアクセスすることができました
角括弧表記とそれ、ええ。

1157
00:51:58,220 --> 00:52:00,221
あなたはそれらを同じに扱うことができます。

1158
00:52:00,221 --> 00:52:00,720
はい。

1159
00:52:00,720 --> 00:52:02,420
>> 聴衆：なぜだろう
ポインタは、これまでnullになりますか？

1160
00:52:02,420 --> 00:52:04,170
>> SPEAKER 1：なぜだろう
ポインタは、これまでnullになりますか？

1161
00:52:04,170 --> 00:52:06,570
あなたはすべてのを使用する場合
ヒープ上のメモリ。

1162
00:52:06,570 --> 00:52:09,141
あなたのプログラムが食べている場合は、
、食べメモリを食べて、

1163
00:52:09,141 --> 00:52:11,890
何も、その後、左ありません
malloc関数は、あなたが言う場合say--になるだろう

1164
00:52:11,890 --> 00:52:14,760
私はそれが起こっている、100以上のバイトをしたいです
言って、私は100バイトを持っていません。

1165
00:52:14,760 --> 00:52:15,740
ここではnullです。

1166
00:52:15,740 --> 00:52:18,780
ことを意味し、私は失敗しました。

1167
00:52:18,780 --> 00:52:20,516
はい。

1168
00:52:20,516 --> 00:52:22,830
>> 聴衆：その場合は、
nullは右、何もありませんか？

1169
00:52:22,830 --> 00:52:24,110
>> SPEAKER 1：はい、その中
場合は、nullが何もありません。

1170
00:52:24,110 --> 00:52:24,943
あなたは何のアドレスを持っていません。

1171
00:52:24,943 --> 00:52:28,065
全く記憶がありません。

1172
00:52:28,065 --> 00:52:31,500
すべての権利、に移動。

1173
00:52:31,500 --> 00:52:34,976
[OK]を、のは、本当にすぐに話をしましょう
バッファオーバーフローについて。

1174
00:52:34,976 --> 00:52:38,210
私たちは、バッファオーバーフローの発生する可能性があるのはいつですか？

1175
00:52:38,210 --> 00:52:42,980
我々はA--たちがあるとしましょう
メモリのチャンクを割り当て、

1176
00:52:42,980 --> 00:52:44,720
我々は内の文字列を記述するつもりです。

1177
00:52:44,720 --> 00:52:47,240
そして、私たちは言うつもりです、
[OK]を、私は割り当てするつもりです

1178
00:52:47,240 --> 00:52:49,320
6文字のための十分な部屋。

1179
00:52:49,320 --> 00:52:51,680
そして、私はお願いするつもりです
いくつかの入力のためのユーザー。

1180
00:52:51,680 --> 00:52:54,470
そして、ユーザ入力、例えば、こんにちは。

1181
00:52:54,470 --> 00:52:56,430
そして、それは完璧にフィット
我々は細かいので、

1182
00:52:56,430 --> 00:53:00,790
ハローのすべての文字のための部屋、
ヌル終端文字。

1183
00:53:00,790 --> 00:53:02,840
部屋のプレンティ、問題ありません。

1184
00:53:02,840 --> 00:53:08,010
>> しかし、我々はチャンスを何を与える場合
我々のプログラムを使用するには、邪悪なユーザーのために、

1185
00:53:08,010 --> 00:53:13,152
彼らはない6文字で入力し、
か5文字が、百万円となりました。

1186
00:53:13,152 --> 00:53:15,860
彼らは、タイピング、タイピングを維持し、
タイピング、何が起こるだろうか？

1187
00:53:15,860 --> 00:53:18,220
まあ我々は与えます
コンピュータenough--または申し訳ありませんが、

1188
00:53:18,220 --> 00:53:23,350
我々は、この文字列を与えました
5文字のための十分なスペース。

1189
00:53:23,350 --> 00:53:28,300
だから、私たちはのようなものを取得するつもりです
だこれ、どこに悪人

1190
00:53:28,300 --> 00:53:31,750
入力に入力すると上書きすることができます
バッファのサイズ、

1191
00:53:31,750 --> 00:53:35,922
その量を超えて実際に行くことができます
ことそれは、もともと割り当てられています。

1192
00:53:35,922 --> 00:53:38,380
そして、あなたは何ができますか、
あなたが行うことができます本当に邪悪なもの、

1193
00:53:38,380 --> 00:53:40,260
リターンアドレスを上書きです。

1194
00:53:40,260 --> 00:53:42,010
基本的にどの手段
あなたはこの種の取ることができます

1195
00:53:42,010 --> 00:53:45,110
プログラムの動作を制御します。

1196
00:53:45,110 --> 00:53:47,880
だから、非常に高いレベルで
バッファオーバーフローがあるとき

1197
00:53:47,880 --> 00:53:49,960
あなたは、メモリのいくつかの量を割り当てます。

1198
00:53:49,960 --> 00:53:53,060
そして、このyou--あなたがしているので、
ユーザー入力または何かを取ります

1199
00:53:53,060 --> 00:53:57,190
あなたが境界を超えて行くthat--様
あなたが最初に割り当てられたものの

1200
00:53:57,190 --> 00:53:59,955
そしてあなたのプログラムをめちゃくちゃに開始します。

1201
00:53:59,955 --> 00:54:00,455
はい？

1202
00:54:00,455 --> 00:54:03,220
>> 聴衆：なぜしないことだけ
セグメンテーションフォールトを返しますか？

1203
00:54:03,220 --> 00:54:05,594
>> SPEAKER 1：なぜしないこと
セグメンテーションフォールトを返しますか？

1204
00:54:05,594 --> 00:54:06,570
それは可能性があります。

1205
00:54:06,570 --> 00:54:10,030
時には、コンパイラや
ランタイムの間、

1206
00:54:10,030 --> 00:54:11,430
実際にそれを確認しようとしています。

1207
00:54:11,430 --> 00:54:13,890
特定の物事が起こる場合、および
これは、下位レベルの一種であります

1208
00:54:13,890 --> 00:54:15,610
あなたは知っている必要があります。

1209
00:54:15,610 --> 00:54:18,820
しかし、あなたが設計していない場合
適切にこれらのシステム、

1210
00:54:18,820 --> 00:54:21,170
あなたはチャンスがあります
ちょうどそれをキャッチし、ないの

1211
00:54:21,170 --> 00:54:24,844
take--コンピュータを許可します
邪悪な人は、お使いのコンピュータを制御することができます。

1212
00:54:24,844 --> 00:54:25,344
うん。

1213
00:54:25,344 --> 00:54:26,260
>> 聴衆：[聞こえませんか]？

1214
00:54:26,260 --> 00:54:28,934

1215
00:54:28,934 --> 00:54:29,600
SPEAKER 1：確かに。

1216
00:54:29,600 --> 00:54:33,800
私はバッファを言うときああ、私はちょうど意味します
あなたが割り当てられてきたメモリの量。

1217
00:54:33,800 --> 00:54:39,090
だからここに私はああ、私たちが割り当てられてきた、と述べた6
6文字のための十分な余地をchar--。

1218
00:54:39,090 --> 00:54:42,880
そして私はちょうど私のバッファことを呼び出します
どこで情報を書き込むことがあります。

1219
00:54:42,880 --> 00:54:44,390
うん。

1220
00:54:44,390 --> 00:54:46,791
この上の任意の他の質問？

1221
00:54:46,791 --> 00:54:47,290
うん。

1222
00:54:47,290 --> 00:54:49,150
>> 観客：あなたはそれを阻止する方法を教えてください

1223
00:54:49,150 --> 00:54:50,274
どのようにそれを停止するのですか？

1224
00:54:50,274 --> 00:54:51,440
SPEAKER 1：素晴らしい質問です。

1225
00:54:51,440 --> 00:54:52,240
どのようにそれを停止するのですか？

1226
00:54:52,240 --> 00:54:54,110
どのようにして、バッファオーバーフローを防ぐのですか？

1227
00:54:54,110 --> 00:54:59,160
まあそれを行う方法の1つは、のようなものです
私たちは常に増加のGetString、

1228
00:54:59,160 --> 00:55:03,200
我々が割り当てるメモリの量
ユーザは、大量のテキストを入力した場合。

1229
00:55:03,200 --> 00:55:07,570
もう一つは、あなたの場合にのみ、です
6文字にしたい、クイックチェックを実行します。

1230
00:55:07,570 --> 00:55:11,220
入力のみ6文字を言います。

1231
00:55:11,220 --> 00:55:12,444
うん。

1232
00:55:12,444 --> 00:55:14,360
それでは、あなたがいたとしましょう
私たちが行っている作業on--

1233
00:55:14,360 --> 00:55:16,985
ウェブのものに行くために少し
後でcourse--ではなくレッツ

1234
00:55:16,985 --> 00:55:21,422
あなたが希望、フォームに取り組んでいると言います
ただで渡した可能性がどのくらい制限しています。

1235
00:55:21,422 --> 00:55:22,378
うん。

1236
00:55:22,378 --> 00:55:24,768
>> 観客は：のGetStringを引っ張ります
スタックからメモリ、右？

1237
00:55:24,768 --> 00:55:25,444
ただ明確にしますか？

1238
00:55:25,444 --> 00:55:26,485
SPEAKER 1：1つのより多くの時間？

1239
00:55:26,485 --> 00:55:28,400
聴衆：DOESのGetString
スタックからメモリを取りますか？

1240
00:55:28,400 --> 00:55:31,210
SPEAKER 1：私は信じてGetm-- GET
int型は、ヒープからメモリを取ります

1241
00:55:31,210 --> 00:55:32,911
それはALLOCを呼び出すため。

1242
00:55:32,911 --> 00:55:33,452
聴衆：ああ。

1243
00:55:33,452 --> 00:55:33,951
OK。

1244
00:55:33,951 --> 00:55:35,750
SPEAKER 1：うん、mallocとreallocの。

1245
00:55:35,750 --> 00:55:37,120
その他の質問？

1246
00:55:37,120 --> 00:55:37,803
うん。

1247
00:55:37,803 --> 00:55:40,650
>> 聴衆：だから定義することで、
バッファのサイズは、

1248
00:55:40,650 --> 00:55:42,733
あなたがれるのを防ぎます
コー​​ドを挿入することができるという

1249
00:55:42,733 --> 00:55:45,700
それは[聞こえない]を越えてスライドすることができます。

1250
00:55:45,700 --> 00:55:48,130
>> SPEAKER 1：だから、定義することにより、
バッファのサイズ、

1251
00:55:48,130 --> 00:55:50,760
[OK]を、ここでどのようだ、と述べてきました
我々が使用することができます多くのメモリ。

1252
00:55:50,760 --> 00:55:55,550
あなたは上にユーザーが書き込むことができるようにした場合、
あなたが問題に実行しようとしています。

1253
00:55:55,550 --> 00:55:57,930
意味をなさない。

1254
00:55:57,930 --> 00:55:59,370
驚くばかり。

1255
00:55:59,370 --> 00:56:00,640
それでは、一緒に移動してみましょう。

1256
00:56:00,640 --> 00:56:02,320
大丈夫。

1257
00:56:02,320 --> 00:56:06,652
エラーといえば、ここにいます
いくつかの一般的なエラーメッセージ

1258
00:56:06,652 --> 00:56:09,860
あなたがあったが、それは最大を示している可能性があります
コー​​ディング、あなたの問題セットに取り組んでいます。

1259
00:56:09,860 --> 00:56:12,320
1のチャンス
これらは、クイズに現れます

1260
00:56:12,320 --> 00:56:15,090
過去数年間は、任意の表示であれば。

1261
00:56:15,090 --> 00:56:17,580
だから、答えは一種のです
ここでボード上のアップ。

1262
00:56:17,580 --> 00:56:19,510
しかし、いくつかのより多くの叫ぶ気軽に。

1263
00:56:19,510 --> 00:56:21,280
>> なぜセグメンテーションフォールトが発生する可能性がありますか？

1264
00:56:21,280 --> 00:56:24,279
なぜあなたは、セグメンテーションフォールトを得るかもしれません
あなたはあなたのプログラムを実行しているとき？

1265
00:56:24,279 --> 00:56:26,760

1266
00:56:26,760 --> 00:56:28,230
>> 聴衆：[聞こえません]。

1267
00:56:28,230 --> 00:56:29,500
>> SPEAKER 1：良いです。

1268
00:56:29,500 --> 00:56:32,820
ええ、私たちは、アクセスしようとした場合
私たちに与えられていないメモリ。

1269
00:56:32,820 --> 00:56:34,610
我々NULLポインタデリファレンスの場合。

1270
00:56:34,610 --> 00:56:38,610
例えば、我々はmalloc関数を呼び出す場合は、
そして、それがnullだかどうかを確認することを忘れ

1271
00:56:38,610 --> 00:56:42,250
そして私たちは、コンピュータのそれを使用してみてください
私たちにセグメンテーションフォールトを与えるつもり。

1272
00:56:42,250 --> 00:56:42,750
良い。

1273
00:56:42,750 --> 00:56:46,680
暗黙のはどう
関数の宣言？

1274
00:56:46,680 --> 00:56:48,589
どういう意味ですか？

1275
00:56:48,589 --> 00:56:51,380
観客：あなたが使用しようとしています
あなたが定義されていない機能。

1276
00:56:51,380 --> 00:56:52,130
SPEAKER 1：良いです。

1277
00:56:52,130 --> 00:56:54,504
あなたは、関数を使用しようとしています
あなたが定義されていないこと。

1278
00:56:54,504 --> 00:56:56,000
だから、2つのうちの1つである可能性があります。

1279
00:56:56,000 --> 00:56:59,320
多分それは例のようでした
カミーユは、以前のあなたを示しました。

1280
00:56:59,320 --> 00:57:02,330
そして、あなたは主な機能を持っています
それは、キューブと呼ばれるものを呼び出します。

1281
00:57:02,330 --> 00:57:04,371
そして、あなたが忘れてしまったとしましょう
このプロトタイプを書き込みます。

1282
00:57:04,371 --> 00:57:07,540
あなたが言うのを忘れて、ちょっとコンピュータ、
私はキューブと呼ばれるこの機能を持っています。

1283
00:57:07,540 --> 00:57:09,380
あなたは、後でそれを見ることができます。

1284
00:57:09,380 --> 00:57:12,440
それでは、あなたが書くのを忘れたとしましょう
プロトタイプは、このエラーが発生する場合があります。

1285
00:57:12,440 --> 00:57:14,820
もう一つは、のは言わせています
あなたは、printfのを使用しようとしました

1286
00:57:14,820 --> 00:57:16,880
そして含めるのを忘れました
標準ライブラリ、

1287
00:57:16,880 --> 00:57:20,240
それは暗黙の言おうとしています
関数の宣言。

1288
00:57:20,240 --> 00:57:22,800
そして最後に、ではなく、少なくとも、
未宣言の識別子。

1289
00:57:22,800 --> 00:57:23,300
うん。

1290
00:57:23,300 --> 00:57:24,841
>> 観客は：あなたは、問題の範囲を持っています。

1291
00:57:24,841 --> 00:57:28,728
多分あなたがしようとしているように
だローカル変数を呼び出します

1292
00:57:28,728 --> 00:57:30,884
地域別の種類です。

1293
00:57:30,884 --> 00:57:33,550
SPEAKER 1：今、あなたが持っている場合ので、
スコープではない変数、

1294
00:57:33,550 --> 00:57:36,890
そして、あなたはそれを使用しようとしています、
あなたがトラブルに取得するつもりです。

1295
00:57:36,890 --> 00:57:40,960
そして、ちょうどより一般的には、のは言わせて
あなたはint型を言って、Xを使用するようにしてください

1296
00:57:40,960 --> 00:57:45,140
Xはあなたがしている、その後、5に等しいです
トラブルに実行するつもり。

1297
00:57:45,140 --> 00:57:47,640
これについての質問、すみません！

1298
00:57:47,640 --> 00:57:49,330
恐ろしい、右に沿って一気飲み。

1299
00:57:49,330 --> 00:57:55,692
>> [OK]を、再帰、なぜてみましょうmight--
see--私は、私のオハイオ州ここで行くsch--失わ

1300
00:57:55,692 --> 00:57:57,400
念私たちがしている作ります
おおよそのスケジュールで。

1301
00:57:57,400 --> 00:57:59,060
すべての権利、涼しいです。

1302
00:57:59,060 --> 00:58:03,150
[OK]を、再帰、一般的な考え方
再帰、再帰関数

1303
00:58:03,150 --> 00:58:05,380
自分自身を呼び出す関数です。

1304
00:58:05,380 --> 00:58:08,170
[OK]を、ので、それは私です
プログラムの概念の意味

1305
00:58:08,170 --> 00:58:11,130
それによって機能が自分自身を呼び出します。

1306
00:58:11,130 --> 00:58:16,210
何some--何だろう
再帰を使うのは良い理由は？

1307
00:58:16,210 --> 00:58:17,550
とき、それは便利かもしれませんか？

1308
00:58:17,550 --> 00:58:20,926
またはいただきましプログラム本当に
再帰に適していますか？

1309
00:58:20,926 --> 00:58:22,330
>> 聴衆：バイナリ検索。

1310
00:58:22,330 --> 00:58:25,500
>> SPEAKER 1：バイナリ検索
再帰に自分自身を貸します、

1311
00:58:25,500 --> 00:58:29,060
あなたはこの問題を持っているので、
小さな断片に分解することができ、

1312
00:58:29,060 --> 00:58:32,330
かつ継続的に行います
その上に同じアルゴリズム。

1313
00:58:32,330 --> 00:58:37,790
これは、より多くの場合に導きます
より正確なエレガントなコード。

1314
00:58:37,790 --> 00:58:40,500
私たちは一例です
バイナリサーチの。

1315
00:58:40,500 --> 00:58:43,100
別の例は、マージソートです。

1316
00:58:43,100 --> 00:58:45,920
時には、あなたが考えるとき、
アルゴリズム、階乗のように、

1317
00:58:45,920 --> 00:58:47,410
それはちょうど、再帰的な感じ？

1318
00:58:47,410 --> 00:58:52,440
我々はその階乗を知っているので
5の階乗は4〜5倍です。

1319
00:58:52,440 --> 00:58:56,080
だから、あなたが問題を設定するとき
その方法は、それだけで再帰的な感じ。

1320
00:58:56,080 --> 00:58:58,530
だからだろう
それを書くのに最適な方法。

1321
00:58:58,530 --> 00:58:59,425
質問？

1322
00:58:59,425 --> 00:59:00,395
はい。

1323
00:59:00,395 --> 00:59:01,850
>> 聴衆：ベースケースは何ですか？

1324
00:59:01,850 --> 00:59:02,770
>> SPEAKER 1：ああベースケースは何ですか？

1325
00:59:02,770 --> 00:59:04,680
私は忘れていない、と述べました
基本ケースを含めることができます。

1326
00:59:04,680 --> 00:59:07,690
我々は書いていたとしましょう
階乗関数、

1327
00:59:07,690 --> 00:59:09,620
私たちは5の階乗をしていました。

1328
00:59:09,620 --> 00:59:12,352
そして、我々は5の階乗を知っています
4の5倍の階乗で、

1329
00:59:12,352 --> 00:59:13,310
何とか、何とか、何とか、何とか。

1330
00:59:13,310 --> 00:59:14,360
停止するとき、どのように我々は知っているのですか？

1331
00:59:14,360 --> 00:59:16,276
我々は、我々の方法を知っていますか
実際に数を持っていますか？

1332
00:59:16,276 --> 00:59:20,180
我々は階乗呼び続けている場合ので、
その後、我々は正しい、答えを得ることは決してないだろうか？

1333
00:59:20,180 --> 00:59:24,470
だから我々はどのように知っているとき
階乗の例で停止。

1334
00:59:24,470 --> 00:59:25,460
誰でも、ええ。

1335
00:59:25,460 --> 00:59:27,764
>> 対象：1階乗が1の場合。

1336
00:59:27,764 --> 00:59:28,430
SPEAKER 1：良いです。

1337
00:59:28,430 --> 00:59:29,530
だから我々は知っています。

1338
00:59:29,530 --> 00:59:33,400
私たちは、付与され、そのために取ることができます
1階乗は1に等しいです。

1339
00:59:33,400 --> 00:59:36,570
だから我々はどこにポイントに取得する場合
私たちは、1の階乗を呼んでいます

1340
00:59:36,570 --> 00:59:38,050
ただ先に行くと1を返します。

1341
00:59:38,050 --> 00:59:39,180
そして、それはあなたのベースケースです。

1342
00:59:39,180 --> 00:59:45,040
私たちがかつて知っているので、我々はそれを押すと、
我々は常にそれをヒットする、私たちはnever--ます

1343
00:59:45,040 --> 00:59:48,800
私たちは永遠に続けることはありません。

1344
00:59:48,800 --> 00:59:50,700
再帰上の任意の他の質問？

1345
00:59:50,700 --> 00:59:51,630
はい。

1346
00:59:51,630 --> 00:59:54,420
>> 聴衆：だから、返します
1、それだけで自動的に

1347
00:59:54,420 --> 00:59:56,290
右、プログラムを停止しますか？

1348
00:59:56,290 --> 00:59:59,390
>> SPEAKER 1：うんそうするときに、
のは言わせif--、復帰1を呼び出し、

1349
00:59:59,390 --> 01:00:04,480
のは言わせて2コールの階乗
1の階乗1の階乗、

1350
01:00:04,480 --> 01:00:06,120
わずか1をバック手になります。

1351
01:00:06,120 --> 01:00:12,790
そして今、2の階乗は、[OK] 2を言うだろう
回1〜2であり、その答えを返します。

1352
01:00:12,790 --> 01:00:14,260
はい。

1353
01:00:14,260 --> 01:00:16,710
>> 観客は：私たちが心配する必要はありますか
再帰内のスコープについて

1354
01:00:16,710 --> 01:00:20,150
あなたはアルゴリズムに行くとき？

1355
01:00:20,150 --> 01:00:21,880
>> SPEAKER 1：ああ、はい。

1356
01:00:21,880 --> 01:00:25,060
はい、あなたは心配する必要がありません
再帰の文脈でスコープ。

1357
01:00:25,060 --> 01:00:29,820
だから、唯一の変数が定義されています
関数の実行中

1358
01:00:29,820 --> 01:00:32,170
便利なことを行っています。

1359
01:00:32,170 --> 01:00:33,792
うん良い質問。

1360
01:00:33,792 --> 01:00:35,250
すべての権利、に沿って動かし続けるみましょう。

1361
01:00:35,250 --> 01:00:37,320
私たちはたくさんあるので
材料は、を介して取得します。

1362
01:00:37,320 --> 01:00:41,080
私が言ったようにしかし、打つ気軽に
事後営業時間、または私達。

1363
01:00:41,080 --> 01:00:42,850
>> これは、本当に迅速なスライドです。

1364
01:00:42,850 --> 01:00:45,150
私たちは、について多くのことを学びました
検索とソートされます。

1365
01:00:45,150 --> 01:00:47,400
お願い、お願い、お願い、
これらのセクションでは、オンラインであります

1366
01:00:47,400 --> 01:00:51,240
私はcs50.net/quizzesで信じています。

1367
01:00:51,240 --> 01:00:53,762
だから、このチャートを取りに行くと
あなたのレビューシートの上に置きます、

1368
01:00:53,762 --> 01:00:55,470
が存在することになるため、
これについての質問です。

1369
01:00:55,470 --> 01:00:56,682
それは誤解しないでください。

1370
01:00:56,682 --> 01:00:58,390
ただ、非常に迅速に、
何このチャート手段、

1371
01:00:58,390 --> 01:01:04,370
それは我々が知っている、ビッグOについて語っています
アルゴリズムの上限であるために

1372
01:01:04,370 --> 01:01:05,150
実行時間。

1373
01:01:05,150 --> 01:01:08,080
そして、我々は、オメガを持っています
下限になるだろう

1374
01:01:08,080 --> 01:01:10,290
アルゴリズムランタイムの。

1375
01:01:10,290 --> 01:01:10,840
OK？

1376
01:01:10,840 --> 01:01:12,480
>> 聴衆：[聞こえません]。

1377
01:01:12,480 --> 01:01:12,800
>> SPEAKER 1：うん、最後のものは何ですか？

1378
01:01:12,800 --> 01:01:13,380
シータは何ですか？

1379
01:01:13,380 --> 01:01:16,850
我々は唯一のつもりwe--場合があります
場合には、このクラスでは気に

1380
01:01:16,850 --> 01:01:19,381
ここで、私たちの上限と
私たちの下界は同じです。

1381
01:01:19,381 --> 01:01:22,005
うん、それはそれは唯一の時間です
このクラスに出てくるつもり。

1382
01:01:22,005 --> 01:01:23,320
[OK]を、私は続けるつもりです。

1383
01:01:23,320 --> 01:01:26,490
あなたがあなたの写真を撮影していない場合は、
私はこれらがオンラインになります約束します。

1384
01:01:26,490 --> 01:01:28,220
>> [OK]を、素晴らしい、構造体。

1385
01:01:28,220 --> 01:01:29,810
なぜ我々は構造体をしたいのでしょうか？

1386
01:01:29,810 --> 01:01:34,110
便利な理由は何ですか
我々は、構造体が必要になる場合があります。

1387
01:01:34,110 --> 01:01:36,277
誰かが何かを叫びます。

1388
01:01:36,277 --> 01:01:38,110
さてそれでは、見てみましょう
ボード上の例。

1389
01:01:38,110 --> 01:01:41,090
我々は扱っているとしましょう
これらの学生のすべてと。

1390
01:01:41,090 --> 01:01:44,900
我々はのためのプログラムを作っている場合
CS50は、800人のようにあります。

1391
01:01:44,900 --> 01:01:47,890
我々はするつもりwrite--する必要があります
多くの情報を処理する必要があります

1392
01:01:47,890 --> 01:01:49,020
学生について。

1393
01:01:49,020 --> 01:01:50,990
それは、もしいいだろう
我々は可能性基の種類

1394
01:01:50,990 --> 01:01:54,460
すべての情報をthis--こと
特定の学生に関係しています

1395
01:01:54,460 --> 01:01:56,027
一つのデータ型に変換します。

1396
01:01:56,027 --> 01:01:58,360
しかし、我々はデータがありません知っています
右、学生、と呼ばれるタイプ？

1397
01:01:58,360 --> 01:02:01,890
私たちは、フロートを持って、整数を持っています、
我々は、文字列、またはcharの星を持っています、

1398
01:02:01,890 --> 01:02:03,920
私たちは、学生を持っていません。

1399
01:02:03,920 --> 01:02:08,680
>> だから我々は、実際にこの種の定義されて行うことができます
当社独自の構造、生徒を呼び出し、

1400
01:02:08,680 --> 01:02:12,440
そして、我々はいくつかを関連付けることができます
その構造体と異​​なるフィールド。

1401
01:02:12,440 --> 01:02:14,410
したがって、この場合には、してみましょう
私たちは学生を持っていると言います。

1402
01:02:14,410 --> 01:02:17,350
我々はケアとの事
約学籍番号です

1403
01:02:17,350 --> 01:02:19,500
そして、学生の名前。

1404
01:02:19,500 --> 01:02:24,175
そして今、我々はこのIDを関連付けることができます
与えられた学生と、この名前。

1405
01:02:24,175 --> 01:02:25,300
それでは、いくつかの例を見てみましょう。

1406
01:02:25,300 --> 01:02:28,860

1407
01:02:28,860 --> 01:02:33,490
>> [OK]を、私が言うので、ここでは、[OK]を、してみましょう
私たちは学生をしたいと言います。

1408
01:02:33,490 --> 01:02:35,050
私は学生1彼に電話。

1409
01:02:35,050 --> 01:02:38,850
そして、彼のID番号、
この場合、私たちはアクセスすることができます

1410
01:02:38,850 --> 01:02:45,200
ただ、学生の名前を実行して、
私たちがアクセスしたいフィールドに点在しています。

1411
01:02:45,200 --> 01:02:49,110
だから、これはただの学生であることを行っています
1ドットIDは、我々は1に等しく、それを設定します。

1412
01:02:49,110 --> 01:02:52,300
覚えているので、我々はそれを言いました
IDが整数になるだろう。

1413
01:02:52,300 --> 01:02:56,540
そして、非常に似た、我々は、これを言うことができます
学生の名前は、デーヴィンになるだろう

1414
01:02:56,540 --> 01:02:57,760
例えば。

1415
01:02:57,760 --> 01:03:01,420
だから我々はただフィールドにアクセスすることができます
このドットを使って構造体の。

1416
01:03:01,420 --> 01:03:03,098
その上での質問？

1417
01:03:03,098 --> 01:03:03,598
うん。

1418
01:03:03,598 --> 01:03:05,582
>> 聴衆：どのような方法があります
あなたの変数を保護するには？

1419
01:03:05,582 --> 01:03:08,560
変数を保護する方法はあります
外部からアクセスされていますか？

1420
01:03:08,560 --> 01:03:10,726
>> SPEAKER 1：とにかくあり
あなたの変数を保護します

1421
01:03:10,726 --> 01:03:12,680
外部からアクセスされていますか？

1422
01:03:12,680 --> 01:03:13,750
ありませんCS50の範囲です。

1423
01:03:13,750 --> 01:03:16,680

1424
01:03:16,680 --> 01:03:17,977
その他の質問？

1425
01:03:17,977 --> 01:03:18,476
うん。

1426
01:03:18,476 --> 01:03:18,942
>> 聴衆：typedefは構造体とは何ですか？

1427
01:03:18,942 --> 01:03:20,192
各コンポーネントは何を意味するのでしょうか？

1428
01:03:20,192 --> 01:03:22,937

1429
01:03:22,937 --> 01:03:24,520
SPEAKER 1：ああ、typedefは構造体は何ですか？

1430
01:03:24,520 --> 01:03:26,240
各コンポーネントには何が
この男の意味ですか？

1431
01:03:26,240 --> 01:03:26,850
>> 聴衆：うん。

1432
01:03:26,850 --> 01:03:27,683
>> SPEAKER 1：OK、涼しいです。

1433
01:03:27,683 --> 01:03:31,200
だから、これは私は、ちょっとコンピュータ、言います
新しい構造を作成します。

1434
01:03:31,200 --> 01:03:34,970
そして、私は定義を定義するつもりです
私はそれを使用することができることをそれのために、このような

1435
01:03:34,970 --> 01:03:37,520
それはタイプであるか​​のように
私のプログラムを通して。

1436
01:03:37,520 --> 01:03:39,300
[OK]をので、私は構造を定義します。

1437
01:03:39,300 --> 01:03:41,650
そして、私は今であることを行っています
タイプとしてそれを使用すること。

1438
01:03:41,650 --> 01:03:43,400
その名前は、学生です。

1439
01:03:43,400 --> 01:03:45,730
そして、ここでそのフィールドがあります。

1440
01:03:45,730 --> 01:03:48,130
>> 観客は：だからということです
typedefは構造体[聞こえませんか]？

1441
01:03:48,130 --> 01:03:50,592

1442
01:03:50,592 --> 01:03:53,800
SPEAKER 1：次のことができるようにしたい場合
あなたのプログラムを通じて、この構造体を使用し、

1443
01:03:53,800 --> 01:03:57,910
そして、CS50の私達のほとんどのケースで
、我々はタイプデフを言わなければなりません。

1444
01:03:57,910 --> 01:04:01,190
そして、それはそれはそれを同じように使用することができます
我々はintやfloat型のように使用する方法。

1445
01:04:01,190 --> 01:04:04,168
コンピュータ意志
常にそれが何であるかを知っています。

1446
01:04:04,168 --> 01:04:04,668
うん。

1447
01:04:04,668 --> 01:04:06,560
>> 観客：我々は書くことができます
このヘッダファイルで？

1448
01:04:06,560 --> 01:04:07,060
>> SPEAKER 1：ああ、申し訳ありません。

1449
01:04:07,060 --> 01:04:08,600
我々は、ヘッダファイルでこれを書いていますか？

1450
01:04:08,600 --> 01:04:11,410
あなたはあなたのの上でこれを書くことができます
プログラム、Cプログラムの一番上にあります。

1451
01:04:11,410 --> 01:04:13,010
ええ、それはほとんどのだろう
それのための合理的な場所。

1452
01:04:13,010 --> 01:04:13,509
そこに戻って。

1453
01:04:13,509 --> 01:04:15,704
聴衆：同じ質問なので、主の前に？

1454
01:04:15,704 --> 01:04:18,870
SPEAKER 1：右、あなたはこれをする必要があります
誰もがそれにアクセスできることをどこかで。

1455
01:04:18,870 --> 01:04:20,612
だからあなたの場合には主の前に、ええ。

1456
01:04:20,612 --> 01:04:23,820
聴衆：差があります
上と一番下に学生を入れて？

1457
01:04:23,820 --> 01:04:25,810
SPEAKER 1：ああ、あり
パッティングの学生の違い

1458
01:04:25,810 --> 01:04:26,840
上部または下部のオン？

1459
01:04:26,840 --> 01:04:29,650
その質問を保存し、Let--
我々は、リンクされたリストを取得するとき、

1460
01:04:29,650 --> 01:04:31,020
我々はOK、それが表示されますか？

1461
01:04:31,020 --> 01:04:32,750
だから、1秒間それにしがみつきます。

1462
01:04:32,750 --> 01:04:37,080
私はここで言及したい最後のこと、
代わりに構造を有することがあり、

1463
01:04:37,080 --> 01:04:41,180
我々は、構造体へのポインタを持っています
我々は我々の表記法を変更することができます

1464
01:04:41,180 --> 01:04:42,480
少しよりよいします。

1465
01:04:42,480 --> 01:04:45,810
>> 我々は、我々が持っているとしましょう​​、と言うことができます
学生へのポインタだけではなく、

1466
01:04:45,810 --> 01:04:47,040
学生。

1467
01:04:47,040 --> 01:04:52,460
我々は、代わりのフィールドにアクセスしたい場合
やって、うまくポインタを間接参照行き、

1468
01:04:52,460 --> 01:04:54,100
して、フィールド名にアクセスします。

1469
01:04:54,100 --> 01:04:57,310
この表記は少し見えます
このドットのスターと厄介。

1470
01:04:57,310 --> 01:05:00,790
完全に正しいが、種類
それを行うためのクリーンな方法を、

1471
01:05:00,790 --> 01:05:03,280
ちょうどポインタの矢印の名前を言うことです。

1472
01:05:03,280 --> 01:05:11,460
そして、それは実際に間接参照を組み合わせました
一つの美しいシンボルにアクセスします。

1473
01:05:11,460 --> 01:05:12,470
その上での質問？

1474
01:05:12,470 --> 01:05:13,760
>> 観客は：ちょうどその1より多くの時間を言います。

1475
01:05:13,760 --> 01:05:14,480
>> SPEAKER 1：1より多くの時間と言います。

1476
01:05:14,480 --> 01:05:16,021
>> 聴衆：まさにあなただけ言いました。

1477
01:05:16,021 --> 01:05:17,870
SPEAKER 1：確かに、正確に
何私は言いました。

1478
01:05:17,870 --> 01:05:21,580
私たちは、学生へのポインタを持っている場合
むしろ学生自体よりも、

1479
01:05:21,580 --> 01:05:25,410
私たちがアクセスできる一つの方法をcan--
フィールドは、間接参照であり、そしてその後

1480
01:05:25,410 --> 01:05:27,110
アクセス名。

1481
01:05:27,110 --> 01:05:29,040
もう一つの、よりよい方法は我々
ちょうどである、それを行うことができます

1482
01:05:29,040 --> 01:05:33,550
構文糖を少し、
ちょうどポインタの矢印の名前を行うことです。

1483
01:05:33,550 --> 01:05:38,190
そして、それは結合するために起こっています
逆参照およびアクセス。

1484
01:05:38,190 --> 01:05:40,400
うん、かなりクール。

1485
01:05:40,400 --> 01:05:41,260
大丈夫。

1486
01:05:41,260 --> 01:05:44,390
>> それでは、他の質問について話しましょう​​。

1487
01:05:44,390 --> 01:05:46,520
ノードにジャンプしてみましょう、
我々が使用するつもりれます

1488
01:05:46,520 --> 01:05:49,120
ちょうど秒でリンクされたリストです。

1489
01:05:49,120 --> 01:05:53,580
だからここに、あなたがそれに気付くでしょう
単語のノードの両方が、下部にあります

1490
01:05:53,580 --> 01:05:55,160
そして、上に。

1491
01:05:55,160 --> 01:05:59,040
前に、私たちは学生を定義したところ、
私達はちょうど底に学生を持っていました。

1492
01:05:59,040 --> 01:06:00,470
私たちは、上の学生を持っていませんでした。

1493
01:06:00,470 --> 01:06:01,902
それはあるかもしれない理由を誰もが知っていますか？

1494
01:06:01,902 --> 01:06:02,860
違いは何ですか？

1495
01:06:02,860 --> 01:06:03,360
うん。

1496
01:06:03,360 --> 01:06:06,212
聴衆：だから、ノードを使用
ノードの定義は、あります

1497
01:06:06,212 --> 01:06:08,254
それは、再帰的なことですか？

1498
01:06:08,254 --> 01:06:08,920
SPEAKER 1：良いです。

1499
01:06:08,920 --> 01:06:13,230
ええ、私たちは私たちのノードには必要あり
他のノードへのポインタを持っています。

1500
01:06:13,230 --> 01:06:17,640
だから我々は、このタイプを使用するので
それが実際に定義されています前に、

1501
01:06:17,640 --> 01:06:20,613
私たちは、一番上にそれを配置する必要があります
ちょうどそれはそれが何であるかを知っているので。

1502
01:06:20,613 --> 01:06:22,446
聴衆：だからまだ
それは、一番下にある必要がありますか？

1503
01:06:22,446 --> 01:06:23,338
SPEAKER 1：はい。

1504
01:06:23,338 --> 01:06:24,754
聴衆：だから、常に一番下にあります。

1505
01:06:24,754 --> 01:06:26,090
SPEAKER 1：常に下部にあります。

1506
01:06:26,090 --> 01:06:29,410
したがって、すべてのあなたの意志
一番下にそれを持っています。

1507
01:06:29,410 --> 01:06:30,720
その他の質問は？

1508
01:06:30,720 --> 01:06:33,511
すべての権利なので、実際に話をすることができます
本当にすぐにリストをリンクしました。

1509
01:06:33,511 --> 01:06:36,510
だから、リンクされたリストは、我々はそれらを使用are--
代わりに、いくつかのケースでは、配列の、

1510
01:06:36,510 --> 01:06:40,030
私たちは、配列があることを知っているので、
固定長、リンクされたリストに対し、

1511
01:06:40,030 --> 01:06:42,670
私たちは成長し、私たちが望むよう縮小することができます。

1512
01:06:42,670 --> 01:06:45,790
だから、これは何の例です。
リンクリストは、次のようになります。

1513
01:06:45,790 --> 01:06:48,590
我々が見る必要がどのようなものです
リストの先頭。

1514
01:06:48,590 --> 01:06:50,330
だからここでリストが開始されます。

1515
01:06:50,330 --> 01:06:53,010
そして彼は、それぞれ、ノード
後続のノードは、あります

1516
01:06:53,010 --> 01:06:55,880
知るための責任
ここで、次のノードです。

1517
01:06:55,880 --> 01:07:00,950
したがって、この場合には、ノード1を格納します
図3は、ここで知ることに責任があります。

1518
01:07:00,950 --> 01:07:04,540
3を格納した人です
9がどこにあるかを知るための責任。

1519
01:07:04,540 --> 01:07:06,230
そして、図9は、を指すように、誰もがありません。

1520
01:07:06,230 --> 01:07:08,750
それは、リストの最後です
それはちょうどヌル言います。

1521
01:07:08,750 --> 01:07:09,250
OK？

1522
01:07:09,250 --> 01:07:10,530
>> 聴衆：これのポイントは何ですか？

1523
01:07:10,530 --> 01:07:11,480
>> SPEAKER 1：これのポイントは何ですか？

1524
01:07:11,480 --> 01:07:12,105
>> 聴衆：うん。

1525
01:07:12,105 --> 01:07:15,390
SPEAKER 1：レッツなぜなら、
我々はいくつかのデータを持っていることを言います。

1526
01:07:15,390 --> 01:07:18,480
そして、我々は正確にどのように知りません
多くのデータは、私たちは早めにしたいです。

1527
01:07:18,480 --> 01:07:22,479
だから、配列で、どこのは言わせて
最初の行で人々をカウントします。

1528
01:07:22,479 --> 01:07:24,020
チャンスはそれを変更するつもりはないです。

1529
01:07:24,020 --> 01:07:28,120
私達はちょうど私は、[OK]を、言うことができます
サイズ6の配列をしたいです。

1530
01:07:28,120 --> 01:07:30,120
しかし、私たちが何かをしたい場合
それは変更になるだろう。

1531
01:07:30,120 --> 01:07:32,900
>> たとえば、のは、私がしようとしていたとしましょう
学生を追跡するために

1532
01:07:32,900 --> 01:07:35,330
彼らは部屋に入ってくるよう
レビューセッションのため。

1533
01:07:35,330 --> 01:07:38,420
私はあなたの何見当がつかない
人々は表示しようとしています。

1534
01:07:38,420 --> 01:07:43,094
だから私は、データ構造が必要になる場合があります
私は拡大し、縮小することができます。

1535
01:07:43,094 --> 01:07:45,510
多分誰かがするので、
多分誰かが来るままにしておきます。

1536
01:07:45,510 --> 01:07:48,386
だから、いつでも、我々
ノードを追加または削除することができます。

1537
01:07:48,386 --> 01:07:49,771
クール、偉大な質問。

1538
01:07:49,771 --> 01:07:50,270
うん。

1539
01:07:50,270 --> 01:07:52,311
>> 観客：あなたが使用できる場合
GetStringのようなもの

1540
01:07:52,311 --> 01:07:55,750
それはあなたが、より多くのデータを取得させる保ちます
あなたもこれを必要としますなぜあなたは、それを必要としますか？

1541
01:07:55,750 --> 01:07:57,625
>> SPEAKER 1：なぜだろう
ときにリンクされたリストを使用します

1542
01:07:57,625 --> 01:07:59,440
あなたはのGetStringのようなものを使用することができますか？

1543
01:07:59,440 --> 01:08:01,640
それはいい質問ですね。

1544
01:08:01,640 --> 01:08:04,240
Get-- 1のことを覚えています
GetStringのdownfalls

1545
01:08:04,240 --> 01:08:06,750
我々は非常にをしなかったということです
そのメモリを解放するのは良い仕事、

1546
01:08:06,750 --> 01:08:09,320
私たちはの束を導入しました
メモリは、プログラムの中に漏れますか？

1547
01:08:09,320 --> 01:08:15,037
あなたは静的に取ることができます
サイズ配列とそれを成長を維持。

1548
01:08:15,037 --> 01:08:16,870
しかし、あなたが見つける必要があるだろう
メモリ内の新しい場所。

1549
01:08:16,870 --> 01:08:18,359
それだけで多くのオーバーヘッドになります。

1550
01:08:18,359 --> 01:08:21,050
>> リンクについての素晴らしいことの一つ
配列とは対照的にリストは、配列であります

1551
01:08:21,050 --> 01:08:22,830
すべてメモリ内の同じ場所にあります。

1552
01:08:22,830 --> 01:08:25,540
それは、連続的である必要があります
メモリのチャンク。

1553
01:08:25,540 --> 01:08:29,920
リンクリスト、2と3場合があります
全く別の場所にあります。

1554
01:08:29,920 --> 01:08:31,880
同様に2はこっちで、3はこっちです。

1555
01:08:31,880 --> 01:08:34,421
そして限り、彼らが持っています
お互いへのポインタ、それは大丈夫です。

1556
01:08:34,421 --> 01:08:35,830
私たちはそれらを見つけることができます知っています。

1557
01:08:35,830 --> 01:08:37,084
あそこ質問？

1558
01:08:37,084 --> 01:08:40,563
>> 観客：のGetString関数であります
CS50ライブラリで、右か？

1559
01:08:40,563 --> 01:08:42,060
これは、実際のプログラムには存在しません。

1560
01:08:42,060 --> 01:08:42,851
>> SPEAKER 1：正しいです。

1561
01:08:42,851 --> 01:08:44,130
右、それは他のことです。

1562
01:08:44,130 --> 01:08:47,210
GetStringは存在しません
CS50のコンテキストの外側。

1563
01:08:47,210 --> 01:08:47,710
うん。

1564
01:08:47,710 --> 01:08:54,556
>> 聴衆：だからという事実を行います
二人は遠く離れて、本当にすることができ、

1565
01:08:54,556 --> 01:08:59,859
その影響をの効率化を行います
リストの要素にアクセスしますか？

1566
01:08:59,859 --> 01:09:01,359
SPEAKER 1：それは素晴らしい質問です。

1567
01:09:01,359 --> 01:09:04,278
質問は、それが影響を与えない、でした
アクセスの効率性

1568
01:09:04,278 --> 01:09:05,819
リスト内のこれらの異なる要素。

1569
01:09:05,819 --> 01:09:06,930
実際には、はい。

1570
01:09:06,930 --> 01:09:09,569
私たちが知っているのでif--はしてみましょう
私たちがアクセスしたいと言います

1571
01:09:09,569 --> 01:09:14,520
配列の2番目の要素、我々は知っています
私達はちょうど、アレイブラケット1を行うことができます。

1572
01:09:14,520 --> 01:09:16,630
それは常にに起こっています
同じ場所です。

1573
01:09:16,630 --> 01:09:20,720
しかし、我々はその3を取得したい場合は、
私たちは3ということを取りに行く、と言うことはできません。

1574
01:09:20,720 --> 01:09:24,009
私たちは言っている、[OK]を、で開始
リストの先頭

1575
01:09:24,009 --> 01:09:26,050
そして今、我々は実際に持っています
私たちまで、ウォークスルーします

1576
01:09:26,050 --> 01:09:28,149
我々が興味を持っている番号を見つけます。

1577
01:09:28,149 --> 01:09:30,790
>> この場合のように、我々はOK、と言います
これは最初の番号です。

1578
01:09:30,790 --> 01:09:32,207
だから基本的に、それはインデックス0です。

1579
01:09:32,207 --> 01:09:33,790
今、私たちは第二の数を見つける必要があります。

1580
01:09:33,790 --> 01:09:34,740
それはインデックス1です。

1581
01:09:34,740 --> 01:09:39,180
だから、実際にはto--起こっています
アクセス、N個の時間を取るために起こっています。

1582
01:09:39,180 --> 01:09:42,027
クール、大きな古いN.うん。

1583
01:09:42,027 --> 01:09:43,903
>> 聴衆：リストのそれぞれは何ですか？

1584
01:09:43,903 --> 01:09:45,401
彼らはそれぞれの配列、または何ですか？

1585
01:09:45,401 --> 01:09:46,859
SPEAKER 1：それは素晴らしい質問です。

1586
01:09:46,859 --> 01:09:48,950
のそれぞれがどのようなものがあります
私が描いた構造？

1587
01:09:48,950 --> 01:09:51,649
彼らは、ノードです。

1588
01:09:51,649 --> 01:09:53,720
したがって、これらのほとんどの各
構造は、2つの部分があります。

1589
01:09:53,720 --> 01:09:55,264
これは、保持する整数を持っています。

1590
01:09:55,264 --> 01:09:57,180
これは実際のデータです
それは上に保持していること。

1591
01:09:57,180 --> 01:09:58,770
それが有用な部分のようなものです。

1592
01:09:58,770 --> 01:10:00,820
そして、これは何ですか
それにリンクされたリストになり、

1593
01:10:00,820 --> 01:10:03,690
それは、次のノードへのポインタを有しています。

1594
01:10:03,690 --> 01:10:05,260
素晴らしい質問です。

1595
01:10:05,260 --> 01:10:11,320
すべての権利なので、のは非常に見てみましょう
すぐに何のいくつかの例を見て

1596
01:10:11,320 --> 01:10:12,820
我々は、リンクされたリストを行う可能性があります。

1597
01:10:12,820 --> 01:10:16,920
>> だから、1つの非常に簡単な例であり、
我々が検索を実行するとします。

1598
01:10:16,920 --> 01:10:20,240
検索はどのようなことはできません
我々は、リンクされたリスト上で行いますか？

1599
01:10:20,240 --> 01:10:21,150
>> 聴衆：バイナリ。

1600
01:10:21,150 --> 01:10:21,900
>> SPEAKER 1：バイナリ。

1601
01:10:21,900 --> 01:10:23,408
なぜ我々は、バイナリ検索を使用することができないのですか？

1602
01:10:23,408 --> 01:10:25,181
>> 聴衆：[聞こえません]。

1603
01:10:25,181 --> 01:10:28,180
SPEAKER 1：右、バイナリであるため
検索、我々は実際に頼らなければなりませんでした

1604
01:10:28,180 --> 01:10:31,300
私たちはジャンプができること
任意の時点での配列に。

1605
01:10:31,300 --> 01:10:33,420
私達はちょうど行く、と言うことができます
中央の要素に。

1606
01:10:33,420 --> 01:10:35,550
我々が言ったように、ここでは
少し早く、

1607
01:10:35,550 --> 01:10:37,270
私達はちょうどにジャンプすることはできません
中央の要素。

1608
01:10:37,270 --> 01:10:38,978
いずれかを見つけるために
要素、実際に我々

1609
01:10:38,978 --> 01:10:40,780
私達の全体のリストを歩かなければなりません。

1610
01:10:40,780 --> 01:10:43,910
>> だから我々は、検索を実行したい場合、
私たちができる最善のは、ちょうどリニアサーチです。

1611
01:10:43,910 --> 01:10:45,910
私たちは、頭で開始
我々はしているとしましょう​​check--

1612
01:10:45,910 --> 01:10:47,790
私たちが先頭に開始9--​​を探して。

1613
01:10:47,790 --> 01:10:49,200
私たちは、これが9である、と言いますか？

1614
01:10:49,200 --> 01:10:49,710
いいえ。

1615
01:10:49,710 --> 01:10:50,430
この9か？

1616
01:10:50,430 --> 01:10:50,930
いいえ。

1617
01:10:50,930 --> 01:10:51,620
この9か？

1618
01:10:51,620 --> 01:10:53,730
はい、我々はそれを見つけました。

1619
01:10:53,730 --> 01:10:56,350
[OK]を、それがすべてのことです。

1620
01:10:56,350 --> 01:10:57,940
ここでは擬似コードの少しです。

1621
01:10:57,940 --> 01:11:01,420
私はあなたのためにこれを残すつもりです
人は、自分でオーバー解約します

1622
01:11:01,420 --> 01:11:04,370
我々は実行しているという理由だけで
時間の短い少し。

1623
01:11:04,370 --> 01:11:05,610
>> 挿入について話すことができます。

1624
01:11:05,610 --> 01:11:08,644
我々は、本当にクールなデモを見ました
我々が言った講義では、この、

1625
01:11:08,644 --> 01:11:11,560
[OK]を、私たちはどこでこのリンクリストを持っています
誰もがお互いを指しています、

1626
01:11:11,560 --> 01:11:13,400
そして、誰かがステージに上がっています。

1627
01:11:13,400 --> 01:11:17,050
我々はそれを挿入するにはどうすればよいです
私達のリンクリストへの人？

1628
01:11:17,050 --> 01:11:20,150
まあ、間違った方法は、行うにはどの
私たちが最初に見たものと思いますが、

1629
01:11:20,150 --> 01:11:22,740
時の人であります
自動的にフロント

1630
01:11:22,740 --> 01:11:25,270
新しい人に指摘しました。

1631
01:11:25,270 --> 01:11:29,057
そして、我々は一種の放棄しました
リストの後半、右？

1632
01:11:29,057 --> 01:11:31,390
私たちはどこかわからないので
それはもはやメモリ内にあります。

1633
01:11:31,390 --> 01:11:34,750
だから、について非常に注意します
私たちは物事を挿入する順序。

1634
01:11:34,750 --> 01:11:37,860
>> だからここに、我々はしたいとしましょう
私たちのリストの先頭に1を置きます。

1635
01:11:37,860 --> 01:11:42,190
まず、我々は、1ポイントを持っています
二element--または要素

1636
01:11:42,190 --> 01:11:44,170
それは1が含まれています。

1637
01:11:44,170 --> 01:11:47,210
だから、私達はちょうど私たちがいないなら、それを行います
後半を失うつもり。

1638
01:11:47,210 --> 01:11:51,020
そして今、私たちは、1頭のポイントを持つことができます。

1639
01:11:51,020 --> 01:11:52,930
だから、再び、これは単なるです
超ハイレベルのような。

1640
01:11:52,930 --> 01:11:55,290
これは、我々はノードを挿入する方法です。

1641
01:11:55,290 --> 01:11:57,337
私たちはたくさんあり​​ます
擬似コードhere--申し訳ありませんが、

1642
01:11:57,337 --> 01:11:59,170
私は、なぜ私は知りません
擬似コードを呼び出します。

1643
01:11:59,170 --> 01:12:00,350
これは、実際のコードです。

1644
01:12:00,350 --> 01:12:02,570
あなたは後でそれをチェックアウト行くことができます。

1645
01:12:02,570 --> 01:12:04,870
>> すべての権利、非常にしてみましょう
それ以上の質問をquickly--

1646
01:12:04,870 --> 01:12:07,120
私の前にリンクされたリストに
カップルの他のデータの上に移動

1647
01:12:07,120 --> 01:12:08,450
私たちの最後の10分間での構造。

1648
01:12:08,450 --> 01:12:10,340
>> 観客：我々は今する必要がありますか
テストでそれを書くためにどのように？

1649
01:12:10,340 --> 01:12:11,040
>> SPEAKER 1：私たちはどのようにto--知っている必要がありますか

1650
01:12:11,040 --> 01:12:12,030
>> 対象：テストでそれを書きます。

1651
01:12:12,030 --> 01:12:14,071
>> SPEAKER 1：我々は必要なのですto--
あなたが準備する必要があります

1652
01:12:14,071 --> 01:12:18,870
インサートを書くために、削除し、
テストにリンクされたリストを検索します。

1653
01:12:18,870 --> 01:12:21,480
それは我々のものです
あなたがする期待できます。

1654
01:12:21,480 --> 01:12:22,750
ちょうどその上に行きます。

1655
01:12:22,750 --> 01:12:26,460
あなたは上の任意の質問がある場合
コー​​ドは、あなたのTFメールを撃ちます、

1656
01:12:26,460 --> 01:12:27,750
営業時間に来ます。

1657
01:12:27,750 --> 01:12:30,041
多くの時間はまだあります
勉強する、心配することはありません。

1658
01:12:30,041 --> 01:12:32,290
すべての権利、他の
リンクされたリストについての質問？

1659
01:12:32,290 --> 01:12:32,986
はい。

1660
01:12:32,986 --> 01:12:37,360
>> 観客：あなたが使用していないのであれば
右側のいずれかに行くためのポインタ

1661
01:12:37,360 --> 01:12:41,308
あなたは、ポインタを使用する前に
左の上の1つ、それはです

1662
01:12:41,308 --> 01:12:43,211
削除の同等
すべて、右？

1663
01:12:43,211 --> 01:12:43,877
SPEAKER 1：うん。

1664
01:12:43,877 --> 01:12:44,820
聴衆：[聞こえません]。

1665
01:12:44,820 --> 01:12:47,570
SPEAKER 1：右、私たちがすることができないので
それを得る、それは実際にはさらに悪いです。

1666
01:12:47,570 --> 01:12:50,690
だけでなく、私たちが知らないので、
それがどこにあるか、私たちはもはやそれを使用することはできません、

1667
01:12:50,690 --> 01:12:53,580
しかし、私たちではありませんwe've--
もうそのメモリを解放。

1668
01:12:53,580 --> 01:12:58,570
だから、ただ周りではなく、ぶら下がっています
我々はそれを見つけることができないために有用です。

1669
01:12:58,570 --> 01:12:59,580
うん、クールな質問。

1670
01:12:59,580 --> 01:13:01,280
>> すべての権利、のスタックについて話しましょう​​。

1671
01:13:01,280 --> 01:13:03,230
我々は非常に迅速にスタックを見ました。

1672
01:13:03,230 --> 01:13:06,280
彼らは最後に最初のものです
アウトデータ構造。

1673
01:13:06,280 --> 01:13:10,664
だから我々はアネンバーグでスタックを考えます
私たちは上のものをスタックトレイ。

1674
01:13:10,664 --> 01:13:12,580
そして、あなたはするつもりなら
あなたがしている、トレイを取得してきます

1675
01:13:12,580 --> 01:13:15,870
常に上の1つを取るつもり
最もrecently--でトップ、

1676
01:13:15,870 --> 01:13:18,840
我々ほとんどの事これは
最近スタックの一番上に置きます。

1677
01:13:18,840 --> 01:13:22,680
だから、一種のこの種のを考えることができます
あなたはスタックを考えているときに、視覚的。

1678
01:13:22,680 --> 01:13:26,010
そして、私たちは何かをポップしました
スタックの先頭オフ。

1679
01:13:26,010 --> 01:13:29,850
>> 我々はああare--、と言葉ならば、我々
我々は、これらのデータについて話しているときに使用

1680
01:13:29,850 --> 01:13:32,680
構造は、通常、私たちの場合
スタック上に何かを置きます、

1681
01:13:32,680 --> 01:13:34,550
私たちはそれをスタックにプッシュしていると言います。

1682
01:13:34,550 --> 01:13:38,450
そして、我々はスタックから何かを取る場合、
我々はスタックからポップしていると言います。

1683
01:13:38,450 --> 01:13:41,470
あなたが実装しようとしている場合
間違いなく私stack--

1684
01:13:41,470 --> 01:13:44,840
あなたがしているout--試してお勧めします
を追跡するためにするつもり、

1685
01:13:44,840 --> 01:13:46,669
例えば、あなたが、配列を使用しているとしましょう​​。

1686
01:13:46,669 --> 01:13:48,960
我々が話をした私は、講義で知っています
配列の両方を使用する方法について

1687
01:13:48,960 --> 01:13:51,120
またはスタックを実装するためにリストをリンクしました。

1688
01:13:51,120 --> 01:13:53,490
あなたが使用している場合
配列は、あなたがkeep--する必要があります

1689
01:13:53,490 --> 01:13:56,750
言い訳は、私たちは記録しておく必要がありme--
サイズと容量の。

1690
01:13:56,750 --> 01:14:00,820
だから、最大数
私たちのスタックが保持できること。

1691
01:14:00,820 --> 01:14:03,240
スタックに関する質問？

1692
01:14:03,240 --> 01:14:05,657
>> 観客：違いは何ですか
サイズと容量と？

1693
01:14:05,657 --> 01:14:08,573
SPEAKER 1：との違い
サイズと容量、素晴らしい質問です。

1694
01:14:08,573 --> 01:14:10,330
それでは、私たちがしているとしましょう
配列を使用して、我々

1695
01:14:10,330 --> 01:14:13,340
10整数の十分なスペースを割り当てます。

1696
01:14:13,340 --> 01:14:15,050
そして、我々はそれを埋めるために開始します。

1697
01:14:15,050 --> 01:14:17,330
そして、我々は、で物事をプッシュ
私たちは物事をオフにポップ。

1698
01:14:17,330 --> 01:14:21,060
我々は最大のトラックを維持したいです
我々が保持できる数は、それが容量です。

1699
01:14:21,060 --> 01:14:24,790
そして、我々はを追跡したいです
我々が持っている現在の数は、そのサイズです。

1700
01:14:24,790 --> 01:14:26,530
良い質問。

1701
01:14:26,530 --> 01:14:28,720
スタック上の他には？

1702
01:14:28,720 --> 01:14:31,260
すべての権利、話をしましょう
驚きについて、キューに入れます。

1703
01:14:31,260 --> 01:14:37,034
>> 最後に最初のものであるスタックとは異なり、
うち、これらは先入れ先出し、です。

1704
01:14:37,034 --> 01:14:38,450
だから、これはラインのlike--と思います。

1705
01:14:38,450 --> 01:14:41,530
アップルで並ぶと考えて
どのような製品を得るために保管してください。

1706
01:14:41,530 --> 01:14:44,540
また、行の最初の人はすべき
助けた初の人物です。

1707
01:14:44,540 --> 01:14:48,270
プッシュですので、最初のものです
このポップの最初の事。

1708
01:14:48,270 --> 01:14:49,460
クール？

1709
01:14:49,460 --> 01:14:52,890
非常にsimilarly--ああ、言葉はその
我々は、プッシュとpop--の代わりに使用します

1710
01:14:52,890 --> 01:14:55,060
これは私がちょうど使用し、
私は、私たちが言うIS sorry--よ

1711
01:14:55,060 --> 01:14:58,170
我々はに何かを入れている場合
キューは、我々はそれをエンキュー言います。

1712
01:14:58,170 --> 01:15:00,795
私たちは外の何かを取っている場合
キューは、我々はデキュー言います。

1713
01:15:00,795 --> 01:15:01,950
これ。

1714
01:15:01,950 --> 01:15:05,454
私はそれらを発音することができます
間違った、しかし、あなたのアイデアを得ます。

1715
01:15:05,454 --> 01:15:08,370
そして再び、ちょうどスタックのように、
私たちは、配列としてこれを実装している場合、

1716
01:15:08,370 --> 01:15:12,350
私たちはを追跡する必要があります
サイズ、容量、およびヘッド。

1717
01:15:12,350 --> 01:15:13,570
私は頭とはどういう意味ですか？

1718
01:15:13,570 --> 01:15:15,278
なぜ我々は維持する必要があります
ヘッドのトラック？

1719
01:15:15,278 --> 01:15:18,549

1720
01:15:18,549 --> 01:15:21,685
>> 観客：それはあるので
あなたのリストの先頭です。

1721
01:15:21,685 --> 01:15:24,810
SPEAKER 1：うん、基本的にヘッドがあります
ここで私たちのキューの始まりです。

1722
01:15:24,810 --> 01:15:29,460
私たちが知っているので、スタックとは異なり、which--
私はこれに直面しようとするつもりですway--

1723
01:15:29,460 --> 01:15:33,570
我々はそれが常にに起こっていることを知っています
このように縮小し、このように成長します。

1724
01:15:33,570 --> 01:15:37,840
キュー、人々は端に来ます
そして、、最初から離れます

1725
01:15:37,840 --> 01:15:40,620
私たちはトラックを維持する必要があります
スタートがどこにあるの。

1726
01:15:40,620 --> 01:15:43,540
それは私たちがする必要が何を意味するかです
ヘッドがどこにあるかを追跡します。

1727
01:15:43,540 --> 01:15:45,190
クール？

1728
01:15:45,190 --> 01:15:46,440
大丈夫。

1729
01:15:46,440 --> 01:15:49,250
8分、カップル
より多くのトピックは、我々はそれを行うことができます。

1730
01:15:49,250 --> 01:15:51,240
>> すべての権利、ハッシュテーブル。

1731
01:15:51,240 --> 01:15:53,095
我々は非常に簡潔に話しました
ハッシュテーブルについて。

1732
01:15:53,095 --> 01:15:55,720
クイズでは、あなただけに必要
高いレベルでそれらを理解しています。

1733
01:15:55,720 --> 01:15:58,330
基本的な考え方は、このデータを持っています。

1734
01:15:58,330 --> 01:16:02,570
そして、我々はだ時間にアクセスしたいです
リンクのようなものよりも速く

1735
01:16:02,570 --> 01:16:03,070
リスト。

1736
01:16:03,070 --> 01:16:05,290
我々が言ったので、私たちはいた場合
リンクリストを検索、

1737
01:16:05,290 --> 01:16:06,248
それは、N個の時間がかかることがあります。

1738
01:16:06,248 --> 01:16:08,810
でも取ることができますアクセス
リンクされたリスト内のN個の時間。

1739
01:16:08,810 --> 01:16:12,930
ハッシュテーブルは、私たちすることができます私たちに道を譲ります
より迅速に物事をアクセスし、より

1740
01:16:12,930 --> 01:16:16,970
すぐにせずに、物事を検索
配列の制約を持ちます

1741
01:16:16,970 --> 01:16:19,030
ここで我々はサイズが固定されています。

1742
01:16:19,030 --> 01:16:23,950
>> だから我々はどこにデータ構造を考え、
我々は、データ構造にそれを置く場所

1743
01:16:23,950 --> 01:16:26,620
これに依存しています
魔法のハッシュ関数。

1744
01:16:26,620 --> 01:16:30,630
この場合には、魔法のハッシュそう
この関数は、単に単語を取っています、

1745
01:16:30,630 --> 01:16:34,027
最初の文字が何であるかをチェックし、
その後、ちょうどアルファベット順にソートします。

1746
01:16:34,027 --> 01:16:36,110
だから我々は、本質的にそれらを置きます
別のバケットに。

1747
01:16:36,110 --> 01:16:39,510
我々はバナナを見たとき、私たちは言います、
[OK]を、のがBバケツに入れましょう。

1748
01:16:39,510 --> 01:16:41,820
我々は、Appleが表示されたら、してみましょう
Aのバケツに入れて。

1749
01:16:41,820 --> 01:16:44,744
我々はアプリコットを見た場合、してみましょう
Aのバケツに入れました。

1750
01:16:44,744 --> 01:16:45,600
OK？

1751
01:16:45,600 --> 01:16:51,090
>> だから私は、私を探していたと仮定しfor--
知らない、他​​の果物は何ですか？

1752
01:16:51,090 --> 01:16:52,920
私はオレンジを探していたとします。

1753
01:16:52,920 --> 01:16:55,340
私はどこになりますか？

1754
01:16:55,340 --> 01:16:56,420
Oバケットで。

1755
01:16:56,420 --> 01:17:01,450
ええ、唯一の場所があります
そのオレンジは、OKでしょうか？

1756
01:17:01,450 --> 01:17:05,370
だから私は何が起こるかを先に述べました
if--よく私は、以前に述べました

1757
01:17:05,370 --> 01:17:10,030
我々はアプリコットin--を置くとしましょう​​けど
本当に事実に対処すること、ああ、いや、

1758
01:17:10,030 --> 01:17:14,990
私はベリーを入れていた場合、それはです
バナナと競合する予定。

1759
01:17:14,990 --> 01:17:20,160
どこにあるのならば、我々はそれを置きます
すでに私たちのテーブルで何か？

1760
01:17:20,160 --> 01:17:22,760
さて、私たちはカップルのオプションがあります。

1761
01:17:22,760 --> 01:17:26,160
>> オプション番号1は線形であります
基本的に意味し、プロービング、

1762
01:17:26,160 --> 01:17:28,690
それでは、私が試してみたいとしましょう
ああ、いや、ベリーを入れて、なるほど、

1763
01:17:28,690 --> 01:17:31,170
すでにそこにバナナ、
私はOK、と言うてみましょう

1764
01:17:31,170 --> 01:17:33,810
私は、次の利用可能なスポットを探します。

1765
01:17:33,810 --> 01:17:36,744
だから私は、ああ、私は言う、歩きます
Dバケットには何もありません。

1766
01:17:36,744 --> 01:17:39,410
私は本当にすべての果物を考えることはできません
それは、文字Dで始まります

1767
01:17:39,410 --> 01:17:41,620
私はちょうどそこにベリーを入れるつもりです。

1768
01:17:41,620 --> 01:17:42,650
ドリアン。

1769
01:17:42,650 --> 01:17:44,590
[OK]を、そこだからそう
そこには何もありませんまだ、

1770
01:17:44,590 --> 01:17:47,020
私もちょうどその場所を使用する場合があります。

1771
01:17:47,020 --> 01:17:48,805
それの欠点は何ですか？

1772
01:17:48,805 --> 01:17:49,300
>> 観客：それは順不同でです。

1773
01:17:49,300 --> 01:17:50,008
>> SPEAKER 1：申し訳ありませんか？

1774
01:17:50,008 --> 01:17:51,280
観客：それは順不同でです。

1775
01:17:51,280 --> 01:17:53,113
>> SPEAKER 1：それはout--です
右、我々は終わるかもしれません

1776
01:17:53,113 --> 01:17:56,380
in--されていないものと
方法で、バケットに格納されています

1777
01:17:56,380 --> 01:17:57,790
我々は彼らがあることを期待しています。

1778
01:17:57,790 --> 01:18:00,670
だから我々は、検索された場合
ベリーのために、私たちが言った前に、

1779
01:18:00,670 --> 01:18:02,000
ああ、私たちは1つのバケットで見ることができます。

1780
01:18:02,000 --> 01:18:03,650
それだけで1つのバケットである可能性があります。

1781
01:18:03,650 --> 01:18:07,380
しかし、今、本当に、それは可能性があり
すべてのバケットで、右か？

1782
01:18:07,380 --> 01:18:10,400
>> [OK]を、ここでは別のオプションです、
別々chaining--

1783
01:18:10,400 --> 01:18:16,630
これは、我々が行っている考えであります
Pに少し後で使用するために5を設定します。

1784
01:18:16,630 --> 01:18:19,340
むしろちょうど持っているよりも
各バケット内の1つのスペース、

1785
01:18:19,340 --> 01:18:23,610
私たちはそれぞれのバケツを持っていない理由
リンクリストへのポインタで？

1786
01:18:23,610 --> 01:18:28,570
我々はOK、バケツがあると言う場合には
A.で始まるすべてのため

1787
01:18:28,570 --> 01:18:31,990
そして、ちょうどリンクがあるように起こっています
A.で始まる果物の一覧

1788
01:18:31,990 --> 01:18:36,240
私たちは新しい果物を取得する場合それでは、言わせて
我々はリンゴを持って、我々はアボカドget--、

1789
01:18:36,240 --> 01:18:39,530
我々はアプリコットを取得しましょう​​、
どのように我々は、リストに入れますか？

1790
01:18:39,530 --> 01:18:43,330
まあ、我々は0をバケットに行くだろう、と私たちは思います
ちょうど私たちの気に入っリストに挿入し、

1791
01:18:43,330 --> 01:18:45,320
そのような単純な。

1792
01:18:45,320 --> 01:18:47,160
>> 今、私はバケツを言い続けます。

1793
01:18:47,160 --> 01:18:49,470
私たちはこれを実装することができ
いくつかの方法です。

1794
01:18:49,470 --> 01:18:52,040
このこと一つの典型的な方法
画像の種類は、示唆しています

1795
01:18:52,040 --> 01:18:55,580
多分の配列をしています
リンクされたリストへのポインタ。

1796
01:18:55,580 --> 01:18:58,174
それは私達ができる一つの方法です
ハッシュテーブルを実装します。

1797
01:18:58,174 --> 01:19:01,090
聴衆：あなたは別のものを必要とするだろう
リストバナナとベリーが出ているので、

1798
01:19:01,090 --> 01:19:01,591
オーダーの？

1799
01:19:01,591 --> 01:19:03,298
SPEAKER 1：あなたのだろう
あなたはだろう、ああneed--

1800
01:19:03,298 --> 01:19:06,310
バナナので別のリストを必要とします
そして、ベリーの順序がありますか？

1801
01:19:06,310 --> 01:19:09,880
この場合、我々のハッシュ関数
これはどこのものを置くことを教えてくれる

1802
01:19:09,880 --> 01:19:11,647
二番目の文字を気にしません。

1803
01:19:11,647 --> 01:19:14,730
これは、アルファベット順を気にしません、
それは最初の文字だけを気遣います。

1804
01:19:14,730 --> 01:19:15,672
質問？

1805
01:19:15,672 --> 01:19:18,947
>> 聴衆：それの定義は何ですか
機能、そして何が見えますか？

1806
01:19:18,947 --> 01:19:19,780
SPEAKER 1：ああ、良いです。

1807
01:19:19,780 --> 01:19:22,450
[OK]を、私たちはする必要はありません
このクイズのためにあまり心配。

1808
01:19:22,450 --> 01:19:23,700
だから私はスライドに入れませんでした。

1809
01:19:23,700 --> 01:19:26,320
我々は導入するつもりです
Pのためのそれには、5を設定します。

1810
01:19:26,320 --> 01:19:31,520
しかし、基本的に、それは言う、与えられました
私はそれを置く必要があり、新しい要素、？

1811
01:19:31,520 --> 01:19:35,450
あるいは、のは私が探しているとしましょう
要素、それはあるかもしれませんか？

1812
01:19:35,450 --> 01:19:37,860
うん、偉大な質問。

1813
01:19:37,860 --> 01:19:40,870
>> [OK]を、非常に迅速に、木と試みます。

1814
01:19:40,870 --> 01:19:44,779
だから、木はただの一種であります
編成されたデータ構造。

1815
01:19:44,779 --> 01:19:47,820
そして、私たちはたくさんの写真を参照してくださいするつもりです
それが、これはスーパー明らかになります。

1816
01:19:47,820 --> 01:19:51,180
そして私達がクラスで見たトライ、
木の非常に特別な種類です

1817
01:19:51,180 --> 01:19:53,440
それは基本的に同じように動作し
マルチレベルのハッシュテーブル。

1818
01:19:53,440 --> 01:19:54,390
それは超クールです。

1819
01:19:54,390 --> 01:19:56,030
私達はちょうど秒でそれを見るつもりです。

1820
01:19:56,030 --> 01:19:57,821
すべての権利は​​、そのようにしてみましょう
最初の木について話しています。

1821
01:19:57,821 --> 01:20:01,040
だから、これは実際の典型的な例であります
我々はいくつかの階層を持っている木、。

1822
01:20:01,040 --> 01:20:03,220
あなたは1つがであることを確認します
非常に上、右？

1823
01:20:03,220 --> 01:20:06,190
そこだからと私はトップを言うことができます
私たちのため明らかに発注

1824
01:20:06,190 --> 01:20:08,260
これらの矢印がダウンして行く必要があります。

1825
01:20:08,260 --> 01:20:11,740
だから、一番上にあるもの、
私は、ルートノードことを呼び出します。

1826
01:20:11,740 --> 01:20:13,080
だから、1はルートノードです。

1827
01:20:13,080 --> 01:20:17,330
そして、一番下にあるもの、
これは、それらをオフに来て何もありません、

1828
01:20:17,330 --> 01:20:18,783
私はこれらがリーフノードであると言います。

1829
01:20:18,783 --> 01:20:22,730
だから8,9 5、6、7、[OK]をクリックします。

1830
01:20:22,730 --> 01:20:27,740
そして、通常の用語の我々
1が3の親である、と言うことができます。

1831
01:20:27,740 --> 01:20:30,740
だから、来ることです
それ以上のレベル、およびそれへのポイント。

1832
01:20:30,740 --> 01:20:32,710
そして、図3は、1の子です。

1833
01:20:32,710 --> 01:20:34,505
それは、その1点にことです。

1834
01:20:34,505 --> 01:20:35,005
質問？

1835
01:20:35,005 --> 01:20:36,414
>> 聴衆：あなたが戻って行くことができます
前のスライド、してください？

1836
01:20:36,414 --> 01:20:37,388
>> SPEAKER 1：私は戻って行くことができます
前のスライドに？

1837
01:20:37,388 --> 01:20:37,888
確かに。

1838
01:20:37,888 --> 01:20:40,640

1839
01:20:40,640 --> 01:20:41,390
このに関する質問？

1840
01:20:41,390 --> 01:20:42,764
それとも、ただそれを見てみたかったですか？

1841
01:20:42,764 --> 01:20:44,650
聴衆：私はちょうどそれを取得できませんでした。

1842
01:20:44,650 --> 01:20:47,100
>> SPEAKER 1：OK、クール、うん。

1843
01:20:47,100 --> 01:20:49,846
これらは、すべてのように、オンラインではないでしょう
すべての単語を心配。

1844
01:20:49,846 --> 01:20:51,720
との利益のために
時間は、私は行くつもりです。

1845
01:20:51,720 --> 01:20:53,270
それはいいですか？

1846
01:20:53,270 --> 01:20:53,790
驚くばかり。

1847
01:20:53,790 --> 01:20:55,720
うんいいね。

1848
01:20:55,720 --> 01:20:57,790
それでは、について話しましょう
非常に具体的なkind--

1849
01:20:57,790 --> 01:20:59,710
私たちはこれらの一般的なを持っています
木の構造、

1850
01:20:59,710 --> 01:21:02,876
これは私たちを可能にするだけのものです
階層的にランクどのような種類のものに。

1851
01:21:02,876 --> 01:21:06,000

1852
01:21:06,000 --> 01:21:11,110
>> バイナリツリーはどこにすべてのものです
ノードは最大で二人の子供を持っています。

1853
01:21:11,110 --> 01:21:11,690
OK？

1854
01:21:11,690 --> 01:21:14,560
そして、私はOK、その結果はそう言いました
この記述に合うように。

1855
01:21:14,560 --> 01:21:16,830
私は、ノードではなく、二分探索木と述べました。

1856
01:21:16,830 --> 01:21:19,720
二分探索木は何ですか？

1857
01:21:19,720 --> 01:21:20,440
これは、並べ替えています。

1858
01:21:20,440 --> 01:21:22,890
だから、あなたが知っている中で、その
二分探索木、

1859
01:21:22,890 --> 01:21:26,580
tree--すべてにすべてのもの
左ノードに小さい場合、

1860
01:21:26,580 --> 01:21:28,830
そしてすべてに
ノードは、右大きいです。

1861
01:21:28,830 --> 01:21:30,620
だから、これは二分探索木ではありません。

1862
01:21:30,620 --> 01:21:32,770
これは単なるバイナリツリーです。

1863
01:21:32,770 --> 01:21:35,910
だから我々はの大きなカテゴリを持っています
木、わずかに小さいカテゴリ

1864
01:21:35,910 --> 01:21:40,106
二分木の、検索によって
A--二分探索木。

1865
01:21:40,106 --> 01:21:41,540
クール？

1866
01:21:41,540 --> 01:21:44,410
大丈夫。

1867
01:21:44,410 --> 01:21:47,380
>> のそして今、最も楽しいです
すべて、私たちは私たちの試行を持っています。

1868
01:21:47,380 --> 01:21:49,500
君たちは講義にこの写真を見ましたか？

1869
01:21:49,500 --> 01:21:51,790
ええ、それは超おなじみのはずです。

1870
01:21:51,790 --> 01:21:54,252
のは、見てみましょうどのように我々は、かもしれません
実際にこれを実装しています。

1871
01:21:54,252 --> 01:21:56,210
あるいは実際に、見てみましょう、
ことも出てくるのでしょうか？

1872
01:21:56,210 --> 01:21:56,731
いいえ。

1873
01:21:56,731 --> 01:21:59,480
すべての権利、私たちもする必要はありません
その低レベルのものを心配します。

1874
01:21:59,480 --> 01:22:02,320
私たちは多くの時間を持つことになります
その後にアドレスPが5を設定します。

1875
01:22:02,320 --> 01:22:05,780
しかし、今のところ、ちょうど非常に高いレベル、我々
これは、それがどのように見えるかであることを知っています。

1876
01:22:05,780 --> 01:22:08,530
私たちは、の一種としてそれを説明しました
マルチレベルのハッシュテーブル

1877
01:22:08,530 --> 01:22:12,264
where--このストアを何？

1878
01:22:12,264 --> 01:22:14,430
これは、名が格納さ
私たちが実際にすることができます科学者

1879
01:22:14,430 --> 01:22:20,690
だけの種類に従って、探し
異なるハッシュテーブルダウン、大丈夫？

1880
01:22:20,690 --> 01:22:24,730
>> そしてこの目的は、理論的には、あります
彼らは一定の時間ルックアップを提供しています。

1881
01:22:24,730 --> 01:22:29,630
私はそれを確認したいのであれば、
例えば、someone--だ人

1882
01:22:29,630 --> 01:22:33,410
マンデルは、この中であること
トライ、私は非常に迅速にできました

1883
01:22:33,410 --> 01:22:36,260
linear--に私はで、ごめんなさい
一定時間、把握

1884
01:22:36,260 --> 01:22:39,010
かどうか、それはトライでです。

1885
01:22:39,010 --> 01:22:41,500
しかしconが、これはどのように大きなを見ています。

1886
01:22:41,500 --> 01:22:44,120
私たちも、それを保存していません
多くのデータ、それは巨大です。

1887
01:22:44,120 --> 01:22:47,950
だから、一つの大きな詐欺はそれということです
大量のメモリを使用しています。

1888
01:22:47,950 --> 01:22:48,746
はい。

1889
01:22:48,746 --> 01:22:50,610
>> 聴衆：なぜそれは提供しません
一定時間、正確に？

1890
01:22:50,610 --> 01:22:51,376
>> SPEAKER 1：1つのより多くの時間？

1891
01:22:51,376 --> 01:22:53,360
>> 観客：直感は何ですか
それは一定の時間を提供し、なぜか？

1892
01:22:53,360 --> 01:22:54,610
>> SPEAKER 1：優秀な質問。

1893
01:22:54,610 --> 01:22:56,030
なぜそれが一定の時間を提供していますか？

1894
01:22:56,030 --> 01:22:59,280
だから我々は、してみましょうされて何ができますか
我々はマンデル探していると言います。

1895
01:22:59,280 --> 01:23:02,830
我々は開始したいことを知っています
M.の最初のレベルで

1896
01:23:02,830 --> 01:23:06,890
私たちは、Eそうにそれをフォローしたい知っています
それは正しい一歩、2つの手順を取るのか？

1897
01:23:06,890 --> 01:23:10,710
我々はDにそれに従うNにそれに従います
我々はLにそれに従うEにそれに従ってください

1898
01:23:10,710 --> 01:23:15,100
そして次の事、私たちはチェック
このデルタsays--はい、それはだと言います

1899
01:23:15,100 --> 01:23:15,990
私たちのテーブルです。

1900
01:23:15,990 --> 01:23:16,880
それは言葉です。

1901
01:23:16,880 --> 01:23:19,900
それが私たちのトライで有効なエントリです。

1902
01:23:19,900 --> 01:23:22,450
だから、[OK]を、言っています、
それは7つのステップを取りました。

1903
01:23:22,450 --> 01:23:27,200
しかし、我々はより多くの無数のように追加した場合
このデータ構造への科学者、

1904
01:23:27,200 --> 01:23:29,470
我々はチェックする必要はありません
膨大な数より多くの事。

1905
01:23:29,470 --> 01:23:33,580
私たちは今まで取る必要があるとしています
7つのステップ、人のの長さ

1906
01:23:33,580 --> 01:23:35,260
名。

1907
01:23:35,260 --> 01:23:39,350
>> だから、私たちは考えたいです
ランタイムのと仮定し、として

1908
01:23:39,350 --> 01:23:42,340
我々は、我々のサイズを大きくします
データ構造、どのくらい長く

1909
01:23:42,340 --> 01:23:44,580
それは取るつもりですか？

1910
01:23:44,580 --> 01:23:47,372
ここでは、束を追加する場合
より多くの科学者たちは、それは問題ではありません。

1911
01:23:47,372 --> 01:23:49,413
それはまだ取るつもりです
同じ時間。

1912
01:23:49,413 --> 01:23:50,350
これは、一定の時間です。

1913
01:23:50,350 --> 01:23:50,850
はい。

1914
01:23:50,850 --> 01:23:53,557
>> 聴衆：どのようにしていない知っています
他の番号の上を走査するには？

1915
01:23:53,557 --> 01:23:54,932
SPEAKER 1：どのように私は知っていますかto--

1916
01:23:54,932 --> 01:23:58,236
観客：あなたはあなたが行く知っていますかのように
ストレートMからEまでとしないように、Mか？

1917
01:23:58,236 --> 01:23:59,069
SPEAKER 1：ああ、してください。

1918
01:23:59,069 --> 01:24:01,620
私は私が知っていたので、
マンデル単語を探して、

1919
01:24:01,620 --> 01:24:04,195
私はちょうどそれは、M-Eであることを知っています。
ええthat--だから、先に行きます。

1920
01:24:04,195 --> 01:24:06,528
観客：あなたが持っていません
他の文字を見て

1921
01:24:06,528 --> 01:24:07,870
[聞こえない]の残りの部分？

1922
01:24:07,870 --> 01:24:10,020
>> SPEAKER 1：ああ、私は持っていません
偉大the-- OK、を見て。

1923
01:24:10,020 --> 01:24:10,790
これは素晴らしい質問です。

1924
01:24:10,790 --> 01:24:12,170
それは我々がそれを実装する方法によって異なります。

1925
01:24:12,170 --> 01:24:15,350
私たちは同じようにそれを実装する場合
一連の配列のような

1926
01:24:15,350 --> 01:24:18,100
ここで我々は、Eがあることを知っています
常に位置0、

1927
01:24:18,100 --> 01:24:21,270
私は知らない、何でも
数指数はです。

1928
01:24:21,270 --> 01:24:24,901
ええ、私たちはただ一定行うことができます
時間、、、やるんんありません。

1929
01:24:24,901 --> 01:24:25,400
クール。

1930
01:24:25,400 --> 01:24:27,556
あそこ質問？

1931
01:24:27,556 --> 01:24:30,927
>> 観客は：一定の時間です
リアルタイムと同じもの？

1932
01:24:30,927 --> 01:24:33,260
SPEAKER 1：時定数
同じことは、リアルタイムのですか？

1933
01:24:33,260 --> 01:24:34,799
私は本当の時間は本当にわかりません。

1934
01:24:34,799 --> 01:24:36,965
聴衆：ような時間
文字通り二進みます

1935
01:24:36,965 --> 01:24:40,150
秒単位であることとは対照的に、
独立変数。

1936
01:24:40,150 --> 01:24:42,960
>> SPEAKER 1：ああ、ええ、あなたは
そのように考えることができます。

1937
01:24:42,960 --> 01:24:46,240
換言すれば、依存ではありません
データ構造のサイズ。

1938
01:24:46,240 --> 01:24:48,310
それはそれを考えるための方法です。

1939
01:24:48,310 --> 01:24:50,510
その他の質問は？

1940
01:24:50,510 --> 01:24:53,120
たぶんでは初めてで
歴史は、私たちは時間通りに終了しました。

1941
01:24:53,120 --> 01:24:57,080
ご質問があれば、感じます
セクションに移動し、私たちを尋ねに来て自由に、

1942
01:24:57,080 --> 01:25:00,190
あなたのTF、オフィスに話します
営業時間は8時00分と午前8時30分です

1943
01:25:00,190 --> 01:25:03,985
そう月曜日と火曜日は11:00、へ
それは少し違う時間です、

1944
01:25:03,985 --> 01:25:05,110
あなたはそれを注意していることを確認します。

1945
01:25:05,110 --> 01:25:06,048
うん。

1946
01:25:06,048 --> 01:25:08,673
>> 観客は：私たちが知っている必要がありますか
コマンドライン引数のようなもの、

1947
01:25:08,673 --> 01:25:10,360
ダッシュLS、どのようなダッシュ？

1948
01:25:10,360 --> 01:25:11,840
>> SPEAKER 1：コマンドライン
引数、およびLinuxのコマンド、

1949
01:25:11,840 --> 01:25:13,010
はい、あなたはそれらを知っている必要があります。

1950
01:25:13,010 --> 01:25:18,234
それはレベルの一種のようなものですVery--
私たちはセクション0に覆われたもの、

1951
01:25:18,234 --> 01:25:19,400
限りLinuxなどのコマンドが行きます。

1952
01:25:19,400 --> 01:25:20,942
>> 聴衆：アネンバーグで時間はありますか？

1953
01:25:20,942 --> 01:25:23,525
SPEAKER 1：営業時間は、私はないんだけど
彼らがどこにあるかを完全に確認してください。

1954
01:25:23,525 --> 01:25:25,980
しかし、あなたは確認することができます
ウェブサイトは、それはあなたを教えてくれます。

1955
01:25:25,980 --> 01:25:27,499