1
00:00:07,590 --> 00:00:09,920
[Powered by Google Translate] デイヴィッドJ.マラン：全ての権利は​​、これはCS50であり、これは

2
00:00:09,920 --> 00:00:15,250
1週目の終わりには、とても勉強カードがでており、数の合計

3
00:00:15,250 --> 00:00:18,640
あなたが今年持っているクラスメートは745です。

4
00:00:18,640 --> 00:00:20,920
そして、我々はそうもちろん、あなたのように多くを持って興奮している

5
00:00:20,920 --> 00:00:23,680
この学期が、このコースは非常に大きいにもかかわらず、

6
00:00:23,680 --> 00:00:26,090
それは次のように、金曜日のランチのようなこれらの事だと気付く

7
00:00:26,090 --> 00:00:29,020
営業時間は、15人のセクションなど、その

8
00:00:29,020 --> 00:00:30,590
本当にこれは、より親密な作成するために意図されている

9
00:00:30,590 --> 00:00:31,140
環境。

10
00:00:31,140 --> 00:00:34,070
だから我々はここで、週に1,2回集まるかもしれませんが

11
00:00:34,070 --> 00:00:36,420
サンダースは、このコースでは、あなたの経験の多くは知っている

12
00:00:36,420 --> 00:00:39,330
非常にあなたのクラスメートと一緒にハンズオンになります

13
00:00:39,330 --> 00:00:40,730
と教員。

14
00:00:40,730 --> 00:00:43,960
>> そこでここでは、2012年秋、行く。

15
00:00:43,960 --> 00:00:47,530
だから我々の注意に終了し、その最後の時間を思い出す

16
00:00:47,530 --> 00:00:50,460
数の表現について話して不正確、。

17
00:00:50,460 --> 00:00:52,950
そして、我々はで、何が起こった障害のいずれかを見

18
00:00:52,950 --> 00:00:54,920
それは誤解に来た本当の世界では、

19
00:00:54,920 --> 00:00:55,890
どのようにコンピュータが動作します。

20
00:00:55,890 --> 00:00:58,590
さて、今日我々は次のようにそれらのアイデアの別のものを再訪します

21
00:00:58,590 --> 00:01:01,410
同様CS50クライアントの我々の議論を続ける

22
00:01:01,410 --> 00:01:04,090
とCをどのように処理し、プログラムに本当に意味する。

23
00:01:04,090 --> 00:01:06,430
しかし、最初に、旋風のアナウンスだけのカップル。

24
00:01:06,430 --> 00:01:08,930
>> のセクションでは、この日曜日始まり、最初の週は、常に

25
00:01:08,930 --> 00:01:11,030
ラピッドスタートのビット、我々だけになったので

26
00:01:11,030 --> 00:01:12,620
あなたのセクションを形成する。

27
00:01:12,620 --> 00:01:14,450
我々は今、教育の仲間と、今では、同じことをやっている

28
00:01:14,450 --> 00:01:16,410
彼らは自分のスケジュールを知っていること、によって、我々が目指しているので、

29
00:01:16,410 --> 00:01:19,380
土曜日の朝、あなたのセクションであなたをフォローアップするために

30
00:01:19,380 --> 00:01:20,760
割り当ておよびTF。

31
00:01:20,760 --> 00:01:22,770
彼らは翌日から始めましょうことを認識し、日曜日

32
00:01:22,770 --> 00:01:24,510
または月曜日か火曜日。

33
00:01:24,510 --> 00:01:27,730
彼らが発生するようにし、我々はセクションの変更にも対応します

34
00:01:27,730 --> 00:01:28,690
日に来ています。

35
00:01:28,690 --> 00:01:31,590
オフィスの営業時間は、一方で、11から8時、再び、今夜アール

36
00:01:31,590 --> 00:01:33,740
アネンバーグならびに明日の夜。

37
00:01:33,740 --> 00:01:36,150
問題セットは、一般的に木曜日に起因しているにもかかわらず、

38
00:01:36,150 --> 00:01:39,020
正午に、過ごすためにあなたが5後期日まで持って実現する、

39
00:01:39,020 --> 00:01:42,430
木曜日の営業時間故に可用性場合

40
00:01:42,430 --> 00:01:45,930
あなたはそれらの後半の日のいずれかで、現金と、それによって、提出

41
00:01:45,930 --> 00:01:47,070
金曜日に何か。

42
00:01:47,070 --> 00:01:50,850
私の中で、スクラッチがもっと楽しく間にあることを示唆してみよう

43
00:01:50,850 --> 00:01:52,390
もっと低いキー問題セット。

44
00:01:52,390 --> 00:01:55,160
そして私はちょうど、戦略的に、それらの後半の日にしがみつこう

45
00:01:55,160 --> 00:01:57,380
人生は邪魔に起動したとき以降の学期のための

46
00:01:57,380 --> 00:01:59,470
中間試験および他のクラスと一緒。

47
00:01:59,470 --> 00:02:01,580
問題は1を設定し、その間、コースの上に掲示される

48
00:02:01,580 --> 00:02:06,080
ホームページ今週の金曜日、もちろん徒歩になりますように

49
00:02:06,080 --> 00:02:08,789
ビデオを通して、これらは金曜日に午後2時30分撮影され

50
00:02:08,789 --> 00:02:11,890
そして次の日までにオンラインで掲示。

51
00:02:11,890 --> 00:02:13,880
>> だから我々は月曜日に終了しました。

52
00:02:13,880 --> 00:02:15,450
実際に、自分がここに注意 - 私がしたいと思います。

53
00:02:15,450 --> 00:02:18,870
なぜならクラス - サンダースは正確に向いていないので、

54
00:02:18,870 --> 00:02:22,220
自体カジュアルなQ＆Aに戻って行ったり来たりひどくよく、我々はしている

55
00:02:22,220 --> 00:02:24,030
これにより、今年はほとんど何か新しいことをしようとするつもり

56
00:02:24,030 --> 00:02:26,160
あなたは自分の手を上げ快適じゃないか、あれば

57
00:02:26,160 --> 00:02:28,800
むしろ、このような部屋の中に手を上げない

58
00:02:28,800 --> 00:02:30,710
我々は、指導員とCAのいくつかを持っているつもりです

59
00:02:30,710 --> 00:02:33,260
講義中cs50.net/discussを配乗。

60
00:02:33,260 --> 00:02:35,440
だから私は完全だったので、ご質問がある場合は

61
00:02:35,440 --> 00:02:37,510
何か、については不明ではいくつかのは、興味を持っている

62
00:02:37,510 --> 00:02:39,640
トピックでは、そこにそれを投稿してみて。

63
00:02:39,640 --> 00:02:42,670
講義のラベルでタグ付け、そして我々は最善を尽くします

64
00:02:42,670 --> 00:02:45,430
今日と来週 -  we'llこれを試してみる - それをフィールドへ

65
00:02:45,430 --> 00:02:47,990
どちら電子的に、オンラインで、または場合、それは我々があるべきであるように感じている

66
00:02:47,990 --> 00:02:50,430
本当に、一斉指導の仲間の​​一つをそれに対処または

67
00:02:50,430 --> 00:02:52,080
CAの中には、手を上げて聞いてきます

68
00:02:52,080 --> 00:02:53,480
あなたに代わって匿名で。

69
00:02:53,480 --> 00:02:55,650
だから我々はこれを試してみて、どれだけこの作品を見てみるよ。

70
00:02:55,650 --> 00:02:58,540
しかし、すべての手段によって、あなたが希望として手を上げ続けています。

71
00:02:58,540 --> 00:03:11,420
>> 我々は10％以上10分の1ではなく、であることを明らかにしたので、最後の時間

72
00:03:11,420 --> 00:03:13,840
あなたは何年も前に教えられたように実際、0.1、。

73
00:03:13,840 --> 00:03:15,390
それは、実際にこのような値です。

74
00:03:15,390 --> 00:03:16,970
しかし、それは右、完全に真実ではないですか？

75
00:03:16,970 --> 00:03:19,585
我々は、ちょうどあなたの場合、それによってコンピュータにこの制約を持っている

76
00:03:19,585 --> 00:03:22,450
のみ有限のメモリの量、RAMまたはそれ以上を持っている

77
00:03:22,450 --> 00:03:25,220
特にビットは、まあ、有限数だけあり

78
00:03:25,220 --> 00:03:26,980
物事には表すことができます。

79
00:03:26,980 --> 00:03:29,780
例えば、我々は数字のゼロを持って、私たちがしたい場合は

80
00:03:29,780 --> 00:03:32,790
どこビット、8ビットを使用して、バイナリで表す

81
00:03:32,790 --> 00:03:34,710
再び、0または1であり、我々は可能性がある

82
00:03:34,710 --> 00:03:39,240
00000000としてそれを表しています。

83
00:03:39,240 --> 00:03:41,160
そして、それは少し不必要に冗長です。

84
00:03:41,160 --> 00:03:43,700
ただ、現実の世界では十進法で好き

85
00:03:43,700 --> 00:03:47,040
一般的には、番号123を作成したければ、

86
00:03:47,040 --> 00:03:52,240
人間はおそらく、たとえ00000123を書いてはいけません

87
00:03:52,240 --> 00:03:53,940
機能的には、それはまったく同じ数字です。

88
00:03:53,940 --> 00:03:56,580
我々だけで、いわば先行ゼロをドロップします。

89
00:03:56,580 --> 00:03:58,270
>> バイナリでは、同じことを行うことができます。

90
00:03:58,270 --> 00:04:01,440
バイナリデータとゼロ、ゼロ、バイナリだけでゼロになります。

91
00:04:01,440 --> 00:04:02,870
あなただけの単一のビットを必要としています。

92
00:04:02,870 --> 00:04:05,020
しかし、再び、世界のメジャーの最も一般的なユニット

93
00:04:05,020 --> 00:04:07,820
コンピューティングのバイト、8ビットである。

94
00:04:07,820 --> 00:04:09,720
という理由だけで1ビット、全く使い物にならないわ。

95
00:04:09,720 --> 00:04:12,020
8ビット、ひどく有用ではありませんが、少なくともそれは、さらに

96
00:04:12,020 --> 00:04:14,280
メジャーの単一ユニットより便利。

97
00:04:14,280 --> 00:04:17,100
だから8ビットで、当社は通常、バイナリを表現します。

98
00:04:17,100 --> 00:04:20,459
そこでここでは、のように、その後の数字がゼロ、1つ、2つを持っており、

99
00:04:20,459 --> 00:04:24,200
ネイトは先週の水曜日、私たちのビデオでやった、我々は継続することができ

100
00:04:24,200 --> 00:04:25,940
8に、7までカウントアップ。

101
00:04:25,940 --> 00:04:27,860
そして、我々はより多くのビットを使用する場合、我々

102
00:04:27,860 --> 00:04:29,880
無限まで数えることが出来る。

103
00:04:29,880 --> 00:04:32,800
あなたが唯一のこれらのビットの有限数を持っている場合でも、そのままで

104
00:04:32,800 --> 00:04:35,030
任意のコンピュータ·システムの場合、あるいはミサイル

105
00:04:35,030 --> 00:04:36,670
システムは、まあ、確かにあなただけの持っている

106
00:04:36,670 --> 00:04:37,900
精度の有限な量。

107
00:04:37,900 --> 00:04:41,290
あなたにも、0.1のように数字を表現したいのであれば、

108
00:04:41,290 --> 00:04:43,410
コンピュータがピックアップして選択する必要があります。

109
00:04:43,410 --> 00:04:45,970
それだけで、それができる数の有限数を持っている場合

110
00:04:45,970 --> 00:04:50,490
表し、それはあなたのために0.1に近い来ることができますが、それはできません

111
00:04:50,490 --> 00:04:53,730
必ずしもあなたが望むことを正確に値を与える。

112
00:04:53,730 --> 00:04:55,660
そして、これは、単にコンピュータの課題の一つである

113
00:04:55,660 --> 00:04:57,090
ボンネットの下に、ありがたい。

114
00:04:57,090 --> 00:04:59,110
>> 私たちは学期に遠くに移動すると、これらの下位レベル

115
00:04:59,110 --> 00:05:02,310
詳細はあまり興味深いものとなるが、確かに

116
00:05:02,310 --> 00:05:05,700
これらのアイデアのアプリケーションは、いくつかの非常に現実の世界を持つことができます

117
00:05:05,700 --> 00:05:06,760
影響。

118
00:05:06,760 --> 00:05:08,190
一つは、少し楽しいです。

119
00:05:08,190 --> 00:05:12,150
どのようにあなたがたの多くは、驚くべき映画のオフィススペースを見てきました？

120
00:05:12,150 --> 00:05:13,620
あなたがいない場合、それはあなたの非公式だ

121
00:05:13,620 --> 00:05:14,370
今週の宿題。

122
00:05:14,370 --> 00:05:16,730
しかし、オフィススペースで、その映画の中でフェローがかかる

123
00:05:16,730 --> 00:05:19,900
まさにこの考え方の利点が、実際には盗んだ

124
00:05:19,900 --> 00:05:21,270
それはあなたが持つかもしれないことを別のムービーから

125
00:05:21,270 --> 00:05:22,760
何年も前に見た。

126
00:05:22,760 --> 00:05:24,920
だから私はあなたにこのトレーラーの数秒からを与えることができます

127
00:05:24,920 --> 00:05:27,470
この素晴らしい映画を、これは非常によく似ている

128
00:05:27,470 --> 00:05:28,340
学問的に関連する。

129
00:05:28,340 --> 00:05:30,310
>> [ムービーを再生]

130
00:05:30,310 --> 00:05:32,240
実際に私が推進されています。

131
00:05:32,240 --> 00:05:33,360
私はそれをリッピングするウイルスをプログラムすることができます

132
00:05:33,360 --> 00:05:34,460
大きな時間をオフに置きます。

133
00:05:34,460 --> 00:05:35,770
まあ、それはどのように動作しますか？

134
00:05:35,770 --> 00:05:37,836
関心がある銀行取引があるたびに

135
00:05:37,836 --> 00:05:40,154
計算された、何千もの日があると、コンピュータが終わる

136
00:05:40,154 --> 00:05:41,040
セントのこれらの画分である。

137
00:05:41,040 --> 00:05:43,050
しかし、私は違法何もするつもりはない。

138
00:05:43,050 --> 00:05:46,730
違法？サミールは、これはアメリカです。

139
00:05:46,730 --> 00:05:48,010
あなたは神に誓ってしなければならない。

140
00:05:48,010 --> 00:05:51,870
誰もがこのことについて知りませんが、私たちの場合は、すべての権利？いいえ、家族があってはなりません。

141
00:05:51,870 --> 00:05:52,490
恋人、誰も。

142
00:05:52,490 --> 00:05:53,882
[聞こえない]。

143
00:05:53,882 --> 00:05:57,594
男は、私はどちらか誰も教えてくれません、心配しないでください。

144
00:05:57,594 --> 00:05:59,680
[ムービー即決]

145
00:05:59,680 --> 00:06:01,900
>> すべての権利なので、多分私はほとんどよりもこの映画良い発見

146
00:06:01,900 --> 00:06:05,530
彼らがいたことをここの人々が、どのような場合でも、ウイルス

147
00:06:05,530 --> 00:06:06,400
作成しようとしている - 

148
00:06:06,400 --> 00:06:08,410
そして映画の中で、いつでも、彼らは、何かウイルスと呼んでおきます

149
00:06:08,410 --> 00:06:09,770
それは実際には一般的にウイルスはありません。

150
00:06:09,770 --> 00:06:11,600
それはちょうど、誰かが何かを書いたプログラムです。

151
00:06:11,600 --> 00:06:13,800
この場合には、みんながプログラムを作成しようとした

152
00:06:13,800 --> 00:06:16,610
それは、イノテックのと呼ばれる彼らの会社を利用しました

153
00:06:16,610 --> 00:06:19,740
コンピューティングシステムは、あまりにもそれによってコンピュータは、場合でも、それ

154
00:06:19,740 --> 00:06:21,350
することはできません必ずしも、お金になる

155
00:06:21,350 --> 00:06:23,490
正確に金額を表す。

156
00:06:23,490 --> 00:06:27,630
ですから、あなたの銀行口座に$ 0.10を持っている場合でも、

157
00:06:27,630 --> 00:06:31,060
0.10、まあ、コンピュータが実際にあなたが持っていると思うかもしれません

158
00:06:31,060 --> 00:06:33,560
あなたの銀行口座にこれだけ多くのセント。

159
00:06:33,560 --> 00:06:35,750
それで、これらの人がやることを夢見ていたもの - そして、彼ら

160
00:06:35,750 --> 00:06:38,240
アイデアを盗んだ、それはどこに、スーパーマンIIIから判明

161
00:06:38,240 --> 00:06:41,210
リチャード·プライヤーは、同じ事をした - 彼らは本質的にあった

162
00:06:41,210 --> 00:06:44,880
後続のすべてを取ることを熱望する書き込みプログラム

163
00:06:44,880 --> 00:06:46,930
数字の小さな小さな、小さな画分のすべて

164
00:06:46,930 --> 00:06:50,160
ペニー、その人間はちょうどので、それらをオフに吸い上げる

165
00:06:50,160 --> 00:06:52,620
思考は、ああ、それはそこだけ0.10ドルだが、それらのすべて

166
00:06:52,620 --> 00:06:54,410
末尾の数字は最終的に追加します。

167
00:06:54,410 --> 00:06:57,490
素晴らしいアイデアは、だから、それが裏目に出たという点で、陽気に

168
00:06:57,490 --> 00:06:58,250
特定のフィルム。

169
00:06:58,250 --> 00:07:01,800
>> しかし、現実の世界でも、多くの関係がある

170
00:07:01,800 --> 00:07:03,190
物事のこれらの種類の影響。

171
00:07:03,190 --> 00:07:05,450
と理由の一つは、コンピュータの分野に飛び込む

172
00:07:05,450 --> 00:07:07,620
科学は、再びではなく、への適用である

173
00:07:07,620 --> 00:07:09,740
エンジニアリング科学単独で、ただへ

174
00:07:09,740 --> 00:07:10,650
他の分野と同様。

175
00:07:10,650 --> 00:07:14,760
だから、これは間違って行くことができるかではあまり気軽な外観です​​が、

176
00:07:14,760 --> 00:07:17,630
それがに来るとき、それは、私が思うに、また、非常にアイ開口の

177
00:07:17,630 --> 00:07:20,760
正確にどのように遍在する技術のような理解

178
00:07:20,760 --> 00:07:22,870
コンピュータやプログラミングや、これらの日、

179
00:07:22,870 --> 00:07:23,930
ソフトウェアの形である。

180
00:07:23,930 --> 00:07:26,500
だから、これの次のクリップは、わずか6分程度で続けて

181
00:07:26,500 --> 00:07:30,320
我々は最後の時間をオフのままにしますが、私たちは少し検索することができますどこに

182
00:07:30,320 --> 00:07:33,370
これらの問題のような1つの深さでより。

183
00:07:33,370 --> 00:07:35,270
私は、我々が去ったところまで進んでみましょう、

184
00:07:35,270 --> 00:07:37,780
これは、右ここにあった。

185
00:07:37,780 --> 00:07:41,580
そして、我々はここで6分程度、2の第2部を持っています。

186
00:07:41,580 --> 00:07:41,980
>> [ムービーを再生]

187
00:07:41,980 --> 00:07:45,430
現代のロケット技術を苦しめ。

188
00:07:45,430 --> 00:07:49,280
1991年、第一次湾岸戦争の開始とともに、パトリオット

189
00:07:49,280 --> 00:07:51,350
ミサイルは似たような種類のを経験した

190
00:07:51,350 --> 00:07:52,645
数値変換の問題。

191
00:07:52,645 --> 00:07:57,460
その結果として、20人、20人の米兵が殺された

192
00:07:57,460 --> 00:08:01,130
負傷者は約100人、ときになっていたパトリオット、

193
00:08:01,130 --> 00:08:03,400
着信スカッドから守るために、

194
00:08:03,400 --> 00:08:06,020
ミサイルを発射することができませんでした。

195
00:08:06,020 --> 00:08:09,350
>> イラクがクウェートに侵攻し、アメリカは砂漠を進水させたとき

196
00:08:09,350 --> 00:08:13,530
早い1991年に嵐、パトリオットミサイルのバッテリーはあった

197
00:08:13,530 --> 00:08:16,970
イラクからサウジアラビア、イスラエルを守るために配備され

198
00:08:16,970 --> 00:08:19,810
スカッドミサイル攻撃。

199
00:08:19,810 --> 00:08:23,740
パトリオットは、米国の中​​距離地対空システムです

200
00:08:23,740 --> 00:08:26,370
レイセオン社製。

201
00:08:26,370 --> 00:08:30,860
パトリオット迎撃機自体の大きさは、それについてです

202
00:08:30,860 --> 00:08:35,650
約20フィートの長い、それは約2000ポンドの重量を量る。

203
00:08:35,650 --> 00:08:38,809
そして、それは程度の弾頭を運ぶ - 私はそれが大体だと思う

204
00:08:38,809 --> 00:08:40,169
150ポンド。

205
00:08:40,169 --> 00:08:45,820
そして弾頭自体が持つ高性能爆薬である

206
00:08:45,820 --> 00:08:48,120
その周りの断片。

207
00:08:48,120 --> 00:08:51,870
弾頭のケーシングは、散弾のように機能するように設計されています。

208
00:08:51,870 --> 00:08:54,920
ミサイルはコンテナごとに4つを搭載し、アールアール

209
00:08:54,920 --> 00:08:57,850
セミトレーラーで輸送されます。

210
00:08:57,850 --> 00:09:02,940
>> パトリオットミサイル防衛システムは、少なくともまでさかのぼり

211
00:09:02,940 --> 00:09:05,530
現在20歳。

212
00:09:05,530 --> 00:09:09,150
それはもともとの防空ミサイルとして設計されました

213
00:09:09,150 --> 00:09:12,920
第一次湾岸戦争では、敵の飛行機を撃墜する。

214
00:09:12,920 --> 00:09:17,700
戦争が一緒に来たとき、軍隊は撃つためにそれを使用したい

215
00:09:17,700 --> 00:09:19,880
スカッドはなく、飛行機ダウン。

216
00:09:19,880 --> 00:09:24,860
エアイラク空軍はあまり問題ではありませんでしたが、陸軍

217
00:09:24,860 --> 00:09:27,260
スカッドを心配していた。

218
00:09:27,260 --> 00:09:30,810
そして彼らは愛国をアップグレードしようとした。

219
00:09:30,810 --> 00:09:33,770
マッハ5で移動して敵のミサイルが起こっていたインターセプト

220
00:09:33,770 --> 00:09:35,790
十分に挑戦することができます。

221
00:09:35,790 --> 00:09:39,460
しかし、パトリオットをサービスに連れて行かれました、陸軍

222
00:09:39,460 --> 00:09:43,730
自分を作ったイラクの変更を認識していなかった

223
00:09:43,730 --> 00:09:46,510
ヒットするのはほとんど不可能スカッド。

224
00:09:46,510 --> 00:09:50,040
>> 何が起きたことはあったスカッドです

225
00:09:50,040 --> 00:09:51,360
入ってくると、不安定であった。

226
00:09:51,360 --> 00:09:52,266
彼らはウォブリングされた。

227
00:09:52,266 --> 00:09:56,300
この理由は、600を取得するために、イラク人であった

228
00:09:56,300 --> 00:10:00,650
300キロ範囲ミサイルのキロアウトは、かかった

229
00:10:00,650 --> 00:10:02,423
フロント弾頭の重量と外

230
00:10:02,423 --> 00:10:03,990
軽い弾頭を作った。

231
00:10:03,990 --> 00:10:08,700
だから今、愛国者はスカッドで来るようにしようと、ほとんどのだ

232
00:10:08,700 --> 00:10:11,192
時間、時間の圧倒的多数は、それがでしょう

233
00:10:11,192 --> 00:10:13,450
ちょうどスカッドで飛ぶ。

234
00:10:13,450 --> 00:10:16,300
パトリオット·システムオペレータは、パトリオットを実現したら

235
00:10:16,300 --> 00:10:20,160
そのターゲットを逃したが、彼らは愛国者の弾頭を爆発させた。

236
00:10:20,160 --> 00:10:22,760
可能な死傷を回避するために、許可された

237
00:10:22,760 --> 00:10:25,100
地面に落下する。

238
00:10:25,100 --> 00:10:29,400
それは、空に大きな火の玉のように、ほとんどの人が見たものだった

239
00:10:29,400 --> 00:10:34,930
とスカッドの弾頭のインターセプトと誤解。

240
00:10:34,930 --> 00:10:37,490
>> 夜空に、愛国者であるように見えたが、

241
00:10:37,490 --> 00:10:41,570
首尾よく破壊されたスカッドは、ダーランで、何があるかもしれない

242
00:10:41,570 --> 00:10:43,730
そのパフォーマンスについて間違い。

243
00:10:43,730 --> 00:10:46,370
そこでは、パトリオットのレーダーシステムが見失ってしまった

244
00:10:46,370 --> 00:10:50,090
スカッド着信および起因打ち上げたことがない

245
00:10:50,090 --> 00:10:51,340
ソフトウェアの欠陥に。

246
00:10:54,030 --> 00:10:57,050
それは最初になったことを発見したイスラエル人だった

247
00:10:57,050 --> 00:11:02,000
システムは、大きな時間のずれがなっていた

248
00:11:02,000 --> 00:11:05,530
システムのコンピュータに埋め込まれたクロックに起因する。

249
00:11:05,530 --> 00:11:09,060
ダーランの悲劇の前に約2週間、

250
00:11:09,060 --> 00:11:11,730
イスラエル人はその国防総省に報告

251
00:11:11,730 --> 00:11:13,250
システムは時間を失っていた。

252
00:11:13,250 --> 00:11:15,610
実行中の約8時間後、彼らは気づいた

253
00:11:15,610 --> 00:11:18,330
システムが著しく少ない正確​​になっていた。

254
00:11:18,330 --> 00:11:20,910
国防省のすべてを伝えることで対応

255
00:11:20,910 --> 00:11:23,710
パトリオット電池はシステムを残さないようにすること

256
00:11:23,710 --> 00:11:25,450
長い時間のために。

257
00:11:25,450 --> 00:11:28,010
8時間、10  - 彼らは長い時間が何であったか言わなかった

258
00:11:28,010 --> 00:11:29,690
時間、1,000時間。

259
00:11:29,690 --> 00:11:31,940
誰も知りませんでした。

260
00:11:31,940 --> 00:11:35,020
>> ダーランで兵舎に駐屯パトリオットバッテリー

261
00:11:35,020 --> 00:11:39,030
その欠陥の内部クロックはオン100時間以上にしていた

262
00:11:39,030 --> 00:11:42,240
2月25日の夜。

263
00:11:42,240 --> 00:11:46,580
それは10分の1秒程度の精度で時間を追跡した。

264
00:11:46,580 --> 00:11:48,830
今では10分の1秒は面白い数であるため、

265
00:11:48,830 --> 00:11:52,660
それはつまり、正確には、バイナリで表現することはできません

266
00:11:52,660 --> 00:11:54,940
それは、任意で正確に表現することはできません

267
00:11:54,940 --> 00:11:57,330
現代のデジタルコンピュータ。

268
00:11:57,330 --> 00:11:59,130
それは信じがたい。

269
00:11:59,130 --> 00:12:01,720
しかし、例として、これを使用しています。

270
00:12:01,720 --> 00:12:04,090
>> のは、ナンバーワンの三分の一を見てみましょう。

271
00:12:04,090 --> 00:12:07,950
三分の一が正確に、10進数で表記することはできません。

272
00:12:07,950 --> 00:12:12,710
三分の一が、0.333は無限大のために起こっている。

273
00:12:12,710 --> 00:12:17,050
小数点以下の絶対精度でそれを行う方法はありません。

274
00:12:17,050 --> 00:12:19,340
それはまさにで起こった問題と同じようなものだ

275
00:12:19,340 --> 00:12:20,190
パトリオット。

276
00:12:20,190 --> 00:12:24,680
もはやシステムが走り、悪化時エラーになりました。

277
00:12:24,680 --> 00:12:28,640
操作100時間の後、時間の誤差があっただけ

278
00:12:28,640 --> 00:12:29,870
第二の約3分の1。

279
00:12:29,870 --> 00:12:34,790
しかし、マッハ5で走行ミサイルを標的にするという点で、

280
00:12:34,790 --> 00:12:39,140
それは、600メートル以上のトラッキングエラーが発生しました。

281
00:12:39,140 --> 00:12:42,510
それは、ダーランで兵士のための致命的なエラーになります。

282
00:12:42,510 --> 00:12:48,680
>> 何が起こったのはスカッドの発射では、早期警戒によって検出されました

283
00:12:48,680 --> 00:12:52,440
衛星と彼らはスカッドが自分に来ていたことを知っていた

284
00:12:52,440 --> 00:12:53,350
一般的な方向。

285
00:12:53,350 --> 00:12:55,470
彼らはそれが来ていたどこにいるのかわからなかった。

286
00:12:55,470 --> 00:12:58,210
それは、パトリオットのレーダー部品に今まであった

287
00:12:58,210 --> 00:13:01,920
のトラックを見つけ、維持するためのシステム、ダーランを擁護し、

288
00:13:01,920 --> 00:13:03,700
入ってくる敵ミサイル。

289
00:13:03,700 --> 00:13:05,390
レーダーはとてもかっこよかったです。

290
00:13:05,390 --> 00:13:07,570
あなたが実際にスカッドの位置を追跡してからでしょう

291
00:13:07,570 --> 00:13:10,340
それはおそらく、次回であろう場所を予測

292
00:13:10,340 --> 00:13:12,040
レーダーはパルスを送った。

293
00:13:12,040 --> 00:13:13,730
その範囲は、ゲートと呼ばれていました。

294
00:13:13,730 --> 00:13:18,820
その後、一度パトリオットは十分な時間が経過して行くことに決定

295
00:13:18,820 --> 00:13:22,600
背中と検出これについては、次の場所を確認

296
00:13:22,600 --> 00:13:24,190
オブジェクトは、それはさかのぼる。

297
00:13:24,190 --> 00:13:27,940
だから、それは間違った場所に戻ったとき、それはその後全く見ない

298
00:13:27,940 --> 00:13:31,000
オブジェクト、そしてそれはどんなオブジェクトにも存在しなかったと判断します。

299
00:13:31,000 --> 00:13:34,370
それは誤検出だったとトラックをドロップします。

300
00:13:34,370 --> 00:13:37,630
>> 着信スカッドはレーダー画面から姿を消した。

301
00:13:37,630 --> 00:13:41,300
そして数秒後には、兵舎に突っ込んだ。スカッドミサイル

302
00:13:41,300 --> 00:13:44,730
28人が死亡し、中に発射最後の一つだった

303
00:13:44,730 --> 00:13:46,450
第一次湾岸戦争。

304
00:13:46,450 --> 00:13:50,570
悲劇的に、更新されたソフトウェアは、ダーランに到着

305
00:13:50,570 --> 00:13:52,060
次の日。

306
00:13:52,060 --> 00:13:56,210
およびソフトウェアの欠陥が1つの章を閉じ、固定されていた

307
00:13:56,210 --> 00:13:58,370
パトリオット·ミサイルの問題を抱えた歴史。

308
00:14:01,790 --> 00:14:04,990
愛国者は実際には "フェーズドアレイトラッキングのための頭字語である

309
00:14:04,990 --> 00:14:08,516
ターゲットの切片。 "

310
00:14:08,516 --> 00:14:13,390
>> はなく、かなりのすべての権利は​​、そんなに多く哀しい結末

311
00:14:13,390 --> 00:14:14,430
この世界を理解する。

312
00:14:14,430 --> 00:14:18,180
と持ち帰りは、本当に、フィルムからのものであることを解

313
00:14:18,180 --> 00:14:20,790
あなたのミサイル防衛システムが再起動されました

314
00:14:20,790 --> 00:14:21,770
たまにインチ

315
00:14:21,770 --> 00:14:24,280
それで再び、このコースの目的の一つは、確かに

316
00:14:24,280 --> 00:14:26,900
これらのアプリケーションよりも謙虚な規模で、することです

317
00:14:26,900 --> 00:14:30,710
あなたが約行く方法を正確に本当にオープンみんなの目

318
00:14:30,710 --> 00:14:34,380
製造機は、あなたは彼らが何をしたいか、あなたはどのように行く

319
00:14:34,380 --> 00:14:37,180
道に沿って、それをやりながら、正しくそれをすることについて

320
00:14:37,180 --> 00:14:38,810
よく、エレガントなど。

321
00:14:38,810 --> 00:14:41,680
それで今日は、これのより少しに飛び込むみましょうが、

322
00:14:41,680 --> 00:14:44,210
我々は、より少ない特にそれらのために、速すぎて行かないように

323
00:14:44,210 --> 00:14:46,590
我々が関心を保持できるように、また快適であるが、

324
00:14:46,590 --> 00:14:49,390
それらをより快適に、ビットで始まるだけ速くしてみましょう

325
00:14:49,390 --> 00:14:50,970
これらのアイデアのいくつかの要約の。

326
00:14:50,970 --> 00:14:53,710
あなたが持っている場合、もう一度、両方の人またはオンラインで、離れて頼む

327
00:14:53,710 --> 00:14:56,320
質問私たちは同じページ上のすべての人を維持することができます。

328
00:14:56,320 --> 00:14:58,820
>> だからCS50アプライアンス、バッククイックステップは、ある

329
00:14:58,820 --> 00:15:02,360
あなた自身の言葉で、何？

330
00:15:02,360 --> 00:15:06,454
あなたがそれらの言葉はまだかもしれないか見当がつかない場合には、これはOKです。

331
00:15:06,454 --> 00:15:07,830
[聞こえない]

332
00:15:07,830 --> 00:15:10,950
さて、のための普遍的なインターフェイス - 

333
00:15:10,950 --> 00:15:11,900
我々はすべて共有することができます。

334
00:15:11,900 --> 00:15:12,470
絶対に。

335
00:15:12,470 --> 00:15:14,840
だから我々は、例えば、いくつかに行くように言うことができる

336
00:15:14,840 --> 00:15:16,910
ウェブサイトは、Mac OSのためのこのソフトウェアをダウンロードしてください。

337
00:15:16,910 --> 00:15:19,140
に設定し、Windows用のこのソフトウェアをダウンロードする

338
00:15:19,140 --> 00:15:20,100
このようにしている。

339
00:15:20,100 --> 00:15:22,370
しかし、現実には、我々は無数の技術的に実行され

340
00:15:22,370 --> 00:15:23,200
問題をサポート。

341
00:15:23,200 --> 00:15:26,630
サーバ側を行われていることの多く、また、これらの日、、

342
00:15:26,630 --> 00:15:28,490
に来る場合は特に、コンピューティングの世界では、

343
00:15:28,490 --> 00:15:31,460
Web開発とWebベースのアプリケーションは、実際には

344
00:15:31,460 --> 00:15:35,110
とは対照的に、かなり頻繁に、UNIXまたはLinuxコンピュータ上で行われ

345
00:15:35,110 --> 00:15:36,800
MacやWindowsパソコン。

346
00:15:36,800 --> 00:15:39,240
>> だから五分五分の間で、その後、この事を使用するのではと呼ばれる

347
00:15:39,240 --> 00:15:41,500
CS50アプライアンスは、我々はすべて同じ環境があるでしょうです。

348
00:15:41,500 --> 00:15:43,670
だから、皆が同じページにどのようなハードウェアあなたどんなにません

349
00:15:43,670 --> 00:15:46,650
でキャンパスに来ただけでなく、正確に手を染めされます

350
00:15:46,650 --> 00:15:48,230
あなたが向かって使用することがありますのと同じ環境

351
00:15:48,230 --> 00:15:51,080
よくWeb開発のためのと同様、のように学期の終わり

352
00:15:51,080 --> 00:15:53,580
その現実世界のアプリケーションの将来。

353
00:15:53,580 --> 00:15:56,350
だからもっと具体的に、CS50 Applianceはの自由な作品です

354
00:15:56,350 --> 00:15:59,400
あなたが別のオペレーティングシステムを実行することを可能にするソフトウェア、

355
00:15:59,400 --> 00:16:02,670
Linuxでは、この場合には、自分のコンピュータ上で、ウィンドウに表示されます。

356
00:16:02,670 --> 00:16:04,750
今、あなたはちょうどアプライアンスをダウンロードすることはできません。

357
00:16:04,750 --> 00:16:08,170
アプライアンスを再生したり、実行するとプログラムが必要です。

358
00:16:08,170 --> 00:16:11,220
およびソフトウェアのその部分は、一般に知られている

359
00:16:11,220 --> 00:16:11,520
ハイパーバイザ。

360
00:16:11,520 --> 00:16:14,050
ハイパーバイザーは、VMwareのような製品の形で来る

361
00:16:14,050 --> 00:16:15,820
バーチャルボックスは、Parallels。

362
00:16:15,820 --> 00:16:18,390
企業のすべての種類は、無料で両方、​​ソフトウェアを作る

363
00:16:18,390 --> 00:16:19,310
同様に、商業。

364
00:16:19,310 --> 00:16:21,480
あなたが問題に表示されます何セット1は、以下の方法についての説明があり

365
00:16:21,480 --> 00:16:23,440
フリーソフトウェアを入手しているのと

366
00:16:23,440 --> 00:16:25,000
CS50アプライアンスを実行します。

367
00:16:25,000 --> 00:16:28,060
そして、一度、あなたは、お使いのMacまたはPC上のウィンドウで、必要があるでしょうか

368
00:16:28,060 --> 00:16:30,710
非常にこのようになりますデスクトップ環境、どこ

369
00:16:30,710 --> 00:16:33,100
それは、[スタート]メニューのようなものを持ってい

370
00:16:33,100 --> 00:16:34,510
左下隅。

371
00:16:34,510 --> 00:16:38,030
それは左上に、ホームフォルダ、またはホームディレクトリを持ってい

372
00:16:38,030 --> 00:16:40,280
そこに、ごみ箱など。

373
00:16:40,280 --> 00:16:43,450
だから我々は我々が行くように必要な詳細情報を離れていじめるよ。

374
00:16:43,450 --> 00:16:46,430
>> しかし、今でに飛び込むことから始めましょう

375
00:16:46,430 --> 00:16:49,200
だからCは精神においてと同様に、このプログラミング言語です。

376
00:16:49,200 --> 00:16:52,390
スクラッチが、はるかに少ないグラフィカルですが、皮肉なことに、遠く

377
00:16:52,390 --> 00:16:54,730
あなたがそれに精通し得れば、より強力。

378
00:16:54,730 --> 00:16:58,970
だからCで、私達はある、ソースコードを記述することでプログラムを書く

379
00:16:58,970 --> 00:17:01,640
靴下と同様に、この英語のような構文、

380
00:17:01,640 --> 00:17:05,609
私たちはあなたのことが可能になり、前回やったデモンストレーション

381
00:17:05,609 --> 00:17:07,910
あれば、かなり正確に自分を表現する

382
00:17:07,910 --> 00:17:09,760
arcanely、コンピュータに接続します。

383
00:17:09,760 --> 00:17:11,960
>> だから、実際に製品ソフトウェアの種類が必要なのでしょうか

384
00:17:11,960 --> 00:17:15,520
当社に基づいて、Cのようなプログラミング言語でプログラムを記述する

385
00:17:15,520 --> 00:17:17,492
月曜日に会話？

386
00:17:17,492 --> 00:17:19,650
[聞こえない]

387
00:17:19,650 --> 00:17:21,079
[OK]を、あなたはただのテキストエディタが必要です。

388
00:17:21,079 --> 00:17:22,890
あなたは、特別なソフトウェアを必要としない

389
00:17:22,890 --> 00:17:24,460
それ自体がプログラムを書き込むことができます。

390
00:17:24,460 --> 00:17:27,220
あなたはただ、Windows上では、メモ帳などのテキストエディタが必要です

391
00:17:27,220 --> 00:17:30,450
の世界ではMac上でテキストエディット、やgeditと呼ばれるもの、

392
00:17:30,450 --> 00:17:32,020
我々がここで使うLinuxでは、。

393
00:17:32,020 --> 00:17:33,750
そして、それはプログラムを書くことが、それだ。

394
00:17:33,750 --> 00:17:35,480
>> しかし、書き込みは方程式の半分だけです。

395
00:17:35,480 --> 00:17:36,630
その後、それらを実行する必要があります。

396
00:17:36,630 --> 00:17:38,320
しかし、プログラムを実行するために - 

397
00:17:38,320 --> 00:17:39,600
あなたは、ソースコードを実行することはできません。

398
00:17:39,600 --> 00:17:41,500
代わりに、最初に何をしなければならない？

399
00:17:41,500 --> 00:17:41,900
うん。

400
00:17:41,900 --> 00:17:43,200
デイヴィッドJ.マラン：あなたがする必要がある

401
00:17:43,200 --> 00:17:44,130
それをコンパイルします。

402
00:17:44,130 --> 00:17:49,010
そして、他の誰かが、ソースコードをコンパイルすることを意味 - 

403
00:17:49,010 --> 00:17:50,260
[聞こえない]

404
00:17:52,300 --> 00:17:52,700
デイヴィッドJ.マラン：その通りです。

405
00:17:52,700 --> 00:17:54,430
ゼロとものにそれを翻訳します。

406
00:17:54,430 --> 00:17:57,150
私たちのすべて、これらの日は、CPUを持つコンピュータを持っているので、

407
00:17:57,150 --> 00:18:00,350
ほとんどインテルという会社によって作られてすべてが、と

408
00:18:00,350 --> 00:18:03,320
Intel Insideは、あなたのこの脳内があることを意味し

409
00:18:03,320 --> 00:18:04,990
CPUとして知られているコンピュータ。

410
00:18:04,990 --> 00:18:07,570
そして、その脳がないことの一つは、それが知っている、ある

411
00:18:07,570 --> 00:18:10,390
0と1のパターンを理解する方法について説明します。

412
00:18:10,390 --> 00:18:13,240
これは、ビットのパターンが加算を表しているもの知っていること

413
00:18:13,240 --> 00:18:15,500
パターンは減算を示し、どのようなパターンの

414
00:18:15,500 --> 00:18:18,890
ビットは、印刷、可聴音を作成表す。

415
00:18:18,890 --> 00:18:22,450
>> だから短い、CPUのオペレーティングシステムと相まって、

416
00:18:22,450 --> 00:18:25,230
これは、CPUの上で動作するソフトウェアの一部です

417
00:18:25,230 --> 00:18:26,050
いわば。

418
00:18:26,050 --> 00:18:29,850
一緒に、これらの2つの部分は、そのプログラムを実行する方法を知っている

419
00:18:29,850 --> 00:18:31,070
私たち人間は書いている。

420
00:18:31,070 --> 00:18:34,040
>> 私はここCS50アプライアンスに入るのであれば、私は開く必要が

421
00:18:34,040 --> 00:18:35,660
テキストエディタ起動し、私はこれにアクセスすることができます

422
00:18:35,660 --> 00:18:36,560
いくつかの方法インチ

423
00:18:36,560 --> 00:18:39,060
私はどちらかのメニューに行くことができ、プログラミング、

424
00:18:39,060 --> 00:18:40,230
そして私は選択することができます - 

425
00:18:40,230 --> 00:18:40,810
いや、しないと、そのメニュー。

426
00:18:40,810 --> 00:18:43,860
私が開くにはここをアクセサリー/ geditのに行くことができます

427
00:18:43,860 --> 00:18:45,090
私の小さなテキストエディタ。

428
00:18:45,090 --> 00:18:48,030
あるいはもっと単純に、私が最後にこの小さなアイコンをクリックすることができます

429
00:18:48,030 --> 00:18:48,970
左隅。

430
00:18:48,970 --> 00:18:50,430
そして今、私はここに、この環境を手に入れよう。

431
00:18:50,430 --> 00:18:52,590
だけで、それは、単純なテキストエディタのかなり思い起こさせる

432
00:18:52,590 --> 00:18:53,820
1つまたは2つの違いがあります。

433
00:18:53,820 --> 00:18:56,420
カーソルが点滅している今ではトップでは、これはどこにあるの

434
00:18:56,420 --> 00:18:57,900
私は自分のコードを書き始めることができます。

435
00:18:57,900 --> 00:19:00,415
底部には、ターミナルウィンドウと呼ばれるこの事である。

436
00:19:00,415 --> 00:19:03,400
そして、私はこれで何物事の種類を行うことができます

437
00:19:03,400 --> 00:19:04,960
いわゆるターミナルウィンドウ？

438
00:19:04,960 --> 00:19:06,680
[聞こえない]

439
00:19:06,680 --> 00:19:07,890
>> わかりましたので、私は、コマンドを実行することになるでしょう。

440
00:19:07,890 --> 00:19:10,300
そして、我々は月曜日に走ったコマンドのいくつかは少しあった

441
00:19:10,300 --> 00:19:15,070
、最初は謎めいていますが、リストには、lsは、ディレクトリを変更するためのCD

442
00:19:15,070 --> 00:19:16,540
rmは、削除用。

443
00:19:16,540 --> 00:19:19,680
だから、あなたをナビゲートする古い学校の道のようなものだ

444
00:19:19,680 --> 00:19:22,310
コンピュータには、お使いのキーボードとテキストコマンドを使用して、

445
00:19:22,310 --> 00:19:24,130
はなく、一般的には、マウスを使用しています。

446
00:19:24,130 --> 00:19:25,960
しかし、我々はずっと前に、表示されます、これは実際に私たちに与えます

447
00:19:25,960 --> 00:19:28,520
もう少しパワーとするともう少し精度

448
00:19:28,520 --> 00:19:29,600
自分自身を表現しています。

449
00:19:29,600 --> 00:19:31,330
そして、こっちに左に、私達はちょうど見ていくつもりですが、

450
00:19:31,330 --> 00:19:34,360
我々は、ソフトウェアのほとんど要約を書き始めるように

451
00:19:34,360 --> 00:19:36,350
我々は左上に書いているプログラム。

452
00:19:36,350 --> 00:19:38,360
しかし、我々は長い前に再び表示されます。

453
00:19:38,360 --> 00:19:40,050
>> そこでここではかなり単純な何かをしてみましょう。

454
00:19:40,050 --> 00:19:43,440
私が最初に先に行くと、ファイルを保存するために行ってみよう、と私はちょうどよ

455
00:19:43,440 --> 00:19:45,970
左の上に、ここjharvardをクリックしようと、

456
00:19:45,970 --> 00:19:48,930
jharvardは、私は、もう一度、自分のホームフォルダの名前です

457
00:19:48,930 --> 00:19:52,110
個人的なファイル、私、今あるジョン·ハーバード、あなたのすべてと

458
00:19:52,110 --> 00:19:54,230
早くこの環境でジョン·ハーバードなります。

459
00:19:54,230 --> 00:19:57,360
彼は、など、このホームディレクトリ、マイドキュメントとを持っている

460
00:19:57,360 --> 00:19:58,900
私はインチ、今や、このファイルを保存したい

461
00:19:58,900 --> 00:20:01,520
だから私はそれがhello.c呼ぶつもりです。それから私は行くつもりです

462
00:20:01,520 --> 00:20:05,770
先に、私はここに持っているものをすぐに保存]をクリックし、表示されるタブです

463
00:20:05,770 --> 00:20:09,440
そんなにエディタの別のタイプのように、hello.cという。

464
00:20:09,440 --> 00:20:11,760
>> だから今、私が先に行くとプログラムを書き始めることができます。

465
00:20:11,760 --> 00:20:14,440
int型のmain（void）を。

466
00:20:14,440 --> 00:20:18,150
そして私はちょうど前回と、printfは、印刷がフォーマットのために、

467
00:20:18,150 --> 00:20:22,120
（ "こんにちは、世界！"

468
00:20:22,120 --> 00:20:24,500
）;

469
00:20:24,500 --> 00:20:25,630
ほぼ完全。

470
00:20:25,630 --> 00:20:27,130
しかし、私は細部のいくつかが欠けている。

471
00:20:27,130 --> 00:20:30,210
何が私は本当にために必要とするこのプログラムから抜けている

472
00:20:30,210 --> 00:20:31,890
それは実際にコンパイルするには？

473
00:20:31,890 --> 00:20:32,130
うん。

474
00:20:32,130 --> 00:20:33,980
[聞こえない]？

475
00:20:33,980 --> 00:20:35,770
>> デイヴィッドJ.マラン：ええ、私は標準を含める必要が

476
00:20:35,770 --> 00:20:36,700
I / Oライブラリ。

477
00:20:36,700 --> 00:20:39,470
だから、メインの上に移動するには、このニーズは、私はちょうどに行くよ

478
00:20:39,470 --> 00:20:40,790
そこにそれのためのいくつかの部屋を作る。

479
00:20:40,790 --> 00:20:44,420
そして、私は、Cランタイムライブラリの＃includeするつもりです。

480
00:20:44,420 --> 00:20:46,570
そしてそこに山括弧に気づく。

481
00:20:46,570 --> 00:20:49,410
そして余談ですが、geditがあれば、少しユーザーフレンドリーです

482
00:20:49,410 --> 00:20:52,420
それはあなたを助けようとするという点で、時には少し混乱

483
00:20:52,420 --> 00:20:54,770
目は何を使って何行まで気付く。

484
00:20:54,770 --> 00:20:57,760
だから私のカーソルがこの角度のすぐ隣にあるという事実

485
00:20:57,760 --> 00:21:00,600
ブラケット、それは他の傾斜を強調している様子がわかります

486
00:21:00,600 --> 00:21:01,920
ブラケットに加え、この1。

487
00:21:01,920 --> 00:21:03,770
そして、それはちょうど実際に私の注意を引くためだと私は

488
00:21:03,770 --> 00:21:04,460
対称性を持っています。

489
00:21:04,460 --> 00:21:07,010
とプログラミングの対称性は、一般的に良いことです。

490
00:21:07,010 --> 00:21:10,270
私は最後まで、私のカーソルを移動した場合も、気付く方法

491
00:21:10,270 --> 00:21:13,630
中括弧は、ラインアップ、はい、私はオープンされているものを持っていることを示すために

492
00:21:13,630 --> 00:21:15,160
と、いわば1を閉じた。

493
00:21:15,160 --> 00:21:16,640
>> すべての権利、私はもう一つのことを行うことができます。

494
00:21:16,640 --> 00:21:20,090
それは言っても、厳密には必要ですが、良い方法はありません

495
00:21:20,090 --> 00:21:21,250
0を返す。

496
00:21:21,250 --> 00:21:24,140
とリターン0ここで私たちのために何をするのでしょうか？

497
00:21:24,140 --> 00:21:25,584
または何を意味する？

498
00:21:25,584 --> 00:21:27,480
[聞こえない]

499
00:21:27,480 --> 00:21:28,300
デイヴィッドJ.マラン：しかし、何が間違ってません。

500
00:21:28,300 --> 00:21:30,280
はるかに間違って行くことに対して、率直に言ってそれは難しい

501
00:21:30,280 --> 00:21:31,250
この短いプログラムします。

502
00:21:31,250 --> 00:21:33,930
だから、僕はすべてが順調であることを明示的にスーパーあるよ。

503
00:21:33,930 --> 00:21:36,740
私は、人間は、私はこのプログラムを実行するときには、おそらくないでしょう

504
00:21:36,740 --> 00:21:38,150
その0を参照してください。

505
00:21:38,150 --> 00:21:41,070
一般に、これらの数字はメインから返されていること

506
00:21:41,070 --> 00:21:43,540
ときだけ人間に自分の頭をもたげる

507
00:21:43,540 --> 00:21:44,360
何かがうまくいかない。

508
00:21:44,360 --> 00:21:46,640
そして、あなたは、システムエラー、1を言ってアップ少しポップを得る

509
00:21:46,640 --> 00:21:48,760
2つ、3つ、または何でも数はということでした

510
00:21:48,760 --> 00:21:50,100
実際に返されました。

511
00:21:50,100 --> 00:21:52,870
これと他に何か問題だから？

512
00:21:52,870 --> 00:21:55,300
[聞こえない]

513
00:21:55,300 --> 00:21:58,100
>> デイヴィッドJ.マラン：だからこれはあまり機能的な間違いではありません

514
00:21:58,100 --> 00:21:59,240
しかし美的1。

515
00:21:59,240 --> 00:22:02,340
私はおそらくそこで改行文字に置くべきである

516
00:22:02,340 --> 00:22:05,240
この文字列の最後に我々は実際にカーソルを移動されるように

517
00:22:05,240 --> 00:22:08,340
次の行に、プログラムが少しだけきれいに見えます。

518
00:22:08,340 --> 00:22:10,340
>> だから今、私は私の端末ウィンドウにダウン手放す

519
00:22:10,340 --> 00:22:11,490
と見るにはズームインして

520
00:22:11,490 --> 00:22:13,390
そしてここでこの事は、プロンプトと呼ばれています。

521
00:22:13,390 --> 00:22:16,760
それはちょうど、私が誰jharvard @アプライアンス、場所を思い出させてくれている

522
00:22:16,760 --> 00:22:18,850
アプライアンスは、私が上にいるコンピュータの名前です。

523
00:22:18,850 --> 00:22:22,380
括弧内にこのチルダ、波線記号は、ある

524
00:22:22,380 --> 00:22:24,160
何を表す？

525
00:22:24,160 --> 00:22:25,590
読者：ホームディレクトリ。

526
00:22:25,590 --> 00:22:26,350
デイヴィッドJ.マラン：ホームディレクトリにコピーします。

527
00:22:26,350 --> 00:22:29,350
だからそれはちょうどあなたがいると言うの簡略表記です

528
00:22:29,350 --> 00:22:32,780
すべてのファイルは、デフォルトで行くあなたの個人用フォルダ。

529
00:22:32,780 --> 00:22:36,080
だから今、ここで、私はリストのlsを入力することができます。

530
00:22:36,080 --> 00:22:40,020
そして私は、現時点ではここを参照してください唯一のものはhello.cです。

531
00:22:40,020 --> 00:22:41,770
私はちょうどこれを書いたので、それは良いことだ。

532
00:22:41,770 --> 00:22:44,380
>> だから私は先に行くとhello作るやってみましょう。

533
00:22:44,380 --> 00:22:46,830
そして、私がhello.c makeと入力ないよ注意してください。

534
00:22:46,830 --> 00:22:50,300
代わりに、私は唯一のハロー、ファイルのベース名を入力している。

535
00:22:50,300 --> 00:22:53,690
とする、我々は月曜日に見たように、ちょうど私がしたいことを推測します

536
00:22:53,690 --> 00:22:54,920
cファイル。

537
00:22:54,920 --> 00:22:56,820
だから今は、ハロー作る入力した。

538
00:22:56,820 --> 00:22:59,280
今私はこのかなり長いコマンドを参照して続行されます

539
00:22:59,280 --> 00:23:00,480
何度も何度もこれを見て。

540
00:23:00,480 --> 00:23:03,620
しかし、明確な、打ち鳴らす、ちょうど現れた言葉であるためには、

541
00:23:03,620 --> 00:23:05,340
それは実際のコンパイラです。

542
00:23:05,340 --> 00:23:08,200
作るだけでビルドユーティリティです。

543
00:23:08,200 --> 00:23:11,900
それはで、私だけが保存され、よりユーザーフレンドリーなプログラムです

544
00:23:11,900 --> 00:23:15,310
長く信じられないほど退屈なを入力することから、長期的、

545
00:23:15,310 --> 00:23:17,020
1そのようなコマンド。

546
00:23:17,020 --> 00:23:18,950
それで、あなたは手動でClangのを実行することができます。

547
00:23:18,950 --> 00:23:20,530
手動ですべてのことを入力することができます。

548
00:23:20,530 --> 00:23:21,580
ただ、非常に退屈な取得します。

549
00:23:21,580 --> 00:23:24,720
そしてこれだけ私たちの生活を簡素化プログラムであり、作る

550
00:23:24,720 --> 00:23:27,120
私たちのために、より複雑なコマンドを実行します。

551
00:23:27,120 --> 00:23:29,410
>> すべての権利は​​、今私が何のファイルが必要です

552
00:23:29,410 --> 00:23:31,540
私の現在のディレクトリにある？

553
00:23:31,540 --> 00:23:36,310
ただのhello.cでなく、ハローではない。

554
00:23:36,310 --> 00:23:39,710
私はハロー実行したいのであれば、私はドットスラッシュを言うことを思い出してください

555
00:23:39,710 --> 00:23:42,220
ドットはどこに、現在のフォルダに行く意味する

556
00:23:42,220 --> 00:23:46,060
され、その後、今、確かにhelloというプログラムを実行して、

557
00:23:46,060 --> 00:23:48,080
私はHello Worldを持っています。

558
00:23:48,080 --> 00:23:51,640
すべての権利、またはワークフローの構文について質問

559
00:23:51,640 --> 00:23:52,890
我々だけで何をしたか？

560
00:23:55,380 --> 00:23:57,040
>> よし、それでは再びワンランク上のものを取ることができます。

561
00:23:57,040 --> 00:24:00,430
だから、これは単にプログラムを書くためにがっかりされたことのみ

562
00:24:00,430 --> 00:24:01,790
これまで世界、こんにちはと言います。

563
00:24:01,790 --> 00:24:03,920
だから我々はデビッド、こんにちは、と言って、月曜日には、それを変更しました。

564
00:24:03,920 --> 00:24:06,560
それは、もう少し個人的なのですが、同じように一生懸命のようにコーディング

565
00:24:06,560 --> 00:24:07,410
最初のバージョン。

566
00:24:07,410 --> 00:24:08,780
だから、すべてのことを説得力はない。

567
00:24:08,780 --> 00:24:13,120
しかし、以外にも確かに、C言語では、関数が存在する

568
00:24:13,120 --> 00:24:15,700
プリントには、ユーザー入力を取得するための関数。

569
00:24:15,700 --> 00:24:17,990
そして、我々はこれをしなかった方法で、他の日は、次のとおりであった。

570
00:24:17,990 --> 00:24:21,440
私は実際に何かをプリントアウトする前に、私は最初に得た

571
00:24:21,440 --> 00:24:22,410
ユーザーから何か。

572
00:24:22,410 --> 00:24:23,370
だから私は再びこれを行うことができます。

573
00:24:23,370 --> 00:24:26,580
>> sがためだけにここに任意の名前、ある文字列s、

574
00:24:26,580 --> 00:24:30,600
文字列は、GetString等しい。

575
00:24:30,600 --> 00:24:32,070
だから何をgetStringをされたのですか？

576
00:24:32,070 --> 00:24:34,630
それは明らかに、その名前に基づいて、文字列を取得します。

577
00:24:34,630 --> 00:24:37,560
しかし、それはより技術的に、何ですか？

578
00:24:37,560 --> 00:24:38,440
これは、関数です。

579
00:24:38,440 --> 00:24:41,790
だから、それ自体はC言語が付属していない関数です。

580
00:24:41,790 --> 00:24:43,660
CS50スタッフがこれを書いた。

581
00:24:43,660 --> 00:24:46,940
それで、これを使用するには、ちょうど、stdio.hに含めることはできません

582
00:24:46,940 --> 00:24:49,630
また、何を含める必要がありますか？

583
00:24:49,630 --> 00:24:50,060
うん。

584
00:24:50,060 --> 00:24:54,210
単なるファイルですcs50.hので、我々は何年か前に書いた。

585
00:24:54,210 --> 00:24:57,130
私達は並んであなたのためのアプライアンス上にインストール

586
00:24:57,130 --> 00:24:58,490
標準のすべてのファイル。

587
00:24:58,490 --> 00:25:00,500
それでクラスのこれらの最初の数週間で、私たちは使います

588
00:25:00,500 --> 00:25:02,820
これはただの非常に基本的なことのプロセスを簡素化する

589
00:25:02,820 --> 00:25:04,600
ユーザー入力を取得するようなもの。

590
00:25:04,600 --> 00:25:07,370
そのために我々は数週間のうちにわかるように、取得したユーザー入力

591
00:25:07,370 --> 00:25:10,180
Cのような言語は、実際には驚くほど複雑であり、

592
00:25:10,180 --> 00:25:14,360
あなたはどのように、通常、事前にわかっていないため、特に

593
00:25:14,360 --> 00:25:17,030
多くのものは、ユーザーがインチ入力しようとしている

594
00:25:17,030 --> 00:25:20,340
そして、あなたが期待するのはどのくらいのデータがわからない場合、あなたはしないでください

595
00:25:20,340 --> 00:25:22,380
割り当てにどのくらいのメモリを知って​​います。

596
00:25:22,380 --> 00:25:25,480
そして、あなたが実際に行おうとしているの敵対ユーザーを持っている場合

597
00:25:25,480 --> 00:25:28,180
お使いのシステムに侵入するために、よく、あなたのコンピュータをクラッシュさせる

598
00:25:28,180 --> 00:25:31,600
一般的には攻撃の第一の方法は、私がやったのと同じように、ある

599
00:25:31,600 --> 00:25:34,950
月曜日は、ランダムな文字列の全体の長いシーケンスを入力します

600
00:25:34,950 --> 00:25:37,020
Enterを押すと、壊れるものを参照してください。

601
00:25:37,020 --> 00:25:40,800
一般的に、プログラムが破損した場合は、それがほのめかしているので

602
00:25:40,800 --> 00:25:42,650
セキュリティ上の欠陥、潜在的に。

603
00:25:42,650 --> 00:25:45,250
それは確かに作られた、プログラマー、あなたにヒント

604
00:25:45,250 --> 00:25:49,050
間違いが、より危険なほど、あなたはしたかもしれない

605
00:25:49,050 --> 00:25:52,430
セキュリティ関連のミス、一般的に我々はそれが表示されます

606
00:25:52,430 --> 00:25:54,840
マシンはこの日に侵害された方法だと、両方の

607
00:25:54,840 --> 00:25:56,620
でWebやプログラムの世界では

608
00:25:56,620 --> 00:25:58,070
このようなコマンドライン、。

609
00:25:58,070 --> 00:25:58,350
>> かしこまりました。

610
00:25:58,350 --> 00:26:00,460
だから、文字列sがGetStringメソッドに相当します。

611
00:26:00,460 --> 00:26:03,380
だから、もっと具体的に今、6行目は、ここで何をするのでしょうか？

612
00:26:03,380 --> 00:26:05,640
だから右側の関数は文字列を取得し、

613
00:26:05,640 --> 00:26:06,890
どのように多くの引数をとります？

614
00:26:09,458 --> 00:26:09,900
オーケー。

615
00:26:09,900 --> 00:26:10,400
だからなし。

616
00:26:10,400 --> 00:26:11,360
少し健全性チェック。

617
00:26:11,360 --> 00:26:15,380
引数には、再び、ただ変更するための関数に入力される

618
00:26:15,380 --> 00:26:17,250
何らかの方法でそのデフォルトの動作。

619
00:26:17,250 --> 00:26:19,540
しかし、この場合には、私は変更したくない

620
00:26:19,540 --> 00:26:20,650
GetStringメソッドの振る舞い​​。

621
00:26:20,650 --> 00:26:22,430
私は、単に文字列を取得したい。

622
00:26:22,430 --> 00:26:25,190
だから私は、カッコ内に何も入れないし、私は置く

623
00:26:25,190 --> 00:26:27,550
セミコロンは、コードの行の終わりをdemarking。

624
00:26:27,550 --> 00:26:29,840
さて、それ自体が、等しいという意味ではありません等号。

625
00:26:29,840 --> 00:26:32,690
それを取得何でも入れを意味する、代入を意味

626
00:26:32,690 --> 00:26:36,060
左にあるものは何でもの右内側に出力される。

627
00:26:36,060 --> 00:26:39,400
>> だから左側に、私たちは宣言したと言う

628
00:26:39,400 --> 00:26:41,630
文字列は、sと呼ばれる。

629
00:26:41,630 --> 00:26:44,240
より具体的には、我々の内部のメモリを割り当てた

630
00:26:44,240 --> 00:26:46,340
我々は、のシーケンスを表すビットを置くことにしましょう​​どの

631
00:26:46,340 --> 00:26:46,850
文字。

632
00:26:46,850 --> 00:26:49,400
しかし、今日のために、我々は、割り当てられている

633
00:26:49,400 --> 00:26:51,450
または文字列を宣言した。

634
00:26:51,450 --> 00:26:51,790
かしこまりました。

635
00:26:51,790 --> 00:26:54,760
だから今、私はこれをやった後に、私はの値をプラグインしたい

636
00:26:54,760 --> 00:26:56,535
のではなく、ダビデの値。

637
00:26:56,535 --> 00:27:00,200
だから、これはなぜ間違っているのでしょうか？

638
00:27:03,060 --> 00:27:04,870
だから、これは文字通り、ハードコーディングされたsです。

639
00:27:04,870 --> 00:27:06,870
それは私がそうしたくないのである "こんにちは、S、"と言うことだ。

640
00:27:06,870 --> 00:27:07,790
だから私はこれを行うことができます。

641
00:27:07,790 --> 00:27:10,330
パーセント記号は、プレースホルダですが、今私がする必要がある

642
00:27:10,330 --> 00:27:12,520
印刷物に第二引数を渡します。

643
00:27:12,520 --> 00:27:15,160
関数への引数は、で区切られていることを思い出してください

644
00:27:15,160 --> 00:27:20,300
コンマは、ので、ここで次のカンマは、私は、この手紙の後に置く。

645
00:27:20,300 --> 00:27:23,740
そして今、この文脈では、sは、printfの変数であり、

646
00:27:23,740 --> 00:27:25,550
それら二つの入力を受信すると - 

647
00:27:25,550 --> 00:27:29,440
左側と右側の変数名の上の文字列 - 

648
00:27:29,440 --> 00:27:32,750
それが私たちのために前者に後者を接続しますと、

649
00:27:32,750 --> 00:27:34,600
ちょうど含んでいる素敵な美しい文字列を出力

650
00:27:34,600 --> 00:27:36,770
それは我々が打鍵したことは何でも

651
00:27:36,770 --> 00:27:37,560
>> それでは、これを試してみましょう。

652
00:27:37,560 --> 00:27:38,860
先に行くと戻って、ズームアウトするつもり

653
00:27:38,860 --> 00:27:40,250
私の端末ウィンドウに。

654
00:27:40,250 --> 00:27:41,840
ここで下部に拡大します。

655
00:27:41,840 --> 00:27:44,070
こんにちは作る再入力します。

656
00:27:44,070 --> 00:27:45,870
Clangのは再放送されているようだ。

657
00:27:45,870 --> 00:27:49,280
私は入力するつもりです。/こんにちは、入力します。

658
00:27:49,280 --> 00:27:52,145
まだ何も起きていないようにみえますが、それはこのプロンプトでだ

659
00:27:52,145 --> 00:27:55,700
私は、ネイトのようなものを入力して入力して、今、私たちは持つことができること

660
00:27:55,700 --> 00:27:56,380
こんにちは、ネイト。

661
00:27:56,380 --> 00:27:59,600
そして、私はロブなどで再びそれを行うことができます。

662
00:27:59,600 --> 00:28:03,410
私が意図したとおりになりましたので、うまくいけば、このプログラムが動作している。

663
00:28:03,410 --> 00:28:05,720
>> これで、すべてそのユーザーフレンドリーではありません。

664
00:28:05,720 --> 00:28:07,930
私は私に期待されているのかさっぱりだが。

665
00:28:07,930 --> 00:28:09,620
だから我々は確かに少しに整理することができます。

666
00:28:09,620 --> 00:28:13,270
私はここに戻ってまで行こう、とだけではなく、ダイビングと

667
00:28:13,270 --> 00:28:16,480
文字列をユーザに尋ねる、私は明示的に教えてみましょう

668
00:28:16,480 --> 00:28:17,750
私が期待しているかをユーザ。

669
00:28:17,750 --> 00:28:21,610
だからのprintf（ "文字列を入力してください："

670
00:28:21,610 --> 00:28:24,080
）;

671
00:28:24,080 --> 00:28:25,510
ここで変数もありませんので。

672
00:28:25,510 --> 00:28:26,750
いいえパーセント記号。

673
00:28:26,750 --> 00:28:28,550
単純な英語のフレーズ。

674
00:28:28,550 --> 00:28:34,030
私は今ここに底に行くと私のプログラムを再実行してみましょう。

675
00:28:34,030 --> 00:28:35,380
しかし、何も変更されているように思えません。

676
00:28:35,380 --> 00:28:37,350
なぜですか？

677
00:28:37,350 --> 00:28:38,380
私はそれを再コンパイルする必要があります。

678
00:28:38,380 --> 00:28:39,570
だから犯しやすい間違い。

679
00:28:39,570 --> 00:28:41,700
しかし、あなたがファイルを保存するだけでなく、持っていますが、

680
00:28:41,700 --> 00:28:43,260
プログラムを再コンパイルしてください。

681
00:28:43,260 --> 00:28:46,640
ので、私は再実行こんにちは作れば、今Clangのが実行されます。

682
00:28:46,640 --> 00:28:51,800
今、私は実行することができます/こんにちは。そして今、私は "文字列を入力してください："を参照してください。

683
00:28:51,800 --> 00:28:52,050
オーケー。

684
00:28:52,050 --> 00:28:53,440
今度は、もう少しユーザーフレンドリーです。

685
00:28:53,440 --> 00:28:55,850
ネイトは、、こんにちは、ネイトを入力します。

686
00:28:55,850 --> 00:28:57,310
>> さて、再びこれを試してみて、考えてみましょう

687
00:28:57,310 --> 00:28:58,080
コー​​ナーケースについて。

688
00:28:58,080 --> 00:29:00,520
ただスクラッチのようにそう、あなたは奨励している、またはされている

689
00:29:00,520 --> 00:29:03,180
種類で行くことができるかを考えるために仕様で奨励

690
00:29:03,180 --> 00:29:06,610
間違ったユーザーが行う可能性がありますすべてのものを予想していない場合。

691
00:29:06,610 --> 00:29:08,050
バグは、したがって、結果として起きる可能性があります。

692
00:29:08,050 --> 00:29:09,710
だから文字列を入力します - 

693
00:29:09,710 --> 00:29:11,130
ここでコーナーケースは何ですか？

694
00:29:11,130 --> 00:29:13,320
何が、プログラマが、持っていないかもしれないというシナリオだ

695
00:29:13,320 --> 00:29:16,070
予想？

696
00:29:16,070 --> 00:29:17,600
うん。

697
00:29:17,600 --> 00:29:17,920
オーケー。

698
00:29:17,920 --> 00:29:22,060
私はこのような番号を入力だから何たら？

699
00:29:22,060 --> 00:29:22,500
かしこまりました。

700
00:29:22,500 --> 00:29:24,490
だから、それはまだ動作します。

701
00:29:24,490 --> 00:29:25,880
Gramaticallyも意味がありません。

702
00:29:25,880 --> 00:29:27,180
しかし、少なくとも、プログラムが動作します。

703
00:29:27,180 --> 00:29:28,650
>> 別のコーナーケースは何ですか？

704
00:29:28,650 --> 00:29:29,610
私は期待していなかった何か。

705
00:29:29,610 --> 00:29:31,590
うん？

706
00:29:31,590 --> 00:29:31,940
オーケー。

707
00:29:31,940 --> 00:29:34,950
だから我々は本当に、本当に大きな数のような何かを行うことができます。

708
00:29:34,950 --> 00:29:37,270
だからここにこれを行うにしてみましょう。

709
00:29:37,270 --> 00:29:40,880
私は第二のためにズームアウトしましょう​​、私が強調することができます。

710
00:29:40,880 --> 00:29:42,250
コピーしてここに貼り付けることはできません。

711
00:29:42,250 --> 00:29:42,470
かしこまりました。

712
00:29:42,470 --> 00:29:44,440
だから私はコピーして、この端末ウィンドウに貼り付けることはできません、我々はよそう

713
00:29:44,440 --> 00:29:46,950
ただ、それをシミュレートします。

714
00:29:46,950 --> 00:29:51,340
私はラップするつもり、ズームアウトしてみましょう。

715
00:29:51,340 --> 00:29:52,700
私はそれがないので、あまりにも長いためにこれを行うつもりはありません

716
00:29:52,700 --> 00:29:54,440
実際に、このプログラムで破る。

717
00:29:54,440 --> 00:29:55,260
しかし、それは可能性があります。

718
00:29:55,260 --> 00:29:55,830
入力します。

719
00:29:55,830 --> 00:29:56,580
しかし、それはしませんでした。

720
00:29:56,580 --> 00:29:57,050
かしこまりました。

721
00:29:57,050 --> 00:29:58,440
しかし、それは本物の角のケースです。

722
00:29:58,440 --> 00:30:01,610
正しく振る舞って唯一の理由は、そうする

723
00:30:01,610 --> 00:30:05,820
CS50関数GetStringメソッドは、実際にあるため、話す、です

724
00:30:05,820 --> 00:30:08,040
我々は数週間のうちにわかるように、フードの下に設計された、

725
00:30:08,040 --> 00:30:11,570
自動的に、より多くの、より多くのRAMを割り当てる

726
00:30:11,570 --> 00:30:14,330
オペレーティング·システムからメモリを、それが実現したときに、すごい、

727
00:30:14,330 --> 00:30:16,670
あなたは、実際にはかなり長いものに入力した。

728
00:30:16,670 --> 00:30:18,500
さて、これは白い嘘のビットです。

729
00:30:18,500 --> 00:30:22,020
我々は実際には非常にしばらくの間、一時停止し、私が入力した場合

730
00:30:22,020 --> 00:30:24,640
キーボードでも5億文字のようなもの

731
00:30:24,640 --> 00:30:28,060
ここで、あるいは実際にコピー＆ペーストかなりヒット、恐らく我々

732
00:30:28,060 --> 00:30:29,730
プログラムがクラッシュする可能性があります。

733
00:30:29,730 --> 00:30:32,130
ほんの少し難しく有限でそれをシミュレートする

734
00:30:32,130 --> 00:30:33,740
時間の量。

735
00:30:33,740 --> 00:30:37,320
>> 私達は試みることができる別のコーナーケースは何ですか？

736
00:30:37,320 --> 00:30:38,730
うん？

737
00:30:38,730 --> 00:30:39,020
うん。

738
00:30:39,020 --> 00:30:40,360
では、なぜ我々は何も答えないのですか？

739
00:30:40,360 --> 00:30:43,130
だから我々は、実際に何らかのアクションを取らなければならないなぜなら、そうでなければ

740
00:30:43,130 --> 00:30:45,060
プログラムは一日中点滅そこに座ってになるだろう。

741
00:30:45,060 --> 00:30:46,860
しかし、私はちょうどヒットした場合、入力してください - 

742
00:30:46,860 --> 00:30:48,780
[OK]を、今、まだ間違って見えます。

743
00:30:48,780 --> 00:30:51,670
クラッシュが、多分する機会は今は​​ありませんでした

744
00:30:51,670 --> 00:30:54,190
より厳密なプログラムの実装を開始

745
00:30:54,190 --> 00:30:55,290
それは実際にチェックします。

746
00:30:55,290 --> 00:30:57,640
そして、もし文字列、文章、その単語、私

747
00:30:57,640 --> 00:31:00,890
長さが0であるに入力し、まあ、多分私は怒鳴りつけるべき

748
00:31:00,890 --> 00:31:03,770
ユーザー、またはように、彼に言うか、彼女は再び列を入力する

749
00:31:03,770 --> 00:31:06,560
我々は実際には正しい行動のように見えるものを手にしていない

750
00:31:06,560 --> 00:31:08,570
私の一部にだけ完全な見落とし。

751
00:31:08,570 --> 00:31:11,130
>> 背中の質問ですか？

752
00:31:11,130 --> 00:31:11,970
10進数を指定します。

753
00:31:11,970 --> 00:31:13,120
だから我々はあまりにも、それを試みることができる。

754
00:31:13,120 --> 00:31:16,840
1.10000005。

755
00:31:16,840 --> 00:31:19,470
それはちょうど実際にちゃんと動作するように起こっているように思える。

756
00:31:19,470 --> 00:31:21,160
そして、それは実際に期待されています。

757
00:31:21,160 --> 00:31:24,550
我々はそこにその番号を入力したりしているかもしれませんが

758
00:31:24,550 --> 00:31:28,200
大きい数字以前、実現することを我々は、ユーザが入力しているとき

759
00:31:28,200 --> 00:31:31,070
入力と我々は、GetStringメソッドの機能をしていません使用している

760
00:31:31,070 --> 00:31:34,380
私が入力している何かの問題は、数のように見えます。

761
00:31:34,380 --> 00:31:36,720
ことを思い出して、ASCII、あなたの上のすべてのものによる

762
00:31:36,720 --> 00:31:39,920
キーボードにマッピングすることができ、数値を持つ

763
00:31:39,920 --> 00:31:41,480
文字は、char。

764
00:31:41,480 --> 00:31:44,490
だから私は、番号を入力することがあり、この場合、にも関わらず、

765
00:31:44,490 --> 00:31:48,190
コンピュータがあるため、文字列のように、話すこと、それを考えるために起こっている - 

766
00:31:48,190 --> 00:31:49,870
数字のように見えるが、何か

767
00:31:49,870 --> 00:31:51,090
実際には数値ではない。

768
00:31:51,090 --> 00:31:53,450
しかし、それは今我々ができるので、実際に完璧Segueの

769
00:31:53,450 --> 00:31:55,450
プログラムを書くには、実際に移行すること

770
00:31:55,450 --> 00:31:56,730
他のデータ型を使用します。

771
00:31:56,730 --> 00:32:01,840
>> だから文字列を使用する以外に、というより、文字を使用する以外に、

772
00:32:01,840 --> 00:32:04,510
我々は同様でCのように、他のデータ·タイプを持っていることを実感

773
00:32:04,510 --> 00:32:05,230
他の言語。

774
00:32:05,230 --> 00:32:08,480
char型は、その名前が示すように、ちょうど単一文字です。

775
00:32:08,480 --> 00:32:12,150
floatは浮動小数点値であり、それはただの空想だ

776
00:32:12,150 --> 00:32:14,470
実数を言う方法 - 小数点を持っている何か

777
00:32:14,470 --> 00:32:17,410
左及び/または右にいくつかの数字とそれにポイント。

778
00:32:17,410 --> 00:32:21,370
intはちょうど123のような数を表す整数です。

779
00:32:21,370 --> 00:32:24,170
そして今、さらに興味深い二重のようなものがあります。

780
00:32:24,170 --> 00:32:28,540
我々は、ダブルが最後の時間だった何て言った？

781
00:32:28,540 --> 00:32:30,050
それは右、64です。

782
00:32:30,050 --> 00:32:33,560
だから一般的に、一方フロートは32ビットです - 

783
00:32:33,560 --> 00:32:37,340
ので、メモリ内の長い間、この、それは〜32 0と1を使用し

784
00:32:37,340 --> 00:32:40,530
値を表す - 二重は文字通り二度あることである

785
00:32:40,530 --> 00:32:43,810
どちらか大きい数を表すことができることを意味し、または

786
00:32:43,810 --> 00:32:45,810
あなたは、より正確な数値を表すことができます。

787
00:32:45,810 --> 00:32:48,690
だから、小数点の後に複数の番号を持つことができますが、

788
00:32:48,690 --> 00:32:51,520
男は単純なものであっても、映像の中で述べたように

789
00:32:51,520 --> 00:32:55,360
概念的1月3日のようにすることによって正確に表現できない

790
00:32:55,360 --> 00:32:58,330
コンピュータ、最終的にはビットを使い果たしているので、と

791
00:32:58,330 --> 00:33:02,510
したがって、あなただけ0.33333333そう何回も、で行うことができます

792
00:33:02,510 --> 00:33:05,050
その時点であなたはちょうど私が表現が切れてしまったと言わざるを得ない

793
00:33:05,050 --> 00:33:08,120
スペースは、私はちょうど一日を呼び出すと、それを表現するために持っている

794
00:33:08,120 --> 00:33:10,200
多少不正確にそのようなもの。

795
00:33:10,200 --> 00:33:11,110
そして長い長い - 

796
00:33:11,110 --> 00:33:13,880
として知られているデータ型があるので、愚かな名前ですが、それだ

797
00:33:13,880 --> 00:33:19,350
偶然にも同じように、多くの場合、32ビットであるCのlong

798
00:33:19,350 --> 00:33:21,670
int型は32ビットですが、長い長いです

799
00:33:21,670 --> 00:33:23,560
一般的には64ビット。

800
00:33:23,560 --> 00:33:25,740
だからそれはちょうどあなたが大きな意味を表すことができます

801
00:33:25,740 --> 00:33:26,990
これより数値。

802
00:33:26,990 --> 00:33:27,410
>> かしこまりました。

803
00:33:27,410 --> 00:33:29,390
だから我々は、実際に物事を表す開始したい場合、我々は、

804
00:33:29,390 --> 00:33:31,030
より洗練されたタイプが必要かもしれません、そして、

805
00:33:31,030 --> 00:33:32,340
我々は文字列を持っている理由です。

806
00:33:32,340 --> 00:33:36,450
だからCS50ライブラリに、そのファイルがcs50.hと呼ばれ、我々はしました

807
00:33:36,450 --> 00:33:41,110
実際には文字列と呼ばれるデータ型は、いわば、宣言された

808
00:33:41,110 --> 00:33:42,710
しかし、文字列が実際には存在しません。

809
00:33:42,710 --> 00:33:44,780
これは、再び、我々は皮に行くんだ、これらの層の一つである

810
00:33:44,780 --> 00:33:47,490
背中一週間か二週間で、それを捨てて、実際に

811
00:33:47,490 --> 00:33:49,640
文字列が実際に何であるかで、フードの下に見て、

812
00:33:49,640 --> 00:33:50,840
どのようにそれが表されている。

813
00:33:50,840 --> 00:33:53,520
我々はまた、ブール値で見ていくつもりです。

814
00:33:53,520 --> 00:33:56,040
>> だからスクラッチの文脈におけるboolは何でしたか？

815
00:33:59,154 --> 00:34:00,300
これは、trueまたはfalseです。

816
00:34:00,300 --> 00:34:03,900
だからそれは、ちょうど、trueまたはfalseを、オンまたはオフの値の1または

817
00:34:03,900 --> 00:34:06,140
0は、しかし、あなたは世界を見たい。

818
00:34:06,140 --> 00:34:09,739
だからCで、CS50ライブラリのおかげで、どの順番に

819
00:34:09,739 --> 00:34:12,179
ボンネットの下に別のライブラリが含まれています、我々は持っている

820
00:34:12,179 --> 00:34:14,909
boolと呼ばれたデータ型へのアクセスが、その意志

821
00:34:14,909 --> 00:34:18,730
文字通り私たちにtrueまたはfalseの値を割り当てることができます

822
00:34:18,730 --> 00:34:20,219
プログラムの事。

823
00:34:20,219 --> 00:34:23,880
>> それでは、ここで先に行くと、その小さなプログラムを書いてみましょう

824
00:34:23,880 --> 00:34:26,330
代わりに、数値を含む何かをする。

825
00:34:26,330 --> 00:34:29,840
だから私はCS50アプライアンスに戻りましょう、私は先に行きましょうと

826
00:34:29,840 --> 00:34:32,770
ここで呼ばれる新しいファイルを作成する - 

827
00:34:32,770 --> 00:34:35,460
ちょうどmath.c.ような単純なものを、言うてみましょう

828
00:34:38,270 --> 00:34:38,710
かしこまりました。

829
00:34:38,710 --> 00:34:41,600
そして今、私のプログラムの一番上に上がる、アイム

830
00:34:41,600 --> 00:34:42,510
いつものをやろうとして - 

831
00:34:42,510 --> 00:34:44,780
私が使用できるように、＃、<stdio.h>を含める

832
00:34:44,780 --> 00:34:46,860
printfは、int型のmain（void）を - 

833
00:34:46,860 --> 00:34:49,270
我々は、intが何を意味するのか、最終的には、戻ってくるよ

834
00:34:49,270 --> 00:34:52,389
ここでは、空隙がここに何を意味するのかが、今のところ、ちょうど知っている

835
00:34:52,389 --> 00:34:54,270
あなたはこのようなプログラムを開始する必要があります。

836
00:34:54,270 --> 00:34:56,280
今、私は先に行くと、少し何かを言おうとしてる

837
00:34:56,280 --> 00:35:02,110
異なる - のprintf（ "私に番号を付与します。"

838
00:35:02,110 --> 00:35:03,570
）;

839
00:35:03,570 --> 00:35:09,220
その後、私はそれているので、int型N = getIntをするつもりです

840
00:35:09,220 --> 00:35:12,770
場合、getInt判明CS50は、ライブラリ内の別の関数である

841
00:35:12,770 --> 00:35:14,060
getString以外。

842
00:35:14,060 --> 00:35:17,340
そして今、私は感謝 "のように、愚かな何かをするつもりです

843
00:35:17,340 --> 00:35:25,760
％dの "進整数のために、次にコンマn、および

844
00:35:25,760 --> 00:35:26,620
その後、0を返します。

845
00:35:26,620 --> 00:35:28,940
だからもう一度、戻り0私は番号とは何の関係もない

846
00:35:28,940 --> 00:35:30,080
をユーザに尋ねる。

847
00:35:30,080 --> 00:35:33,620
ただ、すべてが、おそらく、よくあること終わりに示します。

848
00:35:33,620 --> 00:35:36,290
>> だから私はここに私の端末ウィンドウに落とす。

849
00:35:36,290 --> 00:35:39,590
私は数学を行う入力してみましょう、次のように入力します。

850
00:35:39,590 --> 00:35:41,360
と何かが間違っている。

851
00:35:41,360 --> 00:35:44,620
数学が機能しなかったことを確認します。

852
00:35:44,620 --> 00:35:46,170
ここに我々のエラーメッセージの最初のです。

853
00:35:46,170 --> 00:35:46,570
なぜですか？

854
00:35:46,570 --> 00:35:49,720
少し不可解な、しかし - 

855
00:35:49,720 --> 00:35:50,060
うん。

856
00:35:50,060 --> 00:35:51,240
だからcs50.h.

857
00:35:51,240 --> 00:35:53,900
だからもう一度、特に早い段階で、あなたは最初のを書こうと思います

858
00:35:53,900 --> 00:35:56,590
セクション内のpset 1のプログラム、営業時間、および

859
00:35:56,590 --> 00:35:59,050
率直に言って、それは時々何これらのものを圧倒することでしょう

860
00:35:59,050 --> 00:36:00,000
実際に言っている。

861
00:36:00,000 --> 00:36:01,890
しかし、あなたは彼らが低下し始め、非常に迅速に実現するだろう

862
00:36:01,890 --> 00:36:06,120
このひとつは、あなたが1つをオフに残してきたことを意味することによりバケットに

863
00:36:06,120 --> 00:36:08,290
＃のファイルの先頭に含まれています。

864
00:36:08,290 --> 00:36:10,960
とClangのは、コンパイラは、することによって、このことを知らせるさ

865
00:36:10,960 --> 00:36:14,090
のと言って、むしろfancifully、暗黙的な宣言

866
00:36:14,090 --> 00:36:15,990
関数getIntは無効です。

867
00:36:15,990 --> 00:36:16,310
>> かしこまりました。

868
00:36:16,310 --> 00:36:17,520
だからそれは何を意味するのでしょうか？

869
00:36:17,520 --> 00:36:22,080
それはちょうどあなたが暗黙でgetIntを宣言したことを意味し

870
00:36:22,080 --> 00:36:24,850
あなたはそれを明示的に宣言していないという意味。

871
00:36:24,850 --> 00:36:27,300
明示的にint型を宣言するには、次のように教えなければならない

872
00:36:27,300 --> 00:36:28,740
それが存在することを打ち鳴らす。

873
00:36:28,740 --> 00:36:32,020
とのために非常に簡単な解決策は、それをすることによって教えることです

874
00:36:32,020 --> 00:36:34,780
この他のファイル、cs50.h、少なくとも含む

875
00:36:34,780 --> 00:36:35,850
ファイルの最上部。

876
00:36:35,850 --> 00:36:40,380
文字通り、それはClangのに言うことは、＃includeしないであるので

877
00:36:40,380 --> 00:36:44,030
かなりcs50.h、コピーと呼ばれるファイルを探しに行くためには、

878
00:36:44,030 --> 00:36:48,150
私のために、プログラムの先頭に自動的に貼り付けたり、

879
00:36:48,150 --> 00:36:50,850
その後ゼロとものにソースコードを変換します。

880
00:36:50,850 --> 00:36:52,850
私たち人間が持っていた場合、しかし、それは明らかに非常に面倒です

881
00:36:52,850 --> 00:36:55,370
これらの大きなファイルのすべての時間をコピーして貼り付けるに移動するには、

882
00:36:55,370 --> 00:36:58,540
ので、＃だけで自動的にせずにすべてのことを行い含める

883
00:36:58,540 --> 00:37:01,550
誰か他の人のライブラリーと私のコードを濁水。

884
00:37:01,550 --> 00:37:06,370
とライブラリは単に関数を含む別のファイルです

885
00:37:06,370 --> 00:37:08,340
他の誰かが私達がであることを、書いていることを他の事

886
00:37:08,340 --> 00:37:10,270
私たち自身のために活用する。

887
00:37:10,270 --> 00:37:10,580
>> かしこまりました。

888
00:37:10,580 --> 00:37:11,200
のは、もう一度試してみましょう。

889
00:37:11,200 --> 00:37:12,250
数学を作る。

890
00:37:12,250 --> 00:37:13,120
入力します。

891
00:37:13,120 --> 00:37:13,530
グッド。

892
00:37:13,530 --> 00:37:14,880
だからそれは働いているようだ。

893
00:37:14,880 --> 00:37:18,330
だから私は今、数学を実行してみましょう。。/数学。

894
00:37:18,330 --> 00:37:21,100
入力は私番号、123を与える。

895
00:37:21,100 --> 00:37:22,620
123ありがとうございました。

896
00:37:22,620 --> 00:37:24,490
今度は、別のコーナーケースを試してみましょう。

897
00:37:24,490 --> 00:37:26,530
文字列があるので、かなり寛大である

898
00:37:26,530 --> 00:37:27,620
文字列は何でもかまいません。

899
00:37:27,620 --> 00:37:28,910
数字のように見えることができます、のように見える

900
00:37:28,910 --> 00:37:30,600
文字は、言葉のように見えます。

901
00:37:30,600 --> 00:37:31,900
しかし、int型はintです。

902
00:37:31,900 --> 00:37:34,370
だから今は困難なユーザーだし、それは私を与える "と言っている場合

903
00:37:34,370 --> 00:37:38,730
番号、 "私は0.1のような何かをしようとする場合はどうなりますか？

904
00:37:38,730 --> 00:37:41,510
まあ、それは数字だし、それはと一貫性のある

905
00:37:41,510 --> 00:37:44,180
文法は、私がここで使用されますが、フードの下に、私はのよ

906
00:37:44,180 --> 00:37:45,610
関数getIntを使用してコース。

907
00:37:45,610 --> 00:37:46,610
>> だから何が起こるか見てみましょう。

908
00:37:46,610 --> 00:37:48,250
再試行し、入力します。

909
00:37:48,250 --> 00:37:48,560
かしこまりました。

910
00:37:48,560 --> 00:37:50,570
私は困難になると、もう一度Enterを押してみましょう。

911
00:37:50,570 --> 00:37:51,700
は、Enterを入力します。

912
00:37:51,700 --> 00:37:53,890
だから今はそれが場合、getIntがもう少しあると思われる

913
00:37:53,890 --> 00:37:55,240
GetStringメソッドよりも強力。

914
00:37:55,240 --> 00:37:58,540
我々スタッフは、私たちが気づいたときように実装

915
00:37:58,540 --> 00:38:02,100
あなたは私たちにintを与えていない - とintは10進数です

916
00:38:02,100 --> 00:38:04,785
含むゼロ、もの、補数、スリー、四つんばい、ファイブズ、シックス、

917
00:38:04,785 --> 00:38:05,540
セブン、エイト、またはナイン。

918
00:38:05,540 --> 00:38:06,310
そして、それはそれだ。

919
00:38:06,310 --> 00:38:08,810
いいえ小数点なし、文字、句読点。

920
00:38:08,810 --> 00:38:10,390
それは我々が協力しなければならないようだ。

921
00:38:10,390 --> 00:38:13,680
だから私は、4、5、6、およびを通じて私を取得してみましょう。

922
00:38:13,680 --> 00:38:16,760
だから本当に、ここに肛門であることが、私はおそらく私を与える "と言うべき

923
00:38:16,760 --> 00:38:20,310
整数 "ユーザに伝えるために

924
00:38:20,310 --> 00:38:22,620
まさに私が意図したもの。

925
00:38:22,620 --> 00:38:24,090
>> それでは、ボンネットの下にについて考えてみましょう。

926
00:38:24,090 --> 00:38:27,930
今日はどのように実装されるかcs50.h見するつもりはない、

927
00:38:27,930 --> 00:38:29,080
そのライブラリ。

928
00:38:29,080 --> 00:38:33,600
しかし、それは、リトライ、リトライ、リトライ言い続けたらどうプログラミング

929
00:38:33,600 --> 00:38:36,970
私はおそらくにフードの下に使用しています構築

930
00:38:36,970 --> 00:38:39,000
それを実装する？

931
00:38:39,000 --> 00:38:39,980
だから、ループ、右か？

932
00:38:39,980 --> 00:38:41,930
我々がスクラッチで見た最も単純なアイデアの一つ。

933
00:38:41,930 --> 00:38:45,050
フォーエバーリピート構築し、構築します。

934
00:38:45,050 --> 00:38:47,320
おそらく、このプログラムでは、ボンネットの下に、偶数

935
00:38:47,320 --> 00:38:49,470
それはしないスクラッチCで書かれているが、それはやっている

936
00:38:49,470 --> 00:38:54,300
ユーザーがいない場合は何かが永遠に相当呼ば

937
00:38:54,300 --> 00:38:58,710
整数で入力したので、リトライ、リトライ、リトライ、リトライ言う

938
00:38:58,710 --> 00:39:01,220
そして最後に私たちが行うときは、次に、整数を取得

939
00:39:01,220 --> 00:39:02,970
そのループから抜け出す。

940
00:39:02,970 --> 00:39:05,610
>> だから我々はCS50のライブラリにここで他にどのような機能を使用することができますか？

941
00:39:05,610 --> 00:39:07,880
まあ、明らかなものの種類は、少なくとも部分的に基づいて

942
00:39:07,880 --> 00:39:09,570
私たちが今存在することがわかっているデータ型。

943
00:39:09,570 --> 00:39:12,900
我々は、GetStringメソッド、getIntを実装しますが、全体

944
00:39:12,900 --> 00:39:15,680
用語の最初の数週間は、あなたもgetFloatはを使用することができ、

945
00:39:15,680 --> 00:39:18,870
正確に取得するために、getDoubleはとGetLongLong

946
00:39:18,870 --> 00:39:20,030
必要なデータ型。

947
00:39:20,030 --> 00:39:24,030
ここで重要なディテールは、そのいくつかの言語とは異なりますので

948
00:39:24,030 --> 00:39:26,630
あなたは必ずしもする必要はありませんPythonやRubyのような

949
00:39:26,630 --> 00:39:29,730
変数のデータ型を宣言 - 

950
00:39:29,730 --> 00:39:32,390
あなたはどのような種類のものをコンピュータに指示する必要はありません

951
00:39:32,390 --> 00:39:34,000
あなたは、変数に格納しようとしている - 

952
00:39:34,000 --> 00:39:36,640
C言語で、あなたは今までので正確でなければならない。

953
00:39:36,640 --> 00:39:40,060
あなたは、nという変数は、ストレージのチャンクをお望みであれば

954
00:39:40,060 --> 00:39:42,900
このケースでは、慣例により、32ビットであることを起こること

955
00:39:42,900 --> 00:39:45,660
これらのビットであることをコンピュータに指示する必要があります

956
00:39:45,660 --> 00:39:47,840
数値を格納する予定 - 

957
00:39:47,840 --> 00:39:50,630
れていない文字、文字列ではありませんではなく、フロート。

958
00:39:50,630 --> 00:39:52,620
そして、これは我々効果的に問題を解決します

959
00:39:52,620 --> 00:39:53,760
先週に走った。

960
00:39:53,760 --> 00:39:57,050
我々だけではない表現するためにゼロとものの番号を使用している場合

961
00:39:57,050 --> 00:40:00,770
数字の世界でどのようにしかし、とBS、CSの、

962
00:40:00,770 --> 00:40:03,460
コンピュータは知っているつもりが、実際にこのビットのパターン

963
00:40:03,460 --> 00:40:07,650
として表すのではなく番号65を表し、

964
00:40:07,650 --> 00:40:09,860
によると偶然、文字A、

965
00:40:09,860 --> 00:40:13,440
リコールは、ASCII、65と同等だったのですか？

966
00:40:13,440 --> 00:40:16,550
>> そう、コンピュータにコンテキストを提供し、これらのデータ·タイプには、

967
00:40:16,550 --> 00:40:18,810
これらのビットは次のように解釈されるべきである場合、それは知っている

968
00:40:18,810 --> 00:40:23,660
intやstringなど。

969
00:40:23,660 --> 00:40:26,500
どの質問でも、その後、この上の？

970
00:40:26,500 --> 00:40:28,149
うん？

971
00:40:34,780 --> 00:40:35,270
デイヴィッドJ.マラン：良い質問です。

972
00:40:35,270 --> 00:40:39,140
我々はstdio.hを取り出す場合は、ファイルを保存する - 

973
00:40:39,140 --> 00:40:44,360
私は、ターミナルウィンドウに下ると数学、ズームを行う実行してみましょう

974
00:40:44,360 --> 00:40:45,530
と入力します - 

975
00:40:45,530 --> 00:40:47,700
私は暗黙のうちにだから、今私は、別のエラーが出る

976
00:40:47,700 --> 00:40:49,650
NOW関数宣言何？

977
00:40:49,650 --> 00:40:50,700
printfの。

978
00:40:50,700 --> 00:40:52,970
だから今は、その解決策であるという新たな問題を作成しました

979
00:40:52,970 --> 00:40:53,890
本質的には同じ。

980
00:40:53,890 --> 00:40:55,365
私はその背中を配置する必要があります。

981
00:40:55,365 --> 00:40:56,615
読者：[聞こえない]

982
00:41:03,534 --> 00:41:04,030
デイヴィッドJ.マラン：ああ。

983
00:41:04,030 --> 00:41:04,850
私が取るのであれば - 

984
00:41:04,850 --> 00:41:05,360
大丈夫、うん。

985
00:41:05,360 --> 00:41:08,960
だから私は、標準I / Oライブラリの包含を削除する場合

986
00:41:08,960 --> 00:41:12,020
ここでは、その後、私は、printfを取り除く場合は、getと言っている

987
00:41:12,020 --> 00:41:13,450
printf関数を取り除く？

988
00:41:13,450 --> 00:41:13,810
はい。

989
00:41:13,810 --> 00:41:18,450
私はもはやいずれかを使用していませんので、これは動作するはずです - おっと。

990
00:41:18,450 --> 00:41:20,110
私は嘘だったのか。

991
00:41:20,110 --> 00:41:21,650
ああ、大丈夫。

992
00:41:21,650 --> 00:41:25,640
これは、我々はちょうど導入された新しいエラーのため動作しません。

993
00:41:25,640 --> 00:41:28,390
そして、この1つはもう少し自明です。

994
00:41:28,390 --> 00:41:29,440
>> 何が問題なの？

995
00:41:29,440 --> 00:41:30,680
未使用の変数n。

996
00:41:30,680 --> 00:41:34,040
ので、このエラーは、当社が設定した結果です

997
00:41:34,040 --> 00:41:36,640
本当にに向かって怒鳴り、特に知識をひけらかすするアプライアンス

998
00:41:36,640 --> 00:41:39,060
すべての可能な間違いのためにあなた、たとえその種の

999
00:41:39,060 --> 00:41:41,950
このような非致命的な間違いは、 - それは本当にそのような大きさです

1000
00:41:41,950 --> 00:41:44,820
私はintを割り当てた対処、それに数字を入れて、

1001
00:41:44,820 --> 00:41:46,030
ただ、それには何もしなかった？

1002
00:41:46,030 --> 00:41:47,020
いや、だから、機能的。

1003
00:41:47,020 --> 00:41:50,410
つまり、プログラムを壊すことはないだろう。

1004
00:41:50,410 --> 00:41:51,490
それはちょうど愚かな、右のようなものだ？

1005
00:41:51,490 --> 00:41:54,220
保存されて、その番号に求めなくする値はありません

1006
00:41:54,220 --> 00:41:56,370
それが変数で、あなたは何もするつもりはありませんしている場合

1007
00:41:56,370 --> 00:41:58,000
それと、それを印刷したり、それを保存するかどうか。

1008
00:41:58,000 --> 00:42:00,270
したがって、この例の場合、Clangのは、できるだけ多く認められ、

1009
00:42:00,270 --> 00:42:02,010
それは、未使用の変数nを言っている。

1010
00:42:02,010 --> 00:42:05,380
>> 私たちが本当にしたい場合だから我々はこの問題を解決することができます。

1011
00:42:05,380 --> 00:42:07,250
しかし、再び、これは今、良いプログラミングではありません。

1012
00:42:07,250 --> 00:42:09,310
だから、僕はこれを行うことができます - 

1013
00:42:09,310 --> 00:42:12,060
ここに降りて行き、私は、画面をクリア数学を作ってみましょう。

1014
00:42:12,060 --> 00:42:13,090
その作品。

1015
00:42:13,090 --> 00:42:18,110
今、私は入力を受け取り、私の数学のプログラムを実行することができます - 

1016
00:42:18,110 --> 00:42:18,700
まあ、それは悪かった。

1017
00:42:18,700 --> 00:42:23,450
入力を受け取り、それがこの場合には、それはないすべてです。

1018
00:42:23,450 --> 00:42:25,220
>> だから、実際に、のはもう一つのコーナーケースを試してみましょう私たち

1019
00:42:25,220 --> 00:42:26,300
以前から考えていませんでした。

1020
00:42:26,300 --> 00:42:28,220
このケースでは - ここで、のはの1に戻りましょう

1021
00:42:28,220 --> 00:42:29,500
ユーザーフレンドリーもう少し。

1022
00:42:29,500 --> 00:42:32,580
私はここに戻って、もう一度数学をmakeを実行してみましょう。

1023
00:42:32,580 --> 00:42:34,190
おっと、私は間違って何をしましたか？

1024
00:42:34,190 --> 00:42:35,400
さらにロールバックするようになった。

1025
00:42:35,400 --> 00:42:36,390
オーケー。

1026
00:42:36,390 --> 00:42:38,490
今、私たちは、すべての場所、元の状態に戻っている

1027
00:42:38,490 --> 00:42:39,990
うまくいけば十分です。

1028
00:42:39,990 --> 00:42:43,360
私は数学を実行する場合、現在は、123が動作するように思われる。

1029
00:42:43,360 --> 00:42:46,010
しかし、これは単に言っても、本当に効果的な構造になっていません

1030
00:42:46,010 --> 00:42:47,930
大丈夫、それは動作します。

1031
00:42:47,930 --> 00:42:49,120
789、動作します。

1032
00:42:49,120 --> 00:42:50,100
提出する時間。

1033
00:42:50,100 --> 00:42:51,870
他のコーナーケースがここにありますので。

1034
00:42:51,870 --> 00:42:55,040
文字列が実際に入力することで私たちに多大な迷惑を与えていない

1035
00:42:55,040 --> 00:42:56,510
文字の全体の多く。

1036
00:42:56,510 --> 00:42:59,580
しかし、私はこれで何を入力した場合？

1037
00:42:59,580 --> 00:43:04,850
 - ナンバー1の全体の多くは、ここで全体の多くを打つ

1038
00:43:04,850 --> 00:43:06,300
すべての権利、それは少し退屈になってきたので、私はするつもりです

1039
00:43:06,300 --> 00:43:10,040
ここで停止し、私は入力をヒットするつもりです。

1040
00:43:10,040 --> 00:43:11,290
>> ただ一体何が起こったのか？

1041
00:43:14,110 --> 00:43:17,680
だから、これは実際に説明することができる。

1042
00:43:17,680 --> 00:43:18,920
だからそれは、バイナリとしてそれを取るのですか？

1043
00:43:18,920 --> 00:43:21,130
良い思いをしますが、いや、それはそれがそれを取ったという事実はありません

1044
00:43:21,130 --> 00:43:22,815
バイナリとして、確かに、それはただのようなものだったので、

1045
00:43:22,815 --> 00:43:23,080
偶然。

1046
00:43:23,080 --> 00:43:23,930
我々は再びこれを行うことができます。

1047
00:43:23,930 --> 00:43:26,530
それでは、バイナリシステムには2がありません

1048
00:43:26,530 --> 00:43:27,420
おそらく十分なとにかく。

1049
00:43:27,420 --> 00:43:28,780
入力します。

1050
00:43:28,780 --> 00:43:30,140
だからそれは問題ではありませんでした。

1051
00:43:30,140 --> 00:43:31,390
他に何が？

1052
00:43:34,650 --> 00:43:35,400
その通りです。

1053
00:43:35,400 --> 00:43:37,830
>> だからintが実際に何であるかを思い出す。

1054
00:43:37,830 --> 00:43:40,970
それは集合的に解釈され、32ビットだ

1055
00:43:40,970 --> 00:43:42,090
数として。

1056
00:43:42,090 --> 00:43:44,730
あなたは32ビットを持っているならば、それはビットのそれぞれができることを意味します

1057
00:43:44,730 --> 00:43:46,690
0または1（0または1）。

1058
00:43:46,690 --> 00:43:49,090
このビットの二つの可能性があることを意味するので、その

1059
00:43:49,090 --> 00:43:51,140
この2つの可能性、この2つの可能性

1060
00:43:51,140 --> 00:43:52,570
ビット - それは2倍2倍だそう - 

1061
00:43:52,570 --> 00:43:55,480
そう32の電源を2だとの合計数です

1062
00:43:55,480 --> 00:43:58,960
0と1の順列は、32を持っている場合

1063
00:43:58,960 --> 00:44:01,400
あなたの目の前でプレースホルダ、ゼロまたは、。

1064
00:44:01,400 --> 00:44:04,250
私は32から2を持っているなら、数学的に、どのようなことですか？

1065
00:44:07,080 --> 00:44:07,840
だから、多くのです。

1066
00:44:07,840 --> 00:44:09,910
これは、与えるか、または取る、40億だ。

1067
00:44:09,910 --> 00:44:13,510
と4億ドルはここにプリントアウトしたものであるように思えません。

1068
00:44:13,510 --> 00:44:16,290
実際には、これは20億に近い見えます。

1069
00:44:16,290 --> 00:44:17,970
しかし、これは偶然ではありません。

1070
00:44:17,970 --> 00:44:21,590
コンピュータは私の膨大な数を誤解しているという事実、

1071
00:44:21,590 --> 00:44:24,260
ものその後補数の私の巨大な配列の私の巨大な配列、

1072
00:44:24,260 --> 00:44:26,880
約2億円、としてどのように説明されています？

1073
00:44:30,250 --> 00:44:32,180
int型のキャップがあります。

1074
00:44:32,180 --> 00:44:34,970
あなたが表現できる最大値は確かにありま​​す。

1075
00:44:34,970 --> 00:44:36,370
しかし、それは通常、右の40億ですか？

1076
00:44:36,370 --> 00:44:39,100
32から2のように思えるが約4億円である場合

1077
00:44:39,100 --> 00:44:40,350
それが最大の数だ。

1078
00:44:42,420 --> 00:44:45,240
そうではない残りますが、良いと思った。

1079
00:44:45,240 --> 00:44:46,340
負の数。

1080
00:44:46,340 --> 00:44:49,570
だから、あなたができる40億可能なものを持っている場合

1081
00:44:49,570 --> 00:44:52,970
32 0のこれらの様々な順列で表すと

1082
00:44:52,970 --> 00:44:55,600
1S、まあ、それは私たち人間がしたがっているかもしれない理にかなっている

1083
00:44:55,600 --> 00:44:57,110
だけではなく、正の整数を表す

1084
00:44:57,110 --> 00:44:58,240
しかし、負の整数。

1085
00:44:58,240 --> 00:45:00,410
そして実際、それはCが行うことを前提です。

1086
00:45:00,410 --> 00:45:03,550
だから、32ビットでは、ほぼ負の2を表すことができます

1087
00:45:03,550 --> 00:45:06,630
正の20億円は、すべての方法を。

1088
00:45:06,630 --> 00:45:08,750
ので、この場合には、私たちが本当に見ているだけである

1089
00:45:08,750 --> 00:45:13,600
従って私達の整数の容量のフリンジ、そして我々は持っている、

1090
00:45:13,600 --> 00:45:15,860
話すように、整数をオーバーフローしました。

1091
00:45:15,860 --> 00:45:19,180
私たちは、実際に合うことができるよりも、それに多くのビットを詰め込むことを試みた。

1092
00:45:19,180 --> 00:45:22,960
だから、最終的な結果は、我々は本質的に全て1のビットを持っていることです。

1093
00:45:22,960 --> 00:45:25,280
我々が表現しようとしました、上に私たちは、すべてのビットを反転した

1094
00:45:25,280 --> 00:45:27,630
可能な最大の数は、それがほぼ明確ではありません

1095
00:45:27,630 --> 00:45:30,960
私はちょうどインチ入力した二つのことを表現するのに十分な大きさ

1096
00:45:30,960 --> 00:45:31,730
うん？

1097
00:45:31,730 --> 00:45:32,980
読者：[聞こえない]

1098
00:45:37,230 --> 00:45:37,830
>> デイヴィッドJ.マラン：良い質問です。

1099
00:45:37,830 --> 00:45:40,080
なぜ我々はちょうどその負を表すことができません

1100
00:45:40,080 --> 00:45:41,500
単に文字として署名しますか？

1101
00:45:41,500 --> 00:45:44,200
だから我々は絶対に可能性があり、我々はそれから救うことができる

1102
00:45:44,200 --> 00:45:45,470
追加ビット。

1103
00:45:45,470 --> 00:45:49,100
しかし、あなたはまだそのダッシュを表現する必要があるとしている、と

1104
00:45:49,100 --> 00:45:50,700
それはあなたに、少なくとも何かをコストになるだろう

1105
00:45:50,700 --> 00:45:52,220
おそらくビット。

1106
00:45:52,220 --> 00:45:55,610
そうです、私達は私達の多数のために使用される32ビットを持っていますが、可能性が今

1107
00:45:55,610 --> 00:45:57,610
私達は私達のダッシュのために使用される別のビットを必要とする

1108
00:45:57,610 --> 00:45:58,810
記号、マイナス記号。

1109
00:45:58,810 --> 00:46:01,470
だから今我々は、我々は何ができる33ビット値を、持っているが、それはだ

1110
00:46:01,470 --> 00:46:02,570
それが行われているだけではない方法です。

1111
00:46:02,570 --> 00:46:05,140
我々は、32ビットの一種で、審判の判定の年前に作られ

1112
00:46:05,140 --> 00:46:06,170
ここでの測定単位。

1113
00:46:06,170 --> 00:46:08,120
だから我々は効果的にこれらのビットのいずれかを使用するつもりだ

1114
00:46:08,120 --> 00:46:12,950
否定性を表しており、数字を表すために31ビット。

1115
00:46:12,950 --> 00:46:15,550
その他の質問は？

1116
00:46:15,550 --> 00:46:15,670
かしこまりました。

1117
00:46:15,670 --> 00:46:16,030
それはたくさんある。

1118
00:46:16,030 --> 00:46:17,930
なぜ我々は先に行くと、私たちの5分の休憩をここでみませんか？

1119
00:46:23,580 --> 00:46:24,270
>> かしこまりました。

1120
00:46:24,270 --> 00:46:31,250
だからもう一度、数学アプリケーションを過度に強調しないように

1121
00:46:31,250 --> 00:46:33,840
プログラミングの、この1つだけ例を毟り取るみましょう

1122
00:46:33,840 --> 00:46:36,590
我々はそれているので、他の構造物に移動する前に、

1123
00:46:36,590 --> 00:46:39,430
のいくつかについてのいくつかの一般的なつまずきのポイントを説明します

1124
00:46:39,430 --> 00:46:41,520
基礎それはプログラムを書くことになる。

1125
00:46:41,520 --> 00:46:44,360
このケースでは、いくつかを持っている算術式をやって

1126
00:46:44,360 --> 00:46:48,010
構文に興味深い関連性。

1127
00:46:48,010 --> 00:46:50,430
>> だから、これはちょうど私達が変換できるとの計算式です

1128
00:46:50,430 --> 00:46:52,690
華氏から摂氏への温度。

1129
00:46:52,690 --> 00:46:54,600
あなたは覚えていない場合、これは単なる計算式です。

1130
00:46:54,600 --> 00:46:58,870
だから我々は32度華氏の値をプラグインした場合、ある

1131
00:46:58,870 --> 00:47:02,850
32から32を差し引いたものになるだろう凍結、0であり、確かに、

1132
00:47:02,850 --> 00:47:05,130
摂氏0も凍結です。

1133
00:47:05,130 --> 00:47:08,210
だからクイック正気があるチェック - おなじみの式ですね。

1134
00:47:08,210 --> 00:47:10,880
私はしかし、アプライアンスの所へ行くと、始めましょう

1135
00:47:10,880 --> 00:47:13,920
f2cは、同じように、というプログラムを書いて、 "華氏へ

1136
00:47:13,920 --> 00:47:15,920
"ドットC摂氏。

1137
00:47:15,920 --> 00:47:18,930
とここまでトップで、私は、＃includeとオフを開始つもり

1138
00:47:18,930 --> 00:47:22,190
stdio.hに、私はint型のmain（void）をするつもりです、と

1139
00:47:22,190 --> 00:47:24,680
再び、我々は、intが何を意味するかのように、将来的に戻ってくる

1140
00:47:24,680 --> 00:47:26,820
そこに、どのような空隙が存在することを意味します。

1141
00:47:26,820 --> 00:47:28,770
そして今、私が先に行くと、そのプログラムを実装してみましょう

1142
00:47:28,770 --> 00:47:31,170
本質的に私たちのためにこの変換が行われます。

1143
00:47:31,170 --> 00:47:36,830
>> だからprintfの、のは、華氏で、温度を言わせてください。

1144
00:47:36,830 --> 00:47:40,140
そして、私が先に行くと、ユーザーから値を取得することができます。

1145
00:47:40,140 --> 00:47:43,120
私がしたい場合は、この値はどのような私は、ユーザーから取得する必要があります

1146
00:47:43,120 --> 00:47:45,620
それらは私に華氏の温度を与えるため？

1147
00:47:45,620 --> 00:47:48,090
うん？

1148
00:47:48,090 --> 00:47:50,090
あなたは何を提案するか？

1149
00:47:50,090 --> 00:47:50,410
うん。

1150
00:47:50,410 --> 00:47:51,960
だからフロートはかなり合理的に感じている。

1151
00:47:51,960 --> 00:47:53,950
私たちは、再び、そのちょうどいくつかのオプションがあります

1152
00:47:53,950 --> 00:47:55,310
我々はこれまで見てきました。

1153
00:47:55,310 --> 00:48:00,100
私たちは、長い長い、char型、ダブル型、float型、int型のようなものを持っている

1154
00:48:00,100 --> 00:48:01,150
ブール値、文字列。

1155
00:48:01,150 --> 00:48:03,510
そこで、これらの、フロートはかなり合理的に感じている。

1156
00:48:03,510 --> 00:48:06,340
私たちが本当にしたい場合は、ので、我々は、二重、右を使うことができ

1157
00:48:06,340 --> 00:48:07,580
人間の体温を表現する - 

1158
00:48:07,580 --> 00:48:10,730
98.60000  - 

1159
00:48:10,730 --> 00:48:12,990
我々はそれを行うために64ビットを使用することもできますが、それはのように感じている

1160
00:48:12,990 --> 00:48:14,200
温度のやり過ぎ。

1161
00:48:14,200 --> 00:48:16,380
だからフロートで行くみましょう。

1162
00:48:16,380 --> 00:48:18,100
今私は、変数が必要です。

1163
00:48:18,100 --> 00:48:20,500
物事をシンプルに保つために、私はそれをFと呼ぶことにしますが、私はよ

1164
00:48:20,500 --> 00:48:23,370
同じように正しく温度呼び出すことができ、

1165
00:48:23,370 --> 00:48:24,600
が、どちらかで結構です。

1166
00:48:24,600 --> 00:48:27,610
だからフロートF = getFloatは。

1167
00:48:27,610 --> 00:48:30,220
私は今getFloatはを使用することを決定したとすぐに、しかし、私

1168
00:48:30,220 --> 00:48:33,340
1補正を行う必要があります。

1169
00:48:33,340 --> 00:48:33,720
うん。

1170
00:48:33,720 --> 00:48:37,460
だから我々は＃<cs50.h>インクルードする必要があり、そうしないとコンパイラがある

1171
00:48:37,460 --> 00:48:39,000
私たちに叫ぶつもり。

1172
00:48:39,000 --> 00:48:41,720
今私はフロートを持っていることを、私は先に行くとやらせる

1173
00:48:41,720 --> 00:48:42,460
変換。

1174
00:48:42,460 --> 00:48:44,980
>> そこでまず、私はまたここにする習慣をつけましょう

1175
00:48:44,980 --> 00:48:46,310
私のコードをコメントアウト。

1176
00:48:46,310 --> 00:48:49,820
だからもう一度、コメントは人間だけだと表記である

1177
00:48:49,820 --> 00:48:52,600
しないプログラム自体の一部が、それは1、あなたを助けます

1178
00:48:52,600 --> 00:48:55,010
あなたが次の日の朝やったことを理解するか、または次の

1179
00:48:55,010 --> 00:48:57,570
月、それはあなたのティーチング·フェローはあなたが何をしたか理解するのに役立ちます

1180
00:48:57,570 --> 00:48:59,230
または何をするかを意図しているので、だ

1181
00:48:59,230 --> 00:49:00,950
一般的には非常に良い練習。

1182
00:49:00,950 --> 00:49:02,940
コー​​ドのすべての数行は、にコメントを書き込む

1183
00:49:02,940 --> 00:49:04,490
あなた自身やあなたの同僚。

1184
00:49:04,490 --> 00:49:08,460
そこでここでは、私は言おうとしている "温度をユーザーに尋ねる。"

1185
00:49:08,460 --> 00:49:10,890
完全な文章、わずかな短いフレーズである必要はありません。

1186
00:49:10,890 --> 00:49:14,270
しかし、Cのコメントの背後にある考え方は、自分の各

1187
00:49:14,270 --> 00:49:17,980
、と言う、TFや同僚または - コメントはあなたを力づけるべき - 

1188
00:49:17,980 --> 00:49:21,290
ないことによって、あなたのプログラムをざっと読んで、それが何かを正確に知るために

1189
00:49:21,290 --> 00:49:24,650
そんなにコードを読んでますが、コメントを読むことによって、どの

1190
00:49:24,650 --> 00:49:26,220
簡潔かつ明確にする必要があります。

1191
00:49:26,220 --> 00:49:29,030
すべての権利なので、今変換 "は、私が先に行くとしましょう

1192
00:49:29,030 --> 00:49:32,660
華氏から摂氏 "だから私は先に行くと何をしようとしてんだけど、

1193
00:49:32,660 --> 00:49:34,340
cをフロートと呼びましょう。

1194
00:49:34,340 --> 00:49:36,610
我々は、浮動小数点値として摂氏おこう。

1195
00:49:36,610 --> 00:49:37,630
>> そして、私はこれで刺してみましょう。

1196
00:49:37,630 --> 00:49:40,350
式はここで、再度、アップしている。

1197
00:49:40,350 --> 00:49:45,510
5月9日回としてFマイナス32。

1198
00:49:45,510 --> 00:49:46,360
だから、これを実行してみましょう。

1199
00:49:46,360 --> 00:49:50,450
だから5は9で割った値、マイナス - 

1200
00:49:50,450 --> 00:49:52,330
おっと、私はすでにそれを台無しに。

1201
00:49:52,330 --> 00:49:53,070
タイムズ。

1202
00:49:53,070 --> 00:49:56,550
だから、5月9日回Fマイナス32。

1203
00:49:56,550 --> 00:49:59,650
セミコロンは、Fから32を差し引いたそう。

1204
00:49:59,650 --> 00:50:02,000
そして今、ここでダウン、私は先に行くつもりです

1205
00:50:02,000 --> 00:50:03,220
と、言う結果を印刷します。

1206
00:50:03,220 --> 00:50:05,160
そして、この部分は簡単です。 printfの。

1207
00:50:05,160 --> 00:50:07,980
どのように私はこれを印刷して行くのですか？

1208
00:50:07,980 --> 00:50:16,890
まあ、私は、 "摂氏でその数は％fは\ nです"と言うことができる

1209
00:50:16,890 --> 00:50:18,060
ちょうどいくつかの美学のために。

1210
00:50:18,060 --> 00:50:20,450
そして、どのような値私は、printfのように、ここにプラグインしたい

1211
00:50:20,450 --> 00:50:21,360
二番目の引数？

1212
00:50:21,360 --> 00:50:21,650
オーケー。

1213
00:50:21,650 --> 00:50:22,540
だからC。

1214
00:50:22,540 --> 00:50:24,760
だから我々はこれで始まりますし、ただ0を返す。

1215
00:50:24,760 --> 00:50:25,960
再び、それは数学とは何の関係もない。

1216
00:50:25,960 --> 00:50:27,610
それだけですべてが順調であることを意味します。

1217
00:50:27,610 --> 00:50:31,210
>> さて、これは正しい、このプログラムは何ですか？

1218
00:50:31,210 --> 00:50:31,520
かしこまりました。

1219
00:50:31,520 --> 00:50:33,630
だから私はいくつかのミスを犯しました。

1220
00:50:33,630 --> 00:50:35,980
あなたがプログラミングが何であるか見当がつかない場合でも、並べ替えることができます

1221
00:50:35,980 --> 00:50:37,120
推論バックの何小学校へ

1222
00:50:37,120 --> 00:50:38,740
ここで間違いがあるかもしれません。

1223
00:50:38,740 --> 00:50:40,050
最初の一人は何ですか？

1224
00:50:40,050 --> 00:50:41,256
読者：[聞こえない]

1225
00:50:41,256 --> 00:50:41,660
デイヴィッドJ.マラン：うん。

1226
00:50:41,660 --> 00:50:42,940
だから我々は括弧を逃している。

1227
00:50:42,940 --> 00:50:45,420
それは、私は基調講演で、かっこをしたことが意図的であった

1228
00:50:45,420 --> 00:50:48,130
オーダーのこの概念は、実際に存在したため、ここにスライド

1229
00:50:48,130 --> 00:50:51,590
操作の、または優先順位、それにより特定の操作 - 

1230
00:50:51,590 --> 00:50:52,890
乗算 - 

1231
00:50:52,890 --> 00:50:56,000
高い結合があり、物事よりも、より高い優先度を持ってい

1232
00:50:56,000 --> 00:50:58,050
加算または減算のような。

1233
00:50:58,050 --> 00:51:00,550
だから我々はただ正確に明らかにするために何年もこれをやった

1234
00:51:00,550 --> 00:51:02,840
どんな数学演算を先に行ってください。

1235
00:51:02,840 --> 00:51:05,010
だから私は、たぶん、ここまで厳密に模倣する必要があります。

1236
00:51:05,010 --> 00:51:08,990
そうしないと、コンピュータはおそらくやろうとしている

1237
00:51:08,990 --> 00:51:13,090
9で割る5のようなものが、その後減算し、Fを掛ける

1238
00:51:13,090 --> 00:51:14,850
全部から32。

1239
00:51:14,850 --> 00:51:16,480
これは、我々が何をしたいのか、実際には、ありません。

1240
00:51:16,480 --> 00:51:17,340
それでは、括弧ましょう。

1241
00:51:17,340 --> 00:51:20,860
ここで、括弧、ここに私のかっこを追加してみましょう。

1242
00:51:20,860 --> 00:51:22,670
のは、ここにこれを入れてみましょう。

1243
00:51:22,670 --> 00:51:25,130
ここでは、私はちょうど私が道に沿って作られた別の間違いに気づいた。

1244
00:51:25,130 --> 00:51:25,680
うん？

1245
00:51:25,680 --> 00:51:26,930
読者：[聞こえない]

1246
00:51:29,632 --> 00:51:30,130
>> デイヴィッドJ.マラン：ああ。

1247
00:51:30,130 --> 00:51:30,470
グッド。

1248
00:51:30,470 --> 00:51:32,400
だから我々は実際には同じ整数を持つ

1249
00:51:32,400 --> 00:51:34,020
前から分割問題。

1250
00:51:34,020 --> 00:51:35,800
私は症状が何であるかを確認してみましょう、それは正しい。

1251
00:51:35,800 --> 00:51:36,990
しかし、我々は1を修正する必要があるとしている

1252
00:51:36,990 --> 00:51:37,680
ここでは他のミス。

1253
00:51:37,680 --> 00:51:38,015
うん？

1254
00:51:38,015 --> 00:51:39,540
読者：[聞こえない]

1255
00:51:39,540 --> 00:51:40,070
デイヴィッドJ.マラン：はい。

1256
00:51:40,070 --> 00:51:43,130
だから、愚かなミスを私が作ったが、非常に重要。

1257
00:51:43,130 --> 00:51:45,870
コンピュータはただ目をつぶるとさせるつもりされていません

1258
00:51:45,870 --> 00:51:48,770
私が実際に変数を宣言したときに私は、資本Fを使用

1259
00:51:48,770 --> 00:51:51,360
ここで小文字fと、ライン8インチ

1260
00:51:51,360 --> 00:51:54,470
だから私は、11行目の私の総額で修正する必要がある

1261
00:51:54,470 --> 00:51:56,820
少し前に誤って大文字Fであった。

1262
00:51:56,820 --> 00:51:57,610
ここで何がどうですか？

1263
00:51:57,610 --> 00:51:59,980
これは同様に小文字であるべきですか？

1264
00:51:59,980 --> 00:52:02,260
それはする必要がありますが、それは偶然だ。

1265
00:52:02,260 --> 00:52:05,070
つまり、％fは変数とは何の関係もありません。

1266
00:52:05,070 --> 00:52:07,980
だからここにスーパークリアであることが、私は先に行かせてと

1267
00:52:07,980 --> 00:52:10,710
この、簡単に、 "温度"をリネーム私は名前を変更してみましょう

1268
00:52:10,710 --> 00:52:15,050
この "温度"。私は、この名前を変更しないようにしましょう​​。

1269
00:52:15,050 --> 00:52:18,180
そのため、再度、％fはグローバルに、 "浮動小数点値"を意味します。

1270
00:52:18,180 --> 00:52:19,950
my変数とは何の関係もありません。

1271
00:52:19,950 --> 00:52:23,080
しかし、あちこちに "温度"は、ほんの少し長ったらしいです

1272
00:52:23,080 --> 00:52:25,370
ので、私は小文字の "f" sに戻って行くつもりです。

1273
00:52:25,370 --> 00:52:27,890
>> 今、私はここに私の窓に降り先に行くことができます。

1274
00:52:27,890 --> 00:52:29,190
f2cの確認 - 

1275
00:52:29,190 --> 00:52:31,200
これは、再度、任意の名前であった私

1276
00:52:31,200 --> 00:52:32,590
このファイルに与えた。

1277
00:52:32,590 --> 00:52:33,690
コンパイルされているようだ。

1278
00:52:33,690 --> 00:52:35,080
私はf2cを実行してみましょう。

1279
00:52:35,080 --> 00:52:35,780
入力します。

1280
00:52:35,780 --> 00:52:37,786
華氏の温度 - 簡単にいずれかの操作を実行してみましょう。

1281
00:52:37,786 --> 00:52:39,370
32。

1282
00:52:39,370 --> 00:52:40,910
[OK]を、修正してください。

1283
00:52:40,910 --> 00:52:45,910
しかし、私は今、沸騰のため212を実行した場合 - 

1284
00:52:45,910 --> 00:52:46,630
いまいましい。

1285
00:52:46,630 --> 00:52:47,030
かしこまりました。

1286
00:52:47,030 --> 00:52:50,780
あなたのTFがそうしようとした場合、明らかに、修正されない

1287
00:52:50,780 --> 00:52:51,800
少なくとも2つの値。

1288
00:52:51,800 --> 00:52:53,340
だから、ここでの問題は何ですか？

1289
00:52:53,340 --> 00:52:55,970
さて、あなたはすでに問題が何であるかに指を置く。

1290
00:52:55,970 --> 00:52:57,600
しかし、なぜそのような場合は何ですか？

1291
00:52:57,600 --> 00:53:00,630
ここまで、私が9で割った5の数学をやっているとき。

1292
00:53:00,630 --> 00:53:02,190
だから概念的には、それが完全に正しいです。

1293
00:53:02,190 --> 00:53:03,690
式と完全に一致している。

1294
00:53:03,690 --> 00:53:05,940
しかし、コンピュータには正確に何をすべきかあなた

1295
00:53:05,940 --> 00:53:06,760
行うためにそれらを教えてください。

1296
00:53:06,760 --> 00:53:08,940
と私たちは効果的にここでコンピュータを言っていることです

1297
00:53:08,940 --> 00:53:12,320
整数9によって整数5の分割

1298
00:53:12,320 --> 00:53:13,670
と私に結果を与える。

1299
00:53:13,670 --> 00:53:16,230
あなたはデータを使用して分割を行う場合には、この問題は、しかし、である

1300
00:53:16,230 --> 00:53:20,220
タイプ、出力は入力と同じデータ型です。

1301
00:53:20,220 --> 00:53:23,670
2つの入力が両方とも整数である場合など、出力が起こっている

1302
00:53:23,670 --> 00:53:25,110
intである。

1303
00:53:25,110 --> 00:53:28,770
それで9で割った5点ものです。

1304
00:53:28,770 --> 00:53:32,320
しかし、何かをポイントに最も近い整数は何ですか？

1305
00:53:32,320 --> 00:53:33,630
だから、それは実際には0です。

1306
00:53:33,630 --> 00:53:36,620
小数点の後、我々は月曜日に論じように、すべてのもの

1307
00:53:36,620 --> 00:53:37,940
ポイントは切り捨てられます。

1308
00:53:37,940 --> 00:53:39,495
それはわずかスローされます。

1309
00:53:39,495 --> 00:53:42,760
だから、これは完全な間違いですが、私は可能性があるため、同様にわずか

1310
00:53:42,760 --> 00:53:44,700
ここでは0で全てを掛けます。

1311
00:53:44,700 --> 00:53:46,550
>> 今、私はいくつかの方法でこの問題を解決することができます。

1312
00:53:46,550 --> 00:53:48,080
私はこれを行うことができます。

1313
00:53:48,080 --> 00:53:50,490
5.0は9.0で割った値です。

1314
00:53:50,490 --> 00:53:52,110
技術的には、私もそれを実行する必要はありません。

1315
00:53:52,110 --> 00:53:55,780
それは数字だけフロートの1つを作るために十分ではない - 

1316
00:53:55,780 --> 00:53:58,290
またはダブル - ここに小数点を入れていました。

1317
00:53:58,290 --> 00:54:01,740
あなたがして整数を分割するとき今何が起こるかであるため、

1318
00:54:01,740 --> 00:54:04,670
float、またはdouble、コンピュータが実現するだろう

1319
00:54:04,670 --> 00:54:06,830
ああ、それらの一つは、より正確です。

1320
00:54:06,830 --> 00:54:09,420
私はあなたよりも精度を与えることの側で間違えてみよう

1321
00:54:09,420 --> 00:54:10,310
あなたが意図しています。

1322
00:54:10,310 --> 00:54:12,700
だから、結果を変換します - 

1323
00:54:12,700 --> 00:54:16,240
それだけでなく、浮動小数点値として結果を返します。

1324
00:54:16,240 --> 00:54:17,330
だからそれは働くだろう。

1325
00:54:17,330 --> 00:54:18,060
これが働くだろう。

1326
00:54:18,060 --> 00:54:20,010
そして、我々は後で見ることになりますことをもう一つのメカニズムがある

1327
00:54:20,010 --> 00:54:21,390
より詳細来週。

1328
00:54:21,390 --> 00:54:24,690
あなたが実際に、プログラマーとして、コンピュータに伝えることができます

1329
00:54:24,690 --> 00:54:27,930
実際には1つのデータ型として扱うこと

1330
00:54:27,930 --> 00:54:29,260
それは別だったけど。

1331
00:54:29,260 --> 00:54:30,990
>> だから私は実際にこれを行うことができます。

1332
00:54:30,990 --> 00:54:35,280
括弧内に、私はオープンのようなものを（フロート）、と言うことができます

1333
00:54:35,280 --> 00:54:36,350
括弧、括弧近い。

1334
00:54:36,350 --> 00:54:39,050
そして、これはと呼ばれるものです "キャスト"。繰り返しになりますが、もっと

1335
00:54:39,050 --> 00:54:39,940
これ来週で。

1336
00:54:39,940 --> 00:54:42,280
しかし、これは単なる占いのプログラム的な方法である

1337
00:54:42,280 --> 00:54:45,910
コンピュータは、ええ私は9は整数または長であることを知っている。

1338
00:54:45,910 --> 00:54:47,700
私はそれが浮動小数点値ではないと知っている。

1339
00:54:47,700 --> 00:54:49,420
しかし、いずれにせよ、そういうものとしてそれを扱います。

1340
00:54:49,420 --> 00:54:52,000
だからデータ型をキャストすると、変換することを意味

1341
00:54:52,000 --> 00:54:53,310
一方から他方へ。

1342
00:54:53,310 --> 00:54:55,790
率直に言って、これはちょっと醜いですので、私は、我々が行く提案する

1343
00:54:55,790 --> 00:54:58,830
背中だけ変換元の提案へ

1344
00:54:58,830 --> 00:55:00,770
手動で浮動小数点値にこれらの事。

1345
00:55:00,770 --> 00:55:02,890
今では何が起こっているのか単にスーパークリアだから、と

1346
00:55:02,890 --> 00:55:04,280
それはすべての気が散ることがありません。

1347
00:55:04,280 --> 00:55:06,710
>> だから今、私の端末ウィンドウに戻ってみましょう。

1348
00:55:06,710 --> 00:55:07,990
f2cを作る。

1349
00:55:07,990 --> 00:55:09,430
私が先に行くと、これを実行してみましょう。

1350
00:55:09,430 --> 00:55:12,340
そして、余談ですが、あなたはこれらのコマンドを入力して飽きてしまう

1351
00:55:12,340 --> 00:55:14,910
何度も何度も、ここにLinuxのように、そのコンピュータを実現する、

1352
00:55:14,910 --> 00:55:16,010
かなりスマートになる傾向があります。

1353
00:55:16,010 --> 00:55:18,890
私が打つなら、私達は私の全体の歴史を通過することができます

1354
00:55:18,890 --> 00:55:20,380
コマンド、UpとDown。

1355
00:55:20,380 --> 00:55:23,840
そこでここでは、この場合、私はちょうどf2cのmakeを実行に上がることができます。

1356
00:55:23,840 --> 00:55:25,830
私はちょうど2番目の前にあることをやったので、私は、怒鳴られてる。

1357
00:55:25,830 --> 00:55:27,030
これは既に最新です。

1358
00:55:27,030 --> 00:55:30,720
だから今、私は再びf2cを実行することができます。

1359
00:55:30,720 --> 00:55:33,260
32華氏を試してみましょう。

1360
00:55:33,260 --> 00:55:36,720
今度は、華氏212を試してみましょう。

1361
00:55:36,720 --> 00:55:37,250
>> ふう。

1362
00:55:37,250 --> 00:55:38,250
動作するように思われる。

1363
00:55:38,250 --> 00:55:41,760
さて、これは良いですが、それは少し感じている任意の

1364
00:55:41,760 --> 00:55:44,890
私は、小数点の後に6つの数字を見せている。

1365
00:55:44,890 --> 00:55:45,070
右か？

1366
00:55:45,070 --> 00:55:47,830
あなたがテレビの天気予報の人なら、あなたは愚か者の一種だ

1367
00:55:47,830 --> 00:55:49,150
あなたは、温度を読んでいるなら

1368
00:55:49,150 --> 00:55:50,070
この程度の精度。

1369
00:55:50,070 --> 00:55:51,270
だから、これを簡略化してみましょう。

1370
00:55:51,270 --> 00:55:53,880
それでは、実際に私のprintf関数に、ここまで行くことができます。

1371
00:55:53,880 --> 00:55:55,490
そして、ええ、私は浮くようにしたい。

1372
00:55:55,490 --> 00:55:57,570
しかし、私は今では精度を指定する。

1373
00:55:57,570 --> 00:55:59,070
そして、私は少し簡潔になるつもりです。

1374
00:55:59,070 --> 00:56:03,090
私は私に小数点の後に1点を与える、と言うつもりです。

1375
00:56:03,090 --> 00:56:07,590
だからではなく％fを言うよりも、私は％.1 fを言うつもりです。

1376
00:56:07,590 --> 00:56:09,760
そして、これはちょうど私に一つの位置を与えることを意味

1377
00:56:09,760 --> 00:56:11,410
小数点以下。

1378
00:56:11,410 --> 00:56:11,700
かしこまりました。

1379
00:56:11,700 --> 00:56:12,570
のは、再びこれを試してみましょう。

1380
00:56:12,570 --> 00:56:15,590
私はそれをコンパイルした後、再実行してみましょう。

1381
00:56:15,590 --> 00:56:18,160
そして今、私は32に入力して、私が帰る

1382
00:56:18,160 --> 00:56:19,310
より簡潔値。

1383
00:56:19,310 --> 00:56:22,480
そして、私は、今、212に入力し、より簡潔を取り戻すことができる

1384
00:56:22,480 --> 00:56:23,260
値と同様。

1385
00:56:23,260 --> 00:56:25,190
そして、あなたは、printfで行うことができます他のものがあります。

1386
00:56:25,190 --> 00:56:27,950
あなたは、実際には数値がどうあるべきか広い指定することができます。

1387
00:56:27,950 --> 00:56:30,900
あなたがそれのパディングを持つようにしたいなら、君も右揃えにしたり、

1388
00:56:30,900 --> 00:56:32,360
左揃えにあなたの番号の全部または

1389
00:56:32,360 --> 00:56:33,400
中心に物事をみてください。

1390
00:56:33,400 --> 00:56:35,340
ですから、そこを行うことができます小さなトリックがあります理解しています。

1391
00:56:35,340 --> 00:56:38,420
しかし、彼らはただ、書式コードになるまで煮詰める

1392
00:56:38,420 --> 00:56:39,600
我々はそこにあるようだな。

1393
00:56:39,600 --> 00:56:41,090
>> だから優先順位のこの問題に関して。

1394
00:56:41,090 --> 00:56:43,820
これは念入りに通過するための非常に退屈なテーブルです。

1395
00:56:43,820 --> 00:56:46,780
しかし、Cの作者が出ていることを認識

1396
00:56:46,780 --> 00:56:50,190
オペレータが高い持っているかを指定する規則

1397
00:56:50,190 --> 00:56:53,680
優先順位が、他のものよりも結合力、。

1398
00:56:53,680 --> 00:56:55,890
だから、小学校のに対し、我々は一般的にそれがあったことを知っていた

1399
00:56:55,890 --> 00:56:58,930
乗算と除算は、加算と減算、

1400
00:56:58,930 --> 00:56:59,950
その後、いくつかの他のもの。

1401
00:56:59,950 --> 00:57:01,720
プログラミングの世界では、あまりあり

1402
00:57:01,720 --> 00:57:03,360
物事の長いリスト。

1403
00:57:03,360 --> 00:57:05,150
そして、これが今覚える価値のあるものではありません。

1404
00:57:05,150 --> 00:57:07,310
あなたはやがてそれに慣れるでしょう。

1405
00:57:07,310 --> 00:57:10,690
しかし、ちょうど小学校のように、括弧は、一般的に解決する

1406
00:57:10,690 --> 00:57:12,990
にスーパーを明確にすることによって、優先順位の問題、

1407
00:57:12,990 --> 00:57:15,620
コンピュータと意図されているもの問わず人間。

1408
00:57:15,620 --> 00:57:17,770
だからこのほんの少しのチートシートを検討してください。

1409
00:57:17,770 --> 00:57:21,690
しかし、これらの詳細の大部分は、我々はいくつかの時間のために取得することはありません。

1410
00:57:21,690 --> 00:57:21,900
>> かしこまりました。

1411
00:57:21,900 --> 00:57:24,120
それでは、ビルドアップさせ、これらの他愛ないから離れる

1412
00:57:24,120 --> 00:57:25,460
数学的な例。

1413
00:57:25,460 --> 00:57:27,500
まだ同じファンダメンタルズを使用していますが、開始

1414
00:57:27,500 --> 00:57:29,960
スクラッチのようにもう少し自分自身を表現しています。

1415
00:57:29,960 --> 00:57:31,660
だからスクラッチで、我々はこれらのブール式を持っていた。

1416
00:57:31,660 --> 00:57:34,890
と英語で、ブール式は何ですか？

1417
00:57:34,890 --> 00:57:35,580
trueまたはfalse。

1418
00:57:35,580 --> 00:57:38,300
これは、trueまたはfalseに評価何かです。

1419
00:57:38,300 --> 00:57:39,060
1または0。

1420
00:57:39,060 --> 00:57:39,870
オンまたはオフにします。

1421
00:57:39,870 --> 00:57:41,000
も好きなように呼んでください。

1422
00:57:41,000 --> 00:57:43,210
今すぐスクラッチで、パズルのピースは、このように見えた。

1423
00:57:43,210 --> 00:57:45,850
そして、それは、3つの中で、そこに底に、組み合わせだ

1424
00:57:45,850 --> 00:57:47,980
パズルのピース。

1425
00:57:47,980 --> 00:57:48,980
一つ接続詞 - 

1426
00:57:48,980 --> 00:57:51,710
空白と空白の持っている何か。

1427
00:57:51,710 --> 00:57:53,970
それの内側とし、2つのブール式。

1428
00:57:53,970 --> 00:57:56,460
それで、あなたはより多くを得るために巣ブール式ができます

1429
00:57:56,460 --> 00:57:59,360
複雑なブール式。

1430
00:57:59,360 --> 00:58:03,930
例えば、それは土曜日であり、あれば、それはいいです

1431
00:58:03,930 --> 00:58:06,180
天気が、その後外に出る。

1432
00:58:06,180 --> 00:58:07,500
そのような任意のまたは何か。

1433
00:58:07,500 --> 00:58:10,090
だからあなたは思い付くブール式に参加することができます

1434
00:58:10,090 --> 00:58:12,780
その答えに基づいている大規模な真理値、

1435
00:58:12,780 --> 00:58:13,800
小さいもので。

1436
00:58:13,800 --> 00:58:15,770
>> さて、C言語で、ありがたいことに、このマッピングは

1437
00:58:15,770 --> 00:58:16,720
実際にはかなりシンプル。

1438
00:58:16,720 --> 00:58:18,820
括弧は、物事はここで明確にするのに役立ちます。

1439
00:58:18,820 --> 00:58:21,700
&&は何を意味するかである "と。"だからそれはどのような

1440
00:58:21,700 --> 00:58:24,700
我々は、最初からCにそれらのブロックを変換しようとしている

1441
00:58:24,700 --> 00:58:27,590
および条件については、我々は左手に、スクラッチで見てきた

1442
00:58:27,590 --> 00:58:31,150
xが小さい場合がある側、私はC言語で同様にそれらを積み重ねることができます

1443
00:58:31,150 --> 00:58:32,970
Yよりも、これを行う。

1444
00:58:32,970 --> 00:58:35,100
xがyより大きい他の場合には、これを行う。

1445
00:58:35,100 --> 00:58:38,030
他に、論理的にはそう言う、等しくなければなりません

1446
00:58:38,030 --> 00:58:39,140
彼らは同じであること。

1447
00:58:39,140 --> 00:58:41,210
だから我々は現在、これらのものを構築するために始めることができます。

1448
00:58:41,210 --> 00:58:42,170
>> だから例を行うてみましょう。

1449
00:58:42,170 --> 00:58:45,550
私はもちろんのウェブサイト、その上にあるファイルを開いてみましょう

1450
00:58:45,550 --> 00:58:47,270
私は事前に書いている。

1451
00:58:47,270 --> 00:58:50,540
それはnonswitch.cと呼ばれています。

1452
00:58:50,540 --> 00:58:52,270
なぜ一瞬でと我々が表示されます。

1453
00:58:52,270 --> 00:58:54,770
したがって、このファイル内の -  nonswitch.c- - 

1454
00:58:54,770 --> 00:58:56,830
第一の全体の束があることを認識

1455
00:58:56,830 --> 00:58:58,460
先頭のコメント。

1456
00:58:58,460 --> 00:59:00,110
それはちょうど何それ、ファイルの名前を説明している

1457
00:59:00,110 --> 00:59:01,260
ない、など。

1458
00:59:01,260 --> 00:59:04,390
そしてそれは明らかに論理積（AND）するの使用方法を示しています - 

1459
00:59:04,390 --> 00:59:06,220
二つの式を対等接続。

1460
00:59:06,220 --> 00:59:07,670
>> だから、このプログラムがどのように機能するかを確認してみましょう。

1461
00:59:07,670 --> 00:59:10,840
私は2つのファイル、cs50.hとstdio.hをインクルード。

1462
00:59:10,840 --> 00:59:13,180
私はプログラムに、今では、下にスクロールすると、それはやや長いです

1463
00:59:13,180 --> 00:59:15,730
よりも、我々は前に書いたが、かなり読みやすい。

1464
00:59:15,730 --> 00:59:18,360
だから私は、最初にライン18上に、ユーザに印刷

1465
00:59:18,360 --> 00:59:20,460
"私に1から10までの整数を与える。"そう

1466
00:59:20,460 --> 00:59:21,530
それはすぐそこです。

1467
00:59:21,530 --> 00:59:23,410
今私は、整数を取得します。

1468
00:59:23,410 --> 00:59:25,380
しかし、それgetIntを実現する - 非常にシンプル。

1469
00:59:25,380 --> 00:59:26,510
それはちょうどintを得るために起こっている。

1470
00:59:26,510 --> 00:59:28,830
それはint型ではなく、取得しないことを保証するために起こっている

1471
00:59:28,830 --> 00:59:30,060
文字列またはフロート。

1472
00:59:30,060 --> 00:59:32,390
しかし、それは境界チェックのどんなことをするつもりはない。

1473
00:59:32,390 --> 00:59:34,750
それはの間になるように数字をフィルタリングするつもりはない

1474
00:59:34,750 --> 00:59:35,630
一定の範囲。

1475
00:59:35,630 --> 00:59:37,730
だから我々は自分自身それを実装する必要があります。

1476
00:59:37,730 --> 00:59:40,680
だから、私はの組み合わせを行うことができる場合には、スクラッチのように

1477
00:59:40,680 --> 00:59:43,560
二つの表現は、私は次のようにC言語でそれを行うことができる。

1478
00:59:43,560 --> 00:59:48,660
nは1以上であり、n未満の場合とで

1479
00:59:48,660 --> 00:59:52,220
または3に等しく、私は非常に勝手に決めてしようと思っている

1480
00:59:52,220 --> 00:59:53,830
小さな数になるように番号。

1481
00:59:53,830 --> 00:59:56,730
ただ文のために。

1482
00:59:56,730 --> 01:00:00,210
nは4と6の間にある他の場合は、印刷は、 "あなたは、媒体を選んだ

1483
01:00:00,210 --> 01:00:03,440
番号 "エルスnはプリント、7〜10であれば"あなたが選んだ

1484
01:00:03,440 --> 01:00:06,390
大きな数。 "ELSE printは"無効な数字を選ぶ。 "

1485
01:00:06,390 --> 01:00:07,900
私たちがしている場合は、論理的にはそれが続くので

1486
01:00:07,900 --> 01:00:09,230
私達の範囲を使い果たした。

1487
01:00:09,230 --> 01:00:12,400
>> だから、これは我々がより大きいか、またはどのように書くかというわけではありません。実現

1488
01:00:12,400 --> 01:00:15,000
数学の授業中に等しい。

1489
01:00:15,000 --> 01:00:15,160
右か？

1490
01:00:15,160 --> 01:00:17,430
通常は、その下の行で、このようにそれを描く。

1491
01:00:17,430 --> 01:00:19,250
しかし、私のキーボードのようなキーがありません。

1492
01:00:19,250 --> 01:00:22,390
以上を発現するためのCの記号がそう

1493
01:00:22,390 --> 01:00:25,770
に等しい未満のための2つの文字、および記号です

1494
01:00:25,770 --> 01:00:29,100
または等しいだけでなく2文字です。

1495
01:00:29,100 --> 01:00:29,330
かしこまりました。

1496
01:00:29,330 --> 01:00:31,910
私はこのプログラムを実行する場合だから、あなたは、おそらくそれは何かを推測することができます

1497
01:00:31,910 --> 01:00:32,650
何をするつもり。

1498
01:00:32,650 --> 01:00:36,180
私が先に行くとnonswitchを加えた場合は、入力します。

1499
01:00:36,180 --> 01:00:38,130
その後nonswitchを実行します。

1500
01:00:38,130 --> 01:00:39,530
私に1から10までの数字を与える。

1501
01:00:39,530 --> 01:00:40,870
私はそれを11を与えるつもりだ。

1502
01:00:40,870 --> 01:00:42,280
私は、無効な番号を選んだ。

1503
01:00:42,280 --> 01:00:44,090
私は3番を試してみましょう。

1504
01:00:44,090 --> 01:00:45,990
私は少数を選んだ。

1505
01:00:45,990 --> 01:00:48,360
だからそこにはかなり簡単。

1506
01:00:48,360 --> 01:00:52,230
>> 私はこのプログラムの動作を変更したい場合はどうすればよいと

1507
01:00:52,230 --> 01:00:54,250
代わりに少し何か違うのですか？

1508
01:00:54,250 --> 01:00:57,620
私が先に行くとこれを言わせてください。

1509
01:00:57,620 --> 01:00:59,480
私はこのすべてを取り除くましょう。

1510
01:00:59,480 --> 01:01:03,780
と言わせするif（n == 42）。

1511
01:01:03,780 --> 01:01:08,730
そして私はあなたが選んだ "先に行くと、プリントを言うつもりです

1512
01:01:08,730 --> 01:01:16,340
正しい答えは "そうでなければ我々は、先に行くと言おうとしている

1513
01:01:16,340 --> 01:01:18,460
printf（ "あなたが選んだ

1514
01:01:18,460 --> 01:01:21,170
間違った答え "）;。オーケー。

1515
01:01:21,170 --> 01:01:22,040
という理由だけで。

1516
01:01:22,040 --> 01:01:23,890
>> 今、私たちはここで行うことができますいくつかのポイント。

1517
01:01:23,890 --> 01:01:26,570
一つは、私はあなただと思うだろうと記号を入力しませんでした

1518
01:01:26,570 --> 01:01:27,390
最も合理的。

1519
01:01:27,390 --> 01:01:30,110
あなたが使用していないアウト私は平等を確認する場合は、オン

1520
01:01:30,110 --> 01:01:30,910
等号。

1521
01:01:30,910 --> 01:01:34,000
代わりに、同等の等号を使用しています。

1522
01:01:34,000 --> 01:01:36,440
そして、なぜそれだけで直感的に、かもしれない？

1523
01:01:36,440 --> 01:01:37,030
うん。

1524
01:01:37,030 --> 01:01:39,330
読者：[聞こえない]

1525
01:01:39,330 --> 01:01:39,615
デイヴィッドJ.マラン：正しい。

1526
01:01:39,615 --> 01:01:41,630
等号は、すでに割り当てに使用されます。

1527
01:01:41,630 --> 01:01:43,020
誰かが実際にを介してこれを考えていませんでした。

1528
01:01:43,020 --> 01:01:45,820
そして、今、それは等価テストに来るとき、我々はする必要はあり

1529
01:01:45,820 --> 01:01:48,850
より明確になる、と等しいか言う。

1530
01:01:48,850 --> 01:01:52,110
非常によくある間違いは、これを行うことです。

1531
01:01:52,110 --> 01:01:54,800
そして、営業時間または来週中にifやで

1532
01:01:54,800 --> 01:01:58,340
あなたは、このような何かを行うと次の2週間

1533
01:01:58,340 --> 01:02:00,920
10のそれとの闘争、把握しようとして20分

1534
01:02:00,920 --> 01:02:03,330
いまいましいバグが何であるかを、あなたはそれらのいずれかであることを認識

1535
01:02:03,330 --> 01:02:04,470
このミスを犯した人々。

1536
01:02:04,470 --> 01:02:06,030
作りやすいので、スーパー。

1537
01:02:06,030 --> 01:02:08,240
しかし、目標は今、この間違いを追い払うためです。

1538
01:02:08,240 --> 01:02:11,840
これは本当に何を言っているので、これは評価するだろうか？

1539
01:02:11,840 --> 01:02:15,010
nは42を取得した場合。

1540
01:02:15,010 --> 01:02:18,250
だから動詞の人々が表現する、口頭、使用

1541
01:02:18,250 --> 01:02:21,800
割り当ての概念は、 "取得"です。だから、nが42を取得する場合。

1542
01:02:21,800 --> 01:02:24,060
ので、nに42を代入することを意味します。

1543
01:02:24,060 --> 01:02:26,250
今私は、括弧内のブール式を持っている

1544
01:02:26,250 --> 01:02:30,230
この条件の中に、の値は42です。

1545
01:02:30,230 --> 01:02:30,390
右か？

1546
01:02:30,390 --> 01:02:32,690
あなたが内側からそれを評価する場合があるため、合計

1547
01:02:32,690 --> 01:02:34,100
答えは、今では、42である。

1548
01:02:34,100 --> 01:02:37,360
>> 私はあなたに質問をしそうだとすれば、 "（42）、あれば"とは何か

1549
01:02:37,360 --> 01:02:38,410
ことは本当に言って？

1550
01:02:38,410 --> 01:02:40,990
さて、ブール式はtrueまたはfalseを指定できます。

1551
01:02:40,990 --> 01:02:42,010
1または0。

1552
01:02:42,010 --> 01:02:43,010
オンまたはオフにします。

1553
01:02:43,010 --> 01:02:45,240
だから我々はそれによって、すべての、ここのコーナーケースを持っているように見える

1554
01:02:45,240 --> 01:02:50,060
"（42）が"突然、私は言っている。これはブール値ではありません。

1555
01:02:50,060 --> 01:02:54,500
だから、コンピュータは何をすべきか、しかし、それは本質的に相当である

1556
01:02:54,500 --> 01:02:58,620
0ではない何かが真であると解釈されます。

1557
01:02:58,620 --> 01:02:59,340
1。

1558
01:02:59,340 --> 01:02:59,690
上。

1559
01:02:59,690 --> 01:03:01,510
彼らはすべて機能的に等価だ。

1560
01:03:01,510 --> 01:03:05,070
のみ値0、またはfalseキーワードは、我々が説明するように

1561
01:03:05,070 --> 01:03:07,860
最終的に参照してください、実際にはfalseです。

1562
01:03:07,860 --> 01:03:15,040
それが非ゼロであるためこのように "した場合（42）"実際に、真となります。

1563
01:03:15,040 --> 01:03:18,620
そこでここでは、より正確に言えば、ブール値は実際にそうではありません

1564
01:03:18,620 --> 01:03:20,680
はるかにtrueまたはfalseですが、このために

1565
01:03:20,680 --> 01:03:24,650
場合、0または非ゼロであるなら。

1566
01:03:24,650 --> 01:03:26,330
だから偽またはfalseではない。

1567
01:03:26,330 --> 01:03:28,640
そして、私たちはすべての多くを包含することを可能にする

1568
01:03:28,640 --> 01:03:30,980
括弧内の表現の可能性。

1569
01:03:30,980 --> 01:03:33,840
だから我々は、今までので、慎重に、これを言う必要があります - 

1570
01:03:33,840 --> 01:03:35,620
するif（n == 42）。

1571
01:03:35,620 --> 01:03:39,100
単に我々が平等のテストを指定する必要があるため、

1572
01:03:39,100 --> 01:03:40,930
値の代入ではない。

1573
01:03:40,930 --> 01:03:42,830
>> ここで注目に値する他に何がある？

1574
01:03:42,830 --> 01:03:46,030
これらの中括弧は、実際には必要ありません。

1575
01:03:46,030 --> 01:03:48,650
私はちょうどここにNIT-選り好みするためにそれらをやってきました。

1576
01:03:48,650 --> 01:03:51,350
しかし、あなたは唯一の1ラインを持っている条件がある場合

1577
01:03:51,350 --> 01:03:55,100
コー​​ドは、便利なように、プログラマが使用する必要はありません

1578
01:03:55,100 --> 01:03:56,030
中括弧。

1579
01:03:56,030 --> 01:03:59,370
それは単に審美的な理由のために、インデントすれば十分である、と

1580
01:03:59,370 --> 01:04:01,050
その後、コードのあなたの行を記述します。

1581
01:04:01,050 --> 01:04:04,160
ために - あなたは2行のコードを記述したい場合にのみ、

1582
01:04:04,160 --> 01:04:08,230
例えば、他のprintf（ "バイバイ！"）。あなたは何をしたい場合

1583
01:04:08,230 --> 01:04:09,540
つまり、これは壊れています。

1584
01:04:09,540 --> 01:04:11,700
あなたはあなたが欲しいすべてをインデントすることができますが、あなたが持っているという事実

1585
01:04:11,700 --> 01:04:14,600
中括弧を使用せずに2行のコードを入力した

1586
01:04:14,600 --> 01:04:16,860
このプログラムが正しく実行またはかもしれないことを意味

1587
01:04:16,860 --> 01:04:18,530
でも正しくコンパイルされません。

1588
01:04:18,530 --> 01:04:21,040
だから今は、正直に言うと、私は最高の癖がちょうどだと思う

1589
01:04:21,040 --> 01:04:24,460
中括弧を使用して、あなたは彼らが行うことがわかります

1590
01:04:24,460 --> 01:04:25,750
スーパーに何が起こっているのをオフにします。

1591
01:04:25,750 --> 01:04:29,410
>> また、余談として - あなたはそれらの中している場合は特に使用している人

1592
01:04:29,410 --> 01:04:31,700
オンライン推薦図書やリソース - 

1593
01:04:31,700 --> 01:04:33,480
でスタイルのこの概念があることを認識

1594
01:04:33,480 --> 01:04:34,130
プログラミング。

1595
01:04:34,130 --> 01:04:37,280
そして何人かの人々は実際に中括弧を置くことを好む

1596
01:04:37,280 --> 01:04:38,720
こっちのライン上。

1597
01:04:38,720 --> 01:04:41,520
一部の人々は、とんでもない事をすることを好む

1598
01:04:41,520 --> 01:04:43,830
ここにそれらを入れたい。

1599
01:04:43,830 --> 01:04:45,140
それがに来るときに間違った答えはありません

1600
01:04:45,140 --> 01:04:46,710
スタイルが、これは間違っている。

1601
01:04:46,710 --> 01:04:47,700
しかし、一部の人々はそれを行う。

1602
01:04:47,700 --> 01:04:49,160
[笑い]

1603
01:04:49,160 --> 01:04:51,760
デイヴィッドJ.マラン：だから私は今、これを言及、単にので、

1604
01:04:51,760 --> 01:04:54,400
あなたの本やオンラインで物事をよく読んで、あなたは取得するつもりだ

1605
01:04:54,400 --> 01:04:55,990
異なる別の先生からのメッセージと

1606
01:04:55,990 --> 01:04:56,730
さまざまな作家。

1607
01:04:56,730 --> 01:04:58,640
そして、ちょうど機能的には、彼らがしている、ことを認識

1608
01:04:58,640 --> 01:05:00,740
一般的には同等ですが、一貫している。

1609
01:05:00,740 --> 01:05:02,850
したがって、このケースでは、我々は、中に標準化します

1610
01:05:02,850 --> 01:05:04,650
括弧は左側にここに並ぶ。

1611
01:05:04,650 --> 01:05:04,910
>> かしこまりました。

1612
01:05:04,910 --> 01:05:07,040
それでは、今、先に行くと、これを実行し、何が起こるか見てみましょう

1613
01:05:07,040 --> 01:05:07,780
このプログラムと。

1614
01:05:07,780 --> 01:05:09,970
nonswitchを作る。

1615
01:05:09,970 --> 01:05:11,040
その後nonswitchを実行します。

1616
01:05:11,040 --> 01:05:13,900
私0の間の整数を与えると - だからそれは関係ないです

1617
01:05:13,900 --> 01:05:16,480
もう、私はちょうど任意に42を言うつもりです。

1618
01:05:16,480 --> 01:05:17,850
そして、私は、正しい答えを選んだ。

1619
01:05:17,850 --> 01:05:20,430
さてさて、実際には別の方向でこれを取ることができます。

1620
01:05:20,430 --> 01:05:22,070
他の構文は、我々はそこのoutそれは回り

1621
01:05:22,070 --> 01:05:23,480
プログラム内で使用することができます。

1622
01:05:23,480 --> 01:05:27,310
ここでは、機能的に同じですが、構文の新しい作品は、だ

1623
01:05:27,310 --> 01:05:30,680
しかし、ただ自分自身を表現する別の方法を紹介します。

1624
01:05:30,680 --> 01:05:32,830
だから、これはと呼ばれるものである "switch文。"と

1625
01:05:32,830 --> 01:05:34,820
switch文は、次のように動作します。

1626
01:05:34,820 --> 01:05:37,580
それはあなたがしたい値、カッコ内に取り

1627
01:05:37,580 --> 01:05:38,860
上の "スイッチ"。

1628
01:05:38,860 --> 01:05:41,490
あなたは、その値に基づいて、異なる動作をしたいと思います。

1629
01:05:41,490 --> 01:05:44,360
だから、これはnの値のスイッチを意味します。

1630
01:05:44,360 --> 01:05:45,480
そして、これは何を意味するのか？

1631
01:05:45,480 --> 01:05:50,530
さて、nは1または2または3の場合、先に行くと "あなたをプリントアウト

1632
01:05:50,530 --> 01:05:52,680
大きな数を選んだ "とし、休憩。

1633
01:05:52,680 --> 01:05:55,720
休憩のための理由は、Cの働き方としてあるということです

1634
01:05:55,720 --> 01:05:59,790
それはそのマッチケースを見つけるとすぐに、それが実行を開始します

1635
01:05:59,790 --> 01:06:01,610
その下にあるすべてのコード。

1636
01:06:01,610 --> 01:06:04,580
だから私は、27行目でここにそうであるように私は、コードの1行を持っている場合、それは

1637
01:06:04,580 --> 01:06:05,360
実行されます。

1638
01:06:05,360 --> 01:06:07,520
私はここで別の行を追加した場合、それは実行されます。

1639
01:06:07,520 --> 01:06:09,350
別のラインがここに、それが実行されます。

1640
01:06:09,350 --> 01:06:12,460
プログラムは下に何実行を停止します

1641
01:06:12,460 --> 01:06:14,680
私は明示的に適用可能なcase文

1642
01:06:14,680 --> 01:06:17,210
"壊す"と言う。だから、間違っている。

1643
01:06:17,210 --> 01:06:19,220
右、この場合には、結果として。

1644
01:06:19,220 --> 01:06:22,130
ケース4または5または6が、同様に起こっている

1645
01:06:22,130 --> 01:06:23,160
メッセージをプリントアウトする。

1646
01:06:23,160 --> 01:06:24,410
この場合、培地数。

1647
01:06:24,410 --> 01:06:25,200
破る。

1648
01:06:25,200 --> 01:06:28,160
ケース7、8、9、10、それは "あなたはビッグを選んだプリントアウトするために起こっている

1649
01:06:28,160 --> 01:06:28,950
番号 "ブレーク。

1650
01:06:28,950 --> 01:06:31,290
そして、 "デフォルト"というキーワードは、文字通りあり

1651
01:06:31,290 --> 01:06:34,090
それが効果的に構築する "else"のようなものだ。

1652
01:06:34,090 --> 01:06:36,010
だから新しい構文が、知的、

1653
01:06:36,010 --> 01:06:37,060
すべての新しいここでは何もありません。

1654
01:06:37,060 --> 01:06:38,280
それはちょうどスクラッチのようなものだ。

1655
01:06:38,280 --> 01:06:41,040
ブロックのソート、ELSE IF、ELSE IF、IF。

1656
01:06:41,040 --> 01:06:44,560
>> だから、このプログラムの切り替えバージョンです。

1657
01:06:44,560 --> 01:06:46,280
しかし、我々はここに数字でそれをやったことがわかります。

1658
01:06:46,280 --> 01:06:49,040
私は、2番目のバージョンを開くだけで表示するようにしましょう

1659
01:06:49,040 --> 01:06:50,670
もう少し具体的な何か。

1660
01:06:50,670 --> 01:06:52,840
そこでここでは代わりに等級を持っています。

1661
01:06:52,840 --> 01:06:55,540
あなただけではなく整数にしますが、上のスイッチを使用することができ判明

1662
01:06:55,540 --> 01:06:56,340
文字。

1663
01:06:56,340 --> 01:06:58,930
すべてのデータ型であるが、少なくとも文字ではありません。

1664
01:06:58,930 --> 01:07:02,670
だからここで、我々は、Cの値がある場合のようにそんなことができる

1665
01:07:02,670 --> 01:07:06,230
GetChar関数を使って、19行目で入力したユーザーに、、、

1666
01:07:06,230 --> 01:07:09,410
資本金またはそれグレードとして解釈してみましょう、小文字である

1667
01:07:09,410 --> 01:07:11,340
彼らは優れたグレードを選んだと言う。

1668
01:07:11,340 --> 01:07:14,690
とダウンswitch文に沿って、我々は他のを持っている

1669
01:07:14,690 --> 01:07:17,950
"B"と "C"のsの例など。

1670
01:07:17,950 --> 01:07:19,780
しかし、今はもうひとつの締めくくりしてみましょう。

1671
01:07:19,780 --> 01:07:21,130
そして再び、種類のを飛んで

1672
01:07:21,130 --> 01:07:22,200
これらの例のいくつか。

1673
01:07:22,200 --> 01:07:26,990
しかし、それは我々が今、それらを適用することができます本当にそうだ - 

1674
01:07:26,990 --> 01:07:28,880
または実際に、ちょうど今それらを翻訳 - 

1675
01:07:28,880 --> 01:07:32,220
Cへ

1676
01:07:32,220 --> 01:07:33,310
>> だから私は先に行くとこれを行うことができます。

1677
01:07:33,310 --> 01:07:34,830
私は、新しいファイルを開くつもりです。

1678
01:07:34,830 --> 01:07:39,430
そして、私は、Cランタイムライブラリが含まれていますかするつもりです。

1679
01:07:39,430 --> 01:07:42,770
そして私はint型のmain（void）をするつもりです。

1680
01:07:42,770 --> 01:07:46,390
私はloop.c.としてこのファイルを保存しておきましょう

1681
01:07:46,390 --> 01:07:48,280
ほんの一例を挙げると。

1682
01:07:48,280 --> 01:07:49,910
そして、私は先に行くと、次の操作を実行するつもりです。

1683
01:07:49,910 --> 01:07:54,180
私は非常に面倒なプログラムを書きたい。

1684
01:07:54,180 --> 01:07:56,170
10だから。

1685
01:07:56,170 --> 01:07:58,862
これを実行してみましょう。

1686
01:07:58,862 --> 01:07:59,320
9。

1687
01:07:59,320 --> 01:08:00,360
かしこまりました。

1688
01:08:00,360 --> 01:08:02,120
あなたがプログラミングでこれをやって起動するとすぐに、君がいる

1689
01:08:02,120 --> 01:08:03,490
おそらく何か間違ったことをして。

1690
01:08:03,490 --> 01:08:04,950
しかし、我々はそこにとにかく始めましょう。

1691
01:08:04,950 --> 01:08:05,430
おっと。

1692
01:08:05,430 --> 01:08:06,950
それは実際に間違っている。

1693
01:08:06,950 --> 01:08:08,230
7。

1694
01:08:08,230 --> 01:08:09,440
6。

1695
01:08:09,440 --> 01:08:10,750
5。

1696
01:08:10,750 --> 01:08:11,200
4。

1697
01:08:11,200 --> 01:08:12,450
何も我々が0に到達したとき発生するつもりはないだ。

1698
01:08:12,450 --> 01:08:13,290
3。

1699
01:08:13,290 --> 01:08:14,590
2。

1700
01:08:14,590 --> 01:08:15,630
1。

1701
01:08:15,630 --> 01:08:16,020
オーケー。

1702
01:08:16,020 --> 01:08:17,560
0。

1703
01:08:17,560 --> 01:08:18,689
削除します。

1704
01:08:18,689 --> 01:08:19,029
>> かしこまりました。

1705
01:08:19,029 --> 01:08:20,029
だから、0を返します。

1706
01:08:20,029 --> 01:08:22,010
したがって、このプログラムは明らかに非常に何をしてどうするつもりだ

1707
01:08:22,010 --> 01:08:23,310
うんざりするほど、それが何をするつもりだと言う。

1708
01:08:23,310 --> 01:08:24,060
それはそれらのすべてを印字することになっている

1709
01:08:24,060 --> 01:08:25,290
上から下に値。

1710
01:08:25,290 --> 01:08:27,140
だから私はループを作るやらせる。

1711
01:08:27,140 --> 01:08:28,640
その後 - おっと。

1712
01:08:28,640 --> 01:08:29,700
ループを作成します。

1713
01:08:29,700 --> 01:08:31,479
私が間違ったディレクトリにありました。

1714
01:08:31,479 --> 01:08:33,300
そして今、私はループを実行してみましょう。

1715
01:08:33,300 --> 01:08:34,140
入力します。

1716
01:08:34,140 --> 01:08:34,620
WOOHOO。

1717
01:08:34,620 --> 01:08:35,270
非常に素晴らしい。

1718
01:08:35,270 --> 01:08:36,279
ニース、長いプログラム。

1719
01:08:36,279 --> 01:08:38,109
>> すべての権利が、今より良いこれを実行してみましょう。

1720
01:08:38,109 --> 01:08:40,810
あなたはループを使用し始めたときだけ、スクラッチのように

1721
01:08:40,810 --> 01:08:43,149
構築するのではなく、ただのすべてをコピーして貼り付ける

1722
01:08:43,149 --> 01:08:45,580
パズルのピースは、私はこの事をご紹介しましょう​​。

1723
01:08:45,580 --> 01:08:48,609
だから、C言語では、様々なループ構造がありますが、

1724
01:08:48,609 --> 01:08:50,540
の一つは、このように見えます。

1725
01:08:50,540 --> 01:08:55,069
"for"ループは2つのセミコロンで区切られた3つのものを持っています。

1726
01:08:55,069 --> 01:08:57,770
そして、ループの本体の内側に、いわば - 

1727
01:08:57,770 --> 01:08:59,390
中括弧の内側のもの - 

1728
01:08:59,390 --> 01:09:01,010
我々は何度も何度も何かを行うことができます。

1729
01:09:01,010 --> 01:09:02,310
だから私は、画面上にここに持っているもの、これは

1730
01:09:02,310 --> 01:09:03,300
文字通りコメント。

1731
01:09:03,300 --> 01:09:05,380
/ /ここで意味のコメントをしています。

1732
01:09:05,380 --> 01:09:06,180
これは、コードではありません。

1733
01:09:06,180 --> 01:09:08,890
これは私にはちょうど英語の説明は、ヒトである。

1734
01:09:08,890 --> 01:09:11,300
>> だから初期化、条件、および更新します。

1735
01:09:11,300 --> 01:09:12,770
さて、どのようにこの作品を見てみましょう。

1736
01:09:12,770 --> 01:09:15,520
これは、私は次のようにこのプログラムを書き換えることができます。

1737
01:09:15,520 --> 01:09:16,399
のための - 

1738
01:09:16,399 --> 01:09:18,029
ので、ここで私のループが来る - 

1739
01:09:18,029 --> 01:09:19,439
私をint  - 

1740
01:09:19,439 --> 01:09:21,330
ここでの "i"という変数は来る - 

1741
01:09:21,330 --> 01:09:23,140
10に初期化されます。

1742
01:09:23,140 --> 01:09:25,260
だから、私の初期化があります。

1743
01:09:25,260 --> 01:09:29,450
私は長い間 "i"がより大きいか、このループをやってみたい

1744
01:09:29,450 --> 01:09:30,899
0に等しい。

1745
01:09:30,899 --> 01:09:32,880
そして、このループの繰り返しごとに、私がしたい

1746
01:09:32,880 --> 01:09:34,979
iを実行する - 。

1747
01:09:34,979 --> 01:09:36,310
だから我々は月曜日に+ +を見ました。

1748
01:09:36,310 --> 01:09:37,660
 - 反対です。

1749
01:09:37,660 --> 01:09:39,410
これは、値を1減らします。

1750
01:09:39,410 --> 01:09:43,319
このループの内部では、私は実際に何かをしたい。

1751
01:09:43,319 --> 01:09:46,390
だから私は、printfのような何かを言うつもりです。

1752
01:09:46,390 --> 01:09:48,939
これは明らかにだけであるので、私は、今では10を言いたくない

1753
01:09:48,939 --> 01:09:50,000
同じ値を印字すること。

1754
01:09:50,000 --> 01:09:52,246
私はおそらく、代わりに印刷するには何が欲しいですか？

1755
01:09:52,246 --> 01:09:52,590
うん。

1756
01:09:52,590 --> 01:09:55,270
だから、 "私は。"ので、％D、I。

1757
01:09:55,270 --> 01:09:57,340
>> だから私は以前から、これらのアイデアの一つを盗むつもりだ - 

1758
01:09:57,340 --> 01:09:59,640
フォーマットコードのこの置換 - 

1759
01:09:59,640 --> 01:10:01,620
その後ダウンここで、一番下に、私はちょうど、0を返します

1760
01:10:01,620 --> 01:10:02,710
おまけに。

1761
01:10:02,710 --> 01:10:04,740
しかし、今、私は、より簡潔なプログラムを持っています。

1762
01:10:04,740 --> 01:10:07,490
それは、ほんの数行ではなく、いくつかの10または11行です。

1763
01:10:07,490 --> 01:10:09,440
私はここに私のプロンプトに移動しましょう​​。

1764
01:10:09,440 --> 01:10:10,630
リメイクループ。

1765
01:10:10,630 --> 01:10:12,140
ループを再実行してください。

1766
01:10:12,140 --> 01:10:13,570
そして、それは同じように見えます。

1767
01:10:13,570 --> 01:10:15,550
さて、プログラムはもっと面白いです。

1768
01:10:15,550 --> 01:10:17,180
しかし、今私はこのような何かを入力することができます。

1769
01:10:17,180 --> 01:10:18,970
私は100にこれを変更することができます。

1770
01:10:18,970 --> 01:10:21,400
私はその後、私のプログラムを再コンパイルすることができます。

1771
01:10:21,400 --> 01:10:23,360
そして私は私のプログラムを再実行することができます。

1772
01:10:23,360 --> 01:10:26,390
そして今、それは、今日のコンピュータ上で超高速になる。

1773
01:10:26,390 --> 01:10:27,820
しかし、私はそこに持っている - 

1774
01:10:27,820 --> 01:10:29,620
そして実際に、私のスクロールバッファはしません

1775
01:10:29,620 --> 01:10:30,890
でも、そんなに遠くまで行く。

1776
01:10:30,890 --> 01:10:31,680
そうしよう。

1777
01:10:31,680 --> 01:10:34,090
だから、そこに我々はすべての100を持っています。

1778
01:10:34,090 --> 01:10:35,880
しかし、それはここでミスをするのは簡単です。

1779
01:10:35,880 --> 01:10:37,920
私は何かの予想される動作になるだろう

1780
01:10:37,920 --> 01:10:41,150
誤っているのですか？

1781
01:10:41,150 --> 01:10:42,550
だから、それは無限のように感じている。

1782
01:10:42,550 --> 01:10:44,670
だから、コンピュータが動作するかどうか見てみましょう。

1783
01:10:44,670 --> 01:10:47,020
>> だから私は先に行くと、ループを作ってみましょう。

1784
01:10:47,020 --> 01:10:48,355
そして、私はループを実行してみましょう。

1785
01:10:53,590 --> 01:10:55,210
だから、その瞬間にそれに戻ってみましょう。

1786
01:10:55,210 --> 01:10:56,720
我々は、実行してみましょうよ。

1787
01:10:56,720 --> 01:10:59,520
なぜなら我々は最小限に、何をカウントアップするべきでしょうか？

1788
01:10:59,520 --> 01:11:02,200
おそらく、少なくとも2億ドル、我々は多くのビットを持っている場合、および

1789
01:11:02,200 --> 01:11:03,660
我々は、正の値を使用しています。

1790
01:11:03,660 --> 01:11:04,890
それでは、ここに戻ってジャンプすることができます。

1791
01:11:04,890 --> 01:11:07,810
ループは、これらの種類に加えて、我々は中には何と呼ばれている

1792
01:11:07,810 --> 01:11:09,430
ループ。それでは、スクラッチのように、あなたは永遠に持っていた

1793
01:11:09,430 --> 01:11:11,240
ブロックは、あなたはブロックを繰り返していた。

1794
01:11:11,240 --> 01:11:13,270
同様に、C言語では、あなただけの他の方法を持っている

1795
01:11:13,270 --> 01:11:14,260
自身を表現する。

1796
01:11:14,260 --> 01:11:17,110
だからあなたができるようになり、whileループの概念を持っている

1797
01:11:17,110 --> 01:11:18,860
自分で少し異なって表現しています。

1798
01:11:18,860 --> 01:11:21,490
そしてあなたは、do-whil​​eループと呼ばれるものを持っている

1799
01:11:21,490 --> 01:11:24,200
どちらも微妙に異なります。

1800
01:11:24,200 --> 01:11:25,320
そして、我々は時間をかけて離れてこれらをいじめるよ。

1801
01:11:25,320 --> 01:11:28,630
>> しかし、ここではここで、この最後の1を見てみましょう。

1802
01:11:28,630 --> 01:11:30,160
我々は、に行く場合 - 

1803
01:11:30,160 --> 01:11:31,466
まだ実行されている。

1804
01:11:31,466 --> 01:11:32,770
それはかなり無限大です。

1805
01:11:32,770 --> 01:11:36,870
だから私はポジティブに行かせ、そしてどのように我々が実際にできることを示す

1806
01:11:36,870 --> 01:11:39,410
もう少し効率的にユーザ入力を制御します。

1807
01:11:39,410 --> 01:11:40,910
それはかなり短いプログラムです。

1808
01:11:40,910 --> 01:11:43,730
そしてここで我々は、メインは、int nの宣言の中で、持っている。

1809
01:11:43,730 --> 01:11:46,570
だから私、Nという名前の変数を与える。今、私は文字通り言う

1810
01:11:46,570 --> 01:11:48,340
"を行う。"そして私は中かっこを持っている

1811
01:11:48,340 --> 01:11:49,630
ブレース、近い中かっこ。

1812
01:11:49,630 --> 01:11:52,000
そして、その直後、気付く、それは言うはn

1813
01:11:52,000 --> 01:11:53,790
1未満である。

1814
01:11:53,790 --> 01:11:55,300
だから、これらの行がわかり - 

1815
01:11:55,300 --> 01:11:56,740
19から24  - 

1816
01:11:56,740 --> 01:11:59,450
総称して、do-whil​​eループを構成しています。

1817
01:11:59,450 --> 01:12:01,280
そして再び、新しい構文ではなく、新しいアイデア。

1818
01:12:01,280 --> 01:12:03,740
これは、文法的に、ループのちょうど別の方法です。

1819
01:12:03,740 --> 01:12:04,890
だから、これは何をするのでしょうか？

1820
01:12:04,890 --> 01:12:08,000
nが1未満である間、以下の操作を行います。

1821
01:12:08,000 --> 01:12:09,080
だから私は何をすべきかをしたいですか？

1822
01:12:09,080 --> 01:12:11,390
私はあなたが私達に正の整数を与えることを求めています。

1823
01:12:11,390 --> 01:12:14,110
それから私は、実際にユーザから整数を取得しようとします。

1824
01:12:14,110 --> 01:12:16,740
しかし、ここでの操作の順序の点で、なぜなら

1825
01:12:16,740 --> 01:12:21,850
条件はここでダウンしている間、私はその後、チェックするつもりだ、nは

1826
01:12:21,850 --> 01:12:23,100
1未満？

1827
01:12:23,100 --> 01:12:24,600
したがって、ユーザーと仮定 - 

1828
01:12:24,600 --> 01:12:26,450
この方法で求められた後 - 

1829
01:12:26,450 --> 01:12:29,190
値0の型。

1830
01:12:29,190 --> 01:12:34,510
この条件は、trueまたはfalseになるだろうか？

1831
01:12:34,510 --> 01:12:35,820
まあ、それは実際に本当のことになるだろう。

1832
01:12:35,820 --> 01:12:38,700
ので、nは0であり、0が1未満です。

1833
01:12:38,700 --> 01:12:40,140
だからそれは何を意味するのでしょうか？

1834
01:12:40,140 --> 01:12:41,160
再びそれを行う。

1835
01:12:41,160 --> 01:12:41,990
再びそれを行う。

1836
01:12:41,990 --> 01:12:42,640
再びそれを行う。

1837
01:12:42,640 --> 01:12:46,080
一度だけ、その条件がfalseと評価されます。

1838
01:12:46,080 --> 01:12:47,510
私は42で入力した場合。

1839
01:12:47,510 --> 01:12:49,690
ノーまあ、42は1未満ではありません。

1840
01:12:49,690 --> 01:12:52,320
したがって、このループは、実行が終了しています。

1841
01:12:52,320 --> 01:12:54,650
それで、その時点では、プログラムは、感謝を言うだろう

1842
01:12:54,650 --> 01:12:57,530
この場合は42、。

1843
01:12:57,530 --> 01:13:00,320
今、あなたは自分自身を表現するこの方法を持っていること - 

1844
01:13:00,320 --> 01:13:02,360
これが終了するのを我々は待つべきではありません。

1845
01:13:02,360 --> 01:13:03,620
これは、いくつかの時間がかかるだろう。

1846
01:13:03,620 --> 01:13:04,990
多分、次回つづく。

1847
01:13:04,990 --> 01:13:08,050
>> しかし、今、あなたは、うまくいけば理解する能力を持っている

1848
01:13:08,050 --> 01:13:09,060
オタクユーモアのビット。

1849
01:13:09,060 --> 01:13:11,560
謝罪。

1850
01:13:11,560 --> 01:13:13,620
これは、計算機科学にユーモアを表すものではありません

1851
01:13:13,620 --> 01:13:14,870
世界が、それはかわいいです。

1852
01:13:21,020 --> 01:13:23,890
それに関連して（笑）レッツエンド。

1853
01:13:23,890 --> 01:13:25,750
そして、我々は月曜日にお会いしましょう​​。

1854
01:13:25,750 --> 01:13:31,629
[拍手]