1
00:00:00,000 --> 00:00:05,830

2
00:00:05,830 --> 00:00:08,650
>> JASON HIRSCHHORN：歡迎到
CS50節，每個人。

3
00:00:08,650 --> 00:00:11,430
我的名字是賈森·赫塞豪恩。

4
00:00:11,430 --> 00:00:15,850
我是你的轉錄因子很多，但很多
人們會希望能夠加入我們

5
00:00:15,850 --> 00:00:20,420
在線擴展學生或學生
試圖通過部分看，如果他們

6
00:00:20,420 --> 00:00:22,830
那一周或錯過了他們的部分
正好趕上，如果他們想

7
00:00:22,830 --> 00:00:24,510
回顧一些材料。

8
00:00:24,510 --> 00:00:30,060
>> 因此，按照教學大綱，所有
你們都讀過，糾正嗎？

9
00:00:30,060 --> 00:00:31,390
我看到了很多的點頭。

10
00:00:31,390 --> 00:00:34,220
節為您提供的機會
探索課程

11
00:00:34,220 --> 00:00:37,420
材料在一個更親密的環境，
以及潛入

12
00:00:37,420 --> 00:00:38,810
實踐活動。

13
00:00:38,810 --> 00:00:41,230
>> 所以，基本上我們什麼
會做每週。

14
00:00:41,230 --> 00:00:45,090
我們通過我們有什麼打算去
確定為最重要的

15
00:00:45,090 --> 00:00:49,170
涵蓋的主題演講，和那些
大概也是最有用和最

16
00:00:49,170 --> 00:00:52,780
最有可能想出問題集
和測驗，並在您的編碼

17
00:00:52,780 --> 00:00:53,970
CS50之外的生活。

18
00:00:53,970 --> 00:00:57,260
因此，我們要進入這些主題，
討論這些問題，他們走了過來，

19
00:00:57,260 --> 00:01:00,660
回答你們有任何問題，
然後我們做了很多

20
00:01:00,660 --> 00:01:02,250
在編碼的實際問題。

21
00:01:02,250 --> 00:01:04,239
>> 你們都帶來了筆記本電腦，
這是夢幻般的。

22
00:01:04,239 --> 00:01:05,710
這是一個計算機科學類。

23
00:01:05,710 --> 00:01:10,070
但是，我們做了很多的練習，
你不會需要你的筆記本電腦。

24
00:01:10,070 --> 00:01:11,720
你可以做他們在片材上的紙張。

25
00:01:11,720 --> 00:01:13,580
這就是你要
做他們的測驗。

26
00:01:13,580 --> 00:01:16,450
而事實上，這是一個偉大的方式來
真的知道，你該怎麼辦

27
00:01:16,450 --> 00:01:19,720
如果你沒有的東西檢查50〜
依賴或依靠，告訴

28
00:01:19,720 --> 00:01:20,620
你做了任何錯誤。

29
00:01:20,620 --> 00:01:25,670
>> 因此，歡迎你在代碼
裝置或run.cs50.net，這是

30
00:01:25,670 --> 00:01:29,770
另一種工具，允許您編寫
在線，但我也建議，如果

31
00:01:29,770 --> 00:01:32,280
你有沒有試過，使用表
紙和嘗試這些做法

32
00:01:32,280 --> 00:01:33,640
一張紙的問題。

33
00:01:33,640 --> 00:01:35,330
這還是因為同樣的原因，這是最終
你要什麼

34
00:01:35,330 --> 00:01:37,430
要求做測驗。

35
00:01:37,430 --> 00:01:44,080
>> 因此，讓我們開始我們的
今天的議程。

36
00:01:44,080 --> 00:01:47,710
我們打算去了一些規範
我們的部分，然後我們要去潛水

37
00:01:47,710 --> 00:01:51,180
成數組，函數和命令行
參數，這是你們

38
00:01:51,180 --> 00:01:56,200
過去的這一周，已覆蓋講座
然後在週一，你會覆蓋

39
00:01:56,200 --> 00:01:57,330
更多的明天。

40
00:01:57,330 --> 00:01:59,060
最後，我們要
談論pset2。

41
00:01:59,060 --> 00:02:03,640
如果我能得到一個舉手，如果你
沒有看著兩個問題集

42
00:02:03,640 --> 00:02:04,890
規範。

43
00:02:04,890 --> 00:02:07,060

44
00:02:07,060 --> 00:02:08,120
我們大家會說。

45
00:02:08,120 --> 00:02:09,419
太棒了。

46
00:02:09,419 --> 00:02:12,070
>> 我們將談論問題套在一個位，
但如果你閱讀問題集

47
00:02:12,070 --> 00:02:14,340
規範，這是
所有你需要做的。

48
00:02:14,340 --> 00:02:18,370
如果你讀之前，你來
類和部分在週二，你會

49
00:02:18,370 --> 00:02:19,220
是一個偉大的位置。

50
00:02:19,220 --> 00:02:21,680
我們可以去通過習題集，
這就是我們要去

51
00:02:21,680 --> 00:02:22,090
做底。

52
00:02:22,090 --> 00:02:23,500
我們要經過
邏輯，確保

53
00:02:23,500 --> 00:02:24,710
每個人都在同一頁上。

54
00:02:24,710 --> 00:02:28,650
>> 我希望你能夠離開週二
你感覺很舒服

55
00:02:28,650 --> 00:02:31,560
需要做的這個星期的問題集，
如果你不這樣做，我會很高興

56
00:02:31,560 --> 00:02:33,050
留後，並與您合作。

57
00:02:33,050 --> 00:02:36,850
但是，這是一件事，你必須
做，但我認為很聰明，

58
00:02:36,850 --> 00:02:40,500
只是閱讀問題集
規範類星期二

59
00:02:40,500 --> 00:02:42,640
這聽起來像一個
你們做的很多。

60
00:02:42,640 --> 00:02:45,810
>> 我將開始與每類議程
所以你知道我們要去的地方。

61
00:02:45,810 --> 00:02:49,520
這也是有幫助的人看
在網上，因為每個節

62
00:02:49,520 --> 00:02:53,540
顏色編碼，所以如果你要來
，只是看10分鐘，而

63
00:02:53,540 --> 00:02:56,950
比整個90分鐘的部分，
剛去的顏色編碼部分

64
00:02:56,950 --> 00:02:57,890
並期待在這一部分。

65
00:02:57,890 --> 00:03:01,510
因此，我一直試圖將它們分開成漂亮的
模塊將允許你 - 

66
00:03:01,510 --> 00:03:03,960
如果你想回來，並檢討，
或其他學生只是

67
00:03:03,960 --> 00:03:05,350
看一段檢討 - 

68
00:03:05,350 --> 00:03:08,130
找到具體的事情，他們
要注意的

69
00:03:08,130 --> 00:03:10,480
並進一步了解。

70
00:03:10,480 --> 00:03:11,390
甜。

71
00:03:11,390 --> 00:03:12,180
>> 規範。

72
00:03:12,180 --> 00:03:13,680
我是一個FOP在校園裡的領導者。

73
00:03:13,680 --> 00:03:14,900
我不知道，如果有人做FOP。

74
00:03:14,900 --> 00:03:16,280
有沒有人做FOP？

75
00:03:16,280 --> 00:03:17,100
一個人做FOP。

76
00:03:17,100 --> 00:03:18,430
兩個人做FOP。

77
00:03:18,430 --> 00:03:19,250
真棒。

78
00:03:19,250 --> 00:03:22,360
因此，FOP是第一年戶外
迎新活動。

79
00:03:22,360 --> 00:03:27,240
我們進了樹林，使新生
最神奇的經歷

80
00:03:27,240 --> 00:03:28,830
他們的生活，是否正確？

81
00:03:28,830 --> 00:03:29,220
嗯。

82
00:03:29,220 --> 00:03:30,080
聽起來是正確的。

83
00:03:30,080 --> 00:03:36,360
>> 所以，我只是想開始我們的第一個
通過討論一些規範部分

84
00:03:36,360 --> 00:03:38,860
類和我們之間的關係
因為我覺得

85
00:03:38,860 --> 00:03:40,010
他們是非常重要的。

86
00:03:40,010 --> 00:03:43,630
首先，那些你們誰
我的部分已收到並

87
00:03:43,630 --> 00:03:47,150
中討論的
電子郵件，我喜歡這個。

88
00:03:47,150 --> 00:03:48,130
這是今年我最喜歡的部分。

89
00:03:48,130 --> 00:03:49,100
我一直很興奮。

90
00:03:49,100 --> 00:03:50,040
我在這裡已經好幾個小時。

91
00:03:50,040 --> 00:03:54,560
我還沒有離開這棟樓除了
去吃飯，因為我愛CS50節，我

92
00:03:54,560 --> 00:03:58,620
愛教學，我愛工作
你們。

93
00:03:58,620 --> 00:04:02,000
>> 我的最高優先事項之一，如果不是我
頭號優先，不僅為

94
00:04:02,000 --> 00:04:05,130
這一類，但包括我的其他
類和課外活動，是

95
00:04:05,130 --> 00:04:09,350
支持你們，幫助你們，
盡我所能，確保您

96
00:04:09,350 --> 00:04:13,780
你們有一個美好的，有趣的，多產，
引人入勝，令人振奮

97
00:04:13,780 --> 00:04:15,250
在這個類中的經驗。

98
00:04:15,250 --> 00:04:16,190
這就是我的承諾。

99
00:04:16,190 --> 00:04:17,959
這就是為什麼我喜歡這樣做。

100
00:04:17,959 --> 00:04:20,190
這是我的一件事，
支持你們。

101
00:04:20,190 --> 00:04:25,110
如果您有任何關於講座的問題，
問題集，節，

102
00:04:25,110 --> 00:04:28,830
生活中，即使你想談談
生活中，請隨時伸手。

103
00:04:28,830 --> 00:04:31,210
>> 你有我的手機號碼，
你有我的電子郵件

104
00:04:31,210 --> 00:04:32,910
地址，你有我的GChat。

105
00:04:32,910 --> 00:04:37,540
你可以聯繫我的任何或所有
何時何地，但可能不會得到

106
00:04:37,540 --> 00:04:38,720
響應時。

107
00:04:38,720 --> 00:04:41,020
我嘗試在24小時內取回。

108
00:04:41,020 --> 00:04:44,760
通常情況下，它會在
20分鐘或24分鐘。

109
00:04:44,760 --> 00:04:46,110
我應該說，
使其平行。

110
00:04:46,110 --> 00:04:48,840
但是，你會得到一個回應
很快。

111
00:04:48,840 --> 00:04:54,220
>> 如果你給我發短信前一小時
問題集中到期，我會冷靜

112
00:04:54,220 --> 00:04:57,660
下來，做深呼吸練習
你，但如果你還沒有開始，

113
00:04:57,660 --> 00:05:00,270
你可能不會完成，
我真的不能幫你在那裡

114
00:05:00,270 --> 00:05:01,710
儘管我會盡我所能。

115
00:05:01,710 --> 00:05:03,920
所以，我會盡一切
我可以支持你。

116
00:05:03,920 --> 00:05:07,980
請隨意是否達到
它在節再次，在辦公時間

117
00:05:07,980 --> 00:05:09,150
如果你看到我，甚至在外頭。

118
00:05:09,150 --> 00:05:11,800
我很高興，設立時間，以滿足
通過問題和工作

119
00:05:11,800 --> 00:05:14,410
或材料走了過來。

120
00:05:14,410 --> 00:05:15,990
所以這是頭號，支持。

121
00:05:15,990 --> 00:05:17,940
我會盡我
可以支持你。

122
00:05:17,940 --> 00:05:21,520
>> 二，會議中間。

123
00:05:21,520 --> 00:05:24,760
就像我想是的，我
不是萬能的或強大或

124
00:05:24,760 --> 00:05:28,410
全知的，所以我不知道所有的
時間，如果我在做什麼

125
00:05:28,410 --> 00:05:33,410
跨越，如果我教的方式
主題幫助您了解它，或者，如果你

126
00:05:33,410 --> 00:05:36,120
感到困惑的話題，但不
舉起你的手，或問我

127
00:05:36,120 --> 00:05:37,390
或發電子郵件給我。

128
00:05:37,390 --> 00:05:42,150
或者，即使你再感到困惑
有關問題上的東西。

129
00:05:42,150 --> 00:05:44,240
如果你不拿出來給我，
我不知道那是肯定的。

130
00:05:44,240 --> 00:05:46,950
我要盡我所能來檢查
你們這些傢伙，確保一切

131
00:05:46,950 --> 00:05:51,170
順利，試教的方式的事情
大部分將有利於

132
00:05:51,170 --> 00:05:54,910
您的學習風格，但如果有
我能做些什麼，讓我知道。

133
00:05:54,910 --> 00:05:58,520
>> 沿著這些線路，如果你想要一些幫助
設置的問題，我更

134
00:05:58,520 --> 00:05:59,700
比竭誠為您服務
問題集。

135
00:05:59,700 --> 00:06:02,300
我們打算做了很多
，朝第二

136
00:06:02,300 --> 00:06:03,460
本節的一半。

137
00:06:03,460 --> 00:06:06,040
但是，如果你還沒有閱讀問題集
備份和沒有看過步行

138
00:06:06,040 --> 00:06:09,310
通過和沒有看過的短褲
並期待我來教你

139
00:06:09,310 --> 00:06:13,260
一切已經錄像
在線或你可以找到CS50

140
00:06:13,260 --> 00:06:16,720
學習，這不是一個真正公平的
我或你的其他同行。

141
00:06:16,720 --> 00:06:20,440

142
00:06:20,440 --> 00:06:25,730
>> 所以，請我更樂意幫助
你，但你們得到了滿足我

143
00:06:25,730 --> 00:06:27,230
中間。

144
00:06:27,230 --> 00:06:30,100
我們有資源噸
你CS50。

145
00:06:30,100 --> 00:06:31,230
我提到其中的一些。

146
00:06:31,230 --> 00:06:32,960
請利用它們。

147
00:06:32,960 --> 00:06:35,140
如果你困惑，我更樂意
幫你解釋他們在

148
00:06:35,140 --> 00:06:39,290
另一種方式，但它是不公平的，如果
學生在辦公時間，

149
00:06:39,290 --> 00:06:42,530
還沒有開始任何事情，它是
週四晚上，他們正在期待

150
00:06:42,530 --> 00:06:45,880
他們通過每一個TF走
由於問題的東西設置

151
00:06:45,880 --> 00:06:47,140
第二天中午。

152
00:06:47,140 --> 00:06:48,300
有意義嗎？

153
00:06:48,300 --> 00:06:50,890
再次，請配合我們在中間。

154
00:06:50,890 --> 00:06:53,230
>> 最後，很高的期望。

155
00:06:53,230 --> 00:06:58,010
我要分級大家誰
在我的部分，或得分

156
00:06:58,010 --> 00:06:59,020
習題集。

157
00:06:59,020 --> 00:07:01,240
你還沒有問題
設置零次或一次。

158
00:07:01,240 --> 00:07:02,250
我們很遺憾。

159
00:07:02,250 --> 00:07:04,970
我們花了一段時間，終於
解決部分，而現在

160
00:07:04,970 --> 00:07:05,560
我們可以開始分級。

161
00:07:05,560 --> 00:07:09,560
>> 我將讓他們回到你
盡快。

162
00:07:09,560 --> 00:07:11,890
這些都是我的一些
有advisees。

163
00:07:11,890 --> 00:07:14,150
我將讓他們回到你
盡快。

164
00:07:14,150 --> 00:07:18,046
第二個問題集，我們會在
安排，我們將開始讓他們

165
00:07:18,046 --> 00:07:20,440
你很快後
你打開它們。

166
00:07:20,440 --> 00:07:24,130
>> 當您重新設置您的問題，
將獲得更高的分數，因為你知道，從

167
00:07:24,130 --> 00:07:28,150
閱讀大綱 - 正確性，
設計，範圍和風格分數。

168
00:07:28,150 --> 00:07:29,760
您還可以得到意見。

169
00:07:29,760 --> 00:07:32,160
更重要的意見
比分數。

170
00:07:32,160 --> 00:07:33,780
我認為它是安全地說。

171
00:07:33,780 --> 00:07:37,930
>> 分數只是一個數字
從一到五。

172
00:07:37,930 --> 00:07:38,930
這是很難讀入那些。

173
00:07:38,930 --> 00:07:40,720
這是從那些難以改善。

174
00:07:40,720 --> 00:07:44,460
但評論指出具體
事情，你做得很好或地區

175
00:07:44,460 --> 00:07:48,360
你可以改善，並給你一些
對未來的想法或替代

176
00:07:48,360 --> 00:07:49,160
做事的方法。

177
00:07:49,160 --> 00:07:52,270
>> 所以，請，請，請仔細閱讀“
通過的意見。

178
00:07:52,270 --> 00:07:54,190
我把大量的時間到
這些意見。

179
00:07:54,190 --> 00:07:57,190
請仔細閱讀並通過他們不只是
向下滾動到的底部

180
00:07:57,190 --> 00:08:01,890
PDF格式，看你的分數，或者去網上
找到你的分數，然後忽略

181
00:08:01,890 --> 00:08:02,800
的意見。

182
00:08:02,800 --> 00:08:03,910
那不是你
會變得更好。

183
00:08:03,910 --> 00:08:06,550
那不是你要增加
你的分數，最終，只是

184
00:08:06,550 --> 00:08:07,340
看上面的分數。

185
00:08:07,340 --> 00:08:08,760
請看看這些意見。

186
00:08:08,760 --> 00:08:13,240
>> 沿線很高的期望，
再次，就像我說的，你

187
00:08:13,240 --> 00:08:14,260
可以砍下從一到五。

188
00:08:14,260 --> 00:08:17,120
三三兩兩，三分球，四肢
絕大多數分數

189
00:08:17,120 --> 00:08:17,940
你要得到。

190
00:08:17,940 --> 00:08:20,180
和五歲以下兒童的都是真的很罕見。

191
00:08:20,180 --> 00:08:21,720
總是有東西
我們可以做的更好。

192
00:08:21,720 --> 00:08:23,490
每當我編寫一個程序，有
總有一些事情我

193
00:08:23,490 --> 00:08:24,800
可以做的更好。

194
00:08:24,800 --> 00:08:28,740
>> 因此，而不是說你得到了五
一切所有的時間，並

195
00:08:28,740 --> 00:08:31,960
一切完美，我不認為任何
我們真的相信我們 - 

196
00:08:31,960 --> 00:08:34,830
希望我們不要做的一切
完善所有的時間。

197
00:08:34,830 --> 00:08:37,010
所以，不要擔心，如果你
沒有得到一個五。

198
00:08:37,010 --> 00:08:40,470
一個五不映射到一個A，
不映射到一個B，一個三不

199
00:08:40,470 --> 00:08:42,950
不映射到這不是一個C。
的分數是如何工作的。

200
00:08:42,950 --> 00:08:48,140
>> 像大衛已經說過很多次，
學期結束所有你的分數和

201
00:08:48,140 --> 00:08:53,390
從我做起，輸入你的TF，走到了一起
並為您確定最終成績。

202
00:08:53,390 --> 00:08:56,760
但同樣，它不是五，
四，B，等等。

203
00:08:56,760 --> 00:09:01,150
所以我要抱有很高的期望
為你們。

204
00:09:01,150 --> 00:09:03,670
我要去預期良好的問題
套，我要去給

205
00:09:03,670 --> 00:09:05,010
您的反饋等。

206
00:09:05,010 --> 00:09:07,430
它不會意味著你
會得到檔次更糟。

207
00:09:07,430 --> 00:09:09,760
您而言，分級
你的進步從週

208
00:09:09,760 --> 00:09:11,260
為零，當然結束。

209
00:09:11,260 --> 00:09:17,190
>> 最後，在高
在課堂上的期望，我愛

210
00:09:17,190 --> 00:09:18,460
人參與。

211
00:09:18,460 --> 00:09:23,180
我明白有些人覺得更多的還是
不太舒服的參與。

212
00:09:23,180 --> 00:09:26,050
其他人參與
不是靠提高他們的手，

213
00:09:26,050 --> 00:09:27,320
說話的時候。

214
00:09:27,320 --> 00:09:30,570
但我們在這個類將要
做了很多的小問題，很多

215
00:09:30,570 --> 00:09:33,770
小的問題，然後一些
更大的編碼問題。

216
00:09:33,770 --> 00:09:36,760
所以肯定這些工作鍛煉出來
當我們這樣做，他們在您的計算機上或

217
00:09:36,760 --> 00:09:37,900
一張紙。

218
00:09:37,900 --> 00:09:40,933
>> 但我還會給你前一段時間
有人回答一些

219
00:09:40,933 --> 00:09:42,220
我問的問題。

220
00:09:42,220 --> 00:09:44,930
所以，因為我會給你一些時間
想想吧，因為我們要去

221
00:09:44,930 --> 00:09:49,380
有時合作夥伴做的事情，
我會期待大家

222
00:09:49,380 --> 00:09:52,150
要有點從事。

223
00:09:52,150 --> 00:09:56,030
而對於缺乏一個更好的詞，
可能會冷通話，

224
00:09:56,030 --> 00:09:59,045
是每個人都將有機會
思考答案，然後

225
00:09:59,045 --> 00:10:01,150
我會打電話給你，然後
你會說答案。

226
00:10:01,150 --> 00:10:05,200
>> 不要擔心或害怕，。

227
00:10:05,200 --> 00:10:08,610
我已經做到了在過去，我們已經找到了
它的成功得多，

228
00:10:08,610 --> 00:10:11,810
閱讀教育研究
確定是否它是一個

229
00:10:11,810 --> 00:10:12,640
良好的戰術。

230
00:10:12,640 --> 00:10:15,790
這是非常有用的，特別是如果你
讓學生有時間去思考

231
00:10:15,790 --> 00:10:20,070
的答案，不要讓他們剛進來
出來，說出來了蝙蝠的權利。

232
00:10:20,070 --> 00:10:22,620
但是，如果你感覺不舒服
回答，我還不錯

233
00:10:22,620 --> 00:10:25,370
感應到了，我們不打算
把你在現場，尤其是在

234
00:10:25,370 --> 00:10:28,240
攝像頭，即使沒有
你是在相機現在。

235
00:10:28,240 --> 00:10:32,250
>> 因此，這些都是我的規範。

236
00:10:32,250 --> 00:10:34,670
沿線的一件事
滿足在中間。

237
00:10:34,670 --> 00:10:36,490
我去給你們
很多反饋意見。

238
00:10:36,490 --> 00:10:38,310
請給我反饋。

239
00:10:38,310 --> 00:10:46,190
有一個網站，sayat.me/cs50。

240
00:10:46,190 --> 00:10:48,380
所以這是一個誠實的反饋。

241
00:10:48,380 --> 00:10:50,730
如果你想給它一節期間，
我收到一封電子郵件，每當發生。

242
00:10:50,730 --> 00:10:53,820
我們將稍事休息，所以我會在一個位
然後看通過反饋。

243
00:10:53,820 --> 00:10:55,970
如果你有任何意見，
請給我有。

244
00:10:55,970 --> 00:11:01,380
>> 如果你給我反饋，這是在Q
美妙的，但是這是導

245
00:11:01,380 --> 00:11:02,570
你做底。

246
00:11:02,570 --> 00:11:05,690
但是，這將是在學期結束，所以
我不會可以採取任何的

247
00:11:05,690 --> 00:11:08,620
反饋，並把它融入教學
你們更好。

248
00:11:08,620 --> 00:11:11,020
所以，請如果您有任何
反饋，把它給我。

249
00:11:11,020 --> 00:11:12,010
我愛的反饋。

250
00:11:12,010 --> 00:11:14,490
備份FOP，我們得到的反饋
所有的時間。

251
00:11:14,490 --> 00:11:18,610
>> 你可以給我加號，好東西，
三角洲的事情，我可以改善。

252
00:11:18,610 --> 00:11:20,600
你可以評論我的衣服上。

253
00:11:20,600 --> 00:11:24,170
這不會是有幫助，但你
歡迎發表任何評論，

254
00:11:24,170 --> 00:11:24,570
一切。

255
00:11:24,570 --> 00:11:26,280
請，請給我反饋。

256
00:11:26,280 --> 00:11:28,740
我很看重它了很多，這
對我來說意味著很多。

257
00:11:28,740 --> 00:11:31,760

258
00:11:31,760 --> 00:11:33,280
>> 一個規範，樂趣無窮。

259
00:11:33,280 --> 00:11:34,530
我們將有很多的樂趣。

260
00:11:34,530 --> 00:11:36,930
希望在這個過程中，你會
有很多的樂趣。

261
00:11:36,930 --> 00:11:38,780
我們將有糖果部分。

262
00:11:38,780 --> 00:11:40,040
我們就得音樂。

263
00:11:40,040 --> 00:11:45,510
我們會希望去了解一個
另一個有點好，所以我想

264
00:11:45,510 --> 00:11:47,690
這是一個有趣的，引人入勝的體驗。

265
00:11:47,690 --> 00:11:50,890
>> 我知道你們有些人睡著
你今天早些時候的演講，

266
00:11:50,890 --> 00:11:53,750
所以希望這不會
現在的情況。

267
00:11:53,750 --> 00:11:55,960
而如果是現在的情況下，只是
不打呼嚕，因為可能

268
00:11:55,960 --> 00:11:57,580
被抓相機。

269
00:11:57,580 --> 00:11:58,770
甜。

270
00:11:58,770 --> 00:12:04,020
有任何疑問，意見或疑慮
之前，我謹什麼，我們已經

271
00:12:04,020 --> 00:12:05,270
談到？

272
00:12:05,270 --> 00:12:08,620

273
00:12:08,620 --> 00:12:11,350
太好了。

274
00:12:11,350 --> 00:12:14,830
>> 因此，我們打算去
先成陣列。

275
00:12:14,830 --> 00:12:17,140
這是你如何使一個數組。

276
00:12:17,140 --> 00:12:18,410
我們已經看到過。

277
00:12:18,410 --> 00:12:21,830
你有一個數據類型，你有一個
名稱，然後你有一個大小。

278
00:12:21,830 --> 00:12:24,430
在這裡，我創建了兩個數組。

279
00:12:24,430 --> 00:12:30,360
第一個是一個字符數組，
它有26個停車位。

280
00:12:30,360 --> 00:12:33,790
第二個是一個數組
分數，它有三個

281
00:12:33,790 --> 00:12:35,390
空間三個整數。

282
00:12:35,390 --> 00:12:35,827
是嗎？

283
00:12:35,827 --> 00:12:38,200
>> 學生：所有這些幻​​燈片
可為我們的地方嗎？

284
00:12:38,200 --> 00:12:38,850
>> JASON HIRSCHHORN：大問題。

285
00:12:38,850 --> 00:12:40,650
問題是，所有的
這些滑動？

286
00:12:40,650 --> 00:12:40,920
是。

287
00:12:40,920 --> 00:12:43,420
所有這些幻​​燈片將是可利用的，
在未來，我會通過電子郵件給

288
00:12:43,420 --> 00:12:44,640
你之前部分。

289
00:12:44,640 --> 00:12:47,340
然而今天，因為這是第一次
本週，我們起步較晚。

290
00:12:47,340 --> 00:12:49,675
所以通常情況下，你會得到這些幻燈片，但
他們將可在網上和

291
00:12:49,675 --> 00:12:52,420
我會通過電子郵件發送給你
下課後權。

292
00:12:52,420 --> 00:12:54,140
任何其他的問題嗎？

293
00:12:54,140 --> 00:13:01,330
>> 如此反复，陣列箱，由於缺乏
一個更好的詞，有多個

294
00:13:01,330 --> 00:13:06,420
一種數據類型的元素，而且他們
在內存中彼此旁邊。

295
00:13:06,420 --> 00:13:11,370
如此反复，這怎麼可以
使兩種類型的陣列。

296
00:13:11,370 --> 00:13:15,090
>> 所以在你做出陣列
 - 詮釋，第一行分數，支架

297
00:13:15,090 --> 00:13:17,430
三，靠近支架 - 
想要初始化它。

298
00:13:17,430 --> 00:13:19,050
你想在那裡把一些值。

299
00:13:19,050 --> 00:13:24,660
這是你如何把一些值
在那裡，只是選擇的指數和

300
00:13:24,660 --> 00:13:25,670
記錄的號碼。

301
00:13:25,670 --> 00:13:27,130
讓我們畫在黑板上。

302
00:13:27,130 --> 00:13:28,270
每個人都可以看到嗎？

303
00:13:28,270 --> 00:13:29,030
每個人都可以看到。

304
00:13:29,030 --> 00:13:30,790
甜。

305
00:13:30,790 --> 00:13:36,550
>> 所以這將是我的
陣列稱為比分。

306
00:13:36,550 --> 00:13:37,730
正如你可以看到的，它的大小為3。

307
00:13:37,730 --> 00:13:39,210
在那裡有三個框。

308
00:13:39,210 --> 00:13:43,120
每一個可以容納什麼
類型的數據類型？

309
00:13:43,120 --> 00:13:43,790
>> 學生：整數。

310
00:13:43,790 --> 00:13:45,250
>> JASON HIRSCHHORN：一個整數
在這其中。

311
00:13:45,250 --> 00:13:48,790
我們寫INT的分數，並且第一個字
那將是數據類型

312
00:13:48,790 --> 00:13:50,910
該數組中的框。

313
00:13:50,910 --> 00:13:52,160
所以，我能適合三種。

314
00:13:52,160 --> 00:13:54,880

315
00:13:54,880 --> 00:13:57,000
為什麼我必須零
板？

316
00:13:57,000 --> 00:13:59,240
為什麼它說得分為零等於1？

317
00:13:59,240 --> 00:14:02,090

318
00:14:02,090 --> 00:14:03,180
提醒我你的名字。

319
00:14:03,180 --> 00:14:03,470
>> 學生：庫爾特。

320
00:14:03,470 --> 00:14:04,070
>> JASON HIRSCHHORN：庫爾特。

321
00:14:04,070 --> 00:14:04,480
>> 學生：是的。

322
00:14:04,480 --> 00:14:04,920
>> JASON HIRSCHHORN：為什麼呢？

323
00:14:04,920 --> 00:14:07,230
>> 學生：因為第一個索引
為零，我們開始計數為零。

324
00:14:07,230 --> 00:14:08,480
>> JASON HIRSCHHORN：所以我們開始
在零計數。

325
00:14:08,480 --> 00:14:09,580
這是完全正確的。

326
00:14:09,580 --> 00:14:12,340
這是令人困惑的部分和意志之旅
你，尤其是當你

327
00:14:12,340 --> 00:14:14,900
試圖遍歷數組，
我們會做一個位。

328
00:14:14,900 --> 00:14:15,980
我們開始計數為零。

329
00:14:15,980 --> 00:14:19,170
所以，如果我想參照第一
盒，它不是箱裡。

330
00:14:19,170 --> 00:14:22,290
不幸的是，箱零。

331
00:14:22,290 --> 00:14:26,460
第二個是框中，並在這
的情況下，第三個是箱兩種。

332
00:14:26,460 --> 00:14:28,700
>> 關於對話框三是什麼？

333
00:14:28,700 --> 00:14:30,670
箱三在哪裡呢？

334
00:14:30,670 --> 00:14:34,750
或者，如果我想要做的成績，支架
三，密切支架，那是什麼？

335
00:14:34,750 --> 00:14:37,650

336
00:14:37,650 --> 00:14:39,760
所以你說的空字符。

337
00:14:39,760 --> 00:14:41,600
任何其他的想法？

338
00:14:41,600 --> 00:14:44,590
什麼是得分支架三個支架？

339
00:14:44,590 --> 00:14:48,045
>> 學生：它並沒有真正存在，因為
你只定義為得分，

340
00:14:48,045 --> 00:14:49,370
支架三。

341
00:14:49,370 --> 00:14:51,400
>> JASON HIRSCHHORN：所以你說
它並沒有真正存在。

342
00:14:51,400 --> 00:14:54,230
在某些情況下，當我們正在處理
字符串，一般我們把空

343
00:14:54,230 --> 00:14:54,790
結束字符。

344
00:14:54,790 --> 00:14:56,100
我們會在第二。

345
00:14:56,100 --> 00:15:01,020
但是，在這種情況下，有
這裡沒有第三個方塊。

346
00:15:01,020 --> 00:15:06,390
所以任何數組中的最後一箱
的尺寸減去1。

347
00:15:06,390 --> 00:15:11,310
所以，如果我們有一個大小為n的數組，
第一盒是為零，最後一個是

348
00:15:11,310 --> 00:15:12,700
在n減1。

349
00:15:12,700 --> 00:15:14,970
在這種情況下，它不存在。

350
00:15:14,970 --> 00:15:17,970
也有一些是在這裡
內存，但它不是我們的。

351
00:15:17,970 --> 00:15:18,460
我們並不擁有它。

352
00:15:18,460 --> 00:15:19,570
我們並沒有要求它。

353
00:15:19,570 --> 00:15:22,606
因此，如果我們嘗試訪問它，我們將
做在一個位，我們很可能會

354
00:15:22,606 --> 00:15:24,970
惹上麻煩。

355
00:15:24,970 --> 00:15:29,180
>> 在這種情況下，我初始化我
三個變量的數組。

356
00:15:29,180 --> 00:15:36,195
我們把一箱零，兩
在箱，三箱二。

357
00:15:36,195 --> 00:15:39,280
沒有任何人有任何疑問，
有關初始化的數組？

358
00:15:39,280 --> 00:15:44,540

359
00:15:44,540 --> 00:15:46,970
>> 於是我們過剛才。

360
00:15:46,970 --> 00:15:52,725
比分，支架三，靠近支架，
不存在。

361
00:15:52,725 --> 00:15:58,130
我們從零開始編制索引，計算機科學，
所以我們開始計數為零。

362
00:15:58,130 --> 00:16:01,860
最後一箱提供給我們，這是
第三個框，但是它稱為盒

363
00:16:01,860 --> 00:16:03,110
數二。

364
00:16:03,110 --> 00:16:05,790

365
00:16:05,790 --> 00:16:09,710
>> 而在下面，這是一種替代
初始化數組的方式。

366
00:16:09,710 --> 00:16:13,410
因此，而不是創建一個數組
線，灌裝的第一個框，然後

367
00:16:13,410 --> 00:16:17,070
第二個框中，然後在第三個框，
在同一行中，你可以做到這一切。

368
00:16:17,070 --> 00:16:19,040
因此，在該行中，兩個數組。

369
00:16:19,040 --> 00:16:23,460
這將創建完全相同的陣列
我們在這裡，但它

370
00:16:23,460 --> 00:16:24,710
只是它在一行。

371
00:16:24,710 --> 00:16:29,740

372
00:16:29,740 --> 00:16:31,360
>> 現在，我們已經創建了我們的陣列。

373
00:16:31,360 --> 00:16:34,100
通常，一旦你創建一個數組，你
它想要做的事，無論是

374
00:16:34,100 --> 00:16:38,430
填寫或得到的東西出來呢
並打印出來在屏幕上。

375
00:16:38,430 --> 00:16:42,270
在這種情況下，我們將通過我們的
分數數組，初始化

376
00:16:42,270 --> 00:16:44,740
的第一行，在這裡在灰度。

377
00:16:44,740 --> 00:16:49,600
然後在第二行，我們開始
遍歷數組。

378
00:16:49,600 --> 00:16:52,640
沒有任何人有任何疑問，
一個for循環的結構？

379
00:16:52,640 --> 00:16:55,250

380
00:16:55,250 --> 00:16:56,400
>> 因此，這是for循環。

381
00:16:56,400 --> 00:16:59,530
我們有我們的初始條件，然後
我們的最終狀態，然後我們

382
00:16:59,530 --> 00:17:01,160
迭代，我，每一個循環。

383
00:17:01,160 --> 00:17:05,579
而在此花括號中的
循環，會發生什麼，如果我是運行

384
00:17:05,579 --> 00:17:06,290
這個程序？

385
00:17:06,290 --> 00:17:10,410
誰能告訴我，我們會得到什麼？

386
00:17:10,410 --> 00:17:11,589
[？成熟度？ ？]

387
00:17:11,589 --> 00:17:13,819
>> MATU：打印所有分數
在每一行上。

388
00:17:13,819 --> 00:17:14,900
這將打印每個分數
在一個單獨的行。

389
00:17:14,900 --> 00:17:16,300
>> JASON HIRSCHHORN：究竟
它會打印嗎？

390
00:17:16,300 --> 00:17:19,790
>> 學生：它會打印一個，
然後兩個，然後三個。

391
00:17:19,790 --> 00:17:20,235
>> JASON HIRSCHHORN：沒錯。

392
00:17:20,235 --> 00:17:23,490
它會打印一個，然後兩個，然後
三，每一個單獨的行，因為

393
00:17:23,490 --> 00:17:27,810
我們正在經歷的數組，你會
看到第二個，在printf

394
00:17:27,810 --> 00:17:29,275
聲明，分數。

395
00:17:29,275 --> 00:17:32,880
因此，在第一輪通過我們的
循環，i等於為零，這意味著我們

396
00:17:32,880 --> 00:17:34,640
獲得得分為零的值 - 

397
00:17:34,640 --> 00:17:36,900
其中，如果我們回去
我們的圖，是一個 - 

398
00:17:36,900 --> 00:17:38,630
並填寫 - 

399
00:17:38,630 --> 00:17:39,700
哦，它說。

400
00:17:39,700 --> 00:17:41,680
這應該為％d。

401
00:17:41,680 --> 00:17:43,970
我會解決這個問題有點
我的手，你們。

402
00:17:43,970 --> 00:17:48,670
但我們呈現一個整數，所以
這裡應該為％d，而不是％C。

403
00:17:48,670 --> 00:17:50,340
％c代表是什麼？

404
00:17:50,340 --> 00:17:50,790
>> 學生：字符。

405
00:17:50,790 --> 00:17:52,680
>> JASON HIRSCHHORN：性格，正是。

406
00:17:52,680 --> 00:17:53,690
另一種是什麼呢？

407
00:17:53,690 --> 00:17:56,260
如果你不想做一個％D
整數，還有什麼可以做什麼？

408
00:17:56,260 --> 00:17:57,000
>> 學生：我。

409
00:17:57,000 --> 00:17:59,180
>> JASON HIRSCHHORN％，完全相同。

410
00:17:59,180 --> 00:18:01,660
所以任何疑問迭代
通過數組？

411
00:18:01,660 --> 00:18:05,500

412
00:18:05,500 --> 00:18:07,800
所以會發生什麼，如果我們做到這一點嗎？

413
00:18:07,800 --> 00:18:10,290
而不是做i小於
三，我是少

414
00:18:10,290 --> 00:18:11,390
大於或等於3。

415
00:18:11,390 --> 00:18:13,420
當我們運行這段代碼，會發生什麼事？

416
00:18:13,420 --> 00:18:17,510

417
00:18:17,510 --> 00:18:18,940
是的，安妮？

418
00:18:18,940 --> 00:18:22,030
>> 學生：他們打算打印出來
第四行的怪異的東西。

419
00:18:22,030 --> 00:18:23,850
>> JASON HIRSCHHORN：所以你說的，是什麼
要打印出怪異的東西

420
00:18:23,850 --> 00:18:24,390
第四行嗎？

421
00:18:24,390 --> 00:18:25,750
沒有任何人有一個答案
她的問題？

422
00:18:25,750 --> 00:18:28,940

423
00:18:28,940 --> 00:18:33,160
所以賠率是當
我們得到的 - 

424
00:18:33,160 --> 00:18:36,700
通過我們對第四輪
循環，就像你想，安妮，

425
00:18:36,700 --> 00:18:39,430
這將是分數支架三，
我們已經想通了，不

426
00:18:39,430 --> 00:18:41,990
存在的，我們要去嘗試
和訪問，打印

427
00:18:41,990 --> 00:18:43,350
出來，用一些方式。

428
00:18:43,350 --> 00:18:46,060
所以電腦可能會
我們生氣。

429
00:18:46,060 --> 00:18:46,760
你說得對。

430
00:18:46,760 --> 00:18:48,830
>> 它可能完全退出程序。

431
00:18:48,830 --> 00:18:52,222
它可能會打印出來的東西
真不可思議。

432
00:18:52,222 --> 00:18:53,420
你不能說是肯定的。

433
00:18:53,420 --> 00:18:56,210
賠率是它可能會生氣
你，只是馬上退出。

434
00:18:56,210 --> 00:19:00,100
>> 但是，這是一個常見的錯誤，你就會有
你只是在關閉

435
00:19:00,100 --> 00:19:05,110
到底，這是一個錯誤，將
困擾你整個編碼。

436
00:19:05,110 --> 00:19:09,350

437
00:19:09,350 --> 00:19:14,150
我喜歡做的僅僅是在
白板，經過每次迭代

438
00:19:14,150 --> 00:19:18,190
手頭上或在紙上看到循環
發生了什麼，然後你

439
00:19:18,190 --> 00:19:20,440
普遍意識到，哦，等一下，我不應該
已經小於或

440
00:19:20,440 --> 00:19:20,870
等於三。

441
00:19:20,870 --> 00:19:24,730
，這是我應該停止在兩個
會發生什麼，如果你的條件

442
00:19:24,730 --> 00:19:26,206
超過三種。

443
00:19:26,206 --> 00:19:29,120
有任何疑問，這麼遠嗎？

444
00:19:29,120 --> 00:19:31,010
甜。

445
00:19:31,010 --> 00:19:33,360
>> 所以你打開你的電腦。

446
00:19:33,360 --> 00:19:36,760
我們要去給你兩到三個
分鐘寫一個程序，

447
00:19:36,760 --> 00:19:40,460
創建一個數組整數
通過五個，然後打印出每個

448
00:19:40,460 --> 00:19:41,720
在新的一行的整數。

449
00:19:41,720 --> 00:19:44,330

450
00:19:44,330 --> 00:19:46,000
如果您有任何疑問，
舉起你的手。

451
00:19:46,000 --> 00:19:48,140
我很高興來的。

452
00:19:48,140 --> 00:19:50,630
就像我說的，讓我們採取三種
分鐘來寫這篇文章。

453
00:19:50,630 --> 00:20:41,300

454
00:20:41,300 --> 00:20:45,110
是所有人都好，如果我去一個
新窗口，並關閉此？

455
00:20:45,110 --> 00:22:13,420

456
00:22:13,420 --> 00:22:15,520
>> 對不起，如果你還沒有機會
完成，但我們要做到這一點

457
00:22:15,520 --> 00:22:17,310
現在一起。

458
00:22:17,310 --> 00:22:23,640
所以在屏幕上，我的＃include
cs50.h＃包括stdio.h中。

459
00:22:23,640 --> 00:22:26,090
有人可以告訴我是什麼
這兩行辦？

460
00:22:26,090 --> 00:22:32,250

461
00:22:32,250 --> 00:22:33,155
邁克爾？

462
00:22:33,155 --> 00:22:40,030
>> 學生：他們包括庫
CS50和史蒂夫

463
00:22:40,030 --> 00:22:44,210
保存供您使用
使您的生活更輕鬆。

464
00:22:44,210 --> 00:22:46,820
>> JASON HIRSCHHORN：所以你說他們
包括圖書館，一個CS50

465
00:22:46,820 --> 00:22:51,230
，cs50.h，另一種是
只是標準，自帶

466
00:22:51,230 --> 00:22:53,510
C包，stdio.h中。

467
00:22:53,510 --> 00:22:54,890
你是什​​麼意思，包括
圖書館，雖然？

468
00:22:54,890 --> 00:22:55,770
你能更具體一點嗎？

469
00:22:55,770 --> 00:23:01,180
>> 學生：它使得你可以
使用某些碼字有

470
00:23:01,180 --> 00:23:05,710
不必去功能發生
c的功能自己。

471
00:23:05,710 --> 00:23:08,730
>> JASON HIRSCHHORN：你能
給我一個例子嗎？

472
00:23:08,730 --> 00:23:11,160
>> 學生：喜歡的printf
是您可以使用。

473
00:23:11,160 --> 00:23:11,860
>> JASON HIRSCHHORN：printf的。

474
00:23:11,860 --> 00:23:14,680
所以，你說的printf是那些
功能而不必

475
00:23:14,680 --> 00:23:19,840
寫上自己的printf，printf是
實際上包含stdio.h中，所以你

476
00:23:19,840 --> 00:23:22,010
可以只使用它，並承擔
它會奏效。

477
00:23:22,010 --> 00:23:28,270
stdio.h中，如果打開了這個文件，
這包括如何的printf

478
00:23:28,270 --> 00:23:31,620
作品，所有的代碼為printf？

479
00:23:31,620 --> 00:23:33,105
你為什麼搖頭？

480
00:23:33,105 --> 00:23:35,710
>> 學生：因為剛才的頭文件
包括函數的聲明。

481
00:23:35,710 --> 00:23:36,400
>> JASON HIRSCHHORN：完全正確。

482
00:23:36,400 --> 00:23:39,680
頭文件只是包括
在函數聲明。

483
00:23:39,680 --> 00:23:42,950
所以基本上，當你編譯這個，
打計數，我們將做一個

484
00:23:42,950 --> 00:23:48,070
第二，編譯器知道，如果
使用了printf printf的存在。

485
00:23:48,070 --> 00:23:49,370
這是怎麼回事某處被定義。

486
00:23:49,370 --> 00:23:51,200
這不是一個問題，你使用它。

487
00:23:51,200 --> 00:23:55,490
再後來，它會包括
實際上包含的和為零

488
00:23:55,490 --> 00:23:58,360
printf的實施和
將其與你的代碼。

489
00:23:58,360 --> 00:24:01,935
你如何確保它包括
的和零點，也就是說，得到的字符串？

490
00:24:01,935 --> 00:24:05,670

491
00:24:05,670 --> 00:24:07,210
>> 學生：獲取字符串cs50.h.

492
00:24:07,210 --> 00:24:07,830
>> JASON HIRSCHHORN：右。

493
00:24:07,830 --> 00:24:11,110
所以說得到的字符串存在，
在函數聲明。

494
00:24:11,110 --> 00:24:15,410
但隨後的1和0的二進制
文件實際上包含

495
00:24:15,410 --> 00:24:17,370
實施獲取字符串？

496
00:24:17,370 --> 00:24:19,310
你如何確保
與你的程序？

497
00:24:19,310 --> 00:24:23,220
>> 學生：通過連接器
命令行參數。

498
00:24:23,220 --> 00:24:25,430
>> JASON HIRSCHHORN：通過連接器
在命令行參數。

499
00:24:25,430 --> 00:24:26,700
你怎麼做到這一點呢？

500
00:24:26,700 --> 00:24:29,730
>> 學生：這是鐺-L線

501
00:24:29,730 --> 00:24:30,480
>> JASON HIRSCHHORN：完全正確。

502
00:24:30,480 --> 00:24:32,900
你說CS50-L，對不對？

503
00:24:32,900 --> 00:24:34,940
這包括那些和零。

504
00:24:34,940 --> 00:24:36,460
>> 學生：但要確實
為你，對不對？

505
00:24:36,460 --> 00:24:37,010
>> JASON HIRSCHHORN：沒錯。

506
00:24:37,010 --> 00:24:40,390
make沒有你，但最終，
你不會有廠名，或

507
00:24:40,390 --> 00:24:43,220
你就得做出
你自己的，所以這是一個

508
00:24:43,220 --> 00:24:43,940
好事要記住。

509
00:24:43,940 --> 00:24:47,350
如果你要使用其中的一個
其他圖書館，你不僅有

510
00:24:47,350 --> 00:24:49,490
寫＃
然後圖書館。

511
00:24:49,490 --> 00:24:51,420
您還需要與其鏈接。

512
00:24:51,420 --> 00:24:54,480
而這兩件事情是不同的。
-L CS50是不同的

513
00:24:54,480 --> 00:24:59,260
＃cs50.h.

514
00:24:59,260 --> 00:25:02,870
>> 然後我們有INT主要無效花括號，
現在我們要去代碼

515
00:25:02,870 --> 00:25:03,590
主內。

516
00:25:03,590 --> 00:25:07,090
我這裡有第一行是註釋
說，創建一個數組

517
00:25:07,090 --> 00:25:08,820
與int的一到五。

518
00:25:08,820 --> 00:25:12,600
什麼是一個很好的詞來形容我
現在在屏幕上，只是

519
00:25:12,600 --> 00:25:14,170
裡面主要的意見？

520
00:25:14,170 --> 00:25:15,722
我們稱之為什麼呢？

521
00:25:15,722 --> 00:25:16,820
>> 學生：偽代碼。

522
00:25:16,820 --> 00:25:17,840
>> JASON HIRSCHHORN：偽代碼。

523
00:25:17,840 --> 00:25:18,420
謝謝你，杰弗裡。

524
00:25:18,420 --> 00:25:19,540
這是完全正確的。

525
00:25:19,540 --> 00:25:20,005
偽代碼。

526
00:25:20,005 --> 00:25:22,854
有你們之前見過的偽代碼？

527
00:25:22,854 --> 00:25:28,340
舉起你的手，如果你使用
問題的偽代碼之前設置一個。

528
00:25:28,340 --> 00:25:29,400
關於你的一半。

529
00:25:29,400 --> 00:25:32,700
>> 我會強烈建議使用
偽代碼問題

530
00:25:32,700 --> 00:25:35,210
更小，更容易咬掉件。

531
00:25:35,210 --> 00:25:38,630
另外，如果你做偽代碼，你
您的意見已經在很大程度上

532
00:25:38,630 --> 00:25:40,760
內置的，所以你不要有
回去揣摩

533
00:25:40,760 --> 00:25:42,450
你在做什麼。

534
00:25:42,450 --> 00:25:44,730
因此，有人可以給我這個第一線
創建一個數組int類型之一

535
00:25:44,730 --> 00:25:45,980
通過五個？

536
00:25:45,980 --> 00:25:48,700

537
00:25:48,700 --> 00:25:49,130
你呢？

538
00:25:49,130 --> 00:25:53,350
>> 學生：詮釋，然後你可以調用
任何號碼，然後方

539
00:25:53,350 --> 00:25:54,830
支架五。

540
00:25:54,830 --> 00:25:57,820
>> JASON HIRSCHHORN：所以整型數，
方形支架五個。

541
00:25:57,820 --> 00:25:59,160
>> 學生：等於，
然後大括號。

542
00:25:59,160 --> 00:26:00,830
>> JASON HIRSCHHORN：等於，
大括號。

543
00:26:00,830 --> 00:26:01,830
>> 學生：一，二，三，四。

544
00:26:01,830 --> 00:26:05,566
>> JASON HIRSCHHORN：一，二，
三，四，五。

545
00:26:05,566 --> 00:26:07,390
>> 學生：那麼大括號
然後分號。

546
00:26:07,390 --> 00:26:09,240
>> JASON HIRSCHHORN和捲曲
括號和分號。

547
00:26:09,240 --> 00:26:10,330
優秀的。

548
00:26:10,330 --> 00:26:12,210
打印出每個INT在新的一行。

549
00:26:12,210 --> 00:26:17,140
可以給別人
我該代碼，好嗎？

550
00:26:17,140 --> 00:26:17,530
[？成熟度？ ？]

551
00:26:17,530 --> 00:26:18,560
來吧。

552
00:26:18,560 --> 00:26:20,440
>> 學生：（

553
00:26:20,440 --> 00:26:21,750
>> JASON HIRSCHHORN：（

554
00:26:21,750 --> 00:26:23,740
>> 學生：INT I = 0

555
00:26:23,740 --> 00:26:26,070
>> JASON HIRSCHHORN：INT I = 0

556
00:26:26,070 --> 00:26:28,190
>> 學生：分號我不到五。

557
00:26:28,190 --> 00:26:31,680
>> JASON HIRSCHHORN：分號，
我小於5。

558
00:26:31,680 --> 00:26:33,600
>> 學生：分號，我+ +。

559
00:26:33,600 --> 00:26:35,140
>> JASON HIRSCHHORN：分號，I + +。

560
00:26:35,140 --> 00:26:37,720
>> 學生：休息括號，
然後開括號。

561
00:26:37,720 --> 00:26:39,410
>> JASON HIRSCHHORN：休息括號
兩個大括號。

562
00:26:39,410 --> 00:26:40,510
在大括號內？

563
00:26:40,510 --> 00:26:47,640
>> 學生：當時的printf“％D / N”

564
00:26:47,640 --> 00:26:48,695
>> JASON HIRSCHHORN：很抱歉，挺住。

565
00:26:48,695 --> 00:26:52,330
printf的“％D / N，封閉的引號。

566
00:26:52,330 --> 00:26:55,980
>> 學生：那麼封閉報價，
逗號，計數，支架I。

567
00:26:55,980 --> 00:26:58,350
>> JASON HIRSCHHORN：逗號，
數，支架í。

568
00:26:58,350 --> 00:26:59,970
>> 學生：對不起，數字支架。

569
00:26:59,970 --> 00:27:01,416
>> 的JASON HIRSCHHORN：數字，支架I。

570
00:27:01,416 --> 00:27:03,200
>> 學生：對不起。

571
00:27:03,200 --> 00:27:04,750
然後關閉括號，
分號。

572
00:27:04,750 --> 00:27:07,156
>> JASON HIRSCHHORN：休息
括號，分號。

573
00:27:07,156 --> 00:27:08,680
我要去拯救。

574
00:27:08,680 --> 00:27:12,670
我們要去計數。

575
00:27:12,670 --> 00:27:14,742
我怎麼運行計數？

576
00:27:14,742 --> 00:27:16,470
>> 學生：反斜杠。

577
00:27:16,470 --> 00:27:17,180
>> 學生：點斜杠 - 

578
00:27:17,180 --> 00:27:18,050
>> JASON HIRSCHHORN：。/計數，準確。

579
00:27:18,050 --> 00:27:19,380
謝謝。 /計數。

580
00:27:19,380 --> 00:27:21,060
一，二，三，四，
五個新的生產線。

581
00:27:21,060 --> 00:27:22,110
看起來像它的工作。

582
00:27:22,110 --> 00:27:23,200
是的，諾亞？

583
00:27:23,200 --> 00:27:26,660
>> 學生：你也可以做到小於或
等於4，如i小於

584
00:27:26,660 --> 00:27:27,630
或等於4？

585
00:27:27,630 --> 00:27:31,190
少做有什麼優勢
五，或只是以不同的方式

586
00:27:31,190 --> 00:27:31,610
寫它呢？

587
00:27:31,610 --> 00:27:35,280
>> JASON HIRSCHHORN：所以，問題是你
可以做得i是小於或

588
00:27:35,280 --> 00:27:37,450
等於四，而不是
i是少於五個。

589
00:27:37,450 --> 00:27:38,935
又會有同樣的工作嗎？

590
00:27:38,935 --> 00:27:39,760
>> 學生：它應該。

591
00:27:39,760 --> 00:27:39,860
>> JASON HIRSCHHORN：是的。

592
00:27:39,860 --> 00:27:41,660
它完全將工作一樣。

593
00:27:41,660 --> 00:27:44,780
在文體上，它是一般小於
你會看到在第二個時

594
00:27:44,780 --> 00:27:48,160
我們的字符串，可以使用的東西
調用strlen的，你見過

595
00:27:48,160 --> 00:27:50,380
之前，來取得長度
的字符串。

596
00:27:50,380 --> 00:27:54,090
你不能小於
或等於strlen的。

597
00:27:54,090 --> 00:27:56,500
你可以做到小於或
等於strlen的減一。

598
00:27:56,500 --> 00:27:59,260
所以它只是更好
做小於strlen的。

599
00:27:59,260 --> 00:28:00,240
是嗎？

600
00:28:00,240 --> 00:28:03,270
>> 學生：在實際測驗，
我們必須提供我們的意見

601
00:28:03,270 --> 00:28:04,620
代碼呢？

602
00:28:04,620 --> 00:28:06,130
>> JASON HIRSCHHORN：問題
測驗，你

603
00:28:06,130 --> 00:28:07,760
有提供意見？

604
00:28:07,760 --> 00:28:12,050
因此，我們會更多地談到測驗時
他們來了，但一般來說，一個好的

605
00:28:12,050 --> 00:28:14,530
經驗法則是，只要你
編寫代碼，提供意見。

606
00:28:14,530 --> 00:28:18,130
如果你得到的代碼錯了，但
發表意見的權利，你可能會得到一些

607
00:28:18,130 --> 00:28:22,280
信貸從我，如果我是分級
您的問題集，或交了白卷。

608
00:28:22,280 --> 00:28:24,660
因此，意見總是
好來提供。

609
00:28:24,660 --> 00:28:25,040
甜。

610
00:28:25,040 --> 00:28:25,460
計數。

611
00:28:25,460 --> 00:28:26,720
出色的工作。

612
00:28:26,720 --> 00:28:28,570
讓我們繼續前進。

613
00:28:28,570 --> 00:28:29,920
>> 字符串。

614
00:28:29,920 --> 00:28:30,630
字符串。

615
00:28:30,630 --> 00:28:31,730
我們已經看到了這個講座之前。

616
00:28:31,730 --> 00:28:33,390
吹我的腦海裡，當我
首先發現了這一點。

617
00:28:33,390 --> 00:28:37,240
它可能沒有任何人吹的
想到這裡，不過沒關係。

618
00:28:37,240 --> 00:28:41,260
>> 字符串是字符數組，
他們最終，正如你自己所說，

619
00:28:41,260 --> 00:28:45,710
空終結者，
這是/ 0個字符。

620
00:28:45,710 --> 00:28:47,740
如果我們要畫一個串上
板，我們將它畫在這裡。

621
00:28:47,740 --> 00:28:53,080

622
00:28:53,080 --> 00:28:56,420
所以，這是字符串有多長？

623
00:28:56,420 --> 00:28:56,680
抱歉。

624
00:28:56,680 --> 00:28:57,660
這是字符串有多長？

625
00:28:57,660 --> 00:28:57,910
>> 學生：[聽不清]。

626
00:28:57,910 --> 00:28:59,010
>> JASON HIRSCHHORN：四？

627
00:28:59,010 --> 00:28:59,880
為什麼是四個呢？

628
00:28:59,880 --> 00:29:02,240
>> 學生：因為第五位
是空字符。

629
00:29:02,240 --> 00:29:04,070
>> JASON HIRSCHHORN：所以第五位
是空字符。

630
00:29:04,070 --> 00:29:07,130
所以，如果我上運行的strlen
這一點，那就給我4。

631
00:29:07,130 --> 00:29:07,850
正確。

632
00:29:07,850 --> 00:29:11,640
而陣中，不過，如果我是
初始化這個數組，多少個空格

633
00:29:11,640 --> 00:29:13,444
我要問的嗎？

634
00:29:13,444 --> 00:29:13,821
>> 學生：五。

635
00:29:13,821 --> 00:29:14,200
>> JASON HIRSCHHORN：五。

636
00:29:14,200 --> 00:29:17,650
我不得不問五，但我可以
在這裡只把四個字符

637
00:29:17,650 --> 00:29:19,750
因為我需要把這些空
終結者就結束了。

638
00:29:19,750 --> 00:29:25,260
因此，我們打算寫“ohai”
把空終止符結束時。

639
00:29:25,260 --> 00:29:31,820

640
00:29:31,820 --> 00:29:34,940
我們會說這是串
s等於這一點。

641
00:29:34,940 --> 00:29:36,610
什麼是支架為零？

642
00:29:36,610 --> 00:29:40,210

643
00:29:40,210 --> 00:29:41,550
Ş支架零，安妮？

644
00:29:41,550 --> 00:29:41,950
>> 學生：O。

645
00:29:41,950 --> 00:29:45,400
>> JASON HIRSCHHORN：O型，正好。
Ş支架？

646
00:29:45,400 --> 00:29:48,200
Ş支架五？

647
00:29:48,200 --> 00:29:52,670

648
00:29:52,670 --> 00:29:53,955
Ş支架五？

649
00:29:53,955 --> 00:29:54,740
>> 學生：不存在。

650
00:29:54,740 --> 00:29:55,040
>> JASON HIRSCHHORN：不存在。

651
00:29:55,040 --> 00:29:57,050
完全正確。

652
00:29:57,050 --> 00:29:57,940
涼爽。

653
00:29:57,940 --> 00:30:03,120
任何理解問題
字符數組，字符串？

654
00:30:03,120 --> 00:30:03,870
OK，然後。

655
00:30:03,870 --> 00:30:05,440
你們更多的程序。

656
00:30:05,440 --> 00:30:09,190
寫一個程序，要求用戶
一個字符串，然後打印出每個

657
00:30:09,190 --> 00:30:11,880
在新的一行字符。

658
00:30:11,880 --> 00:30:14,160
因此，讓我們三分鐘的時間寫
這個程序，然後，我們將對其進行編碼

659
00:30:14,160 --> 00:30:15,410
作為一個群體。

660
00:30:15,410 --> 00:31:04,730

661
00:31:04,730 --> 00:31:04,830
>> 抱歉。

662
00:31:04,830 --> 00:31:06,470
你需要看到這一點嗎？

663
00:31:06,470 --> 00:31:07,410
>> 學生：

664
00:31:07,410 --> 00:31:08,660
>> JASON HIRSCHHORN：確定。

665
00:31:08,660 --> 00:31:36,390

666
00:31:36,390 --> 00:31:40,605
讓我們多一分鐘的代碼這一點，
或至少​​開始瀏覽網頁就可以了。

667
00:31:40,605 --> 00:32:13,900

668
00:32:13,900 --> 00:32:17,020
>> 所以，你可以繼續工作，但我要去
開始經歷它。

669
00:32:17,020 --> 00:32:22,560
像以前一樣，我在屏幕上
＃＃cs50.h，包括stdio.h中。

670
00:32:22,560 --> 00:32:24,020
int類型主作廢。

671
00:32:24,020 --> 00:32:28,880
主要的大括號內，我有
兩點意見，偽代碼。

672
00:32:28,880 --> 00:32:30,980
其一是要求一個來自用戶的字符串。

673
00:32:30,980 --> 00:32:33,900
二是打印出每個人
在新的一行字符。

674
00:32:33,900 --> 00:32:39,780
所以，安娜，你能不能給我問
一個來自用戶的字符串？

675
00:32:39,780 --> 00:32:41,970
>> 學生：printf的。

676
00:32:41,970 --> 00:32:42,720
>> JASON HIRSCHHORN：printf的？

677
00:32:42,720 --> 00:32:45,050
>> 學生：是的。

678
00:32:45,050 --> 00:32:46,165
（

679
00:32:46,165 --> 00:32:47,610
>> JASON HIRSCHHORN：（

680
00:32:47,610 --> 00:32:49,300
>> 學生：“給我一個字符串。

681
00:32:49,300 --> 00:32:52,380
>> JASON HIRSCHHORN：“給
我STR  - 哎呀 - 

682
00:32:52,380 --> 00:32:53,710
字符串。

683
00:32:53,710 --> 00:32:59,980
>> 學生：/ N“）分號。

684
00:32:59,980 --> 00:33:02,300
>> JASON HIRSCHHORN：結束的字符串，
閉合的括號，分號。

685
00:33:02,300 --> 00:33:03,550
>> 學生：是的。

686
00:33:03,550 --> 00:33:09,080
然後，下一行，串
S =得到的字符串。

687
00:33:09,080 --> 00:33:11,240
>> JASON HIRSCHHORN：字符串
S =得到的字符串。

688
00:33:11,240 --> 00:33:11,665
>> 學生：是的。

689
00:33:11,665 --> 00:33:13,080
然後是（）

690
00:33:13,080 --> 00:33:14,365
>> JASON HIRSCHHORN：（）

691
00:33:14,365 --> 00:33:14,720
>> 學生：分號。

692
00:33:14,720 --> 00:33:15,540
>> JASON HIRSCHHORN：分號。

693
00:33:15,540 --> 00:33:16,890
太棒了。

694
00:33:16,890 --> 00:33:19,000
所以我要得到一個字符串
我要保存在什麼？

695
00:33:19,000 --> 00:33:21,830
什麼是變量
您創建的嗎？

696
00:33:21,830 --> 00:33:23,290
>> 學生：String的。

697
00:33:23,290 --> 00:33:24,580
>> JASON HIRSCHHORN：變量
稱為s。

698
00:33:24,580 --> 00:33:25,700
字符串類型。

699
00:33:25,700 --> 00:33:27,200
沒錯。

700
00:33:27,200 --> 00:33:30,080
接下來的事情，我們要的是打印出來
每個字符在新的一行。

701
00:33:30,080 --> 00:33:31,710
誰可以給我代碼嗎？

702
00:33:31,710 --> 00:33:32,110
[聽不清]？

703
00:33:32,110 --> 00:33:33,000
你可以把它給我嗎？

704
00:33:33,000 --> 00:33:33,580
>> 學生：當然。

705
00:33:33,580 --> 00:33:35,420
>> JASON HIRSCHHORN：讓我們做吧。

706
00:33:35,420 --> 00:33:36,080
對不起。

707
00:33:36,080 --> 00:33:38,896
我不喜歡重複你說的話
因為你得到它的權利，但我

708
00:33:38,896 --> 00:33:42,100
有重複，當他們
抄寫這一點，他們可以得到所有

709
00:33:42,100 --> 00:33:44,870
的文本改編出來。

710
00:33:44,870 --> 00:33:47,180
所以，你可以繼續說話。

711
00:33:47,180 --> 00:33:48,590
不幸的是，我有
說你。

712
00:33:48,590 --> 00:33:49,510
我很抱歉，但 - 

713
00:33:49,510 --> 00:33:50,610
>> 學生：那很好。

714
00:33:50,610 --> 00:33:53,010
對於INT I = 0

715
00:33:53,010 --> 00:33:54,170
>> JASON HIRSCHHORN：INT I = 0

716
00:33:54,170 --> 00:33:56,740
>> 學生：我小於 - 

717
00:33:56,740 --> 00:33:58,206
>> JASON HIRSCHHORN：分號。

718
00:33:58,206 --> 00:34:00,650
>> 學生：在此之前，我們可以把一個
可變的，所以你得到的int名長度？

719
00:34:00,650 --> 00:34:01,870
>> JASON HIRSCHHORN：哦，你不要
想要把分號？

720
00:34:01,870 --> 00:34:02,310
確定。

721
00:34:02,310 --> 00:34:05,120
所以，你想要什麼後做零？

722
00:34:05,120 --> 00:34:09,340
>> 學生：我想要得到的
字符串的長度和

723
00:34:09,340 --> 00:34:10,410
設置到一個變量？

724
00:34:10,410 --> 00:34:11,760
>> JASON HIRSCHHORN：OK，
所以我怎麼做呢？

725
00:34:11,760 --> 00:34:17,636
>> 學生：所以你做INT長度=

726
00:34:17,636 --> 00:34:20,010
>> JASON HIRSCHHORN：詮釋長度=

727
00:34:20,010 --> 00:34:22,230
>> 學生：S-T-R-L-E-N。

728
00:34:22,230 --> 00:34:24,260
>> JASON HIRSCHHORN：S-T-R-L-E-Ñ - 

729
00:34:24,260 --> 00:34:25,380
>> 學生：的​​S。

730
00:34:25,380 --> 00:34:25,790
括號內。

731
00:34:25,790 --> 00:34:27,920
>> JASON HIRSCHHORN：（S）。

732
00:34:27,920 --> 00:34:33,040
>> 學生：那麼我認為你必須
把兩個整數之間用分號隔開。

733
00:34:33,040 --> 00:34:34,590
>> JASON HIRSCHHORN：分號
零後？

734
00:34:34,590 --> 00:34:35,260
>> 學生：是啊。

735
00:34:35,260 --> 00:34:40,670
然後放一個分號後，
你說，我不到長度。

736
00:34:40,670 --> 00:34:43,250
我長度小於
是可變的。

737
00:34:43,250 --> 00:34:44,590
>> 學生：分號。

738
00:34:44,590 --> 00:34:45,790
>> JASON HIRSCHHORN：分號。

739
00:34:45,790 --> 00:34:46,290
>> 學生：我+ +。

740
00:34:46,290 --> 00:34:46,909
>> JASON HIRSCHHORN：我+ +。

741
00:34:46,909 --> 00:34:47,530
還有我們的for循環。

742
00:34:47,530 --> 00:34:48,860
OK，在for循環中。

743
00:34:48,860 --> 00:34:51,670
>> 學生：然後做的printf。

744
00:34:51,670 --> 00:34:53,340
>> JASON HIRSCHHORN：printf的。

745
00:34:53,340 --> 00:34:53,889
>> 學生：括號內。

746
00:34:53,889 --> 00:34:55,130
>> 的JASON HIRSCHHORN：括號，報價。

747
00:34:55,130 --> 00:34:59,930
>> 學生：括號，引號，％C / N。

748
00:34:59,930 --> 00:35:00,760
>> JASON HIRSCHHORN：％C，“確定”。

749
00:35:00,760 --> 00:35:01,670
>> 學生：/ N。

750
00:35:01,670 --> 00:35:03,470
>> JASON HIRSCHHORN / N。

751
00:35:03,470 --> 00:35:04,410
>> 學生：休息的報價。

752
00:35:04,410 --> 00:35:05,270
>> JASON HIRSCHHORN：閉合的引號。

753
00:35:05,270 --> 00:35:05,810
>> 學生：逗號。

754
00:35:05,810 --> 00:35:06,860
>> JASON HIRSCHHORN：逗號。

755
00:35:06,860 --> 00:35:07,800
>> 學生：S.

756
00:35:07,800 --> 00:35:08,070
>> JASON HIRSCHHORN：S。

757
00:35:08,070 --> 00:35:08,690
>> 學生：支架。

758
00:35:08,690 --> 00:35:10,230
>> JASON HIRSCHHORN：支架I。

759
00:35:10,230 --> 00:35:11,520
>> 學生：然後關閉括號。

760
00:35:11,520 --> 00:35:12,540
>> JASON HIRSCHHORN：封閉括號。

761
00:35:12,540 --> 00:35:13,660
>> 學生：分號。

762
00:35:13,660 --> 00:35:13,770
>> JASON HIRSCHHORN：分號。

763
00:35:13,770 --> 00:35:14,380
太棒了。

764
00:35:14,380 --> 00:35:16,890
因此，讓我們保存這個。

765
00:35:16,890 --> 00:35:19,770
讓拼寫。

766
00:35:19,770 --> 00:35:20,040
哦，男孩。

767
00:35:20,040 --> 00:35:22,275
我有一對夫婦的錯誤。

768
00:35:22,275 --> 00:35:33,120
第11行的第一個錯誤，它說，
預期表達，它給

769
00:35:33,120 --> 00:35:36,910
我的錯誤，第二
整型，有錯誤。

770
00:35:36,910 --> 00:35:38,430
有一些錯誤圍在那裡。

771
00:35:38,430 --> 00:35:41,060
有誰知道什麼樣的錯誤，是嗎？

772
00:35:41,060 --> 00:35:41,640
庫爾特？

773
00:35:41,640 --> 00:35:44,108
>> 學生：我認為它應該
是一個逗號，而不是一個分號。

774
00:35:44,108 --> 00:35:46,010
>> ，JASON HIRSCHHORN：OK，逗號
而不是分號。

775
00:35:46,010 --> 00:35:47,340
因此，我們需要修復？

776
00:35:47,340 --> 00:35:47,655
>> 學生：

777
00:35:47,655 --> 00:35:48,930
>> JASON HIRSCHHORN：還有什麼
我們需要修正？

778
00:35:48,930 --> 00:35:50,920
>> 學生：我們有包括string.h中。

779
00:35:50,920 --> 00:35:51,680
>> JASON HIRSCHHORN：包括string.h中。

780
00:35:51,680 --> 00:35:53,730
在哪裡我需要的是什麼？

781
00:35:53,730 --> 00:35:57,085
>> 學生：同一個地方，你包括
其他的東西，右

782
00:35:57,085 --> 00:35:59,560
之後包括stdio.h中。

783
00:35:59,560 --> 00:36:01,610
>> JASON HIRSCHHORN：讓我們來看看如果這樣運行
首先是因為一般來說，我喜歡

784
00:36:01,610 --> 00:36:06,360
解決一件事第一，然後運行
它，然後看看我們得到的錯誤。

785
00:36:06,360 --> 00:36:11,620
因此，我們要清除終端
與控制n，讓我們做法術。

786
00:36:11,620 --> 00:36:15,190

787
00:36:15,190 --> 00:36:18,770
因此，第11行的另一個錯誤。

788
00:36:18,770 --> 00:36:20,540
預期分號。

789
00:36:20,540 --> 00:36:22,640
而且我還得到
此線路上的錯誤。

790
00:36:22,640 --> 00:36:25,270
所以，還沒有給我一個錯誤說
不明白strlen的是，

791
00:36:25,270 --> 00:36:28,980
但它給我的錯誤
行，所以什麼是錯的？

792
00:36:28,980 --> 00:36:29,690
馬克？

793
00:36:29,690 --> 00:36:30,940
馬庫斯。

794
00:36:30,940 --> 00:36:32,570
>> 學生：你必須刪除
第二個int類型聲明？

795
00:36:32,570 --> 00:36:34,990
>> JASON HIRSCHHORN：刪除
第二個int。

796
00:36:34,990 --> 00:36:35,710
讓我們試試這個。

797
00:36:35,710 --> 00:36:37,600
現在清除的終端。

798
00:36:37,600 --> 00:36:40,130
讓拼寫。

799
00:36:40,130 --> 00:36:40,490
錯誤。

800
00:36:40,490 --> 00:36:42,890
隱式聲明庫
strlen函數。

801
00:36:42,890 --> 00:36:44,270
所以，現在我們看到這個錯誤。

802
00:36:44,270 --> 00:36:45,760
我們需要包括什麼？

803
00:36:45,760 --> 00:36:46,660
>> 學生：string.h中。

804
00:36:46,660 --> 00:36:51,880
>> JASON HIRSCHHORN：包括string.h中，
我們要做的＃include string.h中的頂部

805
00:36:51,880 --> 00:36:52,920
在屏幕上。

806
00:36:52,920 --> 00:36:55,450
讓我們保存，拼寫。

807
00:36:55,450 --> 00:36:56,970
現在編譯。

808
00:36:56,970 --> 00:37:01,970
所以，再一次的事情，我們需要
記得在for循環時，12號線

809
00:37:01,970 --> 00:37:08,010
我們設置它，INT I = 0，
長度= strlen的（）。

810
00:37:08,010 --> 00:37:09,350
>> 這是一個很好的策略。

811
00:37:09,350 --> 00:37:12,590
這樣的風格是偉大的，
這是偉大的設計。

812
00:37:12,590 --> 00:37:15,620
我們可以進入這些原因後，
但這樣一來，你只需要調用

813
00:37:15,620 --> 00:37:19,040
strlen的一次，而不是每一個
時間運行循環。

814
00:37:19,040 --> 00:37:22,255
但是，您需要使用一個逗號
你不需要重新詮釋。

815
00:37:22,255 --> 00:37:24,180
如果你宣布這兩個
變量在一起，你

816
00:37:24,180 --> 00:37:26,850
不需要再次詮釋。

817
00:37:26,850 --> 00:37:29,820
然後，如果你要使用strlen
這是另一種庫

818
00:37:29,820 --> 00:37:33,560
的功能不包括在
stdio.h中或cs50.h的的，使

819
00:37:33,560 --> 00:37:35,310
一定要包括string.h中。

820
00:37:35,310 --> 00:37:35,900
庫爾特？

821
00:37:35,900 --> 00:37:39,085
>> 學生：那麼，如果你並不需要
說是什麼類型的長度，是否

822
00:37:39,085 --> 00:37:40,290
意味著它必須是一個int？

823
00:37:40,290 --> 00:37:41,930
你不能有兩個不同的
類型嗎？

824
00:37:41,930 --> 00:37:43,290
>> JASON HIRSCHHORN：所以，你可以
有兩種不同的類型。

825
00:37:43,290 --> 00:37:45,730
長度是一個int在這裡，雖然。

826
00:37:45,730 --> 00:37:48,590
長度是一個int，因為它是逗號
然後同樣的事情。

827
00:37:48,590 --> 00:37:50,460
>> 學生：所以它假定它是怎麼回事
作為第一個是相同的嗎？

828
00:37:50,460 --> 00:37:52,423
>> JASON HIRSCHHORN：沒錯。

829
00:37:52,423 --> 00:37:54,970
我們不打算現在做到這一點，但你
可以包括兩個變量對

830
00:37:54,970 --> 00:37:57,080
同一個聯機使用一種數據類型。

831
00:37:57,080 --> 00:38:01,415
所以詮釋的x，y將創建
兩個變量。

832
00:38:01,415 --> 00:38:05,830

833
00:38:05,830 --> 00:38:10,770
因此，整數X，Y，如果我們做的是，它給
我一個未使用的變量x和y，因為

834
00:38:10,770 --> 00:38:12,020
我們不使用它們。

835
00:38:12,020 --> 00:38:17,950

836
00:38:17,950 --> 00:38:21,650
所以把無效之前，僅僅是一個
花哨的技巧，如果你不使用

837
00:38:21,650 --> 00:38:22,810
的東西，要使用它。

838
00:38:22,810 --> 00:38:26,300
但是，正如你看到的，我創建了x和y
在同一線路上用逗號。

839
00:38:26,300 --> 00:38:28,450
它創建兩個整數
就在這裡。

840
00:38:28,450 --> 00:38:31,560
所以，是的，完全可以創建
兩件事情在同一行上

841
00:38:31,560 --> 00:38:33,720
用逗號分隔。

842
00:38:33,720 --> 00:38:35,470
讓我們擺脫這些，雖然。

843
00:38:35,470 --> 00:38:36,370
>> 因此，有法術。

844
00:38:36,370 --> 00:38:39,200
謝謝你們為我們編碼。

845
00:38:39,200 --> 00:38:43,040
讓我們把它更多的時間，運行它。

846
00:38:43,040 --> 00:38:44,580
給我一個字符串。

847
00:38:44,580 --> 00:38:45,580
[聽不清]，你做了大部分。

848
00:38:45,580 --> 00:38:47,910
字符串是什麼？

849
00:38:47,910 --> 00:38:48,250
>> 學生：您好。

850
00:38:48,250 --> 00:38:50,110
>> JASON HIRSCHHORN：你好。

851
00:38:50,110 --> 00:38:52,810
H-E-L-L-O，同一行上的每個字符。

852
00:38:52,810 --> 00:38:53,700
看起來不錯。

853
00:38:53,700 --> 00:38:54,750
讓我們再次運行它。

854
00:38:54,750 --> 00:38:56,050
總是要檢查
為一角案件。

855
00:38:56,050 --> 00:38:57,750
有什麼好的角落的情況進行檢查？

856
00:38:57,750 --> 00:39:00,250

857
00:39:00,250 --> 00:39:00,890
>> 學生：多少？

858
00:39:00,890 --> 00:39:02,240
>> JASON HIRSCHHORN：一個數字。

859
00:39:02,240 --> 00:39:06,580
所以，我會投入1，它打印出1。

860
00:39:06,580 --> 00:39:08,970
它不要求的信件，所以
它看起來像數字工作。

861
00:39:08,970 --> 00:39:09,890
好角落的情況進行檢查。

862
00:39:09,890 --> 00:39:11,740
什麼是另一個很好的角落
檢查的情況？

863
00:39:11,740 --> 00:39:12,420
>> 學生：一個空字符串。

864
00:39:12,420 --> 00:39:12,910
>> JASON HIRSCHHORN：嗯？

865
00:39:12,910 --> 00:39:13,880
>> 學生：喜歡一個空字符串。

866
00:39:13,880 --> 00:39:14,400
>> JASON HIRSCHHORN：空字符串。

867
00:39:14,400 --> 00:39:16,730
所以，讓我們不要把任何東西。

868
00:39:16,730 --> 00:39:18,660
什麼被打印出來？

869
00:39:18,660 --> 00:39:19,090
>> 學生：沒有。

870
00:39:19,090 --> 00:39:19,870
>> JASON HIRSCHHORN：沒有。

871
00:39:19,870 --> 00:39:20,555
好像它的工作原理。

872
00:39:20,555 --> 00:39:23,790
你可以嘗試更多的角的情況下，但
一般的數字，不同的數據

873
00:39:23,790 --> 00:39:26,160
偉大的嘗試，也什麼都不是。

874
00:39:26,160 --> 00:39:29,180
沒有，零，底片總是
偉大的事情，嘗試和活動

875
00:39:29,180 --> 00:39:33,140
測試應該，事情當然我們會測試
和檢查50測試。

876
00:39:33,140 --> 00:39:34,720
任何問題spell.c？

877
00:39:34,720 --> 00:39:37,752

878
00:39:37,752 --> 00:39:39,310
>> OK，讓我們的後腦勺。

879
00:39:39,310 --> 00:39:42,420
我還有一個程序
你們寫。

880
00:39:42,420 --> 00:39:44,700
它稱為students.c。

881
00:39:44,700 --> 00:39:49,020
這是一個程序，要求用戶
五個名字，然後隨機選擇

882
00:39:49,020 --> 00:39:51,600
打印出的名字之一。

883
00:39:51,600 --> 00:39:54,840
這個程序是多一點點
參與比過去兩年中，我們寫道，

884
00:39:54,840 --> 00:39:58,080
那麼，為什麼我們不採取五分鐘
單獨代碼，然後我們會

885
00:39:58,080 --> 00:40:00,130
代碼為一組。

886
00:40:00,130 --> 00:40:03,795
>> 該方案還涉及到一些東西
你可能沒有見過，所以如果

887
00:40:03,795 --> 00:40:06,390
你有一個問題，怎麼辦
我這樣做，舉起你的手。

888
00:40:06,390 --> 00:40:08,530
我會過來和指向你
在正確的方向。

889
00:40:08,530 --> 00:40:10,820
但我們也這樣做，因為這
將是一個很好的方式來介紹一些

890
00:40:10,820 --> 00:40:12,070
是棘手的話題。

891
00:40:12,070 --> 00:44:14,600

892
00:44:14,600 --> 00:44:15,560
>> 因此，它的工作原理，對不對？

893
00:44:15,560 --> 00:44:17,580
>> 學生：是啊。

894
00:44:17,580 --> 00:44:19,180
>> JASON HIRSCHHORN：每當你打開一個
習題集，有很多方法可以做到

895
00:44:19,180 --> 00:44:20,790
，但有些更
優雅的比別人多。

896
00:44:20,790 --> 00:44:29,000

897
00:44:29,000 --> 00:44:31,110
讓我們長驅直入

898
00:44:31,110 --> 00:44:32,880
＃包括cs50.h.服務

899
00:44:32,880 --> 00:44:34,250
＃包括stdio.h中。

900
00:44:34,250 --> 00:44:37,240
int主要的空隙中，花括號。

901
00:44:37,240 --> 00:44:39,430
大括號內，
我有兩點意見。

902
00:44:39,430 --> 00:44:41,500
第一個問
5名用戶。

903
00:44:41,500 --> 00:44:46,580
第二個是，隨機選擇
打印出來的名字之一。

904
00:44:46,580 --> 00:44:50,250
因此，讓我們做的第一個，問
5名用戶。

905
00:44:50,250 --> 00:44:53,730
誰已要求用戶5名
並能告訴我該怎麼辦？

906
00:44:53,730 --> 00:44:56,760

907
00:44:56,760 --> 00:44:58,570
只有兩個人做的第一部分。

908
00:44:58,570 --> 00:45:00,150
三個人做的第一部分。

909
00:45:00,150 --> 00:45:00,670
四，五。

910
00:45:00,670 --> 00:45:03,140
湯姆，你怎麼辦呢？

911
00:45:03,140 --> 00:45:09,940
>> 學生：你聲明一個字符串
然後將其命名，支架五。

912
00:45:09,940 --> 00:45:12,070
>> JASON HIRSCHHORN：字符串
命名支架五。

913
00:45:12,070 --> 00:45:15,350
那麼，什麼是做這行，
字符串名稱支架五？

914
00:45:15,350 --> 00:45:17,800
>> 學生：你會聲明
一個字符串數組。

915
00:45:17,800 --> 00:45:19,000
>> JASON HIRSCHHORN：這是
一個字符串數組。

916
00:45:19,000 --> 00:45:21,590
多少字符串會
適合在這裡嗎？

917
00:45:21,590 --> 00:45:22,010
>> 學生：五。

918
00:45:22,010 --> 00:45:22,320
>> JASON HIRSCHHORN：五。

919
00:45:22,320 --> 00:45:22,660
優秀的。

920
00:45:22,660 --> 00:45:26,360
我們要調用它的名字，因為
我們要得到多個。

921
00:45:26,360 --> 00:45:27,790
OK，接下來呢？

922
00:45:27,790 --> 00:45:29,270
>> 學生：那麼你
有一個for循環 - 

923
00:45:29,270 --> 00:45:30,060
>> JASON HIRSCHHORN：For循環。

924
00:45:30,060 --> 00:45:33,035
>> 學生： - 對於i = 0。

925
00:45:33,035 --> 00:45:37,040
>> JASON HIRSCHHORN：為（int i = 0。

926
00:45:37,040 --> 00:45:38,270
>> 學生：分號。

927
00:45:38,270 --> 00:45:38,880
>> JASON HIRSCHHORN：分號。

928
00:45:38,880 --> 00:45:39,790
>> 學生：我不到五。

929
00:45:39,790 --> 00:45:41,310
>> JASON HIRSCHHORN：我不到五。

930
00:45:41,310 --> 00:45:42,230
>> 學生：分號。

931
00:45:42,230 --> 00:45:42,560
>> JASON HIRSCHHORN：分號。

932
00:45:42,560 --> 00:45:43,380
>> 學生：我+ +。

933
00:45:43,380 --> 00:45:46,050
>> JASON HIRSCHHORN：我+ +。

934
00:45:46,050 --> 00:45:47,100
>> 學生：然後關閉括號。

935
00:45:47,100 --> 00:45:48,600
>> JASON HIRSCHHORN：閉合的括號，
然後一些大括號。

936
00:45:48,600 --> 00:45:50,050
花括號內的？

937
00:45:50,050 --> 00:45:51,423
>> 學生：printf的。

938
00:45:51,423 --> 00:45:52,535
>> JASON HIRSCHHORN：printf的。

939
00:45:52,535 --> 00:45:56,200
>> 學生：開括號，名稱為％d。

940
00:45:56,200 --> 00:45:57,090
>> JASON HIRSCHHORN：對不起？

941
00:45:57,090 --> 00:45:57,660
>> 學生：名稱。

942
00:45:57,660 --> 00:45:58,200
>> JASON HIRSCHHORN：名稱。

943
00:45:58,200 --> 00:46:01,700
>> 學生：空間，然後％D。

944
00:46:01,700 --> 00:46:02,950
>> JASON HIRSCHHORN：名稱，空間，％D。

945
00:46:02,950 --> 00:46:05,630

946
00:46:05,630 --> 00:46:10,820
>> 學生：/ N，然後關閉。

947
00:46:10,820 --> 00:46:15,070
>> JASON HIRSCHHORN：所以名稱，空間，
％D / N，右括號。

948
00:46:15,070 --> 00:46:17,730
>> 學生：逗號，I + 1。

949
00:46:17,730 --> 00:46:19,390
對不起。

950
00:46:19,390 --> 00:46:21,040
封閉報價，然後逗號，我+1。

951
00:46:21,040 --> 00:46:24,400
>> JASON HIRSCHHORN：休息
引號，逗號，I +1。

952
00:46:24,400 --> 00:46:25,850
>> 學生：是的。

953
00:46:25,850 --> 00:46:27,650
然後下一行 - 

954
00:46:27,650 --> 00:46:29,400
>> JASON HIRSCHHORN：+ 1。

955
00:46:29,400 --> 00:46:31,600
>> 學生：是的。

956
00:46:31,600 --> 00:46:36,440
然後下一張幻燈片
名稱支架I。

957
00:46:36,440 --> 00:46:39,000
>> JASON HIRSCHHORN：下一行
名稱支架I。

958
00:46:39,000 --> 00:46:41,360
>> 學生：獲得字符串。

959
00:46:41,360 --> 00:46:43,460
>> JASON HIRSCHHORN：=  - 

960
00:46:43,460 --> 00:46:44,510
資本G-E-T  - 

961
00:46:44,510 --> 00:46:45,530
字符串。

962
00:46:45,530 --> 00:46:47,800
哎呀，對不起。

963
00:46:47,800 --> 00:46:49,050
>> 學生：開放式，封閉式括號
然後 - 

964
00:46:49,050 --> 00:46:50,940
>> JASON HIRSCHHORN：開放，封閉括號。

965
00:46:50,940 --> 00:46:51,030
>> 學生：分號。

966
00:46:51,030 --> 00:46:52,500
>> JASON HIRSCHHORN：分號。

967
00:46:52,500 --> 00:46:57,545
好了，你初始化數組
字符串，名稱，然後經過一個

968
00:46:57,545 --> 00:47:02,720
for循環，並打印出一些五倍
提示給用戶，然後存儲

969
00:47:02,720 --> 00:47:03,360
五根弦。

970
00:47:03,360 --> 00:47:08,090
沒有任何人有任何
調整？

971
00:47:08,090 --> 00:47:10,030
湯姆，我想每個人都
同意你的。

972
00:47:10,030 --> 00:47:10,880
看起來還不錯。

973
00:47:10,880 --> 00:47:11,660
確定。

974
00:47:11,660 --> 00:47:14,830
你為什麼要這麼做i +1的，但？

975
00:47:14,830 --> 00:47:18,000
>> 學生：我的意思是，沒有
是的，但我+1，它是

976
00:47:18,000 --> 00:47:19,700
名稱命名五。

977
00:47:19,700 --> 00:47:21,930
否則，這將是名
僅舉四個零。

978
00:47:21,930 --> 00:47:24,400
>> JASON HIRSCHHORN：所以，你做了我+1
因為否則它將有

979
00:47:24,400 --> 00:47:27,060
通過四個零打印出來，因為
這電腦怎麼想的，但人類

980
00:47:27,060 --> 00:47:28,530
真的不讀這樣的。

981
00:47:28,530 --> 00:47:30,190
這是另一回事
你會遇到的問題。

982
00:47:30,190 --> 00:47:33,210
有時，當你打印出來的東西
給用戶，你會想它

983
00:47:33,210 --> 00:47:35,733
有點漂亮，做
i +1的在這種情況下，是一個

984
00:47:35,733 --> 00:47:37,430
方式，使其更漂亮。

985
00:47:37,430 --> 00:47:41,380
>> 我也看到了五進行兩次，字符串名稱
範圍是5，i是小於5。

986
00:47:41,380 --> 00:47:42,430
我知道你從哪裡得到的五個。

987
00:47:42,430 --> 00:47:44,890
我告訴你猜對了
五個名字。

988
00:47:44,890 --> 00:47:49,000
但是，如果我們想使代碼
有點更強大的，有一件事我們

989
00:47:49,000 --> 00:47:53,110
能做的就出在這裡，外面的int，
我們可以做這樣的事情，

990
00:47:53,110 --> 00:47:57,070
＃定義，我們可以做名稱5。

991
00:47:57,070 --> 00:48:01,580

992
00:48:01,580 --> 00:48:05,390
>> 所以基本上，無論我寫的資本
N，資本大寫M，A，大寫字母E，

993
00:48:05,390 --> 00:48:08,890
大寫字母S，則該字符串，它將取代
5代碼。

994
00:48:08,890 --> 00:48:11,530

995
00:48:11,530 --> 00:48:13,445
還是讓我們只是把它 - 我們將
只需撥打號碼。

996
00:48:13,445 --> 00:48:17,190
所以我定義全部大寫
號碼為5。

997
00:48:17,190 --> 00:48:22,830
>> 所以，現在無論我有5號，我
可以將其替換所有瓶蓋號碼。

998
00:48:22,830 --> 00:48:26,880
而現在，如果我想改變號碼
名字，所有我需要做的是

999
00:48:26,880 --> 00:48:31,350
這一條線，4號線，在那裡我有
＃定義5號，改到10，

1000
00:48:31,350 --> 00:48:34,340
或改變4。

1001
00:48:34,340 --> 00:48:37,400
當你的代碼越長，你不是
要記住所有的地方，你

1002
00:48:37,400 --> 00:48:41,630
把你想要多少名，並在
為了讓你不要錯過，這是

1003
00:48:41,630 --> 00:48:45,490
做到這一點，找到一個很好的方式
往上頂，然後只使用該短語

1004
00:48:45,490 --> 00:48:46,400
各地你的代碼。

1005
00:48:46,400 --> 00:48:46,780
馬庫斯？

1006
00:48:46,780 --> 00:48:49,780
>> 學生：那是風格的首選
不是全局定義

1007
00:48:49,780 --> 00:48:51,270
常數n？

1008
00:48:51,270 --> 00:48:53,760
>> JASON HIRSCHHORN：是
文體不是全局的首選

1009
00:48:53,760 --> 00:48:54,980
定義一個常數n？

1010
00:48:54,980 --> 00:48:59,036
所以你說你能
做數= 5？

1011
00:48:59,036 --> 00:49:01,300
>> 學生：他們有輔音
在C或沒有？

1012
00:49:01,300 --> 00:49:02,720
>> JASON HIRSCHHORN或const  - 等於。

1013
00:49:02,720 --> 00:49:04,275
所以，你說的只是
一個全局變量？

1014
00:49:04,275 --> 00:49:04,990
>> 學生：是啊。

1015
00:49:04,990 --> 00:49:08,670
>> JASON HIRSCHHORN：文體，
有沒有一定的權利

1016
00:49:08,670 --> 00:49:12,050
回答，但那些都更好
不僅僅是扔這些隨機

1017
00:49:12,050 --> 00:49:12,960
整個代碼中的數字。

1018
00:49:12,960 --> 00:49:14,650
我們稱他們為幻數。

1019
00:49:14,650 --> 00:49:16,450
當我看看你的代碼或當
任何人的閱讀，通過它，他們

1020
00:49:16,450 --> 00:49:18,790
要的不只是這些隨機數
沒有意義的。

1021
00:49:18,790 --> 00:49:22,420
連號26，它一般是
字母表中的字母數，

1022
00:49:22,420 --> 00:49:28,870
這是更好地定義字母往上頂
並保存在該字符串中的26號，

1023
00:49:28,870 --> 00:49:29,550
如果是有道理的。

1024
00:49:29,550 --> 00:49:33,210
>> 或者問題上設置一個，而不是 - 
再次，我們不談論這個在

1025
00:49:33,210 --> 00:49:37,020
的時候，但不是僅僅拋出
到處25或10，你可以

1026
00:49:37,020 --> 00:49:41,860
節省25號的季度或10
毛錢，這使得它更容易

1027
00:49:41,860 --> 00:49:44,140
無論是誰，通過閱讀你的代碼
明白你為什麼選擇了這個數字。

1028
00:49:44,140 --> 00:49:46,540
，也為你，如果你曾經想要的
更新你的代碼，這使得它有點

1029
00:49:46,540 --> 00:49:47,290
更健壯。

1030
00:49:47,290 --> 00:49:48,070
是嗎？

1031
00:49:48,070 --> 00:49:50,830
>> 學生：這是代碼也將
後為我們提供？

1032
00:49:50,830 --> 00:49:52,453
>> JASON HIRSCHHORN：所有這些代碼
我們一起寫的是

1033
00:49:52,453 --> 00:49:54,620
將通過電子郵件發送給你
傢伙。

1034
00:49:54,620 --> 00:49:55,740
是。

1035
00:49:55,740 --> 00:49:58,040
因此，要求用戶5名。

1036
00:49:58,040 --> 00:50:00,280
隨機選擇和打印
的名稱之一。

1037
00:50:00,280 --> 00:50:00,940
誰這樣做行嗎？

1038
00:50:00,940 --> 00:50:02,230
這是這裡最棘手的線。

1039
00:50:02,230 --> 00:50:02,450
對不起，湯姆。

1040
00:50:02,450 --> 00:50:05,510
你做了一個很好的工作，但
這是一個有點棘手。

1041
00:50:05,510 --> 00:50:06,600
馬庫斯，請便。

1042
00:50:06,600 --> 00:50:10,180
>> 學生：那麼首先，你要
需要包含stdlib.h中time.h中

1043
00:50:10,180 --> 00:50:13,200
>> JASON HIRSCHHORN：所以你說在
頂部，包括兩個庫。

1044
00:50:13,200 --> 00:50:18,830
你要我包括S-T-D-L-I-乙
點H，標準庫，

1045
00:50:18,830 --> 00:50:19,760
是另一個人呢？

1046
00:50:19,760 --> 00:50:21,010
>> 學生：time.h中

1047
00:50:21,010 --> 00:50:25,130

1048
00:50:25,130 --> 00:50:27,840
>> JASON HIRSCHHORN：＃包括time.h中

1049
00:50:27,840 --> 00:50:29,470
因此，這些都是兩個庫。

1050
00:50:29,470 --> 00:50:31,790
我假設現在我們將要使用
在這些中所包含的功能

1051
00:50:31,790 --> 00:50:34,240
二，這就是為什麼你需要
包括他們？

1052
00:50:34,240 --> 00:50:36,980
>> 學生：那麼，你先
會想要寫srand函數。

1053
00:50:36,980 --> 00:50:38,770
>> JASON HIRSCHHORN：函數srand。

1054
00:50:38,770 --> 00:50:42,070
>> 學生：（（0）

1055
00:50:42,070 --> 00:50:42,700
>> JASON HIRSCHHORN：對不起。

1056
00:50:42,700 --> 00:50:45,580
函數srand（時間（

1057
00:50:45,580 --> 00:50:46,890
>> 學生：0。

1058
00:50:46,890 --> 00:50:47,230
>> JASON HIRSCHHORN：0。

1059
00:50:47,230 --> 00:50:49,990
>> 學生：）），分號。

1060
00:50:49,990 --> 00:50:51,320
>> JASON HIRSCHHORN：另一個封閉的括號？

1061
00:50:51,320 --> 00:50:51,650
分號。

1062
00:50:51,650 --> 00:50:53,610
我要去只需更換
您零NULL。

1063
00:50:53,610 --> 00:50:55,980
它會做同樣的事情，但
通常，你會看到NULL，

1064
00:50:55,980 --> 00:50:57,720
我們會談論這個
在第二行。

1065
00:50:57,720 --> 00:50:58,580
>> 學生：文體更好？

1066
00:50:58,580 --> 00:51:02,240
>> JASON HIRSCHHORN：一般來說，人們
右NULL，但同樣的事情。

1067
00:51:02,240 --> 00:51:05,010
>> 學生：INT名。

1068
00:51:05,010 --> 00:51:06,490
>> JASON HIRSCHHORN：詮釋名。

1069
00:51:06,490 --> 00:51:07,280
>> 學生：=

1070
00:51:07,280 --> 00:51:07,780
>> JASON HIRSCHHORN：=

1071
00:51:07,780 --> 00:51:08,580
>> 學生：蘭特。

1072
00:51:08,580 --> 00:51:09,340
>> JASON HIRSCHHORN：蘭特。

1073
00:51:09,340 --> 00:51:10,420
>> 學生：（）

1074
00:51:10,420 --> 00:51:11,500
>> JASON HIRSCHHORN：（）

1075
00:51:11,500 --> 00:51:12,850
>> 學生：模數。

1076
00:51:12,850 --> 00:51:14,310
>> JASON HIRSCHHORN：模是什麼？

1077
00:51:14,310 --> 00:51:14,970
字符？

1078
00:51:14,970 --> 00:51:16,000
％字符？

1079
00:51:16,000 --> 00:51:17,790
>> 學生：百分比字符。

1080
00:51:17,790 --> 00:51:19,521
模數定義往上頂。

1081
00:51:19,521 --> 00:51:22,030
>> JASON HIRSCHHORN：模數。

1082
00:51:22,030 --> 00:51:24,052
>> 學生：分號。

1083
00:51:24,052 --> 00:51:24,660
>> JASON HIRSCHHORN：分號。

1084
00:51:24,660 --> 00:51:27,820
>> 學生：那麼新生產線中，將printf。

1085
00:51:27,820 --> 00:51:28,460
>> JASON HIRSCHHORN：printf的。

1086
00:51:28,460 --> 00:51:29,730
>> 學生：（

1087
00:51:29,730 --> 00:51:30,620
>> JASON HIRSCHHORN：（

1088
00:51:30,620 --> 00:51:31,650
>> 學生：“

1089
00:51:31,650 --> 00:51:32,630
>> JASON HIRSCHHORN：“

1090
00:51:32,630 --> 00:51:35,320
>> 學生：％S / N

1091
00:51:35,320 --> 00:51:37,220
>> JASON HIRSCHHORN：％S / N

1092
00:51:37,220 --> 00:51:38,420
>> 學生：“

1093
00:51:38,420 --> 00:51:40,640
>> JASON HIRSCHHORN：％S / N“

1094
00:51:40,640 --> 00:51:43,540
>> 學生：逗號，空間名稱。

1095
00:51:43,540 --> 00:51:44,350
>> JASON HIRSCHHORN：空間 - 

1096
00:51:44,350 --> 00:51:46,300
>> 學生：哦，我猜，
我們在這裡？

1097
00:51:46,300 --> 00:51:48,640
>> JASON HIRSCHHORN：我們稱它的名字。

1098
00:51:48,640 --> 00:51:52,360
>> 學生：打開支架，名稱。

1099
00:51:52,360 --> 00:51:55,090
>> JASON HIRSCHHORN打開支架，姓名。

1100
00:51:55,090 --> 00:51:55,850
>> 學生：休息支架。

1101
00:51:55,850 --> 00:51:56,490
>> JASON HIRSCHHORN：休息支架。

1102
00:51:56,490 --> 00:51:57,460
>> 學生：）

1103
00:51:57,460 --> 00:51:58,800
>> JASON HIRSCHHORN：）

1104
00:51:58,800 --> 00:51:59,440
>> 學生：分號。

1105
00:51:59,440 --> 00:52:00,410
>> JASON HIRSCHHORN：分號。

1106
00:52:00,410 --> 00:52:01,500
OK，讓我們保存。

1107
00:52:01,500 --> 00:52:04,410
讓我們把這段代碼。

1108
00:52:04,410 --> 00:52:06,365
學生。

1109
00:52:06,365 --> 00:52:07,100
讓運行該代碼。

1110
00:52:07,100 --> 00:52:08,480
學生。

1111
00:52:08,480 --> 00:52:11,630
/學生。 /學生。

1112
00:52:11,630 --> 00:52:12,870
名稱之一。

1113
00:52:12,870 --> 00:52:15,490
我們會說大衛。

1114
00:52:15,490 --> 00:52:18,070
名稱兩種，RJ。

1115
00:52:18,070 --> 00:52:20,561
名稱三，羅布。

1116
00:52:20,561 --> 00:52:22,490
名稱四，盧卡斯。

1117
00:52:22,490 --> 00:52:26,060
名稱五，約瑟夫。

1118
00:52:26,060 --> 00:52:28,850
然後它打印出約瑟夫。

1119
00:52:28,850 --> 00:52:31,730
>> 所以，讓我再次運行此。

1120
00:52:31,730 --> 00:52:32,460
讓我做相同的名稱。

1121
00:52:32,460 --> 00:52:39,760
大衛，RJ，羅布，盧卡斯，約瑟夫。

1122
00:52:39,760 --> 00:52:41,070
它給了我這一次大衛。

1123
00:52:41,070 --> 00:52:43,030
所以我做了同樣的事情，但它給
我不同的東西，這就是

1124
00:52:43,030 --> 00:52:45,410
因為，當然，我們要求
一個隨機名稱。

1125
00:52:45,410 --> 00:52:50,950
所以我認為，根據我徘徊
在房間裡，大多數人

1126
00:52:50,950 --> 00:52:55,960
可能得到的第一部分權利，
設立該陣列，然後讓

1127
00:52:55,960 --> 00:52:56,430
所有的名字。

1128
00:52:56,430 --> 00:52:59,320
我說的是第10行到16。

1129
00:52:59,320 --> 00:53:02,150
但18至21行可能
有些東西，你以前沒有見過，

1130
00:53:02,150 --> 00:53:03,750
讓我們通過這些。

1131
00:53:03,750 --> 00:53:10,390
>> 這線，的函數srand時間NULL
本質上是 - 

1132
00:53:10,390 --> 00:53:14,300
對不起，讓我們跳過下來
一條線，RAND（）。

1133
00:53:14,300 --> 00:53:17,320
這就給了你一個隨機數，
一個隨機整數。

1134
00:53:17,320 --> 00:53:19,630
如果你打的人蘭特，
很多你做 - 

1135
00:53:19,630 --> 00:53:21,530
M-A-n空間R-A-N-D  - 

1136
00:53:21,530 --> 00:53:25,910
在這樣的終端，M-A-N
空間上R-A-N-D，敲回車。

1137
00:53:25,910 --> 00:53:30,490
你會拿出來手冊
將能夠閱讀蘭特的

1138
00:53:30,490 --> 00:53:34,260
命令輸出數偽隨機字節
播種後的隨機數

1139
00:53:34,260 --> 00:53:35,510
發電機一次。

1140
00:53:35,510 --> 00:53:38,450

1141
00:53:38,450 --> 00:53:39,700
>> 所以這是一個描述。

1142
00:53:39,700 --> 00:53:43,860

1143
00:53:43,860 --> 00:53:46,800
這是什麼蘭特，給人
你一個隨機號碼，當

1144
00:53:46,800 --> 00:53:48,610
你調用該函數。

1145
00:53:48,610 --> 00:53:53,140
不幸的是，這是不是真正的隨機
因為如果你只需要調用隨機

1146
00:53:53,140 --> 00:53:55,970
一些種子，一些沒有得到
起點，但它總是會選擇

1147
00:53:55,970 --> 00:53:59,100
相同的之一，它使用一個公式
以確定下一個。

1148
00:53:59,100 --> 00:54:01,730
所以，如果你調用rand，它只是
給你同樣的事情。

1149
00:54:01,730 --> 00:54:02,610
這將是非常可預測的。

1150
00:54:02,610 --> 00:54:03,790
實際上，它不會是隨機的。

1151
00:54:03,790 --> 00:54:09,610
>> 所以我們需要做什麼，每馬庫斯的
指示給我，種子蘭特

1152
00:54:09,610 --> 00:54:13,810
別的東西，這是什麼
的srand函數確實。

1153
00:54:13,810 --> 00:54:18,055
種子蘭特的東西多一點
隨機比同樣的事情，

1154
00:54:18,055 --> 00:54:23,360
他的播種時間NULL，
是，按照慣例，目前的

1155
00:54:23,360 --> 00:54:24,650
時間（以秒為單位）。

1156
00:54:24,650 --> 00:54:29,790
>> 所以，你假設每個人的不
要在準確的運行代碼

1157
00:54:29,790 --> 00:54:33,620
同一秒內，所以它是一個安全的賭注
時間NULL將是不同的

1158
00:54:33,620 --> 00:54:35,250
每次運行此代碼。

1159
00:54:35,250 --> 00:54:39,020
安全的賭注，因此，srand函數將種子蘭特
不同的東西每

1160
00:54:39,020 --> 00:54:39,990
一次。

1161
00:54:39,990 --> 00:54:44,110
因此，按照慣例，當我們想要一個
隨機數，我們寫這條線，

1162
00:54:44,110 --> 00:54:50,540
函數srand時間NULL，給我們一個更
更多的隨機種子，然後我們運行

1163
00:54:50,540 --> 00:54:52,080
蘭特，這給了我們一個隨機數。

1164
00:54:52,080 --> 00:54:52,840
是嗎？

1165
00:54:52,840 --> 00:54:54,140
>> 學生：你能說什麼
你的意思是由種子嗎？

1166
00:54:54,140 --> 00:54:55,630
>> JASON HIRSCHHORN：如在種子 - 

1167
00:54:55,630 --> 00:54:58,730
所以蘭特要挑一些數字
它會使用一些

1168
00:54:58,730 --> 00:55:00,060
公式得到。

1169
00:55:00,060 --> 00:55:03,250
所以它要的東西開始
然後把它變成一種基於

1170
00:55:03,250 --> 00:55:03,890
關閉該公式。

1171
00:55:03,890 --> 00:55:06,090
如果你總是給它同樣的事情，
它總是會變成

1172
00:55:06,090 --> 00:55:06,790
同樣的事情。

1173
00:55:06,790 --> 00:55:08,450
所以，第一件事你
給它的種子。

1174
00:55:08,450 --> 00:55:10,880
所以，你想給的東西
不同的開始，所以它

1175
00:55:10,880 --> 00:55:12,610
會變成不同的東西。

1176
00:55:12,610 --> 00:55:15,840
>> ，然後最後，第20行
這被稱為％

1177
00:55:15,840 --> 00:55:17,470
模，那就是混亂。

1178
00:55:17,470 --> 00:55:19,850
這東西是一點點
不同，在這裡，你真的不

1179
00:55:19,850 --> 00:55:22,240
在現實生活中的數學。

1180
00:55:22,240 --> 00:55:27,430
但本質上，當你把一個巨大的
號碼，你分在C，

1181
00:55:27,430 --> 00:55:29,482
發生的其餘？

1182
00:55:29,482 --> 00:55:30,510
>> 學生：被截斷。

1183
00:55:30,510 --> 00:55:31,220
>> JASON HIRSCHHORN：被截斷。

1184
00:55:31,220 --> 00:55:35,200
所以20除以3是什麼？

1185
00:55:35,200 --> 00:55:37,950
這是什麼返回
你，20除以3。

1186
00:55:37,950 --> 00:55:39,260
我們很抱歉，10除以3。

1187
00:55:39,260 --> 00:55:41,062
這是什麼回報給你嗎？

1188
00:55:41,062 --> 00:55:41,540
>> 學生：[聽不清]。

1189
00:55:41,540 --> 00:55:45,170
>> JASON HIRSCHHORN：10除以3只是
返回3，不是3餘1。

1190
00:55:45,170 --> 00:55:51,490
那麼，什麼10模3返回
僅僅是餘數，1。

1191
00:55:51,490 --> 00:55:54,020
所以，如果你想知道什麼10分
3，你會

1192
00:55:54,020 --> 00:55:58,950
做10除以3，你會得到你的3，
然後你會做10模3，

1193
00:55:58,950 --> 00:55:59,860
你會得到一個1。

1194
00:55:59,860 --> 00:56:04,630
所以，你會意識到10分
3 3，其餘1。

1195
00:56:04,630 --> 00:56:07,990
>> 在此行中，蘭特
的任一整數，本質上。

1196
00:56:07,990 --> 00:56:12,660
因此，模說，它除以
號，這是在這種情況下，5。

1197
00:56:12,660 --> 00:56:16,420
如果你曾經除以一個數字，
整數總是有小於

1198
00:56:16,420 --> 00:56:17,590
這個數字。

1199
00:56:17,590 --> 00:56:22,200
所以，如果你數除以5，
剩下的總是要

1200
00:56:22,200 --> 00:56:23,396
通過四個零。

1201
00:56:23,396 --> 00:56:25,520
這是多麼的數學工作。

1202
00:56:25,520 --> 00:56:29,700
>> 所以一個一個較小的moduloed的大量
數將始終返回

1203
00:56:29,700 --> 00:56:33,530
其餘部分將始終返回一些
數數比您少

1204
00:56:33,530 --> 00:56:34,693
除以。

1205
00:56:34,693 --> 00:56:37,920
沒有任何人有任何疑問，
模的，因為它會非常，

1206
00:56:37,920 --> 00:56:41,450
非常方便，所以我要確保
大家都明白嗎？

1207
00:56:41,450 --> 00:56:43,710
涼爽。

1208
00:56:43,710 --> 00:56:46,000
而且，我們看到，這個程序工作。

1209
00:56:46,000 --> 00:56:50,280
OK，繼續前進。

1210
00:56:50,280 --> 00:56:52,970
>> 所以接下來，我們將要進入
的功能，我們打算去

1211
00:56:52,970 --> 00:56:55,580
通過這個東西剩下的漂亮
很快，因為我​​想獲得

1212
00:56:55,580 --> 00:56:57,150
命令行參數。

1213
00:56:57,150 --> 00:57:00,330
所以基本上，
如您所見，黑盒子。

1214
00:57:00,330 --> 00:57:04,290
他們拿東西名為參數，
他們做了他們，無論是

1215
00:57:04,290 --> 00:57:06,990
改變或創造一些副作用，
最後，他們吐

1216
00:57:06,990 --> 00:57:09,530
出來的東西，這是
返回值。

1217
00:57:09,530 --> 00:57:12,495
有誰能夠給我一個理由
為什麼我們會使用的功能呢？

1218
00:57:12,495 --> 00:57:15,870

1219
00:57:15,870 --> 00:57:16,360
任何人嗎？

1220
00:57:16,360 --> 00:57:19,360
其中一個原因就是為什麼我們要使用的功能嗎？

1221
00:57:19,360 --> 00:57:21,280
有人嗎？

1222
00:57:21,280 --> 00:57:22,700
我看到了兩隻手。

1223
00:57:22,700 --> 00:57:23,590
一個很好的理由是什麼？

1224
00:57:23,590 --> 00:57:24,930
馬庫斯？

1225
00:57:24,930 --> 00:57:27,730
>> 學生：如果你必須調用相同的
大塊的代碼多次。

1226
00:57:27,730 --> 00:57:29,150
>> JASON HIRSCHHORN：OK，如果你需要
調用相同的塊

1227
00:57:29,150 --> 00:57:30,040
多次編碼。

1228
00:57:30,040 --> 00:57:32,470
傑夫，你是否也有不同的原因嗎？

1229
00:57:32,470 --> 00:57:34,230
>> 學生：只要
您可以編寫更少。

1230
00:57:34,230 --> 00:57:35,070
>> JASON HIRSCHHORN：您可以編寫更少。

1231
00:57:35,070 --> 00:57:35,320
右。

1232
00:57:35,320 --> 00:57:38,720
如果你想要做的東西很多 - 

1233
00:57:38,720 --> 00:57:41,720
在上面的代碼中，我能有
書面串五倍，但

1234
00:57:41,720 --> 00:57:44,620
for循環，使它看起來更好，
你必須寫更少的代碼。

1235
00:57:44,620 --> 00:57:45,760
函數是一種類似的想法。

1236
00:57:45,760 --> 00:57:48,720
如果我想要做同樣的事情很多，
將它移動到一個函數，並調用

1237
00:57:48,720 --> 00:57:49,610
每次功能。

1238
00:57:49,610 --> 00:57:51,190
這會為你做那件事。

1239
00:57:51,190 --> 00:57:53,740
這是一個很大的原因
使用功能。

1240
00:57:53,740 --> 00:57:54,870
>> 因此，解剖函數。

1241
00:57:54,870 --> 00:57:56,670
函數一般會
這個樣子。

1242
00:57:56,670 --> 00:57:59,280
它會開始返回類型，
那麼你會得到這個名字。

1243
00:57:59,280 --> 00:58:02,935
它會採取的論點，否則
已知參數，和內部

1244
00:58:02,935 --> 00:58:05,290
那些花括號，你會
寫你的代碼。

1245
00:58:05,290 --> 00:58:07,150
>> 我們已經看到了一個功能很多。

1246
00:58:07,150 --> 00:58:09,160
這是主要的。

1247
00:58:09,160 --> 00:58:13,820
這裡主要是疊加
解剖我有更早。

1248
00:58:13,820 --> 00:58:15,525
詮釋權在這裡表示什麼？

1249
00:58:15,525 --> 00:58:18,534

1250
00:58:18,534 --> 00:58:19,450
什麼詮釋是什麼意思？

1251
00:58:19,450 --> 00:58:21,026
當我寫的詮釋主要（無效）。

1252
00:58:21,026 --> 00:58:21,740
>> 學生：返回類型？

1253
00:58:21,740 --> 00:58:22,350
>> JASON HIRSCHHORN：對不起？

1254
00:58:22,350 --> 00:58:23,170
>> 學生：返回類型。

1255
00:58:23,170 --> 00:58:24,820
>> JASON HIRSCHHORN：詮釋是
返回類型，分毫不差。

1256
00:58:24,820 --> 00:58:25,870
主返回一個int。

1257
00:58:25,870 --> 00:58:28,678
主要是什麼？

1258
00:58:28,678 --> 00:58:29,510
>> 學生：功能名稱。

1259
00:58:29,510 --> 00:58:30,800
>> JASON HIRSCHHORN：主要是
的函數名。

1260
00:58:30,800 --> 00:58:31,510
完全正確。

1261
00:58:31,510 --> 00:58:31,840
和無效的呢？

1262
00:58:31,840 --> 00:58:33,190
括號內的什麼是無效的？

1263
00:58:33,190 --> 00:58:36,650

1264
00:58:36,650 --> 00:58:42,030
>> 學生：它並不需要
任何外部的價值。

1265
00:58:42,030 --> 00:58:42,930
>> JASON HIRSCHHORN：所以無效 - 

1266
00:58:42,930 --> 00:58:43,240
正確的。

1267
00:58:43,240 --> 00:58:45,940
括號內的，我們把
參數或參數

1268
00:58:45,940 --> 00:58:48,480
功能需要？
黑盒子內。

1269
00:58:48,480 --> 00:58:50,760
當你寫無效，你說
這需要什麼英寸

1270
00:58:50,760 --> 00:58:53,802
因此INT主要無效意味著主要的
不採取任何英寸

1271
00:58:53,802 --> 00:58:56,950
>> 花括號內的，我們有一些
代碼，然後我們看到了在年底

1272
00:58:56,950 --> 00:58:57,640
返回零。

1273
00:58:57,640 --> 00:59:01,220
歸零什麼意思？

1274
00:59:01,220 --> 00:59:02,470
好吧，我們談到的返回類型。

1275
00:59:02,470 --> 00:59:03,780
主要需要返回一個int。

1276
00:59:03,780 --> 00:59:04,960
這是這一行做什麼。

1277
00:59:04,960 --> 00:59:07,330
它返回一個int，零。

1278
00:59:07,330 --> 00:59:13,600
>> 當然，我們還沒有看到，很多
因為在編程中，我們做

1279
00:59:13,600 --> 00:59:16,070
我們做的機器和編譯器
我們用如今，你

1280
00:59:16,070 --> 00:59:16,990
不需要該行。

1281
00:59:16,990 --> 00:59:20,070
主要是夠特別，它知道
主，只是當你到達終點

1282
00:59:20,070 --> 00:59:22,060
返回零，如果一切都很順利。

1283
00:59:22,060 --> 00:59:25,560
事實上，如果事情不順利，
主往往會返回不同的

1284
00:59:25,560 --> 00:59:28,500
數字標誌著東西
與你的程序出了錯。

1285
00:59:28,500 --> 00:59:32,470
>> 所以，通常當你看到代碼，你
不寫返回零，但它的好

1286
00:59:32,470 --> 00:59:34,770
知道背後發生了什麼事
場景，因為每當你寫

1287
00:59:34,770 --> 00:59:36,370
另一種不同的功能，
您將需要

1288
00:59:36,370 --> 00:59:37,400
包括返回行。

1289
00:59:37,400 --> 00:59:39,710
如果你說我要去
返回一個int，你必須

1290
00:59:39,710 --> 00:59:41,250
寫返回的東西。

1291
00:59:41,250 --> 00:59:45,160
如果你說在這裡無效
年初，無效的主要無效，

1292
00:59:45,160 --> 00:59:48,670
例如，那麼它並沒有返回
什麼 - 空虛意味著什麼 - 

1293
00:59:48,670 --> 00:59:50,320
所以你不需要返回的行。

1294
00:59:50,320 --> 00:59:53,610
但你曾經寫的東西，這不是
無效的返回類型，你需要

1295
00:59:53,610 --> 00:59:55,950
一個回報，你說行
需要把東西

1296
00:59:55,950 --> 00:59:57,650
類型相匹配的。

1297
00:59:57,650 --> 00:59:58,900
任何問題嗎？

1298
00:59:58,900 --> 01:00:03,110

1299
01:00:03,110 --> 01:00:04,680
甜。

1300
01:00:04,680 --> 01:00:05,930
>> 範圍。

1301
01:00:05,930 --> 01:00:07,360
這是我們已經
以及感動。

1302
01:00:07,360 --> 01:00:10,720
每個變量，因為我們知道，有一個
一定範圍內，這是基本

1303
01:00:10,720 --> 01:00:14,160
談論變量
可能會或可能不會被引用。

1304
01:00:14,160 --> 01:00:16,310
我喜歡說會發生什麼
在大括號中保持

1305
01:00:16,310 --> 01:00:18,000
花括號內。

1306
01:00:18,000 --> 01:00:21,490
因此，例如，如果我們看一下這段代碼，
我們定義了一個全局變量

1307
01:00:21,490 --> 01:00:24,510
為主，詮釋一個外，
這裡在頂部。

1308
01:00:24,510 --> 01:00:27,380
我們調用另一個
int一個主裡面。

1309
01:00:27,380 --> 01:00:29,760
我們有一些比較大括號，
我們調用另一個INT的一個。

1310
01:00:29,760 --> 01:00:31,690
>> 我們有三個代碼。

1311
01:00:31,690 --> 01:00:32,550
這些都是不一樣的東西。

1312
01:00:32,550 --> 01:00:34,880
我創建了三個不同的變量。

1313
01:00:34,880 --> 01:00:39,370
然後裡面這些內在的捲髮
牙套，我說A = 4。

1314
01:00:39,370 --> 01:00:44,130
哪一個是談論，
第一個，第二個，

1315
01:00:44,130 --> 01:00:47,045
第三只呢？

1316
01:00:47,045 --> 01:00:47,920
>> 學生：第三個。

1317
01:00:47,920 --> 01:00:49,320
>> JASON HIRSCHHORN：在談論
關於第三個。

1318
01:00:49,320 --> 01:00:52,850
所有那些實際上可以
談到在這個特殊的

1319
01:00:52,850 --> 01:00:58,660
例如，由於其範圍
到這些最裡面的大括號。

1320
01:00:58,660 --> 01:01:02,360
然而，當你調用東西是一樣的
名稱，稱為隱藏的東西。

1321
01:01:02,360 --> 01:01:09,670
所以你只處理或修復，或使用
最近的變量，或者一個

1322
01:01:09,670 --> 01:01:11,090
最接近你。

1323
01:01:11,090 --> 01:01:14,760
所以，裡面第三個是在這裡，這是最接近
該行中，a = 4，所以它

1324
01:01:14,760 --> 01:01:16,550
影響第三。

1325
01:01:16,550 --> 01:01:19,890
和最後一行中，a = 2，a是
，談論，所述第一，第二，

1326
01:01:19,890 --> 01:01:20,805
第三個是？

1327
01:01:20,805 --> 01:01:22,530
>> 學生：二。

1328
01:01:22,530 --> 01:01:24,430
>> JASON HIRSCHHORN：在談論
關於第二個是。

1329
01:01:24,430 --> 01:01:27,970
當然，第三個是最接近
它的代碼，但第三個

1330
01:01:27,970 --> 01:01:30,200
外部不存在
那些大括號。

1331
01:01:30,200 --> 01:01:32,650
一旦你到那個封閉的捲髮
梅開二度，這就像它不見了，

1332
01:01:32,650 --> 01:01:33,570
本質上。

1333
01:01:33,570 --> 01:01:36,150
所以，唯一的兩個你已經離開的是那些
第2個，當然，現在

1334
01:01:36,150 --> 01:01:37,960
它的最近的第二個。

1335
01:01:37,960 --> 01:01:39,410
>> 所以這是一件好事，
記得大約範圍。

1336
01:01:39,410 --> 01:01:42,900
例如，我敢肯定，你遇到
這在一個do while循環。

1337
01:01:42,900 --> 01:01:46,680
如果初始化的變量裡面
DO WHILE循環，然後你試試

1338
01:01:46,680 --> 01:01:50,360
訪問它之外，你可能
像，這得到了一些警告

1339
01:01:50,360 --> 01:01:51,680
變量不存在。

1340
01:01:51,680 --> 01:01:54,370
那是因為範圍的想法，
事情只存在

1341
01:01:54,370 --> 01:01:55,320
那些大括號內。

1342
01:01:55,320 --> 01:01:59,320
大括號是像一個巨大的擁抱
你給你的代碼，又是另一回事

1343
01:01:59,320 --> 01:02:01,380
去想它。

1344
01:02:01,380 --> 01:02:05,280
>> 因此，這是另一種功能，這
你們的代碼​​，hellofunction.c。

1345
01:02:05,280 --> 01:02:08,240
我們要跳過的現在，但
這是我鼓勵你

1346
01:02:08,240 --> 01:02:09,740
在自己的練習。

1347
01:02:09,740 --> 01:02:12,510
寫一個方案，其中主要電話
另一個函數，打印出

1348
01:02:12,510 --> 01:02:13,750
問候給用戶。

1349
01:02:13,750 --> 01:02:17,750
它本質上是“世界，你好
和抽象成的printf

1350
01:02:17,750 --> 01:02:18,680
另一個功能。

1351
01:02:18,680 --> 01:02:22,360
但我們不打算這樣做，現在
因為我們沒有盡可能多的時間

1352
01:02:22,360 --> 01:02:23,350
離開，我會很喜歡。

1353
01:02:23,350 --> 01:02:26,250
>> 所以函數聲明。

1354
01:02:26,250 --> 01:02:28,080
我們已經看到了這個前。

1355
01:02:28,080 --> 01:02:31,180
如果你想要寫另一個函數，
你需要讓計算機知道

1356
01:02:31,180 --> 01:02:32,600
主知道它的存在。

1357
01:02:32,600 --> 01:02:37,140
所以，我們做的是上面的主，我們寫
返回類型，名稱，和

1358
01:02:37,140 --> 01:02:42,970
參數，然後向下跌破主力，
這裡，我們實際上該行複製

1359
01:02:42,970 --> 01:02:45,080
然後編寫實際的代碼。

1360
01:02:45,080 --> 01:02:50,990
那麼這樣一來，如果你調用函數
主要在頂部，主知道，

1361
01:02:50,990 --> 01:02:54,650
你好存在，例如，如果我是
打電話招呼，然後它看起來

1362
01:02:54,650 --> 01:02:56,710
實施向下跌破。

1363
01:02:56,710 --> 01:02:59,680
會發生什麼事，如果不包括這
線向上頂，無效（無效）？

1364
01:02:59,680 --> 01:03:03,820

1365
01:03:03,820 --> 01:03:06,560
>> 如果不包括此行
和主呼叫你好，我是

1366
01:03:06,560 --> 01:03:07,640
要得到一個錯誤。

1367
01:03:07,640 --> 01:03:10,090
我要得到一個錯誤，因為
編譯器不知道

1368
01:03:10,090 --> 01:03:13,070
這件事情的存在。

1369
01:03:13,070 --> 01:03:16,680
這就是為什麼我們
＃包括cs50.h.

1370
01:03:16,680 --> 01:03:21,390
基本上cs50.h做
放置得到字符串在那裡。

1371
01:03:21,390 --> 01:03:23,120
推桿得到int的有。

1372
01:03:23,120 --> 01:03:26,570
它把所有這些功能
前主讓原型時

1373
01:03:26,570 --> 01:03:29,900
你叫他們在主，主知道
這些東西的存在。

1374
01:03:29,900 --> 01:03:31,630
這是那些h文件。

1375
01:03:31,630 --> 01:03:33,850
所以，如果你打算讓自己的
功能，你一定要確保

1376
01:03:33,850 --> 01:03:36,690
在那裡，你把原型。

1377
01:03:36,690 --> 01:03:38,380
關於這個到目前為止的任何問題？

1378
01:03:38,380 --> 01:03:41,630

1379
01:03:41,630 --> 01:03:42,490
>> 命令行參數。

1380
01:03:42,490 --> 01:03:44,780
這就是我們要去完成
，然後希望我們能

1381
01:03:44,780 --> 01:03:46,180
擠在一些pset中。

1382
01:03:46,180 --> 01:03:48,700
我不知道，如果我們將能夠擠
因為時間，但

1383
01:03:48,700 --> 01:03:51,560
你們誰在這裡，如果你
傢伙想了一下後說，我們

1384
01:03:51,560 --> 01:03:54,290
可以在它外面。

1385
01:03:54,290 --> 01:03:56,020
但我們要完成
命令行參數

1386
01:03:56,020 --> 01:03:58,510
最後15分鐘。

1387
01:03:58,510 --> 01:03:59,930
我們醒了，邁克爾？

1388
01:03:59,930 --> 01:04:01,180
你醒了嗎？

1389
01:04:01,180 --> 01:04:01,660
好。

1390
01:04:01,660 --> 01:04:03,760
我不知道，如果你睡
閉上你的眼睛。

1391
01:04:03,760 --> 01:04:05,800
這將是非常棘手。

1392
01:04:05,800 --> 01:04:07,180
>> 命令行參數。

1393
01:04:07,180 --> 01:04:10,430
這是一個的方式來傳遞信息
進入程序。

1394
01:04:10,430 --> 01:04:12,780
最後，我們會遇到別人。

1395
01:04:12,780 --> 01:04:15,600
但是，從本質上講，我們要停止
寫詮釋的主要（無效）如果我們想

1396
01:04:15,600 --> 01:04:16,720
採取一些命令行參數。

1397
01:04:16,720 --> 01:04:19,850
我們打算寫這個東西
被稱為國際主要（INT ARGC，

1398
01:04:19,850 --> 01:04:22,430
串argv的括號內。

1399
01:04:22,430 --> 01:04:23,710
這是令人目不暇接。

1400
01:04:23,710 --> 01:04:26,070
這是一個很大的字母中所沒有的
人類的英語，所以我們要

1401
01:04:26,070 --> 01:04:27,680
現在他們解壓。

1402
01:04:27,680 --> 01:04:30,450
>> ARGC參數計數 - 

1403
01:04:30,450 --> 01:04:32,600
再次，所有這些都將
可在線 - 

1404
01:04:32,600 --> 01:04:34,280
參數的個數。

1405
01:04:34,280 --> 01:04:37,940
ARGV參數向量，
這些都是自己的論據。

1406
01:04:37,940 --> 01:04:38,830
這是一個字符串數組。

1407
01:04:38,830 --> 01:04:40,880
實際上，我們已經看到了一個陣列
今天之前的字符串。

1408
01:04:40,880 --> 01:04:44,390
我們創建了一個在過去
程序編碼。

1409
01:04:44,390 --> 01:04:45,720
>> 因此，這裡是一個例子。

1410
01:04:45,720 --> 01:04:50,230
我寫。/ ohai CS50節
我的命令行。

1411
01:04:50,230 --> 01:04:54,090
ARGC在這種情況下等於3。

1412
01:04:54,090 --> 01:05:01,170
ARGV支架0 ohai，argv的支架1
CS50，argv的支架2部分。

1413
01:05:01,170 --> 01:05:05,160
同樣，ar​​gc是參數的個數，
把你絆倒了一點

1414
01:05:05,160 --> 01:05:08,710
位，我們總是算的名稱
函數的第一個參數。

1415
01:05:08,710 --> 01:05:12,350
因此，在這種情況下，有三個
參數的函數名

1416
01:05:12,350 --> 01:05:14,590
那麼這兩個，我鍵入。

1417
01:05:14,590 --> 01:05:18,900
>> 下一步，我們要拯救那些
參數本身argv中。

1418
01:05:18,900 --> 01:05:22,690
再次，正如我們之前看到的，我們做
這在過去的程序編碼。

1419
01:05:22,690 --> 01:05:27,110
您可以將通過數組
argv和那些字符串。

1420
01:05:27,110 --> 01:05:28,830
本質上這是我們做了什麼
年底我們的最後一個節目。

1421
01:05:28,830 --> 01:05:33,190
我們挑了隨機的名字，然後去
名稱支架無論和印刷

1422
01:05:33,190 --> 01:05:34,580
出字符串設在那裡。

1423
01:05:34,580 --> 01:05:39,870

1424
01:05:39,870 --> 01:05:43,670
>> 論只是一個陣列的頂部，由於
字符串本身陣列，

1425
01:05:43,670 --> 01:05:46,320
談到，你可以有陣列
的陣列，這是

1426
01:05:46,320 --> 01:05:48,530
基本上argv是什麼。

1427
01:05:48,530 --> 01:05:51,370
一種方式，你可以考慮一下
這是行和列。

1428
01:05:51,370 --> 01:05:54,750
現在，我可以得出這樣的權利。

1429
01:05:54,750 --> 01:05:57,370
所以argv的 - 

1430
01:05:57,370 --> 01:05:58,630
不擦除。

1431
01:05:58,630 --> 01:05:59,880
讓我們借鑒ohai下。

1432
01:05:59,880 --> 01:06:09,320

1433
01:06:09,320 --> 01:06:12,490
>> 所以，如果我寫的，ohai CS50部分，
我要截斷

1434
01:06:12,490 --> 01:06:14,520
在這個例子中的一節。

1435
01:06:14,520 --> 01:06:29,026
但是，從本質上講，我的多維
陣列，ohai CS50

1436
01:06:29,026 --> 01:06:32,200
我們要做的教派。

1437
01:06:32,200 --> 01:06:34,610
所以在這裡，我可以訪問 - 

1438
01:06:34,610 --> 01:06:40,930

1439
01:06:40,930 --> 01:06:45,710
如果我只是給argv的一個數字 - 

1440
01:06:45,710 --> 01:06:46,390
這是錯誤的。

1441
01:06:46,390 --> 01:06:49,020
在這個圖中有什麼不對？

1442
01:06:49,020 --> 01:06:49,690
>> 學生：從零開始。

1443
01:06:49,690 --> 01:06:50,350
>> JASON HIRSCHHORN：它應該
從零開始。

1444
01:06:50,350 --> 01:06:52,940
也許我應該還可以旋轉它，但
因為我已經畫了，我

1445
01:06:52,940 --> 01:06:54,120
要離開現在。

1446
01:06:54,120 --> 01:06:55,160
但是，從零開始。

1447
01:06:55,160 --> 01:06:56,410
這是正確的。

1448
01:06:56,410 --> 01:06:58,980

1449
01:06:58,980 --> 01:07:00,120
對不起，如果這是小的。

1450
01:07:00,120 --> 01:07:01,370
你們可以看到嗎？

1451
01:07:01,370 --> 01:07:03,620

1452
01:07:03,620 --> 01:07:06,670
所以，如果我做的argv 0，我會
得到所有ohai。

1453
01:07:06,670 --> 01:07:08,555
如果我做的argv 1，我會得到所有的CS50。

1454
01:07:08,555 --> 01:07:10,720
如果我做的argv 2，我會得到所有的教派。

1455
01:07:10,720 --> 01:07:13,370
>> 但現在，正如我們所說，字符串
陣列本身。

1456
01:07:13,370 --> 01:07:19,740
那麼我能做什麼我就可以把這個
作為一個多維數組，並且我

1457
01:07:19,740 --> 01:07:24,190
可以做一些沿線
argv的0，0，這給了我只是

1458
01:07:24,190 --> 01:07:25,400
字符0。

1459
01:07:25,400 --> 01:07:28,760
ARGV 0，1，這給了我只是ħ。

1460
01:07:28,760 --> 01:07:33,960
ARGV 1，3，給我
0這裡CS50。

1461
01:07:33,960 --> 01:07:37,690
>> 因此，因為字符串本身
陣列，我們把

1462
01:07:37,690 --> 01:07:38,540
在另一個數組。

1463
01:07:38,540 --> 01:07:42,850
我們現在有數組的數組，我們
我們的第一個數組索引和

1464
01:07:42,850 --> 01:07:44,840
然後我們第二個數組的索引。

1465
01:07:44,840 --> 01:07:48,650
和你所期望的，我們這樣做
只是把那兩個 - 

1466
01:07:48,650 --> 01:07:51,760
只是我們做的方括號
旁邊另一個。

1467
01:07:51,760 --> 01:07:58,930
所以在這個例子中，argv 1是CS50和
argv的1，2，就像我們所說的，僅僅是5。

1468
01:07:58,930 --> 01:08:02,120
沒有任何人有任何疑問，
多維數組？

1469
01:08:02,120 --> 01:08:05,090

1470
01:08:05,090 --> 01:08:06,380
你們做得真棒。

1471
01:08:06,380 --> 01:08:07,750
甜。

1472
01:08:07,750 --> 01:08:11,980
>> 因此，我們有另一個程序在這裡，
這是我們的最後一件事

1473
01:08:11,980 --> 01:08:13,690
現在要做的。

1474
01:08:13,690 --> 01:08:18,160
所以，我要你寫一個程序，
以用戶的全名，只有兩個

1475
01:08:18,160 --> 01:08:21,649
兩個命令行參數，最後，
打印出問候

1476
01:08:21,649 --> 01:08:24,180
用戶包括他們的名字。

1477
01:08:24,180 --> 01:08:27,800
那麼，為什麼不把三個或四個
分鐘做這個，然後我們一起去

1478
01:08:27,800 --> 01:08:29,870
以上為一組，並
然後我們將收官？

1479
01:08:29,870 --> 01:09:44,189

1480
01:09:44,189 --> 01:09:48,084
>> 再次，在這裡，當我們說一個
描述每個用戶的全名

1481
01:09:48,084 --> 01:09:54,473
這個問題，它應該是命令
行參數，不使用字符串。

1482
01:09:54,473 --> 01:09:55,450
是啊，馬庫斯？

1483
01:09:55,450 --> 01:09:58,260
>> 學生：所以當你說兩個命令
行參數，除了

1484
01:09:58,260 --> 01:10:00,000
/運行，或者 - 

1485
01:10:00,000 --> 01:10:02,980
>> JASON HIRSCHHORN：好問題。

1486
01:10:02,980 --> 01:10:05,995
做的，包括。/運行，三
命令行參數。

1487
01:10:05,995 --> 01:10:08,550

1488
01:10:08,550 --> 01:10:11,320
或包括/個性化，
這種情況下，因為這是

1489
01:10:11,320 --> 01:10:12,360
此文件的名稱。

1490
01:10:12,360 --> 01:10:13,300
所以ARGC將有三個。

1491
01:10:13,300 --> 01:10:19,480
不過，我想只有兩個參數
給程序。

1492
01:10:19,480 --> 01:10:20,400
我應該指定。

1493
01:10:20,400 --> 01:10:23,380
之前，我交的，我會作出這樣的改變
這些，並送他們到你們。

1494
01:10:23,380 --> 01:10:32,747

1495
01:10:32,747 --> 01:10:34,740
>> 學生：如果你
有一個中間的名字嗎？

1496
01:10:34,740 --> 01:10:36,800
>> JASON HIRSCHHORN：如果你有一個中間
名字，你的運氣了。

1497
01:10:36,800 --> 01:10:38,050
對不起。

1498
01:10:38,050 --> 01:10:40,320

1499
01:10:40,320 --> 01:10:43,744
或者，如果你只去夏奇拉
你也是出於運氣。

1500
01:10:43,744 --> 01:10:55,672

1501
01:10:55,672 --> 01:10:56,425
是嗎？

1502
01:10:56,425 --> 01:11:00,760
>> 學生：所以當人們沒有
cs50.h，他們定義的argv

1503
01:11:00,760 --> 01:11:03,450
為char明星argv的？

1504
01:11:03,450 --> 01:11:05,160
或者是它仍然被稱為串的argv？

1505
01:11:05,160 --> 01:11:07,430
>> JASON HIRSCHHORN：是的。

1506
01:11:07,430 --> 01:11:10,480
因此，字符串，我們再次掩蓋了什麼
究竟是有發生。

1507
01:11:10,480 --> 01:11:14,040
這是怎麼回事也許要解​​壓縮
上週三，但很快。

1508
01:11:14,040 --> 01:11:16,380
這就像訓練車輪。

1509
01:11:16,380 --> 01:11:18,370
因為從本質上講，它是
同樣的事情。

1510
01:11:18,370 --> 01:11:37,040

1511
01:11:37,040 --> 01:11:42,560
>> 因此，讓我們一分鐘程序
這一點，然後我們會去

1512
01:11:42,560 --> 01:11:45,130
為一組，然後
就像我說的，包裹起來。

1513
01:11:45,130 --> 01:11:47,770
而且我覺得他們仍然是額外的糖果，
所以你們應該有希望

1514
01:11:47,770 --> 01:11:49,790
，請採取這一。

1515
01:11:49,790 --> 01:12:20,380

1516
01:12:20,380 --> 01:12:22,560
>> 很抱歉，如果你還在寫，
但我想潛水，我們

1517
01:12:22,560 --> 01:12:24,010
可以一起完成。

1518
01:12:24,010 --> 01:12:30,470
所以，我已經寫了＃
cs50.h＃包括stdio.h中。

1519
01:12:30,470 --> 01:12:33,970
詮釋的主要（無效），捲髮，大括號
括號，裡面三行

1520
01:12:33,970 --> 01:12:38,760
偽代碼，用戶的全名，
兩個，只有兩個命令行

1521
01:12:38,760 --> 01:12:42,670
參數，打印出問候
用戶包括他們的名字。

1522
01:12:42,670 --> 01:12:45,810
>> 因此，第一個，
用戶的全名。

1523
01:12:45,810 --> 01:12:47,290
誰可以幫我
用戶的全名嗎？

1524
01:12:47,290 --> 01:12:50,882

1525
01:12:50,882 --> 01:12:52,780
我該怎麼做的那部分？

1526
01:12:52,780 --> 01:12:57,685

1527
01:12:57,685 --> 01:12:59,500
難道你們這樣做，第一部分？

1528
01:12:59,500 --> 01:13:02,587

1529
01:13:02,587 --> 01:13:03,894
以用戶的全名。

1530
01:13:03,894 --> 01:13:05,860
那麼，對於一個命令行
的說法，我應該寫什麼？

1531
01:13:05,860 --> 01:13:09,624
我應該改變什麼
我的函數聲明？

1532
01:13:09,624 --> 01:13:11,140
>> 學生：你不希望
它是無效的了。

1533
01:13:11,140 --> 01:13:11,410
>> JASON HIRSCHHORN：沒錯。

1534
01:13:11,410 --> 01:13:12,385
我不希望它是無效的。

1535
01:13:12,385 --> 01:13:13,630
我想要什麼？

1536
01:13:13,630 --> 01:13:14,650
>> 學生：INT ARGC。

1537
01:13:14,650 --> 01:13:15,720
>> JASON HIRSCHHORN：INT ARGC。

1538
01:13:15,720 --> 01:13:17,430
>> 學生：弦樂的argv。

1539
01:13:17,430 --> 01:13:19,055
>> JASON HIRSCHHORN的String argv的。

1540
01:13:19,055 --> 01:13:19,705
>> 學生：支架，支架。

1541
01:13:19,705 --> 01:13:20,070
>> JASON HIRSCHHORN：支架，支架。

1542
01:13:20,070 --> 01:13:21,780
這完全正確的，那就是
其實我會怎麼得到

1543
01:13:21,780 --> 01:13:22,820
用戶的全名。

1544
01:13:22,820 --> 01:13:24,070
他們打算把它放在那裡。

1545
01:13:24,070 --> 01:13:27,720

1546
01:13:27,720 --> 01:13:28,780
所以，一個人的工作。

1547
01:13:28,780 --> 01:13:30,780
所以現在我想兩個，只有兩個
命令行參數。

1548
01:13:30,780 --> 01:13:35,065
所以，諾亞，什麼是盡我所能
檢查數量的命令

1549
01:13:35,065 --> 01:13:36,315
我行參數？

1550
01:13:36,315 --> 01:13:39,676

1551
01:13:39,676 --> 01:13:40,725
>> 學生：你做一個if語句。

1552
01:13:40,725 --> 01:13:42,270
>> JASON HIRSCHHORN：如果
聲明中，完全吻合。

1553
01:13:42,270 --> 01:13:44,830
我想要什麼條件？

1554
01:13:44,830 --> 01:13:48,370
>> 學生：如果大於3的argc。

1555
01:13:48,370 --> 01:13:52,485
>> JASON HIRSCHHORN：如果ARGC
大於3。

1556
01:13:52,485 --> 01:13:58,430
如果ARGC大於3，怎麼做？

1557
01:13:58,430 --> 01:13:59,400
>> 學生：返回1。

1558
01:13:59,400 --> 01:14:01,856
>> JASON HIRSCHHORN：返回1。

1559
01:14:01,856 --> 01:14:04,050
將確保我有
兩個只有兩個？

1560
01:14:04,050 --> 01:14:07,280

1561
01:14:07,280 --> 01:14:07,820
>> 學生：

1562
01:14:07,820 --> 01:14:13,110
如果argc是大於
3和小於2。

1563
01:14:13,110 --> 01:14:17,770
>> JASON HIRSCHHORN：如果argc是更大
比3和argc小於2。

1564
01:14:17,770 --> 01:14:21,540
什麼方法可以讓我寫這篇文章，在短短
一行上，或者不使用該

1565
01:14:21,540 --> 01:14:23,890
布爾運算符？

1566
01:14:23,890 --> 01:14:25,942
>> 學生：這不是等於2。

1567
01:14:25,942 --> 01:14:28,790
>> JASON HIRSCHHORN：如果ARGC
不等於2。

1568
01:14:28,790 --> 01:14:29,260
沒錯。

1569
01:14:29,260 --> 01:14:34,890
因此，如果argc是不等於2，即
會給我這個程序，

1570
01:14:34,890 --> 01:14:37,250
個性化，當我跑的時候，
會給我多少

1571
01:14:37,250 --> 01:14:38,740
命令行參數？

1572
01:14:38,740 --> 01:14:42,110
我檢查了多少？

1573
01:14:42,110 --> 01:14:42,370
>> 抱歉。

1574
01:14:42,370 --> 01:14:43,400
讓我改寫了。

1575
01:14:43,400 --> 01:14:46,620
如果ARGC = 2，沒多少東西
用戶寫入行？

1576
01:14:46,620 --> 01:14:47,500
>> 學生：一。

1577
01:14:47,500 --> 01:14:49,120
>> JASON HIRSCHHORN：只有一個問題。

1578
01:14:49,120 --> 01:14:50,430
所以之前，你是對的，諾亞。

1579
01:14:50,430 --> 01:14:52,192
什麼我確實需要放在那裡？

1580
01:14:52,192 --> 01:14:53,640
>> 學生：那等於3。

1581
01:14:53,640 --> 01:14:55,970
>> JASON HIRSCHHORN：ARGC
不等於3。

1582
01:14:55,970 --> 01:15:00,250
因為我想，我要等於3
個性化的附加其他兩個。

1583
01:15:00,250 --> 01:15:02,560
因此，如果ARGC不等於3，返回1。

1584
01:15:02,560 --> 01:15:04,475
你為什麼說返回1？

1585
01:15:04,475 --> 01:15:06,180
>> 學生：因為，
意味著它是錯誤的。

1586
01:15:06,180 --> 01:15:08,420
>> JASON HIRSCHHORN：這意味著它是錯誤的，
什麼該怎麼辦？

1587
01:15:08,420 --> 01:15:10,360
>> 學生：重新提示用戶。

1588
01:15:10,360 --> 01:15:11,940
>> JASON HIRSCHHORN：這將退出
程序，所以它會運行

1589
01:15:11,940 --> 01:15:14,520
了，但我們不會有什麼關係
在這裡再次要求他們。

1590
01:15:14,520 --> 01:15:14,840
我沒有要求。

1591
01:15:14,840 --> 01:15:15,990
所以這是完全正確的。

1592
01:15:15,990 --> 01:15:17,680
返回1只退出程序。

1593
01:15:17,680 --> 01:15:18,520
太好了。

1594
01:15:18,520 --> 01:15:21,600
>> 並打印出用戶打招呼
，其中包括他們的名字。

1595
01:15:21,600 --> 01:15:24,010
我怎樣才能做到這一點呢？

1596
01:15:24,010 --> 01:15:25,990
安娜？

1597
01:15:25,990 --> 01:15:26,580
>> 學生：printf的。

1598
01:15:26,580 --> 01:15:27,785
>> JASON HIRSCHHORN：printf的。

1599
01:15:27,785 --> 01:15:28,640
>> 學生：（“

1600
01:15:28,640 --> 01:15:30,460
>> JASON HIRSCHHORN：（

1601
01:15:30,460 --> 01:15:31,600
>> 學生：“你好

1602
01:15:31,600 --> 01:15:33,210
>> JASON HIRSCHHORN：“你好

1603
01:15:33,210 --> 01:15:34,800
>> 學生：％S

1604
01:15:34,800 --> 01:15:37,230
>> JASON HIRSCHHORN：％s的

1605
01:15:37,230 --> 01:15:38,840
>> 學生：/ N

1606
01:15:38,840 --> 01:15:41,030
>> JASON HIRSCHHORN / N

1607
01:15:41,030 --> 01:15:43,120
>> 學生：“

1608
01:15:43,120 --> 01:15:45,130
>> JASON HIRSCHHORN：“

1609
01:15:45,130 --> 01:15:46,620
>> 學生：ARGV

1610
01:15:46,620 --> 01:15:47,080
>> JASON HIRSCHHORN：對不起？

1611
01:15:47,080 --> 01:15:47,750
>> 學生：ARGV

1612
01:15:47,750 --> 01:15:48,840
>> JASON HIRSCHHORN：ARGV

1613
01:15:48,840 --> 01:15:50,190
>> 學生：方括號1。

1614
01:15:50,190 --> 01:15:51,230
>> JASON HIRSCHHORN：方括號？

1615
01:15:51,230 --> 01:15:51,870
>> 學生：1。

1616
01:15:51,870 --> 01:15:54,050
>> JASON HIRSCHHORN：1。

1617
01:15:54,050 --> 01:15:55,850
>> 學生：）和分號。

1618
01:15:55,850 --> 01:15:58,290
>> JASON HIRSCHHORN：）分號。

1619
01:15:58,290 --> 01:16:00,250
讓我們運行這個。

1620
01:16:00,250 --> 01:16:03,730
使個性化。

1621
01:16:03,730 --> 01:16:06,392
/個性化。

1622
01:16:06,392 --> 01:16:07,420
它只是退出。

1623
01:16:07,420 --> 01:16:10,390
為什麼退出？

1624
01:16:10,390 --> 01:16:11,310
>> 學生：你沒有提出任何論據。

1625
01:16:11,310 --> 01:16:12,560
>> JASON HIRSCHHORN：我沒有
把任何參數英寸

1626
01:16:12,560 --> 01:16:16,360

1627
01:16:16,360 --> 01:16:16,920
看起來不錯。

1628
01:16:16,920 --> 01:16:18,130
你們釘。

1629
01:16:18,130 --> 01:16:22,420
如此反复，你走進argv和你
在開始的argc檢查。

1630
01:16:22,420 --> 01:16:24,390
這些是兩個重要的
事情要記住。

1631
01:16:24,390 --> 01:16:29,250
因此，在我們之前，我們最後兩分鐘
離開，我們不會給pset兩個，但

1632
01:16:29,250 --> 01:16:33,585
就像我說的，如果你想留後
10分鐘，我想他樂意去

1633
01:16:33,585 --> 01:16:35,710
用你們的邏輯
這些問題集。

1634
01:16:35,710 --> 01:16:37,930
我們有很多今天覆蓋
所以我沒有得到他們。

1635
01:16:37,930 --> 01:16:39,820
通常情況下，我想包括
在末端。

1636
01:16:39,820 --> 01:16:42,150
所以，如果你要堅持圍繞，
堅持10分鐘左右。

1637
01:16:42,150 --> 01:16:42,990
我們會做到這一點。

1638
01:16:42,990 --> 01:16:46,250
>> 然後，我開始提到的，
pset的零和一，我們會拿到

1639
01:16:46,250 --> 01:16:48,040
反饋回給您
盡快。

1640
01:16:48,040 --> 01:16:51,260
我們的目標是獲得的pset一個反饋，
註釋部分，

1641
01:16:51,260 --> 01:16:52,850
之前的pset二是由於。

1642
01:16:52,850 --> 01:16:56,730
所以，如果你犯了一些錯誤或
文體，事情可能會更好，

1643
01:16:56,730 --> 01:17:01,330
你就會有這些信息，以便您
不會做同樣的事情在pset中兩個。

1644
01:17:01,330 --> 01:17:06,140
然後在未來，你會得到所有
您的的PSET反饋和意見

1645
01:17:06,140 --> 01:17:08,190
回在下單前到期。

1646
01:17:08,190 --> 01:17:12,695
>> 最後，如果我可以把在另一個
插頭反饋。

1647
01:17:12,695 --> 01:17:13,935
這是你的第一個部分。

1648
01:17:13,935 --> 01:17:15,920
這是我的第一部分
今年教學。

1649
01:17:15,920 --> 01:17:16,930
去那裡。

1650
01:17:16,930 --> 01:17:19,800
寫的東西​​，好的和壞的，
我會用它來作

1651
01:17:19,800 --> 01:17:21,320
部分在下一次做得更好。

1652
01:17:21,320 --> 01:17:24,870
最後，再次，如果你需要
什麼，讓我知道。

1653
01:17:24,870 --> 01:17:26,410
我更樂意幫助你們。

1654
01:17:26,410 --> 01:17:28,420
如果你只是想糖果，我
將有額外的糖果。

1655
01:17:28,420 --> 01:17:29,800
我很高興把它給你。

1656
01:17:29,800 --> 01:17:31,190
>> 這將是一個驚人的課程。

1657
01:17:31,190 --> 01:17:34,900
這是一個，如果不是我喜歡的
當然，我已經在我的整個生命，

1658
01:17:34,900 --> 01:17:37,220
我希望這將是
為您精彩。

1659
01:17:37,220 --> 01:17:40,090
所以，我想要做我的一切力量
，你真棒。

1660
01:17:40,090 --> 01:17:46,590
我要發送一封電子郵件，如果你
在我的部分或諾亞，

1661
01:17:46,590 --> 01:17:50,310
去嘗試，並安排與各
你們的時間檢查過

1662
01:17:50,310 --> 01:17:53,820
接下來的幾個星期，這樣我就可以得到
感你的CS背景是什麼，

1663
01:17:53,820 --> 01:17:58,170
它也將幫助我定制這些
部分，以更好地滿足您的需求。

1664
01:17:58,170 --> 01:17:59,740
所以，這就是我得到一字排開。

1665
01:17:59,740 --> 01:18:02,260
再次，我會看到你外
如果你想在那裡。

1666
01:18:02,260 --> 01:18:03,700
這是一周兩節。

1667
01:18:03,700 --> 01:18:04,950
謝謝你們這麼多。

1668
01:18:04,950 --> 01:18:09,067