1
00:00:08,119 --> 00:00:11,630
[Powered by Google Translate] DAVID J.馬蘭：好吧，這是CS50，這是

2
00:00:11,630 --> 00:00:14,790
本週二開始。

3
00:00:14,790 --> 00:00:16,300
謝謝。

4
00:00:16,300 --> 00:00:19,000
讓我們從這裡開始，一個電話。

5
00:00:19,000 --> 00:00:30,005
我要撥打617-BUG-CS50。

6
00:00:30,005 --> 00:00:31,230
CS50：這是CS50。

7
00:00:31,230 --> 00:00:33,930
穿梭男孩，按1。

8
00:00:33,930 --> 00:00:36,660
在開始之前，請按9。

9
00:00:36,660 --> 00:00:38,180
DAVID J.馬蘭：所以他說，班車男孩，請按1。

10
00:00:38,180 --> 00:00:41,560
因此，我們準備按1。

11
00:00:41,560 --> 00:00:43,230
CS50：您的起源是什麼？

12
00:00:43,230 --> 00:00:45,340
對於四，請按1。

13
00:00:45,340 --> 00:00:47,080
馬瑟，請按2。

14
00:00:47,080 --> 00:00:49,240
斯頓，請按3。

15
00:00:49,240 --> 00:00:51,280
拉蒙特，請按4。

16
00:00:51,280 --> 00:00:53,210
紀念品館，請按5。

17
00:00:53,210 --> 00:00:55,660
在開始之前，請按0。

18
00:00:55,660 --> 00:00:59,590
DAVID J.馬蘭：我們會按四。

19
00:00:59,590 --> 00:01:03,610
CS50：下穿梭離開這一刻，在1:10 PM，

20
00:01:03,610 --> 00:01:09,820
然後在1:20 PM，1:30 PM，1:40 PM。

21
00:01:09,820 --> 00:01:12,030
這是CS50。

22
00:01:12,030 --> 00:01:15,570
>> DAVID J.馬蘭：這是CS50的聲音。

23
00:01:15,570 --> 00:01:18,030
這是一個例子的最終的項目，

24
00:01:18,030 --> 00:01:19,500
例如，你可以咬向

25
00:01:19,500 --> 00:01:20,600
學期結束的時候。

26
00:01:20,600 --> 00:01:23,840
比如，，shuttleboy.cs50.net存在 - 

27
00:01:23,840 --> 00:01:28,200
其實一個項目，我第一次寫後，CS51

28
00:01:28,200 --> 00:01:29,740
回來時，我是一名大學生。

29
00:01:29,740 --> 00:01:32,250
這裡的靈感當年，他們所有的

30
00:01:32,250 --> 00:01:34,320
印刷穿梭巴士時間表，以及有沒有

31
00:01:34,320 --> 00:01:35,970
尋找的東西了網上的概念。

32
00:01:35,970 --> 00:01:38,730
所以，我的鴿子在一個週末，通過澆

33
00:01:38,730 --> 00:01:41,460
印刷的時間表，並把它移植到一個計算機程序。

34
00:01:41,460 --> 00:01:43,790
當時，所述計算機程序發生了要寫入

35
00:01:43,790 --> 00:01:47,110
在C，你居然跑了它在輸入班車男孩

36
00:01:47,110 --> 00:01:48,600
閃爍提示，如我們已經做了迄今。

37
00:01:48,600 --> 00:01:50,450
但這些年來，它演變成瞬間

38
00:01:50,450 --> 00:01:51,390
消息槐樹。

39
00:01:51,390 --> 00:01:53,970
最近到本網站的發展，成

40
00:01:53,970 --> 00:01:57,720
基於短信的工具，以及這個基於語音的工具。

41
00:01:57,720 --> 00:02:00,170
這是暗示在各種各樣的事情，你可以

42
00:02:00,170 --> 00:02:02,380
學期結束為自己做的。

43
00:02:02,380 --> 00:02:05,490
>> 例如，在那裡，發生班車男孩的短信版

44
00:02:05,490 --> 00:02:06,510
操作如下。

45
00:02:06,510 --> 00:02:10,880
，你的手機上，如果你發送一條短信到41411

46
00:02:10,880 --> 00:02:14,300
然後發送的的特殊符號sboy，請為班車男孩，

47
00:02:14,300 --> 00:02:18,350
其次是由A和B，其中A是一個原點和B是一個

48
00:02:18,350 --> 00:02:19,070
目的地 - 

49
00:02:19,070 --> 00:02:21,030
例如，博伊爾斯頓空間四 - 

50
00:02:21,030 --> 00:02:23,330
你應該在幾秒鐘內是一個文本

51
00:02:23,330 --> 00:02:25,820
從航天飛機男孩的消息告訴你什麼時候

52
00:02:25,820 --> 00:02:28,990
未來幾年的班車，從A點到該

53
00:02:28,990 --> 00:02:29,640
B點。

54
00:02:29,640 --> 00:02:32,510
這是一個更普遍的例子，被稱為什麼

55
00:02:32,510 --> 00:02:33,920
使用API​​。

56
00:02:33,920 --> 00:02:36,930
>> 因此，舉例來說，這裡只是shuttleboy.cs50.net的，

57
00:02:36,930 --> 00:02:39,300
實際的基於Web的化身。

58
00:02:39,300 --> 00:02:42,480
但強調這一點和其他應用程序的數據，CS50

59
00:02:42,480 --> 00:02:45,560
已開發的所有暴露的形式在這裡給大家

60
00:02:45,560 --> 00:02:49,340
的API，應用程序編程接口。

61
00:02:49,340 --> 00:02:52,220
而這僅僅是一種奇特的方式，人們喜歡說，我們對

62
00:02:52,220 --> 00:02:56,010
互聯網和其他人花了一些時間來創建

63
00:02:56,010 --> 00:02:59,970
為了搶從我們的數據和軟件，您可以使用

64
00:02:59,970 --> 00:03:02,510
然後在上面建立自己的應用程序

65
00:03:02,510 --> 00:03:03,840
該數據集。

66
00:03:03,840 --> 00:03:06,610
因此，舉例來說，這班車男孩API頁面在這裡，

67
00:03:06,610 --> 00:03:09,390
恰好是在CS50手冊，基本上文件

68
00:03:09,390 --> 00:03:13,080
你可以去CS50服務器的數據要求。

69
00:03:13,080 --> 00:03:16,240
例如，如果你熟悉CSV文件，逗號

70
00:03:16,240 --> 00:03:18,940
分隔的值，這些都只是形式的快速和骯髒的

71
00:03:18,940 --> 00:03:20,310
類似Excel的文件。

72
00:03:20,310 --> 00:03:23,110
所以，你可以問班車上所有的男孩的所有數據

73
00:03:23,110 --> 00:03:25,090
房子和他們的GPS坐標，你會得到

74
00:03:25,090 --> 00:03:27,300
回來了，從本質上講，一個類似電子表格的，

75
00:03:27,300 --> 00:03:30,820
然後，你可以閱讀到自己的程序，然後

76
00:03:30,820 --> 00:03:33,250
產生的結果，就像班車男孩本身

77
00:03:33,250 --> 00:03:34,160
發生做的事情。

78
00:03:34,160 --> 00:03:37,030
對於那些比較熟悉的，更現代的數據表示

79
00:03:37,030 --> 00:03:39,420
包括JSON，JavaScript對象表示法。

80
00:03:39,420 --> 00:03:40,620
東西會回來給你走向

81
00:03:40,620 --> 00:03:41,720
學期結束的時候。

82
00:03:41,720 --> 00:03:45,440
>> 但是，這只是其中的幾個CS50自己的API。

83
00:03:45,440 --> 00:03:48,320
而令人興奮的事情，現在，這些天來，Facebook和

84
00:03:48,320 --> 00:03:51,110
Twitter和谷歌，幾乎每一個受歡迎的網站了

85
00:03:51,110 --> 00:03:54,130
有某種形式的API，這意味著如果你讀了

86
00:03:54,130 --> 00:03:56,620
在他們的網站上的文檔，你註冊一個

87
00:03:56,620 --> 00:03:59,980
帳戶，您就可以開始編寫軟件之上

88
00:03:59,980 --> 00:04:03,680
有任何工具或數據公司提供的。

89
00:04:03,680 --> 00:04:06,210
因此，我們自己的教學研究員幾年

90
00:04:06,210 --> 00:04:07,620
寫了Mac版本的。

91
00:04:07,620 --> 00:04:10,990
因此，在左上角的鏈接標題為“蘋果在這裡，你其實可以

92
00:04:10,990 --> 00:04:13,940
下載你自己的Mac上運行的Mac OS部件的做

93
00:04:13,940 --> 00:04:15,040
同樣的事情。

94
00:04:15,040 --> 00:04:17,970
因此，它是所有有關的數據集上，像這樣的。

95
00:04:17,970 --> 00:04:21,839
但更向本學期結束。

96
00:04:21,839 --> 00:04:25,780
>> 所以我們來看看真正的快速的一個錯誤，只是一種獲得

97
00:04:25,780 --> 00:04:27,990
事情回暖的今天，與回想起一些

98
00:04:27,990 --> 00:04:29,660
事情，我們看到在上週。

99
00:04:29,660 --> 00:04:32,840
特別是，讓我去拉起來，說，

100
00:04:32,840 --> 00:04:34,080
這個例子在這裡。

101
00:04:34,080 --> 00:04:37,500
Buggy1.c，這是本課程的網站上，如果您想

102
00:04:37,500 --> 00:04:40,250
喜歡下載並戳在自己周圍。

103
00:04:40,250 --> 00:04:43,520
但是，讓我們在這裡的放大在這相當短節目，

104
00:04:43,520 --> 00:04:46,550
超快速的回顧一下一些基本構建塊，

105
00:04:46,550 --> 00:04:48,880
我們真的要開始考慮是理所當然的。

106
00:04:48,880 --> 00:04:51,860
>> 因此，藍色的東西，在第1行至第9行，只是

107
00:04:51,860 --> 00:04:53,670
壘球的問題。

108
00:04:53,670 --> 00:04:54,590
所以，這些都只是意見。

109
00:04:54,590 --> 00:04:56,230
他們有沒有功能上的意義。

110
00:04:56,230 --> 00:04:58,460
但他們在這個意義上，他們的意見筆記

111
00:04:58,460 --> 00:05:02,010
我的人，做自己的事情，所以在演講後

112
00:05:02,010 --> 00:05:04,340
講座中，我實際上可以記得這是什麼程序

113
00:05:04,340 --> 00:05:07,120
沒有讀通過一行行

114
00:05:07,120 --> 00:05:08,990
在我的腦海裡重新創建歷史。

115
00:05:08,990 --> 00:05:11,000
此外，如果有人喜歡我把這個程序

116
00:05:11,000 --> 00:05:14,420
你，這是更清晰的你，因為這樣的意見，

117
00:05:14,420 --> 00:05:16,680
是什麼程序實際上做，或至少是

118
00:05:16,680 --> 00:05:18,210
程序應該做的事情。

119
00:05:18,210 --> 00:05:20,760
無論它是正確的，是另一回事。

120
00:05:20,760 --> 00:05:25,040
現在，在C，多行註釋，回想一下，上線

121
00:05:25,040 --> 00:05:27,880
這裡是神奇的符號，/ *。

122
00:05:27,880 --> 00:05:30,380
這意味著在這裡來了一個註釋的開始。

123
00:05:30,380 --> 00:05:34,560
並沒有什麼別的事情，直到你到達終點終止，

124
00:05:34,560 --> 00:05:36,700
這是* /，相反。

125
00:05:36,700 --> 00:05:39,120
因此，事實上，我這裡有80個，一些奇怪的恆星從

126
00:05:39,120 --> 00:05:41,550
從左到右依次是真的只是一個審美的細節。

127
00:05:41,550 --> 00:05:43,370
它沒有功能上的意義。

128
00:05:43,370 --> 00:05:44,490
>> 第11行嗎？

129
00:05:44,490 --> 00:05:46,940
通俗地說是什麼？

130
00:05:51,560 --> 00:05:52,540
那是什麼？

131
00:05:52,540 --> 00:05:54,280
聽眾：包括標準。

132
00:05:54,280 --> 00:05:54,740
DAVID J.馬蘭：OK，好。

133
00:05:54,740 --> 00:05:57,500
因此，它包括stdio.h中的庫。

134
00:05:57,500 --> 00:05:58,230
那麼，是什麼意思呢？

135
00:05:58,230 --> 00:06:01,570
那麼，在這個文件中，stdio.h中，一大堆的

136
00:06:01,570 --> 00:06:03,320
函數聲明 - 

137
00:06:03,320 --> 00:06:05,290
那是別人寫的代碼。

138
00:06:05,290 --> 00:06:08,160
聲明一個函數，在一個完美的例子，

139
00:06:08,160 --> 00:06:10,250
stdio.h中 - 

140
00:06:10,250 --> 00:06:11,980
現在最喜歡的？

141
00:06:11,980 --> 00:06:14,300
因此我們知道printf，最常用的方法之一，使用，當然

142
00:06:14,300 --> 00:06:15,840
在初期，該庫是存在的。

143
00:06:15,840 --> 00:06:19,290
如果我排除該行的代碼，鐺大喊

144
00:06:19,290 --> 00:06:22,550
在我一些有關使用未聲明的符號。

145
00:06:22,550 --> 00:06:24,930
東西未申報的可能是關鍵字，因為

146
00:06:24,930 --> 00:06:27,770
我們沒有告訴編譯器輸出看起來

147
00:06:27,770 --> 00:06:29,230
喜歡，除非我們有該行。

148
00:06:29,230 --> 00:06:31,830
而更多的地球，真的，該行說的是

149
00:06:31,830 --> 00:06:34,890
打開該文件，stdio.h中，無論它是在服務器上的

150
00:06:34,890 --> 00:06:38,200
硬盤驅動器或設備的硬盤驅動器，複製粘貼

151
00:06:38,200 --> 00:06:40,240
到我的文件，沒有我的

152
00:06:40,240 --> 00:06:41,730
做手工。

153
00:06:41,730 --> 00:06:44,420
>> 現在，一旦我們在這裡為主，不久我們將開始

154
00:06:44,420 --> 00:06:46,900
梳理int和空洞。

155
00:06:46,900 --> 00:06:48,430
但現在，讓我們來看看在三線

156
00:06:48,430 --> 00:06:50,350
在15到17。

157
00:06:50,350 --> 00:06:52,250
這裡，我要求車。

158
00:06:52,250 --> 00:06:54,900
7號線在我的評論說：“如果打印10

159
00:06:54,900 --> 00:06:59,410
星號，但沒有。“為什麼這不是打印的，其實，

160
00:06:59,410 --> 00:07:01,097
10個這樣的明星嗎？

161
00:07:01,097 --> 00:07:02,347
觀眾：[聽不清]。

162
00:07:05,210 --> 00:07:05,800
DAVID J.馬蘭：沒錯。

163
00:07:05,800 --> 00:07:08,720
所以，請注意，我們從0開始計數。

164
00:07:08,720 --> 00:07:10,780
這實際上是一個編程慣例

165
00:07:10,780 --> 00:07:13,230
計算機科學，更普遍，開始計數

166
00:07:13,230 --> 00:07:14,610
從0而不是1。

167
00:07:14,610 --> 00:07:16,690
這真的只是來自於事實，即

168
00:07:16,690 --> 00:07:18,940
例如，當我們有八人在舞台上時，

169
00:07:18,940 --> 00:07:20,680
沒有人舉手，他們

170
00:07:20,680 --> 00:07:22,340
所有有效的零。

171
00:07:22,340 --> 00:07:24,260
因此，它只是種一台計算機公約，

172
00:07:24,260 --> 00:07:26,030
因此，從0開始計數。

173
00:07:26,030 --> 00:07:29,130
如果是這樣的最低數量，你可以以二進制表示。

174
00:07:29,130 --> 00:07:32,270
>> 所以，在這裡，我們已經開始初始化i為0。

175
00:07:32,270 --> 00:07:34,230
我們設定i等於0。

176
00:07:34,230 --> 00:07:37,780
但後​​來我犯了這個錯誤，在這裡，說我是小於或

177
00:07:37,780 --> 00:07:38,820
等於10。

178
00:07:38,820 --> 00:07:41,700
但是，如果你認為，如果我是從0開始，然後我去

179
00:07:41,700 --> 00:07:46,410
，1，2，3，4，5，6，7，8，9，10，實際上，我要

180
00:07:46,410 --> 00:07:49,980
打印到屏幕上的11顆星，因為我已​​經走了

181
00:07:49,980 --> 00:07:52,410
和等於10。

182
00:07:52,410 --> 00:07:55,090
因此，簡單的辦法是什麼？

183
00:07:55,090 --> 00:07:56,070
觀眾：[聽不清]。

184
00:07:56,070 --> 00:07:57,350
DAVID J.馬蘭：只要將它更改為小於。

185
00:07:57,350 --> 00:07:59,700
如果你真的想，你可以做到這一點。

186
00:07:59,700 --> 00:08:01,370
但在一般情況下，是不可取的。

187
00:08:01,370 --> 00:08:04,020
因此，從0開始計數的東西，你應該

188
00:08:04,020 --> 00:08:05,510
通常習慣。

189
00:08:05,510 --> 00:08:07,810
現在，這整個結構本身？

190
00:08:07,810 --> 00:08:10,640
這條線的15 demarks一個for循環。

191
00:08:10,640 --> 00:08:12,510
因此，對於是不是一個函數。

192
00:08:12,510 --> 00:08:13,640
這只是一個聲明。

193
00:08:13,640 --> 00:08:16,180
這是一個循環結構，就像我們所看到的划痕。

194
00:08:16,180 --> 00:08:17,600
它由三部分組成。

195
00:08:17,600 --> 00:08:19,740
請注意，這裡是第一部分

196
00:08:19,740 --> 00:08:21,350
左邊的分號。

197
00:08:21,350 --> 00:08:24,200
兩個分號之間的中間部分。

198
00:08:24,200 --> 00:08:26,250
再有就是右手部分的權利

199
00:08:26,250 --> 00:08:27,640
第二個分號。

200
00:08:27,640 --> 00:08:31,822
現在，這些做什麼？

201
00:08:31,822 --> 00:08:33,679
觀眾：[聽不清]。

202
00:08:33,679 --> 00:08:34,270
DAVID J.馬蘭嗎？

203
00:08:34,270 --> 00:08:34,816
是嗎？

204
00:08:34,816 --> 00:08:35,980
觀眾：初始化。

205
00:08:35,980 --> 00:08:36,850
>> DAVID J.馬蘭：初始化。

206
00:08:36,850 --> 00:08:37,840
所以，這是什麼意思呢？

207
00:08:37,840 --> 00:08:40,690
我們已經聲明了一個變量叫我。

208
00:08:40,690 --> 00:08:43,840
它的類型是int，因為我已​​經指定了INT I。

209
00:08:43,840 --> 00:08:46,470
我初始化i的值為0。

210
00:08:46,470 --> 00:08:47,730
那麼，這是什麼真正的意思嗎？

211
00:08:47,730 --> 00:08:50,680
它是有效的電腦說：嘿，給我足夠的

212
00:08:50,680 --> 00:08:53,660
內存，足夠的RAM，以適應數字，然後把

213
00:08:53,660 --> 00:08:56,130
0，塊RAM。

214
00:08:56,130 --> 00:08:59,100
順便說一句，有多大，是一個int通常情況下，至少裡面

215
00:08:59,100 --> 00:09:00,280
的產品？

216
00:09:00,280 --> 00:09:01,000
觀眾：32位。

217
00:09:01,000 --> 00:09:01,670
DAVID J.馬蘭：32位。

218
00:09:01,670 --> 00:09:04,890
因此，這意味著32位，否則被稱為4字節給我，

219
00:09:04,890 --> 00:09:07,250
並把值0，這是很容易的，因為

220
00:09:07,250 --> 00:09:09,110
它只是意味著將所有的位為0。

221
00:09:09,110 --> 00:09:11,690
>> 所以，現在，這裡的第二部分是條件。

222
00:09:11,690 --> 00:09:14,590
和條件，顧名思義，就是檢查

223
00:09:14,590 --> 00:09:18,100
再，再而三，是否是真還是假。

224
00:09:18,100 --> 00:09:21,410
因此，這只是說做下面的幾行代碼 - 

225
00:09:21,410 --> 00:09:23,950
即第16行，因為這是唯一一個縮進

226
00:09:23,950 --> 00:09:24,820
下 - 

227
00:09:24,820 --> 00:09:26,980
所以，只要i小於10。

228
00:09:26,980 --> 00:09:30,520
通過這個循環的每次迭代後，做

229
00:09:30,520 --> 00:09:33,840
遞加在這種情況下，這是一+ +。

230
00:09:33,840 --> 00:09:35,580
現在，它不具有為i + +。

231
00:09:35,580 --> 00:09:37,610
這可能是我 - 。

232
00:09:37,610 --> 00:09:39,860
但如果我這樣做，什麼行為會

233
00:09:39,860 --> 00:09:41,370
這個計劃嗎？

234
00:09:41,370 --> 00:09:42,290
觀眾：這將是一個無限循環。

235
00:09:42,290 --> 00:09:44,060
DAVID J.馬蘭：這將是某種形式的無限循環，

236
00:09:44,060 --> 00:09:47,720
除非我們很幸運後2負億左右。

237
00:09:47,720 --> 00:09:51,320
也許事情會環繞，只是性質的有限

238
00:09:51,320 --> 00:09:53,930
數，我們已經分配給一個int的位數。

239
00:09:53,930 --> 00:09:56,270
但它肯定是要遍歷遠遠超過10

240
00:09:56,270 --> 00:09:58,630
肯定超過11次。

241
00:09:58,630 --> 00:10:02,240
>> 而現在，正如順便說一句，我+ +和i  - 

242
00:10:02,240 --> 00:10:04,420
真的只是語法糖。

243
00:10:04,420 --> 00:10:07,210
什麼是多一點，這只是速記符號

244
00:10:07,210 --> 00:10:08,720
明確寫入如下：

245
00:10:08,720 --> 00:10:11,200
I = I + 1。

246
00:10:11,200 --> 00:10:13,460
這是相同的到i + +。

247
00:10:13,460 --> 00:10:15,860
它只是一種看起來更漂亮，說我+ +。

248
00:10:15,860 --> 00:10:17,490
它更簡潔，更具可讀性。

249
00:10:17,490 --> 00:10:19,030
因此，大多數人做，而不是。

250
00:10:19,030 --> 00:10:21,840
但是，這是相同的功能，以

251
00:10:21,840 --> 00:10:22,900
我們剛才看到的東西。

252
00:10:22,900 --> 00:10:27,770
因此，在短期，快速修復這裡只是說重複我的

253
00:10:27,770 --> 00:10:30,690
從0一路攀升至不到10個。

254
00:10:30,690 --> 00:10:32,700
然後，我們將確實得到10顆星。

255
00:10:32,700 --> 00:10:33,430
>> 所以，讓我們來試試這個。

256
00:10:33,430 --> 00:10:35,310
讓我打開終端底部。

257
00:10:35,310 --> 00:10:37,420
讓我進入的目錄，這是英寸

258
00:10:37,420 --> 00:10:40,030
我要手動編譯鐺現在。

259
00:10:40,030 --> 00:10:44,880
而且我要編譯為buggy1.c，輸入的。

260
00:10:44,880 --> 00:10:50,280
現在buggy1，為什麼沒有這樣的文件或目錄

261
00:10:50,280 --> 00:10:52,026
被稱為buggy1？

262
00:10:52,026 --> 00:10:53,850
觀眾：[聽不清]。

263
00:10:53,850 --> 00:10:54,240
DAVID J.馬蘭：是的。

264
00:10:54,240 --> 00:10:55,420
因此，它實際上是名為a.out。

265
00:10:55,420 --> 00:10:57,480
所以，記得，如果你只是運行鐺，鐺

266
00:10:57,480 --> 00:11:00,420
編譯器，和你沒有指定你想要的名稱

267
00:11:00,420 --> 00:11:03,550
給你的程序，它會默認為a.out的。

268
00:11:03,550 --> 00:11:05,030
事實上，如果我做LS  - 

269
00:11:05,030 --> 00:11:05,510
哎呀。

270
00:11:05,510 --> 00:11:07,680
我沒說 - 黑與白的問題的一些

271
00:11:07,680 --> 00:11:08,840
你所面對的已得到修復。

272
00:11:08,840 --> 00:11:10,670
但是，讓我這樣做。

273
00:11:10,670 --> 00:11:14,570
在那裡，我們有a.out的左側。

274
00:11:14,570 --> 00:11:17,360
因此，我們必須運行a.out，而不是buggy1。

275
00:11:17,360 --> 00:11:19,140
>> 所以，讓我繼續這樣做。

276
00:11:19,140 --> 00:11:22,840
。/ a.out格式，回車。

277
00:11:22,840 --> 00:11:26,160
而我顯然沒有做什麼呢？

278
00:11:26,160 --> 00:11:26,620
觀眾：保存。

279
00:11:26,620 --> 00:11:27,390
DAVID J.馬蘭：我的文件。

280
00:11:27,390 --> 00:11:31,520
所以，很容易通過點擊控制S，或去解決

281
00:11:31,520 --> 00:11:33,450
文件，保存，就像在大多數程序中。

282
00:11:33,450 --> 00:11:36,360
讓我走在這裡，清屏，再次運行它。

283
00:11:36,360 --> 00:11:37,960
仍然是一個錯誤。

284
00:11:37,960 --> 00:11:41,618
這是怎麼回事 - 

285
00:11:41,618 --> 00:11:42,980
觀眾：你沒有編譯。

286
00:11:42,980 --> 00:11:44,040
DAVID J.馬蘭：啊，太好了。

287
00:11:44,040 --> 00:11:45,010
我沒有編譯它。

288
00:11:45,010 --> 00:11:47,250
像一個白痴，我在看代碼，看看什麼是錯的。

289
00:11:47,250 --> 00:11:51,275
所以的的鐺buggy1.c，現在的a.out。

290
00:11:51,275 --> 00:11:52,640
和不快，保存。

291
00:11:52,640 --> 00:11:55,090
>> 因此，它看起來有點難看，因為沒有新的生產線

292
00:11:55,090 --> 00:11:55,970
在程序的任何地方。

293
00:11:55,970 --> 00:11:57,390
但同樣，這只是一個審美的細節。

294
00:11:57,390 --> 00:11:59,430
至少，如果再算上這些的時候，我們應該

295
00:11:59,430 --> 00:12:01,160
現在看到10個這樣的恆星。

296
00:12:01,160 --> 00:12:03,260
那麼，關於第二個熱身的例子？

297
00:12:03,260 --> 00:12:07,750
所以在buggy2的，我要求這個版本中，也將打印

298
00:12:07,750 --> 00:12:10,110
10顆星，每行一個。

299
00:12:10,110 --> 00:12:12,340
所以這一次，我有一個換行符，只是為了讓

300
00:12:12,340 --> 00:12:13,520
事情有點漂亮。

301
00:12:13,520 --> 00:12:15,410
但不是我所得到的是這樣的。

302
00:12:15,410 --> 00:12:19,590
因此，讓我做鐺buggy2.c的，Enter鍵。

303
00:12:19,590 --> 00:12:21,790
現在，它再次名為a.out。

304
00:12:21,790 --> 00:12:23,130
輸入。

305
00:12:23,130 --> 00:12:26,900
我只看到一個新的生產線，只有最後一個新行

306
00:12:26,900 --> 00:12:29,370
我的提示移動到下一行。

307
00:12:29,370 --> 00:12:32,660
，但顯然我已經打印*，然後一個新的生產線，

308
00:12:32,660 --> 00:12:33,990
*，然後一個新行。

309
00:12:33,990 --> 00:12:35,490
但是，什麼是這裡的錯誤？

310
00:12:35,490 --> 00:12:35,974
是嗎？

311
00:12:35,974 --> 00:12:37,224
觀眾：[聽不清]。

312
00:12:39,850 --> 00:12:40,470
>> DAVID J.馬蘭：沒錯。

313
00:12:40,470 --> 00:12:44,110
因此，不像有些語言，如Python中，縮進

314
00:12:44,110 --> 00:12:46,030
實際上有功能意義，在

315
00:12:46,030 --> 00:12:47,150
語言，如C  - 

316
00:12:47,150 --> 00:12:49,140
正如我們將看到的，PHP，JavaScript的 - 

317
00:12:49,140 --> 00:12:51,940
的的縮進是真的，只是為了人類的利益。

318
00:12:51,940 --> 00:12:55,690
因此，事實上，我已經縮進了16和17號線看起來不錯，

319
00:12:55,690 --> 00:12:57,530
但它沒有功能上的意義。

320
00:12:57,530 --> 00:13:00,700
如果我想這兩條線執行的一部分，

321
00:13:00,700 --> 00:13:05,140
循環，那麼我必須把它們括在大括號內這樣做。

322
00:13:05,140 --> 00:13:08,540
你只能砍那個角落，省略了花括號，如果

323
00:13:08,540 --> 00:13:10,036
什麼情況下？

324
00:13:10,036 --> 00:13:10,410
觀眾：只要一行。

325
00:13:10,410 --> 00:13:11,130
DAVID J.馬蘭：只要一行。

326
00:13:11,130 --> 00:13:15,280
所以，這只是一個很好的排序，排序的語法細節，使

327
00:13:15,280 --> 00:13:17,900
你不要浪費時間寫三行，其中兩個是

328
00:13:17,900 --> 00:13:20,040
花括號，只是寫了一行代碼。

329
00:13:20,040 --> 00:13:21,650
但是，如果你有兩個或兩個以上的線，我們

330
00:13:21,650 --> 00:13:22,860
確實需要做到這一點。

331
00:13:22,860 --> 00:13:24,210
>> 所以，現在讓我保存這個。

332
00:13:24,210 --> 00:13:27,140
讓我繼續前進，重新運行鐺。

333
00:13:27,140 --> 00:13:31,375
然後讓我重新運行a.out的，現在我讓他們每行一個。

334
00:13:31,375 --> 00:13:33,670
現在，a.out格式是怎麼樣的一個愚蠢的程序名稱。

335
00:13:33,670 --> 00:13:37,500
我怎麼能告訴鏘給我一個文件名

336
00:13:37,500 --> 00:13:39,820
更重要的是用戶友好的，像buggy2本身？

337
00:13:43,200 --> 00:13:44,466
一個更清楚一點嗎？

338
00:13:44,466 --> 00:13:45,220
觀眾：[聽不清]。

339
00:13:45,220 --> 00:13:47,810
DAVID J.馬蘭：OK，所以我其實可以採取非常

340
00:13:47,810 --> 00:13:51,000
用戶友好的快捷方式，只是寫buggy2。

341
00:13:51,000 --> 00:13:53,840
我不指定，C在這種情況下，並按下回車鍵。

342
00:13:53,840 --> 00:13:58,530
做確實是編譯buggy2.c我

343
00:13:58,530 --> 00:14:00,260
問鐺做到這一點。

344
00:14:00,260 --> 00:14:05,100
具體而言，它會調用鐺鐺，它運行使用方式

345
00:14:05,100 --> 00:14:08,540
比我真正需要的命令行參數或開關。

346
00:14:08,540 --> 00:14:11,270
隨著時間的推移，我們會回來，所有這些不同的

347
00:14:11,270 --> 00:14:13,810
神秘的連字符號的表達的意思。

348
00:14:13,810 --> 00:14:16,910
但就目前而言，這只是救了我的麻煩

349
00:14:16,910 --> 00:14:19,600
記住，不必輸入所有的這些

350
00:14:19,600 --> 00:14:21,150
不同的連字符號的表達。

351
00:14:21,150 --> 00:14:23,240
上攻，最終是

352
00:14:23,240 --> 00:14:25,900
現在我有buggy2。

353
00:14:25,900 --> 00:14:27,480
如果我想做到這一點，不過，我手動

354
00:14:27,480 --> 00:14:28,775
而是可以做到這一點 - 

355
00:14:28,775 --> 00:14:34,110
鐺-O buggy2然後buggy2.c的。

356
00:14:34,110 --> 00:14:37,980
這同樣給我一個名為buggy2。

357
00:14:37,980 --> 00:14:39,710
>> 因此，在短，鐺的編譯器。

358
00:14:39,710 --> 00:14:43,080
使僅僅是一個用戶友好的工具，我們將使用更多的

359
00:14:43,080 --> 00:14:44,420
多，因為它只是開始

360
00:14:44,420 --> 00:14:47,330
簡化對我們的事情。

361
00:14:47,330 --> 00:14:49,430
而我們，最後返回0。

362
00:14:49,430 --> 00:14:51,890
現在，只因為，但我們會開始戲弄的那部分

363
00:14:51,890 --> 00:14:52,930
今日（星期三）。

364
00:14:52,930 --> 00:14:55,560
對任何有任何疑問？

365
00:14:55,560 --> 00:14:56,450
是嗎？

366
00:14:56,450 --> 00:14:58,234
觀眾：[聽不清]

367
00:14:58,234 --> 00:15:00,020
LS的報價有嗎？

368
00:15:00,020 --> 00:15:01,710
DAVID J.馬蘭：OK。

369
00:15:01,710 --> 00:15:05,880
當我輸入ls命令報價，那是我做了一些神奇的

370
00:15:05,880 --> 00:15:07,160
幕後修復一個bug。

371
00:15:07,160 --> 00:15:09,370
我忘了，好像我們已經告訴你了

372
00:15:09,370 --> 00:15:11,600
討論板，做的 - 

373
00:15:11,600 --> 00:15:17,220
我們會做到這一點現在 - ：sudo的議案Ÿ更新appliance50，。

374
00:15:17,220 --> 00:15:19,790
哎呀，這拼寫正確的。

375
00:15:19,790 --> 00:15:23,240
因此，設備，就像是一個操作系統。

376
00:15:23,240 --> 00:15:25,650
它的運行這個名為Fedora操作系統。

377
00:15:25,650 --> 00:15:27,450
而現在，因為我的Internet連接速度較慢，我已經

378
00:15:27,450 --> 00:15:28,260
真的大清洗。

379
00:15:28,260 --> 00:15:31,620
因此，運行sudo yum更新，我們告訴你做的

380
00:15:31,620 --> 00:15:34,080
習題集，基本上是喜歡跑步的自動更新

381
00:15:34,080 --> 00:15:35,420
在Mac OS或Windows。

382
00:15:35,420 --> 00:15:37,280
和的原因，這在一開始的

383
00:15:37,280 --> 00:15:39,640
問題集，因為當我們創建設備時，我

384
00:15:39,640 --> 00:15:42,480
搞砸了，我不小心讓所有的程序看

385
00:15:42,480 --> 00:15:45,210
黑色在黑色屏幕上，這就是為什麼你沒有看到他們

386
00:15:45,210 --> 00:15:45,860
默認情況下。

387
00:15:45,860 --> 00:15:48,020
但設備的最新版本修復了這一點。

388
00:15:48,020 --> 00:15:50,500
我會解決這個問題在休息，一旦我有上網

389
00:15:50,500 --> 00:15:51,280
連通性。

390
00:15:51,280 --> 00:15:54,630
>> 因此，在報價只是隱藏我的錯，非常謹慎，

391
00:15:54,630 --> 00:15:55,730
顯然是。

392
00:15:55,730 --> 00:15:56,980
其他問題嗎？

393
00:15:59,750 --> 00:16:00,668
是嗎？

394
00:16:00,668 --> 00:16:02,012
觀眾：不使來自？

395
00:16:02,012 --> 00:16:03,810
[聽不清]

396
00:16:03,810 --> 00:16:04,280
DAVID J.馬蘭：好問題。

397
00:16:04,280 --> 00:16:05,460
在哪裡做從何而來？

398
00:16:05,460 --> 00:16:09,390
這是一個Linux程序已經存在了很多年，長

399
00:16:09,390 --> 00:16:10,570
前CS50。

400
00:16:10,570 --> 00:16:12,930
它配備了如Fedora操作系統。

401
00:16:12,930 --> 00:16:14,830
它不來從CS50庫。

402
00:16:14,830 --> 00:16:17,560
事實上，來自CS50庫的唯一的東西，

403
00:16:17,560 --> 00:16:20,470
到目前為止，我們已經看到的，是GetString時，調用getInt，所有的

404
00:16:20,470 --> 00:16:25,550
這些獲取的功能，以及字字符串，並在一定

405
00:16:25,550 --> 00:16:26,575
程度上，這個詞的布爾值。

406
00:16:26,575 --> 00:16:29,180
但是，我們會逗，除了當我們深入到CS50

407
00:16:29,180 --> 00:16:30,580
設備本身。

408
00:16:30,580 --> 00:16:32,820
>> 所以，是的，還有一個問題在這裡。

409
00:16:32,820 --> 00:16:36,636
聽眾：當你說，然後車，請問該怎麼

410
00:16:36,636 --> 00:16:39,980
計算機知道[聽不清]？

411
00:16:39,980 --> 00:16:40,520
DAVID J.馬蘭：好問題。

412
00:16:40,520 --> 00:16:43,830
所以，當你只需要運行使buggy1或使buggy2，如何

413
00:16:43,830 --> 00:16:45,220
做知道嗎？

414
00:16:45,220 --> 00:16:49,900
因此，默認情況下，如果您鍵入buggy1，尋找一個

415
00:16:49,900 --> 00:16:52,330
文件名為buggy1.c。

416
00:16:52,330 --> 00:16:55,570
然後執行的適當鐺命令，

417
00:16:55,570 --> 00:17:00,380
從而覆蓋默認的輸出文件名為a.out。

418
00:17:00,380 --> 00:17:03,670
事實上，如果我們看一下在做什麼 - 

419
00:17:03,670 --> 00:17:04,839
讓我們退出。

420
00:17:04,839 --> 00:17:09,530
如果我們看一下實際上是做什麼的，讓buggy2，

421
00:17:09,530 --> 00:17:10,470
它已經是最新的。

422
00:17:10,470 --> 00:17:13,020
因此，讓我的rm命令刪除，

423
00:17:13,020 --> 00:17:14,319
程序我以前寫的。

424
00:17:14,319 --> 00:17:17,319
鍵入Y-E-S確認，我想刪除它。

425
00:17:17,319 --> 00:17:20,480
如果我現在做，請注意，在這個很長的線，

426
00:17:20,480 --> 00:17:22,980
這最後一件事，在這裡：-O buggy2。

427
00:17:22,980 --> 00:17:26,959
所有品牌做的是通過這樣的說法，可以這麼說，到

428
00:17:26,959 --> 00:17:29,665
鐺，我沒有自己輸入。

429
00:17:29,665 --> 00:17:32,660
>> 好了，所以快速夫婦的行政

430
00:17:32,660 --> 00:17:33,470
公告。

431
00:17:33,470 --> 00:17:36,940
因此，對於部分，從而正式開始了這一未來

432
00:17:36,940 --> 00:17:38,970
週日，你會總是要帶上，如果

433
00:17:38,970 --> 00:17:40,120
你有一個，一台筆記本電腦。

434
00:17:40,120 --> 00:17:42,570
如果你沒有一台筆記本電腦，也達到了我的

435
00:17:42,570 --> 00:17:43,580
把我丟一封電子郵件。

436
00:17:43,580 --> 00:17:44,810
我們會找出一個工作流程。

437
00:17:44,810 --> 00:17:47,100
一般，你會發現在部分是，他們的一部分

438
00:17:47,100 --> 00:17:48,770
的概念，部分動手。

439
00:17:48,770 --> 00:17:52,190
我們會專門用一節的問題，

440
00:17:52,190 --> 00:17:54,110
本週的問題集，通過一些走

441
00:17:54,110 --> 00:17:55,820
從演講的概念性材料。

442
00:17:55,820 --> 00:17:57,480
而這一切在目前的習題集。

443
00:17:57,480 --> 00:18:00,010
而且我們還深入到一些實踐活動，有時

444
00:18:00,010 --> 00:18:02,190
其中將被要求提交，有時

445
00:18:02,190 --> 00:18:02,830
哪些不會。

446
00:18:02,830 --> 00:18:04,630
例如，第一週，他們注定只是作為一個

447
00:18:04,630 --> 00:18:05,780
熱身運動。

448
00:18:05,780 --> 00:18:07,800
你會發現，這些問題真的只是。

449
00:18:07,800 --> 00:18:10,220
這意味著他們是相當小的，但不一定

450
00:18:10,220 --> 00:18:13,100
重要的程序寫的，不一定

451
00:18:13,100 --> 00:18:16,230
令人興奮的和自己，但良好的機會

452
00:18:16,230 --> 00:18:19,620
練習用的語法，新的功能，在一個舒適的

453
00:18:19,620 --> 00:18:21,900
部分，在那裡你有幾個你的同學表現為

454
00:18:21,900 --> 00:18:22,870
以及您的TF。

455
00:18:22,870 --> 00:18:26,210
>> 隨著時間的推移，我們要做的是使用稱為CS50空間的工具，

456
00:18:26,210 --> 00:18:28,940
據此，而不是僅僅使用CS50家電，你會

457
00:18:28,940 --> 00:18:32,450
而不是去一個網頁在瀏覽器中，你就可以

458
00:18:32,450 --> 00:18:35,610
在部分編寫代碼在瀏覽器窗口。

459
00:18:35,610 --> 00:18:38,240
然後，如果你選擇的，你的助教可以顯示

460
00:18:38,240 --> 00:18:40,980
不管它是你在你的屏幕在瀏覽器中輸入

461
00:18:40,980 --> 00:18:43,930
窗口在全班同學面前，無論是匿名或

462
00:18:43,930 --> 00:18:47,250
公開，因此，他或她可以步行通過與

463
00:18:47,250 --> 00:18:50,080
你的同學，你做得很好，你沒有做的很好。

464
00:18:50,080 --> 00:18:52,750
再次，放心，所有這一切都可以很好匿名。

465
00:18:52,750 --> 00:18:54,410
但是這將是一個很好的機會，讓更多的

466
00:18:54,410 --> 00:18:56,810
類似講座的互動性允許的。

467
00:18:56,810 --> 00:18:58,910
>> 在此期間，我們將這些東西叫做超級

468
00:18:58,910 --> 00:19:01,610
部分，這是可選的，但是是向所有人開放

469
00:19:01,610 --> 00:19:04,030
類的，這樣你可以做到這一點更合

470
00:19:04,030 --> 00:19:05,190
問題的設置。

471
00:19:05,190 --> 00:19:06,010
這裡的時間表。

472
00:19:06,010 --> 00:19:08,870
這是也發布的網頁cs50.net。

473
00:19:08,870 --> 00:19:10,850
請注意，這裡是一個黑客特定

474
00:19:10,850 --> 00:19:12,430
明天下午。

475
00:19:12,430 --> 00:19:15,460
我們會拍一個今天和明天，發布者

476
00:19:15,460 --> 00:19:16,720
在24小時內在線。

477
00:19:16,720 --> 00:19:19,370
所以，如果你不能做任何的這些時間，不用擔心。

478
00:19:19,370 --> 00:19:22,720
再次，日程安排在線cs50.net。

479
00:19:22,720 --> 00:19:25,350
>> 在切片本身而言，你應該得到一個

480
00:19:25,350 --> 00:19:28,520
電子郵件，指示你去的過程找到的網頁

481
00:19:28,520 --> 00:19:29,610
你的部分。

482
00:19:29,610 --> 00:19:32,890
如果生活發生了改變，你需要改變你的部分，

483
00:19:32,890 --> 00:19:33,560
不是一個問題。

484
00:19:33,560 --> 00:19:37,900
返回到相同的URL，cs50.net/section，奇異，

485
00:19:37,900 --> 00:19:40,090
你會填寫類似的表格，這樣就可以

486
00:19:40,090 --> 00:19:41,260
然後給我們您的喜好。

487
00:19:41,260 --> 00:19:43,360
同時，我們會作出跟進，本週的結束，我們所能

488
00:19:43,360 --> 00:19:44,240
容納。

489
00:19:44,240 --> 00:19:49,530
上週，記得，我們​​提出使用CS50討論的，

490
00:19:49,530 --> 00:19:51,370
該課程的討論工具，在課堂上。

491
00:19:51,370 --> 00:19:53,680
因此，我們不得不問的40個問題，和

492
00:19:53,680 --> 00:19:54,720
在演講回答。

493
00:19:54,720 --> 00:19:56,280
因此，它似乎很好地工作，因此，我們將繼續

494
00:19:56,280 --> 00:19:57,180
努力做到這一點。

495
00:19:57,180 --> 00:19:59,600
如果您在演講過程中，不只是感覺很舒服提高

496
00:19:59,600 --> 00:20:00,780
你的手，而不是一個問題。

497
00:20:00,780 --> 00:20:04,640
cs50.net/discuss，張貼在那裡，我們的教學

498
00:20:04,640 --> 00:20:07,270
研究員將接聽電子或提高

499
00:20:07,270 --> 00:20:10,620
匿名問，這取決於您的名義手

500
00:20:10,620 --> 00:20:12,470
問題的性質。

501
00:20:12,470 --> 00:20:15,000
的反饋，一般的pset會

502
00:20:15,000 --> 00:20:16,760
在一個星期內返回。

503
00:20:16,760 --> 00:20:19,080
因為它需要一小會兒的部分實現

504
00:20:19,080 --> 00:20:22,430
均衡，第一pset中，0和1，將一點點

505
00:20:22,430 --> 00:20:24,130
延遲沉澱下來的東西。

506
00:20:24,130 --> 00:20:27,130
但敬請期待，在未來幾週內。

507
00:20:27,130 --> 00:20:29,750
>> 好吧，讓我把我嚴重

508
00:20:29,750 --> 00:20:31,040
只是一瞬間的聲音。

509
00:20:31,040 --> 00:20:32,690
因此，這實際上是一個有趣的氣候

510
00:20:32,690 --> 00:20:35,210
具有這個討論中，與所有其他的事情

511
00:20:35,210 --> 00:20:37,310
在校園內與之有關的事情。

512
00:20:37,310 --> 00:20:40,220
但CS50當然有其歷史的這個特殊的

513
00:20:40,220 --> 00:20:43,360
主題，每年在盡可能多的，這門課程，對許多人來說

514
00:20:43,360 --> 00:20:46,910
年，廣告板之類的大約3％。

515
00:20:46,910 --> 00:20:51,620
最近一年，2011年，CS50廣告登上35名學生。

516
00:20:51,620 --> 00:20:54,120
，我想，這是不是由於缺乏明確性。

517
00:20:54,120 --> 00:20:56,760
實現課程的教學大綱中，有一個頁面

518
00:20:56,760 --> 00:20:59,020
說明，解釋的線條。

519
00:20:59,020 --> 00:21:01,350
重複相同的語句上的每一個

520
00:21:01,350 --> 00:21:03,070
問題設置第一頁上。

521
00:21:03,070 --> 00:21:05,760
>> 所以，我今天提到這真的只是為了讓

522
00:21:05,760 --> 00:21:07,030
人們重視。

523
00:21:07,030 --> 00:21:08,080
我們已經嘗試了不同的東西。

524
00:21:08,080 --> 00:21:10,630
我想，今天我們會做的只是花一點時間來

525
00:21:10,630 --> 00:21:13,830
其實看過去的情況下，已經提出了一些。

526
00:21:13,830 --> 00:21:16,160
而不是讓這​​些骯髒的小秘密，其實

527
00:21:16,160 --> 00:21:19,170
指出學生做了什麼，以及我們如何檢測

528
00:21:19,170 --> 00:21:21,630
它和真正的首要動機是什麼

529
00:21:21,630 --> 00:21:23,950
甚至討論這個問題。

530
00:21:23,950 --> 00:21:27,060
因此，隨著中說，該行基本上是這樣的 - 

531
00:21:27,060 --> 00:21:29,200
根據教學大綱，你不客氣，你被鼓勵，以

532
00:21:29,200 --> 00:21:30,210
與同學交談。

533
00:21:30,210 --> 00:21:31,910
這就是全部的這些合作的目的

534
00:21:31,910 --> 00:21:34,470
辦公時間安嫩伯格和鼓勵的人

535
00:21:34,470 --> 00:21:35,755
最後的項目協同工作。

536
00:21:35,755 --> 00:21:38,590
當它來的時候，其實寫的，但界線

537
00:21:38,590 --> 00:21:39,790
您的最終解決方案。

538
00:21:39,790 --> 00:21:42,590
說到英語，完全正常，偽代碼，

539
00:21:42,590 --> 00:21:43,400
完全罰款。

540
00:21:43,400 --> 00:21:46,340
通過電子郵件發送同學PSET，讓他們看

541
00:21:46,340 --> 00:21:48,610
屏幕上的手繼續鍵入，

542
00:21:48,610 --> 00:21:50,110
過線。

543
00:21:50,110 --> 00:21:52,250
不要看教學大綱的特定行。

544
00:21:52,250 --> 00:21:55,850
>> 但為了畫一幅畫，這是怎麼不幸的是

545
00:21:55,850 --> 00:21:58,370
現實中，實現有網站在那裡，

546
00:21:58,370 --> 00:22:01,490
有這一類的解決方案和許多其他類。

547
00:22:01,490 --> 00:22:04,940
事實上，你或約3％，你知道這存在

548
00:22:04,940 --> 00:22:07,240
這意味著，我們知道存在的。

549
00:22:07,240 --> 00:22:09,340
事實上，有這樣的網站，在那裡你

550
00:22:09,340 --> 00:22:11,540
可以花錢找人做你的問題集 - 這是

551
00:22:11,540 --> 00:22:13,450
實際的情況下，來到了去年。

552
00:22:13,450 --> 00:22:15,790
這是一個網站叫做odesk.com。

553
00:22:15,790 --> 00:22:20,090
和TIM的名字是這裡的人到底是誰發布

554
00:22:20,090 --> 00:22:24,580
本網站，並要求別人做他的pset 7

555
00:22:24,580 --> 00:22:25,570
這種特殊情況下。

556
00:22:25,570 --> 00:22:28,350
那麼，odesk.com是非常谷歌能，我們也沒有

557
00:22:28,350 --> 00:22:30,310
在谷歌搜索非常好。

558
00:22:30,310 --> 00:22:32,360
在這裡，有網站 - 這是相當

559
00:22:32,360 --> 00:22:34,234
殘酷的，坦率地說。

560
00:22:34,234 --> 00:22:38,050
[笑]

561
00:22:38,050 --> 00:22:39,610
DAVID J.馬蘭：關於本網站的有趣的事情是，如果

562
00:22:39,610 --> 00:22:41,970
你讀了“關於”頁面，他們談論他們的企業

563
00:22:41,970 --> 00:22:44,390
文化和客戶服務是他們的頭號

564
00:22:44,390 --> 00:22:46,190
優先順序，以確保您的任務獲得

565
00:22:46,190 --> 00:22:47,890
開啟時間。

566
00:22:47,890 --> 00:22:50,580
>> 再次，但在所有的嚴重性，事實上，這些網站

567
00:22:50,580 --> 00:22:52,910
存在，實現我們也認識到，

568
00:22:52,910 --> 00:22:53,730
這些類型的站點。

569
00:22:53,730 --> 00:22:55,890
給你什麼樣的感覺形成一般

570
00:22:55,890 --> 00:22:58,570
需要，我們一般不會有很大的醜聞，人們

571
00:22:58,570 --> 00:23:01,080
任何形式的大規模合作，而是

572
00:23:01,080 --> 00:23:04,540
它的這些弱點，深夜的時刻，你有

573
00:23:04,540 --> 00:23:07,550
很多工作要做，這是上午04點00分，你累了，和你

574
00:23:07,550 --> 00:23:09,770
心裡對自己說，好吧，讓我來看看我的

575
00:23:09,770 --> 00:23:11,770
室友或朋友的代碼等。

576
00:23:11,770 --> 00:23:14,800
的表現，這不幸的是涉及學生

577
00:23:14,800 --> 00:23:17,640
像這樣的學生B一起提交一個提交的東西

578
00:23:17,640 --> 00:23:20,370
這樣的事情，其中​​肯定的是，在一台電腦

579
00:23:20,370 --> 00:23:23,830
理科類，是非常簡單的計算機科學家

580
00:23:23,830 --> 00:23:25,690
檢測軟件。

581
00:23:25,690 --> 00:23:28,410
這是另一種常見的範例，在那裡，你

582
00:23:28,410 --> 00:23:31,010
一起工作的人，也許說

583
00:23:31,010 --> 00:23:32,360
英語，就好了，偽代碼。

584
00:23:32,360 --> 00:23:35,080
但後​​來它的時候，實際提交，pset時

585
00:23:35,080 --> 00:23:37,910
剛剛獲得通過電子郵件或Dropbox或類似的交換。

586
00:23:37,910 --> 00:23:41,120
但是，在不那麼明顯，這是企圖使

587
00:23:41,120 --> 00:23:44,830
發生了什麼事，那麼這就是提交的。

588
00:23:44,830 --> 00:23:47,880
這也是，不跳閘，寫得很好件

589
00:23:47,880 --> 00:23:50,360
之類的軟件，我們必須實際檢測

590
00:23:50,360 --> 00:23:51,280
這些各種各樣的東西。

591
00:23:51,280 --> 00:23:53,760
事實上，我們要做的是運行的軟件比較所有

592
00:23:53,760 --> 00:23:55,540
今年提交的文件對過去一年的

593
00:23:55,540 --> 00:23:57,380
意見書，反對一切我們發現在

594
00:23:57,380 --> 00:24:00,060
互聯網，在那裡對每一個招聘網站。

595
00:24:00,060 --> 00:24:01,710
這一切都非常自動化。

596
00:24:01,710 --> 00:24:05,665
因此，我們這樣做真的很大公正的97％的

597
00:24:05,665 --> 00:24:07,760
真正的工作在這方面和其他的驢

598
00:24:07,760 --> 00:24:11,530
類，並把所有的努力，使工作

599
00:24:11,530 --> 00:24:13,030
他們最終提交的是自己。

600
00:24:13,030 --> 00:24:14,220
我可以去的年齡。

601
00:24:14,220 --> 00:24:16,030
>> 去年的情況下，只是極少數。

602
00:24:16,030 --> 00:24:19,350
一些學生提交的這些文件相同的pset 2，

603
00:24:19,350 --> 00:24:22,460
pset中3，PSET 4，6，PSET 9 5，PSET的pset。

604
00:24:22,460 --> 00:24:26,360
在這種情況下，這是競猜0並在去年，其中兩個

605
00:24:26,360 --> 00:24:29,570
學生提交相同的這句話在許多

606
00:24:29,570 --> 00:24:32,210
其他“類型的請求 - ”點，點，點。

607
00:24:32,210 --> 00:24:34,530
因此，即使在一類600，我們發現這

608
00:24:34,530 --> 00:24:36,310
對提交的測驗。

609
00:24:36,310 --> 00:24:39,080
因此，在短期，這 - 坦率地說，我討厭這種

610
00:24:39,080 --> 00:24:41,300
談話 - 但是這的確是一個刻意

611
00:24:41,300 --> 00:24:43,540
今年盡量壓低這個數字。

612
00:24:43,540 --> 00:24:45,650
因為即使我們說這些事情每

613
00:24:45,650 --> 00:24:48,100
今年，我覺得現實有得住就可以了幾個

614
00:24:48,100 --> 00:24:50,800
比平常多秒，其實只是指出

615
00:24:50,800 --> 00:24:53,600
，看起來可能，嗯，沒有什麼大不了的，至少

616
00:24:53,600 --> 00:24:56,390
回想起這個特殊的時刻，無論是在公平性

617
00:24:56,390 --> 00:25:00,100
你自己和你的同學在這裡。

618
00:25:00,100 --> 00:25:02,480
所以，如果你有任何問題就行了

619
00:25:02,480 --> 00:25:04,290
，請伸出手，就我個人。

620
00:25:04,290 --> 00:25:07,190
但是我的回答永遠是，完全強調，

621
00:25:07,190 --> 00:25:09,090
最後一分鐘，在晚一天的現金。

622
00:25:09,090 --> 00:25:11,080
或者，如果這是一個問題，沒有任何遲交天數，

623
00:25:11,080 --> 00:25:12,900
說實話，親自給我發電子郵件。

624
00:25:12,900 --> 00:25:14,110
我們會想出一些東西。

625
00:25:14,110 --> 00:25:17,480
請不要把你的時間在哈佛的風險。

626
00:25:17,480 --> 00:25:18,570
>> 現在，我想我們應該減輕情緒，所以我

627
00:25:18,570 --> 00:25:20,264
包括下一張幻燈片。

628
00:25:20,264 --> 00:25:22,770
[笑]

629
00:25:22,770 --> 00:25:23,630
DAVID J.馬蘭：此網站是偉大的。

630
00:25:23,630 --> 00:25:24,820
事實上，我有點心煩意亂。

631
00:25:24,820 --> 00:25:26,330
有這一個。

632
00:25:26,330 --> 00:25:29,590
那麼這個人是驚人的。

633
00:25:29,590 --> 00:25:35,190
好了，所以想到，小貓在深夜時，

634
00:25:35,190 --> 00:25:36,040
這些決定。

635
00:25:36,040 --> 00:25:40,110
好，那麼更多的樂趣和不太嚴重的東西，比如

636
00:25:40,110 --> 00:25:40,780
條件。

637
00:25:40,780 --> 00:25:43,900
>> 好，那麼我們短暫交談，了解這些。

638
00:25:43,900 --> 00:25:46,080
這是這可能是相當熟悉的

639
00:25:46,080 --> 00:25:47,260
從頭開始的世界。

640
00:25:47,260 --> 00:25:49,860
在世界上的划痕，我們有這方面的需要，有時

641
00:25:49,860 --> 00:25:51,110
去岔路。

642
00:25:51,110 --> 00:25:54,840
可以這樣做或這樣或那樣的東西在這裡。

643
00:25:54,840 --> 00:25:58,990
而當我們要做到這一點，我們就可以使用，在C，這一點，如果

644
00:25:58,990 --> 00:26:00,860
else結構。

645
00:26:00,860 --> 00:26:06,420
那麼在這裡我們有布爾表達式。

646
00:26:06,420 --> 00:26:09,260
例如，布爾表達式在這裡，我們可以或

647
00:26:09,260 --> 00:26:12,260
他們在一起，在這個意義上，我們有這個條件，或

648
00:26:12,260 --> 00:26:13,200
這一條件。

649
00:26:13,200 --> 00:26:15,100
我們可以和他們一起，在這個意義上，我們要

650
00:26:15,100 --> 00:26:17,710
檢查此條件，但該條件。

651
00:26:17,710 --> 00:26:22,440
在這裡，我們有一個switch語句，這是不那麼

652
00:26:22,440 --> 00:26:26,040
類似的語法上的那些種條件，但它

653
00:26:26,040 --> 00:26:30,160
允許我們這樣做相當於，如果，如​​果，如​​果，否則，

654
00:26:30,160 --> 00:26:34,990
如果，並通過簡單地枚舉他們個案等

655
00:26:34,990 --> 00:26:36,670
由個案。

656
00:26:36,670 --> 00:26:38,370
於是，我們看到了這些最後的時間。

657
00:26:38,370 --> 00:26:40,430
然後我們就開始接觸後，循環類的東西。

658
00:26:40,430 --> 00:26:42,070
我們剛才看到其中一個。

659
00:26:42,070 --> 00:26:44,180
但也有其他循環結構。

660
00:26:44,180 --> 00:26:46,370
>> 比如，這一個在這裡。

661
00:26:46,370 --> 00:26:50,140
因此，雖然（條件），一次又一次地做這件事情。

662
00:26:50,140 --> 00:26:53,070
因此，從根本上說，這之間似乎是不同的

663
00:26:53,070 --> 00:26:55,760
這裡for循環，這個while循環？

664
00:27:00,810 --> 00:27:05,045
這for循環，這個while循環。

665
00:27:05,045 --> 00:27:07,840
是嗎？

666
00:27:07,840 --> 00:27:08,800
那是什麼？

667
00:27:08,800 --> 00:27:10,050
觀眾：[聽不清]。

668
00:27:14,632 --> 00:27:15,120
DAVID J.馬蘭：好。

669
00:27:15,120 --> 00:27:17,130
而在循環條件，顯然有

670
00:27:17,130 --> 00:27:17,940
更多的語法。

671
00:27:17,940 --> 00:27:20,560
有這樣的初始化，此更新。

672
00:27:20,560 --> 00:27:23,820
在while循環中，只是有這個條件。

673
00:27:23,820 --> 00:27:26,630
如此看來，這是一個有點縮減兌

674
00:27:26,630 --> 00:27:28,770
循環，這意味著如果我們希望有變量，我們希望

675
00:27:28,770 --> 00:27:30,800
有遞增，我們實際上有

676
00:27:30,800 --> 00:27:32,500
我們自己做這件事情。

677
00:27:32,500 --> 00:27:34,420
>> 所以，讓我去進取，不斷開拓gedit的。

678
00:27:34,420 --> 00:27:36,320
讓我切換到設備。

679
00:27:36,320 --> 00:27:38,110
讓我們做一個快速的小例子，

680
00:27:38,110 --> 00:27:40,550
區別之一從其他。

681
00:27:40,550 --> 00:27:42,490
在我的腦海，我應該說的一件事。

682
00:27:42,490 --> 00:27:44,120
我特別提到了名添。

683
00:27:44,120 --> 00:27:47,740
蒂姆是確實有人，有學生試圖找到做

684
00:27:47,740 --> 00:27:48,680
他們為他們的功課。

685
00:27:48,680 --> 00:27:51,280
我們沒有添在特定的部分。

686
00:27:51,280 --> 00:27:53,690
因此，實現好，免得我透露一個學生，是不是學生。

687
00:27:53,690 --> 00:27:55,720
這是一個素不相識的人在互聯網上做的事情

688
00:27:55,720 --> 00:27:57,180
由代理在去年。

689
00:27:57,180 --> 00:27:58,670
因此我們發現了。

690
00:27:58,670 --> 00:28:00,630
因此，在這種情況下，在這裡，讓我繼續前進，

691
00:28:00,630 --> 00:28:02,810
打開一個新的文件。

692
00:28:02,810 --> 00:28:04,800
文件，新建。

693
00:28:04,800 --> 00:28:06,050
這給了我一個標籤。

694
00:28:06,050 --> 00:28:09,940
讓我繼續前進，將其保存為loop.c.

695
00:28:09,940 --> 00:28:11,810
讓我走，單擊“保存”。

696
00:28:11,810 --> 00:28:15,340
那麼在這裡，讓我們繼續前進，並開始寫

697
00:28:15,340 --> 00:28:16,605
等級。

698
00:28:19,116 --> 00:28:20,520
讓我放大。

699
00:28:20,520 --> 00:28:23,410
現在，我們要做的詮釋主要（無效）。

700
00:28:23,410 --> 00:28:30,020
現在，讓我繼續做（INT I = 0;

701
00:28:30,020 --> 00:28:33,480
哦，我+ +）。

702
00:28:33,480 --> 00:28:36,620
現在我要繼續做打印的明星，我

703
00:28:36,620 --> 00:28:37,890
前面所做的那樣。

704
00:28:37,890 --> 00:28:39,390
然後在課程結束後，我們只是要

705
00:28:39,390 --> 00:28:41,130
打印新的生產線，只是讓我的提示

706
00:28:41,130 --> 00:28:42,470
不看所有的凌亂。

707
00:28:42,470 --> 00:28:45,170
返回0。

708
00:28:45,170 --> 00:28:47,610
似乎語法上是正確的嗎？

709
00:28:47,610 --> 00:28:48,040
到目前為止。

710
00:28:48,040 --> 00:28:48,560
所以，讓我們來看看。

711
00:28:48,560 --> 00:28:51,290
>> 因此，讓我放大了，進入我的終端窗口。

712
00:28:51,290 --> 00:28:54,570
讓我繼續運行循環，因為我把這個

713
00:28:54,570 --> 00:28:55,690
事情loop.c.

714
00:28:55,690 --> 00:28:56,780
所以循環。

715
00:28:56,780 --> 00:28:57,840
似乎編譯OK。

716
00:28:57,840 --> 00:29:00,210
讓我跑環，現在輸入。

717
00:29:00,210 --> 00:29:01,820
它似乎已經印刷了10位明星。

718
00:29:01,820 --> 00:29:03,780
因此，讓我們將它轉換為一個while循環，看看有什麼

719
00:29:03,780 --> 00:29:05,220
種問題，我們絆倒。

720
00:29:05,220 --> 00:29:11,290
因此，而不是這個，讓我就在這裡說，而我是

721
00:29:11,290 --> 00:29:12,760
小於10  - 

722
00:29:12,760 --> 00:29:14,910
讓我擺脫的for循環。

723
00:29:14,910 --> 00:29:17,170
好了，我們已經有一對夫婦的問題。

724
00:29:17,170 --> 00:29:21,110
因此，條件是相同的，但我明顯缺失

725
00:29:21,110 --> 00:29:21,680
初始化。

726
00:29:21,680 --> 00:29:23,840
我錯過了遞增。

727
00:29:23,840 --> 00:29:28,020
那麼應該怎樣編譯器可能會告訴我，當我嘗試

728
00:29:28,020 --> 00:29:29,170
編譯這個程序？

729
00:29:29,170 --> 00:29:29,666
是嗎？

730
00:29:29,666 --> 00:29:31,154
觀眾：[聽不清]。

731
00:29:31,154 --> 00:29:31,650
>> DAVID J.馬蘭：好。

732
00:29:31,650 --> 00:29:34,180
因此，它會說類似未申報 - 在這種

733
00:29:34,180 --> 00:29:35,280
在這種情況下，變量。

734
00:29:35,280 --> 00:29:37,980
事實上，使用未聲明的標識符我。

735
00:29:37,980 --> 00:29:40,960
所以這是在對比的語言，如PHP，

736
00:29:40,960 --> 00:29:43,120
Python和Ruby，有些人可能是熟悉的，

737
00:29:43,120 --> 00:29:44,820
在那裡你可以開始使用一種變量

738
00:29:44,820 --> 00:29:47,420
不管三七二十一，而不必擔心有關聲明

739
00:29:47,420 --> 00:29:48,560
明確的始終。

740
00:29:48,560 --> 00:29:51,770
在C語言如Java和C + +，你必須要

741
00:29:51,770 --> 00:29:53,020
超明確。

742
00:29:53,020 --> 00:29:55,760
如果你要一個變量叫我，你一定要告訴我

743
00:29:55,760 --> 00:29:57,360
它是什麼類型的變量。

744
00:29:57,360 --> 00:29:59,360
因此，我們要解決這個問題如下。

745
00:29:59,360 --> 00:30:05,510
我要在這裡輸入INT I，因此，

746
00:30:05,510 --> 00:30:07,860
我聲明了一個變量叫我。

747
00:30:07,860 --> 00:30:09,180
現在，我已經跳過一個步驟。

748
00:30:09,180 --> 00:30:11,340
我顯然沒有初始化它，但讓我們看看，在

749
00:30:11,340 --> 00:30:13,650
品牌鐺停止抱怨。

750
00:30:13,650 --> 00:30:15,770
因此，讓我重新製作這個節目。

751
00:30:15,770 --> 00:30:16,770
>> 好了，現在它只是抱怨

752
00:30:16,770 --> 00:30:17,870
出於不同的原因。

753
00:30:17,870 --> 00:30:21,130
“變數”我未初始化的時候用在這裡。“好，那麼

754
00:30:21,130 --> 00:30:22,340
這是非常清楚的。

755
00:30:22,340 --> 00:30:25,510
初始化設置它的值等於。

756
00:30:25,510 --> 00:30:30,820
我們還沒有這樣做，所以讓我來試試等於0。

757
00:30:30,820 --> 00:30:35,030
現在，讓我們再試一次，然後重新運行鐺。

758
00:30:35,030 --> 00:30:36,140
編譯時間。

759
00:30:36,140 --> 00:30:37,210
我運行它。

760
00:30:37,210 --> 00:30:43,120
但是又大又老的無限循環，因為我已​​經做了

761
00:30:43,120 --> 00:30:45,530
初始化時，我已經做了的情況，但我從來沒有做過

762
00:30:45,530 --> 00:30:47,030
任何形式的遞增。

763
00:30:47,030 --> 00:30:48,780
那麼，我該怎麼辦遞增？

764
00:30:48,780 --> 00:30:51,170
那麼，在一個while循環，那感覺就像我要去有

765
00:30:51,170 --> 00:30:54,180
做它的內部循環，因為非常類似於第一個

766
00:30:54,180 --> 00:30:56,570
本週的的做循環結構的例子，如與

767
00:30:56,570 --> 00:30:59,040
襪子和計數，我們不得不這樣做

768
00:30:59,040 --> 00:31:01,550
在最後的東西，想回去到下一行。

769
00:31:01,550 --> 00:31:05,040
如果我繼續做這個，我+ +嗎？

770
00:31:05,040 --> 00:31:06,030
讓我們甚至不能編譯這個。

771
00:31:06,030 --> 00:31:06,890
趕上我了。

772
00:31:06,890 --> 00:31:09,704
什麼是錯的嗎？

773
00:31:09,704 --> 00:31:10,690
觀眾：[聽不清]。

774
00:31:10,690 --> 00:31:11,770
>> DAVID J.馬蘭：這絕對不是整數。

775
00:31:11,770 --> 00:31:13,080
這是我。

776
00:31:13,080 --> 00:31:15,110
和花括號，像以前一樣，

777
00:31:15,110 --> 00:31:16,800
縮進是不夠的。

778
00:31:16,800 --> 00:31:18,410
所以，現在我有這個。

779
00:31:18,410 --> 00:31:21,780
因此，雖然我是小於10，打印的明星，

780
00:31:21,780 --> 00:31:23,220
然後遞增。

781
00:31:23,220 --> 00:31:25,680
的方式，而循環的作品，只要你打的

782
00:31:25,680 --> 00:31:29,630
底部的循環，在這種情況下，看起來像10行，

783
00:31:29,630 --> 00:31:32,880
它會回到6號線，在這一點上，

784
00:31:32,880 --> 00:31:34,400
條件將被再次審核。

785
00:31:34,400 --> 00:31:37,500
，如果我仍然低於10，我們會做8號線和

786
00:31:37,500 --> 00:31:41,250
然後按9，然後我們會打10，並返回至6，再和

787
00:31:41,250 --> 00:31:45,580
一遍又一遍，這樣，只要i小於10。

788
00:31:45,580 --> 00:31:47,860
因此，讓我們重新運行。

789
00:31:47,860 --> 00:31:48,940
>> 好了，我們已經編制了還好。

790
00:31:48,940 --> 00:31:50,300
讓我重新運行循環。

791
00:31:50,300 --> 00:31:52,620
現在它實際上似乎工作。

792
00:31:52,620 --> 00:31:55,100
所以，這裡的長處和短處？

793
00:31:55,100 --> 00:31:58,910
嗯，到目前為止，有其實並沒有一個整體的巴解組織 - 

794
00:31:58,910 --> 00:31:59,420
太可愛了。

795
00:31:59,420 --> 00:32:01,870
所有的權利，這是一個 - 啊，那是個意外。

796
00:32:01,870 --> 00:32:05,200
好吧，讓我們回到for循環。

797
00:32:05,200 --> 00:32:07,530
因此，for循環是不錯的，因為他們是超級明確。

798
00:32:07,530 --> 00:32:09,720
即使他們寫的是一個有點笨拙，這是

799
00:32:09,720 --> 00:32:11,500
非常強大，它可以讓你做

800
00:32:11,500 --> 00:32:12,980
多件事情。

801
00:32:12,980 --> 00:32:16,240
While循環不似乎有一個巨大的量的值

802
00:32:16,240 --> 00:32:18,500
然而，因為它感覺就像是我們必須做更多的工作。

803
00:32:18,500 --> 00:32:20,670
我們必須把初始化在這裡，

804
00:32:20,670 --> 00:32:23,480
更新在這裡，我們要記住做的一切。

805
00:32:23,480 --> 00:32:26,260
因此，我們會看到在while循環的時間，實際上是借

806
00:32:26,260 --> 00:32:29,380
只是不同的背景，不同的數據

807
00:32:29,380 --> 00:32:33,900
列表和哈希表等結構的事，我們會得到

808
00:32:33,900 --> 00:32:34,970
學期中。

809
00:32:34,970 --> 00:32:37,900
但現在，知道有這第三類被稱為一個做

810
00:32:37,900 --> 00:32:38,480
while循環。

811
00:32:38,480 --> 00:32:39,540
我們已經看到了這個簡單。

812
00:32:39,540 --> 00:32:41,830
這可能是超級有幫助的pset 1。

813
00:32:41,830 --> 00:32:45,570
任何時候你想要做的事，然後檢查

814
00:32:45,570 --> 00:32:48,940
用戶合作，如果他們沒有，再這樣做，一做，

815
00:32:48,940 --> 00:32:51,460
while循環適合自己的那種邏輯。

816
00:32:51,460 --> 00:32:55,640
因為作為從頂部到底部的順序在這裡表明，

817
00:32:55,640 --> 00:32:57,750
“的字面意思是”做到這一點。

818
00:32:57,750 --> 00:32:59,830
一次又一次的做到這​​一點，可能是什麼？

819
00:32:59,830 --> 00:33:03,000
也許這意味著調用getInt或GetString和

820
00:33:03,000 --> 00:33:05,830
調用getInt或GetString的檢查值，然後大呼小叫

821
00:33:05,830 --> 00:33:08,260
在用戶，如果他們沒有要求他們合作，

822
00:33:08,260 --> 00:33:10,100
再次，一遍又一遍。

823
00:33:10,100 --> 00:33:11,730
如果您想要做的事一次，

824
00:33:11,730 --> 00:33:13,210
然後檢查一些條件。

825
00:33:13,210 --> 00:33:14,110
>> 所以，讓我們來試試這個。

826
00:33:14,110 --> 00:33:17,130
讓我真正改變現在到do-whil​​e循環。

827
00:33:17,130 --> 00:33:18,830
我要繼續前進並執行以下操作。

828
00:33:18,830 --> 00:33:21,830
因此，請執行以下操作。

829
00:33:21,830 --> 00:33:26,870
讓我們做INT I =調用getInt（），但讓我們先告訴用戶

830
00:33:26,870 --> 00:33:27,410
該怎麼做。

831
00:33:27,410 --> 00:33:29,050
有那麼一點點不同，這一次。

832
00:33:29,050 --> 00:33:31,270
“給我一個int”。

833
00:33:31,270 --> 00:33:32,910
所以，我會使用printf。

834
00:33:32,910 --> 00:33:35,740
現在我來這兒的，我要做到這一點

835
00:33:35,740 --> 00:33:41,520
而我，比方說，大於 - 

836
00:33:41,520 --> 00:33:47,540
讓我們來看看，我是，讓我們說，小於0，或I

837
00:33:47,540 --> 00:33:48,730
大於10。

838
00:33:48,730 --> 00:33:51,810
換句話說，我想一個數字從1到9，只

839
00:33:51,810 --> 00:33:52,720
隨意。

840
00:33:52,720 --> 00:33:55,290
所以，我使用的是組​​合布爾表達式，這裡

841
00:33:55,290 --> 00:33:59,930
確保i是小於0或大於10時，在其中

842
00:33:59,930 --> 00:34:02,530
情況下，我會在這裡做這個循環。

843
00:34:02,530 --> 00:34:04,400
所以，再一次，做到這一點 - 

844
00:34:04,400 --> 00:34:08,480
而i是小於0或i是大於10。

845
00:34:08,480 --> 00:34:11,440
>> 現在讓我們繼續前進，做到這一點，一旦我們做到了這一點。

846
00:34:11,440 --> 00:34:13,270
讓我們做一個快速的完整性檢查。

847
00:34:13,270 --> 00:34:18,929
printf（“請謝謝你，我是％d”，I）。

848
00:34:18,929 --> 00:34:21,350
因此，這個簡單的程序要求用戶類型為int的，

849
00:34:21,350 --> 00:34:24,000
確保是在一定範圍內，1至9，

850
00:34:24,000 --> 00:34:26,280
感謝用戶，提醒他們什麼，他們只是

851
00:34:26,280 --> 00:34:27,940
輸入的，只是作為一個小的完整性檢查。

852
00:34:27,940 --> 00:34:30,659
但是，讓我們來看看，如果這個工程預期。

853
00:34:30,659 --> 00:34:34,533
讓我去低著頭，並重新運行make循環。

854
00:34:34,533 --> 00:34:35,350
嗯。

855
00:34:35,350 --> 00:34:38,600
“使用未聲明的標識符'我'”。這很奇怪。

856
00:34:38,600 --> 00:34:41,509
我想，我們議決。

857
00:34:45,489 --> 00:34:47,560
相同的症狀，但不同的代碼。

858
00:34:47,560 --> 00:34:47,899
是嗎？

859
00:34:47,899 --> 00:34:50,191
觀眾：[聽不清]裡面的兩個，我們必須

860
00:34:50,191 --> 00:34:52,639
[聽不清]。

861
00:34:52,639 --> 00:34:53,260
>> DAVID J.馬蘭：沒錯。

862
00:34:53,260 --> 00:34:55,989
因此，這實際上導致我們的主題被稱為範圍。

863
00:34:55,989 --> 00:34:59,350
原來，C，再次，它真的需要你從字面上。

864
00:34:59,350 --> 00:35:02,970
如果你做這樣的事情，你聲明一個int

865
00:35:02,970 --> 00:35:06,120
然後將其分配一定的價值，但你這樣做，裡面的

866
00:35:06,120 --> 00:35:09,840
一對花括號，什麼C也就是它假設你

867
00:35:09,840 --> 00:35:14,800
只希望知道，因為我存在於那些32位

868
00:35:14,800 --> 00:35:18,200
這些花括號的情況下，行範圍內

869
00:35:18,200 --> 00:35:22,420
6至9。所以我宣布，它被賦予一個

870
00:35:22,420 --> 00:35:26,530
在第8行，但只要你以外的

871
00:35:26,530 --> 00:35:30,270
9號線以下的花括號，我不再是

872
00:35:30,270 --> 00:35:31,910
範圍，可以這麼說。

873
00:35:31,910 --> 00:35:35,030
S-C-O-P-E。它不再是在正確的上下文。

874
00:35:35,030 --> 00:35:37,940
所以，現在有沒有我，所以，雖然我們甚至沒有

875
00:35:37,940 --> 00:35:38,770
宣布它在所有。

876
00:35:38,770 --> 00:35:41,520
>> 那麼，什麼是修復這樣的事情，如果

877
00:35:41,520 --> 00:35:44,300
原因是，我花括號內聲明的，

878
00:35:44,300 --> 00:35:45,120
顯然是壞？

879
00:35:45,120 --> 00:35:45,410
在這裡嗎？

880
00:35:45,410 --> 00:35:46,820
觀眾：[聽不清]。

881
00:35:46,820 --> 00:35:47,150
DAVID J.馬蘭：是的。

882
00:35:47,150 --> 00:35:48,710
因此，我們可以初始化外面。

883
00:35:48,710 --> 00:35:53,530
因此，讓我繼續和刪除的聲明部分，

884
00:35:53,530 --> 00:35:55,820
我指定的類型，並讓我在這裡做起來。

885
00:35:55,820 --> 00:36:00,220
因此，在第5行，現在說“給我一個int。”我呼叫它。

886
00:36:00,220 --> 00:36:03,400
請注意，在第9行，我並不想這樣做，因為我

887
00:36:03,400 --> 00:36:04,830
已經有32位。

888
00:36:04,830 --> 00:36:06,140
我不想問電腦中

889
00:36:06,140 --> 00:36:07,630
不同的32比特。

890
00:36:07,630 --> 00:36:09,850
我想使用相同的32位。

891
00:36:09,850 --> 00:36:13,190
而現在，因為我是第5行中宣布，它仍然是合法的

892
00:36:13,190 --> 00:36:16,550
使用它在第11行和第12行。

893
00:36:16,550 --> 00:36:19,310
>> 因此，讓我嘗試重新編譯，看看

894
00:36:19,310 --> 00:36:20,490
如果鐺停止叫喊。

895
00:36:20,490 --> 00:36:22,380
使循環。

896
00:36:22,380 --> 00:36:25,470
因此，現在是“隱式聲明函數

897
00:36:25,470 --> 00:36:29,880
調用getInt“在C99是無效的。”那是什麼？“

898
00:36:29,880 --> 00:36:30,400
是嗎？

899
00:36:30,400 --> 00:36:32,330
觀眾：[聽不清]。

900
00:36:32,330 --> 00:36:32,690
DAVID J.馬蘭：是的。

901
00:36:32,690 --> 00:36:35,520
所以，現在，我實際使用的調用getInt，這是不是

902
00:36:35,520 --> 00:36:38,190
這只是配備了C.這是來自CS50。

903
00:36:38,190 --> 00:36:39,890
因此，我們需要在這裡。

904
00:36:39,890 --> 00:36:41,450
讓我回去的迅速下降

905
00:36:41,450 --> 00:36:43,500
在這裡，重新運行。

906
00:36:43,500 --> 00:36:44,160
好了，終於。

907
00:36:44,160 --> 00:36:46,270
現在我們已經解決了，其它的錯誤。

908
00:36:46,270 --> 00:36:48,930
讓我跑去循環，並看看會發生什麼。

909
00:36:48,930 --> 00:36:51,740
“給我一個int。”我給它11。

910
00:36:51,740 --> 00:36:53,100
我給它-1。

911
00:36:53,100 --> 00:36:54,470
我給它富。

912
00:36:54,470 --> 00:36:56,080
我給它5。

913
00:36:56,080 --> 00:36:57,450
而現在，它確實工作的。

914
00:36:57,450 --> 00:36:59,410
但提示改變的原因就在這裡。

915
00:36:59,410 --> 00:37:02,800
為什麼說重試這些時間，但給我一個

916
00:37:02,800 --> 00:37:03,920
int的三倍嗎？

917
00:37:03,920 --> 00:37:05,500
這是為什麼行為有什麼不同？

918
00:37:05,500 --> 00:37:06,980
聽眾：給它一個字符串。

919
00:37:06,980 --> 00:37:07,830
DAVID J.馬蘭：你說什麼？

920
00:37:07,830 --> 00:37:08,570
觀眾：你給它一個字符串。

921
00:37:08,570 --> 00:37:08,990
DAVID J.馬蘭：是的。

922
00:37:08,990 --> 00:37:11,450
所以我們給它一個字符串在這第三次嘗試，

923
00:37:11,450 --> 00:37:12,490
當我輸入foo的。

924
00:37:12,490 --> 00:37:13,200
foo是一個字符串。

925
00:37:13,200 --> 00:37:14,340
這顯然不是一個int。

926
00:37:14,340 --> 00:37:17,500
CS50已實施的方式調用getInt的是，我們

927
00:37:17,500 --> 00:37:20,330
不檢查，如果事情是小於0或大於10

928
00:37:20,330 --> 00:37:22,260
你，因為我們該如何提前知道什麼樣的

929
00:37:22,260 --> 00:37:23,130
int的你要嗎？

930
00:37:23,130 --> 00:37:25,880
最低限度，但我們可以檢查你的，沒用戶至少

931
00:37:25,880 --> 00:37:26,730
輸入一個整數？

932
00:37:26,730 --> 00:37:30,500
如果他們沒有，我們喊在用戶鍵入“重試”

933
00:37:30,500 --> 00:37:31,440
在屏幕上。

934
00:37:31,440 --> 00:37:34,210
>> 所以，現在我們有一個程序的循環。好吧。

935
00:37:34,210 --> 00:37:37,070
現在，這是一種更好的結構？

936
00:37:37,070 --> 00:37:39,060
因此，這是事情開始變得有些混亂，

937
00:37:39,060 --> 00:37:42,360
事實上，你一定要記住在這裡聲明一個變量

938
00:37:42,360 --> 00:37:44,630
如果你想使用它裡面的一些

939
00:37:44,630 --> 00:37:46,460
花括號外。

940
00:37:46,460 --> 00:37:48,490
但是，即使這看起來有點神秘

941
00:37:48,490 --> 00:37:50,750
一目了然，只是，記得簡單的邏輯。

942
00:37:50,750 --> 00:37:54,630
為了使用任何C，它是否是一個函數或

943
00:37:54,630 --> 00:37:57,680
它是一個變量，你必須包括它，如果它是一個函數

944
00:37:57,680 --> 00:37:59,770
在一些圖書館，或者你需要聲明它。

945
00:37:59,770 --> 00:38:02,405
但現在你需要額外注意的事實，

946
00:38:02,405 --> 00:38:04,940
你宣布它在正確的範圍內。

947
00:38:04,940 --> 00:38:08,150
你不把它得緊緊的括號內。

948
00:38:08,150 --> 00:38:09,410
>> 所以，讓我真正回滾。

949
00:38:09,410 --> 00:38:12,660
如果我們回到我們的例子前面的內容，和我一起去

950
00:38:12,660 --> 00:38:19,245
為int i = 0; <10; i + +，和我

951
00:38:19,245 --> 00:38:26,370
做printf的明星，這樣，然後關閉括號，現在

952
00:38:26,370 --> 00:38:30,410
printf的，我是現在 - 

953
00:38:30,410 --> 00:38:33,500
根據同樣的邏輯，會發生什麼事，當我嘗試

954
00:38:33,500 --> 00:38:35,500
編譯這個程序？

955
00:38:35,500 --> 00:38:36,790
觀眾：無效的標識符。

956
00:38:36,790 --> 00:38:38,560
DAVID J.馬蘭：這是另一種無效的標識符，

957
00:38:38,560 --> 00:38:39,470
未聲明的標識符。

958
00:38:39,470 --> 00:38:41,810
現在，原因是有一點不同。

959
00:38:41,810 --> 00:38:44,370
這裡顯然沒有花括號，但同樣

960
00:38:44,370 --> 00:38:46,790
的想法，同樣的故事，適用範圍。

961
00:38:46,790 --> 00:38:50,340
如果你像我聲明了一個變量內的

962
00:38:50,340 --> 00:38:53,960
循環，即使你沒有明確的書面的花

963
00:38:53,960 --> 00:38:56,980
括號，認為他們在精神上仍然存在，在

964
00:38:56,980 --> 00:39:00,310
情況下，我是唯一有效的內部循環。

965
00:39:00,310 --> 00:39:03,080
它是無效的，一旦你到下一行，這

966
00:39:03,080 --> 00:39:05,090
這種情況下，現在是10。

967
00:39:05,090 --> 00:39:09,060
因此，只要幾個問題的範圍之類。

968
00:39:09,060 --> 00:39:12,620
好吧，什麼問題嗎？

969
00:39:12,620 --> 00:39:15,310
>> 正確的，所以這是一個簡單的小程序，

970
00:39:15,310 --> 00:39:17,450
打印小星星。

971
00:39:17,450 --> 00:39:20,400
但是，讓我們來看看，如果你還記得這首歌。

972
00:39:20,400 --> 00:39:22,530
這是一個令人難以置信的討厭的歌曲，孩子們會唱

973
00:39:22,530 --> 00:39:23,550
校車等。

974
00:39:23,550 --> 00:39:25,990
但好處是，它有這樣的週期性，

975
00:39:25,990 --> 00:39:27,910
據此，它的“99瓶啤酒在牆壁上，

976
00:39:27,910 --> 00:39:28,520
99瓶啤酒。

977
00:39:28,520 --> 00:39:31,030
拿一個，通過它，98瓶啤酒

978
00:39:31,030 --> 00:39:34,330
牆上。“的歌曲，然後重複97，然後96，然後

979
00:39:34,330 --> 00:39:38,040
95，94，一路下降到0，如果你真的得到了，

980
00:39:38,040 --> 00:39:38,920
遠在總線上。

981
00:39:38,920 --> 00:39:41,960
因此，這是一個很好的方案的實施進行排序，因為我的

982
00:39:41,960 --> 00:39:43,650
上帝，如果你可以只實施這幾個

983
00:39:43,650 --> 00:39:46,660
行代碼，你可以吐出這整個歌詞

984
00:39:46,660 --> 00:39:48,240
歌曲相當快。

985
00:39:48,240 --> 00:39:50,420
但前進的道路上，我們現在就可以開始梳理除了一些

986
00:39:50,420 --> 00:39:52,460
這些基本的循環結構，現在也

987
00:39:52,460 --> 00:39:55,830
介紹，我們寫自己的函數，返回值

988
00:39:55,830 --> 00:39:57,020
我們通過左右。

989
00:39:57,020 --> 00:39:58,910
但是，第一，為什麼我們不繼續前進，並採取我們的五分鐘

990
00:39:58,910 --> 00:39:59,320
在這裡休息一下嗎？

991
00:39:59,320 --> 00:40:01,480
當我們回來時，我們會唱這首歌。

992
00:40:05,680 --> 00:40:08,760
>> 好了，所以我們又回來了。

993
00:40:08,760 --> 00:40:11,850
我說，我們現在唱這首歌時，我的意思是

994
00:40:11,850 --> 00:40:13,250
通過編程，而不是口頭上。

995
00:40:13,250 --> 00:40:19,370
所以在這裡我們beer1.c，這是一個實現

996
00:40:19,370 --> 00:40:20,580
特別的歌。

997
00:40:20,580 --> 00:40:23,110
而僅僅是明確的，對於那些不熟悉

998
00:40:23,110 --> 00:40:24,460
這件事情的樣子，讓我繼續

999
00:40:24,460 --> 00:40:27,070
使beer1，回車。

1000
00:40:27,070 --> 00:40:30,400
現在讓我跑beer1，我們會看到什麼 - 有多少瓶

1001
00:40:30,400 --> 00:40:31,140
啤酒有嗎？

1002
00:40:31,140 --> 00:40:33,240
我會輸入99，喜歡的歌。

1003
00:40:33,240 --> 00:40:34,040
輸入。

1004
00:40:34,040 --> 00:40:35,650
現在，如果我們通過滾動 - 

1005
00:40:35,650 --> 00:40:38,280
很抱歉 - 如果滾動通過這一切，我們會看到，

1006
00:40:38,280 --> 00:40:41,350
這確實唱整首歌曲。

1007
00:40:44,050 --> 00:40:44,540
等待一分鐘。

1008
00:40:44,540 --> 00:40:46,240
我的滾動條有點亂。

1009
00:40:46,240 --> 00:40:47,940
讓我們用更大的窗口。

1010
00:40:47,940 --> 00:40:53,500
因此，beer1，99，我們走吧。

1011
00:40:53,500 --> 00:40:56,420
所以在這裡我們唱整首歌曲，更快，

1012
00:40:56,420 --> 00:40:58,450
計算機，它可能是我們。

1013
00:40:58,450 --> 00:41:00,340
所以注意到，雖然，這裡的週期性質。

1014
00:41:00,340 --> 00:41:03,380
它說99，然後99，然後拿一個下來，通過它

1015
00:41:03,380 --> 00:41:04,740
圍繞“98。

1016
00:41:04,740 --> 00:41:06,640
現在，它重複了一次又一次。

1017
00:41:06,640 --> 00:41:08,840
>> 因此，這實際上是一個絕好的機會某種

1018
00:41:08,840 --> 00:41:10,400
循環結構。

1019
00:41:10,400 --> 00:41:12,950
請注意，我這裡種切割一個角落。

1020
00:41:12,950 --> 00:41:15,960
請注意，我說：“在牆壁上的98瓶啤酒，

1021
00:41:15,960 --> 00:41:19,010
在牆壁上，97瓶啤酒“，這僅僅是

1022
00:41:19,010 --> 00:41:21,640
當我們得到一個瓶啤酒，我沒有

1023
00:41:21,640 --> 00:41:23,300
擔心的英語語法。

1024
00:41:23,300 --> 00:41:25,790
但我們也可以解決這個問題的，如果一點點

1025
00:41:25,790 --> 00:41:26,910
的情況下，也許。

1026
00:41:26,910 --> 00:41:30,110
如果這個數字是單數，繼續說：“瓶子”，

1027
00:41:30,110 --> 00:41:31,840
否則，如果它是多元的，說：“瓶”。

1028
00:41:31,840 --> 00:41:34,150
但現在，我完全切斷那個角落。

1029
00:41:34,150 --> 00:41:35,520
因此，讓我們來看看我們有什麼。

1030
00:41:35,520 --> 00:41:37,150
因此，我們在上面已經得到了一些意見。

1031
00:41:37,150 --> 00:41:39,450
我包括這兩個庫，

1032
00:41:39,450 --> 00:41:41,140
我們已經普遍了。

1033
00:41:41,140 --> 00:41:43,610
現在讓我向下滾動到第一

1034
00:41:43,610 --> 00:41:44,990
實際的代碼行。

1035
00:41:44,990 --> 00:41:47,020
第17行揭開序幕主。

1036
00:41:47,020 --> 00:41:50,610
21和20號線將有多少瓶啤酒？

1037
00:41:50,610 --> 00:41:52,060
然後調用調用getInt。

1038
00:41:52,060 --> 00:41:53,800
現在我有一個位的完整性檢查。

1039
00:41:53,800 --> 00:41:57,030
>> 因此，這是一個約定，我們現在將開始採用

1040
00:41:57,030 --> 00:41:59,620
更嚴格檢查用戶的輸入。

1041
00:41:59,620 --> 00:42:01,710
有時候，你只是不希望促使他們再次

1042
00:42:01,710 --> 00:42:02,630
一遍又一遍。

1043
00:42:02,630 --> 00:42:05,620
如果用戶螺釘和不配合，挺好的。

1044
00:42:05,620 --> 00:42:07,430
退出，只是不處理。

1045
00:42:07,430 --> 00:42:08,990
所以這是我在這裡做什麼。

1046
00:42:08,990 --> 00:42:12,520
如果n是小於1的，我只是罵的用戶，

1047
00:42:12,520 --> 00:42:14,330
“對不起，這是沒有意義的。”然後我去

1048
00:42:14,330 --> 00:42:16,650
隨意返回1。

1049
00:42:16,650 --> 00:42:18,550
所以，再一次，這僅僅是一個慣例習慣。

1050
00:42:18,550 --> 00:42:19,850
現在，只要相信。

1051
00:42:19,850 --> 00:42:22,700
但到現在為止，我們一直返回0，因為

1052
00:42:22,700 --> 00:42:25,204
我們說過的話返回0表示什麼呢？

1053
00:42:25,204 --> 00:42:26,000
觀眾：成功。

1054
00:42:26,000 --> 00:42:27,320
DAVID J.馬蘭：成功，僅此而已。

1055
00:42:27,320 --> 00:42:29,740
所以，現在我們終於開始思考

1056
00:42:29,740 --> 00:42:31,330
非成功 - 

1057
00:42:31,330 --> 00:42:33,760
換句話說，角的情況下，錯誤條件 - 

1058
00:42:33,760 --> 00:42:37,520
現在我有一個無限供給，或至少四個億

1059
00:42:37,520 --> 00:42:39,790
可能的事情，可以去在我的程序錯誤。

1060
00:42:39,790 --> 00:42:42,300
我就可以開始給他們分配單獨的數字。

1061
00:42:42,300 --> 00:42:44,340
現在，一般就足夠了剛剛返回

1062
00:42:44,340 --> 00:42:45,730
0以外的東西。

1063
00:42:45,730 --> 00:42:48,040
因此，我們現在簡單地返回1。

1064
00:42:48,040 --> 00:42:51,440
但是，返回1的原因是，一旦你返回

1065
00:42:51,440 --> 00:42:55,110
1，你猜對其餘的程序會發生什麼情況？

1066
00:42:55,110 --> 00:42:55,720
它停止。

1067
00:42:55,720 --> 00:42:56,560
就是這樣。

1068
00:42:56,560 --> 00:42:59,150
因此，事實上，我返回1是有效的

1069
00:42:59,150 --> 00:43:02,950
短路這個程序的執行，使

1070
00:43:02,950 --> 00:43:06,780
第27行以下將繼續執行。

1071
00:43:06,780 --> 00:43:09,210
一旦作為主要的回報，就是它了。

1072
00:43:09,210 --> 00:43:13,160
>> 所有權利，因此，如果用戶合作，我們到達第30行

1073
00:43:13,160 --> 00:43:15,680
因為他們中鍵入一個合法的號碼，這是我的

1074
00:43:15,680 --> 00:43:16,990
這首歌的實施。

1075
00:43:16,990 --> 00:43:19,050
所以，我第一次打印一個換行符，只為

1076
00:43:19,050 --> 00:43:19,880
美學。

1077
00:43:19,880 --> 00:43:21,500
我現在有一個for循環。

1078
00:43:21,500 --> 00:43:22,930
請注意，我做的事情位

1079
00:43:22,930 --> 00:43:23,880
不同的方向。

1080
00:43:23,880 --> 00:43:26,210
我沒有想得多做得少，我沒有做+ +。

1081
00:43:26,210 --> 00:43:30,660
相反，我可以說初始化變量i，它設置為等於

1082
00:43:30,660 --> 00:43:35,080
N，用戶輸入的數量，然後執行以下操作，所以

1083
00:43:35,080 --> 00:43:39,590
只要我是大於0的，然後我 - 

1084
00:43:39,590 --> 00:43:42,070
一旦你完成了這個循環的一次迭代。

1085
00:43:42,070 --> 00:43:44,310
因此，我們可以使用for循環倒計時為好。

1086
00:43:44,310 --> 00:43:47,520
現在，這是相當多星期的東西現在，用printf。

1087
00:43:47,520 --> 00:43:51,770
因此，打印“％d的啤酒瓶在牆上。”打印“％d

1088
00:43:51,770 --> 00:43:54,990
瓶啤酒。“”拿一個下來，傳遞它。“打印

1089
00:43:54,990 --> 00:43:58,880
“％d個啤酒瓶在牆上。”因此，它仍然是％d，但

1090
00:43:58,880 --> 00:44:02,770
注意的參數printf是不斷變化的。

1091
00:44:02,770 --> 00:44:05,840
在逗號後面，我有我的，因為我想說的是99。

1092
00:44:05,840 --> 00:44:08,590
這個逗號後，我有我的，因為我想說的是99。

1093
00:44:08,590 --> 00:44:14,030
這個逗號後，我有我 -  1，因為我想說98

1094
00:44:14,030 --> 00:44:16,260
這第一次迭代中，等等。

1095
00:44:16,260 --> 00:44:18,520
現在在這裡，我只是有一些雞毛蒜皮的話。

1096
00:44:18,520 --> 00:44:22,270
然後第42行，返回0，按照慣例，表示

1097
00:44:22,270 --> 00:44:23,650
一切都正常。

1098
00:44:23,650 --> 00:44:24,490
>> 那麼，如果我弄錯了嗎？

1099
00:44:24,490 --> 00:44:26,350
一個常見的錯誤是什麼？

1100
00:44:26,350 --> 00:44:29,200
那麼，如果我不小心說好了，我要算

1101
00:44:29,200 --> 00:44:31,640
下降到0，我想0的啤酒瓶在牆上嗎？

1102
00:44:31,640 --> 00:44:34,620
所以我說，我是大於或等於0。

1103
00:44:34,620 --> 00:44:38,920
這是怎麼回事，是我現在的症狀看，如果我重新編譯

1104
00:44:38,920 --> 00:44:41,173
beer1並運行它呢？

1105
00:44:41,173 --> 00:44:42,120
觀眾：陰性。

1106
00:44:42,120 --> 00:44:43,590
DAVID J.馬蘭：是的，這是要去負。

1107
00:44:43,590 --> 00:44:45,950
這是一個令人難以置信的一個off-by-one錯誤，

1108
00:44:45,950 --> 00:44:47,270
常見的錯誤。

1109
00:44:47,270 --> 00:44:48,960
讓我們回到終端窗口

1110
00:44:48,960 --> 00:44:50,620
在這裡，所以我們可以看到更多的時間。

1111
00:44:50,620 --> 00:44:53,280
輸入，99瓶啤酒。

1112
00:44:53,280 --> 00:44:56,580
關閉，但我們就非常輕微太遠。

1113
00:44:56,580 --> 00:45:00,500
我們唱的歌曲太遠了，這樣，我們現在打的

1114
00:45:00,500 --> 00:45:01,510
負數。

1115
00:45:01,510 --> 00:45:03,680
因此，它不是那麼回事。

1116
00:45:03,680 --> 00:45:06,450
>> 好了，這樣我們就可以很容易地解決這個問題，回去

1117
00:45:06,450 --> 00:45:07,650
它曾經是。

1118
00:45:07,650 --> 00:45:10,360
但有一些機會

1119
00:45:10,360 --> 00:45:11,190
改善？

1120
00:45:11,190 --> 00:45:17,200
好吧，讓我們我打開beer2.c，向下滾動這裡，並採取

1121
00:45:17,200 --> 00:45:19,310
看看這個版本。

1122
00:45:19,310 --> 00:45:21,370
什麼跳出來的第一件事情就是在你為不同的

1123
00:45:21,370 --> 00:45:23,715
在這個版本在這裡？

1124
00:45:23,715 --> 00:45:24,190
觀眾：[聽不清]。

1125
00:45:24,190 --> 00:45:26,510
DAVID J.馬蘭：是的，所以沒有更多的我，是因為它發生在

1126
00:45:26,510 --> 00:45:29,350
我說你知道什麼，我詢問用戶的n，然後我

1127
00:45:29,350 --> 00:45:33,580
設定i等於n，然後我改變了我，但我從來沒有

1128
00:45:33,580 --> 00:45:34,590
接觸N鍵。

1129
00:45:34,590 --> 00:45:37,390
那麼到底什麼是你點的分配另外32個

1130
00:45:37,390 --> 00:45:45,210
位叫我，這樣我可以有一個不同的變量？

1131
00:45:45,210 --> 00:45:47,960
因此，在這種情況下，我認識到不必要的

1132
00:45:47,960 --> 00:45:49,190
設計功能。

1133
00:45:49,190 --> 00:45:52,730
我現在去說，而n是大於0的，去

1134
00:45:52,730 --> 00:45:56,180
進行打印同一首歌，通過一個n的printf的

1135
00:45:56,180 --> 00:46:00,210
第二個參數，N  -  1，第二個參數在這裡。

1136
00:46:00,210 --> 00:46:02,930
然後在這個循環的每次迭代，繼續前進，只是

1137
00:46:02,930 --> 00:46:05,080
減n本身。

1138
00:46:05,080 --> 00:46:06,960
現在，在功能上，這個方案

1139
00:46:06,960 --> 00:46:08,010
會是相同的。

1140
00:46:08,010 --> 00:46:10,730
如果我輸入99，正開始在99。

1141
00:46:10,730 --> 00:46:12,890
我遞減，遞減，遞減，遞減。

1142
00:46:12,890 --> 00:46:15,875
我要一路下調至“一瓶啤酒

1143
00:46:15,875 --> 00:46:16,740
在牆上，一瓶啤酒。

1144
00:46:16,740 --> 00:46:18,020
拿一個，到處傳遞。

1145
00:46:18,020 --> 00:46:21,480
0的啤酒瓶在牆上。“結束，因為我做

1146
00:46:21,480 --> 00:46:23,200
得到正確的條件。

1147
00:46:23,200 --> 00:46:24,280
這是大於0。

1148
00:46:24,280 --> 00:46:26,220
我沒有犯這樣的錯誤。

1149
00:46:26,220 --> 00:46:28,470
>> 因此，這是更好的，版本1或版本2？

1150
00:46:31,380 --> 00:46:33,480
所以，我聽到了一堆怨言了兩個。

1151
00:46:33,480 --> 00:46:34,730
為什麼是兩個呢？

1152
00:46:37,210 --> 00:46:38,225
那是什麼？

1153
00:46:38,225 --> 00:46:39,215
觀眾：[聽不清]。

1154
00:46:39,215 --> 00:46:40,070
DAVID J.馬蘭：哦，好吧。

1155
00:46:40,070 --> 00:46:42,870
因此，它不會低於0，但要記住，在一個版本，

1156
00:46:42,870 --> 00:46:45,870
原來正確的版本不低於0或者去。

1157
00:46:45,870 --> 00:46:48,340
所以請記住，這是正確的版本。

1158
00:46:48,340 --> 00:46:51,630
因此，讓我們至少比較正確的版本。

1159
00:46:51,630 --> 00:46:53,300
什麼是贊成的版本的參數

1160
00:46:53,300 --> 00:46:55,146
兩個分別是，嗯，更好的嗎？

1161
00:46:55,146 --> 00:46:55,642
是嗎？

1162
00:46:55,642 --> 00:46:57,630
觀眾：它使用較少的空間。

1163
00:46:57,630 --> 00:46:59,530
DAVID J.馬蘭：好了，所以它使用更少的空間，對不對？

1164
00:46:59,530 --> 00:47:02,900
而使用一個版本的32位為n，然後又

1165
00:47:02,900 --> 00:47:07,680
32位我。

1166
00:47:07,680 --> 00:47:10,060
版本只使用32位為n，所以

1167
00:47:10,060 --> 00:47:11,700
似乎是一個加號。

1168
00:47:11,700 --> 00:47:12,950
其他的想法？

1169
00:47:18,070 --> 00:47:21,520
有誰不想爭辯贊成，1？

1170
00:47:21,520 --> 00:47:22,070
是嗎？

1171
00:47:22,070 --> 00:47:25,240
觀眾：你必須使用額外的代碼為n  - 。

1172
00:47:25,240 --> 00:47:26,090
>> DAVID J.馬蘭：好，確保萬無一失。

1173
00:47:26,090 --> 00:47:26,960
所以這是公平的。

1174
00:47:26,960 --> 00:47:29,040
所以這只不過是，至少對我來說 - 

1175
00:47:29,040 --> 00:47:31,940
我的意思是，這其實感覺稍微複雜一些，但事實上，

1176
00:47:31,940 --> 00:47:35,120
我不能在一個封裝了所有我的邏輯排序

1177
00:47:35,120 --> 00:47:38,030
線條美，for循環，for循環可以。

1178
00:47:38,030 --> 00:47:40,240
在這裡，我有釘在這n  - 

1179
00:47:40,240 --> 00:47:41,120
在循環結束時，由於

1180
00:47:41,120 --> 00:47:42,550
它的必然邏輯。

1181
00:47:42,550 --> 00:47:45,190
但它種磨我走錯了路，只是因為它

1182
00:47:45,190 --> 00:47:48,260
似乎從這裡的邏輯分開，即使

1183
00:47:48,260 --> 00:47:49,430
再次，它是必要的。

1184
00:47:49,430 --> 00:47:50,990
其他的想法？

1185
00:47:50,990 --> 00:47:51,490
是嗎？

1186
00:47:51,490 --> 00:47:52,740
觀眾：[聽不清]。

1187
00:47:57,990 --> 00:47:58,350
>> DAVID J.馬蘭：是的。

1188
00:47:58,350 --> 00:48:00,730
那麼，如果你去，在結尾的歌曲，希望

1189
00:48:00,730 --> 00:48:02,950
再次打印出這首歌的名字嗎？

1190
00:48:02,950 --> 00:48:05,660
打了99瓶啤酒，如“謝謝”，或者什麼

1191
00:48:05,660 --> 00:48:06,690
這樣的傻嗎？

1192
00:48:06,690 --> 00:48:09,750
但問題是，你想進入到原來的值。

1193
00:48:09,750 --> 00:48:13,180
事實上，你已經突變或改變n在每

1194
00:48:13,180 --> 00:48:16,330
迭代，因此破壞了其原有的價值

1195
00:48:16,330 --> 00:48:18,650
意味著你不能做到這一點底。

1196
00:48:18,650 --> 00:48:20,660
可以說，現在，我們可以清楚地不想要做的

1197
00:48:20,660 --> 00:48:21,450
，在這種方案。

1198
00:48:21,450 --> 00:48:22,350
那麼，誰在乎呢？

1199
00:48:22,350 --> 00:48:23,630
但是，這是一個非常有效的一點。

1200
00:48:23,630 --> 00:48:25,520
而且說實話，現在真的是沒有人

1201
00:48:25,520 --> 00:48:26,630
正確的答案。

1202
00:48:26,630 --> 00:48:28,740
他們兩個人都同樣正確。

1203
00:48:28,740 --> 00:48:30,210
我可以確信無論哪種方式。

1204
00:48:30,210 --> 00:48:33,310
我會說，在一般情況下，這是一個很好的原則，如果你

1205
00:48:33,310 --> 00:48:36,030
要求用戶為某個值，並且將存儲在變量

1206
00:48:36,030 --> 00:48:38,730
如N，只是有點原則上，它可能是好

1207
00:48:38,730 --> 00:48:40,160
保持周圍。

1208
00:48:40,160 --> 00:48:43,400
和任何你想要的數據變異，一遍又一遍，

1209
00:48:43,400 --> 00:48:46,030
給自己一個該變量的副本，只是讓你

1210
00:48:46,030 --> 00:48:47,830
有機會到原來的。

1211
00:48:47,830 --> 00:48:51,040
你花32位，但現實的情況是這樣的

1212
00:48:51,040 --> 00:48:53,490
電腦，喜歡，2 GB的RAM，這些天，

1213
00:48:53,490 --> 00:48:55,310
我們糾纏了32位？

1214
00:48:55,310 --> 00:48:56,320
真的不是什麼大不了的。

1215
00:48:56,320 --> 00:48:58,550
甚至在此設備，用半的演出或

1216
00:48:58,550 --> 00:49:01,700
千兆字節的RAM，32位和64位，

1217
00:49:01,700 --> 00:49:02,920
沒有什麼大不了的。

1218
00:49:02,920 --> 00:49:05,890
當然，今天，這將是不堪重負的大小的方法

1219
00:49:05,890 --> 00:49:08,400
程序本身，這將是幾百

1220
00:49:08,400 --> 00:49:10,890
千字節，如果不是幾百兆，這些天。

1221
00:49:10,890 --> 00:49:13,550
>> 因此，合理的關切，沒有一個正確的答案。

1222
00:49:13,550 --> 00:49:15,490
但至少這些都是想法，應該開始

1223
00:49:15,490 --> 00:49:16,790
經過你的頭腦嗎？

1224
00:49:16,790 --> 00:49:19,600
由於在pset中0，即使我們真的只有預期

1225
00:49:19,600 --> 00:49:22,340
正確性，或者至少是否認的各種錯誤，

1226
00:49:22,340 --> 00:49:25,440
你可能也遇到過，因為我們向前邁進，設計

1227
00:49:25,440 --> 00:49:27,910
將是另一個重要方面，編寫代碼

1228
00:49:27,910 --> 00:49:29,770
也是我們的評估代碼。

1229
00:49:29,770 --> 00:49:32,310
因此，至少給想這樣的事情。

1230
00:49:32,310 --> 00:49:35,590
只是因為一些作品，並不意味著它的好，

1231
00:49:35,590 --> 00:49:37,130
並不意味著它的精心設計。

1232
00:49:37,130 --> 00:49:38,820
而那是一個的教學研究員的東西，

1233
00:49:38,820 --> 00:49:41,990
問題集將幫助我們逗隨著時間的推移。

1234
00:49:41,990 --> 00:49:45,020
>> 好了，怎麼樣，讓我們說，這個版本嗎？

1235
00:49:45,020 --> 00:49:49,090
讓我做的東西一點點性感這裡的時刻。

1236
00:49:49,090 --> 00:49:50,740
首先，讓我擺脫這一點。

1237
00:49:50,740 --> 00:49:54,120
現在讓我們來解決這個語法問題。

1238
00:49:54,120 --> 00:49:58,780
所以，我想在這個版本中修復的語法，所以，

1239
00:49:58,780 --> 00:50:02,460
而不是僅僅說括號中的S，如“瓶”

1240
00:50:02,460 --> 00:50:03,360
或“瓶” - 

1241
00:50:03,360 --> 00:50:04,900
我不想砍那個角落 - 

1242
00:50:04,900 --> 00:50:08,350
我也想動態地打印出來的字“瓶”

1243
00:50:08,350 --> 00:50:12,820
“瓶”，從而利用這些％S佔位符。

1244
00:50:12,820 --> 00:50:16,550
所以，我需要有條件地檢查i的值是什麼。

1245
00:50:16,550 --> 00:50:19,590
如果是1，我想說的“瓶”，而如果它的任何東西

1246
00:50:19,590 --> 00:50:23,115
否則，我想說的“瓶”。因此，讓我們嘗試這樣做。

1247
00:50:23,115 --> 00:50:31,340
所以，如果我== 1，然後就讓我去，並宣布 - 

1248
00:50:31,340 --> 00:50:34,080
我需要一個字符串，所以讓我做字符串s1，因為它是

1249
00:50:34,080 --> 00:50:36,070
第一個字符串我只關心現在。

1250
00:50:36,070 --> 00:50:40,980
我會說：“瓶子”。然後，讓我們來看看，串

1251
00:50:40,980 --> 00:50:43,110
S2  - ，我將解釋我要去的地方在一個時刻 - 

1252
00:50:43,110 --> 00:50:47,650
“瓶”。所以記得，在這首歌中，我們需要能夠

1253
00:50:47,650 --> 00:50:50,580
打印的東西，兩個不同的詞可能。

1254
00:50:50,580 --> 00:50:53,590
因此，如果我們回頭看看在這裡要注意的是，當我們到達

1255
00:50:53,590 --> 00:50:56,440
這個例子在這裡，“兩瓶啤酒在牆壁上，

1256
00:50:56,440 --> 00:50:59,490
兩瓶啤酒，一跌，通過它，我想

1257
00:50:59,490 --> 00:51:02,380
這第四行說：“一瓶啤酒

1258
00:51:02,380 --> 00:51:04,900
牆“，所以我需要決定，我想說的”瓶“

1259
00:51:04,900 --> 00:51:07,780
“瓶”嗎？所以，我要武斷地說，沒事的，

1260
00:51:07,780 --> 00:51:10,530
我現在宣布一個名為S1的變量，字符串

1261
00:51:10,530 --> 00:51:13,830
一，要插在這裡和這裡，

1262
00:51:13,830 --> 00:51:16,070
因為這些話都是相同的，只是因為

1263
00:51:16,070 --> 00:51:17,290
歌曲的性質。

1264
00:51:17,290 --> 00:51:20,100
我現在就打電話給S2的話，我想

1265
00:51:20,100 --> 00:51:21,560
最終會出現在這裡。

1266
00:51:21,560 --> 00:51:25,530
現在，從字面上看，滿分100分的99倍，它的將是

1267
00:51:25,530 --> 00:51:28,820
在這種情況下，因為是複數，2

1268
00:51:28,820 --> 00:51:30,200
複數，4個是複數。

1269
00:51:30,200 --> 00:51:34,640
但在這個角落裡的情況下，我們得到為2，然後按1，或

1270
00:51:34,640 --> 00:51:37,250
即使是1和0，我需要這樣的邏輯。

1271
00:51:37,250 --> 00:51:41,020
所以，我必須花一些時間在我理解的正確的代碼。

1272
00:51:41,020 --> 00:51:47,530
所以，如果我這樣做，如果我== 1，則集合S1等於“瓶”

1273
00:51:47,530 --> 00:51:52,010
和S2等於“瓶”，因為這將是1

1274
00:51:52,010 --> 00:51:56,340
瓶，而這將是0瓶。

1275
00:51:56,340 --> 00:51:58,250
而這裡，這是什麼代表什麼呢？

1276
00:51:58,250 --> 00:51:59,780
只要是明確的。

1277
00:51:59,780 --> 00:52:00,620
這僅僅是一個評論。

1278
00:52:00,620 --> 00:52:03,730
因此，事實上，你可以有單行註釋意味著你

1279
00:52:03,730 --> 00:52:06,110
註釋你的代碼，但另一種常見的

1280
00:52:06,110 --> 00:52:09,050
範例，也就是如果你有一個超級短的短語，

1281
00:52:09,050 --> 00:52:11,410
你想要把自己和它只是更具可讀性，把

1282
00:52:11,410 --> 00:52:13,270
正確的代碼行的末尾，你可以

1283
00:52:13,270 --> 00:52:15,230
絕對做這樣的事情。

1284
00:52:15,230 --> 00:52:20,150
>> 所以，現在如果我這樣做呢？否則，如果i不等於1。

1285
00:52:20,150 --> 00:52:21,620
因此，砰等於 - 

1286
00:52:21,620 --> 00:52:23,150
被稱為“砰”的驚嘆號。

1287
00:52:23,150 --> 00:52:25,080
因此，砰= 1。

1288
00:52:25,080 --> 00:52:28,530
所以，如果我是不等於1，什麼我不是想這樣做嗎？

1289
00:52:28,530 --> 00:52:31,700
那麼，第一個字我要的是什麼嗎？

1290
00:52:34,620 --> 00:52:40,030
因此，字符串1用於多瓶“瓶”，

1291
00:52:40,030 --> 00:52:42,440
那麼這將是複數的“瓶”為好，現在。

1292
00:52:42,440 --> 00:52:43,800
我們來看看這實際上是讓我們

1293
00:52:43,800 --> 00:52:44,870
我們想要去的地方。

1294
00:52:44,870 --> 00:52:47,680
所以，現在如果我在這裡向下滾動，請注意，我堵在

1295
00:52:47,680 --> 00:52:50,170
不僅是我，但S1。

1296
00:52:50,170 --> 00:52:51,860
我堵在我和S1。

1297
00:52:51,860 --> 00:52:54,440
然後向下這裡，我減1，這是相同的

1298
00:52:54,440 --> 00:52:55,920
之前，但s2的。

1299
00:52:55,920 --> 00:52:58,730
換句話說，我想改變基礎的英文單詞

1300
00:52:58,730 --> 00:52:59,930
這個邏輯。

1301
00:52:59,930 --> 00:53:03,310
現在，已經有一些在這段代碼中的問題。

1302
00:53:03,310 --> 00:53:08,460
什麼是已經出了門壞了嗎？

1303
00:53:08,460 --> 00:53:10,796
是嗎？

1304
00:53:10,796 --> 00:53:13,210
觀眾：[聽不清]。

1305
00:53:13,210 --> 00:53:13,800
>> DAVID J.馬蘭：沒錯。

1306
00:53:13,800 --> 00:53:16,030
所以，我已經侵犯範圍的教訓。

1307
00:53:16,030 --> 00:53:19,610
所以，我宣布s1和s2，但我已經做了它裡面的

1308
00:53:19,610 --> 00:53:22,980
花括號，裡面是啊，這段代碼將工作

1309
00:53:22,980 --> 00:53:27,430
直到第42行，但只要我打43號線，你猜怎麼沒有

1310
00:53:27,430 --> 00:53:28,900
不再存在？

1311
00:53:28,900 --> 00:53:32,600
好了，你猜怎麼著不再在範圍 - 既不s1或s2。

1312
00:53:32,600 --> 00:53:33,780
因此，我們必須解決這個問題。

1313
00:53:33,780 --> 00:53:36,180
因此，讓我刪除的聲明。

1314
00:53:36,180 --> 00:53:39,320
我會離開的變量名，這裡刪除

1315
00:53:39,320 --> 00:53:40,120
並刪除在這裡。

1316
00:53:40,120 --> 00:53:43,557
在什麼線我真的應該聲明這些東西嗎？

1317
00:53:43,557 --> 00:53:44,960
觀眾：[聽不清]。

1318
00:53:44,960 --> 00:53:45,410
DAVID J.馬蘭：是啊，所以可能

1319
00:53:45,410 --> 00:53:46,850
在這裡，直到33上下的。

1320
00:53:46,850 --> 00:53:50,670
因此，字符串s1和字符串s2。

1321
00:53:50,670 --> 00:53:51,950
而事實證明，我可以做到這一點。

1322
00:53:51,950 --> 00:53:54,260
如果你聲明了兩個變量相同類型的，

1323
00:53:54,260 --> 00:53:57,420
實際上，你可以只用一個逗號和做到這一點。所有

1324
00:53:57,420 --> 00:53:58,970
正確的，所以我現在有兩個變量 - 

1325
00:53:58,970 --> 00:53:59,860
s1和s2。

1326
00:53:59,860 --> 00:54:02,000
我給他們分配這些值

1327
00:54:02,000 --> 00:54:04,210
條件在這裡，或者在這裡。

1328
00:54:04,210 --> 00:54:06,690
然後我使用了下面。

1329
00:54:06,690 --> 00:54:10,960
如何以及現在去上班？

1330
00:54:10,960 --> 00:54:12,740
>> 那麼，它仍然是一個小馬車，但至少讓我們看到

1331
00:54:12,740 --> 00:54:13,730
有多遠，我們已經得到了。

1332
00:54:13,730 --> 00:54:16,500
所以，讓我繼續，並beer3的。

1333
00:54:16,500 --> 00:54:17,695
是這beer3嗎？

1334
00:54:17,695 --> 00:54:19,410
是的，這是beer3。

1335
00:54:19,410 --> 00:54:21,510
現在讓我們我繼續運行beer3的。

1336
00:54:21,510 --> 00:54:23,820
399 99。

1337
00:54:23,820 --> 00:54:25,840
我們可以跳過其中的大多數。

1338
00:54:25,840 --> 00:54:29,100
在這裡，你看那個。

1339
00:54:29,100 --> 00:54:31,110
“在牆壁上一瓶啤酒，一瓶啤酒，

1340
00:54:31,110 --> 00:54:34,306
一跌，通過它周圍，啤酒瓶在牆上。“

1341
00:54:34,306 --> 00:54:37,570
但我提請你注意，只有一半的解決方案。

1342
00:54:37,570 --> 00:54:39,620
類搞砸了這裡。

1343
00:54:39,620 --> 00:54:43,030
因此，它似乎角落的情況下出現時，我等於什麼

1344
00:54:43,030 --> 00:54:44,030
兩個值嗎？

1345
00:54:44,030 --> 00:54:45,020
觀眾：1。

1346
00:54:45,020 --> 00:54:46,190
DAVID J.馬蘭：2和1。

1347
00:54:46,190 --> 00:54:48,180
這是不為1，而不是1。

1348
00:54:48,180 --> 00:54:51,890
這真的只是這些這首歌曲的最後兩段。

1349
00:54:51,890 --> 00:54:53,890
那麼，什麼我不是想要做什麼？

1350
00:54:53,890 --> 00:54:58,890
因此，我似乎已經陷入的情況下，如果我是== 1，

1351
00:54:58,890 --> 00:55:02,240
那麼第一個字是“瓶”，但第二個字

1352
00:55:02,240 --> 00:55:07,230
“瓶”。但在這裡，我想改變這是== 2。

1353
00:55:07,230 --> 00:55:08,570
而如果是這樣的話，我該怎麼想的

1354
00:55:08,570 --> 00:55:09,620
第一個字是什麼？

1355
00:55:09,620 --> 00:55:10,430
觀眾：“瓶”。

1356
00:55:10,430 --> 00:55:12,890
DAVID J.馬蘭：“瓶”，所以兩瓶。

1357
00:55:12,890 --> 00:55:14,690
然後，這個詞在這裡應該是 - 

1358
00:55:14,690 --> 00:55:15,340
觀眾：“瓶子”。

1359
00:55:15,340 --> 00:55:17,316
DAVID J.馬蘭：“瓶子”，單數。

1360
00:55:20,430 --> 00:55:25,160
>> 好吧，讓我們放大了，回到這裡，重新運行make，

1361
00:55:25,160 --> 00:55:28,590
重新運行，99式再次beer3。

1362
00:55:28,590 --> 00:55:30,710
好吧，“分割故障（核心轉儲）。”

1363
00:55:30,710 --> 00:55:32,780
我做了什麼錯了嗎？

1364
00:55:36,050 --> 00:55:38,722
觀眾：你不必值[聽不清]。

1365
00:55:38,722 --> 00:55:40,480
DAVID J.馬蘭：啊，良好的出發點。

1366
00:55:40,480 --> 00:55:43,310
好吧，有什麼錯嗎？

1367
00:55:43,310 --> 00:55:45,450
所以分割故障，我們其實要看到

1368
00:55:45,450 --> 00:55:49,020
這是一個幾十倍的未來，是故意的。

1369
00:55:49,020 --> 00:55:51,030
但現在，這其實是什麼意思？

1370
00:55:51,030 --> 00:55:53,620
幾乎總是意味著你有一個分割故障

1371
00:55:53,620 --> 00:55:56,760
不知何故試圖存取記憶體，RAM在您的計算機上，

1372
00:55:56,760 --> 00:56:00,600
不屬於你的，你有沒有問

1373
00:56:00,600 --> 00:56:02,050
操作系統。

1374
00:56:02,050 --> 00:56:04,440
因此，在這種情況下，請注意我做了什麼，這是

1375
00:56:04,440 --> 00:56:05,870
在我的邏輯有缺陷的。

1376
00:56:05,870 --> 00:56:09,500
我已經指定S1和S2的值如果我等於1。

1377
00:56:09,500 --> 00:56:11,590
我也做了，如果i等於2。

1378
00:56:11,590 --> 00:56:13,710
但我沒有這樣做，在無限多的其他

1379
00:56:13,710 --> 00:56:14,690
可能性 - 

1380
00:56:14,690 --> 00:56:17,940
特別是，3或4，點，99點，或點。

1381
00:56:17,940 --> 00:56:20,100
所以固定的，這可能僅僅是讓我們的

1382
00:56:20,100 --> 00:56:22,190
有其他條件。

1383
00:56:22,190 --> 00:56:26,780
讓我就在這裡說，S1等於 - 

1384
00:56:26,780 --> 00:56:28,180
在這裡，它應該是什麼？

1385
00:56:28,180 --> 00:56:28,750
觀眾：[聽不清]。

1386
00:56:28,750 --> 00:56:30,460
>> DAVID J.馬蘭：“瓶子”，因為在通常情況下，

1387
00:56:30,460 --> 00:56:32,020
它只是同樣的事情。

1388
00:56:32,020 --> 00:56:35,580
所以等於報價，引文結束，“瓶”。因此，對於複數

1389
00:56:35,580 --> 00:56:41,010
瓶，然後在這裡，多個瓶。

1390
00:56:41,010 --> 00:56:44,580
好了，現在讓我回到我的終端窗口，

1391
00:56:44,580 --> 00:56:47,200
重新編譯，再運行它。

1392
00:56:47,200 --> 00:56:48,440
99。

1393
00:56:48,440 --> 00:56:49,150
哇！

1394
00:56:49,150 --> 00:56:50,610
讓我們做一個快速的完整性檢查。

1395
00:56:50,610 --> 00:56:52,400
從技術上講，我們要閱讀所有這些，以確保

1396
00:56:52,400 --> 00:56:53,370
他們是正確的，但讓我們來看看

1397
00:56:53,370 --> 00:56:54,640
至少已知的罪魁禍首。

1398
00:56:54,640 --> 00:56:57,370
3瓶，2瓶，2瓶，1

1399
00:56:57,370 --> 00:57:00,380
瓶，1瓶，瓶。

1400
00:57:00,380 --> 00:57:03,080
我們似乎已經固定在至少它現在。

1401
00:57:03,080 --> 00:57:06,010
但這裡的捕獲量是什麼神爛攤子這是

1402
00:57:06,010 --> 00:57:07,470
只是為了解決一個愚蠢的

1403
00:57:07,470 --> 00:57:09,540
一個字符的語法細節。

1404
00:57:09,540 --> 00:57:11,150
因此，有一個原因，我將這個角落種

1405
00:57:11,150 --> 00:57:14,090
早些時候，因為它是完全惱人的

1406
00:57:14,090 --> 00:57:15,020
寫這麼多的代碼。

1407
00:57:15,020 --> 00:57:17,530
但事實證明，有更優雅的方式

1408
00:57:17,530 --> 00:57:20,110
表示完全一樣的東西。

1409
00:57:20,110 --> 00:57:22,040
我們可以做到這一點，如下所示。

1410
00:57:22,040 --> 00:57:23,890
>> 讓我離開這了一會兒在屏幕上，

1411
00:57:23,890 --> 00:57:27,320
介紹一些被稱為一個三元運算符。

1412
00:57:27,320 --> 00:57:29,600
這是一個班輪，只是為了讓我們

1413
00:57:29,600 --> 00:57:31,880
生活一點點的性感，如許。

1414
00:57:31,880 --> 00:57:33,130
我要做到這一點，如下。

1415
00:57:33,130 --> 00:57:35,810
給我一個字符串名為S1，讓我

1416
00:57:35,810 --> 00:57:37,200
分配如下。

1417
00:57:37,200 --> 00:57:39,900
（我== 1）？

1418
00:57:39,900 --> 00:57:47,820
“瓶”，否則“瓶”。字符串s2得到（我== 2）？

1419
00:57:47,820 --> 00:57:52,670
“瓶”，否則“瓶”。

1420
00:57:52,670 --> 00:57:57,050
所以，這裡的區別又是什麼呢？

1421
00:57:57,050 --> 00:57:59,370
這兩行代碼，我認為，

1422
00:57:59,370 --> 00:58:02,200
更換整個的混亂。

1423
00:58:02,200 --> 00:58:04,280
所以我把它稱為一個爛攤子，只是因為它讓我反感

1424
00:58:04,280 --> 00:58:05,940
走錯了路，它是那麼多行代碼。

1425
00:58:05,940 --> 00:58:06,650
沒有錯。

1426
00:58:06,650 --> 00:58:07,700
這不是糟糕的設計。

1427
00:58:07,700 --> 00:58:10,140
喜歡，這是完全正確的，完全沒有問題。

1428
00:58:10,140 --> 00:58:12,970
不過，編碼很乏味，如果你有表達自己的

1429
00:58:12,970 --> 00:58:15,530
該死的專門一而再，再而再次用一個簡單的

1430
00:58:15,530 --> 00:58:16,620
場景是這樣的。

1431
00:58:16,620 --> 00:58:19,470
所以C有一些快捷鍵，像這樣。

1432
00:58:19,470 --> 00:58:24,270
因此，這實質上是說聲明一個字符串名為S1，

1433
00:58:24,270 --> 00:58:32,610
指定此值，這個值，如果我是==  - 

1434
00:58:32,610 --> 00:58:35,290
對不起，我應該說得更清楚。

1435
00:58:35,290 --> 00:58:41,680
聲明一個變量s1，指定此值，如果這是真的。

1436
00:58:41,680 --> 00:58:44,280
否則，指定此值。

1437
00:58:44,280 --> 00:58:47,220
所以，換句話說，這是一個行的方式

1438
00:58:47,220 --> 00:58:51,490
如果別人說，但前進的道路上做一個賦值。

1439
00:58:51,490 --> 00:58:55,540
所以，如果我是1，然後繼續前進，稱此為“瓶”。和

1440
00:58:55,540 --> 00:58:59,830
那麼這個東西，稱之為“瓶”。同時，s2中，

1441
00:58:59,830 --> 00:59:04,060
第二個字，我們需要定義，如果i等於2，我們將

1442
00:59:04,060 --> 00:59:08,350
集S2“瓶”。否則，將其設置為“瓶”。有什麼

1443
00:59:08,350 --> 00:59:11,460
這意味著現在是我可以通過這一點，並刪除所有的

1444
00:59:11,460 --> 00:59:12,860
這些代碼行。

1445
00:59:12,860 --> 00:59:17,220
當我說，有點可笑的是，這是目前

1446
00:59:17,220 --> 00:59:20,060
性感的性感，這是在排序的文體意識。

1447
00:59:20,060 --> 00:59:22,660
事實上功能，這段代碼實際上是要

1448
00:59:22,660 --> 00:59:24,610
做完全一樣的東西。

1449
00:59:24,610 --> 00:59:26,890
儘管它可能看起來有點神秘

1450
00:59:26,890 --> 00:59:29,250
一目了然，因為我們從來沒見過這個結構之前，我

1451
00:59:29,250 --> 00:59:31,850
認為它是最終要這麼多

1452
00:59:31,850 --> 00:59:34,820
可讀性和更容易為我們人類排序

1453
00:59:34,820 --> 00:59:36,830
理解，因為現在你可以只讀取

1454
00:59:36,830 --> 00:59:38,830
所有代碼在一行上。

1455
00:59:38,830 --> 00:59:41,550
它仍然是類似的，如果這是在精神

1456
00:59:41,550 --> 00:59:44,920
條件，然後，這是內部的，如果這

1457
00:59:44,920 --> 00:59:46,480
是的else裡面有什麼。

1458
00:59:46,480 --> 00:59:49,450
但我們可以做到這一點只是更優雅的。

1459
00:59:49,450 --> 00:59:52,650
>> 如果我現在回去，我的終端，刪除所有

1460
00:59:52,650 --> 00:59:55,530
這些生產線，取而代之的只是這兩個，

1461
00:59:55,530 --> 01:00:00,150
重新編譯，重新運行的99瓶啤酒，請注意，我

1462
01:00:00,150 --> 01:00:03,350
語法是，其實仍然是正確的。

1463
01:00:03,350 --> 01:00:06,160
所以，再一次，事情開始。

1464
01:00:06,160 --> 01:00:08,840
2瓶啤酒，1瓶啤酒。

1465
01:00:08,840 --> 01:00:09,370
看起來是對的。

1466
01:00:09,370 --> 01:00:10,100
是啊。

1467
01:00:10,100 --> 01:00:13,900
因此，我們有一個更簡潔的解決方案。

1468
01:00:13,900 --> 01:00:16,020
因此，這也一樣，你獲得更舒適的C，而不是

1469
01:00:16,020 --> 01:00:18,630
一定pset或第二，但

1470
01:00:18,630 --> 01:00:21,170
認識到這些結構可以讓我們做的事情永遠

1471
01:00:21,170 --> 01:00:22,810
更優雅。

1472
01:00:22,810 --> 01:00:25,200
現在，讓我們在這裡做的另一件事情。

1473
01:00:25,200 --> 01:00:31,460
讓我走進取，不斷開拓return1.c。

1474
01:00:31,460 --> 01:00:34,340
現在，讓我們開始解決其他問題的方式，

1475
01:00:34,340 --> 01:00:37,140
使我們能夠編寫更複雜的代碼。

1476
01:00:37,140 --> 01:00:39,960
>> 所以這裡有一個簡單的小程序，其目的在生活中

1477
01:00:39,960 --> 01:00:41,870
是增加值。

1478
01:00:41,870 --> 01:00:43,100
其實，讓我們退後一步。

1479
01:00:43,100 --> 01:00:44,400
讓我這樣做手工。

1480
01:00:44,400 --> 01:00:52,200
讓我做包括和int的主要（無效）。

1481
01:00:52,200 --> 01:00:53,450
讓我叫increment.c。

1482
01:00:57,150 --> 01:00:58,570
我該怎麼辦？

1483
01:00:58,570 --> 01:01:02,240
我要繼續前進，這樣說 - 

1484
01:01:02,240 --> 01:01:04,280
我們所說的數字是相同的 - 

1485
01:01:04,280 --> 01:01:04,980
詮釋x。

1486
01:01:04,980 --> 01:01:13,670
所以int X取得的printf x是％d，新線，X。

1487
01:01:13,670 --> 01:01:16,780
所以，我打字快​​，但現在有點熟悉的東西。

1488
01:01:16,780 --> 01:01:18,830
然後，我會做x + +。

1489
01:01:18,830 --> 01:01:21,710
然後，我要再次打印相同的句子。

1490
01:01:21,710 --> 01:01:24,550
然後我將返回0只退出程序。

1491
01:01:24,550 --> 01:01:25,960
所有的權利，所以這是一個程序，

1492
01:01:25,960 --> 01:01:26,960
增加一個數。

1493
01:01:26,960 --> 01:01:29,830
它的第一要初始化的東西2，那麼它的

1494
01:01:29,830 --> 01:01:33,470
要增加它，並再次打印。

1495
01:01:33,470 --> 01:01:36,930
>> 因此，讓我們的運行增量，令人難以置信的簡單的程序。

1496
01:01:36,930 --> 01:01:40,940
但是，假設現在我要對多維數據集的值，這樣做

1497
01:01:40,940 --> 01:01:42,490
東西有點亂。

1498
01:01:42,490 --> 01:01:45,140
我真正想要做X取得的立方。

1499
01:01:45,140 --> 01:01:47,570
所以，我可以使用什麼所謂的pow函數，但我不

1500
01:01:47,570 --> 01:01:48,650
真的知道它在哪兒還。

1501
01:01:48,650 --> 01:01:50,580
所以，我要做到這一點，老式的方法。

1502
01:01:50,580 --> 01:01:54,550
x次，這等於x次，x倍所述。

1503
01:01:54,550 --> 01:01:56,880
所以我刺再次乘以它本身的價值，

1504
01:01:56,880 --> 01:02:00,440
一次又一次，使我們獲得的權力

1505
01:02:00,440 --> 01:02:02,050
在這種情況下，共3。

1506
01:02:02,050 --> 01:02:06,000
所以，現在我要打印的數字應該是，正如我們將看到的

1507
01:02:06,000 --> 01:02:08,450
 - 增量，因此它實際上並沒有真正增加

1508
01:02:08,450 --> 01:02:10,260
了，但我們會離開的名稱孤獨 - 

1509
01:02:10,260 --> 01:02:11,590
2和8。

1510
01:02:11,590 --> 01:02:17,670
現在，我們已經有了一個初步的機會細化

1511
01:02:17,670 --> 01:02:21,570
在這裡，由此這種魔方事情乘以一個數字

1512
01:02:21,570 --> 01:02:24,680
由自己本身的感覺，這樣做可能是

1513
01:02:24,680 --> 01:02:27,920
作為一個功能非常有用的，就像有人決定

1514
01:02:27,920 --> 01:02:30,430
年前 - 你知道嗎，有用的，如果我們坐下

1515
01:02:30,430 --> 01:02:33,120
並寫入輸出使世界的其餘部分可以用它

1516
01:02:33,120 --> 01:02:36,160
我們為什麼不坐下來寫一個函數調用的立方體

1517
01:02:36,160 --> 01:02:39,250
做這個魔方給我們，這樣我們就不必手動

1518
01:02:39,250 --> 01:02:41,500
實施立方值的概念呢？

1519
01:02:41,500 --> 01:02:44,040
>> 因此，一個簡單的例子，但是讓我們繼續使用，這是​​作為一個

1520
01:02:44,040 --> 01:02:46,280
寫我們自己的函數。

1521
01:02:46,280 --> 01:02:49,110
因此，到目前為止，我們已經用主，我們已經使用了其他

1522
01:02:49,110 --> 01:02:51,780
人的職能，但我們還沒有實現我們自己的。

1523
01:02:51,780 --> 01:02:52,650
所以，在這裡，我們走了。

1524
01:02:52,650 --> 01:02:56,330
我要繼續前進，寫一個函數，稱為立方體。

1525
01:02:56,330 --> 01:02:58,490
我想，有需要的輸入。

1526
01:02:58,490 --> 01:03:02,070
所以它的輸入將是一個整數。

1527
01:03:02,070 --> 01:03:03,570
又是什麼呢怎麼辦呢？

1528
01:03:03,570 --> 01:03:08,500
這將聲明int輸出輸入的輸入時間

1529
01:03:08,500 --> 01:03:09,880
次輸入。

1530
01:03:09,880 --> 01:03:12,190
那麼它會返回的輸出。

1531
01:03:12,190 --> 01:03:14,500
然後，我現在要具體。

1532
01:03:14,500 --> 01:03:16,820
這個函數會返回一個int。

1533
01:03:16,820 --> 01:03:19,130
所以在這裡告訴您如何編寫自己的函數。

1534
01:03:19,130 --> 01:03:20,850
您可以決定什麼是你的名字

1535
01:03:20,850 --> 01:03:21,720
功能將是。

1536
01:03:21,720 --> 01:03:23,964
而且一般的東西解釋是不錯的，所以我會

1537
01:03:23,964 --> 01:03:25,060
把它立方體。

1538
01:03:25,060 --> 01:03:27,180
然後，你必須指定它會返回什麼，有什麼

1539
01:03:27,180 --> 01:03:28,240
將是它的輸出。

1540
01:03:28,240 --> 01:03:29,595
同時，我們也沒有那麼多的選項。

1541
01:03:29,595 --> 01:03:32,260
int，char和浮點型，布爾型，字符串。

1542
01:03:32,260 --> 01:03:34,260
現在，我要堅持用一個int，因為我想它

1543
01:03:34,260 --> 01:03:35,880
返回一個整數。

1544
01:03:35,880 --> 01:03:38,770
然後，你必須指定其輸入，如果有的話，是什麼。

1545
01:03:38,770 --> 01:03:41,570
如果多維數據集需要一個參數，需要的東西之間

1546
01:03:41,570 --> 01:03:44,970
括號，你必須給該參數的名稱，使

1547
01:03:44,970 --> 01:03:47,860
你可以把它的東西，因為你正在實施或寫

1548
01:03:47,860 --> 01:03:50,550
這個功能，你必須給它一個類型，在這種

1549
01:03:50,550 --> 01:03:51,810
案件正在為int。

1550
01:03:51,810 --> 01:03:54,690
因此，在短，多維數據集是一個函數，它接受一個整數

1551
01:03:54,690 --> 01:03:57,560
作為輸入，並返回一個整數作為輸出。

1552
01:03:57,560 --> 01:03:59,240
>> 所以它是做什麼用的輸入？

1553
01:03:59,240 --> 01:04:03,710
那麼，在第14行中，我聲明了一個變量稱為輸出，和我

1554
01:04:03,710 --> 01:04:07,410
分配給它的值，輸入時間輸入時間輸入。

1555
01:04:07,410 --> 01:04:11,490
然後，我返回的輸出。

1556
01:04:11,490 --> 01:04:14,890
所以，我怎麼使用呢？

1557
01:04:14,890 --> 01:04:19,210
我該怎麼改變這些高亮顯示的字符上線

1558
01:04:19,210 --> 01:04:21,006
7〜，你覺得呢？

1559
01:04:21,006 --> 01:04:21,800
觀眾：[聽不清]。

1560
01:04:21,800 --> 01:04:25,570
DAVID J.馬蘭：是啊，所以多維數據集的x。

1561
01:04:25,570 --> 01:04:28,290
因此，x是一個變量，這意味著它擁有一定的價值。

1562
01:04:28,290 --> 01:04:30,190
幸運的是，它是整數類型。

1563
01:04:30,190 --> 01:04:34,280
因為x是一個整數，這意味著我可以將它傳遞到立方體。

1564
01:04:34,280 --> 01:04:39,500
即使我壓倒一切的x的值的值

1565
01:04:39,500 --> 01:04:42,780
多維數據集x，迄今為止的情況下，任何時候你

1566
01:04:42,780 --> 01:04:46,150
有等號的一行代碼，在正確的東西

1567
01:04:46,150 --> 01:04:49,090
被執行，然後被分配到

1568
01:04:49,090 --> 01:04:50,150
左側值。

1569
01:04:50,150 --> 01:04:52,950
因此，操作的順序是我們希望的。

1570
01:04:52,950 --> 01:04:56,620
所以做這項工作？

1571
01:04:56,620 --> 01:04:58,410
好了，讓我去這裡。

1572
01:04:58,410 --> 01:04:59,970
讓我打開了我的終端窗口。

1573
01:04:59,970 --> 01:05:03,610
讓我做增量，輸入。

1574
01:05:03,610 --> 01:05:07,140
“隱式聲明的函數”立方體“是無效的，

1575
01:05:07,140 --> 01:05:13,700
C99。“順便說一句，C99指的是C語言，因為它是

1576
01:05:13,700 --> 01:05:16,790
定義於1999年，是一個在版本更新

1577
01:05:16,790 --> 01:05:19,360
1989，這是一個較原來的更新。

1578
01:05:19,360 --> 01:05:21,740
因此，所有的手段。

1579
01:05:21,740 --> 01:05:24,250
>> 所以，這是什麼意思，“隱式聲明

1580
01:05:24,250 --> 01:05:26,790
功能“立方體”是無效的嗎？“就在這裡。

1581
01:05:26,790 --> 01:05:28,430
在第12行，這是正確的。

1582
01:05:28,430 --> 01:05:30,460
觀眾：[聽不清]。

1583
01:05:30,460 --> 01:05:30,730
DAVID J.馬蘭：那是什麼？

1584
01:05:30,730 --> 01:05:32,470
觀眾：這是不是之前。

1585
01:05:32,470 --> 01:05:33,540
DAVID J.馬蘭：這是不是之前。

1586
01:05:33,540 --> 01:05:34,740
所以這是事情。

1587
01:05:34,740 --> 01:05:38,190
C是一種愚蠢的，或C編譯器是一種愚蠢。

1588
01:05:38,190 --> 01:05:41,060
他們真的只能做你告訴他們做什麼。

1589
01:05:41,060 --> 01:05:44,770
而他們，尤其是只閱讀你的代碼頂部至底部，

1590
01:05:44,770 --> 01:05:45,620
左到右。

1591
01:05:45,620 --> 01:05:49,140
因此，如果編譯器，鐺，閱讀你的代碼，1號線，

1592
01:05:49,140 --> 01:05:50,120
如何做到這一點。

1593
01:05:50,120 --> 01:05:50,940
哦，來這裡主要的。

1594
01:05:50,940 --> 01:05:53,000
好吧，讓我繼續前進，聲明一個變量x。

1595
01:05:53,000 --> 01:05:54,160
讓我打印的東西。

1596
01:05:54,160 --> 01:05:55,890
7號線，到底是什麼魔方？

1597
01:05:55,890 --> 01:05:58,230
這不是stdio.h中聲明的。

1598
01:05:58,230 --> 01:06:00,950
它不來，我不知道該怎麼辦。

1599
01:06:00,950 --> 01:06:03,960
因此，鐺剛剛撈出，並退出該錯誤消息。

1600
01:06:03,960 --> 01:06:05,850
因此，我們可以在一對夫婦的方式來解決這個問題。

1601
01:06:05,850 --> 01:06:10,530
多維數據集是什麼，只是移動的，我們可以教鐺

1602
01:06:10,530 --> 01:06:11,820
聲明。

1603
01:06:11,820 --> 01:06:14,640
所以，我的剪切和粘貼上面主要。

1604
01:06:14,640 --> 01:06:17,770
現在認識到，只是因為主不再是第一，這是

1605
01:06:17,770 --> 01:06:19,150
默認情況下，仍然執行。

1606
01:06:19,150 --> 01:06:20,060
主要是主要的。

1607
01:06:20,060 --> 01:06:21,022
這是默認的函數名。

1608
01:06:21,022 --> 01:06:22,930
它並不重要，它是在一個文件中。

1609
01:06:22,930 --> 01:06:26,910
但至少現在鐺已經看到立方體之前，我使用它。

1610
01:06:26,910 --> 01:06:28,500
因此，讓我們來看看如果鐺現在是非常美好的。

1611
01:06:28,500 --> 01:06:31,410
增加，並編譯這個時間。

1612
01:06:31,410 --> 01:06:33,060
>> 讓我跑的增量。

1613
01:06:33,060 --> 01:06:34,810
而事實上，它似乎是工作。

1614
01:06:34,810 --> 01:06:36,810
現在，你可以拿出情況下，最終在那裡

1615
01:06:36,810 --> 01:06:38,650
它把每一個功能是不可行的

1616
01:06:38,650 --> 01:06:39,740
以上所有其它功能。

1617
01:06:39,740 --> 01:06:42,140
你會陷在這個無限循環在現實中，

1618
01:06:42,140 --> 01:06:43,480
這傢伙想在這裡，但這個

1619
01:06:43,480 --> 01:06:44,390
傢伙在那裡。

1620
01:06:44,390 --> 01:06:45,830
所以，這並不總是工作。

1621
01:06:45,830 --> 01:06:49,020
幸運的是，C有一個更優雅的解決方案。

1622
01:06:49,020 --> 01:06:50,790
我打算把它這回是，只是因為我

1623
01:06:50,790 --> 01:06:53,390
喜歡的話，作為一個原則問題，即主永遠是

1624
01:06:53,390 --> 01:06:55,550
在頂部，因為它只是很高興看到這是什麼程序

1625
01:06:55,550 --> 01:06:56,920
的默認操作。

1626
01:06:56,920 --> 01:06:58,950
我要在這裡做了什麼，宣布什麼叫做

1627
01:06:58,950 --> 01:07:00,250
一個原型。

1628
01:07:00,250 --> 01:07:05,730
我要重新申報，我的立方體函數的字面意思

1629
01:07:05,730 --> 01:07:07,180
複製和粘貼。

1630
01:07:07,180 --> 01:07:08,290
其實，這是不是真的。

1631
01:07:08,290 --> 01:07:13,060
因此，從字面上複製和粘貼15行

1632
01:07:13,060 --> 01:07:15,160
第6行以上。

1633
01:07:15,160 --> 01:07:17,010
不要緊，哪行結束了。

1634
01:07:17,010 --> 01:07:18,380
它正好是在第4行。

1635
01:07:18,380 --> 01:07:19,950
但它確實有前主。

1636
01:07:19,950 --> 01:07:21,150
但是，注意到其中的差別。

1637
01:07:21,150 --> 01:07:24,100
4號線以分號結束，這意味著哎，

1638
01:07:24,100 --> 01:07:27,510
鐺，把我的話，存在一個函數

1639
01:07:27,510 --> 01:07:31,350
稱為多維數據集採用了一個int並返回一個int。

1640
01:07:31,350 --> 01:07:33,020
但我不會告訴你它是什麼，但。

1641
01:07:33,020 --> 01:07:35,180
只知道，我承諾最終告訴你。

1642
01:07:35,180 --> 01:07:38,490
事實上，現在沒事，這是在下面。

1643
01:07:38,490 --> 01:07:41,275
>> 因此，這通常是更好的，因為這時的頂部

1644
01:07:41,275 --> 01:07:44,240
你的文件，你就可以背出，速射，一行

1645
01:07:44,240 --> 01:07:46,470
，你的職責是什麼名字，他們的

1646
01:07:46,470 --> 01:07:49,120
輸入，其輸出是什麼。

1647
01:07:49,120 --> 01:07:52,210
更清晰，輸入通常是指參數或

1648
01:07:52,210 --> 01:07:54,110
參數的代名詞。

1649
01:07:54,110 --> 01:07:56,890
輸出裝置的返回值，這是什麼

1650
01:07:56,890 --> 01:07:58,700
手回到我的身邊。

1651
01:07:58,700 --> 01:08:03,420
因此，在這種情況下，在這裡，多維數據集已宣布在頂部，但

1652
01:08:03,420 --> 01:08:06,940
定義，否則被稱為實施，在底部。

1653
01:08:06,940 --> 01:08:09,620
所以，現在讓我們回到這裡，重新運行。

1654
01:08:09,620 --> 01:08:13,430
所以，現在讓我繼續前進，重新運行make，重新運行增量。

1655
01:08:13,430 --> 01:08:16,500
它現在似乎工作得很好。

1656
01:08:16,500 --> 01:08:19,450
所以，現在我們可以繼續分解出類似的

1657
01:08:19,450 --> 01:08:23,720
這第四個版本的啤酒例子。

1658
01:08:23,720 --> 01:08:25,590
因此，讓我向下滾動。

1659
01:08:25,590 --> 01:08:28,149
注意到，我種了心剛才的教訓。

1660
01:08:28,149 --> 01:08:31,140
事實上，我是唱同一節再次

1661
01:08:31,140 --> 01:08:34,130
一遍又一遍，同樣的合唱隊中的歌曲，感覺

1662
01:08:34,130 --> 01:08:36,439
喜歡我為什麼不成為一個功能的因素，出嗎？

1663
01:08:36,439 --> 01:08:38,470
事實上，這應該是的動機之一。

1664
01:08:38,470 --> 01:08:40,960
另外一個事實，在世界上其他的人可能要

1665
01:08:40,960 --> 01:08:42,390
使用多維數據集的功能 - 

1666
01:08:42,390 --> 01:08:44,560
這是一個很好的理由因素的東西，寫你的

1667
01:08:44,560 --> 01:08:45,720
自己的自定義功能 - 

1668
01:08:45,720 --> 01:08:48,720
如果有一個塊中的代碼，只是讓你的程序

1669
01:08:48,720 --> 01:08:51,370
概念意義上說，你有種想給它一個

1670
01:08:51,370 --> 01:08:53,740
名稱 - 像在這種情況下，合唱 - 

1671
01:08:53,740 --> 01:08:57,380
那麼你同樣可以寫，作為一個單獨的函數。

1672
01:08:57,380 --> 01:08:59,560
你不寫的一切，如果它只是在主

1673
01:08:59,560 --> 01:09:02,609
感覺清潔劑分離出來，並給它一個名稱。

1674
01:09:02,609 --> 01:09:05,529
>> 因此，在這種情況下，在這裡，請注意，我有一個評論頂上

1675
01:09:05,529 --> 01:09:06,859
這個功能，只是唱

1676
01:09:06,859 --> 01:09:08,630
指定數目的瓶子。

1677
01:09:08,630 --> 01:09:10,609
請注意，在這裡，我不需要調用這些

1678
01:09:10,609 --> 01:09:12,520
輸入和輸出的事情。

1679
01:09:12,520 --> 01:09:16,090
其實，這個時候，我只是叫我輸入b瓶。

1680
01:09:16,090 --> 01:09:19,960
注意的，無效的建議是什麼？

1681
01:09:19,960 --> 01:09:21,309
該合唱團 - 

1682
01:09:21,309 --> 01:09:22,660
聽眾：不會返回。

1683
01:09:22,660 --> 01:09:23,870
DAVID J. MALAN：不返回一個值。

1684
01:09:23,870 --> 01:09:26,800
事實上，函數沒有返回值。

1685
01:09:26,800 --> 01:09:28,060
他們可以做一些事情。

1686
01:09:28,060 --> 01:09:30,270
他們可以有什麼是所謂的副作用，而在這種

1687
01:09:30,270 --> 01:09:33,109
情況下，僅僅是打印在屏幕上一大堆。

1688
01:09:33,109 --> 01:09:36,580
所以請注意，此代碼在這裡，我真的只是偷

1689
01:09:36,580 --> 01:09:37,680
前面的例子。

1690
01:09:37,680 --> 01:09:39,930
唯一的區別是，而不是利用i作為我

1691
01:09:39,930 --> 01:09:42,890
可變的，我現在使用b作為我的變量。

1692
01:09:42,890 --> 01:09:45,880
所以，我有b在這裡，我有b在這裡，我有b

1693
01:09:45,880 --> 01:09:47,109
減去1這裡。

1694
01:09:47,109 --> 01:09:49,279
但代碼是完全一樣的。

1695
01:09:49,279 --> 01:09:52,529
但就現在向您展示如何我們可以利用這一點，讓我去

1696
01:09:52,529 --> 01:09:56,780
進取，實際上這是一個循環。

1697
01:09:56,780 --> 01:10:03,850
（INT I = i> N時，我 - ）。

1698
01:10:03,850 --> 01:10:06,230
>> 所以，我偷了，從我們前面的例子。

1699
01:10:06,230 --> 01:10:08,970
在此之前，它是在第37行，我就已經開始

1700
01:10:08,970 --> 01:10:10,640
唱這討厭的歌曲。

1701
01:10:10,640 --> 01:10:15,810
但是，我只是去，我現在請合唱團。

1702
01:10:15,810 --> 01:10:16,870
完成。

1703
01:10:16,870 --> 01:10:20,260
所以，現在這個循環在每次迭代中，我把這種

1704
01:10:20,260 --> 01:10:22,220
功能，合唱，，我碰巧寫的。

1705
01:10:22,220 --> 01:10:24,110
它不是別人幾年前寫的。

1706
01:10:24,110 --> 01:10:27,930
但是，合唱團，同時，使用printf來打印

1707
01:10:27,930 --> 01:10:29,840
出這四行。

1708
01:10:29,840 --> 01:10:32,720
但事實上我打電話合唱一遍又一遍的

1709
01:10:32,720 --> 01:10:35,900
循環意味著，我要得到的，在最後一刻，

1710
01:10:35,900 --> 01:10:39,310
相同的歌曲，因此，我有。

1711
01:10:39,310 --> 01:10:42,130
因此，在短期，如果我現在回頭看我的代碼，即使

1712
01:10:42,130 --> 01:10:44,240
在功能上，這是等價的，發現它的

1713
01:10:44,240 --> 01:10:46,020
開始變得更可讀。

1714
01:10:46,020 --> 01:10:48,410
我並不確切地知道如何調用getInt

1715
01:10:48,410 --> 01:10:49,250
實施。

1716
01:10:49,250 --> 01:10:52,050
坦率地說，我不知道如何合唱實施。

1717
01:10:52,050 --> 01:10:52,970
不過，這並不重要，我。

1718
01:10:52,970 --> 01:10:55,620
我不在乎，因為我現在可以排序的，作為一個人，讀

1719
01:10:55,620 --> 01:10:57,050
這從頂部向底部。

1720
01:10:57,050 --> 01:10:59,950
因為這些功能根據他們命名

1721
01:10:59,950 --> 01:11:02,910
這樣做，我的代碼是越來越可讀。

1722
01:11:02,910 --> 01:11:05,190
我們的計劃複雜得多 - 

1723
01:11:05,190 --> 01:11:07,220
學期結束，你會寫幾百行

1724
01:11:07,220 --> 01:11:10,970
代碼語言，如PHP和JavaScript之類的 - 

1725
01:11:10,970 --> 01:11:13,550
你會發現，它是如此容易得多跟踪

1726
01:11:13,550 --> 01:11:14,080
你做了什麼。

1727
01:11:14,080 --> 01:11:15,810
當你開始與朋友或

1728
01:11:15,810 --> 01:11:19,010
合作夥伴或同事，你就可以寫更多

1729
01:11:19,010 --> 01:11:22,910
大規模計劃開始行使這些基本

1730
01:11:22,910 --> 01:11:23,990
積木。

1731
01:11:23,990 --> 01:11:25,550
>> 因此，隨著中說，為什麼我們不收工了嗎？

1732
01:11:25,550 --> 01:11:27,190
我們將看到你（星期三）。

1733
01:11:27,190 --> 01:11:33,611
[掌聲]