1
00:00:07,420 --> 00:00:08,160
[Powered by Google Translate] デイヴィッドJ.マラン：全ての権利。

2
00:00:08,160 --> 00:00:11,170
これはCS50であり、これは2週の終わりです。

3
00:00:11,170 --> 00:00:14,650
あなたはこの頃明日飢えていることが予想される場合は、我々が行っていることを知っている

4
00:00:14,650 --> 00:00:18,920
小グループで明日、木曜日、13:15として招集する。

5
00:00:18,920 --> 00:00:21,460
あなたはRSVPしたい場合は、このURLはここにあります。

6
00:00:21,460 --> 00:00:25,270
スペースが限られているので、フォームが時間あなたでいっぱいになった場合はご容赦下さい

7
00:00:25,270 --> 00:00:26,680
これを記入してください。

8
00:00:26,680 --> 00:00:29,400
興味があるかもしれませんが、別のURLはこれです。

9
00:00:29,400 --> 00:00:32,409
>> だから、今月の時間ほどで、コースが利用できるようにしようとしている

10
00:00:32,409 --> 00:00:36,090
すべてのより広くEDXを経由して、インターネット上で人々は次のようになりますそれを介して

11
00:00:36,090 --> 00:00:39,580
実際には、かなり積極的にコースに参加し、一緒に従うことができる。

12
00:00:39,580 --> 00:00:43,070
彼らはCS50とCS50アプライアンス論議とのほとんどを使うことになるでしょう

13
00:00:43,070 --> 00:00:45,840
我々はすでに、この学期を使用してきたさまざまなソフトウェアツール。

14
00:00:45,840 --> 00:00:49,030
そして、我々は今年の実験としてで取りたいと思い取り組みの一つ

15
00:00:49,030 --> 00:00:53,120
我々は他の話とに変換することができますどれだけの内容を確認することです

16
00:00:53,120 --> 00:00:54,110
書かれた言語。

17
00:00:54,110 --> 00:00:58,000
このプロジェクトへの参加に関心、それによってがあるかもしれないので、もし

18
00:00:58,000 --> 00:01:02,090
私たちはコースのための英語成績証明書や字幕を提供します

19
00:01:02,090 --> 00:01:05,190
講義やショートセミナーやセクションなど - 

20
00:01:05,190 --> 00:01:08,700
あなたは流暢に話すか流暢にいくつかの他の言語を記述する場合、我々はだろう

21
00:01:08,700 --> 00:01:12,240
あなたが一つ以上を取ることにより、このプロジェクトであなたを従事するのが大好き

22
00:01:12,240 --> 00:01:15,340
ビデオ、あなたは非常によく知っている言語に翻訳する。

23
00:01:15,340 --> 00:01:19,050
あなたのインターフェイスの感覚を与えるために、このWebベースのユーザー·インターフェースはあり

24
00:01:19,050 --> 00:01:22,330
我々は、本質的にこ​​のようなUIを作成することを使用することがありますことを。

25
00:01:22,330 --> 00:01:24,520
これは、いくつかのハロウィーンの前に教えてくれました。

26
00:01:24,520 --> 00:01:27,710
と右手側にあり、黒でこれらのタイムスタンプの隣に、

27
00:01:27,710 --> 00:01:31,300
あなたはその日、私の口から出てきた様々なものを見ることができます。

28
00:01:31,300 --> 00:01:34,660
そして、その下には、いくつかの他の言語に翻訳することができるでしょう。

29
00:01:34,660 --> 00:01:37,840
マッピングは、この場合、英語では、間にあるかを正確に

30
00:01:37,840 --> 00:01:38,660
そして、スペイン語を言う。

31
00:01:38,660 --> 00:01:40,480
だから、実際には非常にユーザーフレンドリーなツールです。

32
00:01:40,480 --> 00:01:43,690
キーボードショートカットで非常に容易に早送り巻き戻しができます。

33
00:01:43,690 --> 00:01:46,710
ですから、この実験に参加し、あなたの言葉を持っているしたい場合

34
00:01:46,710 --> 00:01:50,730
見て、そこに人々の潜在的に数千人が読んで、感じてください

35
00:01:50,730 --> 00:01:51,960
自由に参加できる。

36
00:01:51,960 --> 00:01:56,940
>> 今、私たちは過度に月曜日から子猫約1単語を、送信​​されないように

37
00:01:56,940 --> 00:01:58,120
怖いメッセージ。

38
00:01:58,120 --> 00:02:02,130
、営業時間が示すように、セクションが示唆するようにすることを実現するか

39
00:02:02,130 --> 00:02:05,110
もちろんデザインがコラボレーションし、学生を持っていることは非常に似ています

40
00:02:05,110 --> 00:02:09,250
一緒に問題セットとの問題を介して動作するように話している。

41
00:02:09,250 --> 00:02:13,630
そして、実際にラインはちょうどあなたは、最終的には仕事、再び、に尽きる

42
00:02:13,630 --> 00:02:16,420
あなた自身でなければなりません提出してください。

43
00:02:16,420 --> 00:02:19,080
そしてそれははっきり言って、だ - 営業時間内に、それは完全に正常です - 

44
00:02:19,080 --> 00:02:21,560
それも、予想されることに全くだ - いくつかとおしゃべりする

45
00:02:21,560 --> 00:02:22,370
あなたの隣の友人。

46
00:02:22,370 --> 00:02:25,240
彼または彼女はいくつかのトピックに苦労している、とあなたが同じなら、ああ、よくみましょう

47
00:02:25,240 --> 00:02:27,750
私はあなたに私が書いたコードのいくつかの行を垣間見ること。

48
00:02:27,750 --> 00:02:28,290
それで結構です。

49
00:02:28,290 --> 00:02:28,700
それは起こる。

50
00:02:28,700 --> 00:02:31,580
そして、それは学習の過程で、私が思うに、非常に多くの助けとなるのです。

51
00:02:31,580 --> 00:02:35,270
再び、交差されるラインは、ヘッドが種の上に傾いたときです

52
00:02:35,270 --> 00:02:38,800
ここでは本当にただ持っているそのためにあまりにも多くの数秒または数分のために

53
00:02:38,800 --> 00:02:41,250
あなたの友人のためのブロックを解除する機会となっ。

54
00:02:41,250 --> 00:02:43,870
そして確かに、物事は、電子メールやDropboxを介して交換されるタイミングや

55
00:02:43,870 --> 00:02:45,350
のような、あまりにも線がある。

56
00:02:45,350 --> 00:02:48,940
だから、すべての手段で、快適に感じる、お友達とのおしゃべりを促したい

57
00:02:48,940 --> 00:02:51,270
psetとより約同級生。

58
00:02:51,270 --> 00:02:54,680
そして、ちょうど何を最終的に提出することは本当にあるべきことを認識

59
00:02:54,680 --> 00:02:57,780
あなたの創造ではなく、他の誰かの製品。

60
00:02:57,780 --> 00:03:01,010
>> だからかわいい生き物の同じ静脈では、あなたは可能性がある

61
00:03:01,010 --> 00:03:02,820
ここでこの男を知っている。

62
00:03:02,820 --> 00:03:06,180
だから、これは数年前から恐ろしく安っぽい映画です。

63
00:03:06,180 --> 00:03:08,680
誰もがここスペース·ボールを見たことある？

64
00:03:08,680 --> 00:03:09,120
かしこまりました。

65
00:03:09,120 --> 00:03:10,220
ここでかなりの数がそう。

66
00:03:10,220 --> 00:03:13,840
だから、これは最終的に、今日の私たちの導入素晴らしく学術的な方法です

67
00:03:13,840 --> 00:03:15,130
暗号の概念。

68
00:03:15,130 --> 00:03:19,010
来るpsetの2のためのドメイン固有の問題のように1と、

69
00:03:19,010 --> 00:03:22,770
遅く明日の夜から、これは、暗号技術の世界に飛び込むことである

70
00:03:22,770 --> 00:03:26,380
情報を暗号化またはスクランブルする技術である。

71
00:03:26,380 --> 00:03:30,160
そして、これは究極的にはセキュリティの世界にも関する。

72
00:03:30,160 --> 00:03:34,440
>> 今すぐ私たちのほとんどのセキュリティはかなりありふれたメカニズムの形式で提供されます。

73
00:03:34,440 --> 00:03:36,920
私たちのすべては、ユーザー名とパスワードを持っています。

74
00:03:36,920 --> 00:03:41,350
と私たちのすべては、最も可能性の高い、非常に悪いユーザー名とパスワードを持っています。

75
00:03:41,350 --> 00:03:45,250
あなたのパスワードは複数のウェブサイトで同じであれば、それはおそらくありません

76
00:03:45,250 --> 00:03:47,920
最高のアイデアは、我々は、学期の終わりに向かって説明しますように。

77
00:03:47,920 --> 00:03:51,680
あなたに - 冗談 - あなたのパスワードは付箋紙に書かれている場合

78
00:03:51,680 --> 00:03:55,130
あまりにも必ずしも最高のデザインが、かなり一般的ではありませんモニター、

79
00:03:55,130 --> 00:03:56,140
現象。

80
00:03:56,140 --> 00:04:00,420
そして、あなたがあなたのパスワードを暗号化する暗号化方式を使用していないのであれば、それらは

81
00:04:00,420 --> 00:04:01,610
特に影響を受けやすい。

82
00:04:01,610 --> 00:04:04,670
あなたは隠された単語を持っていることによって巧妙なスーパーであるしていると思うので、もし

83
00:04:04,670 --> 00:04:07,740
すべてのパスワードを持っていますが、ハードドライブ上のどこかに文書

84
00:04:07,740 --> 00:04:10,550
それはあまりにも非常にされていないか、誰に見に行くんだというフォルダにあります

85
00:04:10,550 --> 00:04:11,540
セキュアなメカニズム。

86
00:04:11,540 --> 00:04:15,100
それで何のpset 2が紹介すると、暗号化のこの芸術であり、

87
00:04:15,100 --> 00:04:18,300
パスワードのようなものであるように、情報をスクランブル

88
00:04:18,300 --> 00:04:19,500
すべてのより安全。

89
00:04:19,500 --> 00:04:24,500
非常に非現実世界でこの非常に現実的な問題をやる気にさせるように

90
00:04:24,500 --> 00:04:28,740
シナリオは、私はこのことからここで私たちのお気に入りのクリップのいずれかをご紹介しましょう

91
00:04:28,740 --> 00:04:29,895
映画、スペース·ボール。

92
00:04:29,895 --> 00:04:30,565
>> [ビデオの再生]

93
00:04:30,565 --> 00:04:32,995
·ヘルメット、あなた悪魔、何が起こっているのですか？

94
00:04:32,995 --> 00:04:34,730
あなたは私の娘に何をしているのか？

95
00:04:34,730 --> 00:04:38,960
私は鮮やかな若い形成外科医、博士フィリップを紹介する - 許可

96
00:04:38,960 --> 00:04:43,290
全体でSchlotkin、最大の鼻の男

97
00:04:43,290 --> 00:04:45,526
宇宙やビバリーヒルズ。

98
00:04:45,526 --> 00:04:46,450
 - 殿下。

99
00:04:46,450 --> 00:04:47,380
 - 鼻の美容整形？

100
00:04:47,380 --> 00:04:48,035
分かりません。

101
00:04:48,035 --> 00:04:49,480
彼女はすでに鼻を持っていた。

102
00:04:49,480 --> 00:04:51,490
それは甘い16に存在していた。

103
00:04:51,490 --> 00:04:53,090
 - いいえ、それはあなたが思っているものではありません。

104
00:04:53,090 --> 00:04:55,150
それは、はるかに悪いです。

105
00:04:55,150 --> 00:04:59,860
意志あなたが私にエアシールドに組み合わせを与えていない場合は、Dr Schlotkin

106
00:04:59,860 --> 00:05:04,135
彼女の昔の鼻を自分の娘をお返し。

107
00:05:04,135 --> 00:05:05,385
 - いいえ！

108
00:05:08,202 --> 00:05:10,186
あなたはどこで手に入れた？

109
00:05:10,186 --> 00:05:11,178
 - すべての権利。

110
00:05:11,178 --> 00:05:11,674
私が教えてあげましょう。

111
00:05:11,674 --> 00:05:12,666
私が教えてあげましょう。

112
00:05:12,666 --> 00:05:14,154
 - いいえ、パパ、ない。

113
00:05:14,154 --> 00:05:15,150
あなたはいけません。

114
00:05:15,150 --> 00:05:16,460
-あなたが右、私の愛する。

115
00:05:16,460 --> 00:05:18,450
私はあなたの新しい鼻を逃してしまう。

116
00:05:18,450 --> 00:05:21,550
しかし、私は組み合わせが何でそれを教えてくれません。

117
00:05:21,550 --> 00:05:23,100
 - 非常によく。

118
00:05:23,100 --> 00:05:25,510
博士Schlotkinは、あなたの最悪を行う。

119
00:05:25,510 --> 00:05:26,760
 - 私の喜び。

120
00:05:30,560 --> 00:05:31,180
 - いいえ！

121
00:05:31,180 --> 00:05:33,450
待って、待って。

122
00:05:33,450 --> 00:05:34,770
私が教えてあげましょう。

123
00:05:34,770 --> 00:05:36,400
私が教えてあげましょう。

124
00:05:36,400 --> 00:05:38,630
 - 私はそれを動作させることを知っていた。

125
00:05:38,630 --> 00:05:42,040
すべての権利、私にそれを与える。

126
00:05:42,040 --> 00:05:46,890
コンビネーションは1つです。

127
00:05:46,890 --> 00:05:47,290
ワン。

128
00:05:47,290 --> 00:05:48,183
ワン。

129
00:05:48,183 --> 00:05:48,950
-Twoの。

130
00:05:48,950 --> 00:05:49,370
-Twoの。

131
00:05:49,370 --> 00:05:50,450
-Twoの。

132
00:05:50,450 --> 00:05:50,715
 - 三

133
00:05:50,715 --> 00:05:51,380
 - 三。

134
00:05:51,380 --> 00:05:52,390
 - 三。

135
00:05:52,390 --> 00:05:53,200
 - フォー。

136
00:05:53,200 --> 00:05:53,720
 - フォー。

137
00:05:53,720 --> 00:05:55,830
 - フォー。

138
00:05:55,830 --> 00:05:56,580
ファイブ

139
00:05:56,580 --> 00:05:57,120
ファイブ。

140
00:05:57,120 --> 00:05:58,560
ファイブ。

141
00:05:58,560 --> 00:06:03,770
 - だから組み合わせは、1つ、2つ、3つ、4つ、5つです。

142
00:06:03,770 --> 00:06:06,745
それは私が今まで私の人生で聞いたバカな組み合わせです。

143
00:06:06,745 --> 00:06:09,290
それは馬鹿が彼の荷物に与える事のようなものだ。

144
00:06:09,290 --> 00:06:11,540
殿下、あなたをありがとうございます。

145
00:06:11,540 --> 00:06:12,940
 - 何をあなたがやったの？

146
00:06:12,940 --> 00:06:14,230
 - 私は、壁をオフにしました。

147
00:06:14,230 --> 00:06:14,630
 - いいえ、その必要はありませんでした。

148
00:06:14,630 --> 00:06:15,430
あなたは、映画全体をオフにしました。

149
00:06:15,430 --> 00:06:16,722
 - 私が間違ったボタンを押しておく必要があります。

150
00:06:16,722 --> 00:06:18,078
 - まあ、それをオンに戻す。

151
00:06:18,078 --> 00:06:18,805
上に戻ってムービーを置く。

152
00:06:18,805 --> 00:06:19,080
 - はい、先生。

153
00:06:19,080 --> 00:06:19,270
はい、先生。

154
00:06:19,270 --> 00:06:19,830
のは、エルナ、ゴーカートましょう。

155
00:06:19,830 --> 00:06:20,270
グレッチェン、来る。

156
00:06:20,270 --> 00:06:22,850
もちろん、私はまだこのご請求する必要があります知っている。

157
00:06:27,400 --> 00:06:28,325
 - まあ、それは動作したのですか？

158
00:06:28,325 --> 00:06:29,550
ゲートはどこにありますか？

159
00:06:29,550 --> 00:06:29,910
 - それは先生、働いていた。

160
00:06:29,910 --> 00:06:30,770
我々は組み合わせを持っている。

161
00:06:30,770 --> 00:06:31,390
 - グレート。

162
00:06:31,390 --> 00:06:35,630
今、私たちは、地球Druidiaから新鮮な空気のすべての最後の息を取ることができます。

163
00:06:35,630 --> 00:06:36,550
組み合わせは何ですか？

164
00:06:36,550 --> 00:06:38,805
 - 一、二、三、四、五。

165
00:06:38,805 --> 00:06:40,610
 - 一、二、三、四、五？

166
00:06:40,610 --> 00:06:41,070
 - はい。

167
00:06:41,070 --> 00:06:41,760
 - それは驚くべきことだ。

168
00:06:41,760 --> 00:06:45,200
私は自分の荷物で同じ組み合わせを持っている。

169
00:06:45,200 --> 00:06:47,800
即時の出発のためにスペースボールの準備1。

170
00:06:47,800 --> 00:06:48,536
 - はい、先生。

171
00:06:48,536 --> 00:06:52,350
 - そして、私の荷物の組み合わせを変更してください。

172
00:06:52,350 --> 00:06:53,250
 - わー！

173
00:06:53,250 --> 00:06:55,020
[エンドビデオの再生]

174
00:06:55,020 --> 00:06:57,470
>> デイヴィッドJ.マラン：あなたが今、すべて表示されるはずです素晴らしい映画。

175
00:07:00,600 --> 00:07:06,540
だからここにコンテキストが安全でないデータとする機会があることです

176
00:07:06,540 --> 00:07:07,790
それを暗号化し、それをスクランブルする。

177
00:07:07,790 --> 00:07:11,060
それでこれは、例えば、暗号化されたメッセージの例です。

178
00:07:11,060 --> 00:07:12,980
これは、実際に英語で何かを言う。

179
00:07:12,980 --> 00:07:14,750
しかし、それは明らかに完全に明確ではありません。

180
00:07:14,750 --> 00:07:17,360
そして、我々は離れていじめるために今日完全な円を来る何この秘密

181
00:07:17,360 --> 00:07:18,380
ここにメッセージがある。

182
00:07:18,380 --> 00:07:22,370
しかし、コンピュータの現実の世界では、物事も、彼らは可能性があるようには見えないでしょう

183
00:07:22,370 --> 00:07:23,440
英語のフレーズである。

184
00:07:23,440 --> 00:07:27,500
例えば、これは、標準のLinuxやMac上で見つけるかもしれないものであるか、

185
00:07:27,500 --> 00:07:32,080
昔々あったファイルにUNIXコンピュータは、パスワードファイルと呼ばれる。

186
00:07:32,080 --> 00:07:34,170
今日では、それが他の場所に移動した。

187
00:07:34,170 --> 00:07:38,660
あなたは、システム上の適切な場所で見てみると、あなただけでなく、あなたが表示されます

188
00:07:38,660 --> 00:07:41,430
ユーザ名またはシステム上の他の人のものですが、あなたが表示されます

189
00:07:41,430 --> 00:07:43,410
それらのパスワードの暗号化バージョン。

190
00:07:43,410 --> 00:07:47,800
確かに、そこにワードcryptは、次のものが暗号化されていることを示唆している。

191
00:07:47,800 --> 00:07:52,030
そして、この一見ランダムな文字と文字と数字のシリーズと

192
00:07:52,030 --> 00:07:56,370
など、一般的にいくつかの秘密を知ることによってのみ復号することができます - 

193
00:07:56,370 --> 00:07:58,600
シークレットワード、暗証番号。

194
00:07:58,600 --> 00:08:02,760
それで実際に、暗号化の技術は、最終的に帰着する一部の信頼に

195
00:08:02,760 --> 00:08:05,700
並べ替えと他の誰かがいない何かを知っている。

196
00:08:05,700 --> 00:08:10,010
今日はもう少し詳細にこれを見ていきますとPSETに来て。

197
00:08:10,010 --> 00:08:11,860
>> そして今、合格/不合格の単語。

198
00:08:11,860 --> 00:08:15,250
だから、特に、あなたのいくつかのようにPSET 1アプライアンスに飛び込んだ、としている

199
00:08:15,250 --> 00:08:18,390
自分のための非常に新しい世界が、そのフラストレーションを実現し、

200
00:08:18,390 --> 00:08:21,340
混乱と単に技術的な困難が予想される。

201
00:08:21,340 --> 00:08:24,410
特にちょうどなって、ちょうどそんなに新しいあり第一PSETと

202
00:08:24,410 --> 00:08:28,830
lsとcd、新しい環境内のすべてのこれらの難解なコマンドに精通。

203
00:08:28,830 --> 00:08:32,679
そして、それは実際の材料とプログラミング自体とは別にです。

204
00:08:32,679 --> 00:08:35,960
だからとして存在営業時間は確かに存在することは、あまりにも、実現する

205
00:08:35,960 --> 00:08:36,770
支持構造。

206
00:08:36,770 --> 00:08:38,620
のセクションでは、今度の日曜日から始まります。

207
00:08:38,620 --> 00:08:41,990
あなただけのことを感じている場合しかし、最も重要なのは、この限りではありません

208
00:08:41,990 --> 00:08:44,420
あなたのための世界では、それは本当にちょうど時間がかかりますことを実現します。

209
00:08:44,420 --> 00:08:47,520
そして、それはクラスを取ることを私のために数年前にこの機会がなかっ

210
00:08:47,520 --> 00:08:50,840
合格/不合格、正直なところ、私も教室に足を踏み入れてもみなかった。

211
00:08:50,840 --> 00:08:53,520
そして、あなたはもちろん第五月曜日、言うまで、これまで変更することができます。

212
00:08:53,520 --> 00:08:57,110
あなたが今エッジにしているのであれば、実現することはなく、他のいくつかの頭に

213
00:08:57,110 --> 00:09:01,000
水が完全に、確かにちょうど合格/失敗し変更することを検討してください。

214
00:09:01,000 --> 00:09:03,750
繰り返しますが、この文化は物事を取るのハーバード大学でここは本当になさそうだ

215
00:09:03,750 --> 00:09:08,080
誰もが本当に実現するか、〜以上の成績を収めるために望んでいるので、合格/不合格。

216
00:09:08,080 --> 00:09:11,470
しかし、率直に言って、これは何かをしようとするの素晴らしい方法であることはないかもしれないから

217
00:09:11,470 --> 00:09:13,110
あなたにはおなじみのもの。

218
00:09:13,110 --> 00:09:17,090
そして、あなたは多分、かなり細かいほとんどの場合でやって終わるだろう

219
00:09:17,090 --> 00:09:18,040
ずっとあなたの驚きに。

220
00:09:18,040 --> 00:09:20,850
そして、より具体的に、私はありません一般的に合格/不合格かと思う

221
00:09:20,850 --> 00:09:23,350
あなたが置かれている場合は、PSET 0で経験したかもしれない、特にとして

222
00:09:23,350 --> 00:09:27,200
で10時間、15時間、25時間、いくつかのpsetに - あなたはただ叩いている

223
00:09:27,200 --> 00:09:28,180
壁に頭、

224
00:09:28,180 --> 00:09:29,850
そしてそれは、夜遅くなってきたスーパー

225
00:09:29,850 --> 00:09:31,880
しかし、あなたは、道の90％のようにpsetを撮影した

226
00:09:31,880 --> 00:09:33,780
あなたはただ一つのことを把握することはできません知っている - 

227
00:09:33,780 --> 00:09:36,830
あなたはどこに並べ替えることができます本当に、このようなクラスの端を脱ぐ合格/不合格

228
00:09:36,830 --> 00:09:39,150
喜んでいいと言うが、私はそれは完璧ではない知っている。

229
00:09:39,150 --> 00:09:40,470
しかし、私はこれで私のお尻をオフに働いた。

230
00:09:40,470 --> 00:09:42,410
私はそれが終わったところでかなり満足している。

231
00:09:42,410 --> 00:09:44,780
そして、それは合格/不合格の期待に応えていきます。

232
00:09:44,780 --> 00:09:46,850
だから、このことを念頭に置いておくん。

233
00:09:46,850 --> 00:09:47,140
>> かしこまりました。

234
00:09:47,140 --> 00:09:50,980
ハーバード大学のWi-Fiを使用するには苦労しているあなたの人々が知っているので、

235
00:09:50,980 --> 00:09:54,780
その周りに浮かんでCS50のSSIDがあること、Wi-Fi接続する

236
00:09:54,780 --> 00:09:56,520
のためのより良い運を持っているかもしれません。

237
00:09:56,520 --> 00:09:59,430
あなたは試してみたい場合は、 - それは、このためのパスワードという少し皮肉なことだ

238
00:09:59,430 --> 00:10:03,080
より良い速度のためにこれに接続しても何が良いでしょうない場合はお知らせ - 

239
00:10:03,080 --> 00:10:09,240
8であるため、1、2、3、4、5、最大8つのすべての方法です

240
00:10:09,240 --> 00:10:10,270
5よりも安全。

241
00:10:10,270 --> 00:10:15,520
あなたは、Wi-Fiのパスワードが必要ですので、もし無線でここCS50に接続します。

242
00:10:15,520 --> 00:10:16,950
一、二、三、四、五、六、七、八。

243
00:10:16,950 --> 00:10:20,440
そして、あなたはまだ断続的な接続性の問題がある場合、議論CS50に投稿

244
00:10:20,440 --> 00:10:24,880
そして、私たちはこの空間のために知っていることの力をもらおう。

245
00:10:24,880 --> 00:10:25,180
>> かしこまりました。

246
00:10:25,180 --> 00:10:30,350
特にファンの男の子か女の子であるあなたの人々のために非常に速くティーザー、

247
00:10:30,350 --> 00:10:31,900
すべてのものはAppleの。

248
00:10:31,900 --> 00:10:37,566
私は数年前から掘っするだけに、ここilock.cこのファイルでした

249
00:10:37,566 --> 00:10:40,930
もっと基本的なC言語のいくつかのより具体的な、より複雑なmakeの一種

250
00:10:40,930 --> 00:10:42,350
私たちが書いてきたプログラム。

251
00:10:42,350 --> 00:10:44,360
だから私はilock.c、このファイルを開いた。

252
00:10:44,360 --> 00:10:46,830
それは、今日の講義のページで利用可能です。

253
00:10:46,830 --> 00:10:49,470
左側では、機能の長いリストを参照してください。

254
00:10:49,470 --> 00:10:51,860
だから、これを書いた奴は、機能の多くを書いた

255
00:10:51,860 --> 00:10:53,290
ちょうどメイン以上。

256
00:10:53,290 --> 00:10:55,490
彼はここにライブラリの全体の束を使用していました。

257
00:10:55,490 --> 00:11:00,450
そして、我々はスクロール開始した場合、これは実際には非常に何かされている

258
00:11:00,450 --> 00:11:04,670
第一、私は信じて、オリジナルのiPhoneのために割れる。

259
00:11:04,670 --> 00:11:08,000
あなたは〜のいましめを解くことを意味し、オリジナルのiPhoneを脱獄したいとき

260
00:11:08,000 --> 00:11:11,800
AT＆Tからそれと実際にそれに特別なソフトウェアをインストールして物事を行う

261
00:11:11,800 --> 00:11:13,510
アップルは、人々はしたくなかったことを - 

262
00:11:13,510 --> 00:11:17,020
よく、誰かが彼らが悪用される可能性があります正確にどのように把握するために時間がかかった

263
00:11:17,020 --> 00:11:20,880
Appleのソフトウェアのソフトウェアの欠陥、ミス、バグ、。

264
00:11:20,880 --> 00:11:22,650
こうしてilock.c生まれた。

265
00:11:22,650 --> 00:11:26,670
それは、コンピュータ上でそれをコンパイルし、そのiPhoneにそれをインストールした場合

266
00:11:26,670 --> 00:11:29,810
USBケーブル、言う、を介してコンピュータに接続されていた、これはあなたを与えるだろう

267
00:11:29,810 --> 00:11:33,360
あなたのiPhone上で管理者権限またはroot権限とはかなりをやらせる

268
00:11:33,360 --> 00:11:34,170
何でもしたい。

269
00:11:34,170 --> 00:11:36,740
>> それで、Appleとの間で、この魅力的な猫とネズミのゲームがありまして

270
00:11:36,740 --> 00:11:39,920
特に、世界の残りの部分は、多くの企業と同様、ロックしようとして

271
00:11:39,920 --> 00:11:43,220
あなただけの彼らが意図したものそれを行うことができるように自分の作品ダウン。

272
00:11:43,220 --> 00:11:46,620
しかし、このような人々のおかげで、低レベルの理解

273
00:11:46,620 --> 00:11:50,580
詳細と、この場合には、Cプログラミング、使い慣れた構造物の多く

274
00:11:50,580 --> 00:11:54,630
私達は一緒に遊んで始めたことを、あなたは本当に活用することができます

275
00:11:54,630 --> 00:11:59,050
あなたがフィットして、いくつかの企業体である必要はありませんを参照してください方法でハードウェア。

276
00:11:59,050 --> 00:12:01,360
だから例えば、私は、このすべてが何をしているのか見当がつかない。

277
00:12:01,360 --> 00:12:03,220
しかし、バージョンの取得は非常に簡単に聞こえる。

278
00:12:03,220 --> 00:12:05,480
そして、それはこのようになり、この人が書いた関数である。

279
00:12:05,480 --> 00:12:09,240
引数として整数のいくつかの種類を取ることは、何も返されませんが、

280
00:12:09,240 --> 00:12:13,080
if条件、状態であれば、ここにforループとでループに表示されます

281
00:12:13,080 --> 00:12:15,620
打破し、何とかバージョン番号に関する。

282
00:12:15,620 --> 00:12:16,700
我々は、下にスクロールした場合 - 

283
00:12:16,700 --> 00:12:19,570
これらのキーワードの多くは、新しいことを行っているし、そこは言っても

284
00:12:19,570 --> 00:12:22,590
ここでの機能の全体の多くは、我々は見たことがないし、これまで以上表示されない場合があります

285
00:12:22,590 --> 00:12:23,830
学期のコース - 

286
00:12:23,830 --> 00:12:27,150
一日の終わりに、それは我々がしてきたのと同じルールとロジックに従う

287
00:12:27,150 --> 00:12:28,760
これまで一緒に遊んで。

288
00:12:28,760 --> 00:12:34,220
だから、これははるかにあなたのiPhone 3sまたは4sのか、まもなく5S、これらの日を、クラックするには古すぎる

289
00:12:34,220 --> 00:12:37,320
しかし、我々はされたことが、それがすべて非常にこの世界から派生していることを知って

290
00:12:37,320 --> 00:12:38,430
に飛び込んだ。

291
00:12:38,430 --> 00:12:41,900
>> それでは、もう少し簡単な例を見てみましょう。

292
00:12:41,900 --> 00:12:46,100
ちょうどいくつかの構文、また、いくつかの他のデータと暖め得るために、この1、

293
00:12:46,100 --> 00:12:49,240
これがあるので、私たちは話をしましたが、実際にC言語で見たことがないタイプ

294
00:12:49,240 --> 00:12:51,680
ファイルがpositive1.c呼ばれる。

295
00:12:51,680 --> 00:12:55,120
そして先頭のコメントにつき、これは単に、ユーザーが提供することを要求

296
00:12:55,120 --> 00:12:55,960
正の数。

297
00:12:55,960 --> 00:12:59,530
だから、ユーザー対話型のための素晴らしいです、do-whil​​eループの例です

298
00:12:59,530 --> 00:13:01,980
あなたが何かをするようにユーザに指示する必要がありますプログラム。

299
00:13:01,980 --> 00:13:05,190
そして、彼らは協力しない場合は、それらで叫ぶか、それらの入力を拒否します。

300
00:13:05,190 --> 00:13:11,610
ポイントのケース、私は長い間、ユーザーが持っている24を介して、ライン19をするつもりです

301
00:13:11,610 --> 00:13:14,310
私に正の数を与えられていない。

302
00:13:14,310 --> 00:13:20,400
今ここでこのディテールは、18行目に、なぜ私はこの全体の上にnを宣言した

303
00:13:20,400 --> 00:13:24,490
22行目、私のすぐ隣には対照的に構築するループ

304
00:13:24,490 --> 00:13:26,880
実際にnを取得する気？

305
00:13:26,880 --> 00:13:27,330
うん？

306
00:13:27,330 --> 00:13:27,780
[聞こえない]

307
00:13:27,780 --> 00:13:29,040
>> デイヴィッドJ.マラン：ええ、そう、スコープのこの問題。

308
00:13:29,040 --> 00:13:30,850
と素人の用語では、スコープはに何を指しているのでしょう？

309
00:13:34,690 --> 00:13:36,610
うん？

310
00:13:36,610 --> 00:13:37,860
[聞こえない]

311
00:13:40,040 --> 00:13:41,105
デイヴィッドJ.マラン：あなたは大声で少し話すことはできますか？

312
00:13:41,105 --> 00:13:43,450
スピーカ1：あなたは、特定の変数にアクセスすることができます。

313
00:13:43,450 --> 00:13:45,170
デイヴィッドJ.マラン：パーフェクト。

314
00:13:45,170 --> 00:13:47,360
どこで特定の変数にアクセスすることができます。

315
00:13:47,360 --> 00:13:50,400
そして一般的には、親指のルールは、これまでされていることをいくつかの範囲

316
00:13:50,400 --> 00:13:55,860
変数は、あなたが見てきた最新の中括弧で定義されています。

317
00:13:55,860 --> 00:14:02,010
ので、この場合では、私は、22行目のnを宣言するミスを犯した場合

318
00:14:02,010 --> 00:14:03,010
そのラインが働くだろう。

319
00:14:03,010 --> 00:14:10,990
私はint型になるだろう、と私は、22行目でその変数nにそれを置くだろう。

320
00:14:10,990 --> 00:14:16,900
しかし、どのコード行は、今私が何について話しているか見当がつかないでしょうか？

321
00:14:16,900 --> 00:14:22,650
25だから、この場合には、それが外れたので、それは、同様に、24判明

322
00:14:22,650 --> 00:14:23,610
中括弧。

323
00:14:23,610 --> 00:14:27,280
だから、非常に簡単に、単純に宣言することで、ほんの少し迷惑のビットが、解決

324
00:14:27,280 --> 00:14:30,140
関数自体の外で変数。

325
00:14:30,140 --> 00:14:32,600
>> 今、私たちは今日後ほど説明しますと、さらに一歩進むことができます。

326
00:14:32,600 --> 00:14:34,860
そして、あなたが少しでも怠け癖がつく可能性 - 

327
00:14:34,860 --> 00:14:37,320
これは一般的には、推奨されるべきではない - 

328
00:14:37,320 --> 00:14:42,260
しかし、あなたは、いなくても怠け癖がつくと、グローバル変数を置き、いわば可能性

329
00:14:42,260 --> 00:14:46,670
関数の内部ではなく、内側のループのが、ファイル自体には、外

330
00:14:46,670 --> 00:14:49,600
私は15行目でここに行ったように、書いてきたすべての関数の。

331
00:14:49,600 --> 00:14:51,160
しかし、これは一般的に眉をひそめている。

332
00:14:51,160 --> 00:14:55,680
私たちが説明するようにしかし、これは時々他の問題への解決策であると認識

333
00:14:55,680 --> 00:14:56,620
最終的に参照してください。

334
00:14:56,620 --> 00:14:58,130
だから今のところ、我々はこのようにそれを残しておきます。

335
00:14:58,130 --> 00:15:01,030
しかし、我々は、これは単に自分自身表現し始めるように書き換えることができるかどうか見てみましょう

336
00:15:01,030 --> 00:15:01,990
少し違った。

337
00:15:01,990 --> 00:15:05,330
>> したがって、このプログラムは、単に明確にするために、positive1です。

338
00:15:05,330 --> 00:15:11,810
私はここで先に行くと、私の端末ウィンドウで入力し、positive1を作ってみましょう。

339
00:15:11,810 --> 00:15:12,740
大丈夫、コンパイルします。

340
00:15:12,740 --> 00:15:14,910
私は、Enterを押して、positive1を実行するつもりです。

341
00:15:14,910 --> 00:15:16,820
私はあなたが私達に正の整数を与えることを求めています。

342
00:15:16,820 --> 00:15:18,260
私は-1と言うでしょう。

343
00:15:18,260 --> 00:15:18,910
それは動作しませんでした。

344
00:15:18,910 --> 00:15:22,150
動作するように思われる0、99、。

345
00:15:22,150 --> 00:15:23,570
多分ない最も厳格なテスト。

346
00:15:23,570 --> 00:15:26,480
しかし、少なくとも、それは我々が正しい道にいることを良い健全性チェックです。

347
00:15:26,480 --> 00:15:29,240
だから今、私が先に行くと、このバージョンの2を開いてみましょう。

348
00:15:29,240 --> 00:15:32,500
そして、すでに何が違うのですか？

349
00:15:32,500 --> 00:15:35,140
それは同じことを実装しています。

350
00:15:35,140 --> 00:15:40,660
しかし、明らかに異なるこの時間として何が飛び出すのか？

351
00:15:40,660 --> 00:15:42,560
ええ、そう、このブール緑インチ

352
00:15:42,560 --> 00:15:45,980
Geditは、ブール値として知られている緑色のこのキーワードで強調表示されている

353
00:15:45,980 --> 00:15:47,000
これは、データ·タイプです。

354
00:15:47,000 --> 00:15:51,080
それはCのすべてのバージョンに組み込まれて来ていないあなたは、インクルードする必要があり

355
00:15:51,080 --> 00:15:52,010
特定のライブラリ。

356
00:15:52,010 --> 00:15:54,770
私たちのケースでは、私はCS50ライブラリが含まれていたように、我々

357
00:15:54,770 --> 00:15:56,460
ブール値にアクセスすることができます。

358
00:15:56,460 --> 00:15:59,810
しかし、18行目では、我々はここに感謝と呼ばれるブール値を持っているように思われる。

359
00:15:59,810 --> 00:16:01,040
だから私はこの何かを求めている可能性があります。

360
00:16:01,040 --> 00:16:04,500
しかし、私はいくつかの意味を伝えるの種類にそれは感謝と呼ばれる。

361
00:16:04,500 --> 00:16:07,930
ためこのように当初は18行目で、私は明らかに感謝してないんだけど

362
00:16:07,930 --> 00:16:12,150
感謝してブール値は18行目でfalseに初期化されます。

363
00:16:12,150 --> 00:16:16,890
そしてそれは私が23を介して、ライン21にここで何をやったかと思われる私はちょうどたです

364
00:16:16,890 --> 00:16:18,610
書き換えられた私のロジックの一種。

365
00:16:18,610 --> 00:16:21,020
ない機能的に異なるので。

366
00:16:21,020 --> 00:16:26,940
ユーザーが提供したintがより大きい場合でも、22行目で、今、私はチェック

367
00:16:26,940 --> 00:16:31,120
0の場合、私は単純にtrueに感謝の値を変更します。

368
00:16:31,120 --> 00:16:32,290
そして、私がなぜそれを行うのですか？

369
00:16:32,290 --> 00:16:35,600
25行目では、どうやら、私は条件をチェックするつもりですので。

370
00:16:35,600 --> 00:16:39,380
感謝がfalseのときにこのループを行う。

371
00:16:39,380 --> 00:16:43,610
>> それは、少なくともだからそう私はバージョン1の代替としてこれを提案する

372
00:16:43,610 --> 00:16:45,130
おそらく、もう少し直感的。

373
00:16:45,130 --> 00:16:46,900
これは、英語で接地もう少しだ。

374
00:16:46,900 --> 00:16:51,710
感謝がfalseのときに感謝していない間や、だから次の手順を実行します。

375
00:16:51,710 --> 00:16:55,890
そして今回は、あまりにも、私は明らかに、ユーザーの入力した内容を覚えて気にしない

376
00:16:55,890 --> 00:16:57,730
なぜなら予告でない変数nはありません。

377
00:16:57,730 --> 00:16:58,650
だから、実際、私は - 

378
00:16:58,650 --> 00:17:00,080
そこに小さな白い嘘。

379
00:17:00,080 --> 00:17:02,770
我々は底に着けば、機能的には、プログラムが少し異なっています

380
00:17:02,770 --> 00:17:04,819
それは私がここで、nは何であるか覚えてないんだから。

381
00:17:04,819 --> 00:17:09,579
しかし、私たちはgetIntを見てきたにもかかわらず、あまりにもここにいることを証明したいと思い、

382
00:17:09,579 --> 00:17:13,920
GetStringメソッドは、これまでのように、等号の右側で使用されている

383
00:17:13,920 --> 00:17:17,160
我々は厳密には必要ではない価値、技術的には、覚えています。

384
00:17:17,160 --> 00:17:20,950
何らかの理由であなただけの値を保存する気にしないなら、あなただけしたい

385
00:17:20,950 --> 00:17:25,710
値をチェックするために、我々は単に場合、getIntオープンとしてこれを書くことができていることがわかり

386
00:17:25,710 --> 00:17:27,000
括弧、括弧近い。

387
00:17:27,000 --> 00:17:30,460
その関数は、我々が言ってきたように、値を返すことになるだろう。

388
00:17:30,460 --> 00:17:32,010
それはintををお返しになるだろう。

389
00:17:32,010 --> 00:17:36,450
それで、あなたは精神的に場合、getInt、私は99で入力したときに、このような出来事を考える場合

390
00:17:36,450 --> 00:17:38,160
番号99を返します。

391
00:17:38,160 --> 00:17:41,330
私のコードは、実際にこのあたかもので、概念的には、それは。

392
00:17:41,330 --> 00:17:45,880
99が0より大きければ確かにそうだとすれば、感謝はtrueになります。

393
00:17:45,880 --> 00:17:50,420
私は今、感謝していますので、その後、25行目は、我々がやっているのoohを実現しています。

394
00:17:50,420 --> 00:17:54,590
そして26行目で、私たちは単に言う、正の整数のおかげで、何でも

395
00:17:54,590 --> 00:17:55,710
であることを起こった。

396
00:17:55,710 --> 00:17:58,900
>> 今すぐいわば、ここで若干の糖衣構文を実行してみましょう。

397
00:17:58,900 --> 00:18:02,990
我々はこの3番目と最後の分散で、この25行目をクリーンアップすることができるかどうかを確認してみましょう

398
00:18:02,990 --> 00:18:04,640
positive3インチ

399
00:18:04,640 --> 00:18:08,250
だから、唯一の違いは、現在のコードの何行目であることに気づく？

400
00:18:11,930 --> 00:18:13,260
ええ、そう25。

401
00:18:13,260 --> 00:18:15,520
そして、我々は本当にただまだこのトリックを見ていない。

402
00:18:15,520 --> 00:18:19,510
しかし、我々は何を表し月曜日に感嘆符を参照してくださいましたか？

403
00:18:19,510 --> 00:18:20,970
そうではない、または否定。

404
00:18:20,970 --> 00:18:23,460
だからブール値を取得し、その値を反転させます。

405
00:18:23,460 --> 00:18:24,390
trueはfalseになります。

406
00:18:24,390 --> 00:18:25,500
falseはtrueになります。

407
00:18:25,500 --> 00:18:28,910
だから、これは、私が提案すると、偶数の道をもう少し直感的です

408
00:18:28,910 --> 00:18:32,200
私はまだfalseに感謝して初期化するためのコードを書く。

409
00:18:32,200 --> 00:18:33,530
私はまだ、次の手順を実行します。

410
00:18:33,530 --> 00:18:35,700
時間が来るとき、私は本当のには感謝し設定します。

411
00:18:35,700 --> 00:18:40,690
しかし、今では本当にただ、口頭で左から右にこのコードを変換することができます

412
00:18:40,690 --> 00:18:42,550
感謝しない間。

413
00:18:42,550 --> 00:18:46,170
ビッグバン、または感嘆符は、そうしながら、ではないという概念を表すので

414
00:18:46,170 --> 00:18:47,010
感謝しない。

415
00:18:47,010 --> 00:18:49,740
>> だから、もう一度、我々はそれ自体任意の新しい概念を導入していない。

416
00:18:49,740 --> 00:18:53,230
我々がスクラッチで演奏するとき、我々は戻ってブール値について説明しました。

417
00:18:53,230 --> 00:18:55,690
しかし、今、私達はちょうど私たちのコードを書き始めることができますを実現

418
00:18:55,690 --> 00:18:56,550
多くの異なった方法。

419
00:18:56,550 --> 00:19:00,010
だから特にPSET1で、あなたがする方法を考え出すのに苦労して一​​種のなら

420
00:19:00,010 --> 00:19:03,400
いくつかのプログラムを書いて、オッズは、どのようにそこに起こっているので、あなたは運がいいアール

421
00:19:03,400 --> 00:19:05,780
あなたは時に起こることができることを多くのソリューション。

422
00:19:05,780 --> 00:19:09,850
例えば、これはプログラムの最も単純なため、わずか3です​​。

423
00:19:09,850 --> 00:19:10,180
かしこまりました。

424
00:19:10,180 --> 00:19:13,860
現在、月曜日に思い出すと、私たちは戻り値でこのノートに残された。

425
00:19:13,860 --> 00:19:18,280
だから、非常に最初の時間のために、我々は、ちょうどメイン持たないプログラムを書いた

426
00:19:18,280 --> 00:19:22,240
それはまた、私がここで書いた独自のカスタム機能を持っています。

427
00:19:22,240 --> 00:19:26,640
だから34を介して、ライン31で、私はキューブの機能を実装しました。

428
00:19:26,640 --> 00:19:27,800
それは、複雑ではありません。

429
00:19:27,800 --> 00:19:29,830
それは、このケースでは、ちょうど倍の倍だ。

430
00:19:29,830 --> 00:19:34,920
しかし、何それについて重要なのは、私がの形式で入力を取っているということであると

431
00:19:34,920 --> 00:19:38,910
私は、時代時代の形式で出力を返すよ。

432
00:19:38,910 --> 00:19:43,940
>> だから今私はそんなに私は呼び出すことは、printf単独で使われていたような能力を持っている

433
00:19:43,940 --> 00:19:47,120
キューブ関数を呼び出すことにより、この機能。

434
00:19:47,120 --> 00:19:49,470
とキューブ関数は、いくつかの入力を取得します。

435
00:19:49,470 --> 00:19:52,030
とキューブ関数は、いくつかの出力を返します。

436
00:19:52,030 --> 00:19:56,660
などとは対照的に、printfのちょうど何かをした。

437
00:19:56,660 --> 00:19:59,490
それは我々が気にかけていることは何も返されませんでした - にもかかわらず、として

438
00:19:59,490 --> 00:20:00,820
余談ですが、それは値を返しません。

439
00:20:00,820 --> 00:20:02,650
あなたはただ、一般的にそれを無視する。

440
00:20:02,650 --> 00:20:04,000
printfはちょうど何かをした。

441
00:20:04,000 --> 00:20:06,220
これは、画面に印刷の副作用を持っていた。

442
00:20:06,220 --> 00:20:09,480
ここではそれとは対照的に、我々は、キューブの機能を持っている

443
00:20:09,480 --> 00:20:11,400
実際に何かを返します。

444
00:20:11,400 --> 00:20:12,960
>> だから、これは一般的です - 

445
00:20:12,960 --> 00:20:15,260
これに精通しているために、それはかなり簡単なアイデアだ。

446
00:20:15,260 --> 00:20:18,460
しかし、入力を渡すと取得のこの考えにあまり精通している人のために

447
00:20:18,460 --> 00:20:21,700
背面の出力は、のは単に何か超簡単に試してみましょう。

448
00:20:21,700 --> 00:20:25,180
快適で誰もが簡単にステージに上がって来ている？

449
00:20:25,180 --> 00:20:27,460
あなたにも、あなたのカメラに慣れている必要があります。

450
00:20:27,460 --> 00:20:27,640
うん。

451
00:20:27,640 --> 00:20:28,610
さて、あなたの名前は何ですか？

452
00:20:28,610 --> 00:20:29,020
KEN：ケン。

453
00:20:29,020 --> 00:20:29,420
デイヴィッドJ.マラン：ケン。

454
00:20:29,420 --> 00:20:29,810
すべての権利、ケン。

455
00:20:29,810 --> 00:20:31,060
アップで来る。

456
00:20:31,060 --> 00:20:34,660
だからケンはここにある種の関数であることを行っている。

457
00:20:34,660 --> 00:20:35,760
と先に進み、これを行うことができます。

458
00:20:35,760 --> 00:20:38,790
少し空想を取得してみましょう。

459
00:20:38,790 --> 00:20:39,770
よろしくね。

460
00:20:39,770 --> 00:20:41,010
センターステージへようこそ。

461
00:20:41,010 --> 00:20:41,980
かしこまりました。

462
00:20:41,980 --> 00:20:45,590
のがここでこのボタンを押してみましょう。

463
00:20:45,590 --> 00:20:46,420
かしこまりました。

464
00:20:46,420 --> 00:20:49,490
だからここでは、現代の黒板を持っています。

465
00:20:49,490 --> 00:20:53,050
そして、どのような私は、インスタンスのために、主な機能です。

466
00:20:53,050 --> 00:20:55,990
そして、私は私の手にiPadを持っていない。

467
00:20:55,990 --> 00:20:59,000
私は実際にどのように覚えていない - まあ、実際に、次のことを言うことはできません。

468
00:20:59,000 --> 00:21:02,200
私は本当に良い筆跡を持っていない。

469
00:21:02,200 --> 00:21:05,260
そして、したがって、私はあなたが私のために、画面上に何かを印刷したい。

470
00:21:05,260 --> 00:21:07,470
>> だから私は、メインプログラムであるのです。

471
00:21:07,470 --> 00:21:15,060
そして、私は鶏の傷でそれを書き込むことによって、あなたはこれを言う必要があるとしていますし、

472
00:21:15,060 --> 00:21:16,600
その後、あなたに入力を渡す。

473
00:21:16,600 --> 00:21:20,000
この演習ではあるが愚かなように、関数の概念と呼び出し

474
00:21:20,000 --> 00:21:22,260
その役割と、この機能には本当に沸騰ダウン返す。

475
00:21:22,260 --> 00:21:23,120
私がメインです。

476
00:21:23,120 --> 00:21:26,270
私はちょうど画面に（ "something"）をprintfの書かれている。

477
00:21:26,270 --> 00:21:27,470
私はこのプログラムを実行している。

478
00:21:27,470 --> 00:21:30,900
、一つのパラメタ - とすぐに呼び出されるprintfのように、それは1つの引数を取り

479
00:21:30,900 --> 00:21:31,660
時々 - 

480
00:21:31,660 --> 00:21:32,780
二重引用符の間。

481
00:21:32,780 --> 00:21:33,960
ここではその引数です。

482
00:21:33,960 --> 00:21:35,740
私はケンにそれを渡している。

483
00:21:35,740 --> 00:21:39,390
今、彼はその明らかに数年前のいくつかの番号を書かれたブラックボックスです

484
00:21:39,390 --> 00:21:41,070
画面だけで物事を印刷する方法を知っています。

485
00:21:41,070 --> 00:21:42,320
>> だから、実行してください。

486
00:21:48,842 --> 00:21:49,900
それは悪くはない。

487
00:21:49,900 --> 00:21:50,890
だから、非常に良い。

488
00:21:50,890 --> 00:21:52,900
だから今のケンは、実行中に行われます。

489
00:21:52,900 --> 00:21:55,810
彼は私に何かを手の甲する必要がありますか？

490
00:21:55,810 --> 00:21:57,240
そうではない私たちがこれまで見てきた。

491
00:21:57,240 --> 00:21:59,230
繰り返しになりますが、printfは実際には数値を返しません。

492
00:21:59,230 --> 00:22:01,640
しかし、我々は我々がそれを使ったことがないので、今のところそれを無視しようとしている。

493
00:22:01,640 --> 00:22:03,400
だからケンのためにそれだ。

494
00:22:03,400 --> 00:22:06,650
それで今、メインの実行に戻ってくる - 

495
00:22:06,650 --> 00:22:09,630
主は、そのコード行ので、再度プログラムの制御を引き継ぐ

496
00:22:09,630 --> 00:22:11,010
printfは、実行中に行われます。

497
00:22:11,010 --> 00:22:13,890
そして、我々は他のラインがあるものは何でも実行する我々の方法については行く。

498
00:22:13,890 --> 00:22:14,130
>> かしこまりました。

499
00:22:14,130 --> 00:22:17,080
だから今度は若干異なる例を試してみましょう。

500
00:22:17,080 --> 00:22:22,430
そしてここで、今回は、最初にここに画面をクリアしてみましょう。

501
00:22:22,430 --> 00:22:24,670
そして、この時、私たちはキュービング機能をするつもりだ。

502
00:22:24,670 --> 00:22:27,350
しかし、この時間は、私は出力値を期待しています。

503
00:22:27,350 --> 00:22:28,630
それでは、先に行くとこれを行うことができます。

504
00:22:28,630 --> 00:22:35,680
だから今は、x =キューブ（x）を言うコードの行を持っています。

505
00:22:35,680 --> 00:22:36,930
だから、実際にlet's  - 

506
00:22:41,450 --> 00:22:43,940
コー​​ド、リコール、の行は次のようになります。

507
00:22:43,940 --> 00:22:45,960
X =キューブ（x）である。

508
00:22:45,960 --> 00:22:48,100
だから、これはどのように動作するように起こっている？

509
00:22:48,100 --> 00:22:50,820
それでは、先に行くと、再びあなたに白い画面を与えることができます。

510
00:22:50,820 --> 00:22:55,000
そして、私はそのこの瞬間に、xの値が現在ダウンして書くつもりです

511
00:22:55,000 --> 00:23:01,080
今回は、それをシンプルに保つために、2、としましょう​​することを起こる。

512
00:23:01,080 --> 00:23:04,890
だから私は、紙の上に2の値を書き留めて

513
00:23:04,890 --> 00:23:06,100
これは、私の値xです。

514
00:23:06,100 --> 00:23:08,250
私はケンにそれを手渡す。

515
00:23:08,250 --> 00:23:09,200
KEN：そして私はちょうど答えを書くのか？

516
00:23:09,200 --> 00:23:12,660
デイヴィッドJ.マラン：うん、ただ答えを書きましょう。

517
00:23:12,660 --> 00:23:13,030
オーケー。

518
00:23:13,030 --> 00:23:16,280
そして今、彼は私に何かを返す必要があります。

519
00:23:16,280 --> 00:23:17,560
だから - 

520
00:23:17,560 --> 00:23:18,170
完璧。

521
00:23:18,170 --> 00:23:18,840
セグエニース。

522
00:23:18,840 --> 00:23:21,970
>> だから今、彼は、このケースでは、8の値を教えて手の甲。

523
00:23:21,970 --> 00:23:23,220
そして、私はそれを使って何を行うのですか？

524
00:23:23,220 --> 00:23:26,130
まあ、実際、見てみましょう。

525
00:23:26,130 --> 00:23:26,640
この権利を取得。

526
00:23:26,640 --> 00:23:27,880
私はそれをどうするつもりですか？

527
00:23:27,880 --> 00:23:31,900
今私は、この値を取るつもりだし、実際にそれらに格納

528
00:23:31,900 --> 00:23:33,400
メモリ内の同じビット。

529
00:23:33,400 --> 00:23:35,030
しかし、通知は、私はここで苦労のようなものだ。

530
00:23:35,030 --> 00:23:38,280
ここで私が実際にxの値を書けばいいので、私は少し混乱している？

531
00:23:38,280 --> 00:23:41,840
私は何で行ったのは一枚の紙ケン物理的に手であるため、

532
00:23:41,840 --> 00:23:44,400
それは、xの値が2であったが、あった。

533
00:23:44,400 --> 00:23:46,300
そして実際、それは何が起こるかを正確にです。

534
00:23:46,300 --> 00:23:50,100
だから、あなたが関数を呼び出すときに、あなたは、引数に渡すことが判明

535
00:23:50,100 --> 00:23:54,130
"Hello World"を好むか、またはあなたがしている、一般的には、2のように引数を渡す

536
00:23:54,130 --> 00:23:56,720
その引数のコピーを渡す。

537
00:23:56,720 --> 00:24:01,020
そして、私はここで2番を書き留めたとケンにそれを手渡し同じように、その必要があります

538
00:24:01,020 --> 00:24:04,760
私はまだどこかに値2のコピーを持っていることを意味する。

539
00:24:04,760 --> 00:24:08,140
確かに、今私は、値8を戻して頂いたので、私は後ろに行く必要があるので

540
00:24:08,140 --> 00:24:12,010
RAMと実際には、私は一度番号2を持っていた8を書き留めます。

541
00:24:12,010 --> 00:24:15,720
>> だから視覚的に文字通りに渡すのこの概念を覚えて

542
00:24:15,720 --> 00:24:16,730
値のコピー。

543
00:24:16,730 --> 00:24:19,570
ケンは、彼のことをやって何かを私に手渡した - この場合、

544
00:24:19,570 --> 00:24:20,820
8のような値です。

545
00:24:20,820 --> 00:24:22,660
そして私は私があればその値を持つ何かをしなければならない

546
00:24:22,660 --> 00:24:24,880
それを周りに残しておきたい。

547
00:24:24,880 --> 00:24:29,470
だから、これのすべてはずっと前にあまりにもよく知られているであろう。

548
00:24:29,470 --> 00:24:33,082
ケン、ここでこのデモのために本当にありがとうございました。

549
00:24:33,082 --> 00:24:34,820
かしこまりました。

550
00:24:34,820 --> 00:24:36,720
非常によくやった。

551
00:24:36,720 --> 00:24:40,610
だから最終的には機能の一部に関し、その方法を見てみましょう

552
00:24:40,610 --> 00:24:42,270
ここでやってきたことを呼び出す。

553
00:24:42,270 --> 00:24:47,610
だから私は先に行くと、ここでキュービング例に私たちを連れ戻すことができます。

554
00:24:47,610 --> 00:24:53,080
そして、我々は実際にはさらにこれを服用開始したい場合、我々が行っていることに気付く

555
00:24:53,080 --> 00:24:57,050
番号xを渡されているという事実に留意しなければならないために

556
00:24:57,050 --> 00:25:01,390
ここで実際に関数に渡されているものとは異なります。

557
00:25:01,390 --> 00:25:03,940
だからもう一度、コピーで渡さこれは非常になろうとしています

558
00:25:03,940 --> 00:25:05,620
一瞬でゲルマン。

559
00:25:05,620 --> 00:25:09,320
>> それでは、かなり右まだ動作しません何かを見てみましょう。

560
00:25:09,320 --> 00:25:11,790
私が先に行くと第三バギー例を開くつもりです、その

561
00:25:11,790 --> 00:25:13,560
自然に欠陥がある。

562
00:25:13,560 --> 00:25:18,070
そして、それはbuggy3と呼ばれ、スワッピング機能を実装している。

563
00:25:18,070 --> 00:25:23,500
そこでここでは、xとyが任意に初期化された主な機能を持っている

564
00:25:23,500 --> 00:25:24,720
それぞれ1と2。

565
00:25:24,720 --> 00:25:27,590
我々は、getIntを使用することもできますが、我々は単純な運動が必要。

566
00:25:27,590 --> 00:25:29,680
だから、1と2のように、ハードコードされたのです。

567
00:25:29,680 --> 00:25:35,330
ライン21と22では、我々は明らかに、xとyは、1行に1つずつをプリントアウト。

568
00:25:35,330 --> 00:25:39,620
次に、23行目で、私はドット、ドット、ドット、これらの値を交換していますと主張している。

569
00:25:39,620 --> 00:25:43,030
私は明らかにスワップと呼ばれる24行目の関数を呼び出す

570
00:25:43,030 --> 00:25:44,000
それは二つの引数をとります。

571
00:25:44,000 --> 00:25:46,430
関数は二つの引数を取ることは全く合法的です。

572
00:25:46,430 --> 00:25:48,220
我々は、printf既にそれを行う見てきました。

573
00:25:48,220 --> 00:25:50,370
だからスワップは明らかにxとyをとります。

574
00:25:50,370 --> 00:25:53,010
その名前が示唆するようにと、私はそれが起こっていることを望んでいるでしょう

575
00:25:53,010 --> 00:25:54,320
これら2つの値を交換します。

576
00:25:54,320 --> 00:25:57,560
それでは私はスワップ25行目、上と主張している。

577
00:25:57,560 --> 00:26:01,570
と私は仮定の下で、xとyを転載その

578
00:26:01,570 --> 00:26:02,830
それらは実際に交換されてきました。

579
00:26:02,830 --> 00:26:04,370
しかし、私は実際にこのプログラムを実行する場合 - 

580
00:26:04,370 --> 00:26:06,060
私は、ターミナルウィンドウを開いてみましょう。

581
00:26:06,060 --> 00:26:07,750
私はbuggy3を作ってみましょう。

582
00:26:07,750 --> 00:26:09,970
名前が示すように、これはよく終わろうとしていません。

583
00:26:09,970 --> 00:26:14,690
私はEnterキーを打ったときだって、xが1であることに気づく。

584
00:26:14,690 --> 00:26:15,720
yは2である。

585
00:26:15,720 --> 00:26:19,160
そして、まだ、プログラムの終了時に、彼らは、実際には、今でも同じだ。

586
00:26:19,160 --> 00:26:22,760
>> だから、実際に何が起こっているのケンとはちょうど今実証に基づいて？

587
00:26:22,760 --> 00:26:24,660
さて、このスワップ機能にダイブしてみましょう。

588
00:26:24,660 --> 00:26:25,800
それは超短いです。

589
00:26:25,800 --> 00:26:28,020
それだけで数行のコード長いです。

590
00:26:28,020 --> 00:26:32,810
しかし、話したシンプルな物語に基づいて基本的な問題は何ですか

591
00:26:32,810 --> 00:26:34,270
ここまでケンと？

592
00:26:34,270 --> 00:26:36,115
なぜスワップが壊れている？

593
00:26:36,115 --> 00:26:37,365
[聞こえない]

594
00:26:39,840 --> 00:26:40,460
その通りです。

595
00:26:40,460 --> 00:26:43,610
だから我々はコピーではなく、変数自体に保存している。

596
00:26:43,610 --> 00:26:46,810
言い換えれば、スワップは明らかに2つの引数は、intをとります。

597
00:26:46,810 --> 00:26:49,370
そして、それは、任意に、aとbと呼ばれています。

598
00:26:49,370 --> 00:26:54,430
とここまでは、私はそれぞれ1と2のx、y、で合格しました。

599
00:26:54,430 --> 00:26:56,580
しかし、私は文字通りxに渡していないよ。

600
00:26:56,580 --> 00:26:58,410
私は文字通り、yに渡していないよ。

601
00:26:58,410 --> 00:27:01,230
私はxとyのコピーのコピーを渡している。

602
00:27:01,230 --> 00:27:05,180
あなたがコピーされ、その値をスワップに貼り付けたかのようにそれはほとんどのようなものだ

603
00:27:05,180 --> 00:27:07,440
あなたはそれが実際に操作したい。

604
00:27:07,440 --> 00:27:11,970
それは私は、プログラムは、実行を開始する場合、ですので、もし

605
00:27:11,970 --> 00:27:14,140
35行目は、36  - 

606
00:27:14,140 --> 00:27:17,740
私は37行目に到達したとき、物語の中で、この時点での値は何ですか？

607
00:27:20,740 --> 00:27:24,850
物語のこの時点では、37行目は、この時点での値は何ですか？

608
00:27:24,850 --> 00:27:25,980
だからそれはちょうど1である必要があります。

609
00:27:25,980 --> 00:27:26,170
右か？

610
00:27:26,170 --> 00:27:29,100
xは最初の引数として渡されたため。

611
00:27:29,100 --> 00:27:33,150
そして、この関数は単に任意に、その最初の引数を呼び出しています。

612
00:27:33,150 --> 00:27:35,130
同様にyを、第二引数です。

613
00:27:35,130 --> 00:27:37,930
とそれだけで勝手に第二引数bを呼び出すことと言えます。

614
00:27:37,930 --> 00:27:40,510
>> 今、この二分法は、実際にはかなり簡単に説明されています。

615
00:27:40,510 --> 00:27:40,880
それについて考えてみよう。

616
00:27:40,880 --> 00:27:42,980
我々の誰もprintfの書いた人に会っていない。

617
00:27:42,980 --> 00:27:49,880
だからきっと、彼または彼女は私たちの変数は30年後にいくらになるかわかりません

618
00:27:49,880 --> 00:27:50,710
と呼ばれていました。

619
00:27:50,710 --> 00:27:55,110
ですから、変数の中に呼んでいるものとの間の区別が存在しなければならない

620
00:27:55,110 --> 00:27:59,960
あなたが書いている機能は、あなたがしている関数の中の変数と呼んでいるもの

621
00:27:59,960 --> 00:28:01,770
呼び出しまたは使用。

622
00:28:01,770 --> 00:28:05,120
だから、他の言葉で、私は、xとyのようにmy変数を書かれている。

623
00:28:05,120 --> 00:28:08,060
しかし、他の誰かがスワップ機能を書いていた場合、彼または彼女は、確かに

624
00:28:08,060 --> 00:28:10,480
my変数と呼ばれようとしているのか分からないだろう。

625
00:28:10,480 --> 00:28:13,850
ですから、名前のこの二重性を持っている理由、これはあると認識しています。

626
00:28:13,850 --> 00:28:16,800
技術的には、私は偶然にこれを行うことができます。

627
00:28:16,800 --> 00:28:19,750
しかし、彼らはまだコピーとして渡されるであろう。

628
00:28:19,750 --> 00:28:22,940
それはちょうど書いた審美あの人あれば純粋な偶然だろう

629
00:28:22,940 --> 00:28:25,590
スワップは、同じ名前を使用していた。

630
00:28:25,590 --> 00:28:25,930
>> かしこまりました。

631
00:28:25,930 --> 00:28:29,010
だから物語の中で、この時点で、37行目は、1です。

632
00:28:29,010 --> 00:28:30,410
bは2である。

633
00:28:30,410 --> 00:28:32,040
そして今、私はそれらを交換するために進んでください。

634
00:28:32,040 --> 00:28:34,730
さて、まず第一に、私は実際にははるかに簡単にこれを行うことができます。

635
00:28:34,730 --> 00:28:36,500
私は、これらのコードの3行は何をしていたかわからない。

636
00:28:36,500 --> 00:28:37,370
私はちょうどこれをやってみましょう。

637
00:28:37,370 --> 00:28:38,850
bが取得します。

638
00:28:38,850 --> 00:28:40,170
bを取得します。

639
00:28:40,170 --> 00:28:41,450
完了しました。

640
00:28:41,450 --> 00:28:43,540
なぜこれが、論理的に壊れたのですか？

641
00:28:46,980 --> 00:28:48,590
それは右、直感的なものの一種ですか？

642
00:28:48,590 --> 00:28:50,640
だからBになる。

643
00:28:50,640 --> 00:28:52,450
aとbは次のようになります。

644
00:28:52,450 --> 00:28:55,410
しかし、問題は、37行が実行されるとすぐに、何ということだ

645
00:28:55,410 --> 00:28:58,170
aとbの値はありますか？

646
00:28:58,170 --> 00:28:59,070
1、同じ。

647
00:28:59,070 --> 00:29:03,460
あなたは、いわば破壊されているので、等しくなるようにbを変更しました。

648
00:29:03,460 --> 00:29:06,000
だから一度37行目が実行されると、それは素晴らしいことだ。

649
00:29:06,000 --> 00:29:09,940
ここで、この関数の番号1の内部の2つのコピーを持って。

650
00:29:09,940 --> 00:29:14,720
それでは、あなたは38行目で言うと、Bを取得し、まあ、あなたは同じ種類でねじ込んだ。

651
00:29:14,720 --> 00:29:17,370
あなただけの1から1を代入していますので。

652
00:29:17,370 --> 00:29:20,400
に、どのような種類のあなたが気にかけて価値を失ってしまった。

653
00:29:20,400 --> 00:29:22,910
>> だから、これの元のバージョンでは、私がやったことに気づく。

654
00:29:22,910 --> 00:29:26,620
私の代わりにこのように見えたコードの3行目を持っていた。

655
00:29:26,620 --> 00:29:29,910
私は一時的な変数を宣言する -  tmpは非常に一般的な名前です。

656
00:29:29,910 --> 00:29:31,240
一時変数のため。

657
00:29:31,240 --> 00:29:34,280
それは私がのコピーを作成するものと一致しなければならないので、それはint型です。

658
00:29:34,280 --> 00:29:39,720
私はtmpの内部のコピーを保管してください。だから一度ライン37が実行された、

659
00:29:39,720 --> 00:29:41,390
の値は - 

660
00:29:41,390 --> 00:29:42,970
迅速な健全性チェック - 

661
00:29:42,970 --> 00:29:43,460
1。

662
00:29:43,460 --> 00:29:45,780
bの値は2です。

663
00:29:45,780 --> 00:29:48,470
とTMPの値も1になります。

664
00:29:48,470 --> 00:29:51,470
だから今は、38行目を実行します。

665
00:29:51,470 --> 00:29:57,180
38行目が実行されたら、それで、bの値をとります。

666
00:29:57,180 --> 00:29:58,510
aとbは2であった。

667
00:29:58,510 --> 00:30:00,500
だから今は2です。

668
00:30:00,500 --> 00:30:03,110
だから物語の中で、この時点で、2であり、bは2である

669
00:30:03,110 --> 00:30:05,130
、tmpは1です。

670
00:30:05,130 --> 00:30:09,330
だから今、論理的に、我々はbにちょうどウンチのtmpの値をすることができます。

671
00:30:09,330 --> 00:30:10,690
そして、我々は完了です。

672
00:30:10,690 --> 00:30:12,170
>> だから我々はその問題を解決しました。

673
00:30:12,170 --> 00:30:16,040
残念ながら、私はこの形でこのプログラムを実行するとき、それは実際に交換されません

674
00:30:16,040 --> 00:30:17,700
任意の値。

675
00:30:17,700 --> 00:30:18,950
しかし、明確にすることが、なぜですか？

676
00:30:23,420 --> 00:30:26,310
私はさっきから論理的な問題を修正しました。

677
00:30:26,310 --> 00:30:31,150
私はこのプログラムを実行する場合しかし、再び、、xとyは年末まで変わらない

678
00:30:31,150 --> 00:30:33,834
プログラムの実行。

679
00:30:33,834 --> 00:30:34,760
[聞こえない]

680
00:30:34,760 --> 00:30:36,030
デイヴィッドJ.マラン：だから我々は何も戻っていない。

681
00:30:36,030 --> 00:30:36,960
だからそれは本当だ。

682
00:30:36,960 --> 00:30:39,880
なぜなら、これまでの問題のビットがここにあるのOUTしかし、それが点灯し、

683
00:30:39,880 --> 00:30:42,460
我々は戻ることができてきた唯一のものは1つの事である。

684
00:30:42,460 --> 00:30:46,540
そして、これは、あなただけの本当につの値を返すことができるCの制限です

685
00:30:46,540 --> 00:30:48,970
その場合には、私はここで立ち往生のようなものだ

686
00:30:48,970 --> 00:30:51,805
私はxの新しい値を返すか、または可能性があるため、私は返すことができます

687
00:30:51,805 --> 00:30:53,160
yの新しい値。

688
00:30:53,160 --> 00:30:54,330
しかし、私は両方のバックが欲しい。

689
00:30:54,330 --> 00:30:58,010
だから戻って、ここで単純な解決策ではありません。

690
00:30:58,010 --> 00:30:59,770
しかし、問題は根本的になぜですか？

691
00:30:59,770 --> 00:31:03,270
我々は実際には何を交換している？

692
00:31:03,270 --> 00:31:04,010
とb。

693
00:31:04,010 --> 00:31:07,670
しかし、AとBは、我々はちょうどこれのすべてをやったことを意味し、xとyのコピーです

694
00:31:07,670 --> 00:31:10,080
働く - 私達はちょうどスワップについて話して3分のように過ごした

695
00:31:10,080 --> 00:31:11,680
機能と、これらの変数のすべての3つ。

696
00:31:11,680 --> 00:31:15,090
そして、それは単独で完全に正しい、素晴らしいことだ。

697
00:31:15,090 --> 00:31:20,230
しかし、AとBのスコープはここでしかこれらの行にあります。

698
00:31:20,230 --> 00:31:24,130
だから、forループのようにあなたは私のために内部で整数を宣言した場合

699
00:31:24,130 --> 00:31:27,400
ループ - 同様に、あなたは、その関数の内部にbを宣言している場合

700
00:31:27,400 --> 00:31:30,550
あなたが書いたことは、その関数の内部でのみ有効だ。

701
00:31:30,550 --> 00:31:35,020
どっちが早くスワップの実行が終了するなどの手段と我々はに24行目から行く

702
00:31:35,020 --> 00:31:38,380
25行目は、xとyは全く変更されていない。

703
00:31:38,380 --> 00:31:42,580
あなただけの変数のコピーを交換する時間の全体の多くを無駄にした。

704
00:31:42,580 --> 00:31:46,490
>> だから、これを解決する方法は、実際に非自明であることが判明した。

705
00:31:46,490 --> 00:31:49,210
それは、私たちができるので、値を返すことは全く十分ではありません

706
00:31:49,210 --> 00:31:50,320
1つの値のみを返す。

707
00:31:50,320 --> 00:31:53,370
と私は本当に同時にxとyの両方を交換したいです。

708
00:31:53,370 --> 00:31:55,020
だから我々はこれに戻ってくるつもりだ。

709
00:31:55,020 --> 00:31:58,770
しかし、今のところ、問題は根本的に事実に由来することを認識

710
00:31:58,770 --> 00:32:00,660
aとbがコピーであることを確認します。

711
00:32:00,660 --> 00:32:03,450
そして彼らは自分のスコープ内にあります。

712
00:32:03,450 --> 00:32:04,980
さて、いくつかの方法でこれを解決しようとしてみましょう。

713
00:32:04,980 --> 00:32:09,200
私は実際にここに戻ってスクロールしてみようと開く、第四変形と呼びましょう

714
00:32:09,200 --> 00:32:11,170
このうち、buggy4。

715
00:32:11,170 --> 00:32:13,230
そして、これについてはどうですか？

716
00:32:13,230 --> 00:32:16,690
これは、我々がで刺しを取る前に見て似ていますが、単純な問題である

717
00:32:16,690 --> 00:32:17,530
それを解決する。

718
00:32:17,530 --> 00:32:19,440
このプログラムは、インクリメントと呼ばれています。

719
00:32:19,440 --> 00:32:24,320
そしてそれは明らかに18行目を1にxの整数を初期化します。

720
00:32:24,320 --> 00:32:25,950
私はその後、xが1であると主張している。

721
00:32:25,950 --> 00:32:28,020
私はその後、ドット、ドット、ドット、インクリメントと主張している。

722
00:32:28,020 --> 00:32:29,460
私はその後、インクリメントを呼び出します。

723
00:32:29,460 --> 00:32:33,480
しかし、その後、線22と23で、私はそれがインクリメントされていると主張している。

724
00:32:33,480 --> 00:32:37,780
私はxはおそらく、それが何で今2であると主張する。

725
00:32:37,780 --> 00:32:39,770
>> しかし、このプログラムはバグが多いです。

726
00:32:39,770 --> 00:32:41,020
何が問題なの？

727
00:32:43,450 --> 00:32:44,418
うん？

728
00:32:44,418 --> 00:32:45,668
[聞こえない]

729
00:32:49,260 --> 00:32:49,850
デイヴィッドJ.マラン：その通りです。

730
00:32:49,850 --> 00:32:52,430
だから、xは18行目で明らかに宣言されています。

731
00:32:52,430 --> 00:32:54,410
それがメインの中括弧の中にある。

732
00:32:54,410 --> 00:32:58,470
だからここに簡単な答えはよく、xはここに存在する、ということです。

733
00:32:58,470 --> 00:33:01,510
これは、32行目には存在しません。

734
00:33:01,510 --> 00:33:03,710
したがって、このプログラムは、実際には、コンパイル時にエラーとなります。

735
00:33:03,710 --> 00:33:07,910
コンパイラは、私はこのコードをコンパイルしようとすると、私に向かって怒鳴り起こっている

736
00:33:07,910 --> 00:33:13,190
いくつかの未宣言の識別子またはその旨を何かについて。

737
00:33:13,190 --> 00:33:13,870
実際、やってみよう。

738
00:33:13,870 --> 00:33:15,235
これはbuggy4を作ることです。

739
00:33:17,780 --> 00:33:18,190
そこにそれがある。

740
00:33:18,190 --> 00:33:22,030
32行目で宣言されていない識別子xの使用。

741
00:33:22,030 --> 00:33:25,700
そして実際に、のはこれが有用であるように、今日ここより明確になるであろう

742
00:33:25,700 --> 00:33:27,140
営業時間と自宅で。

743
00:33:27,140 --> 00:33:29,000
それが書かれた暗号のような少しだということに注意してください。

744
00:33:29,000 --> 00:33:31,560
Clangのが言って、私達に怒鳴られたことが、実際

745
00:33:31,560 --> 00:33:36,970
buggy4.c：32:5は、実際に便利です。

746
00:33:36,970 --> 00:33:41,970
これは、エラーが文字位置5で32行目にあることを意味します。

747
00:33:41,970 --> 00:33:44,670
1、2、3、4、5だから。

748
00:33:44,670 --> 00:33:46,640
どこに問題があることは、実際には、です。

749
00:33:46,640 --> 00:33:49,710
また、営業時間や家庭で心に留めておくために、私はここにラッキーだ。

750
00:33:49,710 --> 00:33:50,740
私は一つのミスがあります。

751
00:33:50,740 --> 00:33:52,660
それは修正することは比較的容易になるだろう。

752
00:33:52,660 --> 00:33:56,220
しかし、あなたは再び、圧倒的なエラー·メッセージの完全な画面全体を取得する場合、

753
00:33:56,220 --> 00:33:59,240
一番下の一つだけの症状かもしれないことを認識

754
00:33:59,240 --> 00:34:00,320
最上位のもの。

755
00:34:00,320 --> 00:34:03,560
だから、常にトップダウンからバグを追いかける。

756
00:34:03,560 --> 00:34:06,720
ちょうどあなたを示唆しているデイジーチェーンの効果があるかもしれないので

757
00:34:06,720 --> 00:34:09,030
あなたが実際に行うよりもずっと問題を抱えている。

758
00:34:09,030 --> 00:34:14,989
>> 私の目標は、xをインクリメントする場合ので、どのように我々はこの問題を解決するだろうか？

759
00:34:14,989 --> 00:34:15,370
それは何？

760
00:34:15,370 --> 00:34:15,620
オーケー。

761
00:34:15,620 --> 00:34:16,679
だから我々は、xがグローバルにすることができます。

762
00:34:16,679 --> 00:34:18,860
のは、私が約前の警告のショートカットを見てみましょう。

763
00:34:18,860 --> 00:34:20,550
しかし一体、私達はちょうど簡単な修正を必要としています。

764
00:34:20,550 --> 00:34:23,949
だからここまでのint xを言ってみましょう。

765
00:34:23,949 --> 00:34:25,600
これは、xがグローバルになります。

766
00:34:25,600 --> 00:34:28,460
だから今のメインそれへのアクセスを持っています。

767
00:34:28,460 --> 00:34:31,780
と増分はそれへのアクセスを持っています。

768
00:34:31,780 --> 00:34:33,860
それで、私が先に行くと、すぐにこれをコンパイルしましょう​​。

769
00:34:33,860 --> 00:34:36,330
buggy4を行い、入力します。

770
00:34:36,330 --> 00:34:37,440
今コンパイルしているようだ。

771
00:34:37,440 --> 00:34:40,949
buggy4を実行してみましょう、そしてそれは実際に動作しているようです。

772
00:34:40,949 --> 00:34:42,780
さて、これは、これらのものの一つです - 

773
00:34:42,780 --> 00:34:45,870
私が言うように、私はちょうどここで行ったように、ではなく、私のように行う。

774
00:34:45,870 --> 00:34:49,239
一般的に、我々のプログラムは、はるかに面白くしようとしているので、と

775
00:34:49,239 --> 00:34:50,440
これよりもはるかに長い。

776
00:34:50,440 --> 00:34:53,199
そして人生の問題に対するソリューションがちょうどああされた場合は、すべての配置

777
00:34:53,199 --> 00:34:57,550
あなたのファイルの先頭にある変数は、非常に迅速にプログラムが入手できますか

778
00:34:57,550 --> 00:34:59,700
管理が恐ろしく難しい。

779
00:34:59,700 --> 00:35:02,050
それは、新しい変数名を考えるように難しくなります。

780
00:35:02,050 --> 00:35:05,240
それは、変数が何をやっているかを理解するために難しくなります。

781
00:35:05,240 --> 00:35:08,250
>> それで、一般的に、これは良い解決策ではありません。

782
00:35:08,250 --> 00:35:09,780
それでは、良いこれを行うことができます。

783
00:35:09,780 --> 00:35:11,920
私たちはここで、グローバル変数を使用する必要はありません。

784
00:35:11,920 --> 00:35:14,050
私はxをインクリメントしたいん。

785
00:35:14,050 --> 00:35:16,050
だから、私は明らかでした - 

786
00:35:16,050 --> 00:35:18,450
我々だけでこれを行うために、一日の終わりに、それは愚かな話のようなものだ。

787
00:35:18,450 --> 00:35:22,050
しかし、私はその演算子については知りませんでしたか、私はことが許可されなかった場合

788
00:35:22,050 --> 00:35:27,700
これは、どのように他の私はこっちケンを実装することができ、それ自体メインでそれを変更する

789
00:35:27,700 --> 00:35:31,450
ではないが、キューブへのインクリメントまでの時間？

790
00:35:31,450 --> 00:35:32,700
どのように私はここにこの事を変更するのですか？

791
00:35:32,700 --> 00:35:33,025
うん。

792
00:35:33,025 --> 00:35:34,275
[聞こえない]

793
00:35:37,430 --> 00:35:38,000
デイヴィッドJ.マラン：じゃあ、良い。

794
00:35:38,000 --> 00:35:40,490
では、なぜ私はxに渡しませんか？

795
00:35:40,490 --> 00:35:44,390
そして、むしろそれを返すのではなく、なぜ私はリターンx + 1をちょうどしない？

796
00:35:44,390 --> 00:35:46,370
さて、カップルより多くの事はここで変更する必要があります。

797
00:35:46,370 --> 00:35:47,530
私は正しい軌道に乗ってよ。

798
00:35:47,530 --> 00:35:48,910
私は微調整するために他に何が必要なのですか？

799
00:35:48,910 --> 00:35:49,470
他の誰か。

800
00:35:49,470 --> 00:35:49,882
うん？

801
00:35:49,882 --> 00:35:51,530
[聞こえない]

802
00:35:51,530 --> 00:35:53,520
デイヴィッドJ.マラン：私はインクリメントの戻り値の型を変更する必要が

803
00:35:53,520 --> 00:35:54,590
それがvoidではないので。

804
00:35:54,590 --> 00:35:56,650
ボイドは何も返されませんされていることを意味します。

805
00:35:56,650 --> 00:35:57,600
しかし、明らかに、今ではそれは。

806
00:35:57,600 --> 00:36:01,280
だから、このニーズは何と矛盾しないようにintに変更する

807
00:36:01,280 --> 00:36:02,580
私は実際に戻っています。

808
00:36:02,580 --> 00:36:04,580
>> 今すぐ何か他のものはまだここにバギーです。

809
00:36:04,580 --> 00:36:04,982
うん？

810
00:36:04,982 --> 00:36:06,590
[聞こえない]

811
00:36:06,590 --> 00:36:07,630
デイヴィッドJ.マラン：だから私は、xをインクリメントする必要がありますか？

812
00:36:07,630 --> 00:36:10,336
[聞こえない]

813
00:36:10,336 --> 00:36:11,880
デイヴィッドJ.マラン：ああ、私はxを渡す必要があります。

814
00:36:11,880 --> 00:36:13,300
だから私はここにこれを行う必要があります。

815
00:36:17,590 --> 00:36:19,690
プロトタイプだから、私はここにこれを設定変更する必要があります。

816
00:36:19,690 --> 00:36:21,290
だから、これはint型になることがあります。

817
00:36:21,290 --> 00:36:22,820
これはなっている - 

818
00:36:22,820 --> 00:36:23,670
うーん。

819
00:36:23,670 --> 00:36:24,710
私は実際にここにバグを持っています。

820
00:36:24,710 --> 00:36:25,780
のは、最初にこの1を修正しましょう​​。

821
00:36:25,780 --> 00:36:27,990
これは実際には何をすべきか？

822
00:36:27,990 --> 00:36:29,330
だからそれはint何かがあるはずだ。

823
00:36:29,330 --> 00:36:30,340
それはxである可能性があります。

824
00:36:30,340 --> 00:36:33,120
あなたが変数xのすべての呼び出しを開始した場合でも、率直に言って、それは得るために起こっている

825
00:36:33,120 --> 00:36:35,250
少なく明確なこれはどちらです。

826
00:36:35,250 --> 00:36:38,210
だから勝手に私のために、異なる命名規則を選択してみましょう

827
00:36:38,210 --> 00:36:40,220
ヘルパー関数は、私が書いている機能。

828
00:36:40,220 --> 00:36:41,100
我々はそれと呼ぶことにします。

829
00:36:41,100 --> 00:36:44,500
あるいは、我々はそれを呼び出すことができます - のは、それがさらに明示的にするためにeven_number呼ぶことにしましょう​​。

830
00:36:44,500 --> 00:36:47,610
それでは私は数がプラス1であるものは何でも返す必要があります。

831
00:36:47,610 --> 00:36:49,720
そして今、私はここに1つの他の事を変更する必要が

832
00:36:49,720 --> 00:36:50,700
ここで他の事まで。

833
00:36:50,700 --> 00:36:54,150
私は、最初の21行目に変更するには何がありますか？

834
00:36:54,150 --> 00:36:55,390
私はそれをxに代入する必要があります。

835
00:36:55,390 --> 00:36:57,480
だから、僕はインクリメントxを呼び出すことはできません。

836
00:36:57,480 --> 00:37:01,000
私は上のxの値を変更することで答えを覚えておく必要があります

837
00:37:01,000 --> 00:37:02,020
左側。

838
00:37:02,020 --> 00:37:04,930
とxが左と右に今あるにもかかわらず、それがため、全く大丈夫です

839
00:37:04,930 --> 00:37:08,370
右側が最初に実行されるから、左にそのまま流しこむれる

840
00:37:08,370 --> 00:37:10,240
手の事、ここではX。

841
00:37:10,240 --> 00:37:11,900
そして、最後に、これは今では簡単な修正です。

842
00:37:11,900 --> 00:37:15,080
これは、ちょうど下の何ダウンだと一致する必要があります。

843
00:37:15,080 --> 00:37:17,120
int型の数値。

844
00:37:17,120 --> 00:37:17,320
>> かしこまりました。

845
00:37:17,320 --> 00:37:20,290
本当に愚かな関数の変化の全体の束だから。

846
00:37:20,290 --> 00:37:24,250
しかし、我々はますますやりたいだろうというものの代表。

847
00:37:24,250 --> 00:37:25,490
だからbuggy4を作る。

848
00:37:25,490 --> 00:37:26,485
私はどこかでしくじった。

849
00:37:26,485 --> 00:37:27,520
オーマイゴッド。

850
00:37:27,520 --> 00:37:29,660
の5つの​​間違い、のように、6行のプログラム。

851
00:37:29,660 --> 00:37:36,500
だから18行、文字5日に何が悪いの？

852
00:37:36,500 --> 00:37:36,970
かしこまりました。

853
00:37:36,970 --> 00:37:39,330
だから私はこのint型を宣言する必要があります。

854
00:37:39,330 --> 00:37:39,630
かしこまりました。

855
00:37:39,630 --> 00:37:41,790
それでは、他のエラーの全体の束を見てみましょう。

856
00:37:41,790 --> 00:37:42,230
オーマイゴッド。

857
00:37:42,230 --> 00:37:43,880
19、18、21。

858
00:37:43,880 --> 00:37:46,020
しかし、再び、ただ画面をクリアしてみましょう - 

859
00:37:46,020 --> 00:37:48,660
コントロールここでL  - と再実行Clangの。

860
00:37:48,660 --> 00:37:51,340
だから、5つの問題は、実際にはちょうどその一つです。

861
00:37:51,340 --> 00:37:53,500
だから今のEnter、buggy4を実行してみましょう。

862
00:37:53,500 --> 00:37:54,150
やれやれ。

863
00:37:54,150 --> 00:37:57,434
xが正しくインクリメントされている。

864
00:37:57,434 --> 00:37:58,420
>> かしこまりました。

865
00:37:58,420 --> 00:38:01,700
数字をインクリメントする方法について何か質問はありますか？

866
00:38:01,700 --> 00:38:02,896
うん？

867
00:38:02,896 --> 00:38:06,864
スピーカー2：なぜそれはあなただけで変数に数値にxを変更することができるということです

868
00:38:06,864 --> 00:38:08,860
名前、それはあなたが何を意味するか知っているでしょう？

869
00:38:08,860 --> 00:38:09,600
デイヴィッドJ.マラン：良い質問です。

870
00:38:09,600 --> 00:38:13,130
それは私はただの数字にxを変更することができますし、プログラムが知っているだろうことになりますよ

871
00:38:13,130 --> 00:38:13,990
すぐに？

872
00:38:13,990 --> 00:38:16,120
だからもう一度、この抽象化と考えることもできます。

873
00:38:16,120 --> 00:38:20,110
私がメインですし、ケンは増分がないような場合は、率直に言って、私は気にしない

874
00:38:20,110 --> 00:38:21,540
ケンは彼のiPadと呼んでいるもの。

875
00:38:21,540 --> 00:38:25,350
私は彼が彼の実装に関係している何と呼んでいるものを気にしない

876
00:38:25,350 --> 00:38:26,550
この機能の。

877
00:38:26,550 --> 00:38:32,130
だから、これは私は、メインではなく、やることを、実装の詳細です

878
00:38:32,130 --> 00:38:33,010
気にする必要があります。

879
00:38:33,010 --> 00:38:37,440
それで、単に数が、ここでは一貫して内部関数のそれを変更

880
00:38:37,440 --> 00:38:41,340
そしてここ数は、それは私が再コンパイルする限り、かかる時間です。

881
00:38:41,340 --> 00:38:43,820
あなたが考えてみれば、それは希望のようなものだ - 私たちの多くは、運転免許を持つあなたのそれらの

882
00:38:43,820 --> 00:38:46,590
運転したか、あなたも車の中で運転した場合、ライセンス - 

883
00:38:46,590 --> 00:38:50,710
私たちのほとんどは、車がボンネットの下にどのように動作するか見当がつかない。

884
00:38:50,710 --> 00:38:54,710
あなたがフード、私たちのほとんどを開く場合、文字通り、 - 私自身を含めて - 

885
00:38:54,710 --> 00:38:56,580
本当に我々が探しているものを知っているつもりはありません。

886
00:38:56,580 --> 00:38:58,850
あなたが今、このようなものと感じるかもしれないようなもの。

887
00:38:58,850 --> 00:39:01,380
しかし、我々は本当に車がどのように動作するかを気にする必要はありません。

888
00:39:01,380 --> 00:39:05,000
私たちは何の内部ロッドとピストンとすべてのケーブル気にする必要はありません

889
00:39:05,000 --> 00:39:07,700
車は実際にやっている。

890
00:39:07,700 --> 00:39:11,360
>> ですから、ピストンと呼んでいるもののような何かは問題ではありません

891
00:39:11,360 --> 00:39:11,920
ここで、この場合インチ

892
00:39:11,920 --> 00:39:12,490
同じ考え。

893
00:39:12,490 --> 00:39:12,670
うん？

894
00:39:12,670 --> 00:39:13,920
[聞こえない]

895
00:39:25,250 --> 00:39:29,530
デイヴィッドJ.マラン：変数XAモーメントのより用途が前にあった場合は、

896
00:39:29,530 --> 00:39:32,220
あなたは、プログラマが、どこでもそれらを変更する必要があります。

897
00:39:32,220 --> 00:39:35,230
それとも、文字通り、ファイル、メニューの操作を行い、[検索/置換ができる

898
00:39:35,230 --> 00:39:36,270
そのような何か。

899
00:39:36,270 --> 00:39:40,110
しかし、あなたはそれらの変更を自分で作る必要があるとしている。

900
00:39:40,110 --> 00:39:41,200
あなたは一貫している必要があります。

901
00:39:41,200 --> 00:39:42,450
[聞こえない]

902
00:39:47,200 --> 00:39:48,960
デイヴィッドJ.マラン：ここのような特定の順序？

903
00:39:48,960 --> 00:39:52,660
これは、int、別の番号であった場合はどうなりますか？

904
00:39:52,660 --> 00:39:52,940
うん。

905
00:39:52,940 --> 00:39:56,430
関数を呼び出しているときだから順序が問題になります。

906
00:39:56,430 --> 00:40:00,350
だから私は、何かコンマ何かでここに増分を呼び出していた場合、

907
00:40:00,350 --> 00:40:01,400
ダイレクトマッピングがあります。

908
00:40:01,400 --> 00:40:04,490
最初の変数は、それが呼ばれるものは何でも、最初のコピーが作られる

909
00:40:04,490 --> 00:40:05,480
こっち引数。

910
00:40:05,480 --> 00:40:07,280
申し訳ありませんが、これは括弧であってはならない。

911
00:40:07,280 --> 00:40:09,300
二番目と二番目の引数ラインアップ。

912
00:40:09,300 --> 00:40:11,220
>> オーダーだから、そう、事項。

913
00:40:11,220 --> 00:40:11,490
かしこまりました。

914
00:40:11,490 --> 00:40:13,360
すみません、私はそこに着くために長い道のりを取った。

915
00:40:13,360 --> 00:40:14,610
その他の質問は？

916
00:40:16,460 --> 00:40:16,850
かしこまりました。

917
00:40:16,850 --> 00:40:20,300
だから我々は、実際に何が起こっているの絵を描くことができないかどうかを確認してみましょう

918
00:40:20,300 --> 00:40:22,160
ここでフードの下に、いわば。

919
00:40:22,160 --> 00:40:26,310
だから、これは、コンピュータのメモリを表すかもしれません四角形です。

920
00:40:26,310 --> 00:40:31,240
少なくともあなたは、メモリがどう機能し、どのメモリがどのように機能するか見当がつかないので、たとえ

921
00:40:31,240 --> 00:40:33,590
あなたは、これらの日それの束を持っていることを前提としています。

922
00:40:33,590 --> 00:40:34,740
あなたはそれのメガバイトを持っている。

923
00:40:34,740 --> 00:40:35,760
あなたはそれのギガバイトを持っている。

924
00:40:35,760 --> 00:40:40,690
そして、我々はバイトだけで何であることを、0週目から知っていますか？

925
00:40:40,690 --> 00:40:41,280
8ビット。

926
00:40:41,280 --> 00:40:42,730
右ので、8ゼロと。

927
00:40:42,730 --> 00:40:46,300
お使いのコンピュータは、これらの日のRAMのギグは、RAMの2ギグを持っている場合だから、あなたが持っている

928
00:40:46,300 --> 00:40:54,450
メモリの億または20億バイト、または約8億160億

929
00:40:54,450 --> 00:40:56,560
ビットは、コンピュータの内部。

930
00:40:56,560 --> 00:40:59,710
少し長毛のウィリーの例とは違って今は、磁性粒子ではありません

931
00:40:59,710 --> 00:41:00,560
一般的にはもう。

932
00:41:00,560 --> 00:41:04,470
ますます、少なくともラップトップで、それは、ソリッドステートドライブ、SSD、それだ

933
00:41:04,470 --> 00:41:05,560
ただ可動部分を持たない。

934
00:41:05,560 --> 00:41:06,710
それは、すべての電子です。

935
00:41:06,710 --> 00:41:08,070
それは基づいて、すべての電気です。

936
00:41:08,070 --> 00:41:12,360
ちょうど1つまたは2つを表すように、この矩形の、しかし、思う

937
00:41:12,360 --> 00:41:13,930
あなたが持っているメモリのギガバイト。

938
00:41:13,930 --> 00:41:15,500
>> だから、メモリの塊だ。

939
00:41:15,500 --> 00:41:20,460
今ではコンピュータサイエンスの世界では、の仕切ら塊のようなものを持っている

940
00:41:20,460 --> 00:41:22,570
さまざまなことを行うためのメモリ。

941
00:41:22,570 --> 00:41:25,930
これはコンピュータのRAMがないような場合は、例えば、 - などによって提案された

942
00:41:25,930 --> 00:41:30,400
そこに矩形が - ので、あなたのRAMの最上部に、慣例により、そのが判明

943
00:41:30,400 --> 00:41:33,170
話すように、テキストセグメントと呼ばれるものが一般的である。

944
00:41:33,170 --> 00:41:35,910
それらはあなたがコンパイルしたゼロとされています。

945
00:41:35,910 --> 00:41:39,040
だから我々は、a.outが何であるかでフードの下に見てきたときに、すべての

946
00:41:39,040 --> 00:41:40,360
ゼロと - 

947
00:41:40,360 --> 00:41:44,000
あなたがプログラムを実行するときに、それらのゼロとは、ハードディスクからロードされます

948
00:41:44,000 --> 00:41:46,290
RAMと呼ばれるものにドライブ。

949
00:41:46,290 --> 00:41:48,950
とRAMに、それらは上部に入れている。

950
00:41:48,950 --> 00:41:50,330
今すぐ一方、あなたは他のものを持っている。

951
00:41:50,330 --> 00:41:53,060
初期化データ、未初期化データ。

952
00:41:53,060 --> 00:41:56,440
メモリのあの二スワスは、グローバル変数を参照している

953
00:41:56,440 --> 00:41:57,530
あなたが頻繁に使用しないでください。

954
00:41:57,530 --> 00:42:00,630
あなたがしなければしかし、時には、彼らは同様にそこまで終わる。

955
00:42:00,630 --> 00:42:01,620
次に、いくつかの他のものがあります。

956
00:42:01,620 --> 00:42:04,130
私たちは多くの時間を費やすことはありません環境変数、。

957
00:42:04,130 --> 00:42:06,120
しかし、その後、この全体に戻ってくるだろう、2つの重要な

958
00:42:06,120 --> 00:42:08,130
学期、スタックとヒープ。

959
00:42:08,130 --> 00:42:12,280
>> ためのプログラムを実行するときに、コンピュータのメモリのほとんどが予約されています

960
00:42:12,280 --> 00:42:14,880
何かがスタックとヒープと呼ばれるものを呼んだ。

961
00:42:14,880 --> 00:42:16,940
そして、我々は今日のヒープについて話をするつもりはないが、我々は意志

962
00:42:16,940 --> 00:42:18,180
スタックについて話しています。

963
00:42:18,180 --> 00:42:22,910
とスタックはダイニングホールなどのビジュアルを想起させることを意図している

964
00:42:22,910 --> 00:42:26,120
マザーハウス、またはどこでもあなたがすることが起こる、で食事トレー

965
00:42:26,120 --> 00:42:27,810
ダイニングホールスタッフは毎日掃除をしてください。

966
00:42:27,810 --> 00:42:30,180
彼らは上の階からそれらを積み重ねる。

967
00:42:30,180 --> 00:42:33,800
と同様に、メモリ内に何かを入れてのこの考えがある

968
00:42:33,800 --> 00:42:36,740
スタックは、スタック上に何かを入れて、スタック上に何かを置く。

969
00:42:36,740 --> 00:42:38,000
そして、我々はこれで何を意味するのですか？

970
00:42:38,000 --> 00:42:41,430
さて、のこの絵のちょうど下半分をズームイン、あなたのコンピュータにしましょう

971
00:42:41,430 --> 00:42:43,990
RAMは、次のように提案する。

972
00:42:43,990 --> 00:42:48,300
それはあなたがa.outのようなプログラムを実行したり、helloとき、何が判明

973
00:42:48,300 --> 00:42:49,920
このプログラムは、あなたが書いたということです

974
00:42:49,920 --> 00:42:53,030
再び、これらのゼロとは、ハードドライブからロードされている - である

975
00:42:53,030 --> 00:42:56,190
長期記憶は、プラグを抜いた場合でもそこに留まる - 

976
00:42:56,190 --> 00:42:57,220
RAMにロードされます。

977
00:42:57,220 --> 00:42:59,020
RAMはハードドライブよりも高速です。

978
00:42:59,020 --> 00:43:00,700
これは、ハードドライブに比べて小さいです。

979
00:43:00,700 --> 00:43:03,490
あなたがそれらを実行している間にプログラムがどこに住んでますが、それは。

980
00:43:03,490 --> 00:43:06,380
>> それで、あなたは二重のMacまたはPC上のプログラムをクリックします - それはから読み込ま

981
00:43:06,380 --> 00:43:07,750
RAMにハード·ドライブ。

982
00:43:07,750 --> 00:43:11,760
それがRAMにロードされるとすぐに、ゼロとは、道の一番上に行く

983
00:43:11,760 --> 00:43:13,130
いわゆるテキストセグメント。

984
00:43:13,130 --> 00:43:17,040
しかし、その後、できるだけ早くあなたのプログラムが実際に実行して起動すると、メイン

985
00:43:17,040 --> 00:43:18,140
関数が呼び出されます。

986
00:43:18,140 --> 00:43:21,070
そしてメインは、これまで見てきたように、多くの場合、ローカル変数を持っています。

987
00:43:21,070 --> 00:43:24,560
そして、それは整数や文字列と文字などがあります。

988
00:43:24,560 --> 00:43:28,300
だからあなたのあなたが書いたプログラムまたはあなたが持っているプログラムの場合

989
00:43:28,300 --> 00:43:33,680
ダブルがメインの内のいくつかの変数を使用してクリックすると、彼らはで終わる

990
00:43:33,680 --> 00:43:37,020
いわば記憶のあなたのスタックの底、。

991
00:43:37,020 --> 00:43:39,160
今ではより具体的には、これは実際に何を意味するのか？

992
00:43:39,160 --> 00:43:44,080
これはちょうど私達が多数に物事を行っていた場合ことを意味します - 

993
00:43:44,080 --> 00:43:49,380
我々は、コンピュータ内の数値RAMのバイトをしようとしている場合は、気付くこと

994
00:43:49,380 --> 00:43:51,650
これは、バイト数がゼロであるかもしれません。

995
00:43:51,650 --> 00:43:56,130
これは、バイト数は1、2、3、4、5、6、すべての可能性があります

996
00:43:56,130 --> 00:43:57,290
好きに至るまで - 

997
00:43:57,290 --> 00:44:01,520
20億までそこに上部のすべての方法であろう。

998
00:44:01,520 --> 00:44:05,960
だから、他の言葉で、私たちは、バイト単位でRAMやメモリの話、それ

999
00:44:05,960 --> 00:44:09,680
ちょうど誰かが何番それぞれのすることを決定したことを意味します

1000
00:44:09,680 --> 00:44:11,110
メモリのそれらの塊。

1001
00:44:11,110 --> 00:44:16,950
>> ですから、intの32ビットを必要とするとき、またはあなたは、charは8ビット、どこが必要

1002
00:44:16,950 --> 00:44:18,320
彼らは、メモリ内に終わるのですか？

1003
00:44:18,320 --> 00:44:20,650
まあ概念的には、彼らはちょうどこれの一番下になってしまう

1004
00:44:20,650 --> 00:44:21,780
ことは、スタックと呼ば​​れる。

1005
00:44:21,780 --> 00:44:25,670
メインは、関数を呼び出したときにしかし、何今面白いのはある。

1006
00:44:25,670 --> 00:44:28,830
、ちょうど任意の名前をfooという関数を仮定します。

1007
00:44:28,830 --> 00:44:32,480
このメモリのスタックの底に何が起こるメインです。

1008
00:44:32,480 --> 00:44:35,630
fooは今やメモリにメインの上に置かれます。

1009
00:44:35,630 --> 00:44:40,020
fooは一種の概念的上記の端を持っているすべてのローカル変数は、そう

1010
00:44:40,020 --> 00:44:40,770
メインのもの。

1011
00:44:40,770 --> 00:44:46,920
fooはbarと呼ばれる別の関数を呼び出す場合、これらの変数はここにたどり着く。

1012
00:44:46,920 --> 00:44:49,790
バーでは、こことここに何か他のものを、ここで、呼び出した場合。

1013
00:44:49,790 --> 00:44:53,900
それでは、プログラムを実行して興味深いのは、あなたが関数を呼び出すようなことです

1014
00:44:53,900 --> 00:44:57,720
それらの関数は、関数を呼び出すように、それらの関数は、関数を呼び出すように、

1015
00:44:57,720 --> 00:45:00,980
あなたは、メモリ内の関数のこのスタックを構築します。

1016
00:45:00,980 --> 00:45:06,740
そして唯一の関数の復帰後は、そのメモリを取り戻す始めるのですか。

1017
00:45:06,740 --> 00:45:11,190
だから、コンピュータプログラムでメモリが不足する最も簡単な方法のひとつとして、

1018
00:45:11,190 --> 00:45:14,170
決して戻らない関数を記述します。

1019
00:45:14,170 --> 00:45:16,650
>> だから例えば、のはと同じくらい発揮させ

1020
00:45:16,650 --> 00:45:18,460
意図的にバグのあるプログラム。

1021
00:45:18,460 --> 00:45:24,690
私が先に行くと＃<stdio.h>を、int型のmain（void）を含めるやってみましょう。

1022
00:45:24,690 --> 00:45:31,270
そして、私は何をしようとしている間、おそらくいないでしょう今までに（2> 1）、

1023
00:45:31,270 --> 00:45:33,370
私たちの上に変更します。

1024
00:45:33,370 --> 00:45:37,720
そして、私は今、先に行くとprintfやらせる。

1025
00:45:37,720 --> 00:45:39,950
実際のところ、それは少なく視覚的に面白いことになるだろう。

1026
00:45:39,950 --> 00:45:40,460
これを実行してみましょう。

1027
00:45:40,460 --> 00:45:44,840
int型は、（i = 0; i> 0の）。

1028
00:45:44,840 --> 00:45:49,740
この間違いを犯してみましょう、i + +は。

1029
00:45:49,740 --> 00:45:51,150
そしてここでのprintfないようにしましょう​​。

1030
00:45:51,150 --> 00:45:52,550
私が説教されたことを実践してみましょう。

1031
00:45:52,550 --> 00:45:54,090
のがここでのメソッドを持ってみましょう。

1032
00:45:54,090 --> 00:46:00,860
ボイドコーラス、そして我々はint型私と言うでしょう。

1033
00:46:00,860 --> 00:46:02,295
そして私は、printf、言おうとしている - 

1034
00:46:04,871 --> 00:46:06,790
ああ、のは、これはもっと面白くしましょう​​。

1035
00:46:06,790 --> 00:46:08,350
実際にはまったく何も印刷されませましょう。

1036
00:46:08,350 --> 00:46:10,530
ただ、これをやってみましょう。

1037
00:46:10,530 --> 00:46:11,780
コー​​ラスは、（i）。

1038
00:46:16,630 --> 00:46:17,000
>> かしこまりました。

1039
00:46:17,000 --> 00:46:20,040
なぜので、だから、これはバグですか？

1040
00:46:20,040 --> 00:46:22,850
私が行くように、プログラムが実際には何も行いませんので、私はこれを作ってるんだ

1041
00:46:22,850 --> 00:46:23,420
興味のある。

1042
00:46:23,420 --> 00:46:24,670
しかし、それはゴールではありません。

1043
00:46:24,670 --> 00:46:30,440
目標は、明らかに、その主な機能は何を行うプログラムを書くことですか？

1044
00:46:30,440 --> 00:46:31,370
自分自身を呼び出す。

1045
00:46:31,370 --> 00:46:32,600
そして、実際に、我々はループを必要としません。

1046
00:46:32,600 --> 00:46:36,070
でも、これはただのように本当にを見失わないように簡略化してみましょう

1047
00:46:36,070 --> 00:46:37,310
根本的なバグを修正しました。

1048
00:46:37,310 --> 00:46:39,200
主要ないくつかのコーラスを歌うコーラスを呼び出します。

1049
00:46:39,200 --> 00:46:41,760
それから私は、愚かなことをした、と私は仮定したので、私はコーラス·コールコーラスを持っていた

1050
00:46:41,760 --> 00:46:43,550
他の誰かが多分それを実装するつもりだった。

1051
00:46:43,550 --> 00:46:45,960
そして今、これはまだコンパイルするつもりはない。

1052
00:46:45,960 --> 00:46:48,340
私は何をする必要がありますか？

1053
00:46:48,340 --> 00:46:49,700
私はプロトタイプを必要とする、覚えています。

1054
00:46:49,700 --> 00:46:55,520
だから私はここにボイドコーラス（int iを）を持っている必要があります;

1055
00:46:55,520 --> 00:46:57,470
>> だから今、私はここでダウンした場合 - 

1056
00:46:57,470 --> 00:46:59,030
実際には、大きな窓を使用してみましょう。

1057
00:46:59,030 --> 00:47:01,670
先に進み、合唱を作ってみましょう。

1058
00:47:01,670 --> 00:47:06,000
先に進み、合唱を作ってみましょう。

1059
00:47:06,000 --> 00:47:08,302
正体不明のディクレアラーIの使用。

1060
00:47:08,302 --> 00:47:09,860
ああ、それは愚かだった。

1061
00:47:09,860 --> 00:47:11,020
我々は、引数を必要としません。

1062
00:47:11,020 --> 00:47:13,680
ただ、これをやってみましょう。

1063
00:47:13,680 --> 00:47:14,550
我々はこのように始まっていたと思います。

1064
00:47:14,550 --> 00:47:16,160
それが書きやすくプログラムされていると思います。

1065
00:47:16,160 --> 00:47:20,100
だからそこ。

1066
00:47:20,100 --> 00:47:23,870
今度は、私の端末ウィンドウに渡って行こう、再実行Clangの。

1067
00:47:23,870 --> 00:47:26,900
そして、ここに私達は行く。

1068
00:47:26,900 --> 00:47:28,020
それは本当に速かった。

1069
00:47:28,020 --> 00:47:30,690
実際に何がちょうどしかし、起こったのか？

1070
00:47:30,690 --> 00:47:33,430
さて、今私は、印刷行を追加しますので、我々は見ることができます。

1071
00:47:33,430 --> 00:47:41,330
だから私はここにいる、としましょう​​、私はprintfとしましょう​​。

1072
00:47:41,330 --> 00:47:43,470
さて、何の変数は、我々はそのようにそれを残さないでしょう。

1073
00:47:43,470 --> 00:47:44,860
私は、再実行してみましょう。

1074
00:47:44,860 --> 00:47:47,940
再実行してコーラスさせて頂いております。

1075
00:47:47,940 --> 00:47:51,235
それになんといっても。

1076
00:47:53,880 --> 00:47:55,130
続ける。

1077
00:47:57,630 --> 00:47:59,750
余談ですが、なぜそれがまだクラッシュしていない？

1078
00:47:59,750 --> 00:48:02,050
セグメンテーションフォールトは前に超高速で起こった。

1079
00:48:02,050 --> 00:48:04,250
[聞こえない]

1080
00:48:04,250 --> 00:48:04,830
デイヴィッドJ.マラン：その通りです。

1081
00:48:04,830 --> 00:48:06,350
だから、印刷に時間がかかります。

1082
00:48:06,350 --> 00:48:08,370
それはちょうど、コンピュータの一部に多くの作業を要する。

1083
00:48:08,370 --> 00:48:09,550
そしてそこにはある。

1084
00:48:09,550 --> 00:48:10,620
セグメンテーションフォールト。

1085
00:48:10,620 --> 00:48:12,140
>> だから、プログラムを実行にどれだけ早く気づく。

1086
00:48:12,140 --> 00:48:14,110
あなたは何も、超高速の印刷をしていない場合。

1087
00:48:14,110 --> 00:48:18,100
しかし、我々はまだ何が起こっていたので、このセグメンテーションフォールトを得たか。

1088
00:48:18,100 --> 00:48:21,310
さて、あなたは、コンピュータのメモリがどのようにレイアウトされるか、これを考えれば

1089
00:48:21,310 --> 00:48:22,890
主であることを起こる。

1090
00:48:22,890 --> 00:48:23,800
しかし、ここに - 

1091
00:48:23,800 --> 00:48:28,670
聞かせはちょうどこのコーラスを呼び出して、このコーラスを呼び出してみましょう。

1092
00:48:28,670 --> 00:48:33,420
そして今、私は右の私の美学をすれば、これはただのコーラスを言おうとしている、

1093
00:48:33,420 --> 00:48:38,060
コー​​ラス、合唱、コーラス、合唱、コーラス、コーラス、広告nauseum。

1094
00:48:38,060 --> 00:48:39,920
そして最終的に、何が起こるだろう？

1095
00:48:39,920 --> 00:48:46,690
大きな絵は文字通り概念的に何が起こるか、これですか？

1096
00:48:46,690 --> 00:48:48,320
スタックオーバーランヒープ。

1097
00:48:48,320 --> 00:48:52,400
または悪いことに、あなただけでテキストセグメントを含むすべてが、オーバーラン

1098
00:48:52,400 --> 00:48:54,530
あなたのプログラムを表すゼロと。

1099
00:48:54,530 --> 00:48:56,690
要するに、これは単にスーパー、超悪いです。

1100
00:48:56,690 --> 00:48:56,860
右か？

1101
00:48:56,860 --> 00:48:58,620
あなたのプログラムが暴走螺旋た。

1102
00:48:58,620 --> 00:49:02,840
あなたの道をあなたが愚かな理由の全てを意図したよりも多くのメモリを使用している

1103
00:49:02,840 --> 00:49:03,920
この場合は間違い。

1104
00:49:03,920 --> 00:49:08,160
このケースで、非常に意図的に行わ関数は自分自身を呼び出す。

1105
00:49:08,160 --> 00:49:09,210
さて、これはすべての不良ではありません。

1106
00:49:09,210 --> 00:49:12,540
自分自身を呼び出している関数は、実際には偉大な力を持っている

1107
00:49:12,540 --> 00:49:13,700
あなたはそれを正しく使用した場合。

1108
00:49:13,700 --> 00:49:15,650
私はここでそれを正しく使用していない。

1109
00:49:15,650 --> 00:49:16,940
>> だから、これはすべての不良ではありません。

1110
00:49:16,940 --> 00:49:20,620
しかし、私は実際に自分自身の呼び出しを止めることはないという事実は、基本である

1111
00:49:20,620 --> 00:49:23,050
ここでは、このプログラムの弱点。

1112
00:49:23,050 --> 00:49:25,090
だから我々はこのすべてにどこへ行くのか？

1113
00:49:25,090 --> 00:49:26,230
まあ、本当に何が起こっている？

1114
00:49:26,230 --> 00:49:30,010
我々はこれらの例でやっていたように私は、インクリメント関数を呼び出すと、

1115
00:49:30,010 --> 00:49:33,290
私が渡した1インチのような値を持っている

1116
00:49:33,290 --> 00:49:35,820
私はナンバーワンのコピーを渡します。

1117
00:49:35,820 --> 00:49:37,080
だから、次のことが起こります。

1118
00:49:37,080 --> 00:49:40,390
それでは、インクリメント例に手放す。

1119
00:49:40,390 --> 00:49:44,230
こっち右、この男。

1120
00:49:44,230 --> 00:49:46,800
そこでここでは、実際に何が起こっているかだ。

1121
00:49:46,800 --> 00:49:50,770
何だ絵で、私はインクリメントと呼ばれ、私はxを渡すと

1122
00:49:50,770 --> 00:49:53,660
ここで起こってこれは - 

1123
00:49:53,660 --> 00:50:00,240
私はここに格納され、1の値を持っており、私が実際にインクリメントを呼び出す場合、その

1124
00:50:00,240 --> 00:50:02,680
今コーラスと呼ばれる - 

1125
00:50:02,680 --> 00:50:04,010
ええ、それは私をここに投げている。

1126
00:50:04,010 --> 00:50:06,750
それでは、この増分を呼ぶことにしましょう​​。

1127
00:50:06,750 --> 00:50:09,420
そして、我々は、この次の関数があることを行っているのか分からない。

1128
00:50:09,420 --> 00:50:14,270
だから、実際に何が起こっているのは、メインのどこかにここにある、私がの塊を持っている

1129
00:50:14,270 --> 00:50:16,670
番号1を格納しているメモリ。

1130
00:50:16,670 --> 00:50:19,730
私はインクリメントを呼び出すときに、私はメモリの別のチャンクを使用したが、今私がしています

1131
00:50:19,730 --> 00:50:20,840
1のコピーを持っている。

1132
00:50:20,840 --> 00:50:25,480
私は、その値をインクリメントすると、この値は2になります - 恐ろしくに書か

1133
00:50:25,480 --> 00:50:26,420
ここに画面が表示されます。

1134
00:50:26,420 --> 00:50:30,550
しかし、その後、何がインクリメント戻り次第でしょうか？

1135
00:50:30,550 --> 00:50:34,610
このメモリは、ちょうどすべてのことを意味し、オペレーティングシステムに戻される

1136
00:50:34,610 --> 00:50:37,470
あなたは何が便利なんやった。

1137
00:50:37,470 --> 00:50:43,460
もともとは主に含まれていたものは、実際にはまだそこにある。

1138
00:50:43,460 --> 00:50:44,650
>> だから我々はこれでどこへ行くのか？

1139
00:50:44,650 --> 00:50:49,400
まあ、それはメモリには、このバックは、シーケンスをバックアップする必要があることが判明

1140
00:50:49,400 --> 00:50:50,940
あなたがものをインチ置くことができるバイト

1141
00:50:50,940 --> 00:50:53,760
そしてそれは我々がすでにパッティングを伴う何かを見てきたことが判明

1142
00:50:53,760 --> 00:50:55,100
背中合わせにし背中合わせに物事。

1143
00:50:55,100 --> 00:51:00,170
今では週1と週2に基づいて、文字列は、何ですか？

1144
00:51:00,170 --> 00:51:01,840
だからそれはただの文字のコレクションです。

1145
00:51:01,840 --> 00:51:05,290
だから、あなたが同様にすることができ、メモリに数字を置くことができるのと同様に、判明

1146
00:51:05,290 --> 00:51:06,900
メモリ内の文字を入れた。

1147
00:51:06,900 --> 00:51:09,810
そして、かつて私たちは、にバックアップするように背中合わせにメモリに入れて文字を開始

1148
00:51:09,810 --> 00:51:12,800
背中には、forループのようなものの最も単純なを使用していることが判明したり

1149
00:51:12,800 --> 00:51:14,510
whileループは、我々は、繰り返すことができます - 

1150
00:51:14,510 --> 00:51:17,130
 - 文字列内の文字の上を左から右へ

1151
00:51:17,130 --> 00:51:20,720
とまったく異なる文字にそれらをマッサージし始めます。

1152
00:51:20,720 --> 00:51:25,550
最終的に、私たちが取ることができるようにBを、BがCになる可能性になるかもしれない

1153
00:51:25,550 --> 00:51:28,830
実際には理にかなっているし、それらのそれぞれを変換する英文

1154
00:51:28,830 --> 00:51:32,440
手紙は私たちのコンピュータのメモリを歩いて1つずつは、左

1155
00:51:32,440 --> 00:51:34,300
実際に暗号化する権利を留保します。

1156
00:51:34,300 --> 00:51:36,590
>> それでは、ここで我々の5分間の休憩を取りましょう、と我々は戻ってくるとき、我々はよ

1157
00:51:36,590 --> 00:51:39,060
情報をスクランブリングのこのプロセスを開始します。

1158
00:51:41,640 --> 00:51:43,180
>> かしこまりました。

1159
00:51:43,180 --> 00:51:48,440
我々はいくつかの暗号に潜り、これらの事は配列と呼ばれ、私を聞かせてだから前

1160
00:51:48,440 --> 00:51:51,610
ご質問のための一時停止、私は本当に一種の混乱したように私は感じるので、いくつかの

1161
00:51:51,610 --> 00:51:52,230
これらのトピック。

1162
00:51:52,230 --> 00:51:53,940
だから我々は、可能であれば今度は、修正しましょう​​。

1163
00:51:53,940 --> 00:51:56,480
だから我々は、ちょうど戻り値について話しました。

1164
00:51:56,480 --> 00:51:58,630
我々は、引数について話しました。

1165
00:51:58,630 --> 00:52:02,330
そして、我々は我々が数週間で戻って来るから、この概念、について話しました

1166
00:52:02,330 --> 00:52:07,140
これらの積み重ねの全体の束のようにメモリを表示するので来る

1167
00:52:07,140 --> 00:52:08,540
トレイは、いわば。

1168
00:52:08,540 --> 00:52:13,460
アップ時には下から、スタックに置かれる各トレイは、表していること

1169
00:52:13,460 --> 00:52:15,160
現在呼び出されている関数です。

1170
00:52:17,970 --> 00:52:20,300
何か質問？

1171
00:52:20,300 --> 00:52:22,890
だから方法について - 私が質問をしてみましょう。

1172
00:52:22,890 --> 00:52:25,520
私はそれを台無しに保つが、今it's  -  you'veはすべての少年の顔を見た。

1173
00:52:25,520 --> 00:52:27,020
だから我々はそれに戻ってくる。

1174
00:52:27,020 --> 00:52:29,700
>> だから私はここに質問をしてみましょう。

1175
00:52:29,700 --> 00:52:34,810
私はそれが我々の以前のQ＆Aの一部の前にあったものにこのバックを簡素化しましょう

1176
00:52:34,810 --> 00:52:41,730
と増分が開き括弧、int型の数値を持っているという事実は、閉じた

1177
00:52:41,730 --> 00:52:42,260
カッコ。

1178
00:52:42,260 --> 00:52:46,370
int型の数字は何を表しているのでしょうか？

1179
00:52:46,370 --> 00:52:47,250
[聞こえない]

1180
00:52:47,250 --> 00:52:47,870
デイヴィッドJ.マラン：引数。

1181
00:52:47,870 --> 00:52:50,732
さて、しかし、引数は何ですか？

1182
00:52:50,732 --> 00:52:51,620
[聞こえない]

1183
00:52:51,620 --> 00:52:52,500
デイヴィッドJ.マラン：申し訳ありませんが、それは何ですか？

1184
00:52:52,500 --> 00:52:53,150
スピーカ3：あなたは何インチ渡す

1185
00:52:53,150 --> 00:52:53,570
デイヴィッドJ.マラン：わかりました。

1186
00:52:53,570 --> 00:52:54,780
あなたが入って渡すように何か

1187
00:52:54,780 --> 00:52:56,560
そして、もっと一般的に、それだけで入力です。

1188
00:52:56,560 --> 00:52:59,860
あなたは生活の中で関数とその関数の目的を書いている場合は実行することです

1189
00:52:59,860 --> 00:53:03,290
その後少し違う何か、あなたがそれを使用するたびに、唯一の方法

1190
00:53:03,290 --> 00:53:07,710
実際に起こることは、入力とそれを提供することであるように思えるでしょうそのように、それ

1191
00:53:07,710 --> 00:53:10,180
その入力とするたびに異なる何かを行うことができます。

1192
00:53:10,180 --> 00:53:13,590
>> ですから、関数が入力を取るときに2つの項目を指定する必要があります。

1193
00:53:13,590 --> 00:53:17,240
あなたは純粋にするためには、その入力に与えたい名前を指定する必要があります

1194
00:53:17,240 --> 00:53:20,790
自分の都合があるので、関数内でそれを参照することができますあなた

1195
00:53:20,790 --> 00:53:23,610
私は32行目でここに行ったように自分で、書いている。

1196
00:53:23,610 --> 00:53:27,840
しかし、あなたはまた、Cはプログラミング言語であるため、そのタイプを指定する必要が

1197
00:53:27,840 --> 00:53:28,840
ちょうど必要とする

1198
00:53:28,840 --> 00:53:31,810
あなたは変数として使用したい場合は、コンピュータに何を伝える必要がある

1199
00:53:31,810 --> 00:53:32,790
データは、それがされているタイプ

1200
00:53:32,790 --> 00:53:35,540
大部分はそれが何ビットに認識できるように

1201
00:53:35,540 --> 00:53:37,230
その変数に割り当てる。

1202
00:53:37,230 --> 00:53:38,600
 - それは、6つの可能性があるため

1203
00:53:38,600 --> 00:53:39,990
申し訳ありませんが、それは6ではありません。

1204
00:53:39,990 --> 00:53:41,050
それが16になることができます。

1205
00:53:41,050 --> 00:53:41,630
それが8に設定できます。

1206
00:53:41,630 --> 00:53:44,410
それも、32個、64個とすることができる。

1207
00:53:44,410 --> 00:53:45,820
しかし、コンピュータが認識する必要があります。

1208
00:53:45,820 --> 00:53:49,110
今すぐ左側のintは対照的に、何を表して？

1209
00:53:52,825 --> 00:53:53,780
[聞こえない]

1210
00:53:53,780 --> 00:53:54,570
デイヴィッドJ.マラン：それは何ですか？

1211
00:53:54,570 --> 00:53:55,390
[聞こえない]

1212
00:53:55,390 --> 00:53:57,920
デイヴィッドJ.マラン：関数のタイプと、より具体的には、

1213
00:53:57,920 --> 00:53:59,755
その出力のタイプを指定します。

1214
00:53:59,755 --> 00:54:00,220
右。

1215
00:54:00,220 --> 00:54:04,220
だから括弧内のものに対し、その入力があれば、表し

1216
00:54:04,220 --> 00:54:06,640
左側にあるものは、その出力を表します。

1217
00:54:06,640 --> 00:54:10,560
この場合には、増分が明らかにintを返します。

1218
00:54:10,560 --> 00:54:14,590
それで、int型では、この関数の戻り値の型です。

1219
00:54:14,590 --> 00:54:16,090
>> それは何を返すためにどういう意味ですか？

1220
00:54:16,090 --> 00:54:19,810
文字通りには、キーワードreturnを使用しています。

1221
00:54:19,810 --> 00:54:24,640
そして、何をキーワードの右側に戻ってきていることである場合

1222
00:54:24,640 --> 00:54:28,340
整数は、それは我々が約束したことと実際に一致している。

1223
00:54:28,340 --> 00:54:31,110
あなたはこのような何かをすることができませんでした - 

1224
00:54:31,110 --> 00:54:32,280
こんにちは、世界 - 

1225
00:54:32,280 --> 00:54:33,500
それが文字列であるため。

1226
00:54:33,500 --> 00:54:35,440
明らかにそれは整数ではありません。

1227
00:54:35,440 --> 00:54:40,450
だから簡単に言えば、負担は特異的であるように、私たちに本当にプログラマです

1228
00:54:40,450 --> 00:54:44,730
私たちは何を返そうとしているし、その後、実際にそれを返すことについては移動する。

1229
00:54:44,730 --> 00:54:49,030
し、コンテキスト少しをより明確にするために - 

1230
00:54:49,030 --> 00:54:50,080
そこに彼は再びです。

1231
00:54:50,080 --> 00:54:51,060
文脈 - 

1232
00:54:51,060 --> 00:54:52,830
大きな驚きは一瞬で来る。

1233
00:54:52,830 --> 00:54:57,720
ここでコンテキストは、コンピュータのメモリが再び、ということである

1234
00:54:57,720 --> 00:54:59,070
ギガバイト、2ギガバイト、何でも。

1235
00:54:59,070 --> 00:54:59,630
たぶんそれは、より多くのです。

1236
00:54:59,630 --> 00:55:00,540
たぶんそれは少ないです。

1237
00:55:00,540 --> 00:55:03,750
しかし、コンピュータは、さまざまなセクションを持っているとして、それを見ている。

1238
00:55:03,750 --> 00:55:04,860
何かがダウンした。

1239
00:55:04,860 --> 00:55:06,020
何か他のものがそこに上がる。

1240
00:55:06,020 --> 00:55:07,540
異なるものが真ん中に入ります。

1241
00:55:07,540 --> 00:55:09,300
そして今日、私達はちょうどこの話を始める。

1242
00:55:09,300 --> 00:55:11,130
>> しかし、我々はこれ以上の時間に戻ってくる。

1243
00:55:11,130 --> 00:55:15,000
今のところ、我々は本当に気にメモリの唯一の作品は、テキストセグメントである

1244
00:55:15,000 --> 00:55:17,160
それはただのゼロとものを表すので、

1245
00:55:17,160 --> 00:55:18,460
そのカンという音は出力されています。

1246
00:55:18,460 --> 00:55:21,570
だからあなたがa.outのようなキーボードでコマンドを実行するとき、または二重

1247
00:55:21,570 --> 00:55:25,350
Mac OSやWindows上のアイコンをクリックすると、あなたのプログラムがハードディスクから読み込まれている

1248
00:55:25,350 --> 00:55:26,930
RAMにドライブ。

1249
00:55:26,930 --> 00:55:30,850
そして、それはいわば、コンピュータのRAMの最上部にそのまま流している。

1250
00:55:30,850 --> 00:55:35,470
あなたのプログラムが起動するようになりました、一方、ランニングやmainがで呼び出され

1251
00:55:35,470 --> 00:55:39,240
あなたが書いたプログラムやMicrosoftやAppleが書いたプログラムは、その任意の

1252
00:55:39,240 --> 00:55:42,930
ローカル変数はコンピュータのメモリの一番下にそこに終わる。

1253
00:55:42,930 --> 00:55:46,490
メインは別の関数を呼び出す場合、それ自体は変数やを持っていること

1254
00:55:46,490 --> 00:55:48,340
引数は、彼らはそれの上に終わる。

1255
00:55:48,340 --> 00:55:50,670
その関数が何かを呼び出した場合、彼らは、それより上になってしまう

1256
00:55:50,670 --> 00:55:51,840
その上、その上に。

1257
00:55:51,840 --> 00:55:56,100
と一度だけ関数はそう、トレーのスタックを実行して実行されません

1258
00:55:56,100 --> 00:55:58,320
いわば、どんどん低く得るために始める。

1259
00:55:58,320 --> 00:56:03,370
 - そして、これはその後、一言で言えば、キュ​​ーブを呼び出したときに、理由を説明するものである

1260
00:56:03,370 --> 00:56:04,660
または増分を呼ぶ - 

1261
00:56:04,660 --> 00:56:06,490
あなたは、値のコピーを渡しています。

1262
00:56:06,490 --> 00:56:09,840
や絵を用いて何を意味するかすれば、文字通り書いているということです

1263
00:56:09,840 --> 00:56:14,540
メモリの別の部分にある数字の1、その変化の場合には1から2まで、

1264
00:56:14,540 --> 00:56:15,360
インクリメント - 

1265
00:56:15,360 --> 00:56:17,450
または8〜、キューブの場合 - 

1266
00:56:17,450 --> 00:56:21,450
その後インクリメントまたはキューブとすぐに離れて、そのメモリを投げる

1267
00:56:21,450 --> 00:56:23,410
関数が戻る。

1268
00:56:23,410 --> 00:56:24,267
>> 質問。

1269
00:56:24,267 --> 00:56:25,517
[聞こえない]

1270
00:56:28,090 --> 00:56:29,970
デイヴィッドJ.マラン： - グローバル変数は何に格納されています

1271
00:56:29,970 --> 00:56:32,960
現在は初期化されたデータまたは未初期化データと呼ばれる。

1272
00:56:32,960 --> 00:56:35,900
あなたはグローバル変数を持っていて、それを代入した場合の違いは、当分

1273
00:56:35,900 --> 00:56:39,530
等号を直ちに値が、それはそこに一番上になってしまう。

1274
00:56:39,530 --> 00:56:43,390
あなただけの値なしでます。int xセミコロンを言う場合、それはわずかに終わる

1275
00:56:43,390 --> 00:56:46,670
単に慣例によりRAMに低い。

1276
00:56:46,670 --> 00:56:49,308
その他の質問。

1277
00:56:49,308 --> 00:56:49,750
かしこまりました。

1278
00:56:49,750 --> 00:56:53,040
>> 我々は何ができるか、より強力になるように、この絵は戻ってくるだろう

1279
00:56:53,040 --> 00:56:53,830
コンピュータと。

1280
00:56:53,830 --> 00:56:58,790
しかし、今のところ、暗号化、特定の種​​類の簡単なイントロを持ってみましょう

1281
00:56:58,790 --> 00:57:01,910
世界のすべての問題を解決するわけではありませんが、解決するのですか暗号

1282
00:57:01,910 --> 00:57:02,480
そのうちのいくつか。

1283
00:57:02,480 --> 00:57:06,090
ここでは、このケースでは、秘密鍵暗号方式と呼ばれるものを持っています。

1284
00:57:06,090 --> 00:57:10,430
と秘密鍵暗号方式は、その名前が示すように、そのセキュリティを導出

1285
00:57:10,430 --> 00:57:11,330
秘密から。

1286
00:57:11,330 --> 00:57:14,720
だから例えば、あなたが小学校に戻って、あなたが渡している場合

1287
00:57:14,720 --> 00:57:18,040
あなたが潰れている少年や少女へのちょっとした秘密の愛の手紙 - あなたなら

1288
00:57:18,040 --> 00:57:20,820
観客を通して、あなたはおそらく書けないだろうと渡したい

1289
00:57:20,820 --> 00:57:24,120
そのような英語でメモや何でもあなたの母国語があるのではなく、あなた

1290
00:57:24,120 --> 00:57:25,800
それを暗号化することがあります。

1291
00:57:25,800 --> 00:57:27,820
それとも、ただ、これらの日彼らにテキストメッセージを送信することがあります。

1292
00:57:27,820 --> 00:57:30,310
しかし、あなたが実際に教室の中にそれらにメモを渡すことがあります。

1293
00:57:30,310 --> 00:57:33,820
お友達や先生にそのような方法で、確実にこれを実行するには

1294
00:57:33,820 --> 00:57:36,820
あなたが書いているかわからない、あなたはかなり簡単思い付くかもしれません

1295
00:57:36,820 --> 00:57:37,800
アルゴリズム - 

1296
00:57:37,800 --> 00:57:39,290
あなたがあるかもしれませんが若い - 

1297
00:57:39,290 --> 00:57:40,780
言葉だけをスクランブルする。

1298
00:57:40,780 --> 00:57:44,390
代わりに書き込むのではそう、あなたが代わりにBのBを書き込むかもしれませんが、次のように書くかもしれません

1299
00:57:44,390 --> 00:57:46,670
Cの代わりでは、Dを書くなどすることがあります。

1300
00:57:46,670 --> 00:57:50,020
それとも手紙のより洗練された翻訳を考え出すこと

1301
00:57:50,020 --> 00:57:51,300
異なる文字に。

1302
00:57:51,300 --> 00:57:55,440
しかし、漁獲量は、あなたがする必要があるこのメモを送っている人に男の子か女の子です

1303
00:57:55,440 --> 00:57:56,850
何かを知っている。

1304
00:57:56,850 --> 00:57:59,620
明らかに、何のどれですか？

1305
00:57:59,620 --> 00:58:01,400
あなたの秘密は何か、のような。

1306
00:58:01,400 --> 00:58:04,620
同様に、AやBのCSとDSの間のマッピングは何ですか？

1307
00:58:04,620 --> 00:58:08,780
それだけでから行くように手紙のそれぞれに、話すように、1を加えている

1308
00:58:08,780 --> 00:58:09,730
Bに、BがCに？

1309
00:58:09,730 --> 00:58:11,350
それはそれよりもっと複雑なのですか？

1310
00:58:11,350 --> 00:58:16,450
だから、あなたとあなたのときめきは、この秘密情報を持っている必要があります。

1311
00:58:16,450 --> 00:58:18,170
しかし、ここでキャッチ22の種類があります。

1312
00:58:18,170 --> 00:58:20,760
これはあなたを介してこの愛の手紙を送っている、非常に最初の時間である場合

1313
00:58:20,760 --> 00:58:25,590
クラスは、どのようにその男の子か女の子は秘密が偶数であるかを知るのでしょうか？

1314
00:58:25,590 --> 00:58:28,450
だから、秘密鍵暗号では、すべての世界の問題を解決していません。

1315
00:58:28,450 --> 00:58:30,490
そして、私たちが向かって戻ってくるだろうという関係が実際にあり

1316
00:58:30,490 --> 00:58:31,370
学期の終わり。

1317
00:58:31,370 --> 00:58:35,970
>> 同様に、私たちの誰もが、おそらくこれまで送信されません持っている - 

1318
00:58:35,970 --> 00:58:39,453
同様に、私たちのほとんどは、で、例えば、働く人を知らない

1319
00:58:39,453 --> 00:58:40,300
Amazon.com。

1320
00:58:40,300 --> 00:58:43,130
そして、まだ、私たちの多くは、おそらくAmazon.comでものを買っている。

1321
00:58:43,130 --> 00:58:45,670
そして、我々は仮定して教えられてきたが、これらの電子商取引

1322
00:58:45,670 --> 00:58:47,060
トランザクションは安全です。

1323
00:58:47,060 --> 00:58:47,210
右か？

1324
00:58:47,210 --> 00:58:49,310
URLはおそらくhttpsを言う。

1325
00:58:49,310 --> 00:58:51,590
愚かな小さな南京錠のアイコンがどこかに多分あります。

1326
00:58:51,590 --> 00:58:54,680
あなたのクレジットカード情報を保護する暗号技術のいくつかの種類があります

1327
00:58:54,680 --> 00:58:56,980
あなたとAmazon.comの間。

1328
00:58:56,980 --> 00:59:00,410
暗号はまだいくつかの秘密を知っている、と関係している場合、まだ、私はしないでください

1329
00:59:00,410 --> 00:59:03,330
Amazonで誰でも知っている、と私は確かに、あらゆる種類のを配置していませんでした

1330
00:59:03,330 --> 00:59:07,350
Amazonで誰かと秘密は、どのように自分のコンピュータまたは私のブラウザがこれをやっている？

1331
00:59:07,350 --> 00:59:10,100
まあ、暗号化の他のタイプが完全に解決することがあり判明

1332
00:59:10,100 --> 00:59:10,740
その問題。

1333
00:59:10,740 --> 00:59:13,610
しかし、今日のために、私たちは、あなたがで手配することができますシンプルなものに焦点を当てていきます

1334
00:59:13,610 --> 00:59:18,480
プラス1またはAsとBの間の一部のマッピングと同様に、いくつかの秘密を知りたいと進める。

1335
00:59:18,480 --> 00:59:20,710
>> と暗号化のプロセスは、一般的にこれを伴います。

1336
00:59:20,710 --> 00:59:23,550
あなたは左でここに示されているように、いくつかのプレーンテキストを持っています。

1337
00:59:23,550 --> 00:59:26,260
あなたは、アルゴリズムやプロシージャのいくつかの種類を使用してそれを実行

1338
00:59:26,260 --> 00:59:27,670
それを暗号化する。

1339
00:59:27,670 --> 00:59:31,390
多分それだけでBになるのは、BはCになり、その後、で終わる

1340
00:59:31,390 --> 00:59:32,260
暗号テキスト。

1341
00:59:32,260 --> 00:59:36,450
一方、一度あなたの片思いが秘密メモを受け取り、彼または彼女はその後にあり

1342
00:59:36,450 --> 00:59:39,950
一般的に取得するように、そのアルゴリズムを逆にすることによってそれを解読

1343
00:59:39,950 --> 00:59:41,640
プレーンテキストをバックアップします。

1344
00:59:41,640 --> 00:59:43,860
さて、これを物理的に化身があります。

1345
00:59:43,860 --> 00:59:46,720
例えば、これはちょっとした秘密デコーダリングです。

1346
00:59:46,720 --> 00:59:50,060
そして、これは2つのダイアルがここにありという意味で、リングです。

1347
00:59:50,060 --> 00:59:53,630
この事の外周囲には、AからZまでの文字、そこ

1348
00:59:53,630 --> 00:59:55,110
彼らはランダムな順番にしているが。

1349
00:59:55,110 --> 00:59:58,410
そして内側には、これになるようにいくつかの数字は、実際にあり

1350
00:59:58,410 --> 01:00:02,940
リングに、どのような種類のラインアップするために、外側ではなく内側を回すことができる

1351
01:00:02,940 --> 01:00:04,110
文字と番号。

1352
01:00:04,110 --> 01:00:08,290
あなたは24/7を見ている可能性がありますいくつかは - そして、あなたが参照してくださいしようとしているクリップで

1353
01:00:08,290 --> 01:00:11,120
クリスマス·ストーリーという映画からクリスマスシーズンの周り。

1354
01:00:11,120 --> 01:00:16,050
あなたは少しRalphieはなけなしの孤児を把握するために熱望していたことがわかります

1355
01:00:16,050 --> 01:00:19,810
アニーの秘密のメッセージは、私が思うに、伝達されていたことを彼にあった

1356
01:00:19,810 --> 01:00:22,810
シリアルボックスの数値メッセージの形式。

1357
01:00:22,810 --> 01:00:26,760
そして、あなたは来たすべての小さなカードを蓄積しなければならなかった

1358
01:00:26,760 --> 01:00:27,480
シリアルの箱インチ

1359
01:00:27,480 --> 01:00:28,320
あなたはそれらをインチ郵送しなければならなかった

1360
01:00:28,320 --> 01:00:31,060
あなたが最終的に理解できるように、秘密のデコーダリングを取り戻す必要があった

1361
01:00:31,060 --> 01:00:34,190
マッピングは文字と数字の間にある何かを、

1362
01:00:34,190 --> 01:00:35,420
または文字と文字。

1363
01:00:35,420 --> 01:00:39,790
だから私は、pset 2をやる気にさせるクリスマスの物語からあなたにこの短いクリップを提供し、

1364
01:00:39,790 --> 01:00:42,340
配列の瞬間に我々の議論、、。

1365
01:00:42,340 --> 01:00:43,773
そこでここではRalphieを持っています。

1366
01:00:43,773 --> 01:00:44,126
>> [ビデオの再生]

1367
01:00:44,126 --> 01:00:47,470
-BEラルフパーカーがここに任命されていること、それをすべてに知られており、諸

1368
01:00:47,470 --> 01:00:50,690
リトル孤児アニーの秘密のサークルのメンバーであり、すべてを受ける権利がある

1369
01:00:50,690 --> 01:00:53,500
そこに発生して名誉と利益。

1370
01:00:53,500 --> 01:00:56,040
署名された、リトル孤児アニー。

1371
01:00:56,040 --> 01:00:58,730
副署、ピエール·アンドレ！

1372
01:00:58,730 --> 01:01:00,150
インクで！

1373
01:01:00,150 --> 01:01:02,910
特別と利点、すでに9歳の時。

1374
01:01:09,970 --> 01:01:10,730
さあ、それに乗ってみましょう。

1375
01:01:10,730 --> 01:01:15,000
私は、密輸や海賊に関するすべてのことジャズを必要としません。

1376
01:01:15,000 --> 01:01:17,624
ブラックの締結冒険のために、明日の夜聞く

1377
01:01:17,624 --> 01:01:19,710
海賊船。

1378
01:01:19,710 --> 01:01:23,380
今それはあなたのメンバーのアニーの秘密のメッセージのための時間です

1379
01:01:23,380 --> 01:01:25,670
秘密サークル。

1380
01:01:25,670 --> 01:01:30,260
、覚えている子供たちは、アニーの秘密サークルのメンバーのみが復号化することができる

1381
01:01:30,260 --> 01:01:31,660
アニーの秘密のメッセージ。

1382
01:01:31,660 --> 01:01:36,230
覚えておいて、アニーはあなたに依存している。

1383
01:01:36,230 --> 01:01:38,720
B2にあなたのピンを設定します。

1384
01:01:38,720 --> 01:01:41,040
ここにメッセージがある。

1385
01:01:41,040 --> 01:01:42,470
12、11  - 

1386
01:01:42,470 --> 01:01:46,000
 - 私は私の最初の秘密の会議で午前。

1387
01:01:46,000 --> 01:01:49,440
-14、11、18、16  - 

1388
01:01:49,440 --> 01:01:51,700
ピエールは偉大な声に今夜だった。

1389
01:01:51,700 --> 01:01:54,890
私は今夜​​のメッセージが本当に重要だと言うことができる。

1390
01:01:54,890 --> 01:01:56,750
-3、25。

1391
01:01:56,750 --> 01:01:58,590
それはアニー自身からのメッセージです。

1392
01:01:58,590 --> 01:01:59,840
覚えておいて、誰にも言わないでください。

1393
01:02:04,570 --> 01:02:08,750
-90秒後、私は家の中で唯一の部屋にいるよどこに9の少年

1394
01:02:08,750 --> 01:02:12,980
プライバシーとデコードに座ることができます。

1395
01:02:12,980 --> 01:02:17,130
アハ、B.私は次に行きました。

1396
01:02:17,130 --> 01:02:20,330
E.最初の単語はであることです。

1397
01:02:20,330 --> 01:02:22,670
S.それは今簡単に来ていた。

1398
01:02:22,670 --> 01:02:24,590
U.

1399
01:02:24,590 --> 01:02:26,510
 - ああ、Ralphie、来る。

1400
01:02:26,510 --> 01:02:28,430
私は行くことを得た。

1401
01:02:28,430 --> 01:02:30,350
-I'llは、右下のミリアンペアである。

1402
01:02:30,350 --> 01:02:33,720
ジー達人。

1403
01:02:33,720 --> 01:02:38,270
-T、Oがにていることを確認します。

1404
01:02:38,270 --> 01:02:40,000
何に必ず？

1405
01:02:40,000 --> 01:02:42,105
言おうとしているリトル孤児アニーは何でしたか？

1406
01:02:42,105 --> 01:02:43,095
何に必ず？

1407
01:02:43,095 --> 01:02:43,590
-Ralphie！

1408
01:02:43,590 --> 01:02:44,580
ランディは行くことを得ました。

1409
01:02:44,580 --> 01:02:45,570
あなたが出てきて下さいませんか。

1410
01:02:45,570 --> 01:02:46,560
 - すべての権利は​​、ミリアンペア。

1411
01:02:46,560 --> 01:02:48,540
私は右の外になるでしょう。

1412
01:02:48,540 --> 01:02:50,580
 - 私は今、近づいてきた。

1413
01:02:50,580 --> 01:02:52,550
緊張はひどいものだった。

1414
01:02:52,550 --> 01:02:53,355
それは何でしたか？

1415
01:02:53,355 --> 01:02:56,315
惑星の運命が不安定な状態にあるかもしれません。

1416
01:02:56,315 --> 01:02:56,790
-Ralphie！

1417
01:02:56,790 --> 01:02:59,165
ランディは絶対に行くと持っている。

1418
01:02:59,165 --> 01:03:02,310
-I'llは、声を出して泣くの、右の外にある。

1419
01:03:02,310 --> 01:03:04,000
ジー、ほとんどそこに。

1420
01:03:04,000 --> 01:03:05,180
私の指が飛んだ。

1421
01:03:05,180 --> 01:03:07,150
私の心は鋼の罠だった。

1422
01:03:07,150 --> 01:03:08,790
あらゆる毛穴が振動。

1423
01:03:08,790 --> 01:03:10,040
それはほとんど明らかだった。

1424
01:03:10,040 --> 01:03:13,400
はい、はい、はい、はい。

1425
01:03:13,400 --> 01:03:18,960
あなたのオヴァルを飲むようにしてください - 必ず。

1426
01:03:18,960 --> 01:03:20,210
オヴァル？

1427
01:03:24,010 --> 01:03:25,260
安っぽいコマーシャル？

1428
01:03:28,200 --> 01:03:29,640
雌犬の息子。

1429
01:03:29,640 --> 01:03:33,340
[エンドビデオの再生]

1430
01:03:33,340 --> 01:03:36,040
>> デイヴィッドJ.マラン：だからそこに私達は、暗号化機能を持っています。

1431
01:03:36,040 --> 01:03:39,670
だから我々はどのようにコンピュータでの実装に取り​​掛かることができますまたは

1432
01:03:39,670 --> 01:03:40,950
このようなものを表す？

1433
01:03:40,950 --> 01:03:44,430
まあ、我々はもう少し柔軟に比べて自分自身を表現する方法が必要

1434
01:03:44,430 --> 01:03:46,420
our変数はこれまで許可されています。

1435
01:03:46,420 --> 01:03:47,370
我々は、int型を持っていた。

1436
01:03:47,370 --> 01:03:48,380
我々は文字を持っていた。

1437
01:03:48,380 --> 01:03:50,790
我々は、floatとdoubleといくつか他のものを持っていた。

1438
01:03:50,790 --> 01:03:55,050
しかし、それらは本当に私たちがすることはできませんメモリの個々の部分である

1439
01:03:55,050 --> 01:03:58,010
言葉や文章やフレーズのようなものを表現しています。

1440
01:03:58,010 --> 01:04:00,200
実際、我々はそのようなものの文字列を呼んでいます。

1441
01:04:00,200 --> 01:04:03,650
しかし、我々は、これは本当にCS50でちょうど簡略化したものであることを約束した

1442
01:04:03,650 --> 01:04:07,020
我々は戻っピールしようとしていることをライブラリ。

1443
01:04:07,020 --> 01:04:08,970
>> ので、ここでそれを行うには始めましょう。

1444
01:04:08,970 --> 01:04:11,130
私が先に行くと、ファイルを開いてみよう - 

1445
01:04:11,130 --> 01:04:13,770
これらのすべてのファイルがオンラインでいつものようにご利用いただけます - 

1446
01:04:13,770 --> 01:04:19,120
文字列とは無関係の問題を解決するためにarray.c呼ばれるが、それは描く

1447
01:04:19,120 --> 01:04:23,040
我々は配列と呼ばれるものを使用する方法のここに絵。

1448
01:04:23,040 --> 01:04:25,530
配列はデータタイプです。

1449
01:04:25,530 --> 01:04:31,320
それは一種の変数の型、だ、それは複数の小さいデータ型を持っている

1450
01:04:31,320 --> 01:04:34,150
その中に背中合わせに背中合わせにします。

1451
01:04:34,150 --> 01:04:37,700
だから例えば、我々はあなたに与えるちょっとしたプログラムを書きたい場合は、

1452
01:04:37,700 --> 01:04:42,110
クイズ、あなた可能性がある、非常に簡単に2つを持っている50のようなコースのために平均をクイズ

1453
01:04:42,110 --> 01:04:45,170
このプログラムを書いた - も、先週の材料の一部に基づいて - 

1454
01:04:45,170 --> 01:04:47,770
getIntおよびいくつかの変数を使用します。

1455
01:04:47,770 --> 01:04:51,920
int型quiz1、int型quiz2、それはかなり簡単です。

1456
01:04:51,920 --> 01:04:55,930
それは聞くプログラムを実装し、多分コード、最大20行10だ

1457
01:04:55,930 --> 01:05:01,170
次に2つのクイズのスコアのため、ユーザーはそれらを追加することで、その平均値を計算します

1458
01:05:01,170 --> 01:05:03,850
併せて、2で割って、その結果を印刷します。

1459
01:05:03,850 --> 01:05:06,380
我々は、おそらく後にかなり容易になりましたことを行うことができます

1460
01:05:06,380 --> 01:05:07,510
分のいくつかの数。

1461
01:05:07,510 --> 01:05:11,005
>> しかし、問題は50が3つまたは​​4つのクイズがあったと仮定するということです。

1462
01:05:11,005 --> 01:05:13,510
あなたが持っていたクラスに同じプログラムを使用していたと仮定し

1463
01:05:13,510 --> 01:05:14,850
毎週クイズ。

1464
01:05:14,850 --> 01:05:16,610
クイズを毎週持つクラスを考える。

1465
01:05:16,610 --> 01:05:20,610
学期中に16人ほどのように週があるとすれば、今は16の変数を持っている - 

1466
01:05:20,610 --> 01:05:24,270
int型quiz1、int型quiz2、int型quiz3、int型quiz4。

1467
01:05:24,270 --> 01:05:27,560
この冗長性を見始めるとすぐに、これは、コピー＆ペースト

1468
01:05:27,560 --> 01:05:31,390
コー​​ドから、それはあなたがより良い方法があったならばなあ作るために開始する必要があります。

1469
01:05:31,390 --> 01:05:33,930
そしてありがたいことに、配列のため、そこにある。

1470
01:05:33,930 --> 01:05:34,980
だから、これを実行してみましょう。

1471
01:05:34,980 --> 01:05:38,430
まず、私たちがこれまで使用されていませんでしたことを非常に単純なものを紹介しましょう​​、

1472
01:05:38,430 --> 01:05:40,140
しかし、あなたは、コード内で時折それを見ることができます。

1473
01:05:40,140 --> 01:05:42,360
これは一般的に定数と呼ばれるものです。

1474
01:05:42,360 --> 01:05:45,790
だから、この値が変わることはないという意味では一定です。

1475
01:05:45,790 --> 01:05:49,210
定数を作成する人間の規則はすべての資本を使用することです

1476
01:05:49,210 --> 01:05:51,940
それは本当にあなたのコードの中で際立っているだけので、文字、。

1477
01:05:51,940 --> 01:05:55,960
そして、あなたがC言語で使用する特殊なキーワードは、＃defineされている。

1478
01:05:55,960 --> 01:06:00,250
あなたが言うならそう＃続いて、次に、あなたが使用したい単語をスペースを定義

1479
01:06:00,250 --> 01:06:03,260
次に定数の名前、および定数の値。

1480
01:06:03,260 --> 01:06:06,180
だから通知は、これは変数に何かを割り当てるとは異なります。

1481
01:06:06,180 --> 01:06:07,020
等号はありません。

1482
01:06:07,020 --> 01:06:08,240
セミコロンはありません。

1483
01:06:08,240 --> 01:06:11,410
これは一般的にプリプロセッサディレクティブとして知られているものですが、より上

1484
01:06:11,410 --> 01:06:12,210
その別の時間。

1485
01:06:12,210 --> 01:06:18,540
>> 今のところ、これは、その実際のクイズと呼ばれる不変の価値を創造する

1486
01:06:18,540 --> 01:06:19,940
数値は2です。

1487
01:06:19,940 --> 01:06:24,020
だから、どこでもだと、このファイル全体クイズ、クイズ、クイズを参照してください

1488
01:06:24,020 --> 01:06:25,410
わずか数2。

1489
01:06:25,410 --> 01:06:28,100
私は今、主を見れば、今、どのようにこの作品を見てみましょう。

1490
01:06:28,100 --> 01:06:29,500
最初は、それは少し不可解に見える。

1491
01:06:29,500 --> 01:06:31,340
しかし、それは週1からすべてのものです。

1492
01:06:31,340 --> 01:06:32,710
グレードのユーザーに依頼します。

1493
01:06:32,710 --> 01:06:33,630
どのように我々はこれを行うのですか？

1494
01:06:33,630 --> 01:06:35,470
さて、22行目で - 

1495
01:06:35,470 --> 01:06:37,210
これは本当にジューシーな一部である - 

1496
01:06:37,210 --> 01:06:40,960
私は、float、それだけではない単一のfloatを宣言します。

1497
01:06:40,960 --> 01:06:44,620
私は、むしろ、浮動小数点値の配列を宣言しています。

1498
01:06:44,620 --> 01:06:49,100
その変数は、ここで暗示として、グレードと呼ばれようとしています。

1499
01:06:49,100 --> 01:06:53,080
しかし、新しい構文の唯一の作品は、その後、事実これらの角括弧アール

1500
01:06:53,080 --> 01:06:59,350
私はその後、フロートグレードしてから、開き括弧と番号を言ってきたこと。

1501
01:06:59,350 --> 01:07:02,460
これが一定である場合の通知は、これは我々がこれをしただけのようなものです。

1502
01:07:02,460 --> 01:07:06,890
これは私に二つの浮動小数点数を与え、ちょっとコンピュータを意味しており、総称して呼ぶことにしましょう

1503
01:07:06,890 --> 01:07:08,220
それらのグレードがあります。

1504
01:07:08,220 --> 01:07:11,920
これは、このような多くの面倒な処理とは対照的である。

1505
01:07:11,920 --> 01:07:15,850
、グレード1をフロートgrade2フロートなど。

1506
01:07:15,850 --> 01:07:20,010
だから、配列は、私たちはこのアイデアを実装することができますが、あまりだらしなく、内

1507
01:07:20,010 --> 01:07:24,630
我々は、と言うのではなく、16のための16のコードの1行を書き込むことができるような方法

1508
01:07:24,630 --> 01:07:25,740
週学期。

1509
01:07:25,740 --> 01:07:29,950
あなたが今このことについて考えている場合ので、だから私はにハードコード2たくありませんでした

1510
01:07:29,950 --> 01:07:34,160
論理的に -  3〜CS50変更が代わりにクイズ来年と仮定します。

1511
01:07:34,160 --> 01:07:35,510
そして、私はここに数字の2を持っていた。

1512
01:07:35,510 --> 01:07:36,600
私はここで2番を持っていた。

1513
01:07:36,600 --> 01:07:37,580
私はここで2番を持っていた。

1514
01:07:37,580 --> 01:07:38,560
私はここで2番を持っていた。

1515
01:07:38,560 --> 01:07:43,180
それは非常に面倒で、台無しにし、誤って変更することが非常に簡単になります

1516
01:07:43,180 --> 01:07:47,690
1〜3の値と2の他のいくつかの値を欠場。

1517
01:07:47,690 --> 01:07:52,460
だから私はこの離れて代わりに抽象的に行って、この定数を使用している、その、そのよう

1518
01:07:52,460 --> 01:07:54,120
名前は、決して変更されないことを示唆している。

1519
01:07:54,120 --> 01:07:57,710
そして今、我々は別の持っているかどうかに関係なく、今年か、次のページ、私はクイズない

1520
01:07:57,710 --> 01:08:01,210
ちょうど上部にここに、一つの場所にそれを変更する必要があります。

1521
01:08:01,210 --> 01:08:02,720
>> だから定数がすべてです。

1522
01:08:02,720 --> 01:08:08,680
一方、新しい概念の特徴は、配列のことです。

1523
01:08:08,680 --> 01:08:14,660
角括弧は私にこの多くの山車を与えると総称させて頂きますので、

1524
01:08:14,660 --> 01:08:16,630
ここではそれらのグレードと呼びます。

1525
01:08:16,630 --> 01:08:17,990
だから今私は何をするつもりか見てみましょう。

1526
01:08:17,990 --> 01:08:20,359
ここでは24行目のforループの始まりです。

1527
01:08:20,359 --> 01:08:22,260
これは本当に何も空想です。

1528
01:08:22,260 --> 01:08:25,060
それだけでハードコードされた番号の代わりにクイズを使っている。

1529
01:08:25,060 --> 01:08:27,790
しかし、先週からそこに知的に異なるものは何もありません。

1530
01:08:27,790 --> 01:08:29,040
これはprintfです。

1531
01:08:29,040 --> 01:08:35,490
だからのprintf（ "％d個のクイズ番号％d"）私はちょうど私がクイズを与えるをプリントアウトしたいので、

1532
01:08:35,490 --> 01:08:38,050
ナンバー2とし、2つの2つのうちの1つ。

1533
01:08:38,050 --> 01:08:39,850
だから、これは純粋に美的なものです。

1534
01:08:39,850 --> 01:08:42,500
しかし、興味深い部分は、今や27行になっています。

1535
01:08:42,500 --> 01:08:48,310
浮動小数点を持つ2つのプレースホルダのいずれかを記入するためには、

1536
01:08:48,310 --> 01:08:51,029
値は、再度、角括弧を使用します。

1537
01:08:51,029 --> 01:08:55,620
このforループは、私が等しいから始まっているため、このケースでは、私は私を使用しています

1538
01:08:55,620 --> 01:08:57,560
明らかに何の価値が、？

1539
01:08:57,560 --> 01:08:58,279
0。

1540
01:08:58,279 --> 01:09:01,350
>> だから、このループの最初の繰り返しでは、それは私があるかのようである

1541
01:09:01,350 --> 01:09:02,689
コー​​ドでこれを書いている。

1542
01:09:02,689 --> 01:09:05,580
しかし、このループの2回目の繰り返しでは、それは私があるかのようである

1543
01:09:05,580 --> 01:09:07,750
私のコードでこれを書いている。

1544
01:09:07,750 --> 01:09:10,750
しかし、私は変数を使用しているという事実は、名前として、ために完全である

1545
01:09:10,750 --> 01:09:14,300
示唆している、それは繰り返しごとにその値を変化させている。

1546
01:09:14,300 --> 01:09:17,370
だから私はこの配列を一度に1つのスポットを充填しています。

1547
01:09:17,370 --> 01:09:18,910
この配列はどのように見えますか？

1548
01:09:18,910 --> 01:09:21,430
まあ、理由は私はここに、画面上のこの超単純な四角形を描きました

1549
01:09:21,430 --> 01:09:23,350
前にこのような理由のためだった。

1550
01:09:23,350 --> 01:09:27,279
アレイは、単にメモリの別のチャンクが続くメモリの塊である

1551
01:09:27,279 --> 01:09:30,109
メモリの別のチャンクが続くなど。

1552
01:09:30,109 --> 01:09:35,260
私の配列のサイズが2だったのなら、ここで、この場合は、すべて私がやっていることであろう

1553
01:09:35,260 --> 01:09:37,590
ここのように、私のクイズの得点を入力する。

1554
01:09:37,590 --> 01:09:39,430
私はこの1つに100を得た。

1555
01:09:39,430 --> 01:09:42,020
そして、私はこの1つに99を得た。

1556
01:09:42,020 --> 01:09:46,040
私だけ尋ねてきたので、次に、このメモリがあっても使用できない場合があります

1557
01:09:46,040 --> 01:09:48,689
サイズ2の配列のためのコンピュータ。

1558
01:09:48,689 --> 01:09:50,180
これらの四角がまだ残っている。

1559
01:09:50,180 --> 01:09:50,340
右か？

1560
01:09:50,340 --> 01:09:52,500
あなたはまだだけだとしても、RAMは2ギガバイトを持っている

1561
01:09:52,500 --> 01:09:53,979
二つの浮動小数点数を求める。

1562
01:09:53,979 --> 01:09:58,710
だから配列の背後にある考え方は、コンピュータは単なるメモリの塊がかかるということです

1563
01:09:58,710 --> 01:10:03,230
その後背中合わせにし、背中合わせに小さなピースをapportions。

1564
01:10:03,230 --> 01:10:04,740
そしてそうそれはすべての配列であるのです。

1565
01:10:04,740 --> 01:10:09,080
あなたは物事を置くことができるの内側には、メモリの連続するチャンクです。

1566
01:10:09,080 --> 01:10:12,400
>> さて、これは、ちょうどいくつかの退屈な算術演算を行うことを起こる。

1567
01:10:12,400 --> 01:10:16,170
私はここで下にスクロールすると、これは私がその配列を反復処理する場所です。

1568
01:10:16,170 --> 01:10:19,410
私は、配列内のすべての値の合計を思い付く。

1569
01:10:19,410 --> 01:10:22,390
そして私は実際に行うには、ここをラウンド関数を使用

1570
01:10:22,390 --> 01:10:23,940
クイズで割った値の合計。

1571
01:10:23,940 --> 01:10:27,450
しかし、私は今のところ十分な算術の一種としてその時点で私の手を振ってみましょう。

1572
01:10:27,450 --> 01:10:30,010
しかし、私のためにやっていることすべてが、最終的に平均を計算している。

1573
01:10:30,010 --> 01:10:33,640
だから、最初のクイズに加え、第二クイズ、2で割って、[印刷

1574
01:10:33,640 --> 01:10:34,700
intとしてそれから。

1575
01:10:34,700 --> 01:10:39,030
>> しかし、今ではstring1と呼ばれる別の例に遷移してみましょう

1576
01:10:39,030 --> 01:10:42,370
これは、似たような絵が、使用して文字列を描画します。

1577
01:10:42,370 --> 01:10:45,550
私が先に行くと、ちょっとこれを簡素化することができます。

1578
01:10:45,550 --> 01:10:48,340
そして今のインデントをお許しください。

1579
01:10:48,340 --> 01:10:52,280
この例の19行目に注目してください、私はユーザから文字列を取得します。

1580
01:10:52,280 --> 01:10:55,780
しかし、私は次の行に22以降をやっていることに気づく。

1581
01:10:55,780 --> 01:11:00,260
私は実際に最大iから反復している - これは新しいトリックです - 

1582
01:11:00,260 --> 01:11:02,730
strlenは、文字列の長さ。

1583
01:11:02,730 --> 01:11:07,010
これは、あなたがそれに文字列を渡した場合、それは語ることは、Cが付属機能である

1584
01:11:07,010 --> 01:11:08,950
あなたは、その文字列が何文字です。

1585
01:11:08,950 --> 01:11:09,440
それがすべてです。

1586
01:11:09,440 --> 01:11:12,520
それはちょうどので、それは代わりに文字列の長さのstrlenのだという事実がある

1587
01:11:12,520 --> 01:11:13,040
より簡潔。

1588
01:11:13,040 --> 01:11:17,100
30年前、人々は簡潔に、できるだけのことを書くのが好きでした。

1589
01:11:17,100 --> 01:11:19,080
だから私たちはここでその規則を守ってきた。

1590
01:11:19,080 --> 01:11:21,730
iは+ +だけで、各反復でiをインクリメントを意味します。

1591
01:11:21,730 --> 01:11:24,310
そして今、本当に興味深いです、これに気づく。

1592
01:11:24,310 --> 01:11:28,730
だから、24行目で、私はコンピュータを言う、私の文字、8を与える

1593
01:11:28,730 --> 01:11:30,770
ビット、およびそれをCと呼ぶ。

1594
01:11:30,770 --> 01:11:35,370
しかし、これは言って右手側には何ですか？

1595
01:11:35,370 --> 01:11:38,150
英語では、それが何を表すのでしょうか？

1596
01:11:38,150 --> 01:11:40,070
[聞こえない]

1597
01:11:40,070 --> 01:11:40,490
デイヴィッドJ.マラン：その通りです。

1598
01:11:40,490 --> 01:11:42,390
私の配列の最初の文字を与える。

1599
01:11:42,390 --> 01:11:45,400
またはより一般的には、私に、配列内のi番目の文字を与える。

1600
01:11:45,400 --> 01:11:48,230
そして、それはコンピュータ科学者として、私たちが実際にしている今、実現することが重要です

1601
01:11:48,230 --> 01:11:49,330
0からカウント。

1602
01:11:49,330 --> 01:11:51,290
あなたはこれをやって起動するようになりました裁量権を持っていない。

1603
01:11:51,290 --> 01:11:54,580
ここでは、コンピュータの期待に従って動作しなければならないと

1604
01:11:54,580 --> 01:11:58,010
[0]が最初であることを行っているので、ゼロからカウント

1605
01:11:58,010 --> 01:11:59,670
文字列内の文字。

1606
01:11:59,670 --> 01:12:01,320
[1]は2番目になるだろう。

1607
01:12:01,320 --> 01:12:03,610
[2]第三などになるだろう。

1608
01:12:03,610 --> 01:12:08,840
このプログラムのように、私はそれをコンパイルする場合 - これは、再び、string1のです。

1609
01:12:08,840 --> 01:12:11,040
>> だから、string1が作る。

1610
01:12:11,040 --> 01:12:16,730
そして今、私は私の端末ウィンドウでstring1が実行されます。

1611
01:12:16,730 --> 01:12:19,180
これは、入力を待っているので、私はデビッド、言う、入力するつもりです。

1612
01:12:19,180 --> 01:12:20,080
入力します。

1613
01:12:20,080 --> 01:12:23,350
そして今、それがために別の行にすべてDAVIDを出力

1614
01:12:23,350 --> 01:12:24,430
私がやっていることに気づく。

1615
01:12:24,430 --> 01:12:27,510
私は、一度に1つの文字を印刷しています。

1616
01:12:27,510 --> 01:12:29,100
今、私たちは、この上に今日詳しく説明しません。

1617
01:12:29,100 --> 01:12:31,610
しかし、私はここに、このチェック前の瞬間を削除しました。

1618
01:12:31,610 --> 01:12:36,310
これは、ユーザーが敵対、ふらちな事、またはちょうどされている場合が判明

1619
01:12:36,310 --> 01:12:41,780
混乱して、実際にはいくつかの長さの文字列を与えることに失敗することがあります。

1620
01:12:41,780 --> 01:12:43,640
あなたには、キーボード上で誤ったキーを叩いてしまった場合は、与えるかもしれない

1621
01:12:43,640 --> 01:12:44,390
まったく文字列はありません。

1622
01:12:44,390 --> 01:12:47,790
あなたが悪意なら、または、あなたは数ギガバイトの価値に貼り付けしようとするかもしれない

1623
01:12:47,790 --> 01:12:49,380
この文字列を埋めるためのエッセイ。

1624
01:12:49,380 --> 01:12:52,060
コンピュータのメモリが不足した場合と、それは我々が行っていることが判明

1625
01:12:52,060 --> 01:12:54,310
ヌルと呼ばれるこの特別な値を取り戻すために。

1626
01:12:54,310 --> 01:12:57,550
だから今のところ、ちょうどヌルと呼ばれるこの特別な値があることを知っている

1627
01:12:57,550 --> 01:13:01,000
私たちは他のものの間で、メモリが不足しているときにチェックすることができます。

1628
01:13:01,000 --> 01:13:07,330
>> しかし、私は今、string2を開く場合は、ここに違いに気付く。

1629
01:13:07,330 --> 01:13:09,760
string2でここに一つの違いに注目してください。

1630
01:13:09,760 --> 01:13:13,260
string2で、このforループは少し異なっています。

1631
01:13:13,260 --> 01:13:16,350
我々はそれらの別の時間の話ができるように私にはNULLを削除しましょう​​。

1632
01:13:16,350 --> 01:13:18,460
しかし、今回のforループについて何が違うのですか？

1633
01:13:21,580 --> 01:13:23,160
そして、私は、前の例に戻ることができます。

1634
01:13:23,160 --> 01:13:24,800
だからそれはバージョン2です。

1635
01:13:24,800 --> 01:13:27,020
これはバージョン1です。

1636
01:13:27,020 --> 01:13:31,935
つ、2つ、2つ。

1637
01:13:35,030 --> 01:13:38,240
だからstrlenの呼び出しはどこにあるのでしょうか？

1638
01:13:38,240 --> 01:13:40,420
これは、forループの最初の部分にあります。

1639
01:13:40,420 --> 01:13:43,060
私はこれをやっている理由として、任意の考え？

1640
01:13:43,060 --> 01:13:43,690
うん。

1641
01:13:43,690 --> 01:13:46,010
[聞こえない]

1642
01:13:46,010 --> 01:13:47,630
デイヴィッドJ.マラン：だから我々は関数を毎回呼び出す必要はありません。

1643
01:13:47,630 --> 01:13:48,040
その通りです。

1644
01:13:48,040 --> 01:13:50,350
彼らは超簡単だというforループを思い出して、並べ替えの回

1645
01:13:50,350 --> 01:13:52,180
これは初期化であることを理解し、

1646
01:13:52,180 --> 01:13:53,330
状態、および更新。

1647
01:13:53,330 --> 01:13:55,430
問題は、条件はすべての上で起こるということである

1648
01:13:55,430 --> 01:13:56,600
ループの繰り返し。

1649
01:13:56,600 --> 01:13:59,930
ので、ここでは、この例では、どのような事実については悪いです

1650
01:13:59,930 --> 01:14:03,500
これは私の条件であること？

1651
01:14:03,500 --> 01:14:05,920
あなたは何度も何度も何度もstrlenを呼び出しています。

1652
01:14:05,920 --> 01:14:08,990
しかし、かつて私はダビデに入力した、その文字列の長さは5です。

1653
01:14:08,990 --> 01:14:11,560
そしてそれがために、ループの繰り返しごとに変更するつもりはない

1654
01:14:11,560 --> 01:14:15,560
文字列は、まだD-V-I-Dである。だから、これはなるために何が起こっているかでヒントです

1655
01:14:15,560 --> 01:14:19,650
だけではありませんか - デザイン決定、として知られてますます重要な考え方

1656
01:14:19,650 --> 01:14:21,640
コンピュータが不要な仕事を作る。

1657
01:14:21,640 --> 01:14:25,630
>> 今では標準版でのpset 2、psetの2のスニークプレビューがそうであるように

1658
01:14:25,630 --> 01:14:28,850
実際に暗号の一部数は、いくつかを実装するためにあなたに挑戦しよう

1659
01:14:28,850 --> 01:14:32,650
暗号化アルゴリズムの数は、あなたができるように、暗号化と復号化の両方

1660
01:14:32,650 --> 01:14:35,530
ずっと1 Ralphieのような秘密のメッセージが、そこにデコードされます。

1661
01:14:35,530 --> 01:14:38,720
psetの2のハッカー版では、さらに少し行くつもり。

1662
01:14:38,720 --> 01:14:42,010
我々は含まれています、実際のコンピュータシステムからあなたにファイルを渡すつもりだ

1663
01:14:42,010 --> 01:14:45,690
全体のユーザー名と実際の暗号化されたパスワードの束、と挑戦

1664
01:14:45,690 --> 01:14:49,110
ハッカー版はそれらのパスワードや図を解読することを行っているため

1665
01:14:49,110 --> 01:14:53,060
何の暗号か何か秘密が実際に使用された出

1666
01:14:53,060 --> 01:14:55,080
これらのパスワードを生成します。

1667
01:14:55,080 --> 01:14:58,360
そして、我々はここでCの私があげるという新しい機能を使用してこれをやろうとしている

1668
01:14:58,360 --> 01:15:02,200
コマンドライン引数として知られているのは単なるデモ、。

1669
01:15:02,200 --> 01:15:05,930
>> だからそれは、あなた方の何人かがセクションまたは教科書で見たことがあるかもしれないので、判明

1670
01:15:05,930 --> 01:15:09,850
主は必ずカッコ内の空隙である必要はありません。

1671
01:15:09,850 --> 01:15:14,060
それは、主はまた、2つの引数を使用して、このように書くことができることが判明

1672
01:15:14,060 --> 01:15:19,690
argcはあなたが後に入力した単語の数であるargcとargv、

1673
01:15:19,690 --> 01:15:21,940
あなたのコマンドライン上でプログラムの名前。

1674
01:15:21,940 --> 01:15:24,550
とargvは、実際の言葉です。

1675
01:15:24,550 --> 01:15:29,470
そこに角括弧が示唆するようにと、argvは明らかに配列です。

1676
01:15:29,470 --> 01:15:33,720
これは、メモリ内の文字列の後の文字列の後の文字列になるだろう。

1677
01:15:33,720 --> 01:15:36,170
ですから、私たちは、psetの2から始まる、行うことができるとされているつもりだ

1678
01:15:36,170 --> 01:15:37,310
このような何か。

1679
01:15:37,310 --> 01:15:42,450
私たちは月曜日にに戻って来て、実行することになるでしょう例ですargv1を行った場合に

1680
01:15:42,450 --> 01:15:45,180
それは、それはまだ何もしていないようにも注意してください。

1681
01:15:45,180 --> 01:15:47,050
それはちょうど自分自身の名前を出力します。

1682
01:15:47,050 --> 01:15:53,220
しかし、私はこのプログラムは明らかに反復しているさようならクラス、通知を言うなら

1683
01:15:53,220 --> 01:15:57,030
プロンプトで入力された単語のそれぞれの上。

1684
01:15:57,030 --> 01:16:02,050
そして、我々は、ユーザーが持っている言葉へのアクセス権を取得される手段

1685
01:16:02,050 --> 01:16:06,780
プロンプトで入力intから、この週末から始まる、メイン変更することです

1686
01:16:06,780 --> 01:16:10,710
メイン（ボイド）がメイン（のargc、argvを）intへ。

1687
01:16:10,710 --> 01:16:13,700
したがって、コマンドライン引数を生まれてくるだろう。

1688
01:16:13,700 --> 01:16:17,210
そして、一度これで本当に洗練された取得は、次のように記述することができるでしょう

1689
01:16:17,210 --> 01:16:21,370
枠を越えて、更に上に行くようなここでこの1として本当に頭がクラクラするようなプログラムは、

1690
01:16:21,370 --> 01:16:25,520
我々はこれまでが、すべての非常に強力やった機能の一部。

1691
01:16:25,520 --> 01:16:27,330
>> だから我々は、画面上にこれとこれを残しておきます。

1692
01:16:27,330 --> 01:16:29,160
そして、我々は月曜日にお会いしましょう​​。