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