1
00:00:00,000 --> 00:00:03,290
>> [音樂播放]

2
00:00:03,290 --> 00:00:04,989

3
00:00:04,989 --> 00:00:06,280
傑森赫塞豪恩：好，大家好。

4
00:00:06,280 --> 00:00:07,460
歡迎來到科。

5
00:00:07,460 --> 00:00:10,840
這是CS50，我們非常
首超一節。

6
00:00:10,840 --> 00:00:13,700
大家都知道，下週
規則部分將啟動，

7
00:00:13,700 --> 00:00:15,580
但本週我們都在一起。

8
00:00:15,580 --> 00:00:17,730
>> 還有就是我自己。

9
00:00:17,730 --> 00:00:18,840
我的名字是賈森。

10
00:00:18,840 --> 00:00:20,630
我在計算機科學系講師。

11
00:00:20,630 --> 00:00:23,910
我們有安迪，誰是CS50的頭TA。

12
00:00:23,910 --> 00:00:27,630
而Scaz，布萊恩Scassellati教授，
他在計算機科學教授。

13
00:00:27,630 --> 00:00:30,970
>> 我們是在耶魯大學的CS50頭。

14
00:00:30,970 --> 00:00:34,992
您可以隨時發送電子郵件
我們heads@cs50.yale.edu。

15
00:00:34,992 --> 00:00:35,950
我們將在講座。

16
00:00:35,950 --> 00:00:37,547
我們會在辦公時間。

17
00:00:37,547 --> 00:00:40,130
如果有過什麼我們可以
為你做，你需要什麼，

18
00:00:40,130 --> 00:00:42,610
隨時接觸到我們。

19
00:00:42,610 --> 00:00:44,140
>> 那麼，我們今天要做？

20
00:00:44,140 --> 00:00:47,790
或者在此之前，有什麼
來了這個星期？

21
00:00:47,790 --> 00:00:52,620
因此，辦公時間是週一，週二，
星期三和星期四，上午8:00至11:00。

22
00:00:52,620 --> 00:00:54,770
還有的網站上日程。

23
00:00:54,770 --> 00:00:57,830
>> 節，就像我提到的，
在下週開始。

24
00:00:57,830 --> 00:01:01,390
而且你會發現這個星期什麼
計時您的部分是，今天是什麼日子，

25
00:01:01,390 --> 00:01:03,350
和你的TA是誰。

26
00:01:03,350 --> 00:01:08,610
>> 問題1在週四是由於在
中午，週五中午至深夜的一天。

27
00:01:08,610 --> 00:01:10,817
是的，你有九晚了幾天。

28
00:01:10,817 --> 00:01:12,150
而且有九個問題集。

29
00:01:12,150 --> 00:01:14,320
而且只能使用一個
每道題集下旬的一天。

30
00:01:14,320 --> 00:01:17,930
是的，實際上，所有的問題
集將於週五中午。

31
00:01:17,930 --> 00:01:18,550
這是所有。

32
00:01:18,550 --> 00:01:20,400
所有的細節都在教學大綱。

33
00:01:20,400 --> 00:01:22,360
>> 每個星期五，我們的午餐。

34
00:01:22,360 --> 00:01:25,230
我們想使這個大
當然感覺有點小。

35
00:01:25,230 --> 00:01:26,580
所以，歡迎您RSVP。

36
00:01:26,580 --> 00:01:30,050
免費的午餐與其他
同學們和工作人員。

37
00:01:30,050 --> 00:01:34,120
cs50.yale.edu/rsvp。

38
00:01:34,120 --> 00:01:36,940
>> 所有這些事情，
我在屏幕上，

39
00:01:36,940 --> 00:01:43,330
多，你可以找到cs50.yale.edu或
cs50.harvard.edu，如果你去哈佛

40
00:01:43,330 --> 00:01:46,800
而在看這個網上。

41
00:01:46,800 --> 00:01:50,240
>> 同時在這些網站上，有
一噸為你的資源。

42
00:01:50,240 --> 00:01:54,610
每個講座不僅具有視頻
講座，但也注意到。

43
00:01:54,610 --> 00:01:58,184
有人將觀看
講課和做筆記給你。

44
00:01:58,184 --> 00:02:00,100
所以，你可以只支付
在講座的關注，

45
00:02:00,100 --> 00:02:03,970
或者您可以使用他們的筆記/我們
筆記來補充自己的筆記。

46
00:02:03,970 --> 00:02:04,987
>> 有網上的幻燈片。

47
00:02:04,987 --> 00:02:07,320
源代碼 - 一切
大衛都要通過講座，

48
00:02:07,320 --> 00:02:09,979
或Scaz都要通過講座，這
源代碼可在網上

49
00:02:09,979 --> 00:02:11,750
還有，像我，提到影片。

50
00:02:11,750 --> 00:02:14,257
>> 部分，同樣地，都將被拍攝下來。

51
00:02:14,257 --> 00:02:15,840
所有這些幻​​燈片將可用。

52
00:02:15,840 --> 00:02:18,190
所有這些代碼將
可為您服務。

53
00:02:18,190 --> 00:02:22,440
還有的網站，短褲
CS50的工作人員花費5到10

54
00:02:22,440 --> 00:02:24,130
分鐘經歷的主題為您服務。

55
00:02:24,130 --> 00:02:26,750
其中一些人已經過
在習題中遇到。

56
00:02:26,750 --> 00:02:30,430
>> 辦公時間，正如我所說，星期一
至週四，8：00至11:00。

57
00:02:30,430 --> 00:02:32,600
CS50研究是一個奇妙的資源。

58
00:02:32,600 --> 00:02:37,100
有實際問題，
樣本幻燈片，已知錯誤

59
00:02:37,100 --> 00:02:40,920
學生喜歡碰到，
基本上對每一個主題中，我們

60
00:02:40,920 --> 00:02:42,650
將覆蓋在這個過程中。

61
00:02:42,650 --> 00:02:46,350
>> 最後，在這張幻燈片
至少，Reference50

62
00:02:46,350 --> 00:02:49,690
它給你的信息
在所有的C函數

63
00:02:49,690 --> 00:02:53,160
你所能可能希望
使用和許多，許多。

64
00:02:53,160 --> 00:02:55,690
>> 再次，點點點的
在屏幕的底部

65
00:02:55,690 --> 00:02:59,990
是表明甚至還有
在這兩個網站上更多的資源：

66
00:02:59,990 --> 00:03:04,270
cs50.yale.edu，cs50.harvard.edu。

67
00:03:04,270 --> 00:03:05,840
>> 那麼，我們今天做什麼？

68
00:03:05,840 --> 00:03:08,970
首先，我想給
你的資源。

69
00:03:08,970 --> 00:03:10,010
已經做了一個。

70
00:03:10,010 --> 00:03:11,590
看看我們。

71
00:03:11,590 --> 00:03:16,430
>> 現在，我們要投奔
數據類型和運營商C.

72
00:03:16,430 --> 00:03:19,990
然後安迪會在這裡和
在C中去了圖書館，printf（）的，

73
00:03:19,990 --> 00:03:24,570
一個函數，你已經
熟悉或將很快成為非常

74
00:03:24,570 --> 00:03:25,530
熟悉。

75
00:03:25,530 --> 00:03:27,810
而且你還可以去了
條件和循環。

76
00:03:27,810 --> 00:03:30,900
>> 然後最後，Scaz
會在CS50 ID。

77
00:03:30,900 --> 00:03:34,250
如果你還沒有鴿子在
已經在習題集1，

78
00:03:34,250 --> 00:03:37,060
以及如何使用
終端和有用的命令

79
00:03:37,060 --> 00:03:42,280
然後給你一些演示和
實踐編碼在CS50 ID。

80
00:03:42,280 --> 00:03:45,130
>> 以前我跳這個
在這一側的內容，

81
00:03:45,130 --> 00:03:46,770
沒有任何人有任何問題這麼遠嗎？

82
00:03:46,770 --> 00:03:53,190

83
00:03:53,190 --> 00:03:54,030
太好了。

84
00:03:54,030 --> 00:03:54,950
確定。

85
00:03:54,950 --> 00:03:55,810
更換齒輪。

86
00:03:55,810 --> 00:03:58,760
>> [換檔]

87
00:03:58,760 --> 00:04:03,070
>> 那是我移
齒輪在手動汽車。

88
00:04:03,070 --> 00:04:10,920
因此，在C數據類型，你不能只是有
一個變量x，並將它是在第10行，

89
00:04:10,920 --> 00:04:17,170
的整數，說不定數字1，
第20行，一個十進制數10.5，

90
00:04:17,170 --> 00:04:20,500
然後一對夫婦行
後來一個字符串，我愛CS50。

91
00:04:20,500 --> 00:04:25,052
>> 在C語言中，變量只能是
一件事，只有一件事。

92
00:04:25,052 --> 00:04:26,510
所以你必須給他們的類型。

93
00:04:26,510 --> 00:04:28,780
而在此板上，我們
有類型的列表。

94
00:04:28,780 --> 00:04:32,000
有字符，這
代表角色。

95
00:04:32,000 --> 00:04:36,850
所以這是一個字母A，B，C，
D.這也可以是一個空間，

96
00:04:36,850 --> 00:04:40,290
或者也可以是
新行字符。

97
00:04:40,290 --> 00:04:45,030
>> 有整數，這只是
數字，全numbers--或整數

98
00:04:45,030 --> 00:04:47,130
rather--但沒有小數。

99
00:04:47,130 --> 00:04:49,790
>> 對於小數，我們有
浮點數。

100
00:04:49,790 --> 00:04:53,200
浮點數
與小數的數字。

101
00:04:53,200 --> 00:04:58,160
>> 再就是多頭頭寸，這是
本質上較長的整數。

102
00:04:58,160 --> 00:05:01,160
你會發現，長
是8，而一個int是4。

103
00:05:01,160 --> 00:05:02,640
我會得到，在第二。

104
00:05:02,640 --> 00:05:07,390
這是因為多頭可以存儲連
比int多個整數可以存儲。

105
00:05:07,390 --> 00:05:10,100
雙是一個長期的浮動。

106
00:05:10,100 --> 00:05:12,460
>> 最後，我們有
串，其是一種類型的

107
00:05:12,460 --> 00:05:14,430
你可能已經使用過。

108
00:05:14,430 --> 00:05:21,100
如果包括包括hashtag
＃includeCS50.h在源文件中，

109
00:05:21,100 --> 00:05:23,170
那麼你可以使用一個字符串類型。

110
00:05:23,170 --> 00:05:25,560
它實際上沒有內置到C.

111
00:05:25,560 --> 00:05:27,760
>> 有一對夫婦的其他類型也是如此。

112
00:05:27,760 --> 00:05:32,900
但這些都是與校長的人
您將使用和遇到的問題。

113
00:05:32,900 --> 00:05:36,210
c以，我又提到，
每一個變量 - 它

114
00:05:36,210 --> 00:05:38,620
只能是一種類型的且只有一個類型。

115
00:05:38,620 --> 00:05:42,890
這是因為C是一種靜態
類型化的語言，而不是

116
00:05:42,890 --> 00:05:45,780
動態類型語言
如果你創建一個變量在哪裡

117
00:05:45,780 --> 00:05:50,081
你可以改變什麼是存儲在
它在程序中去。

118
00:05:50,081 --> 00:05:52,580
在這裡的右手
一邊，我有不同的尺寸

119
00:05:52,580 --> 00:05:57,440
這些類型的字節的數據。

120
00:05:57,440 --> 00:05:59,710
這樣一個字符是1個字節。

121
00:05:59,710 --> 00:06:01,250
這是8位。

122
00:06:01,250 --> 00:06:05,530
這意味著，因為8
位有八個0和1。

123
00:06:05,530 --> 00:06:08,280
我們看到這些演示在第一
週與二進制燈泡。

124
00:06:08,280 --> 00:06:15,680
>> 隨著8位或1個字節，我們可以
表示數字從0到255。

125
00:06:15,680 --> 00:06:16,180
右。

126
00:06:16,180 --> 00:06:18,770
如果所有8位均為0這是0。

127
00:06:18,770 --> 00:06:23,640
如果第一位是1，這是數
1，等等，所有一直到255。

128
00:06:23,640 --> 00:06:28,290
這就是為什麼對於字符可以
有本質上最多255，

129
00:06:28,290 --> 00:06:31,210
但是這足夠覆蓋所有
字符我們需要使用。

130
00:06:31,210 --> 00:06:38,060
>> 對於整數，你可以0，
那麼你有2到32減1。

131
00:06:38,060 --> 00:06:40,340
這些都是多少選擇
你有整數。

132
00:06:40,340 --> 00:06:44,780
>> 長期以來，你有0
到2〜64減1。

133
00:06:44,780 --> 00:06:48,860
所以，你有很多很多，
更多的選擇，為多頭。

134
00:06:48,860 --> 00:06:54,220
>> 字符串，這是一個問號
因為這是一個懸念以後。

135
00:06:54,220 --> 00:06:55,000
是啊。

136
00:06:55,000 --> 00:06:56,350
我可以告訴大家的
在他們的座位邊，

137
00:06:56,350 --> 00:06:57,450
就像那是什麼問號？

138
00:06:57,450 --> 00:06:58,390
這是一個懸念。

139
00:06:58,390 --> 00:07:02,340
我們將最終覆蓋的大小
字符串和多談談字符串。

140
00:07:02,340 --> 00:07:04,692
因為字符串其實是
培訓車輪之一

141
00:07:04,692 --> 00:07:06,400
我們在這個帶上
當然，在開始

142
00:07:06,400 --> 00:07:09,700
再起飛後
對，因為在C字符串

143
00:07:09,700 --> 00:07:13,320
實際上指針
字符數組。

144
00:07:13,320 --> 00:07:15,810
但同樣，這是一個
扣人心弦以後。

145
00:07:15,810 --> 00:07:18,890
在我繼續前進的任何問題，
評論，這個幻燈片的擔憂？

146
00:07:18,890 --> 00:07:25,800

147
00:07:25,800 --> 00:07:26,630
>> 確定。

148
00:07:26,630 --> 00:07:30,330
我一定是一個夢幻般的講解員。

149
00:07:30,330 --> 00:07:33,210
此外，當你在編程，
你要使用這些運算符。

150
00:07:33,210 --> 00:07:36,730
很簡單的標誌，可以做簡單的
操作，與你可能

151
00:07:36,730 --> 00:07:38,340
已經很熟悉了。

152
00:07:38,340 --> 00:07:42,580
>> 例如，在右側
右手邊，我們看到的補充。

153
00:07:42,580 --> 00:07:44,640
要添加，你只是做一個加號。

154
00:07:44,640 --> 00:07:46,850
所以，你可能有
兩個變量x和y。

155
00:07:46,850 --> 00:07:48,810
你可以在你的代碼做X + Y。

156
00:07:48,810 --> 00:07:52,790
也許你想用於：說你
有7號和3，

157
00:07:52,790 --> 00:07:55,780
你想存儲
在一個變量中稱為總和。

158
00:07:55,780 --> 00:08:03,010
你可以做INT的類型，空間
總和，所述變量的名字，= 7 + 3;

159
00:08:03,010 --> 00:08:05,780
>> 那能店總和？

160
00:08:05,780 --> 00:08:07,190
有人嗎？

161
00:08:07,190 --> 00:08:09,270
如果我在總和= 7 + 3。

162
00:08:09,270 --> 00:08:10,437
什麼將存儲在總和？

163
00:08:10,437 --> 00:08:11,520
你可以只喊出來。

164
00:08:11,520 --> 00:08:12,120
聽眾：10。

165
00:08:12,120 --> 00:08:12,995
>> 傑森赫塞豪恩：10！

166
00:08:12,995 --> 00:08:14,870
這是完全正確的。

167
00:08:14,870 --> 00:08:19,520
怎麼樣的總和= 7  -  3，
我只是用了幾許的跡象。

168
00:08:19,520 --> 00:08:20,871
這是怎麼回事存儲？

169
00:08:20,871 --> 00:08:21,370
聽眾：4。

170
00:08:21,370 --> 00:08:22,203
傑森赫塞豪恩：4。

171
00:08:22,203 --> 00:08:25,770
總和可能是錯誤的名字
該變量，但4將被存儲。

172
00:08:25,770 --> 00:08:31,890
>> 為了繁衍C，使用小
明星的性格，你不使用X。

173
00:08:31,890 --> 00:08:35,990
來劃分，使用前向
斜線而不是分裂的象徵。

174
00:08:35,990 --> 00:08:39,580
而對於模，使用百分比符號。

175
00:08:39,580 --> 00:08:47,900
>> 所以我們可以說我想看看INT Z =
7％3，什麼將被存儲在Z'

176
00:08:47,900 --> 00:08:51,250
所以，這是本質
問是什麼模辦？

177
00:08:51,250 --> 00:08:52,750
有誰知道什麼模呢？

178
00:08:52,750 --> 00:08:53,940
是啊。

179
00:08:53,940 --> 00:08:54,870
Y 4。

180
00:08:54,870 --> 00:08:56,120
揚聲器1：這是餘數。

181
00:08:56,120 --> 00:08:58,369
傑森赫塞豪恩：它是
其餘的，當你劃分。

182
00:08:58,369 --> 00:09:02,790
所以7除以3餘數2 1。

183
00:09:02,790 --> 00:09:04,690
所以1將存儲。

184
00:09:04,690 --> 00:09:06,970
>> 你做減法，
但它是如何工作。

185
00:09:06,970 --> 00:09:09,140
這就是模運算符一樣。

186
00:09:09,140 --> 00:09:12,360
它需要通過一些它除以
其他號碼，並返回到你

187
00:09:12,360 --> 00:09:14,590
餘數。

188
00:09:14,590 --> 00:09:19,770
如此反复，7％，3為您提供了1，因為
7 3 2 1餘分，

189
00:09:19,770 --> 00:09:21,650
和返回餘。

190
00:09:21,650 --> 00:09:24,470
>> 那麼，讓我們回到了
一步到位的除號。

191
00:09:24,470 --> 00:09:29,194
如果我做了7 /除以3不
任何人都知道這是什麼會回來？

192
00:09:29,194 --> 00:09:30,090
>> 揚聲器2：2。

193
00:09:30,090 --> 00:09:32,240
>> 傑森赫塞豪恩：為什麼2，而不是2.333？

194
00:09:32,240 --> 00:09:34,560
>> 揚聲器2：我覺得它削減
關閉整數之後。

195
00:09:34,560 --> 00:09:36,310
傑森赫塞豪恩：所以
這是完全正確的。

196
00:09:36,310 --> 00:09:39,880
在C語言中，如果你做了分工
兩個整數7除以3，

197
00:09:39,880 --> 00:09:43,430
它得到了答案，
在這種情況下，2.3333永遠

198
00:09:43,430 --> 00:09:47,080
它認為，小數點和
小數點後挑起大樑事事休

199
00:09:47,080 --> 00:09:49,240
它只是返回2。

200
00:09:49,240 --> 00:09:51,120
>> 所以，如果我做了8除以3。

201
00:09:51,120 --> 00:09:54,010
實際上，我們知道
這回2.666，

202
00:09:54,010 --> 00:09:57,050
但在扒事事休
十進制，截斷了這一切，

203
00:09:57,050 --> 00:09:58,640
而剛剛返回給你2。

204
00:09:58,640 --> 00:10:02,090
因此，6除以3，7分
3，8除以3，

205
00:10:02,090 --> 00:10:04,840
都將回報給你2。

206
00:10:04,840 --> 00:10:08,770
>> 任何人都不會知道，或者有一個猜測，
至於我怎麼能真正得到

207
00:10:08,770 --> 00:10:10,790
完整的答案，如果我想要那個小數點？

208
00:10:10,790 --> 00:10:13,120

209
00:10:13,120 --> 00:10:13,620
是啊。

210
00:10:13,620 --> 00:10:14,152
來吧。

211
00:10:14,152 --> 00:10:15,110
揚聲器3：使用浮動？

212
00:10:15,110 --> 00:10:16,942
傑森赫塞豪恩：你是什麼意思？

213
00:10:16,942 --> 00:10:19,786
揚聲器3：因為你說的
浮動是數字[聽不清]

214
00:10:19,786 --> 00:10:22,900

215
00:10:22,900 --> 00:10:23,900
傑森赫塞豪恩：對。

216
00:10:23,900 --> 00:10:26,100
所以，這是完全正確的。

217
00:10:26,100 --> 00:10:28,440
圖7是一個整數。

218
00:10:28,440 --> 00:10:31,690
但是，如果我想反過來說
成浮點數，

219
00:10:31,690 --> 00:10:34,674
我將不得不存儲
作為7.0，因為計算機

220
00:10:34,674 --> 00:10:37,090
真是stupid--我們看到，
用PB和J example--

221
00:10:37,090 --> 00:10:38,930
它只會做完全
你告訴它。

222
00:10:38,930 --> 00:10:40,846
>> 所以，如果你寫的7，它
認為這是一個整數。

223
00:10:40,846 --> 00:10:43,640
如果你寫7.0，即使我們
知道那些東西是相同的，

224
00:10:43,640 --> 00:10:45,550
它把那像
浮點數。

225
00:10:45,550 --> 00:10:50,441
所以，如果你沒有7.0分
3，或除以3.0，

226
00:10:50,441 --> 00:10:52,440
它會說，好了，現在
我們正在處理的花車。

227
00:10:52,440 --> 00:10:57,514
我會回報給你2.333333永遠。

228
00:10:57,514 --> 00:10:59,930
但不是真的永遠，因為
因為我們也看到在講座中，

229
00:10:59,930 --> 00:11:03,350
這些浮點數
並不完全精確。

230
00:11:03,350 --> 00:11:05,940
>> 所以，如果你想要的小數，
或小數的一部分，

231
00:11:05,940 --> 00:11:08,090
那麼你必須use--其中之一
必須是一個浮點數

232
00:11:08,090 --> 00:11:11,048
和計算機必須了解
這是一個浮點你

233
00:11:11,048 --> 00:11:13,350
處理，而不是一個整數。

234
00:11:13,350 --> 00:11:16,760
在該表上的任何問題
右手側，到目前為止？

235
00:11:16,760 --> 00:11:22,650
或者你的左邊，你的
離開了，你的左手邊。

236
00:11:22,650 --> 00:11:23,264
是啊。

237
00:11:23,264 --> 00:11:23,972
揚聲器4：對。

238
00:11:23,972 --> 00:11:26,216
對於就像一個普通的
整數，你會

239
00:11:26,216 --> 00:11:30,230
寫 - 將你寫浮動？

240
00:11:30,230 --> 00:11:31,920
>> 傑森赫塞豪恩：是這樣。

241
00:11:31,920 --> 00:11:34,400
好吧，如果你想創建
一個變量，它是一個浮動，

242
00:11:34,400 --> 00:11:37,020
你需要說浮法
z等於什麼。

243
00:11:37,020 --> 00:11:37,640
>> 揚聲器4：確定。

244
00:11:37,640 --> 00:11:41,950
>> 傑森赫塞豪恩：但是，如果我想
做7除以3，並獲得了小數，

245
00:11:41,950 --> 00:11:48,540
我會做浮動Z = 7.0 / 3.0;和
這會給我的浮點

246
00:11:48,540 --> 00:11:49,273
號。

247
00:11:49,273 --> 00:11:50,000
>> 揚聲器4：確定。

248
00:11:50,000 --> 00:11:56,370
>> 傑森赫塞豪恩：如果我這樣做
像INT Z = 7/3，

249
00:11:56,370 --> 00:12:00,856
這會給我一個整數，
因為這些都是整數。

250
00:12:00,856 --> 00:12:01,730
這是否有意義？

251
00:12:01,730 --> 00:12:02,320
>> 揚聲器4：是的。

252
00:12:02,320 --> 00:12:02,950
>> 傑森赫塞豪恩：OK。

253
00:12:02,950 --> 00:12:03,450
太好了。

254
00:12:03,450 --> 00:12:06,030
有關該表的任何其他問題？

255
00:12:06,030 --> 00:12:07,220
真的嗎？

256
00:12:07,220 --> 00:12:08,380
我很興奮。

257
00:12:08,380 --> 00:12:09,120
確定。

258
00:12:09,120 --> 00:12:13,910
>> 所以，你會使用一些其他的東西，
經常在條件或循環，

259
00:12:13,910 --> 00:12:17,580
是這些類型的operators--
這些類型的布爾表達式。

260
00:12:17,580 --> 00:12:23,140
當我們了解到，==就是你
用它來檢查，如果兩件事情都是平等的。

261
00:12:23,140 --> 00:12:28,170
>> 所以在這裡我檢查如果x == Y，讓我們
再次假設x是7和y為3。

262
00:12:28,170 --> 00:12:33,220
所以，如果我寫了7 == 3，什麼
將返回給我嗎？

263
00:12:33,220 --> 00:12:34,220
這是真的還是假的？

264
00:12:34,220 --> 00:12:35,275
>> 聽眾：假。

265
00:12:35,275 --> 00:12:36,150
傑森赫塞豪恩：OK。

266
00:12:36,150 --> 00:12:37,370
我覺得每個人都可以得到這一個。

267
00:12:37,370 --> 00:12:39,054
所以每個人，那能回來嗎？

268
00:12:39,054 --> 00:12:39,720
聽眾：假。

269
00:12:39,720 --> 00:12:40,130
傑森赫塞豪恩：假。

270
00:12:40,130 --> 00:12:40,850
太好了。

271
00:12:40,850 --> 00:12:41,930
7不等於3。

272
00:12:41,930 --> 00:12:44,530
因此，7 == 3將返回false。

273
00:12:44,530 --> 00:12:50,746
你有沒有等號，所以如果我
被查7！= 3，那能回來嗎？

274
00:12:50,746 --> 00:12:51,370
聽眾：真。

275
00:12:51,370 --> 00:12:52,650
傑森赫塞豪恩：真。

276
00:12:52,650 --> 00:12:53,200
優秀的。

277
00:12:53,200 --> 00:12:55,990
有人很言之鑿鑿
背部和理解。

278
00:12:55,990 --> 00:12:59,070
然後，你必須小於運算符，
小於或等於操作員，

279
00:12:59,070 --> 00:13:01,990
大於運算，更大
於或等於操作員。

280
00:13:01,990 --> 00:13:03,490
>> 因此，人們更全面的檢查。

281
00:13:03,490 --> 00:13:05,660
如果我有7大
大於或等於3。

282
00:13:05,660 --> 00:13:06,966
那能回來嗎？

283
00:13:06,966 --> 00:13:07,692
>> 聽眾：真。

284
00:13:07,692 --> 00:13:08,650
傑森赫塞豪恩：真。

285
00:13:08,650 --> 00:13:10,050
是。

286
00:13:10,050 --> 00:13:13,290
這回房，背面
房間的，夢幻般的。

287
00:13:13,290 --> 00:13:16,240
您可以將這些
表達式如果你喜歡，還有，

288
00:13:16,240 --> 00:13:21,880
帶有邏輯AND這是
&&或邏輯OR這是||

289
00:13:21,880 --> 00:13:22,800
||。

290
00:13:22,800 --> 00:13:25,785
所以現在你可以測試兩個
事情together--是不是可笑嗎？

291
00:13:25,785 --> 00:13:28,250
這是為什麼笑？

292
00:13:28,250 --> 00:13:35,200
>> 所以，如果我想，我能說的是7
大於3與2小於4？

293
00:13:35,200 --> 00:13:37,090
好吧，如果7大
比3，這是事實。

294
00:13:37,090 --> 00:13:38,400
2小於4，這是事實。

295
00:13:38,400 --> 00:13:41,140
所以，這整個事情將返回true。

296
00:13:41,140 --> 00:13:45,130
>> 如果我測試了7比3和 - 
我只是挑選隨機數這裡 - 

297
00:13:45,130 --> 00:13:47,340
4小於2，好，這是假的。

298
00:13:47,340 --> 00:13:49,610
所以真假作出虛假。

299
00:13:49,610 --> 00:13:54,520
你可以去和你結合的
很多條件在一起，你想。

300
00:13:54,520 --> 00:14:00,000
>> 沒有任何人有任何問題，
評論，關注這麼遠嗎？

301
00:14:00,000 --> 00:14:03,862
而且我看你拍照的一些
在屏幕上，這是我感激我。

302
00:14:03,862 --> 00:14:05,070
但願，這不是Snapchat。

303
00:14:05,070 --> 00:14:06,417
我們希望，這對你的筆記。

304
00:14:06,417 --> 00:14:08,500
但所有這些都將
要在網上提供。

305
00:14:08,500 --> 00:14:11,210
所以，你不必
利用這一圖像。

306
00:14:11,210 --> 00:14:15,150
就像我提到的，應有盡有
會為你在網上提供。

307
00:14:15,150 --> 00:14:15,650
確定。

308
00:14:15,650 --> 00:14:17,980
我即將得到
台下，所以是否有人

309
00:14:17,980 --> 00:14:20,350
不想多說什麼
在此之前，會發生什麼？

310
00:14:20,350 --> 00:14:21,080
有問題嗎？

311
00:14:21,080 --> 00:14:21,680
>> [插入VOICES]

312
00:14:21,680 --> 00:14:22,250
>> 傑森赫塞豪恩：哦，停下來。

313
00:14:22,250 --> 00:14:23,290
你們是太好。

314
00:14:23,290 --> 00:14:23,790
確定。

315
00:14:23,790 --> 00:14:26,520
我要掛牌。

316
00:14:26,520 --> 00:14:27,240
讓我們去。

317
00:14:27,240 --> 00:14:29,570
>> ANDI彭：我們要做的
現在是一個尷尬的MIC變化。

318
00:14:29,570 --> 00:14:32,280
>> 傑森赫塞豪恩：我
要採取這一關。

319
00:14:32,280 --> 00:14:33,946
ANDI彭：欣賞支持，伙計們。

320
00:14:33,946 --> 00:14:42,250

321
00:14:42,250 --> 00:14:43,180
你能聽到我嗎？

322
00:14:43,180 --> 00:14:43,930
好了嗎？

323
00:14:43,930 --> 00:14:44,760
完善。

324
00:14:44,760 --> 00:14:45,630
美麗。

325
00:14:45,630 --> 00:14:47,490
讓我掖了研究。

326
00:14:47,490 --> 00:14:49,100
確定。

327
00:14:49,100 --> 00:14:54,140
所以，我要做到像一個巨大的
信息傾倒在你們現在。

328
00:14:54,140 --> 00:14:57,370
而且沒有任何後顧之憂，如果你
不繼的每一個小線是什麼

329
00:14:57,370 --> 00:14:58,812
我要告訴你。

330
00:14:58,812 --> 00:15:00,770
正如傑森說，一切
完全聯機。

331
00:15:00,770 --> 00:15:03,780
只要我們將嘗試引進
大家的概念覆蓋

332
00:15:03,780 --> 00:15:05,270
在一些幻燈片。

333
00:15:05,270 --> 00:15:06,582
所以只要跟著。

334
00:15:06,582 --> 00:15:09,540
不，如果你不明白的憂慮
一切;然而，如果在任何點

335
00:15:09,540 --> 00:15:12,820
你覺得失落，提高你的
另一方面，我們就會停止，無後​​顧之憂。

336
00:15:12,820 --> 00:15:15,060
酷。

337
00:15:15,060 --> 00:15:19,270
>> 所以，我認為有些事情，大衛有
已經種提到講座

338
00:15:19,270 --> 00:15:23,240
那種和賈森已經暗示
今天是一個圖書館。

339
00:15:23,240 --> 00:15:27,510
因此在編程時，我們有
這些東西叫做庫。

340
00:15:27,510 --> 00:15:29,690
其中，從本質上講，所有的
他們只是一組

341
00:15:29,690 --> 00:15:32,610
的功能，即
本質上只是代碼的

342
00:15:32,610 --> 00:15:35,070
已經被寫入由
別人說我們都可以

343
00:15:35,070 --> 00:15:36,410
我們的程序中使用。

344
00:15:36,410 --> 00:15:38,790
>> 那麼，如何正常
圖書館的工作，對不對？

345
00:15:38,790 --> 00:15:40,030
你進入圖書館的門。

346
00:15:40,030 --> 00:15:41,890
你把所有這些
書籍可以拉出來

347
00:15:41,890 --> 00:15:44,590
您可以訪問信息
在那些書。

348
00:15:44,590 --> 00:15:45,840
同樣的事情在編程。

349
00:15:45,840 --> 00:15:48,820
>> 你有一個已經庫
寫了由其他人。

350
00:15:48,820 --> 00:15:51,530
而這樣就可以了，
作為程序員或學生，

351
00:15:51,530 --> 00:15:55,780
可以訪問該庫
通過包括hashtag的#include。

352
00:15:55,780 --> 00:15:59,720
>> 例如，在C我們
有三個C--最

353
00:15:59,720 --> 00:16:03,420
常用的三C標準
libraries--輸入/輸出庫，

354
00:16:03,420 --> 00:16:05,540
串庫，
和數學庫。

355
00:16:05,540 --> 00:16:07,610
>> 所以，在你的第一個
夫婦習題集，

356
00:16:07,610 --> 00:16:10,940
那些將三個
那你主要使用。

357
00:16:10,940 --> 00:16:14,610
因此，大衛已經
講座中解釋說，

358
00:16:14,610 --> 00:16:17,460
標準I / O庫，或
標準輸入/輸出庫

359
00:16:17,460 --> 00:16:18,620
正是這麼做的。

360
00:16:18,620 --> 00:16:23,530
它可以讓你在你的代碼，輸入
從用戶和輸出任何

361
00:16:23,530 --> 00:16:25,960
到屏幕上，基本上
它打印到屏幕上。

362
00:16:25,960 --> 00:16:29,990
>> 所以，任何時候你使用任何功能，
例如函數printf（），其

363
00:16:29,990 --> 00:16:33,319
我們要投奔的下一張幻燈片，
一定要包括標準I / O

364
00:16:33,319 --> 00:16:36,360
庫要不然你不會
能夠使用的printf（）函數。

365
00:16:36,360 --> 00:16:39,110
因為你作為程序員
從來沒有真正寫到功能，

366
00:16:39,110 --> 00:16:41,840
你只是冒用
在你自己的代碼別人的代碼。

367
00:16:41,840 --> 00:16:43,620
>> 這是否有意義的人呢？

368
00:16:43,620 --> 00:16:44,520
酷。

369
00:16:44,520 --> 00:16:48,530
>> 然後，我們基本上是沾到
該文件string.h庫和文件math.h

370
00:16:48,530 --> 00:16:52,970
圖書館，.H只是表示庫，
其他圖書館，你最終會

371
00:16:52,970 --> 00:16:55,310
是你的代碼中使用。

372
00:16:55,310 --> 00:16:57,620
>> 然而，為了
這個庫，我們也

373
00:16:57,620 --> 00:17:01,170
這個分類 - 我們也有have--
什麼是所謂的CS50庫，

374
00:17:01,170 --> 00:17:05,270
cs50.h，我們在那裡，為
你細讀創造

375
00:17:05,270 --> 00:17:07,369
許多重要和有用的功能。

376
00:17:07,369 --> 00:17:09,550
所以，你作為一個程序員
可以捎帶關閉

377
00:17:09,550 --> 00:17:14,470
我們已經寫了這樣
這一功能的提供給你

378
00:17:14,470 --> 00:17:15,599
供您使用。

379
00:17:15,599 --> 00:17:18,359
>> 我將涵蓋幾個
功能常用

380
00:17:18,359 --> 00:17:20,839
但要知道，這些都是
所有googleable在線。

381
00:17:20,839 --> 00:17:24,904
隨意，拉起CS50庫和
然後你把所有的功能出現。

382
00:17:24,904 --> 00:17:25,828
是啊。

383
00:17:25,828 --> 00:17:28,140
>> 揚聲器5：所以，如果你不
使用該軟件

384
00:17:28,140 --> 00:17:29,916
提供給我們，
類，這是否

385
00:17:29,916 --> 00:17:32,698
意味著我們不得不下載並找到
這個頭文件自己，並告訴

386
00:17:32,698 --> 00:17:33,840
它是計算機？

387
00:17:33,840 --> 00:17:34,320
>> ANDI彭：大的問題。

388
00:17:34,320 --> 00:17:34,820
沒錯。

389
00:17:34,820 --> 00:17:38,194
因此，這就像如果你不
在圖書館實際存在的，

390
00:17:38,194 --> 00:17:40,360
有沒有辦法為你
其實去訪問它。

391
00:17:40,360 --> 00:17:42,589
因此，同樣的事情
在C，你的編程

392
00:17:42,589 --> 00:17:45,880
要確保你使用的是我們的
家電，因為圖書館已經

393
00:17:45,880 --> 00:17:47,270
被納入進去。

394
00:17:47,270 --> 00:17:50,020
然後當你的hashtag
＃包括，圖書館的存在。

395
00:17:50,020 --> 00:17:50,520
是啊。

396
00:17:50,520 --> 00:17:51,920
好問題。

397
00:17:51,920 --> 00:17:53,461
每個人都好？

398
00:17:53,461 --> 00:17:53,960
酷。

399
00:17:53,960 --> 00:17:56,371

400
00:17:56,371 --> 00:17:56,870
好的。

401
00:17:56,870 --> 00:17:59,330
因此，我們會打，
本質上，是什麼

402
00:17:59,330 --> 00:18:01,620
所述第一函數
我們作為程序員

403
00:18:01,620 --> 00:18:03,900
將被我們的代碼中使用。

404
00:18:03,900 --> 00:18:05,690
這就是所謂的printf（）函數。

405
00:18:05,690 --> 00:18:08,450
因此，printf（）函數，因為我
已經在最後一張幻燈片說，

406
00:18:08,450 --> 00:18:11,830
包括在標準I / O，
標準輸入/輸出庫。

407
00:18:11,830 --> 00:18:16,470
>> 所以一定要確保無論你using--
哦，讓我搶激光pointer--

408
00:18:16,470 --> 00:18:18,660
每當你使用
在printf（）函數，

409
00:18:18,660 --> 00:18:21,790
你必須包括標準I / O
庫否則，當你編譯，

410
00:18:21,790 --> 00:18:23,760
你會得到一個錯誤
因為電腦會像，

411
00:18:23,760 --> 00:18:26,140
哦，我不知道在哪裡的printf（）是，
你不告訴我在哪裡的printf（）

412
00:18:26,140 --> 00:18:26,830
是。

413
00:18:26,830 --> 00:18:30,150
井的printf（）被包括在
標準I / O，所以當你用printf（）

414
00:18:30,150 --> 00:18:32,960
確保有
上面一行代碼。

415
00:18:32,960 --> 00:18:36,040
>> 因此，例如，printf（）的
這裡是一個函數。

416
00:18:36,040 --> 00:18:40,260
它所做的就是打印出來的東西
內的括號給用戶。

417
00:18:40,260 --> 00:18:44,840
會有人想藉此刺
在這行代碼的權利

418
00:18:44,840 --> 00:18:46,420
這裡是要打印出來？

419
00:18:46,420 --> 00:18:48,730
因此，應答是在屏幕上。

420
00:18:48,730 --> 00:18:50,480
有人嗎？

421
00:18:50,480 --> 00:18:51,380
>> VERDI：底部。

422
00:18:51,380 --> 00:18:53,510
>> ANDI彭：威爾第，你為什麼不走
直截了當地說出了整個語句？

423
00:18:53,510 --> 00:18:55,718
>> VERDI：你好，我的名字是
安迪，我20歲。

424
00:18:55,718 --> 00:18:57,270
ANDI彭：啊，可愛。

425
00:18:57,270 --> 00:19:00,240
因此，在這條線，我們要
打印出來，你好，我的名字叫安迪，

426
00:19:00,240 --> 00:19:04,280
我今年20歲了，這
其實一個真實的陳述。

427
00:19:04,280 --> 00:19:05,090
>> 語法。

428
00:19:05,090 --> 00:19:08,830
於是幾個語法問題的
你們要確保你知道的。

429
00:19:08,830 --> 00:19:09,360
行情。

430
00:19:09,360 --> 00:19:13,170
雙引號告訴
計算機裡面的一切

431
00:19:13,170 --> 00:19:14,850
將要被打印出來。

432
00:19:14,850 --> 00:19:16,620
>> 裡面可以一切
只是究竟如何

433
00:19:16,620 --> 00:19:19,920
您鍵入它，除了
一般在年底，

434
00:19:19,920 --> 00:19:23,610
我們將要包括
一個hash--哦sorry--破折號ñ。

435
00:19:23,610 --> 00:19:24,640
因此，一個破折號ñ。

436
00:19:24,640 --> 00:19:28,884
>> 有沒有人想以此來猜測
什麼，做我們的代碼？

437
00:19:28,884 --> 00:19:29,465
是啊。

438
00:19:29,465 --> 00:19:30,840
揚聲器6：把它放在一個新行。

439
00:19:30,840 --> 00:19:31,650
ANDI鵬：沒錯。

440
00:19:31,650 --> 00:19:34,660
因此，所有這樣做是
讓無論發生什麼事

441
00:19:34,660 --> 00:19:37,520
在此之後，該語句之後，
要打印到一個新行。

442
00:19:37,520 --> 00:19:40,030
所以，當你寫你的
代碼，您不要隨意有事情

443
00:19:40,030 --> 00:19:41,738
上漲到年底
你不想要的。

444
00:19:41,738 --> 00:19:43,700
這一切變得
整齊地打印一行

445
00:19:43,700 --> 00:19:46,870
然後我們開始在下一行。

446
00:19:46,870 --> 00:19:50,970
>> 有誰還記得那是什麼
當我們編碼分號呢？

447
00:19:50,970 --> 00:19:54,580

448
00:19:54,580 --> 00:19:55,330
是啊。

449
00:19:55,330 --> 00:19:55,740
>> 揚聲器7：聲明。

450
00:19:55,740 --> 00:19:56,010
>> ANDI彭：對不起？

451
00:19:56,010 --> 00:19:57,100
>> 揚聲器7：是否結束的聲明？

452
00:19:57,100 --> 00:19:57,766
>> ANDI彭：是的。

453
00:19:57,766 --> 00:20:02,670
因此，在C或任何編程
語言中，分號

454
00:20:02,670 --> 00:20:04,640
表示一編程線的末端。

455
00:20:04,640 --> 00:20:09,240
因此，例如，在英語中，我們使用期限
說，哦，這是結束一個句子。

456
00:20:09,240 --> 00:20:12,857
在編程中，同樣的事情，我們有一個
分號來表示一個行的末尾。

457
00:20:12,857 --> 00:20:14,690
通常情況下，當你
開始編程，

458
00:20:14,690 --> 00:20:17,150
你會發現你
忘了加分號

459
00:20:17,150 --> 00:20:19,400
然後再嘗試運行
代碼和它不工作。

460
00:20:19,400 --> 00:20:21,520
而你喜歡啊，我不知道
知道為什麼，這應該是工作。

461
00:20:21,520 --> 00:20:24,394
>> 有可能到頭來你可能忘了
分號或支架或東西

462
00:20:24,394 --> 00:20:25,020
某個地方。

463
00:20:25,020 --> 00:20:27,740
所以，這是重要的是要記住。

464
00:20:27,740 --> 00:20:29,627
酷。

465
00:20:29,627 --> 00:20:31,960
好吧，舉手，如何
很多人在這裡有過

466
00:20:31,960 --> 00:20:37,210
採取AP計算機科學或
在Java的編程之前，永遠？

467
00:20:37,210 --> 00:20:37,710
確定。

468
00:20:37,710 --> 00:20:38,210
可愛。

469
00:20:38,210 --> 00:20:41,340
這不會是適用
然後，但在Java，則

470
00:20:41,340 --> 00:20:44,960
有一些所謂的System.out.println
中不存在C.

471
00:20:44,960 --> 00:20:49,927
>> 因此，在C，只要你
要在添加變量

472
00:20:49,927 --> 00:20:51,760
到任何你想要的
打印出來，有

473
00:20:51,760 --> 00:20:54,620
一個特定的語法，我們要使用。

474
00:20:54,620 --> 00:20:56,520
這就是所謂的
placeholding--本質

475
00:20:56,520 --> 00:21:01,180
我們的地方添加佔位符
整數或可變的

476
00:21:01,180 --> 00:21:02,580
我們要打印。

477
00:21:02,580 --> 00:21:07,430
>> 所以當你們可以看到，我們已經包括
這裡一個新的庫頭文件。

478
00:21:07,430 --> 00:21:09,130
在CS50庫。

479
00:21:09,130 --> 00:21:13,160
而載有CS50庫中
是我們將使用一個通用功能

480
00:21:13,160 --> 00:21:15,610
在我們的課程叫調用getInt（）。

481
00:21:15,610 --> 00:21:21,830
>> 有誰要採取刺傷
什麼調用getInt（）有可能會做。

482
00:21:21,830 --> 00:21:22,830
>> 聽眾：[聽不清]

483
00:21:22,830 --> 00:21:23,550
>> ANDI彭：對不起。

484
00:21:23,550 --> 00:21:24,370
聽不見你。

485
00:21:24,370 --> 00:21:25,511
麥迪，任何人。

486
00:21:25,511 --> 00:21:27,260
曼蒂：哦，它會提示
你一個整數。

487
00:21:27,260 --> 00:21:28,051
ANDI鵬：沒錯。

488
00:21:28,051 --> 00:21:30,670
所以這個功能，另一個
功能是已經

489
00:21:30,670 --> 00:21:33,690
寫了由別人
我們可以在請他發言。

490
00:21:33,690 --> 00:21:38,000
所有這就是提示你，用戶，
任何你想要的代碼輸入

491
00:21:38,000 --> 00:21:41,850
正在運行，並且它存儲whatever--
在這種情況下，我們調用getInt（） - 荷蘭國際集團，

492
00:21:41,850 --> 00:21:44,060
所以這意味著我們
獲得的整數。

493
00:21:44,060 --> 00:21:46,150
>> 而且我們要存儲
在另一個整數

494
00:21:46,150 --> 00:21:48,900
我們已經剛才所謂的年紀。

495
00:21:48,900 --> 00:21:51,500
有意義給大家？

496
00:21:51,500 --> 00:21:52,190
酷。

497
00:21:52,190 --> 00:21:56,400
>> 所以，現在我們已經存儲在該整數，
我們已經從用戶提示，

498
00:21:56,400 --> 00:22:00,010
在這個變量中，我們
int類型被稱為時代的創造，

499
00:22:00,010 --> 00:22:03,720
我們可以繼續的地方
在我們的printf（）函數。

500
00:22:03,720 --> 00:22:08,970
因此，語法通常是printf（）的是
這無論在實際的物理

501
00:22:08,970 --> 00:22:14,410
行，你希望包括整數，
你這樣做，符號在那裡，

502
00:22:14,410 --> 00:22:17,800
百分比符號，與
您要的變量類型。

503
00:22:17,800 --> 00:22:20,090
>> 因此，在這種情況下，年齡是一個整數。

504
00:22:20,090 --> 00:22:25,030
所以，你要包括
％我，因為它是一個整數。

505
00:22:25,030 --> 00:22:26,860
然後經過你
聲明中，你會

506
00:22:26,860 --> 00:22:30,370
做逗號和
變量的名稱。

507
00:22:30,370 --> 00:22:33,420
>> 所以在這裡，我們要打印
出，你好，我的名字叫安迪，

508
00:22:33,420 --> 00:22:35,730
而我的空白歲。

509
00:22:35,730 --> 00:22:38,890
Hashta--或sorry--，
年齡無論我輸入。

510
00:22:38,890 --> 00:22:42,790
所以，如果我輸入
20我調用getInt（）在這裡，

511
00:22:42,790 --> 00:22:44,500
它會打印出完全一樣的東西。

512
00:22:44,500 --> 00:22:47,990
但是，如果我想輸入的東西
否則，可能像40或45，

513
00:22:47,990 --> 00:22:50,800
然後你會看到反映
因此在代碼中。

514
00:22:50,800 --> 00:22:52,886
>> 所以這是一個例子
的東西在其中

515
00:22:52,886 --> 00:22:55,260
它打印出來，並期待
你彷彿這是同樣的事情，

516
00:22:55,260 --> 00:22:57,593
但罩下方
計算機實際上有

517
00:22:57,593 --> 00:22:59,560
非常不同的事情發生。

518
00:22:59,560 --> 00:23:00,060
酷。

519
00:23:00,060 --> 00:23:02,760

520
00:23:02,760 --> 00:23:03,260
好的。

521
00:23:03,260 --> 00:23:06,940
那麼，如果我們想要多個變量？

522
00:23:06,940 --> 00:23:08,290
非常的方便。

523
00:23:08,290 --> 00:23:09,150
同樣的事情。

524
00:23:09,150 --> 00:23:11,930
我們也有一個新功能
這裡所謂的GetString（）

525
00:23:11,930 --> 00:23:15,380
也包括在CS50庫中，
所有它的作用是提示用戶

526
00:23:15,380 --> 00:23:18,120
為一個字符串，它是
剛一組字符，

527
00:23:18,120 --> 00:23:19,810
因此喜歡的句子或類似的名稱。

528
00:23:19,810 --> 00:23:25,470
>> 所以在這種情況下，我們將有兩個
佔位符％s的字符串和％I

529
00:23:25,470 --> 00:23:26,750
為整數。

530
00:23:26,750 --> 00:23:29,190
而我們將遵循
由兩個變量

531
00:23:29,190 --> 00:23:32,670
我們希望包括，在訂單
它們出現在句子中。

532
00:23:32,670 --> 00:23:35,471
因此，例如，我的名字是
空白，我想一個名字在那裡，

533
00:23:35,471 --> 00:23:36,970
所以我打算先有名字。

534
00:23:36,970 --> 00:23:39,637
再後來，我想
年齡，希望有年齡第二。

535
00:23:39,637 --> 00:23:42,720
所以，如果我想輸入，你好，
我的名字叫安迪，我20歲。

536
00:23:42,720 --> 00:23:46,370
如果我輸入岸堤和20，
同樣的事情將打印;

537
00:23:46,370 --> 00:23:51,134
然而，現在我們已經有了兩個存儲
名稱變量以及INT。

538
00:23:51,134 --> 00:23:51,634
是啊。

539
00:23:51,634 --> 00:23:54,124
>> 揚聲器8：它會
能夠運行，如果你切換

540
00:23:54,124 --> 00:23:55,620
姓名和年齡在那結束了嗎？

541
00:23:55,620 --> 00:23:55,840
>> ANDI彭：是的。

542
00:23:55,840 --> 00:23:57,006
這是非常好的問題。

543
00:23:57,006 --> 00:23:59,520
所以長話短說，沒有。

544
00:23:59,520 --> 00:24:03,070
由於名稱和age--什麼
變量的類型是什麼名字？

545
00:24:03,070 --> 00:24:03,950
>> 揚聲器8：字符串。

546
00:24:03,950 --> 00:24:05,440
>> ANDI彭：什麼
變量的類型是年齡？

547
00:24:05,440 --> 00:24:06,231
>> 揚聲器8：整數。

548
00:24:06,231 --> 00:24:10,290
ANDI彭：所以在這裡，我們有一個佔位符
字符串和整數，對不對？

549
00:24:10,290 --> 00:24:13,350
所以，如果你要切換這些，
計算機不會知道。

550
00:24:13,350 --> 00:24:16,250
這將檢查一個字符串，
如果你試圖給它一個int，

551
00:24:16,250 --> 00:24:18,083
它會像
等待我很困惑，你

552
00:24:18,083 --> 00:24:21,100
告訴我，我應該是
配發的內存類型為int。

553
00:24:21,100 --> 00:24:23,760
而當就在這裡，
它要求整

554
00:24:23,760 --> 00:24:25,640
你給它一個名稱
和一個字符串代替，

555
00:24:25,640 --> 00:24:28,931
它也將是非常混亂的，它
將不完全運行，你需要的方式。

556
00:24:28,931 --> 00:24:35,280
所以在這裡，命名和語法
用於運行代碼非常重要的。

557
00:24:35,280 --> 00:24:37,991
每個人都好？

558
00:24:37,991 --> 00:24:38,490
是啊。

559
00:24:38,490 --> 00:24:39,476
麥迪。

560
00:24:39,476 --> 00:24:44,620
>> 曼蒂：在這裡，我知道我們已經看了
在類的例子，他們會問在哪裡

561
00:24:44,620 --> 00:24:46,950
什麼是你的年齡，你叫什麼名字。

562
00:24:46,950 --> 00:24:50,250
在這裡，那又是它doesn't--
如果我們運行這段代碼，

563
00:24:50,250 --> 00:24:51,750
它不會要求是什麼？

564
00:24:51,750 --> 00:24:54,740
但是，你只是輸入兩個數字
然後它會運行這樣呢？

565
00:24:54,740 --> 00:24:55,781
>> ANDI彭：是的，沒錯。

566
00:24:55,781 --> 00:24:58,250
所以，如果你想為它
顯示器，請輸入您的年齡，

567
00:24:58,250 --> 00:25:01,100
你可以再補充一個printf（）函數
上面寫著，請輸入您的年齡，

568
00:25:01,100 --> 00:25:01,600
它上面。

569
00:25:01,600 --> 00:25:02,711
這是一個很好的問題。

570
00:25:02,711 --> 00:25:03,210
是啊。

571
00:25:03,210 --> 00:25:07,964
>> 揚聲器9：那麼，就已經是
包括在調用getInt（）[聽不清]。

572
00:25:07,964 --> 00:25:09,380
ANDI彭：不，它實際上不是。

573
00:25:09,380 --> 00:25:11,809
因此，所有這樣做僅僅是
提示空屏幕

574
00:25:11,809 --> 00:25:13,100
到用戶輸入的東西。

575
00:25:13,100 --> 00:25:17,420
如果你想它，如果你想讓它打印
出來的東西，告訴用戶喜歡，

576
00:25:17,420 --> 00:25:21,110
請給我你的年齡，那麼你
必須printf（）的那個自己。

577
00:25:21,110 --> 00:25:23,789
因為每個人都使用這個
功能不同的東西，

578
00:25:23,789 --> 00:25:26,080
你可能會被存儲時代，
你可以存儲地址，

579
00:25:26,080 --> 00:25:28,060
你可能會被儲存的電話號碼。

580
00:25:28,060 --> 00:25:31,190
所以這真的取決於
你的球員的個人用途

581
00:25:31,190 --> 00:25:34,390
你希望它是什麼的話。

582
00:25:34,390 --> 00:25:34,890
是啊。

583
00:25:34,890 --> 00:25:38,236
>> 揚聲器10：所以，我只想澄清，在那裡
做你輸入的名稱和年齡

584
00:25:38,236 --> 00:25:43,020
因此，它顯示了在地方的％s？

585
00:25:43,020 --> 00:25:44,320
>> ANDI彭：作為用戶？

586
00:25:44,320 --> 00:25:47,165
>> 揚聲器10：是的，像我該怎麼辦
使得它 - 我在哪裡把安迪，

587
00:25:47,165 --> 00:25:48,350
和我在哪裡把20？

588
00:25:48,350 --> 00:25:48,640
>> ANDI彭：是的。

589
00:25:48,640 --> 00:25:50,250
所以，如果你要
實際運行這段代碼，

590
00:25:50,250 --> 00:25:52,875
我沒有實際運行
代碼，這僅僅是現在在這裡。

591
00:25:52,875 --> 00:25:56,910
如果我要運行的代碼，我會
編譯代碼，使文件，

592
00:25:56,910 --> 00:26:00,760
運行代碼，然後將有
只是兩個空格，我將其輸入。

593
00:26:00,760 --> 00:26:01,260
是啊。

594
00:26:01,260 --> 00:26:03,843
當你玩你們會看到
周圍與自己的代碼。

595
00:26:03,843 --> 00:26:05,760

596
00:26:05,760 --> 00:26:09,645
>> 所有我們要向右移動
入的下一個章節什麼

597
00:26:09,645 --> 00:26:11,610
我們將涵蓋當今。

598
00:26:11,610 --> 00:26:13,980
我們打算去了什麼
條件語句是。

599
00:26:13,980 --> 00:26:16,500
所以，如果你們還記得
從講座回憶，

600
00:26:16,500 --> 00:26:19,210
條件語句，
所有卻已是一家集

601
00:26:19,210 --> 00:26:24,010
的說明在計算機中
其中，如果某個條件為真，

602
00:26:24,010 --> 00:26:27,470
你執行的代碼
內的這一條件。

603
00:26:27,470 --> 00:26:30,101
>> 因此，在Scratch--本質
從今天的大主題

604
00:26:30,101 --> 00:26:32,850
是，你們已經全部
看到一切背後的邏輯

605
00:26:32,850 --> 00:26:34,020
我們正在覆蓋。

606
00:26:34,020 --> 00:26:36,190
而我們正在做的是
翻譯的東西

607
00:26:36,190 --> 00:26:39,090
這是非常直觀的
從無到有，硬編碼它

608
00:26:39,090 --> 00:26:41,950
到語法，我們將使用
對於這是C類

609
00:26:41,950 --> 00:26:47,550
所以從邏輯上講，這一切都堵得
是一段代碼就在那裡。

610
00:26:47,550 --> 00:26:49,995
是啊。

611
00:26:49,995 --> 00:26:50,900
確定。

612
00:26:50,900 --> 00:26:55,290
>> 我們也進入一個if ... else
聲明這僅僅是一個額外的層

613
00:26:55,290 --> 00:26:59,120
複雜的if語句
其中，計算機需要看看這個

614
00:26:59,120 --> 00:27:04,260
並認為，如果這種情況是真實的，做的
任何的這兩個括號內，

615
00:27:04,260 --> 00:27:08,470
else--樣的等等之類的默認值，如果
它不符合condition--做到這一點。

616
00:27:08,470 --> 00:27:10,120
這就像在一個岔路口。

617
00:27:10,120 --> 00:27:14,400
如果它的外面下雨了，我把
在一個防雨外套，還有什麼別的

618
00:27:14,400 --> 00:27:16,330
別的我不把一個雨衣。

619
00:27:16,330 --> 00:27:18,400
>> 這是否邏輯意義的人呢？

620
00:27:18,400 --> 00:27:21,031
酷。

621
00:27:21,031 --> 00:27:21,530
好的。

622
00:27:21,530 --> 00:27:24,970
因此，像硬例子
這一點，我們將在C見

623
00:27:24,970 --> 00:27:28,890
是，如果我想創建一個
變量調用功課小時。

624
00:27:28,890 --> 00:27:32,050
如果作業時間少
超過五個，我說生命是偉大的。

625
00:27:32,050 --> 00:27:33,070
這是美妙。

626
00:27:33,070 --> 00:27:36,450
不過，說的鬥爭是real--
這是我們這一切星期一

627
00:27:36,450 --> 00:27:39,337
下午起來學山都
可能做正確的now--

628
00:27:39,337 --> 00:27:40,170
聽眾：[笑氣]

629
00:27:40,170 --> 00:27:42,510
ANDI彭：他們的方法，我們
會，向你表示感謝。

630
00:27:42,510 --> 00:27:46,180
我們要硬編碼的方式
這在C是if--讓我們假設

631
00:27:46,180 --> 00:27:49,920
我們已經有類型的變量
int，名為功課小時就在這裡。

632
00:27:49,920 --> 00:27:53,870
如果作業小時小於
5 printf（）的，生命是偉大的。

633
00:27:53,870 --> 00:27:57,330
記住保持/ N，因為
你想後，新的生產線。

634
00:27:57,330 --> 00:27:59,660
否則打印的鬥爭是真實的。

635
00:27:59,660 --> 00:28:03,720
>> 大家是否明白如何
我從這個塊轉換

636
00:28:03,720 --> 00:28:07,610
到這個代碼塊？

637
00:28:07,610 --> 00:28:08,110
酷。

638
00:28:08,110 --> 00:28:11,030

639
00:28:11,030 --> 00:28:11,840
好的。

640
00:28:11,840 --> 00:28:15,930
>> 所以，現在我們要看看
多重如果語句完全。

641
00:28:15,930 --> 00:28:18,140
因此，讓我們假設
該計劃的目的

642
00:28:18,140 --> 00:28:20,870
為我們提示了一個檔次的用戶。

643
00:28:20,870 --> 00:28:24,450
我們提示符下使用調用getInt（）的
級，並且它們的輸入值，

644
00:28:24,450 --> 00:28:27,700
你想顯示
他們得到了什麼樣的檔次。

645
00:28:27,700 --> 00:28:30,730
>> 所以，如果我來設計一個程序，我
在我們所有的目光意味著通常情況下，

646
00:28:30,730 --> 00:28:35,490
90-100是A，80-90是
乙，等等等等。

647
00:28:35,490 --> 00:28:39,040
什麼是不對的
一段代碼，它不是

648
00:28:39,040 --> 00:28:41,393
做我想做的事情。

649
00:28:41,393 --> 00:28:41,892
是啊。

650
00:28:41,892 --> 00:28:45,100
>> 揚聲器11：他們有下限，
但他們沒有上限。

651
00:28:45,100 --> 00:28:46,280
>> ANDI鵬：沒錯。

652
00:28:46,280 --> 00:28:47,950
大家有沒有聽到她說什麼？

653
00:28:47,950 --> 00:28:50,200
還有的將是上
限制，但沒有下限。

654
00:28:50,200 --> 00:28:52,540
對不起，反過來，
下限，沒有上限。

655
00:28:52,540 --> 00:28:55,090
所以，你想
採取刺傷說

656
00:28:55,090 --> 00:28:58,945
什麼將被印刷在該
屏幕如果我要運行該代碼。

657
00:28:58,945 --> 00:28:59,820
揚聲器11：一個錯誤？

658
00:28:59,820 --> 00:29:01,140
ANDI彭：一個錯誤？

659
00:29:01,140 --> 00:29:02,740
偉大的猜測，並不完全正確。

660
00:29:02,740 --> 00:29:05,465
沒有任何人有另一種刺？

661
00:29:05,465 --> 00:29:06,640
是啊，阿龍。

662
00:29:06,640 --> 00:29:10,099
>> AARON：如果你把
東西大於90，

663
00:29:10,099 --> 00:29:11,640
它會顯示所有你得到的成績。

664
00:29:11,640 --> 00:29:13,640
它會告訴你得了A，
你有一個B，你得到了一個C.

665
00:29:13,640 --> 00:29:13,870
>> ANDI彭：是的。

666
00:29:13,870 --> 00:29:14,840
這是完全正確的。

667
00:29:14,840 --> 00:29:17,820
所以，這會是美好的。

668
00:29:17,820 --> 00:29:21,781
然而，它們是相互
獨家的，我想。

669
00:29:21,781 --> 00:29:23,280
如果我要運行這段代碼。

670
00:29:23,280 --> 00:29:26,200
然後讓我們只說，我
輸入的95級。

671
00:29:26,200 --> 00:29:30,360
所以95現在存儲在
整型所謂的檔次。

672
00:29:30,360 --> 00:29:33,610
>> 所以C是一門語言
運行了從上到下，

673
00:29:33,610 --> 00:29:36,000
所以它要永遠
運行到底部。

674
00:29:36,000 --> 00:29:39,420
所以它要來這裡，看是否
級是大於或等於90，

675
00:29:39,420 --> 00:29:42,850
printf（）函數，你得到了一個A.太好了，我
有一個95，這是大於90。

676
00:29:42,850 --> 00:29:44,866
這將打印，
我得到一個答：這是怎麼回事

677
00:29:44,866 --> 00:29:48,850
看看這個，如果，這是怎麼回事
說，還有95也大於80，

678
00:29:48,850 --> 00:29:52,970
這將打印也得到了GOT
A，B感嘆號，等等等等

679
00:29:52,970 --> 00:29:53,690
等等。

680
00:29:53,690 --> 00:29:55,890
>> 因此，當我們都可以看到，
這是一種常見的錯誤

681
00:29:55,890 --> 00:30:00,760
當我們認為可能會出現
編寫代碼看出來的。

682
00:30:00,760 --> 00:30:05,430
任何人，在任何問題
為什麼這是怎麼回事？

683
00:30:05,430 --> 00:30:05,930
太好了。

684
00:30:05,930 --> 00:30:08,920

685
00:30:08,920 --> 00:30:09,440
確定。

686
00:30:09,440 --> 00:30:12,110
>> 那麼，我們如何解決這個問題，顯然是
下一個邏輯問題。

687
00:30:12,110 --> 00:30:16,290
好了，我們有這些美麗
事情如果叫別人，如果別人

688
00:30:16,290 --> 00:30:18,010
如果else語句。

689
00:30:18,010 --> 00:30:22,230
所以你可以看到，如果你想
改變這種狀況的問題，

690
00:30:22,230 --> 00:30:25,260
你想使每個
條件相互排斥的，

691
00:30:25,260 --> 00:30:26,860
您將添加一個else ... if語句。

692
00:30:26,860 --> 00:30:30,068
>> 而這些course--的認為他們是
梯子，還是喜歡上了ladder--梯級

693
00:30:30,068 --> 00:30:34,050
這些可以添加多達你
希望盡可能多的條件，只要你想。

694
00:30:34,050 --> 00:30:36,790
所以在這裡，如果我輸入級為95。

695
00:30:36,790 --> 00:30:39,479
如果等級大於95，
printf（）的，我得到了一個A.大。

696
00:30:39,479 --> 00:30:42,020
這將看到一個else ...如果
而且它會知道，哦，不，

697
00:30:42,020 --> 00:30:43,750
我已經執行的第一人。

698
00:30:43,750 --> 00:30:47,020
我知道 - 或者第一if--我知道，
我沒有看任何這些

699
00:30:47,020 --> 00:30:48,920
因為其中的一個
已是事實。

700
00:30:48,920 --> 00:30:50,410
因此，它會從上往下運行。

701
00:30:50,410 --> 00:30:53,650
一旦第一個是真實的，那麼
它會跳過所有的休息

702
00:30:53,650 --> 00:30:54,675
的東西...... IFS。

703
00:30:54,675 --> 00:30:55,550
這是否有意義？

704
00:30:55,550 --> 00:30:57,841
因此，在這種方式你
不同層次的檢查的

705
00:30:57,841 --> 00:31:01,090
並盡快其中之一為假，則
其餘的都還可以，他們甚至不會檢查。

706
00:31:01,090 --> 00:31:03,577

707
00:31:03,577 --> 00:31:04,076
酷。

708
00:31:04,076 --> 00:31:07,680

709
00:31:07,680 --> 00:31:08,180
好的。

710
00:31:08,180 --> 00:31:11,180
>> 因此，這是一個不同的例子
排序條件語句

711
00:31:11,180 --> 00:31:15,250
我們看到較少，但
我們將看到和使用它們。

712
00:31:15,250 --> 00:31:18,120
而且他們往往更
有效的某些情況。

713
00:31:18,120 --> 00:31:20,020
因此，我們有什麼所謂
switch語句。

714
00:31:20,020 --> 00:31:25,140
所以在我們討論什麼是一個else
語句中，if ... else語句。

715
00:31:25,140 --> 00:31:27,790
在這裡，我們有什麼
所謂的switch語句。

716
00:31:27,790 --> 00:31:31,100
>> 因此，當我們使用開關
語句是關鍵？

717
00:31:31,100 --> 00:31:34,090
因此，在一個switch語句，你
通常情況下，通常情況下，其實你

718
00:31:34,090 --> 00:31:38,010
只能輸入整數您
你正在檢查的變量。

719
00:31:38,010 --> 00:31:42,390
所以，如果我想查查看
如果某一number--例如

720
00:31:42,390 --> 00:31:43,720
一個檔次，如果我有一個90。

721
00:31:43,720 --> 00:31:48,190
我想它，看看如果這是一個A，
B或C.我能有這裡的情況。

722
00:31:48,190 --> 00:31:50,840
然而，這起案件
是另一個恆定。

723
00:31:50,840 --> 00:31:53,170
>> 所以在這個意義上說，
可以切換語句只

724
00:31:53,170 --> 00:31:55,290
檢查兩個數相等。

725
00:31:55,290 --> 00:31:57,242
它不檢查為別的。

726
00:31:57,242 --> 00:31:59,950
所以，這件事情是非常
小心，當你使用這個的。

727
00:31:59,950 --> 00:32:04,810
所以在這裡，如果我想查查看
如果我的90級等於90或80

728
00:32:04,810 --> 00:32:08,500
或70或60，然後打印
相應的等級，

729
00:32:08,500 --> 00:32:11,420
我能寫的
在switch語句。

730
00:32:11,420 --> 00:32:15,120
>> 因此，它會來到這裡，檢查
這個整數等於這個常數？

731
00:32:15,120 --> 00:32:17,030
如果不是，它會跳過。

732
00:32:17,030 --> 00:32:19,880
是不是等於常數
2，等等，等等，

733
00:32:19,880 --> 00:32:22,390
直到你打的默認情況下，
如果他們都不是相等的。

734
00:32:22,390 --> 00:32:24,590
只要其中之一
被設定為相等的，

735
00:32:24,590 --> 00:32:27,040
它會做到這一點
一行代碼和休息。

736
00:32:27,040 --> 00:32:30,990
這意味著它會打的
運行，破裂，只是完全跳過

737
00:32:30,990 --> 00:32:32,240
到代碼的底部。

738
00:32:32,240 --> 00:32:37,550
因此，在這個意義上說的那種功能
就像if的else if else if語句可。

739
00:32:37,550 --> 00:32:40,830
>> 所以這裡有一個具體的
例如，對於你們。

740
00:32:40,830 --> 00:32:46,140
因此，讓我們假設，我想
創建一個名為成立的變量。

741
00:32:46,140 --> 00:32:50,230
我想提示用戶輸入
這一年，他們的學校正式成立。

742
00:32:50,230 --> 00:32:53,300
所以，我可以在這裡創建一個switch語句。

743
00:32:53,300 --> 00:32:56,650
而讓我們只說，我輸入1636。

744
00:32:56,650 --> 00:33:01,120
>> 這裡這段代碼是要見​​開關
成立時間等於1636。

745
00:33:01,120 --> 00:33:03,940
這將看情況
1636年，哦，這些都是平等的，

746
00:33:03,940 --> 00:33:06,230
的printf（）你不應該
在那所學校北上？

747
00:33:06,230 --> 00:33:08,770
因為我們假設他們不這樣做
到這裡，如果他們去哈佛，

748
00:33:08,770 --> 00:33:10,380
突破並跳到結束。

749
00:33:10,380 --> 00:33:14,090
>> 如果我輸入1701年，這
我想大家都會投入，

750
00:33:14,090 --> 00:33:17,500
它會跳過此情況下，來
到案例二是1701年，

751
00:33:17,500 --> 00:33:19,660
和打印歡迎來到耶魯大學！

752
00:33:19,660 --> 00:33:21,360
打破，跳到結束。

753
00:33:21,360 --> 00:33:25,130
否則你可能正在服用此課程
在網上，其中case--真棒歡迎

754
00:33:25,130 --> 00:33:29,020
以Yale--它會進入
默認打印，您好上網！

755
00:33:29,020 --> 00:33:29,870
而打破。

756
00:33:29,870 --> 00:33:30,466
是啊。

757
00:33:30,466 --> 00:33:32,090
>> SPEAKER 12：您可以使用其他
默認情況下，而不是在那裡？

758
00:33:32,090 --> 00:33:34,550
>> ANDI彭：沒有，因為
這樣，這個整體功能

759
00:33:34,550 --> 00:33:39,170
開關建成，語法，
需要使用的情況下，默認的情況下。

760
00:33:39,170 --> 00:33:42,400
這就像如果別人當此
之一，它的情況下，默認的情況下。是啊。

761
00:33:42,400 --> 00:33:45,650
SPEAKER 13：你也許已經說了這一點，
但你有兩個以上的案件？

762
00:33:45,650 --> 00:33:48,066
ANDI彭：是的，你可以
有，只要你想盡可能多的情況下。

763
00:33:48,066 --> 00:33:50,050
把它看成只是想
無限增加的。

764
00:33:50,050 --> 00:33:52,396
>> 揚聲器14：如果你
切換1701 1636，

765
00:33:52,396 --> 00:33:54,187
它並沒有真正做
有差別嗎？

766
00:33:54,187 --> 00:33:55,770
它只是要檢查它。

767
00:33:55,770 --> 00:33:56,900
>> ANDI彭：這是一個
非常好的問題。

768
00:33:56,900 --> 00:33:58,880
我們會觸及
這以後，只是

769
00:33:58,880 --> 00:34:01,160
知道這是開關
聲明infinitely--它的

770
00:34:01,160 --> 00:34:03,536
超過它，如果更高效
否則，如果因為它的運作

771
00:34:03,536 --> 00:34:06,660
使用不同類型的功能
可以讓你，基本上，只是

772
00:34:06,660 --> 00:34:08,790
直接跳轉至
如果您需要所在。

773
00:34:08,790 --> 00:34:10,547
是啊。

774
00:34:10,547 --> 00:34:11,255
揚聲器14：酷。

775
00:34:11,255 --> 00:34:11,754
謝謝。

776
00:34:11,754 --> 00:34:12,526
ANDI彭：是

777
00:34:12,526 --> 00:34:16,687
>> 揚聲器14：你不能
做情況下，像大於。

778
00:34:16,687 --> 00:34:17,270
ANDI彭：沒有。

779
00:34:17,270 --> 00:34:19,860
所以，這是什麼限制了對
switch語句是，你有

780
00:34:19,860 --> 00:34:21,564
有常數只，只有整數。

781
00:34:21,564 --> 00:34:22,064
是啊。

782
00:34:22,064 --> 00:34:25,179

783
00:34:25,179 --> 00:34:25,820
確定。

784
00:34:25,820 --> 00:34:28,659
>> 因此，這是什麼，你
球員都會遇到的次數減少，

785
00:34:28,659 --> 00:34:32,280
但我只是想
在情況介紹吧。

786
00:34:32,280 --> 00:34:36,210
我們這裡有什麼
被稱為三元運算符。

787
00:34:36,210 --> 00:34:39,370
凡從本質上講，它就像一個
if語句編譯成一條線。

788
00:34:39,370 --> 00:34:42,630
在這裡，我會去到下一行中，
下一個頁面，因為它更容易看到的。

789
00:34:42,630 --> 00:34:44,860
>> 所以，我們都看到了這一點嗎？

790
00:34:44,860 --> 00:34:46,110
這是很容易理解。

791
00:34:46,110 --> 00:34:51,290
如果我想創建一個名為變量
名為字符串s，如果一定數目的

792
00:34:51,290 --> 00:34:54,770
我給它小於100，我
要分配較低的字符串，

793
00:34:54,770 --> 00:34:57,240
否則我要分配高。

794
00:34:57,240 --> 00:35:01,370
>> 這在這裡是做同樣的事情
這八行代碼在做什麼。

795
00:35:01,370 --> 00:35:03,600
所以在這裡我想創建
一個變量字符串。

796
00:35:03,600 --> 00:35:08,520
這是我的條件
檢查，如果一個數小於100，

797
00:35:08,520 --> 00:35:12,750
那麼您分配的低價值，
其他指定的高值。

798
00:35:12,750 --> 00:35:15,802
>> 這些幻燈片將在網上，無後顧之憂
如果你們沒有得到這個下來。

799
00:35:15,802 --> 00:35:18,510
這僅僅是一個簡單的方法，更
編寫代碼的有效方式。

800
00:35:18,510 --> 00:35:21,290

801
00:35:21,290 --> 00:35:21,810
確定。

802
00:35:21,810 --> 00:35:25,190
>> 所以，現在我們要
輸入的內容，對於大多數人來說

803
00:35:25,190 --> 00:35:28,660
就像一個非常，非常混亂
件事想在第一。

804
00:35:28,660 --> 00:35:30,226
環路部分。

805
00:35:30,226 --> 00:35:32,600
所以我們今天要談
大約有三種類型的循環。

806
00:35:32,600 --> 00:35:34,890
我們將開始一段時間
循環，再來談一個do while循環，

807
00:35:34,890 --> 00:35:36,740
然後說說for循環。

808
00:35:36,740 --> 00:35:40,010
>> 所以基本上，對於更
視覺學習者在那裡，

809
00:35:40,010 --> 00:35:44,410
我們本質上是一個圖形化
描寫一個什麼樣的while循環一樣。

810
00:35:44,410 --> 00:35:48,290
因此，在編程時，你將開始
並進入循環在某一點。

811
00:35:48,290 --> 00:35:49,470
你檢查的條件。

812
00:35:49,470 --> 00:35:52,165
如果條件為真，
你內心執行的代碼。

813
00:35:52,165 --> 00:35:53,790
而你再回頭來您檢查。

814
00:35:53,790 --> 00:35:57,190
如果它仍然是真的，你繼續運行
一圈又一圈，這個代碼在一個循環。

815
00:35:57,190 --> 00:36:00,970
>> 然而，第二即
條件為假，

816
00:36:00,970 --> 00:36:02,739
你要打破和結束循環。

817
00:36:02,739 --> 00:36:05,030
這在本質上是
語法你要使用。

818
00:36:05,030 --> 00:36:08,250
而一定條件是
真正做到這一點，如果這不是真的，

819
00:36:08,250 --> 00:36:12,920
你要跳到結束
和前進與您的程序。

820
00:36:12,920 --> 00:36:13,690
確定。

821
00:36:13,690 --> 00:36:17,250
>> 有沒有人有一個例子
什麼可能會潛在地發生

822
00:36:17,250 --> 00:36:19,160
如果我嘗試運行這段代碼？

823
00:36:19,160 --> 00:36:22,470
順便說一句，SAJ--這是Scaz，安迪，
Jason--我們將簽署我們的郵件，

824
00:36:22,470 --> 00:36:24,830
愛，SAJ。

825
00:36:24,830 --> 00:36:25,573
這就是我們。

826
00:36:25,573 --> 00:36:26,500
確定。

827
00:36:26,500 --> 00:36:29,829
>> 任何人有一個例子，還是有
什麼這將打印的想法？

828
00:36:29,829 --> 00:36:30,870
樣的一個很難回答的問題。

829
00:36:30,870 --> 00:36:34,550

830
00:36:34,550 --> 00:36:39,380
所以在這裡，記住狀況
我們正在檢查的同時，真實的。

831
00:36:39,380 --> 00:36:42,840
因此，雖然這是真的，這是
付印，我愛SAJ！

832
00:36:42,840 --> 00:36:48,460
有沒有在我們最好的任意點
更改為任何其他方式？

833
00:36:48,460 --> 00:36:49,050
沒有，對不對？

834
00:36:49,050 --> 00:36:51,470
>> 所以在這裡，我們有
遇到什麼可能

835
00:36:51,470 --> 00:36:54,310
將要竊聽了很多
你的程序，無限循環。

836
00:36:54,310 --> 00:36:56,268
你會發現，如果你
運行這段代碼，

837
00:36:56,268 --> 00:36:58,160
它只是要保持
印刷，我愛SAJ！

838
00:36:58,160 --> 00:37:00,701
雖然我們讚賞的支持，
我們不希望你的電腦

839
00:37:00,701 --> 00:37:02,910
崩潰是因為你
保持印刷我愛SAJ！

840
00:37:02,910 --> 00:37:05,320
>> 所以，請，請，
避免無限循環

841
00:37:05,320 --> 00:37:07,320
因為它永遠不會
以評估為假

842
00:37:07,320 --> 00:37:08,780
和你永遠也不會
離開循環。

843
00:37:08,780 --> 00:37:10,530
而你要
被吸入天長地久。

844
00:37:10,530 --> 00:37:13,000
酷。

845
00:37:13,000 --> 00:37:13,694
確定。

846
00:37:13,694 --> 00:37:15,610
第二類型的循環
我們將談論今天

847
00:37:15,610 --> 00:37:17,580
是while循環，做while循環的做的。

848
00:37:17,580 --> 00:37:20,580
它之所以被稱為do while循環
因為你有做，一段時間。

849
00:37:20,580 --> 00:37:24,390
因此，這是非常類似，而
循環，但有一點點不同。

850
00:37:24,390 --> 00:37:27,620
在這裡，你打算怎麼辦
無論公司的這裡面

851
00:37:27,620 --> 00:37:29,747
而在一定條件下是真的。

852
00:37:29,747 --> 00:37:32,580
所以，如果我是C和我的電腦
順著這一段代碼，

853
00:37:32,580 --> 00:37:33,880
我看看頂部。

854
00:37:33,880 --> 00:37:36,890
我去到C，我說的做這件事情。

855
00:37:36,890 --> 00:37:40,550
然後我檢查，而這
是真的，我要重複它。

856
00:37:40,550 --> 00:37:42,750
不過，雖然這是假的，
然後我往前走

857
00:37:42,750 --> 00:37:44,700
我從來沒有回到那個循環一次。

858
00:37:44,700 --> 00:37:48,360
>> 任何人都可以花刺
有什麼區別

859
00:37:48,360 --> 00:37:52,130
這個循環和一個我們之間
只是看著是實際。

860
00:37:52,130 --> 00:37:52,717
是啊。

861
00:37:52,717 --> 00:37:55,050
SPEAKER 15：條件
來代替前後？

862
00:37:55,050 --> 00:37:55,841
ANDI鵬：沒錯。

863
00:37:55,841 --> 00:37:57,984
所以她說的條件
來後，而不是之前。

864
00:37:57,984 --> 00:38:00,400
最終，所不同的
這和while循環之間

865
00:38:00,400 --> 00:38:03,597
是，你只是打算怎麼辦
任何的這裡面不管

866
00:38:03,597 --> 00:38:06,430
無論您的病情
真的，然後檢查條件。

867
00:38:06,430 --> 00:38:08,304
所以在這種情況下，你
always--以這種方式，

868
00:38:08,304 --> 00:38:11,240
你總是要確保
無論是內至少運行

869
00:38:11,240 --> 00:38:14,230
檢查，看看前一次
如果你想讓它再次運行。

870
00:38:14,230 --> 00:38:18,040
>> 這裡有一個例子
當我們會使用它。

871
00:38:18,040 --> 00:38:22,570
因此，舉例來說，如果我想有
int類型的變量命名的時代，

872
00:38:22,570 --> 00:38:25,640
我想提示
他們的年齡的用戶，

873
00:38:25,640 --> 00:38:27,910
我會做的printf（）
什麼是您的年齡？

874
00:38:27,910 --> 00:38:30,330
年齡=調用getInt（），它
是提示用戶。

875
00:38:30,330 --> 00:38:32,140
>> 而有些人會真的很煩人。

876
00:38:32,140 --> 00:38:34,931
而且你不想在錯誤的
有人程序輸入一樣，

877
00:38:34,931 --> 00:38:36,680
哦，我是負4歲或什麼的。

878
00:38:36,680 --> 00:38:39,900
在這種情況下，如果它們
做到這一點，這個計算結果

879
00:38:39,900 --> 00:38:43,150
為true，這意味著我要去
必須保持回去和這樣做。

880
00:38:43,150 --> 00:38:45,310
因此，這是要保持
再次提示用戶

881
00:38:45,310 --> 00:38:47,960
給你像一個真正的
年齡號和它的

882
00:38:47,960 --> 00:38:51,930
要保持回去和重做
它，直到他們給你一個真實年齡

883
00:38:51,930 --> 00:38:56,900
大於一，或不為零。

884
00:38:56,900 --> 00:38:58,020
>> 因此暗示，暗示。

885
00:38:58,020 --> 00:39:02,263
這將是非常，非常有用
為你的PSET問題之一。

886
00:39:02,263 --> 00:39:04,155
是啊。

887
00:39:04,155 --> 00:39:05,580
>> 揚聲器16：哎呀，對不起。

888
00:39:05,580 --> 00:39:06,288
>> ANDI彭：是的。

889
00:39:06,288 --> 00:39:09,424
>> 揚聲器16：有沒有，不
是一個混蛋，但 - 

890
00:39:09,424 --> 00:39:10,340
ANDI彭：不用擔心。

891
00:39:10,340 --> 00:39:11,990
揚聲器16：--are有
這裡不同的規則，

892
00:39:11,990 --> 00:39:13,810
還是你只是忘記
把報價？

893
00:39:13,810 --> 00:39:14,250
>> ANDI彭：哦，是的。

894
00:39:14,250 --> 00:39:15,530
對不起，這是完全是我不好。

895
00:39:15,530 --> 00:39:17,100
這是肯定
應該是一個報價。

896
00:39:17,100 --> 00:39:17,690
良好的漁獲。

897
00:39:17,690 --> 00:39:18,800
那將無法運行。

898
00:39:18,800 --> 00:39:22,070

899
00:39:22,070 --> 00:39:22,830
確定。

900
00:39:22,830 --> 00:39:26,160
>> 因此，循環的最後一個類型，我們將討論
約，最終同類產品中最

901
00:39:26,160 --> 00:39:28,854
複雜的for循環。

902
00:39:28,854 --> 00:39:30,770
如果你不知道不要擔心
知道這意味著什麼。

903
00:39:30,770 --> 00:39:32,061
這是相當混亂在第一。

904
00:39:32,061 --> 00:39:33,640
我們一起去了一個例子。

905
00:39:33,640 --> 00:39:37,040
>> 所有這一切發生在一個for循環
是，你有三個語句

906
00:39:37,040 --> 00:39:38,380
你要去包含。

907
00:39:38,380 --> 00:39:42,130
因此，對於某一件事情，你
要初始化變量。

908
00:39:42,130 --> 00:39:45,280
你要的條件添加到
此循環將繼續運行。

909
00:39:45,280 --> 00:39:47,790
然後，在的結尾
循環，你要更新它。

910
00:39:47,790 --> 00:39:50,248
您可以更新變量
要跟踪。

911
00:39:50,248 --> 00:39:52,530
因此，我們通常使用
for循環的時候，我們

912
00:39:52,530 --> 00:39:55,390
要運行一個循環
一定量的時間

913
00:39:55,390 --> 00:39:58,900
我們已經知道，哦，我想
這個循環就像10次執行，

914
00:39:58,900 --> 00:40:03,060
那麼你do--我過去
下頁的一個例子。

915
00:40:03,060 --> 00:40:07,830
>> 所以在這裡，例如，在刮，如果
想要的東西，重複10次，

916
00:40:07,830 --> 00:40:10,790
你不得不說的是，
重複10次我愛SAJ！

917
00:40:10,790 --> 00:40:15,260
這是一種更可接受
展會對我們的支持

918
00:40:15,260 --> 00:40:17,120
而不是無限循環。

919
00:40:17,120 --> 00:40:19,920
在這裡，你會如何
過渡到C和寫

920
00:40:19,920 --> 00:40:26,040
這是int--我要創建或
聲明一個int類型的變量命名的我。

921
00:40:26,040 --> 00:40:30,089
我要初始化
為0，所以我= 0;

922
00:40:30,089 --> 00:40:31,630
這將是我的病情。

923
00:40:31,630 --> 00:40:33,860
所以i小於10。

924
00:40:33,860 --> 00:40:36,096
然後在end--
你是最後一個發言

925
00:40:36,096 --> 00:40:38,710
將不得不是的更新
恰好變量i什麼

926
00:40:38,710 --> 00:40:40,206
在您的for循環的結束。

927
00:40:40,206 --> 00:40:42,830
因此，它是一種令人困惑的，因為
這條線的不同部分

928
00:40:42,830 --> 00:40:44,871
都發生在不同的
類型的循環。

929
00:40:44,871 --> 00:40:46,746
但我去了一個
那偽代碼示例

930
00:40:46,746 --> 00:40:50,360
也許解釋
只是好一點。

931
00:40:50,360 --> 00:40:51,500
>> 所以在這裡。

932
00:40:51,500 --> 00:40:52,929
這就是我們剛才看到的循環。

933
00:40:52,929 --> 00:40:55,470
基本上偽代碼，是什麼
在這個程序中，

934
00:40:55,470 --> 00:40:57,940
首先是我創建
我，初始化為0。

935
00:40:57,940 --> 00:41:00,440
我檢查，看看我是
小於10，在這種情況

936
00:41:00,440 --> 00:41:02,840
第一次是
因為0小於10。

937
00:41:02,840 --> 00:41:04,727
因此，環路將運行。

938
00:41:04,727 --> 00:41:06,310
然後我會打印這一行。

939
00:41:06,310 --> 00:41:11,240
然後在該行的末尾，右
在這裡，我打算做增量我，我++，

940
00:41:11,240 --> 00:41:13,370
所有的手段是
由一個遞增它。

941
00:41:13,370 --> 00:41:15,460
>> 所以，我現在是1。

942
00:41:15,460 --> 00:41:17,960
因為它曾經是0，如果我
增加它的，它現在是1。

943
00:41:17,960 --> 00:41:19,610
然後，我要回去
到循環的開始

944
00:41:19,610 --> 00:41:20,730
我檢查車況。

945
00:41:20,730 --> 00:41:22,080
是條件還是真的嗎？

946
00:41:22,080 --> 00:41:24,030
是的，1仍低於10。

947
00:41:24,030 --> 00:41:27,370
因此，這將再次打印此，
去，然後加我，並檢查

948
00:41:27,370 --> 00:41:29,180
條件
不斷，不斷，

949
00:41:29,180 --> 00:41:33,290
直到你最終得到
到這種地步，我是10。

950
00:41:33,290 --> 00:41:36,300
>> 你要打印10次
然後我會等於10。

951
00:41:36,300 --> 00:41:37,800
你要檢查的條件。

952
00:41:37,800 --> 00:41:38,760
比10小10？

953
00:41:38,760 --> 00:41:40,370
不，那是假的。

954
00:41:40,370 --> 00:41:43,020
因此，該環是不會
運行，這將打破，

955
00:41:43,020 --> 00:41:45,040
而你要
繼續與您的代碼。

956
00:41:45,040 --> 00:41:47,550
>> 所以當你們看到的，這
是一個真正偉大的例子

957
00:41:47,550 --> 00:41:53,110
一個循環，你可以設定在
運行一段指定的時間量。

958
00:41:53,110 --> 00:41:54,457
每個人都清楚了嗎？

959
00:41:54,457 --> 00:41:54,956
是啊。

960
00:41:54,956 --> 00:41:59,060
>> 揚聲器17：約增量如何
指數，它是不同的編碼？

961
00:41:59,060 --> 00:42:02,060
>> ANDI彭：你can--我們會去
在這個下一張幻燈片。

962
00:42:02,060 --> 00:42:03,350
好問題。

963
00:42:03,350 --> 00:42:05,910
是anyone--之前，我謹
on--任何人都糊塗了，

964
00:42:05,910 --> 00:42:07,640
因為這是一個非常艱難的概念。

965
00:42:07,640 --> 00:42:09,510
不用擔心，如果you're--確定。

966
00:42:09,510 --> 00:42:10,010
酷。

967
00:42:10,010 --> 00:42:12,836

968
00:42:12,836 --> 00:42:13,490
>> 好的。

969
00:42:13,490 --> 00:42:14,610
只是一般的幻燈片。

970
00:42:14,610 --> 00:42:18,020
這個while循環做
循環完全一樣的事情了。

971
00:42:18,020 --> 00:42:19,631
這只是寫的不同。

972
00:42:19,631 --> 00:42:22,130
你們可以仔細閱讀幻燈片
在稍後您方便。

973
00:42:22,130 --> 00:42:24,880
但是，僅僅知道有多重
寫同樣的事情的方法

974
00:42:24,880 --> 00:42:28,300
以發生在不同的循環。

975
00:42:28,300 --> 00:42:28,800
確定。

976
00:42:28,800 --> 00:42:32,380
>> 所以，現在我們的問題得到了什麼
如果我們有一個循環內的循環。

977
00:42:32,380 --> 00:42:35,810
我們正在轉化為現實
盜夢式的東西在這裡。

978
00:42:35,810 --> 00:42:40,640
當你想要做的事情多
其他的事情裡面倍

979
00:42:40,640 --> 00:42:44,129
該做的事情多次，你
想要什麼叫做嵌套循環。

980
00:42:44,129 --> 00:42:47,420
對於那些你們誰第一個看到這一點，
得到非常困惑，所有我們在這裡做

981
00:42:47,420 --> 00:42:50,580
是有循環，其中一個
我們有行的變量。

982
00:42:50,580 --> 00:42:54,500
但是它裡面，我們也有另一種
用於可變稱為柱的循環。

983
00:42:54,500 --> 00:42:58,560
我強烈建議大家
誰是困惑，首先保持

984
00:42:58,560 --> 00:43:00,310
track--畫了這一點，畫了這一點。

985
00:43:00,310 --> 00:43:03,000
不要試圖正當理由
通過它，畫出來。

986
00:43:03,000 --> 00:43:06,630
>> 在你的頭，在這片
紙，或什麼的，寫一行，

987
00:43:06,630 --> 00:43:08,614
跟踪哪些行是公平的。

988
00:43:08,614 --> 00:43:10,780
寫專欄，跟踪
什麼列等於。

989
00:43:10,780 --> 00:43:13,490
並跟踪的是什麼
打印出與每一個迭代。

990
00:43:13,490 --> 00:43:16,320
這個循環的每次迭代，每
那個大循環迭代，

991
00:43:16,320 --> 00:43:17,820
只是一味地按照邏輯。

992
00:43:17,820 --> 00:43:20,190
我向你保證，
你一定會喜歡你所看到的，

993
00:43:20,190 --> 00:43:24,307
因為它也很
適用於您的問題集。

994
00:43:24,307 --> 00:43:24,806
酷。

995
00:43:24,806 --> 00:43:27,501

996
00:43:27,501 --> 00:43:28,000
好的。

997
00:43:28,000 --> 00:43:30,723
所以，最重要的事情
那你們可能都

998
00:43:30,723 --> 00:43:32,400
想著現在，
是你的習題集1秒，

999
00:43:32,400 --> 00:43:33,650
這是由於週四/週五。

1000
00:43:33,650 --> 00:43:36,890

1001
00:43:36,890 --> 00:43:39,710
>> 在您的water.c程序，
暗示你將會有

1002
00:43:39,710 --> 00:43:41,590
以提示的用戶輸入。

1003
00:43:41,590 --> 00:43:43,640
在您mario.c程序
你將有

1004
00:43:43,640 --> 00:43:46,431
使用嵌套的for循環，這是
一個for循環的for循環裡面，

1005
00:43:46,431 --> 00:43:50,247
打印金字塔塊，基本上
像什麼馬里奧跳通過。

1006
00:43:50,247 --> 00:43:53,330
然後在你的greedy--或者
找零，如果有的話你們

1007
00:43:53,330 --> 00:43:55,740
曾經聽說過that--
你將必須非常

1008
00:43:55,740 --> 00:43:58,160
細心的第一個浮點值。

1009
00:43:58,160 --> 00:44:01,860
記住浮動小數和
整數是不一樣的東西。

1010
00:44:01,860 --> 00:44:03,620
跟踪哪個是哪個。

1011
00:44:03,620 --> 00:44:05,953
而你要使用
條件語句，也是如此。

1012
00:44:05,953 --> 00:44:09,070

1013
00:44:09,070 --> 00:44:10,940
>> 好了，最後一件事。

1014
00:44:10,940 --> 00:44:12,770
我有留下一兩分鐘。

1015
00:44:12,770 --> 00:44:13,460
樣式。

1016
00:44:13,460 --> 00:44:19,320
因此，這是一些不
實際上實現的效率，

1017
00:44:19,320 --> 00:44:21,010
或代碼的實際運行。

1018
00:44:21,010 --> 00:44:24,380
然而，它影響我們的
您的平地機，為你的讀者。

1019
00:44:24,380 --> 00:44:27,290
它會影響你自己，如果你
試圖找到一個問題。

1020
00:44:27,290 --> 00:44:30,700
它會影響您的代碼的可讀性。

1021
00:44:30,700 --> 00:44:34,070
>> 所以風格，當你試圖像
如果你的風格的一篇文章為英語，

1022
00:44:34,070 --> 00:44:36,070
沒有段落，
你擁有了一切樣

1023
00:44:36,070 --> 00:44:39,190
的混在一起在同一行，它
使得任何人真的很難

1024
00:44:39,190 --> 00:44:42,620
讀你的文章，即使
你的觀點在邏輯上是健全的。

1025
00:44:42,620 --> 00:44:44,390
同樣的事情在編程。

1026
00:44:44,390 --> 00:44:47,910
你可以有可怕的晦澀
碼Scaz將覆蓋，

1027
00:44:47,910 --> 00:44:49,660
和它仍然可以運行和功能。

1028
00:44:49,660 --> 00:44:53,110
但對我們來說，因為你的可愛助教，誰都會
可以閱讀和評估您的pset時，

1029
00:44:53,110 --> 00:44:54,460
這不是很好。

1030
00:44:54,460 --> 00:44:56,859
>> 所以，請為求
我們和你自己的，

1031
00:44:56,859 --> 00:44:58,900
當你試圖修復
在你的代碼中的問題，

1032
00:44:58,900 --> 00:45:00,774
和你想
看你自己的代碼，使

1033
00:45:00,774 --> 00:45:03,910
一定要遵循一些約定
我們打算走了過來。

1034
00:45:03,910 --> 00:45:04,510
>> 所以第一。

1035
00:45:04,510 --> 00:45:07,070
給你的變量有意義的名稱。

1036
00:45:07,070 --> 00:45:11,450
如果你想存儲的整數
所謂的年齡，請其命名為年齡。

1037
00:45:11,450 --> 00:45:12,875
不要將其命名高度。

1038
00:45:12,875 --> 00:45:14,750
當你想
存儲時代的高度，

1039
00:45:14,750 --> 00:45:16,722
它使一切
很迷惑我們。

1040
00:45:16,722 --> 00:45:17,930
我們不喜歡被人混淆。

1041
00:45:17,930 --> 00:45:19,180
你不喜歡被人混淆。

1042
00:45:19,180 --> 00:45:20,350
沒有人喜歡被混淆。

1043
00:45:20,350 --> 00:45:23,100
如果你想創造的東西，
它命名為一些有意義的事情。

1044
00:45:23,100 --> 00:45:26,440
>> 然而，在用於循環，單
字符變量通常是罰款。

1045
00:45:26,440 --> 00:45:31,350
而在for循環，如果你只想要我，
與J，K，隨意僅僅做到這一點。

1046
00:45:31,350 --> 00:45:32,670
>> 一致的初始化。

1047
00:45:32,670 --> 00:45:33,770
那麼，是什麼意思呢？

1048
00:45:33,770 --> 00:45:37,600
這意味著在技術上，理論上，
你可以發起並創建

1049
00:45:37,600 --> 00:45:40,140
在同一行上的多個變量。

1050
00:45:40,140 --> 00:45:42,820
因此，例如，我可以創建
稱為scaz_age的整數，

1051
00:45:42,820 --> 00:45:47,110
和整數稱為andi_age = 20，
和整數稱為jason_age

1052
00:45:47,110 --> 00:45:48,090
在同一行上。

1053
00:45:48,090 --> 00:45:52,060
而且我也可以指定只有一個
他們，而不是其他人值。

1054
00:45:52,060 --> 00:45:54,142
我們請你，請不要那樣做。

1055
00:45:54,142 --> 00:45:57,350
因為在這裡你已經基本上建立
三個變量，但只有其中的

1056
00:45:57,350 --> 00:45:58,295
實際上有一個值。

1057
00:45:58,295 --> 00:46:00,170
然後，當我們
試圖讀取你的代碼，

1058
00:46:00,170 --> 00:46:01,850
或者如果你試圖修復
在你的代碼中的問題，

1059
00:46:01,850 --> 00:46:03,340
這是非常令人困惑遵循。

1060
00:46:03,340 --> 00:46:09,300
因此，只要你的可讀性，對於
我們的可讀性，不這樣做。

1061
00:46:09,300 --> 00:46:10,355
>> 一致的大括號。

1062
00:46:10,355 --> 00:46:12,980
有些人喜歡把自己的
大括號在不同的地方。

1063
00:46:12,980 --> 00:46:14,100
這其實並不重要。

1064
00:46:14,100 --> 00:46:17,900
只要確保你在一致的
自己的代碼，你喜歡把他們。

1065
00:46:17,900 --> 00:46:18,950
>> 一致的間距。

1066
00:46:18,950 --> 00:46:22,040
如果你把一個空間後，
for循環，始終做到這一點。

1067
00:46:22,040 --> 00:46:24,930
那種就像不要在做
有些地方，不要在別人去做。

1068
00:46:24,930 --> 00:46:26,580
只要是一致的。

1069
00:46:26,580 --> 00:46:29,500
>> 其次，如果有人想
細讀CS50風格指南，

1070
00:46:29,500 --> 00:46:33,230
我們正式有一番風情指南，
告訴你這些公約，

1071
00:46:33,230 --> 00:46:34,890
加上更多。

1072
00:46:34,890 --> 00:46:35,530
這是在網上。

1073
00:46:35,530 --> 00:46:38,670
這就像cs50.net/style
或者類似的東西。

1074
00:46:38,670 --> 00:46:40,180
你可以google一下。

1075
00:46:40,180 --> 00:46:41,399
>> 一致性是關鍵。

1076
00:46:41,399 --> 00:46:43,190
所以不用擔心什麼
其他人都在做，

1077
00:46:43,190 --> 00:46:46,180
只要確保你
在你自己的代碼相一致。

1078
00:46:46,180 --> 00:46:50,570
任何人有關於什麼問題嗎？

1079
00:46:50,570 --> 00:46:51,070
是啊。

1080
00:46:51,070 --> 00:46:53,370
>> 揚聲器18：所以正確的事
做初始化就是

1081
00:46:53,370 --> 00:46:56,130
讓他們都在一個單獨的
行，是你在說什麼？

1082
00:46:56,130 --> 00:46:58,850
>> ANDI彭：所以我很少有這種情況發生。

1083
00:46:58,850 --> 00:47:02,230
但是，如果你想，如果你想
要像節約空間，在你的代碼，

1084
00:47:02,230 --> 00:47:04,000
或什麼的，你可以做到這一點。

1085
00:47:04,000 --> 00:47:07,800
我們要求你只是不初始化
有一件事，而不是其他人。

1086
00:47:07,800 --> 00:47:12,600
所以，如果你想要做INT scaz_age，INT
andi_age，INT jason_age，這很好。

1087
00:47:12,600 --> 00:47:15,600
只是不初始化一個
而不是其他的一切。

1088
00:47:15,600 --> 00:47:18,380

1089
00:47:18,380 --> 00:47:19,904
>> 有問題嗎？

1090
00:47:19,904 --> 00:47:20,850
好的。

1091
00:47:20,850 --> 00:47:24,610
我要通過關閉
麥克風，激光指示器，

1092
00:47:24,610 --> 00:47:28,862
和著指揮棒Scaz在這一點上。

1093
00:47:28,862 --> 00:47:29,808
這是尷尬的。

1094
00:47:29,808 --> 00:47:32,650

1095
00:47:32,650 --> 00:47:33,200
在這裡，它是。

1096
00:47:33,200 --> 00:47:34,408
>> BRIAN SCASSELLATI：謝謝。

1097
00:47:34,408 --> 00:47:42,500

1098
00:47:42,500 --> 00:47:43,380
是如何形成的聲音？

1099
00:47:43,380 --> 00:47:46,420

1100
00:47:46,420 --> 00:47:47,900
聲音是好的？ 。

1101
00:47:47,900 --> 00:47:49,220
優秀的。

1102
00:47:49,220 --> 00:47:50,350
確定。

1103
00:47:50,350 --> 00:47:52,110
所以，大家好。

1104
00:47:52,110 --> 00:47:56,540
>> 我要去嘗試工作，通過
一個實際的例子和你在一起。

1105
00:47:56,540 --> 00:48:00,850
我們要使用CS50的
開發環境，什麼所謂

1106
00:48:00,850 --> 00:48:03,120
集成開發環境。

1107
00:48:03,120 --> 00:48:05,145
你已經看到了這個
證明在講座。

1108
00:48:05,145 --> 00:48:07,520
而在習題集1，你
將有機會

1109
00:48:07,520 --> 00:48:10,890
使用它，和玩
它，並習慣於它，

1110
00:48:10,890 --> 00:48:13,640
因為我們要使用它
通過本學期的休息。

1111
00:48:13,640 --> 00:48:20,350
>> 所以在這個IDE，你有什麼期待
就像一個非常傳統的文件瀏覽器

1112
00:48:20,350 --> 00:48:21,890
過在一個面上。

1113
00:48:21,890 --> 00:48:24,360
你已經有了一個部分了
頂你要去哪裡

1114
00:48:24,360 --> 00:48:28,850
看看你的源代碼，你
CFILE，你寫的代碼。

1115
00:48:28,850 --> 00:48:31,880
上下底，你會
有一個終端窗口

1116
00:48:31,880 --> 00:48:36,330
你會使用到
這兩個編譯程序

1117
00:48:36,330 --> 00:48:39,090
並運行或執行程序。

1118
00:48:39,090 --> 00:48:40,100
確定。

1119
00:48:40,100 --> 00:48:46,560
>> 因此，只要給我們一點點
的基礎上，在終端窗口中，

1120
00:48:46,560 --> 00:48:48,930
你會是
使用一組命令

1121
00:48:48,930 --> 00:48:53,040
這是整個標準命令
大多數Unix或Linux系統。

1122
00:48:53,040 --> 00:48:55,890
所以，如果你曾經使用過
任何形式的Unix，Ubuntu的的，

1123
00:48:55,890 --> 00:48:59,140
或任何其他調味劑，
這些將要看起來很熟悉。

1124
00:48:59,140 --> 00:49:00,890
>> 如果你還沒有，請不要擔心。

1125
00:49:00,890 --> 00:49:02,830
沒有什麼複雜的他們。

1126
00:49:02,830 --> 00:49:05,330
他們只是用不同的
語法，不同的命名

1127
00:49:05,330 --> 00:49:07,630
約定比你以前見過。

1128
00:49:07,630 --> 00:49:12,190
>> 因此，要列出文件
一個特定的目錄中，

1129
00:49:12,190 --> 00:49:15,310
他們將使用
命令稱為LS或列表。

1130
00:49:15,310 --> 00:49:18,010
如果你想看到的一切
與所有的細節，

1131
00:49:18,010 --> 00:49:21,535
你會使用命令
行參數使用​​ls -l命令。

1132
00:49:21,535 --> 00:49:23,910
這會告訴你一切
更詳細地，包括

1133
00:49:23,910 --> 00:49:26,270
該權限的文件。

1134
00:49:26,270 --> 00:49:31,190
>> 要更改目錄，
你會使用cd命令。

1135
00:49:31,190 --> 00:49:35,180
而你就可以更改目錄
既要到你的主目錄。

1136
00:49:35,180 --> 00:49:38,500
這只是CD全部由
本身，光盤有兩個

1137
00:49:38,500 --> 00:49:42,930
點會返回上一層
級別到以前的目錄。

1138
00:49:42,930 --> 00:49:46,400
而且你還可以cd到一個
子目錄通過鍵入CD

1139
00:49:46,400 --> 00:49:48,500
和該子目錄的名稱。

1140
00:49:48,500 --> 00:49:50,540
>> 您還可以創建新的目錄。

1141
00:49:50,540 --> 00:49:52,790
而且我們要走路
通過這次在短短的一分鐘。

1142
00:49:52,790 --> 00:49:54,498
但是，僅僅把
一切都在屏幕上。

1143
00:49:54,498 --> 00:49:56,310
所以，你可以看到他們。

1144
00:49:56,310 --> 00:50:00,420
>> 您也將有能力
直接操作文件

1145
00:50:00,420 --> 00:50:02,100
在命令行。

1146
00:50:02,100 --> 00:50:06,059
您將能夠複製他們，
移動它們，或者將它們刪除，

1147
00:50:06,059 --> 00:50:07,600
也就是說，有效地將其刪除。

1148
00:50:07,600 --> 00:50:10,310

1149
00:50:10,310 --> 00:50:15,350
>> 該CS50 IDE給你完整的
命令行參數的力量。

1150
00:50:15,350 --> 00:50:20,280
這意味著你也可以
這樣做非常危險的事情。

1151
00:50:20,280 --> 00:50:21,560
確定。

1152
00:50:21,560 --> 00:50:25,010
例如，你可以
除去，或者說是刪除，

1153
00:50:25,010 --> 00:50:28,750
不求回報的文件
進行確認。

1154
00:50:28,750 --> 00:50:31,820
你甚至可以刪除
recursively--那

1155
00:50:31,820 --> 00:50:38,940
破折號 -  [R flag--整個
子目錄及其所有內容。

1156
00:50:38,940 --> 00:50:39,660
確定。

1157
00:50:39,660 --> 00:50:42,940
他們列在紅色的，因為你
每次應考慮“危險”

1158
00:50:42,940 --> 00:50:45,000
你看到的那些東西。

1159
00:50:45,000 --> 00:50:45,920
確定。

1160
00:50:45,920 --> 00:50:46,420
好的。

1161
00:50:46,420 --> 00:50:50,090

1162
00:50:50,090 --> 00:50:53,430
>> 現在，終於，這個事情是
將是真正有價值的給你，

1163
00:50:53,430 --> 00:50:57,270
是有幾個不錯的招數
要知道，你正在瀏覽

1164
00:50:57,270 --> 00:50:59,190
通過這個終端窗口。

1165
00:50:59,190 --> 00:51:03,590
首先，你可以清除屏幕上
任何時候只需鍵入明確。

1166
00:51:03,590 --> 00:51:06,310
而且你會看到
我這樣經常。

1167
00:51:06,310 --> 00:51:09,990
你也可以顯示
一個文件的文本

1168
00:51:09,990 --> 00:51:13,992
通過鍵入以上，然後文件名。

1169
00:51:13,992 --> 00:51:17,200
然後，您就可以滾動回來，
提出與剛剛與空格鍵

1170
00:51:17,200 --> 00:51:19,010
和箭頭鍵。

1171
00:51:19,010 --> 00:51:25,450
>> 如果你有，因為我們今天的演講做了，
該連續運行的程序

1172
00:51:25,450 --> 00:51:29,190
在無限循環，你
可以停止該程序

1173
00:51:29,190 --> 00:51:35,160
通過鍵入控制執行，
即按住Ctrl-C組合。

1174
00:51:35,160 --> 00:51:38,360
而且你可能必須做
這種多次。

1175
00:51:38,360 --> 00:51:40,620
計算機得到遠遠領先於你。

1176
00:51:40,620 --> 00:51:43,380
你有時需要
給它一個嘗試幾次

1177
00:51:43,380 --> 00:51:46,280
之前它實際上會通過。

1178
00:51:46,280 --> 00:51:48,760
>> 您還可以
通過命令排序

1179
00:51:48,760 --> 00:51:54,230
您剛剛輸入使用向上鍵，
箭頭鍵，然後向下箭頭鍵。

1180
00:51:54,230 --> 00:51:57,560
什麼是最有用的是，而不是
打字了長文件名，

1181
00:51:57,560 --> 00:52:02,209
您就可以使用Tab鍵
自動完成幾條指令。

1182
00:52:02,209 --> 00:52:04,750
現在，我們將演示
所有這些，在短短一秒鐘。

1183
00:52:04,750 --> 00:52:06,780
所以，如果你不記得
他們，不要擔心。

1184
00:52:06,780 --> 00:52:10,780
這些事情，你會
拿起和使用，因為我們走。

1185
00:52:10,780 --> 00:52:11,470
確定。

1186
00:52:11,470 --> 00:52:18,830
>> 因此，在C--不像在Scratch--
C是編譯型語言。

1187
00:52:18,830 --> 00:52:23,210
這意味著，我們將採取一個源
file--這是你寫的文字，

1188
00:52:23,210 --> 00:52:26,500
你寫的命令
的printf（）語句，環，

1189
00:52:26,500 --> 00:52:32,580
一切else--，我們要
採取該文件，並把它關閉

1190
00:52:32,580 --> 00:52:34,670
到一個程序調用編譯器。

1191
00:52:34,670 --> 00:52:39,850
>> 那麼編譯器將
你寫的文字

1192
00:52:39,850 --> 00:52:43,270
並把它翻譯成
二進制指令

1193
00:52:43,270 --> 00:52:46,010
您的電腦
實際上是使用。

1194
00:52:46,010 --> 00:52:49,700
這就是所謂的對象
或可執行文件。

1195
00:52:49,700 --> 00:52:55,320
如果你看一下這個文件，你會
看到你寫的代碼。

1196
00:52:55,320 --> 00:52:59,480
如果你看一下這個文件，你會
看個字符的隨機序列

1197
00:52:59,480 --> 00:53:01,680
使沒有任何意義。

1198
00:53:01,680 --> 00:53:03,250
這是因為這是二進制。

1199
00:53:03,250 --> 00:53:05,560
這並不意味著你必須閱讀。

1200
00:53:05,560 --> 00:53:08,690
>> 但是，任何時候你想
運行的東西，你要什麼

1201
00:53:08,690 --> 00:53:13,670
在運行是這個目標文件。

1202
00:53:13,670 --> 00:53:19,110
因此，當我們與這些合作
文件，我們會用C編寫的文​​件

1203
00:53:19,110 --> 00:53:23,400
然後，我們將編譯它，使用
命令類似於make將調用

1204
00:53:23,400 --> 00:53:27,070
編譯器鐺的C語言。

1205
00:53:27,070 --> 00:53:31,530
並且，將產生一個對象
文件，就像一個出來，或在此情況下，

1206
00:53:31,530 --> 00:53:36,580
這個名字，我的文件，我已經把研究。

1207
00:53:36,580 --> 00:53:37,780
好的。

1208
00:53:37,780 --> 00:53:39,790
>> 因此，讓我們真正嘗試這一點。

1209
00:53:39,790 --> 00:53:42,850
所以，我想出了一個例子
是我想嘗試。

1210
00:53:42,850 --> 00:53:47,380
和的事情之一
讓我著迷的動畫。

1211
00:53:47,380 --> 00:53:51,010
所以我們要盡量做到
動畫的一點點

1212
00:53:51,010 --> 00:53:53,760
僅使用ASCII字符。

1213
00:53:53,760 --> 00:53:56,470
人物我們現在可以打印出輕鬆。

1214
00:53:56,470 --> 00:54:00,890
>> 因此，這裡是我的最好的嘗試
創造適合你

1215
00:54:00,890 --> 00:54:07,005
兔子的動畫
通過高草運行。

1216
00:54:07,005 --> 00:54:07,505
他在那裡。

1217
00:54:07,505 --> 00:54:10,150

1218
00:54:10,150 --> 00:54:10,670
確定。

1219
00:54:10,670 --> 00:54:14,050
所以，他沒有跑呢，但他
在高高的草叢站在那裡。

1220
00:54:14,050 --> 00:54:17,810
>> 現在，如果我是一個漫畫家，
在老同學

1221
00:54:17,810 --> 00:54:20,860
版本的動畫，我
會做的是我將產生

1222
00:54:20,860 --> 00:54:23,640
這個兔子在草地上的圖片。

1223
00:54:23,640 --> 00:54:25,390
然後，我會產生
另一個picture--

1224
00:54:25,390 --> 00:54:30,600
另外他們所謂cell--了
有兔子只是稍微移動。

1225
00:54:30,600 --> 00:54:34,870
然後第三個是有
兔子感動得遠一點。

1226
00:54:34,870 --> 00:54:40,610
>> 我會產生一個完整的
序列這些細胞。

1227
00:54:40,610 --> 00:54:44,220
一些地方的兔子已經結束
到左側。

1228
00:54:44,220 --> 00:54:47,050
然後緩緩移動，人們
由一個向中間。

1229
00:54:47,050 --> 00:54:51,120
然後從中間
到正確的。

1230
00:54:51,120 --> 00:54:55,760
如果我當時真的
幸運的話，我可以把它在一起

1231
00:54:55,760 --> 00:54:57,970
我可以動畫。

1232
00:54:57,970 --> 00:55:00,370
還有就是我的兔子
通草運行。

1233
00:55:00,370 --> 00:55:02,310
>> 這是我的偉大的PowerPoint
欺騙的一天。

1234
00:55:02,310 --> 00:55:02,809
確定。

1235
00:55:02,809 --> 00:55:04,760
因此，這是因為它得到很好的。

1236
00:55:04,760 --> 00:55:05,260
確定。

1237
00:55:05,260 --> 00:55:08,455
所以，在這裡，人們有更多的時間，這裡是我們的
兔子在草地上運行。

1238
00:55:08,455 --> 00:55:09,217
>> SPEAKER 19：再次。

1239
00:55:09,217 --> 00:55:11,050
BRIAN SCASSELLATI：一
更多的時間，所有的權利。

1240
00:55:11,050 --> 00:55:11,940
這是你的兔子。

1241
00:55:11,940 --> 00:55:12,940
確定。

1242
00:55:12,940 --> 00:55:15,470
>> 所以，我們今天有什麼
做的是我們要去

1243
00:55:15,470 --> 00:55:21,110
嘗試的過程自動化
的生產這些細胞。

1244
00:55:21,110 --> 00:55:24,135
我們不會完全得到以點
能夠把它們放在一起。

1245
00:55:24,135 --> 00:55:28,900
但是，我們要盡量自動化
產生該序列的過程。

1246
00:55:28,900 --> 00:55:32,900
>> 這是很多東西，
今日動畫等。

1247
00:55:32,900 --> 00:55:36,690
也就是說，你沒有做的事情不一定
通過繪製一切手工製作。

1248
00:55:36,690 --> 00:55:40,610
我們用電腦自動化
零件的過程。

1249
00:55:40,610 --> 00:55:41,110
確定。

1250
00:55:41,110 --> 00:55:47,720
>> 因此，讓我切換
現在我們CS50 IDE。

1251
00:55:47,720 --> 00:55:54,260
和我已經us--，讓創建
我放大這裡一點bit--我已經

1252
00:55:54,260 --> 00:55:58,420
為我們創造了一個出發點。

1253
00:55:58,420 --> 00:56:03,830
>> 我們要求你坐每次
來寫一段代碼，

1254
00:56:03,830 --> 00:56:09,250
我們真正要你做
是我們要求解決的一個問題。

1255
00:56:09,250 --> 00:56:11,810
而這樣，你應該
想想這樣做

1256
00:56:11,810 --> 00:56:17,900
是通過啟動與一些
該解決方案的簡單零件。

1257
00:56:17,900 --> 00:56:21,730
然後從該部分打造出來的。

1258
00:56:21,730 --> 00:56:23,400
這就是我們今天要做的。

1259
00:56:23,400 --> 00:56:27,570
>> 因此，而不是試圖全部一次
寫整個一串代碼這是

1260
00:56:27,570 --> 00:56:30,770
要生產這些
10動畫細胞，

1261
00:56:30,770 --> 00:56:35,506
我們要開始，而不是
與該作品一件。

1262
00:56:35,506 --> 00:56:37,380
然後，我們將構建一個
周圍的那一點點

1263
00:56:37,380 --> 00:56:39,740
多一點，多一點。

1264
00:56:39,740 --> 00:56:42,550
>> 現在談談好事
解決問題這樣

1265
00:56:42,550 --> 00:56:46,716
是，它可以讓你開始
總是與你知道的東西

1266
00:56:46,716 --> 00:56:51,130
作品和介紹一款漸變。

1267
00:56:51,130 --> 00:56:54,090
這是一個偉大的方式
學習如何編寫，

1268
00:56:54,090 --> 00:56:58,590
因為每次你犯了一個
變化，你看到什麼影響了。

1269
00:56:58,590 --> 00:56:59,540
確定。

1270
00:56:59,540 --> 00:57:01,450
>> 因此，這裡是我們的出發點。

1271
00:57:01,450 --> 00:57:01,950
確定。

1272
00:57:01,950 --> 00:57:08,030
所以在我的文件的開頭，
我已經哈希包含（#include）stdio.h中。

1273
00:57:08,030 --> 00:57:12,560
這讓我可以得到
printf（）函數工作。

1274
00:57:12,560 --> 00:57:15,240
>> 我然後我有我的主要功能。

1275
00:57:15,240 --> 00:57:18,760
這看起來還是有點
神秘的或不明顯的一些你。

1276
00:57:18,760 --> 00:57:20,010
這是確定的。

1277
00:57:20,010 --> 00:57:23,190
所有這說的是，
主要功能需要

1278
00:57:23,190 --> 00:57:27,830
沒有arguments--無效的手段
沒有在C.它

1279
00:57:27,830 --> 00:57:29,940
按照慣例，返回一個整數。

1280
00:57:29,940 --> 00:57:33,290
主總是返回一個整數，
通常一個代碼說事

1281
00:57:33,290 --> 00:57:35,071
順利或不順利。

1282
00:57:35,071 --> 00:57:35,570
確定。

1283
00:57:35,570 --> 00:57:39,110
但主要必須具有該
現在構成了我們。

1284
00:57:39,110 --> 00:57:42,080
>> 我再放入三行代碼。

1285
00:57:42,080 --> 00:57:46,760
而且隨著每行
代碼，我已經把評論。

1286
00:57:46,760 --> 00:57:51,340
現在，人們的事情，
我們將堅持這樣做，

1287
00:57:51,340 --> 00:57:55,320
它是如此重要
編程實踐，

1288
00:57:55,320 --> 00:57:57,800
是要始終註釋你的代碼。

1289
00:57:57,800 --> 00:58:02,550
總是在記
英文註釋的東西

1290
00:58:02,550 --> 00:58:06,740
你認為
代碼是應該做的。

1291
00:58:06,740 --> 00:58:11,360
這樣，以後當你回來的
它，你可以看看它，你可以說，

1292
00:58:11,360 --> 00:58:13,800
哦，我記得我是什麼
嘗試做這個。

1293
00:58:13,800 --> 00:58:17,590
或者當TA坐下來與你
盡量幫你在辦公時間，

1294
00:58:17,590 --> 00:58:20,890
他們可以看看這個去，我
看看你想要做什麼，

1295
00:58:20,890 --> 00:58:25,630
而是，這是
到底發生了什麼。

1296
00:58:25,630 --> 00:58:26,130
確定。

1297
00:58:26,130 --> 00:58:30,300
>> 所以，我有三個部分，以我的代碼，
我將首先打印

1298
00:58:30,300 --> 00:58:33,110
一些點在開始。

1299
00:58:33,110 --> 00:58:37,480
然後我會打印出我的
非常看中的兔子。

1300
00:58:37,480 --> 00:58:40,600
然後點在最後的一些位。

1301
00:58:40,600 --> 00:58:45,220
>> 而這三種打印報表應
很熟悉，你在這一點上。

1302
00:58:45,220 --> 00:58:47,350
所有這一切我做的
他們每個人是我

1303
00:58:47,350 --> 00:58:49,780
打印出的字符序列。

1304
00:58:49,780 --> 00:58:51,370
有沒有涉及到的變量。

1305
00:58:51,370 --> 00:58:54,320
一切都只是持平。

1306
00:58:54,320 --> 00:58:55,270
確定。

1307
00:58:55,270 --> 00:59:07,340
>> 所以，如果我現在下去給我terminal--
讓我們來看看，如果我能得到這個回out--

1308
00:59:07,340 --> 00:59:09,370
而我要再次鍵入明確。

1309
00:59:09,370 --> 00:59:12,507
>> 揚聲器20：我們用
雙斜線評論？

1310
00:59:12,507 --> 00:59:14,340
BRIAN SCASSELLATI：可以
使用double--肯定。

1311
00:59:14,340 --> 00:59:16,920
有多種方式來
離開C.一個評論

1312
00:59:16,920 --> 00:59:19,440
的方式是使用雙斜線。

1313
00:59:19,440 --> 00:59:24,910
另一種方法是使用一個斜杠和一個星
然後關閉與一個明星，一個斜線。

1314
00:59:24,910 --> 00:59:26,110
好的。

1315
00:59:26,110 --> 00:59:28,950
>> 首先，我要
從這裡開始瀏覽周圍。

1316
00:59:28,950 --> 00:59:35,350
所以，如果我去我的主目錄，
我已經改變了目錄存在，

1317
00:59:35,350 --> 00:59:40,230
我要去看看，看看有什麼
在該目錄中，LS，列出。

1318
00:59:40,230 --> 00:59:43,230
我要看到我
有兩個子目錄。

1319
00:59:43,230 --> 00:59:47,910
讓我們使這個有點大
在這裡，以便我們都可以看到它。

1320
00:59:47,910 --> 00:59:50,610
>> 我可以看到我
有兩個子目錄。

1321
00:59:50,610 --> 00:59:53,510
我會改變目錄
進入工作區。

1322
00:59:53,510 --> 00:59:58,380
而我要的類型只會出
它的一部分，然後只需按一下Tab鍵。

1323
00:59:58,380 --> 01:00:01,520
而且它會完成剩下的我。

1324
01:00:01,520 --> 01:00:03,370
花式。

1325
01:00:03,370 --> 01:00:04,960
>> 我會看看，看看工作區。

1326
01:00:04,960 --> 01:00:08,431
而現在，我的工作
在超部分

1327
01:00:08,431 --> 01:00:09,680
我們是在教現在。

1328
01:00:09,680 --> 01:00:10,971
所以，我會去到該目錄中。

1329
01:00:10,971 --> 01:00:14,770

1330
01:00:14,770 --> 01:00:15,970
最後，再看看吧。

1331
01:00:15,970 --> 01:00:18,480
而且我有這個文件bunny.c。

1332
01:00:18,480 --> 01:00:20,980
>> 好所以讓我清楚的一次。

1333
01:00:20,980 --> 01:00:24,370
而且我要再次聲明，我now--
仍然留在該目錄

1334
01:00:24,370 --> 01:00:27,540
並且它告訴我，我在
該超部分目錄。

1335
01:00:27,540 --> 01:00:30,690
我要繼續前進，
讓我的程序的兔子。

1336
01:00:30,690 --> 01:00:33,730

1337
01:00:33,730 --> 01:00:38,810
而該命令，使兔子，
雖然聽起來有點古怪，

1338
01:00:38,810 --> 01:00:42,960
還調用鐺編譯器。

1339
01:00:42,960 --> 01:00:46,470
>> 而且它產生的
我的輸出，

1340
01:00:46,470 --> 01:00:52,130
可執行funny--的
可執行文件被稱為兔子。

1341
01:00:52,130 --> 01:00:52,700
確定。

1342
01:00:52,700 --> 01:00:56,700
我可以再和這聽起來
更糟的是，執行兔子。

1343
01:00:56,700 --> 01:00:59,360

1344
01:00:59,360 --> 01:01:00,680
確定。

1345
01:01:00,680 --> 01:01:03,150
讓我們看看會發生什麼。

1346
01:01:03,150 --> 01:01:04,527
確定。

1347
01:01:04,527 --> 01:01:06,360
這是一點點
我所期待的。

1348
01:01:06,360 --> 01:01:11,290
我有我的兔子圖片在那裡，
樣的，但我希望它所有的本身。

1349
01:01:11,290 --> 01:01:13,186
我錯過了什麼？

1350
01:01:13,186 --> 01:01:14,478
>> 揚聲器21：斜線L或斜線ñ。

1351
01:01:14,478 --> 01:01:15,602
BRIAN SCASSELLATI：斬ñ。

1352
01:01:15,602 --> 01:01:16,580
確定。

1353
01:01:16,580 --> 01:01:18,800
因此，讓我們回到這裡。

1354
01:01:18,800 --> 01:01:20,330
我會離開的。

1355
01:01:20,330 --> 01:01:23,320
我會重新回到這一個。

1356
01:01:23,320 --> 01:01:27,720
讓我們來看看現在
從我的主要功能在這裡。

1357
01:01:27,720 --> 01:01:29,280
>> 所以，我應該怎麼辦？

1358
01:01:29,280 --> 01:01:30,465
我想結束就行了。

1359
01:01:30,465 --> 01:01:34,020

1360
01:01:34,020 --> 01:01:35,800
所以，我加入了註釋。

1361
01:01:35,800 --> 01:01:38,430
我會在一個printf（）。

1362
01:01:38,430 --> 01:01:41,350
而且我有什麼投入？

1363
01:01:41,350 --> 01:01:41,890
/ N。

1364
01:01:41,890 --> 01:01:43,480
確定。

1365
01:01:43,480 --> 01:01:46,040
我有什麼用結束了嗎？

1366
01:01:46,040 --> 01:01:47,100
分號。

1367
01:01:47,100 --> 01:01:48,730
好的。

1368
01:01:48,730 --> 01:01:52,880
>> 現在的人真的
重要的事情是要確保

1369
01:01:52,880 --> 01:01:56,720
每當你做出改變
在你的代碼，你保存它。

1370
01:01:56,720 --> 01:02:01,380
如果您還沒有保存你的代碼，你
要注意到一個小星星在那裡。

1371
01:02:01,380 --> 01:02:03,420
這星說你
已經沒救了這些代碼。

1372
01:02:03,420 --> 01:02:07,790
>> 如果我現在編譯它，它不是
要反映的任何更改，

1373
01:02:07,790 --> 01:02:11,680
因為編譯器查看文件
這是磁盤，而不是只是文件上

1374
01:02:11,680 --> 01:02:13,790
在編輯器中打開。

1375
01:02:13,790 --> 01:02:14,290
好的。

1376
01:02:14,290 --> 01:02:20,830
>> 因此，讓我們將它保存，然後我們會去
對上到這裡，回來了。

1377
01:02:20,830 --> 01:02:24,670
下來到我的終端。

1378
01:02:24,670 --> 01:02:27,193
而讓我們再次清除空間。

1379
01:02:27,193 --> 01:02:30,690

1380
01:02:30,690 --> 01:02:35,760
>> 我們可以繼續前進，多了一個
時間讓我們的兔子計劃。

1381
01:02:35,760 --> 01:02:40,180
並執行兔子。

1382
01:02:40,180 --> 01:02:42,500
這也不起作用。

1383
01:02:42,500 --> 01:02:43,950
錯誤的斜線。

1384
01:02:43,950 --> 01:02:52,280
所以，如果你看一下我有，我把
/ N在那裡，但我有錯的斜線。

1385
01:02:52,280 --> 01:02:56,190
>> 一切你的電腦
做的是非常明確的。

1386
01:02:56,190 --> 01:02:57,230
OK？

1387
01:02:57,230 --> 01:03:01,250
標點符號的一個小錯誤，
突然間，你沒有得到你想要的。

1388
01:03:01,250 --> 01:03:01,750
好的。

1389
01:03:01,750 --> 01:03:03,740
因此，讓我們放大出來了。

1390
01:03:03,740 --> 01:03:04,410
我們會回去。

1391
01:03:04,410 --> 01:03:07,930
那麼做出非常快修。

1392
01:03:07,930 --> 01:03:09,270
我們會把正確的斜線研究。

1393
01:03:09,270 --> 01:03:10,570
我們會保存。

1394
01:03:10,570 --> 01:03:13,410
我們會放大。

1395
01:03:13,410 --> 01:03:16,730
>> 出於某種原因，這不是
快樂，但讓我們繼續

1396
01:03:16,730 --> 01:03:19,850
我們將回到終端在這裡。

1397
01:03:19,850 --> 01:03:22,940
它清除掉。

1398
01:03:22,940 --> 01:03:24,880
我們將進行放大。

1399
01:03:24,880 --> 01:03:28,410
而一個更多的時間，我們會讓兔子。

1400
01:03:28,410 --> 01:03:32,360
而現在果然，它的工作原理。

1401
01:03:32,360 --> 01:03:33,240
萬歲。

1402
01:03:33,240 --> 01:03:34,300
確定。

1403
01:03:34,300 --> 01:03:39,580
>> 因此，讓我們努力使今天
多了幾分一般。

1404
01:03:39,580 --> 01:03:46,750
讓我們來看看，而不僅僅是
打印一個特定的框架，

1405
01:03:46,750 --> 01:03:49,610
讓我們來看看，如果我們可以讓這個
這樣我們就可以得到所有10

1406
01:03:49,610 --> 01:03:52,960
這些動畫幀
我們希望有。

1407
01:03:52,960 --> 01:03:56,550
如此反复，讓我們
此一步驟的時間。

1408
01:03:56,550 --> 01:03:59,900
>> 讓我們先來概括它，不是
讓我做的所有的幀，

1409
01:03:59,900 --> 01:04:03,990
但讓​​我做任何一
框架，我可能想。

1410
01:04:03,990 --> 01:04:05,920
所以，有什麼區別
在幀之間？

1411
01:04:05,920 --> 01:04:07,377
是兔子一樣嗎？

1412
01:04:07,377 --> 01:04:07,960
聽眾：是的。

1413
01:04:07,960 --> 01:04:08,390
BRIAN SCASSELLATI：是的。

1414
01:04:08,390 --> 01:04:09,370
有什麼區別？

1415
01:04:09,370 --> 01:04:10,246
>> 聽眾：位置。

1416
01:04:10,246 --> 01:04:11,870
BRIAN SCASSELLATI：它的位置，對不對？

1417
01:04:11,870 --> 01:04:15,590
以及如何控制它的位置？

1418
01:04:15,590 --> 01:04:17,340
多少點我
將在開始

1419
01:04:17,340 --> 01:04:19,048
而且我有多少點
將在末端。

1420
01:04:19,048 --> 01:04:21,970
所以，我有五處
開始和五個在末端。

1421
01:04:21,970 --> 01:04:28,320
>> 讓我們來替換五連一個for循環。

1422
01:04:28,320 --> 01:04:29,380
確定。

1423
01:04:29,380 --> 01:04:32,330
而且我要創建一個用於
環現在會說，

1424
01:04:32,330 --> 01:04:37,800
我要打印一些數
的圓點在開始。

1425
01:04:37,800 --> 01:04:39,600
我將使用一個變量。

1426
01:04:39,600 --> 01:04:44,150
比方說，怎麼樣我作為
計數器在我的循環。

1427
01:04:44,150 --> 01:04:47,200
而我要聲明它往上頂。

1428
01:04:47,200 --> 01:04:49,360
>> 然後在for循環
我需要做三件事情。

1429
01:04:49,360 --> 01:04:52,340
我需要做的第一件事情
是我需要初始化我。

1430
01:04:52,340 --> 01:04:56,570
我應該怎麼初始化
它開始呢？

1431
01:04:56,570 --> 01:04:57,160
0。

1432
01:04:57,160 --> 01:04:58,310
確定。

1433
01:04:58,310 --> 01:05:00,950
>> 然後，我需要說的，有什麼
終止條件？

1434
01:05:00,950 --> 01:05:03,020
什麼時候應該停下來？

1435
01:05:03,020 --> 01:05:05,983
那麼多少個點你
要打印在這一個？

1436
01:05:05,983 --> 01:05:06,921
>> 聽眾：五。

1437
01:05:06,921 --> 01:05:08,170
BRIAN SCASSELLATI：五了嗎？

1438
01:05:08,170 --> 01:05:10,650
怎麼樣讓我們做什麼
不同的，我們做了五位。

1439
01:05:10,650 --> 01:05:12,584
讓我們表明，它的不同。

1440
01:05:12,584 --> 01:05:13,250
揚聲器22：兩個。

1441
01:05:13,250 --> 01:05:13,580
BRIAN SCASSELLATI：兩個。

1442
01:05:13,580 --> 01:05:14,080
確定。

1443
01:05:14,080 --> 01:05:17,760
所以，如果我想兩個點，
我應該放在這裡？

1444
01:05:17,760 --> 01:05:19,140
>> 聽眾：三。

1445
01:05:19,140 --> 01:05:20,530
>> BRIAN SCASSELLATI：三。

1446
01:05:20,530 --> 01:05:21,400
確定。

1447
01:05:21,400 --> 01:05:24,220
多少次是
要辦理什麼手續？

1448
01:05:24,220 --> 01:05:28,469
這是怎麼回事要經過
三次，0，1，和圖2，是嗎？

1449
01:05:28,469 --> 01:05:30,010
好吧，讓我們回到到兩個。

1450
01:05:30,010 --> 01:05:31,570
現在，我們會得到兩個點。

1451
01:05:31,570 --> 01:05:35,800
什麼做我想做的每一
一次我去通過循環？

1452
01:05:35,800 --> 01:05:38,657
什麼必須改變
每次我辦理什麼手續？

1453
01:05:38,657 --> 01:05:39,850
>> 揚聲器23：添加一個點。

1454
01:05:39,850 --> 01:05:41,020
>> BRIAN SCASSELLATI：我一定要堅持下去。

1455
01:05:41,020 --> 01:05:41,978
我要加一個點。

1456
01:05:41,978 --> 01:05:45,310
我要打印一個點，
通過每次循環。

1457
01:05:45,310 --> 01:05:49,990
但我怎麼保存，如何跟踪
很多次，我經歷過的循環？

1458
01:05:49,990 --> 01:05:53,260
我用我，那
變量，該計數器。

1459
01:05:53,260 --> 01:05:57,110
>> 所以每次經過，我要去
一個遞增計數器。

1460
01:05:57,110 --> 01:06:00,670
現在，這是相同的
我的話說：I = I + 1。

1461
01:06:00,670 --> 01:06:01,210
這是確定的。

1462
01:06:01,210 --> 01:06:04,653
我能做到這一點that--我喜歡
速記，所以我會說我++。

1463
01:06:04,653 --> 01:06:07,190

1464
01:06:07,190 --> 01:06:08,370
確定。

1465
01:06:08,370 --> 01:06:10,680
>> 讓我們做同樣的事情
這兒的底部。

1466
01:06:10,680 --> 01:06:11,846
那種只有我做了一個。

1467
01:06:11,846 --> 01:06:13,990
我將讓你們
完全做到這一點。

1468
01:06:13,990 --> 01:06:14,260
好的。

1469
01:06:14,260 --> 01:06:15,426
>> 所以，我應該寫在這裡？

1470
01:06:15,426 --> 01:06:17,170
這是我的for循環。

1471
01:06:17,170 --> 01:06:23,162
我會做一個printf（），我要去
為讓這個我只打印一個點

1472
01:06:23,162 --> 01:06:25,740
在該底部。

1473
01:06:25,740 --> 01:06:27,740
>> 我應該怎麼寫
這裡面現在循環？

1474
01:06:27,740 --> 01:06:30,897

1475
01:06:30,897 --> 01:06:33,948
好了，首先是什麼
變量我應該使用？

1476
01:06:33,948 --> 01:06:35,430
>> 揚聲器24：J-。

1477
01:06:35,430 --> 01:06:36,880
>> BRIAN SCASSELLATI：我可以用學家

1478
01:06:36,880 --> 01:06:38,040
我可以使用相同的嗎？

1479
01:06:38,040 --> 01:06:39,961
我還可以再用嗎？

1480
01:06:39,961 --> 01:06:40,460
是啊。

1481
01:06:40,460 --> 01:06:45,531
這是確定的，因為是
我使用了這裡，

1482
01:06:45,531 --> 01:06:47,780
我不要再當需要他們
我得到了這一點。

1483
01:06:47,780 --> 01:06:52,240

1484
01:06:52,240 --> 01:06:53,790
>> 所以，我應該初始化我來？

1485
01:06:53,790 --> 01:06:56,675

1486
01:06:56,675 --> 01:06:57,300
揚聲器25：10。

1487
01:06:57,300 --> 01:06:58,567
BRIAN SCASSELLATI：0。

1488
01:06:58,567 --> 01:06:59,400
我應該怎麼檢查？

1489
01:06:59,400 --> 01:07:02,960
多少點我現在需要在最後
如果我有兩個點的開始？

1490
01:07:02,960 --> 01:07:05,820

1491
01:07:05,820 --> 01:07:09,165
我需要8月末，還等什麼
我應該檢查一下，我少than--

1492
01:07:09,165 --> 01:07:12,645
>> 聽眾：七，八，九。

1493
01:07:12,645 --> 01:07:14,020
BRIAN SCASSELLATI：聽說七人。

1494
01:07:14,020 --> 01:07:14,810
我聽到了八強。

1495
01:07:14,810 --> 01:07:15,970
我聽見九歲。

1496
01:07:15,970 --> 01:07:16,470
確定。

1497
01:07:16,470 --> 01:07:19,540
所以我們都在正確的
ball--傑森說：10。

1498
01:07:19,540 --> 01:07:21,550
確定。

1499
01:07:21,550 --> 01:07:25,920
>> 如果我需要兩個點的
第一位的，又有多少呢

1500
01:07:25,920 --> 01:07:30,170
我 - 我需要8個點的
最後埃德蒙頓我放了兩個加上面，

1501
01:07:30,170 --> 01:07:31,743
我應該放下下面？

1502
01:07:31,743 --> 01:07:32,570
>> 聽眾：八。

1503
01:07:32,570 --> 01:07:33,611
>> BRIAN SCASSELLATI：八。

1504
01:07:33,611 --> 01:07:35,695
因為這是要
算上0到7。

1505
01:07:35,695 --> 01:07:38,490
這就是通過環路八次。

1506
01:07:38,490 --> 01:07:38,990
確定。

1507
01:07:38,990 --> 01:07:41,774
什麼我必須做底？

1508
01:07:41,774 --> 01:07:42,670
>> 觀眾：我++。

1509
01:07:42,670 --> 01:07:44,400
>> BRIAN SCASSELLATI：我++。

1510
01:07:44,400 --> 01:07:45,440
好的。

1511
01:07:45,440 --> 01:07:48,260
所以，這看起來相當不錯那裡。

1512
01:07:48,260 --> 01:07:50,620
讓我們來試試吧，讓我們看看會發生什麼。

1513
01:07:50,620 --> 01:07:51,450
確定。

1514
01:07:51,450 --> 01:07:53,770
所以我們要保存它。

1515
01:07:53,770 --> 01:07:54,940
尼斯和保存。

1516
01:07:54,940 --> 01:07:56,910
>> 我們將放大出來。

1517
01:07:56,910 --> 01:07:58,220
我們將嘗試在這裡的終端。

1518
01:07:58,220 --> 01:08:01,440

1519
01:08:01,440 --> 01:08:02,970
我們將進行放大。

1520
01:08:02,970 --> 01:08:05,416
哎呀。

1521
01:08:05,416 --> 01:08:09,990
我們會，更多的時間，
讓我們的兔子計劃。

1522
01:08:09,990 --> 01:08:14,460
並繼續前進，執行兔子。

1523
01:08:14,460 --> 01:08:15,980
它就在那裡。

1524
01:08:15,980 --> 01:08:17,710
>> 因此，有我們的兔子。

1525
01:08:17,710 --> 01:08:25,130
其中，它有兩個點的開頭
和8個點出在末端。

1526
01:08:25,130 --> 01:08:27,540
大家還我？

1527
01:08:27,540 --> 01:08:28,770
確定。

1528
01:08:28,770 --> 01:08:29,580
>> 因此，我們建立起來。

1529
01:08:29,580 --> 01:08:33,000
我們造成了一輛小兔子，
一個特定幀。

1530
01:08:33,000 --> 01:08:36,229
現在，我們已經能夠
概括說來構建

1531
01:08:36,229 --> 01:08:38,390
更，不同種幀。

1532
01:08:38,390 --> 01:08:42,399
>> 現在，讓我們繼續前進，並有
它產生的不只是一個框架，

1533
01:08:42,399 --> 01:08:46,290
但讓​​我們產生10
幀，在那裡我們慢慢地

1534
01:08:46,290 --> 01:08:50,569
讓兔子把所有
橫跨字段的方式。

1535
01:08:50,569 --> 01:08:51,430
好的。

1536
01:08:51,430 --> 01:08:53,660
>> 讓我們回去。

1537
01:08:53,660 --> 01:08:54,839
我們會盡力了。

1538
01:08:54,839 --> 01:09:00,680

1539
01:09:00,680 --> 01:09:02,830
那麼什麼才是我真正需要改變這裡的？

1540
01:09:02,830 --> 01:09:06,139

1541
01:09:06,139 --> 01:09:07,180
我需要做什麼改變？

1542
01:09:07,180 --> 01:09:10,638
>> 揚聲器26：首先，您需要
改變點的最大數量

1543
01:09:10,638 --> 01:09:11,626
在開始。

1544
01:09:11,626 --> 01:09:16,850
因為如果我們正在做的10點，
這將需要多達規模。

1545
01:09:16,850 --> 01:09:17,850
BRIAN SCASSELLATI：是的。

1546
01:09:17,850 --> 01:09:23,760
所以，現在我有幾分是硬
要始終做到兩個點開頭

1547
01:09:23,760 --> 01:09:27,890
始終做到8個點底。

1548
01:09:27,890 --> 01:09:30,660
>> 我想建一個循環，對不對？

1549
01:09:30,660 --> 01:09:33,290
因為我不希望
建立只是一個兔子圖片，

1550
01:09:33,290 --> 01:09:37,140
我想建立10兔子的照片。

1551
01:09:37,140 --> 01:09:41,500
所以，我需要建立另一個循環，
當我經過這個循環，

1552
01:09:41,500 --> 01:09:44,660
我想換多少
點我打印開頭

1553
01:09:44,660 --> 01:09:50,529
多少點我打印末，
基於通過環路循環

1554
01:09:50,529 --> 01:09:52,270
我研究。

1555
01:09:52,270 --> 01:09:52,770
好的。

1556
01:09:52,770 --> 01:09:54,430
>> 因此，讓我們得到另一個櫃檯。

1557
01:09:54,430 --> 01:09:58,142
別人的面前說Ĵ，
所以我們會再拍學家

1558
01:09:58,142 --> 01:10:00,100
而現在，我們要
for循環另建。

1559
01:10:00,100 --> 01:10:02,650

1560
01:10:02,650 --> 01:10:06,200
>> 什麼是循環中去？

1561
01:10:06,200 --> 01:10:09,060
這東西已去
內循環，對不對？

1562
01:10:09,060 --> 01:10:11,190
難道兔子有
走在循環中？

1563
01:10:11,190 --> 01:10:13,390
我需要在一個小兔子
其中每個10幀？

1564
01:10:13,390 --> 01:10:14,099
>> 聽眾：嗯。

1565
01:10:14,099 --> 01:10:15,098
BRIAN SCASSELLATI：是的。

1566
01:10:15,098 --> 01:10:17,250
我想在每一個兔子
在10幀的，對不對？

1567
01:10:17,250 --> 01:10:20,531
怎麼樣的圓點
最後，我需要嗎？

1568
01:10:20,531 --> 01:10:21,030
確定。

1569
01:10:21,030 --> 01:10:22,550
>> 所以，我要縮進所有的人。

1570
01:10:22,550 --> 01:10:25,110
我要強調的是
這一點，我會打標籤。

1571
01:10:25,110 --> 01:10:28,590
這就是將他們推向全國各地
一點點，這樣很容易讓我

1572
01:10:28,590 --> 01:10:32,010
看看有什麼環路中。

1573
01:10:32,010 --> 01:10:33,710
然後，我將結束它。

1574
01:10:33,710 --> 01:10:35,850
比方說。

1575
01:10:35,850 --> 01:10:36,430
OK？

1576
01:10:36,430 --> 01:10:39,230
>> 現在，在該循環
我building--哎呦，

1577
01:10:39,230 --> 01:10:43,810
做出這樣你就可以see--
我有我的計數器j。

1578
01:10:43,810 --> 01:10:45,630
我會在0開始的。

1579
01:10:45,630 --> 01:10:47,829
多少次，我想
要經過這個循環？

1580
01:10:47,829 --> 01:10:48,620
聽眾：10次。

1581
01:10:48,620 --> 01:10:49,786
布萊恩SCASSELLATI：10次。

1582
01:10:49,786 --> 01:10:51,402
那麼什麼號碼，我應該把在這裡？

1583
01:10:51,402 --> 01:10:52,880
>> 聽眾：9，10。

1584
01:10:52,880 --> 01:10:55,600
>> 布萊恩SCASSELLATI：9，10，
有人在得說11了吧？

1585
01:10:55,600 --> 01:10:58,190

1586
01:10:58,190 --> 01:11:01,585
我想兩個點前
並把小於2我。

1587
01:11:01,585 --> 01:11:03,810
我想8個點，
我把小於8我。

1588
01:11:03,810 --> 01:11:06,950
現在我想通過10
次，所以我把Ĵ少than--

1589
01:11:06,950 --> 01:11:07,590
>> 聽眾：10。

1590
01:11:07,590 --> 01:11:08,610
>> BRIAN SCASSELLATI：10。

1591
01:11:08,610 --> 01:11:10,150
在那裡，我們走了。

1592
01:11:10,150 --> 01:11:13,360
而我做底到j是什麼？

1593
01:11:13,360 --> 01:11:15,310
++，增加它。

1594
01:11:15,310 --> 01:11:16,230
確定。

1595
01:11:16,230 --> 01:11:21,500
現在，這裡的棘手的部分，什麼是
會發生什麼，現在如果我這樣做？

1596
01:11:21,500 --> 01:11:24,537
我要去打印10幀？

1597
01:11:24,537 --> 01:11:26,370
SPEAKER 27：我認為，
他們都會是相同的。

1598
01:11:26,370 --> 01:11:28,453
BRIAN SCASSELLATI：他們會
都是一樣的，對不對？

1599
01:11:28,453 --> 01:11:31,750
因為所有的人都仍在繼續
把兩個點開頭。

1600
01:11:31,750 --> 01:11:34,162
但我不希望它們都
有兩個點的開始。

1601
01:11:34,162 --> 01:11:35,870
多少點我
想在開始？

1602
01:11:35,870 --> 01:11:39,097

1603
01:11:39,097 --> 01:11:40,020
>> 聽眾：更改。

1604
01:11:40,020 --> 01:11:42,840
>> BRIAN SCASSELLATI：我
想要改變，對不對？

1605
01:11:42,840 --> 01:11:46,588
所以，我有什麼在這裡，正在改變
每次循環經歷？

1606
01:11:46,588 --> 01:11:48,242
>> 聽眾：的點數，J。

1607
01:11:48,242 --> 01:11:49,950
BRIAN SCASSELLATI：J-，
點的數量。

1608
01:11:49,950 --> 01:11:54,782
所以，我可以改變這是學家

1609
01:11:54,782 --> 01:11:59,190
第一次通過
環，那是什麼打算呢？

1610
01:11:59,190 --> 01:12:01,700
我該怎麼設置J可在第一？

1611
01:12:01,700 --> 01:12:02,420
>> 聽眾：0。

1612
01:12:02,420 --> 01:12:05,700
>> BRIAN SCASSELLATI：那麼有多少
次我該怎麼做呢？

1613
01:12:05,700 --> 01:12:06,750
0。

1614
01:12:06,750 --> 01:12:11,750
通過循環，J的第二時間
將是1，因為我加一。

1615
01:12:11,750 --> 01:12:14,180
多少點我要去打印？

1616
01:12:14,180 --> 01:12:15,100
1。

1617
01:12:15,100 --> 01:12:19,904
通過循環的第三次，
多少點我要去打印？

1618
01:12:19,904 --> 01:12:20,587
>> 聽眾：三。

1619
01:12:20,587 --> 01:12:22,170
BRIAN SCASSELLATI：J-將是3。

1620
01:12:22,170 --> 01:12:24,890
多少點我要去打印？

1621
01:12:24,890 --> 01:12:26,817
哦，對不起，J將是2。

1622
01:12:26,817 --> 01:12:28,233
多少點我要去打印？

1623
01:12:28,233 --> 01:12:28,980
>> 聽眾：2。

1624
01:12:28,980 --> 01:12:29,855
>> BRIAN SCASSELLATI：2。

1625
01:12:29,855 --> 01:12:32,460
好了，所以我要保持
遞增的，因為我們走。

1626
01:12:32,460 --> 01:12:33,460
如何向下跌破？

1627
01:12:33,460 --> 01:12:34,310
善有善報這兒？

1628
01:12:34,310 --> 01:12:38,080
我不想8總
在結束了嗎？

1629
01:12:38,080 --> 01:12:39,269
>> 揚聲器28：10。

1630
01:12:39,269 --> 01:12:40,685
BRIAN SCASSELLATI：我想10點？

1631
01:12:40,685 --> 01:12:43,440

1632
01:12:43,440 --> 01:12:44,620
我希望它改變了。

1633
01:12:44,620 --> 01:12:47,469
所以，我怎麼想它改變？

1634
01:12:47,469 --> 01:12:49,167
>> 聽眾：[聽不清]。

1635
01:12:49,167 --> 01:12:51,750
BRIAN SCASSELLATI：嗯，如果我
有五個點在開始，

1636
01:12:51,750 --> 01:12:53,293
多少個點的我在最後得到什麼呢？

1637
01:12:53,293 --> 01:12:54,020
>> 聽眾：五。

1638
01:12:54,020 --> 01:12:55,630
>> 布賴恩SCASSELLATI：如果我有
6點之初，

1639
01:12:55,630 --> 01:12:56,875
多少才能獲得在結束了嗎？

1640
01:12:56,875 --> 01:12:57,500
聽眾：四。

1641
01:12:57,500 --> 01:12:58,950
布賴恩SCASSELLATI：如果我有
7點在一開始，

1642
01:12:58,950 --> 01:13:00,204
多少才能獲得在結束了嗎？

1643
01:13:00,204 --> 01:13:00,870
聽眾：三。

1644
01:13:00,870 --> 01:13:03,161
布賴恩SCASSELLATI：如果我
有Ĵ點之初，

1645
01:13:03,161 --> 01:13:04,790
多少才能獲得在結束了嗎？

1646
01:13:04,790 --> 01:13:07,520
10-j的。

1647
01:13:07,520 --> 01:13:08,650
確定。

1648
01:13:08,650 --> 01:13:10,390
所以讓我們嘗試了這一點。

1649
01:13:10,390 --> 01:13:13,180
>> 所以，我要拯救我們的兔子計劃。

1650
01:13:13,180 --> 01:13:16,270
我們再次將縮小。

1651
01:13:16,270 --> 01:13:19,090
我們將去到我們的終端。

1652
01:13:19,090 --> 01:13:20,180
我們將清除它。

1653
01:13:20,180 --> 01:13:23,410
並進行放大。

1654
01:13:23,410 --> 01:13:26,410
我們將讓我們的兔子節目，再次。

1655
01:13:26,410 --> 01:13:27,690
我們將執行它。

1656
01:13:27,690 --> 01:13:30,462

1657
01:13:30,462 --> 01:13:32,090
嗯，哦。

1658
01:13:32,090 --> 01:13:34,580
>> 等一下，讓我們縮小。

1659
01:13:34,580 --> 01:13:36,860
難道我得到10幀？

1660
01:13:36,860 --> 01:13:38,970
那麼，有多少兔子
我看到那裡？

1661
01:13:38,970 --> 01:13:43,330
1，2，3，4，5，6，7，8，9，10。

1662
01:13:43,330 --> 01:13:44,820
我得到了10幀。

1663
01:13:44,820 --> 01:13:46,375
他們都是一樣的嗎？

1664
01:13:46,375 --> 01:13:47,000
聽眾：是的。

1665
01:13:47,000 --> 01:13:48,740
第

1666
01:13:48,740 --> 01:13:50,000
>> BRIAN SCASSELLATI：沒有。

1667
01:13:50,000 --> 01:13:55,050
這第一位的，
兔子是遠在左邊。

1668
01:13:55,050 --> 01:13:57,541
而在這裡，兔子是遠在

1669
01:13:57,541 --> 01:13:58,290
SPEAKER 29：對。

1670
01:13:58,290 --> 01:14:00,502
BRIAN SCASSELLATI：那麼，
我怎麼忘了怎麼辦？

1671
01:14:00,502 --> 01:14:01,750
揚聲器30：啟動一個新行。

1672
01:14:01,750 --> 01:14:04,041
BRIAN SCASSELLATI：我忘了
開始一個新的生產線，再次。

1673
01:14:04,041 --> 01:14:05,270
同樣的錯誤，我之前所做的。

1674
01:14:05,270 --> 01:14:07,120
好吧，讓我們去解決這個問題。

1675
01:14:07,120 --> 01:14:11,690
現在，我還有代碼
在那裡做一個新的生產線。

1676
01:14:11,690 --> 01:14:13,899
為什麼不工作？

1677
01:14:13,899 --> 01:14:15,440
揚聲器31：這不是在循環中。

1678
01:14:15,440 --> 01:14:17,710
BRIAN SCASSELLATI：哦，
它不是在循環中。

1679
01:14:17,710 --> 01:14:18,520
這是正確的。

1680
01:14:18,520 --> 01:14:20,150
它在這裡坐在外面。

1681
01:14:20,150 --> 01:14:23,470

1682
01:14:23,470 --> 01:14:29,050
而for循環就是一切
就是這樣的文字裡。

1683
01:14:29,050 --> 01:14:35,500
>> 所以，我要動
這裡面的for循環。

1684
01:14:35,500 --> 01:14:39,410
我將標籤在它前面
表明它在正確的地方。

1685
01:14:39,410 --> 01:14:42,020
而現在，我們將重新保存。

1686
01:14:42,020 --> 01:14:44,350
我們會縮小。

1687
01:14:44,350 --> 01:14:45,770
我們將切換到我們的終端。

1688
01:14:45,770 --> 01:14:48,330

1689
01:14:48,330 --> 01:14:50,360
進行放大。

1690
01:14:50,360 --> 01:14:54,050
我們將重塑我們的兔子計劃。

1691
01:14:54,050 --> 01:14:59,070
而現在，現在我們已經得到了我們的10幀。

1692
01:14:59,070 --> 01:15:00,190
>> [掌聲]

1693
01:15:00,190 --> 01:15:02,120
>> BRIAN SCASSELLATI：OK。

1694
01:15:02,120 --> 01:15:04,080
所以。

1695
01:15:04,080 --> 01:15:08,370
我們的嵌套這裡的for循環。

1696
01:15:08,370 --> 01:15:13,140
我們能夠生成在
我有多少點希望內環

1697
01:15:13,140 --> 01:15:15,320
打印在開始的時候，在末端。

1698
01:15:15,320 --> 01:15:21,570
和外環控制
多少幀我是建設。

1699
01:15:21,570 --> 01:15:26,340
我們從一個小小的
問題的核心，

1700
01:15:26,340 --> 01:15:30,320
我們從該點建造出來。

1701
01:15:30,320 --> 01:15:30,820
好的。

1702
01:15:30,820 --> 01:15:33,500
>> 讓我們做一個步驟。

1703
01:15:33,500 --> 01:15:35,040
你準備好了嗎？

1704
01:15:35,040 --> 01:15:38,800
有一件事在這兒，
樣的，我們實際上已經得到了

1705
01:15:38,800 --> 01:15:42,180
更多的複雜性比我們所需要的。

1706
01:15:42,180 --> 01:15:44,700
讓我們一起來看看。

1707
01:15:44,700 --> 01:15:52,050
因此，在我們的兔子節目，
如果我縮小這裡，

1708
01:15:52,050 --> 01:15:54,980
我實際上做一些相同的
事情一遍又一遍。

1709
01:15:54,980 --> 01:15:59,032
我該怎麼做那類的
同樣的事情重複了兩次？

1710
01:15:59,032 --> 01:16:00,310
>> 揚聲器32：打印點。

1711
01:16:00,310 --> 01:16:03,526
>> BRIAN SCASSELLATI：是
我打印這些點的兩倍。

1712
01:16:03,526 --> 01:16:05,710
說真的，我應該有
此評論到這裡。

1713
01:16:05,710 --> 01:16:09,037
我打印了一些點在
開始，一直在這裡。

1714
01:16:09,037 --> 01:16:10,620
然後，我打印了一些點底。

1715
01:16:10,620 --> 01:16:14,694
我做那種完全一樣的東西。

1716
01:16:14,694 --> 01:16:17,110
我們要開始
致力於在未來幾週內

1717
01:16:17,110 --> 01:16:23,440
是能夠利用這些區塊
我們使用了一遍又一遍代碼，

1718
01:16:23,440 --> 01:16:25,800
並通過一個過程
所謂抽象，

1719
01:16:25,800 --> 01:16:31,100
我們要拉他們出來，
一旦寫出來，這樣我們就可以

1720
01:16:31,100 --> 01:16:35,130
一遍又一遍重複使用它們。

1721
01:16:35,130 --> 01:16:37,210
因此，讓我們試試吧。

1722
01:16:37,210 --> 01:16:38,220
準備好了嗎？

1723
01:16:38,220 --> 01:16:42,200
>> 我們將利用這個代碼塊。

1724
01:16:42,200 --> 01:16:45,280
而且我打算把它救出來。

1725
01:16:45,280 --> 01:16:50,530
而且我要define--
向下在底部，

1726
01:16:50,530 --> 01:16:53,130
我打算寫一個新的功能。

1727
01:16:53,130 --> 01:16:54,750
它不會返回任何東西。

1728
01:16:54,750 --> 01:16:58,550
而且我要叫它printDots。

1729
01:16:58,550 --> 01:17:01,530
>> 這將需要一個
參數，一個整數，

1730
01:17:01,530 --> 01:17:04,920
說howManyDots我應打印。

1731
01:17:04,920 --> 01:17:09,310

1732
01:17:09,310 --> 01:17:17,720
而不是打印Ĵ點和現在，我
打印告訴howManyDots我應打印。

1733
01:17:17,720 --> 01:17:21,581
>> 而且還有一個小問題在這裡。

1734
01:17:21,581 --> 01:17:22,580
任何人都知道它是什麼？

1735
01:17:22,580 --> 01:17:27,270

1736
01:17:27,270 --> 01:17:31,505
我有什麼說的上市
在這裡沒有定義？

1737
01:17:31,505 --> 01:17:34,165

1738
01:17:34,165 --> 01:17:35,090
>> 聽眾：[聽不清]

1739
01:17:35,090 --> 01:17:37,465
>> BRIAN SCASSELLATI：那麼怎麼樣
多點是指直到

1740
01:17:37,465 --> 01:17:40,584
在這裡，但我使用的變量i。

1741
01:17:40,584 --> 01:17:43,750
所以，我要採取的變量i
我要去下來定義它在這裡

1742
01:17:43,750 --> 01:17:44,610
代替。

1743
01:17:44,610 --> 01:17:49,683
>> 所以，現在它要stay--哎呀，
得到了大寫鎖定somehow--我

1744
01:17:49,683 --> 01:17:52,060
要保持我倒在這裡。

1745
01:17:52,060 --> 01:17:57,050
>> 所以，現在這裡是我的小功能
或子程序，它說，

1746
01:17:57,050 --> 01:18:00,640
多少點我要去打印？

1747
01:18:00,640 --> 01:18:05,300
而且它會通過這個循環，
一遍又一遍打印出來。

1748
01:18:05,300 --> 01:18:10,940
>> 那麼我可以修改我的程序在這裡。

1749
01:18:10,940 --> 01:18:12,540
而且我怎麼調用該函數？

1750
01:18:12,540 --> 01:18:13,960
printDots。

1751
01:18:13,960 --> 01:18:17,060
所以，我會打電話給printDots。

1752
01:18:17,060 --> 01:18:21,530
多少點我要打印
第一次小兔過嗎？

1753
01:18:21,530 --> 01:18:22,030
聽眾：J-。

1754
01:18:22,030 --> 01:18:23,230
BRIAN SCASSELLATI：J-。

1755
01:18:23,230 --> 01:18:27,110
多少點我要打印
在最後，兔子後？

1756
01:18:27,110 --> 01:18:30,610

1757
01:18:30,610 --> 01:18:31,110
10-j的。

1758
01:18:31,110 --> 01:18:35,020

1759
01:18:35,020 --> 01:18:38,010
>> 還有一件事我很想念。

1760
01:18:38,010 --> 01:18:43,740
正如你在演講今天看到的，
我們要聲明printDots

1761
01:18:43,740 --> 01:18:52,430
高達上面給的原型。

1762
01:18:52,430 --> 01:18:56,740

1763
01:18:56,740 --> 01:18:58,220
確定。

1764
01:18:58,220 --> 01:19:03,530
>> 因此，我所做的是我一直在努力，
隔離的代碼重用一部分

1765
01:19:03,530 --> 01:19:06,430
我已經做了一遍又一遍。

1766
01:19:06,430 --> 01:19:11,120
我一直試圖將其拉出，使
所有這一切都包含在一個地方。

1767
01:19:11,120 --> 01:19:16,810
這樣一來，如果我有一個錯誤的地方，
我只需要解決它在一個地方。

1768
01:19:16,810 --> 01:19:17,310
好的。

1769
01:19:17,310 --> 01:19:18,470
>> 因此，讓我們將它保存。

1770
01:19:18,470 --> 01:19:20,950
而且，我們要確保它的工作原理。

1771
01:19:20,950 --> 01:19:22,050
因此，讓我們走出去。

1772
01:19:22,050 --> 01:19:25,200
我們將再次去我們的終端。

1773
01:19:25,200 --> 01:19:27,960
我們將進行放大。

1774
01:19:27,960 --> 01:19:31,010
我們會作出這樣的兔子進程。

1775
01:19:31,010 --> 01:19:32,380
>> 呵呵。

1776
01:19:32,380 --> 01:19:34,800
它給了我一個警告。

1777
01:19:34,800 --> 01:19:37,070
它是什麼告訴我？

1778
01:19:37,070 --> 01:19:39,870
那麼在任何這些
時候，你總是希望

1779
01:19:39,870 --> 01:19:44,170
滾動到第一個error--
現在就這一個，我只得到了一個。

1780
01:19:44,170 --> 01:19:52,700
>> 它告訴我bunny.c，上線
8，第9欄，有一個問題。

1781
01:19:52,700 --> 01:19:58,650
它說，你已經聲明這
變量i，你還沒有使用過。

1782
01:19:58,650 --> 01:20:02,230
>> 現在通常，這是
還不是最壞的錯誤。

1783
01:20:02,230 --> 01:20:04,300
這是一個容易解決。

1784
01:20:04,300 --> 01:20:07,550
而事實上，我們可以回去研究。

1785
01:20:07,550 --> 01:20:09,910
我們可以回到兔子。

1786
01:20:09,910 --> 01:20:13,010
在這種情況下，所有的我們
所要做的就是擺脫我，

1787
01:20:13,010 --> 01:20:16,630
因為我們沒有使用
我在主了。

1788
01:20:16,630 --> 01:20:19,860
我們只是用它
在我們的子程序。

1789
01:20:19,860 --> 01:20:22,777
>> 因此，讓我們保存。

1790
01:20:22,777 --> 01:20:23,360
我們會回去。

1791
01:20:23,360 --> 01:20:26,760

1792
01:20:26,760 --> 01:20:28,630
並進行放大。

1793
01:20:28,630 --> 01:20:30,700
我們將更多的時間做兔子。

1794
01:20:30,700 --> 01:20:33,810

1795
01:20:33,810 --> 01:20:36,530
還有一次是我們的10幀。

1796
01:20:36,530 --> 01:20:39,450

1797
01:20:39,450 --> 01:20:41,360
確定。

1798
01:20:41,360 --> 01:20:43,190
>> 提供給您的任何時候
一個procedure--呀。

1799
01:20:43,190 --> 01:20:44,690
SPEAKER 33：我有A--我很困惑。

1800
01:20:44,690 --> 01:20:45,892
你能回去的代碼？

1801
01:20:45,892 --> 01:20:46,850
BRIAN SCASSELLATI：是的。

1802
01:20:46,850 --> 01:20:50,730

1803
01:20:50,730 --> 01:20:54,367
>> SPEAKER 33：所以，當你寫的
你的原型，爭論你

1804
01:20:54,367 --> 01:20:56,550
有它命名叫的howmany？

1805
01:20:56,550 --> 01:20:57,540
但是，below--

1806
01:20:57,540 --> 01:20:57,640
>> BRIAN SCASSELLATI：哦，是的。

1807
01:20:57,640 --> 01:20:59,140
>> SPEAKER 33：--called他們的東西
不同的，我不明白。

1808
01:20:59,140 --> 01:21:00,240
>> BRIAN SCASSELLATI：為什麼
他們是不同的。

1809
01:21:00,240 --> 01:21:01,780
所以這是一個很好的問題。

1810
01:21:01,780 --> 01:21:08,250
所以現在的問題是，上升
在這裡，我寫的howmany，

1811
01:21:08,250 --> 01:21:12,380
而樓下，我寫了howManyDots。

1812
01:21:12,380 --> 01:21:15,590
>> 其原因是，在你的原型，
它實際上不重視

1813
01:21:15,590 --> 01:21:17,090
給你把的姓名。

1814
01:21:17,090 --> 01:21:20,530
它所真正關心
是，它是一個整數。

1815
01:21:20,530 --> 01:21:23,080
它希望知道的形式
對你把什麼。

1816
01:21:23,080 --> 01:21:31,560
>> 現在stylistically-- oops--我應該
不，是我喜歡做這些比賽。

1817
01:21:31,560 --> 01:21:33,150
確定。

1818
01:21:33,150 --> 01:21:36,430
因為這會保持它
我更容易記住。

1819
01:21:36,430 --> 01:21:38,390
但是，這是我的錯呀。

1820
01:21:38,390 --> 01:21:47,620
>> SPEAKER 34：所以對於
原型去上班，就

1821
01:21:47,620 --> 01:21:50,510
寫作這一行，
寫原型，

1822
01:21:50,510 --> 01:21:53,932
允許函數來
右下方它去年底

1823
01:21:53,932 --> 01:21:55,140
和檢索是什麼意思？

1824
01:21:55,140 --> 01:21:58,480
>> BRIAN SCASSELLATI：這是什麼意思
是當編譯經過，

1825
01:21:58,480 --> 01:22:01,930
它從頂部
你的代碼底部。

1826
01:22:01,930 --> 01:22:05,430
什麼這個原型是，
是它基本上是一個承諾。

1827
01:22:05,430 --> 01:22:09,570
>> 它說，那裡將是
一個函數定義的地方。

1828
01:22:09,570 --> 01:22:11,880
這將是所謂的printDots。

1829
01:22:11,880 --> 01:22:15,110
而這將需要一個參數
那將是一個整數

1830
01:22:15,110 --> 01:22:18,590
並且它會返回
什麼都沒有，空類型。

1831
01:22:18,590 --> 01:22:19,310
確定。

1832
01:22:19,310 --> 01:22:22,950
我向你保證這將是
某處定義的道路。

1833
01:22:22,950 --> 01:22:25,590
但是，任何時候你看
那，你下去

1834
01:22:25,590 --> 01:22:28,710
通過其餘我
主要的功能，我想

1835
01:22:28,710 --> 01:22:33,800
你可以把它看成一個函數
這需要一個整數輸入。

1836
01:22:33,800 --> 01:22:37,970
>> 因此，當編譯器出現故障
通過這一點，它認為這一承諾。

1837
01:22:37,970 --> 01:22:40,220
當它下來，
一直走，一直走，

1838
01:22:40,220 --> 01:22:43,060
它找到的第一次
printDots被提及。

1839
01:22:43,060 --> 01:22:46,910
它說，呵呵，你給
我這個學家生的一個整數。

1840
01:22:46,910 --> 01:22:49,570
>> 嗯，你答應我，會
是一個整數，這是正確的。

1841
01:22:49,570 --> 01:22:51,370
這是確定的。

1842
01:22:51,370 --> 01:22:53,880
然後終於，下來
在最底層，

1843
01:22:53,880 --> 01:22:58,340
之前，我到年底我
文件，我兌現我的諾言

1844
01:22:58,340 --> 01:22:59,896
我定義它。

1845
01:22:59,896 --> 01:23:01,868
OK？

1846
01:23:01,868 --> 01:23:06,320
>> 揚聲器35：所以，saves--的
程序將保存空白

1847
01:23:06,320 --> 01:23:09,570
它可以追溯到並填充在結束了嗎？

1848
01:23:09,570 --> 01:23:12,140
>> BRIAN SCASSELLATI：這不是
關於內存分配。

1849
01:23:12,140 --> 01:23:16,800
它實際上只是什麼
類型是你希望看到的。

1850
01:23:16,800 --> 01:23:19,340
如果這件事情有一個
參數或五個參數？

1851
01:23:19,340 --> 01:23:23,590
應該有它的整數是
給它，或字符串？

1852
01:23:23,590 --> 01:23:25,780
這一切都在尋找
做的是檢查，

1853
01:23:25,780 --> 01:23:29,303
你給我
正確的說法。

1854
01:23:29,303 --> 01:23:31,560
OK？

1855
01:23:31,560 --> 01:23:32,300
好的。

1856
01:23:32,300 --> 01:23:38,570
>> 讓我離開你
另外一個位來看待。

1857
01:23:38,570 --> 01:23:44,850
ASCII藝術不是偉大的榜樣
動畫，因為它是今天。

1858
01:23:44,850 --> 01:23:50,850
但是，當然，也有人拿東西
他們推到自己的極限。

1859
01:23:50,850 --> 01:23:56,790
>> 這是，正如大衛展示
在講座中，一段代碼

1860
01:23:56,790 --> 01:24:02,150
你應該在任何情況下
嘗試複製自己。

1861
01:24:02,150 --> 01:24:05,260
因為它是可怕的文體。

1862
01:24:05,260 --> 01:24:11,180
事實上，它的設計是為
困難的，因為可以讀取。

1863
01:24:11,180 --> 01:24:11,680
確定。

1864
01:24:11,680 --> 01:24:16,210
>> 所以，再一次做，讓我們放大在了這裡。

1865
01:24:16,210 --> 01:24:20,120
我現在要去走，更改目錄。

1866
01:24:20,120 --> 01:24:24,050
我要轉到上一級
的水平，回到我的工作區。

1867
01:24:24,050 --> 01:24:29,760
然後，我會改變目錄到這個
我已經創建了其他目錄。

1868
01:24:29,760 --> 01:24:36,190
>> 這是國際
混淆C程序設計大賽。

1869
01:24:36,190 --> 01:24:40,650
混淆手段硬
如可以理解。

1870
01:24:40,650 --> 01:24:44,150
所以，請不要如果你嚇到
在這去，我無法讀取。

1871
01:24:44,150 --> 01:24:46,350
這是它的點。

1872
01:24:46,350 --> 01:24:47,700
OK？

1873
01:24:47,700 --> 01:24:52,770
>> 但是，我們有這個
精彩的節目，我是

1874
01:24:52,770 --> 01:24:57,180
將只需鍵入更多的關注一下。

1875
01:24:57,180 --> 01:25:01,890
讓我們來看看，如果我能縮小
只是有點，所以你可以看到它

1876
01:25:01,890 --> 01:25:03,940
>> 這就是該程序。

1877
01:25:03,940 --> 01:25:08,080
它的命名endo.c.

1878
01:25:08,080 --> 01:25:14,850
它看起來像這樣桶
一種字母F-L-U-I-D在裡面的。

1879
01:25:14,850 --> 01:25:16,440
>> 這其實是一個程序。

1880
01:25:16,440 --> 01:25:20,260
這是寫在最不起眼的
這樣，作者可能可能

1881
01:25:20,260 --> 01:25:21,760
寫吧。

1882
01:25:21,760 --> 01:25:29,210
但它是一個奇妙的小片的
產生流體動力學模型。

1883
01:25:29,210 --> 01:25:34,870
>> 因此，我們打算給
這種模式的輸入端，

1884
01:25:34,870 --> 01:25:42,520
看起來的這樣，
staired集集裝箱

1885
01:25:42,520 --> 01:25:45,820
一些液體，一些
液，在頂部。

1886
01:25:45,820 --> 01:25:48,790
我們將有它模擬
發生了什麼吧。

1887
01:25:48,790 --> 01:25:52,415
>> 所以，我會調用該函數，內。

1888
01:25:52,415 --> 01:25:59,000
而我給它的
，我已經有輸入文件。

1889
01:25:59,000 --> 01:26:02,830
還有就是我們的ASCII藝術的縮影。

1890
01:26:02,830 --> 01:26:08,960
一個完整的流體動力學模擬
在代碼只有幾行運行。

1891
01:26:08,960 --> 01:26:13,750
>> 現在，什麼是居然真的
令人驚奇這個小程序

1892
01:26:13,750 --> 01:26:17,280
是，我現在要停止它，
所以我打算用什麼命令？

1893
01:26:17,280 --> 01:26:18,660
>> 聽眾：控制-C。

1894
01:26:18,660 --> 01:26:20,390
>> BRIAN SCASSELLATI：控制-C。確定。

1895
01:26:20,390 --> 01:26:22,960
因此，我將使用Ctrl-C組合。
C，它會停止它。

1896
01:26:22,960 --> 01:26:25,330
我會再次清除。

1897
01:26:25,330 --> 01:26:31,210
而現在我要調用
程序，執行程序，

1898
01:26:31,210 --> 01:26:33,740
使用本身作為輸入。

1899
01:26:33,740 --> 01:26:36,760

1900
01:26:36,760 --> 01:26:42,700
>> 我們將看到流體動力
模擬它融化。

1901
01:26:42,700 --> 01:26:43,830
確定。

1902
01:26:43,830 --> 01:26:48,180
請不要讓該程序
是因為混淆了你的東西。

1903
01:26:48,180 --> 01:26:52,220
這只是這樣我們就可以結束
一些冷靜和有趣。

1904
01:26:52,220 --> 01:26:53,930
確定。

1905
01:26:53,930 --> 01:26:56,330
>> 祝您好運與你的習題集。

1906
01:26:56,330 --> 01:26:59,030
我們很樂意回答
課後問題。

1907
01:26:59,030 --> 01:27:01,180
謝謝了，伙計們。

1908
01:27:01,180 --> 01:27:02,793