1
00:00:00,000 --> 00:00:02,880
>> [音樂播放]

2
00:00:02,880 --> 00:00:10,580

3
00:00:10,580 --> 00:00:13,500
>> 揚聲器1：這是CS50和
這是二週的開始。

4
00:00:13,500 --> 00:00:18,400
所以，讓我們深入到一些東西
這是越野車，可以這麼說。

5
00:00:18,400 --> 00:00:24,015
所以，在這裡是CS50的IDE，我已經
停在推動這一screen--該死

6
00:00:24,015 --> 00:00:25,070
它。

7
00:00:25,070 --> 00:00:25,760
劇透。

8
00:00:25,760 --> 00:00:26,260
好的。

9
00:00:26,260 --> 00:00:29,060
我拉起這個屏幕在這裡，
其中有一個非常簡單的程序。

10
00:00:29,060 --> 00:00:32,659
如果我們向下滾動，最
這只是評論，

11
00:00:32,659 --> 00:00:36,730
但在這裡，在第13行至
17我們有一個計劃。

12
00:00:36,730 --> 00:00:40,580
>> 這是語法上有效的，這意味著如果
我編譯它，它會編譯並運行，

13
00:00:40,580 --> 00:00:41,920
但它的越野車。

14
00:00:41,920 --> 00:00:47,330
在評論該方案要求
往上頂，它應該打印10星，

15
00:00:47,330 --> 00:00:48,870
但事實並非如此。

16
00:00:48,870 --> 00:00:53,290
並可以根據你的經驗，
或即將用C的經驗，

17
00:00:53,290 --> 00:00:56,820
你能在邏輯上辨別
這是為什麼，其實，馬車？

18
00:00:56,820 --> 00:00:57,804
是嗎？

19
00:00:57,804 --> 00:00:59,220
聽眾：它從零至10。

20
00:00:59,220 --> 00:01:01,884
這是11次迭代。

21
00:01:01,884 --> 00:01:02,550
揚聲器1：是啊。

22
00:01:02,550 --> 00:01:06,030
因此，它是從零持續
通過向上和等於10，

23
00:01:06,030 --> 00:01:08,140
這當然是11迭代。

24
00:01:08,140 --> 00:01:10,020
因此，這將
打印，的確，11星。

25
00:01:10,020 --> 00:01:13,040
因此，計算機科學大會
在大多數編程語言

26
00:01:13,040 --> 00:01:15,270
確實是，只是
從零開始計數，

27
00:01:15,270 --> 00:01:18,800
但算上，但不通過
值，你真正關心的。

28
00:01:18,800 --> 00:01:21,216
>> 現在，這是一件事，
需要一點時間來適應

29
00:01:21,216 --> 00:01:25,350
甚至划痕，設計，因為它是
對於非程序員或非計算機

30
00:01:25,350 --> 00:01:28,070
科學家和兒童
基本上，被設計成具有

31
00:01:28,070 --> 00:01:29,570
你開始在一個普遍計數。

32
00:01:29,570 --> 00:01:30,277
這很好。

33
00:01:30,277 --> 00:01:33,110
您完全可以開始計數
在一個，如果這是更舒適。

34
00:01:33,110 --> 00:01:37,210
而數到，並通過10位，但
你就會明白尤其是本週

35
00:01:37,210 --> 00:01:39,950
超越，僅僅如此
在規劃很多東西

36
00:01:39,950 --> 00:01:42,465
假設0是第一個
數字與你算，

37
00:01:42,465 --> 00:01:45,590
那你會覺得它更容易
剛進入這個習慣出發

38
00:01:45,590 --> 00:01:49,490
從零計數達到值
你的關心，現在

39
00:01:49,490 --> 00:01:49,990
得到去。

40
00:01:49,990 --> 00:01:50,990
>> 因此，已固定的。

41
00:01:50,990 --> 00:01:53,670
我們改變了小於或
等於只以內。

42
00:01:53,670 --> 00:01:56,050
讓我們來看看
這裡的第二示例。

43
00:01:56,050 --> 00:01:59,585
>> 因此，這個程序也要求其
評論往上頂，它應該打印

44
00:01:59,585 --> 00:02:02,260
十星，但事實並非如此。

45
00:02:02,260 --> 00:02:05,540
這裡有什麼錯誤？

46
00:02:05,540 --> 00:02:07,930
>> 因此，what--對不起，我們要清楚。

47
00:02:07,930 --> 00:02:08,610
10星。

48
00:02:08,610 --> 00:02:11,644
每行一個，但事實並非如此。

49
00:02:11,644 --> 00:02:14,810
所以，實際上，讓我繼續前進，編譯
這一個，因為它是一個少

50
00:02:14,810 --> 00:02:16,900
基於這樣的描述清楚。

51
00:02:16,900 --> 00:02:18,720
讓我進入我們的源代碼目錄。

52
00:02:18,720 --> 00:02:25,110
讓車一個點斜線，越野車之一。

53
00:02:25,110 --> 00:02:28,680
好了，我看11星，這
還是有問題，

54
00:02:28,680 --> 00:02:30,090
但他們也都在同一行。

55
00:02:30,090 --> 00:02:31,500
什麼是這裡的問題？

56
00:02:31,500 --> 00:02:32,339
是啊。

57
00:02:32,339 --> 00:02:33,255
聽眾：[聽不清]。

58
00:02:33,255 --> 00:02:36,194

59
00:02:36,194 --> 00:02:36,860
揚聲器1：是啊。

60
00:02:36,860 --> 00:02:40,210
所以這是一個微妙的，你可以
記得我作簡要的提到。

61
00:02:40,210 --> 00:02:42,793
儘管一切看起來
漂亮，而且它很好地縮進，

62
00:02:42,793 --> 00:02:45,850
一種，它看起來刮樣
在該行的16和17是，

63
00:02:45,850 --> 00:02:47,600
事實上，縮進下，對於循環。

64
00:02:47,600 --> 00:02:48,400
這是無關緊要的。

65
00:02:48,400 --> 00:02:50,460
電腦不
知道或看到空白。

66
00:02:50,460 --> 00:02:52,910
白色的空間只為
我們人類，曲風。

67
00:02:52,910 --> 00:02:57,010
電腦不知道，當你有
大括號，這，的確，

68
00:02:57,010 --> 00:02:58,280
解決這個問題。

69
00:02:58,280 --> 00:03:02,350
>> 所以，如果我們真正走進去，
明確提出在這些大括號

70
00:03:02,350 --> 00:03:05,220
這將通過解決這個問題
昭示編譯器

71
00:03:05,220 --> 00:03:07,930
我居然要執行
兩行代碼再次，

72
00:03:07,930 --> 00:03:09,220
又一次，又一次。

73
00:03:09,220 --> 00:03:11,680
但是，什麼是根本的解釋？

74
00:03:11,680 --> 00:03:12,180
對嗎？

75
00:03:12,180 --> 00:03:15,260
我們不嚴格需要
大括號的時候，

76
00:03:15,260 --> 00:03:18,210
即使它可能是最好的
實踐進入這個習慣呢

77
00:03:18,210 --> 00:03:20,878
即使它增加了兩個
字符代碼。為什麼呢？

78
00:03:20,878 --> 00:03:22,380
>> 聽眾：[聽不清]？

79
00:03:22,380 --> 00:03:24,630
揚聲器1：是啊，這樣的
另一種解決方案完全。

80
00:03:24,630 --> 00:03:25,130
對嗎？

81
00:03:25,130 --> 00:03:28,250
特別是如果乍一看你不
真正體會到這是怎麼回事。

82
00:03:28,250 --> 00:03:31,070
好了，我們肯定能
只是做兩件事

83
00:03:31,070 --> 00:03:32,710
和剛剛完全避免這個問題。

84
00:03:32,710 --> 00:03:36,080
這很好，但現在，
對於今天的目的是什麼

85
00:03:36,080 --> 00:03:38,200
對於錯誤的解釋？

86
00:03:38,200 --> 00:03:39,810
為什麼在同一行所有的星星？

87
00:03:39,810 --> 00:03:40,806
是嗎？

88
00:03:40,806 --> 00:03:43,296
>> 聽眾：看來，如果
你有一行代碼，

89
00:03:43,296 --> 00:03:46,649
你可以不用那些。

90
00:03:46,649 --> 00:03:47,440
揚聲器1：沒錯。

91
00:03:47,440 --> 00:03:48,750
這僅僅是一個人的約定。

92
00:03:48,750 --> 00:03:50,750
人們認識到，這是一個
有點惱人或繁瑣

93
00:03:50,750 --> 00:03:53,470
有把花括號所有
如果你想要做的時候

94
00:03:53,470 --> 00:03:55,090
是執行的一行代碼。

95
00:03:55,090 --> 00:03:57,660
所以，人類決定一些
時間以前，這很好。

96
00:03:57,660 --> 00:04:01,180
如果你想要把所有的循環
上只是這樣一行，

97
00:04:01,180 --> 00:04:04,030
這很好跟單
分號結尾。

98
00:04:04,030 --> 00:04:07,210
但是，你只能做一個這樣的
行沒有花括號。

99
00:04:07,210 --> 00:04:09,900
>> 所以，當CS50風格指南
如將指向你，

100
00:04:09,900 --> 00:04:11,980
你會看到，一般
這是好習慣

101
00:04:11,980 --> 00:04:14,920
進入這個直到你
相當舒適的飄遊

102
00:04:14,920 --> 00:04:17,404
從這類公約
，做自己的事。

103
00:04:17,404 --> 00:04:18,820
只要你是自洽。

104
00:04:18,820 --> 00:04:21,540
我們將詳細討論
風格有點今天晚些時候。

105
00:04:21,540 --> 00:04:23,200
>> 所以，讓我打開另一個程序。

106
00:04:23,200 --> 00:04:24,930
當然，我們應該
修復10為好。

107
00:04:24,930 --> 00:04:32,470
讓我繼續前進，寫一個真正的
快速程序，我會打電話，

108
00:04:32,470 --> 00:04:38,140
比方說，循環點C.因此，循環點C.
而在環路C點我就要有，

109
00:04:38,140 --> 00:04:41,970
包括標準I / O
點^ h詮釋主要無效。

110
00:04:41,970 --> 00:04:44,020
現在，就讓我們做的，的確是一個循環。

111
00:04:44,020 --> 00:04:46,020
因此，4 INT我得到零。

112
00:04:46,020 --> 00:04:48,660
我不到，也就是說，50。

113
00:04:48,660 --> 00:04:49,950
我加分，加分。

114
00:04:49,950 --> 00:04:53,350
然後在下面就讓我們來
繼續前進，不要打印F.

115
00:04:53,350 --> 00:04:56,400
然後我要打印我
和一個新行，分號。

116
00:04:56,400 --> 00:05:00,015
>> 這應該打印所有
從零號至50？

117
00:05:00,015 --> 00:05:02,900

118
00:05:02,900 --> 00:05:03,680
幾頭點點頭。

119
00:05:03,680 --> 00:05:04,270
幾號。

120
00:05:04,270 --> 00:05:05,339
什麼是已經是錯誤嗎？

121
00:05:05,339 --> 00:05:06,630
什麼是容易犯的錯誤我犯了？

122
00:05:06,630 --> 00:05:07,170
是啊。

123
00:05:07,170 --> 00:05:08,544
>> 聽眾：[聽不清]。

124
00:05:08,544 --> 00:05:09,210
揚聲器1：是啊。

125
00:05:09,210 --> 00:05:11,520
因此，即使它看起來
像這就是我打算，

126
00:05:11,520 --> 00:05:13,920
記得，我也是
只是一個ASCII字符。

127
00:05:13,920 --> 00:05:14,955
>> 所以，如果我說，打印“一”

128
00:05:14,955 --> 00:05:16,670
它從字面上去
打印一，所以，如果我

129
00:05:16,670 --> 00:05:20,030
想插件的佔位符
價值其實我需要這樣做

130
00:05:20,030 --> 00:05:22,630
然後插件的
我值動態。

131
00:05:22,630 --> 00:05:25,200
否則，我只是要
獲得50我的屏幕上。

132
00:05:25,200 --> 00:05:28,140
>> 所以，讓我繼續前進，
使這個循環，運行它，

133
00:05:28,140 --> 00:05:30,650
而事實上，我們都
一路攀升至49。

134
00:05:30,650 --> 00:05:34,140
如果我的時間向後滾動我見
數字零的開頭。

135
00:05:34,140 --> 00:05:36,050
>> 好吧，如果我有點搞砸？

136
00:05:36,050 --> 00:05:37,800
如果我這樣做呢？

137
00:05:37,800 --> 00:05:40,120
只是因為我沒有想到。

138
00:05:40,120 --> 00:05:40,970
這是什麼程序。

139
00:05:40,970 --> 00:05:43,970
一旦重新編譯和運行，
要做到邏輯？

140
00:05:43,970 --> 00:05:44,870
>> 聽眾：沒有。

141
00:05:44,870 --> 00:05:45,661
>> 揚聲器1：沒有。

142
00:05:45,661 --> 00:05:47,156
這是為什麼呢？

143
00:05:47,156 --> 00:05:49,124
>> 聽眾：我是專為為零。

144
00:05:49,124 --> 00:05:51,899
因此，條件為假。

145
00:05:51,899 --> 00:05:52,940
揚聲器1：是的，沒錯。

146
00:05:52,940 --> 00:05:55,110
所有的代碼是正確的，語法上。

147
00:05:55,110 --> 00:05:57,310
這將編譯，這
代碼將運行，但它不是

148
00:05:57,310 --> 00:06:00,110
打算做什麼有用的東西
因為我初始化我到零。

149
00:06:00,110 --> 00:06:02,240
然後，我們檢查一下，我是大於50？

150
00:06:02,240 --> 00:06:03,810
顯然，不，不是這樣的。

151
00:06:03,810 --> 00:06:05,760
因此，循環永遠不會執行的。

152
00:06:05,760 --> 00:06:09,580
>> 如果我們做一些事情
多一點魯莽？

153
00:06:09,580 --> 00:06:12,890
那麼，如果我們不喜歡INT我得到零。

154
00:06:12,890 --> 00:06:15,640
現在讓我用，而
循環，這是另一種情況。

155
00:06:15,640 --> 00:06:21,810
雖然我說，而我是大於
或等於零，然後在這裡我

156
00:06:21,810 --> 00:06:26,070
繼續前進，保存文件，進行循環。

157
00:06:26,070 --> 00:06:27,070
而我要運行它。

158
00:06:27,070 --> 00:06:30,230
我該怎麼看到這個
時間while循環？

159
00:06:30,230 --> 00:06:30,852
是啊。

160
00:06:30,852 --> 00:06:32,120
>> 聽眾：一個無限循環？

161
00:06:32,120 --> 00:06:35,360
>> 揚聲器1：一個無限循環？

162
00:06:35,360 --> 00:06:36,662
是的，為什麼？

163
00:06:36,662 --> 00:06:38,120
聽眾：因為它始終為零。

164
00:06:38,120 --> 00:06:38,786
揚聲器1：是啊。

165
00:06:38,786 --> 00:06:40,100
所以，我被初始化為零。

166
00:06:40,100 --> 00:06:44,470
當然，我總是更大
大於或等於0作為一個結果。

167
00:06:44,470 --> 00:06:46,460
所以，我只是要
看到這個無限。

168
00:06:46,460 --> 00:06:49,850
而現在，這已經上來一次
或兩次課程的負責人。

169
00:06:49,850 --> 00:06:52,417
當你發生什麼
有一個無限循環？

170
00:06:52,417 --> 00:06:53,314
>> 聽眾：控制C.

171
00:06:53,314 --> 00:06:53,980
揚聲器1：是啊。

172
00:06:53,980 --> 00:06:56,250
因此，對照C最終會作出反應。

173
00:06:56,250 --> 00:06:59,520
不幸的是，我們已經打印出來
億萬零已經

174
00:06:59,520 --> 00:07:01,520
所以計算機有
種了我前面。

175
00:07:01,520 --> 00:07:03,394
因此，它會忽略
我要一點點。

176
00:07:03,394 --> 00:07:06,560
但如果你只是打對照C幾
你的Mac或PC鍵盤上的時候，

177
00:07:06,560 --> 00:07:08,790
最終它應該確實終止。

178
00:07:08,790 --> 00:07:11,770
如果沒有的話，我們會告訴你一些
用不了多久，你的技術

179
00:07:11,770 --> 00:07:14,850
其實可以強行殺程序，
就像在Windows和Mac OS，

180
00:07:14,850 --> 00:07:15,562
如果需要的話。

181
00:07:15,562 --> 00:07:16,770
但是，讓我們嘗試別的東西。

182
00:07:16,770 --> 00:07:19,895
讓我們實際上會增加一。
這仍然將是無限的？

183
00:07:19,895 --> 00:07:22,870

184
00:07:22,870 --> 00:07:25,140
讓我跑這一點。

185
00:07:25,140 --> 00:07:27,090
現在你可以種
看到發生了什麼。

186
00:07:27,090 --> 00:07:30,140
此，也同樣是一個無限循環。

187
00:07:30,140 --> 00:07:33,080
但是，這是一個有點很難回答的問題。

188
00:07:33,080 --> 00:07:35,460
這是怎麼回事永遠打印的數字呢？

189
00:07:35,460 --> 00:07:36,647
>> 聽眾：第

190
00:07:36,647 --> 00:07:37,230
揚聲器1：否。

191
00:07:37,230 --> 00:07:37,620
為什麼呢？

192
00:07:37,620 --> 00:07:38,820
我聽到一些​​號在這裡。

193
00:07:38,820 --> 00:07:41,859
Someone--呀。

194
00:07:41,859 --> 00:07:44,275
聽眾：您沒有足夠的
位真正堅持下去。

195
00:07:44,275 --> 00:07:44,730
揚聲器1：所有權利。

196
00:07:44,730 --> 00:07:46,000
所以，我沒有足夠的
位繼續下去。

197
00:07:46,000 --> 00:07:47,124
那麼，有什麼事情發生？

198
00:07:47,124 --> 00:07:49,320
它只是要停下來？

199
00:07:49,320 --> 00:07:52,542
>> 聽眾：在某些時候
它將關閉the--

200
00:07:52,542 --> 00:07:54,500
揚聲器1：將關閉
循環下來，但是為什麼呢？

201
00:07:54,500 --> 00:07:57,950
這是怎麼回事發生在
其邊界的盡頭？

202
00:07:57,950 --> 00:07:58,479
是嗎？

203
00:07:58,479 --> 00:08:00,520
聽眾：它會循環
回到負數。

204
00:08:00,520 --> 00:08:02,900
揚聲器1：負數，或
如果我們只是積極的治療，

205
00:08:02,900 --> 00:08:03,570
零最少。

206
00:08:03,570 --> 00:08:04,550
所以，是的，絕對的。

207
00:08:04,550 --> 00:08:08,059
回想一下，我們看到的最後一次，如果你
增加你的點點太多次，

208
00:08:08,059 --> 00:08:10,225
你有FORE溢出
你INT的能力

209
00:08:10,225 --> 00:08:13,058
或任何數據類型，你
要環繞，很可能，

210
00:08:13,058 --> 00:08:14,020
兩個負號。

211
00:08:14,020 --> 00:08:16,644
或者，如果你指定你
範圍應僅是正的，

212
00:08:16,644 --> 00:08:18,560
你可以這樣做，但
我們還沒有看到的是，

213
00:08:18,560 --> 00:08:21,420
你可能最終至少回到零。

214
00:08:21,420 --> 00:08:22,410
雖然，實際上是。

215
00:08:22,410 --> 00:08:24,320
在這種情況下，負
號，在這種情況

216
00:08:24,320 --> 00:08:26,870
環路將要終止
因為我是不是，事實上，

217
00:08:26,870 --> 00:08:29,220
大於或等於
零，如果是負面的。

218
00:08:29,220 --> 00:08:31,780
>> 所以，不幸的是，如何
長會，我們不得不等待？

219
00:08:31,780 --> 00:08:35,490
現在，我們正達
什麼，200萬上下的？

220
00:08:35,490 --> 00:08:37,705
我們是如2十億，
我們將不得不等待

221
00:08:37,705 --> 00:08:39,330
直到我們可以清楚地看到這種現象。

222
00:08:39,330 --> 00:08:46,200
但是，我們可以看到它快一點，
maybe--讓我們看看我們是否可以中斷。

223
00:08:46,200 --> 00:08:46,700
來吧。

224
00:08:46,700 --> 00:08:49,500

225
00:08:49,500 --> 00:08:51,331
就連菜單出現緩慢。

226
00:08:51,331 --> 00:08:51,830
好的。

227
00:08:51,830 --> 00:08:54,270
所以，我們會回來的，不久。

228
00:08:54,270 --> 00:08:56,320
這是一個很好的時間 - 該死的，小狗。

229
00:08:56,320 --> 00:08:58,280
>> 這是一個好時機一些短片。

230
00:08:58,280 --> 00:09:01,225
所以，如果你可能會喜歡
從事YHack，

231
00:09:01,225 --> 00:09:03,600
該事件是
我們的朋友在耶魯大學主辦。

232
00:09:03,600 --> 00:09:05,990
而且，事實上，一些過程的
課題組在耶魯涉及與此有關。

233
00:09:05,990 --> 00:09:08,610
YHack是國際
黑客馬拉松主辦和舉行

234
00:09:08,610 --> 00:09:12,395
在耶魯大學，匯集1500
志同道合的黑客和廣告的所有

235
00:09:12,395 --> 00:09:13,120
遍布世界各地。

236
00:09:13,120 --> 00:09:14,610
如果這是感興趣的，
看看這裡。

237
00:09:14,610 --> 00:09:17,401
如果這是過於短暫的
屏幕，看看今天的幻燈片

238
00:09:17,401 --> 00:09:19,622
對於網址yhack.org。

239
00:09:19,622 --> 00:09:21,080
因此，也有一些快速的公告。

240
00:09:21,080 --> 00:09:24,410
因此，正式部分將啟動
下週在這裡和紐黑文。

241
00:09:24,410 --> 00:09:27,660
請記住，你會得到一個
電子郵件後來這個週末最有可能的。

242
00:09:27,660 --> 00:09:29,390
這需要很長的時間
為CS50節，

243
00:09:29,390 --> 00:09:32,080
給所有的人在
一流的，每個人走動。

244
00:09:32,080 --> 00:09:34,871
而所有的教學研究員“
時間表也仍在鞏固，

245
00:09:34,871 --> 00:09:38,110
但敬請關注電子郵件，如果需要的話
可以，你可以有後再次部分。

246
00:09:38,110 --> 00:09:39,580
>> Study.cs50.net。

247
00:09:39,580 --> 00:09:43,280
所以，即使你是一個恆定的與會者
在段，實現幾乎所有

248
00:09:43,280 --> 00:09:46,786
資源，我們在部分使用
公佈於CS50

249
00:09:46,786 --> 00:09:48,460
在研究這個網址在這裡。

250
00:09:48,460 --> 00:09:51,630
所以，如果你曾經想重新審查
材料部分，或讀取提前，

251
00:09:51,630 --> 00:09:54,170
或者你不能讓一些週，
認識到樣品的幻燈片，

252
00:09:54,170 --> 00:09:58,210
和問題，和定義，
而更多的是所有有作為。

253
00:09:58,210 --> 00:10:00,645
>> 今天辦公時間恢復，
明天，週三，

254
00:10:00,645 --> 00:10:03,020
週四檢查過程中的
網站的日程安排。

255
00:10:03,020 --> 00:10:05,690
>> 而且，現在推出
今天是CS50討論。

256
00:10:05,690 --> 00:10:09,230
因此，如果當你有問題
對方或過程的工作人員，

257
00:10:09,230 --> 00:10:12,099
且通常工作
一些習題集，

258
00:10:12,099 --> 00:10:15,015
認識到你不一定
不得不轉向你旁邊的人。

259
00:10:15,015 --> 00:10:17,810
如果有一個人也沒有，你可以
伸手給我們和同學

260
00:10:17,810 --> 00:10:19,890
網上通過CS50討論。

261
00:10:19,890 --> 00:10:22,600
所以，這是一個討論
板的過程中，

262
00:10:22,600 --> 00:10:24,550
並認識到這
也許是最好的

263
00:10:24,550 --> 00:10:28,480
開始的地方，當你有
辦公時間問題時，外

264
00:10:28,480 --> 00:10:29,470
特別。

265
00:10:29,470 --> 00:10:31,070
>> 午餐將在本週啟動了。

266
00:10:31,070 --> 00:10:33,170
在火與​​冰
[聽不清]在紐黑文。

267
00:10:33,170 --> 00:10:35,379
看一看在課程的
網站以RSVP。

268
00:10:35,379 --> 00:10:36,753
先來先服務於這一點。

269
00:10:36,753 --> 00:10:39,380
如果你沒有得到在這一周
我們將這些最每週五做

270
00:10:39,380 --> 00:10:40,400
在此期限內。

271
00:10:40,400 --> 00:10:41,830
>> OK，現在大約分級字。

272
00:10:41,830 --> 00:10:44,690
特別是當我們進入的問題
設置一個，這是這個星期，

273
00:10:44,690 --> 00:10:46,670
與問題設置兩個，其後。

274
00:10:46,670 --> 00:10:51,680
如何做才好在計算P套
和評價其質量？

275
00:10:51,680 --> 00:10:55,560
所以，這是我們在使用四軸
CS50，他們是這四個位置。

276
00:10:55,560 --> 00:10:59,200
>> 適用範圍，它可以捕獲一個數字
依據到底有多少在P組

277
00:10:59,200 --> 00:10:59,860
你解決。

278
00:10:59,860 --> 00:11:02,890
它大致與對應
努力，這是我們的拍攝方式

279
00:11:02,890 --> 00:11:05,190
你嘗試一半在P
設置，所有P組。

280
00:11:05,190 --> 00:11:08,860
這是一個容易得到完美
分數，如果你做，事實上，

281
00:11:08,860 --> 00:11:11,020
嘗試在P組的每一個方面。

282
00:11:11,020 --> 00:11:12,010
所以，記住這一點。

283
00:11:12,010 --> 00:11:13,420
>> 正確性正是如此。

284
00:11:13,420 --> 00:11:17,760
請問你的代碼工作規範
而作為員工的樣品溶液

285
00:11:17,760 --> 00:11:19,730
建議你的代碼
應，實際上，正常工作。

286
00:11:19,730 --> 00:11:23,260
檢查50，如果你還沒有遇見它
然而，是P中設置一種規格

287
00:11:23,260 --> 00:11:25,060
並且一般
給你是/否的答案

288
00:11:25,060 --> 00:11:26,518
是否你的代碼是正確的。

289
00:11:26,518 --> 00:11:30,680
至少到目前為止，我們要去
對其進行評估的基礎上測試

290
00:11:30,680 --> 00:11:32,430
我們的程序中運行。

291
00:11:32,430 --> 00:11:33,850
>> 設計更加主觀的。

292
00:11:33,850 --> 00:11:35,994
這是怎麼寫得很好，是你的代碼。

293
00:11:35,994 --> 00:11:38,410
這是東西
你會得到在一段時間內比較好，

294
00:11:38,410 --> 00:11:41,201
和它的東西，我們會
提供更多的定性反饋。

295
00:11:41,201 --> 00:11:43,350
並通過設計，我可能
過不了多久意味著你

296
00:11:43,350 --> 00:11:47,650
中了一些p-可能會受到誘惑
設置做一些loopingly，

297
00:11:47,650 --> 00:11:51,590
但有可能三個或四個，或
5嵌套循環前或嵌套而

298
00:11:51,590 --> 00:11:52,090
循環。

299
00:11:52,090 --> 00:11:54,130
這一般應
開始做你畏縮

300
00:11:54,130 --> 00:11:56,070
一般會
認為是不好的設計。

301
00:11:56,070 --> 00:11:59,490
你會開始看到在課堂上
出來做事的類好方法，

302
00:11:59,490 --> 00:12:02,920
做事不好的方式，
可能全部是正確的，但不能

303
00:12:02,920 --> 00:12:04,304
一定精心設計的。

304
00:12:04,304 --> 00:12:05,220
就像寫論文。

305
00:12:05,220 --> 00:12:08,100
你也許能夠把字上
網頁是語法正確，

306
00:12:08,100 --> 00:12:10,016
但作文或
論文他們在僅僅是

307
00:12:10,016 --> 00:12:11,810
完全語無倫次或缺乏說服力。

308
00:12:11,810 --> 00:12:15,930
因此，可能是在該模擬
不良或良好的設計編寫的世界。

309
00:12:15,930 --> 00:12:18,490
>> 和風格，也同樣是相當主觀的。

310
00:12:18,490 --> 00:12:20,060
但至少我們期望的一致性。

311
00:12:20,060 --> 00:12:21,480
這是多麼漂亮是你的代碼。

312
00:12:21,480 --> 00:12:22,840
事情很好地縮進？

313
00:12:22,840 --> 00:12:26,600
是你的變量以及名為/是否所有
你的括號和大括號

314
00:12:26,600 --> 00:12:27,920
對準他們應該是什麼？

315
00:12:27,920 --> 00:12:31,490
我們確實有一個CS50風格指南作為
問題集將指向你的。

316
00:12:31,490 --> 00:12:33,730
那些更舒適的
歡迎來自流浪

317
00:12:33,730 --> 00:12:35,771
只要你是自洽。

318
00:12:35,771 --> 00:12:38,020
而這，也同樣是一個教訓
我們將加強在部分。

319
00:12:38,020 --> 00:12:40,990
因此，如果這一切是一個小
速度快，實現了在P組和部分

320
00:12:40,990 --> 00:12:42,900
將進入更深入沒多久。

321
00:12:42,900 --> 00:12:45,490
>> 但一般我們有
很少有水桶為CS50。

322
00:12:45,490 --> 00:12:48,170
分數一般的規模
的一至三個，或者一至五個。

323
00:12:48,170 --> 00:12:50,836
我們literally--，我不能說
這足以在第一週。

324
00:12:50,836 --> 00:12:51,582
三是良好的。

325
00:12:51,582 --> 00:12:54,290
所以，儘管，是的，四分之三
五通常，數學，

326
00:12:54,290 --> 00:12:57,240
可能是一個60％或像A D減去。

327
00:12:57,240 --> 00:12:58,840
三是，其實不錯的。

328
00:12:58,840 --> 00:13:01,050
而且，事實上，我們預期
大多數學生在課堂上

329
00:13:01,050 --> 00:13:04,280
各地開始術語
三三兩兩，和三分球，和四肢。

330
00:13:04,280 --> 00:13:05,510
也許沒有那麼多五歲以下兒童。

331
00:13:05,510 --> 00:13:06,661
沒有太多的人。

332
00:13:06,661 --> 00:13:08,910
但一般開始於
甜蜜點的曲線

333
00:13:08,910 --> 00:13:11,694
使得隨著時間的推進，
實際上有空間，

334
00:13:11,694 --> 00:13:13,360
和機會上的進展。

335
00:13:13,360 --> 00:13:15,810
所以，請不要等同於三連60％。

336
00:13:15,810 --> 00:13:17,410
這是比這更抽象。

337
00:13:17,410 --> 00:13:20,160
與我們計算公式
成績加權如下。

338
00:13:20,160 --> 00:13:21,610
正確性值得最。

339
00:13:21,610 --> 00:13:23,010
設計是值得少一點。

340
00:13:23,010 --> 00:13:24,490
風格是值得少一點。

341
00:13:24,490 --> 00:13:26,950
而這一般
捕獲的時間量

342
00:13:26,950 --> 00:13:29,800
即進入獲取每個
這些軸的恰到好處。

343
00:13:29,800 --> 00:13:31,810
風格是超級容易，
應該是超級快，

344
00:13:31,810 --> 00:13:33,657
但它是一個簡單的習慣
偷懶一下。

345
00:13:33,657 --> 00:13:35,490
正確性可能需要
你的大部分時間。

346
00:13:35,490 --> 00:13:38,990
追擊了一些bug威力
採取額外小時或更長時間，

347
00:13:38,990 --> 00:13:41,737
因此，計分
最終捕獲。

348
00:13:41,737 --> 00:13:43,070
所以，現在更嚴重的話。

349
00:13:43,070 --> 00:13:45,240
由於CS50有
區分，為了更好的

350
00:13:45,240 --> 00:13:47,440
或者更糟的是，被
也許是更好的認識

351
00:13:47,440 --> 00:13:50,065
與學術的問題
誠信比大多數其他任何課程。

352
00:13:50,065 --> 00:13:53,720
事實上，這是我的知識
我們送更多的學生，遺憾的是，

353
00:13:53,720 --> 00:13:56,690
為懲戒目的
每年作為結果。因此，

354
00:13:56,690 --> 00:13:59,040
在全興趣
信息披露，讓我們來簡單談談

355
00:13:59,040 --> 00:14:02,820
關於什麼在CS50，和你
可以做的，你可以什麼銘記。

356
00:14:02,820 --> 00:14:05,530
>> 所以，這裡從2007年開始的時候，
我繼承的過程中，

357
00:14:05,530 --> 00:14:07,870
是廣告委員會的案件數量。

358
00:14:07,870 --> 00:14:10,690
AD板是哈佛大學的紀律
身體，還是現在的榮譽顧問，

359
00:14:10,690 --> 00:14:13,790
到案件移交時，
學生做一些課程的

360
00:14:13,790 --> 00:14:15,470
教學大綱認為是不合理的。

361
00:14:15,470 --> 00:14:17,220
有沒有真正的模式
在這裡，我想說的。

362
00:14:17,220 --> 00:14:19,530
它的波動比
年，但一般

363
00:14:19,530 --> 00:14:22,262
這是數
這被稱為箱子。

364
00:14:22,262 --> 00:14:23,970
學生人數
所涉及到的？

365
00:14:23,970 --> 00:14:25,290
它也各不相同。

366
00:14:25,290 --> 00:14:27,930
通常情況下，去年
例如，29名學生在哈佛

367
00:14:27,930 --> 00:14:29,740
是廣告登機，可以這麼說。

368
00:14:29,740 --> 00:14:32,670
其中在校學生29，
他們倆之前的學生，

369
00:14:32,670 --> 00:14:35,610
誰是合作
在某些不良方式。

370
00:14:35,610 --> 00:14:38,400
然後在的條款
百分比，通常約為3％

371
00:14:38,400 --> 00:14:41,360
之類的，很遺憾，
使這些類型的決定。

372
00:14:41,360 --> 00:14:44,470
>> 所以，去年是3.5％
CS50的學生的身體

373
00:14:44,470 --> 00:14:46,820
這是廣告登機，可以這麼說。

374
00:14:46,820 --> 00:14:48,490
>> 那麼，是什麼這一切意​​味著什麼呢？

375
00:14:48,490 --> 00:14:49,660
什麼我們實際上做？

376
00:14:49,660 --> 00:14:52,930
>> 因此，對於充分披露，我們
絕對的，因為計算機科學家，

377
00:14:52,930 --> 00:14:57,620
有軟件工具在我們的處置
它很容易讓我們，為公平起見，

378
00:14:57,620 --> 00:15:00,980
其他的同學誰不
越過這些線跨越比較

379
00:15:00,980 --> 00:15:04,570
今年對每家每戶提交
提交在過去的八年。

380
00:15:04,570 --> 00:15:05,445
軟件做到這一點。

381
00:15:05,445 --> 00:15:07,440
而最終它的
人眼的決定

382
00:15:07,440 --> 00:15:11,410
是否要參照一些
此事作進一步審理，

383
00:15:11,410 --> 00:15:12,737
但軟件有一定的幫助。

384
00:15:12,737 --> 00:15:15,820
而這，坦白地說，這就是為什麼我認為
我們有這樣大量的CS50。

385
00:15:15,820 --> 00:15:18,540
這不是因為CS50
學生或CS學生更多

386
00:15:18,540 --> 00:15:20,840
一般是任何減少誠實
比任何其他的學生，

387
00:15:20,840 --> 00:15:22,340
它只是我們有
工具和技術

388
00:15:22,340 --> 00:15:24,095
與藉此第一遍。

389
00:15:24,095 --> 00:15:25,960
>> 但是我們繼續關注
在所有這些事情

390
00:15:25,960 --> 00:15:30,340
同時，又在利益
認識到正在被投入工作

391
00:15:30,340 --> 00:15:32,397
在由絕對多數之類的。

392
00:15:32,397 --> 00:15:34,230
而課程的政策
學術誠信，

393
00:15:34,230 --> 00:15:37,021
即使它是一堆段落
長著一堆子彈

394
00:15:37,021 --> 00:15:40,490
那些希望可讀性很好，它
確實歸結為是合理的。

395
00:15:40,490 --> 00:15:44,000
和拇指的最佳規則
我們提供了教學大綱中

396
00:15:44,000 --> 00:15:46,020
是這樣的，本質
所有的工作，你

397
00:15:46,020 --> 00:15:47,850
提交本課程必須是你自己。

398
00:15:47,850 --> 00:15:51,510
事實上，幾乎所有這些
宗介紀律處分

399
00:15:51,510 --> 00:15:55,640
這是因為一些學生下旬的一個
晚上一般把他或她的代碼

400
00:15:55,640 --> 00:15:58,130
在直接向一個同學，
誰再通過它

401
00:15:58,130 --> 00:16:00,840
其全部或
顯著物。

402
00:16:00,840 --> 00:16:02,680
>> 不過說真的，這是確定。

403
00:16:02,680 --> 00:16:04,684
事實上，在辦公室
紙小時，卡瓦

404
00:16:04,684 --> 00:16:07,850
你一直在流傳，如果你來過辦公室
小時上週鼓勵之多。

405
00:16:07,850 --> 00:16:09,710
你絕對
歡迎和鼓勵

406
00:16:09,710 --> 00:16:12,340
討論習題集與同學。

407
00:16:12,340 --> 00:16:14,461
要絆倒的時候互相幫助。

408
00:16:14,461 --> 00:16:17,710
但一般經驗法則應
是這樣的，“當你尋求幫助，

409
00:16:17,710 --> 00:16:20,412
你可能會顯示你的代碼給其他人，
但你可能不認為他們的。“

410
00:16:20,412 --> 00:16:22,620
所以，換句話說，如果我
一些頁P掙扎

411
00:16:22,620 --> 00:16:25,290
而我在坐在那裡
食堂，或在圖書館，

412
00:16:25,290 --> 00:16:28,470
或在課堂上
試圖找到一些故障，

413
00:16:28,470 --> 00:16:30,340
我可以肯定的顯示
我的我的屏幕上的代碼

414
00:16:30,340 --> 00:16:32,590
的人坐在旁邊
對我來說，肯定是工作人員，

415
00:16:32,590 --> 00:16:33,600
又是同班同學。

416
00:16:33,600 --> 00:16:36,580
但是，如果解決方案，它
我的同學提供的是，哦，

417
00:16:36,580 --> 00:16:39,200
這裡只是來看看什麼
我這樣做，是穿過線。

418
00:16:39,200 --> 00:16:43,120
>> 而且我敢說這是一般
一個合理的事情對大多數人

419
00:16:43,120 --> 00:16:45,030
很容易發現的行。

420
00:16:45,030 --> 00:16:47,195
所以，看大綱
對於更多的細節。

421
00:16:47,195 --> 00:16:49,070
而現在比較1
有爭議的方面

422
00:16:49,070 --> 00:16:52,529
CS50大綱，我認為我
會說話的結論，在這裡

423
00:16:52,529 --> 00:16:53,820
是所謂的遺憾子句。

424
00:16:53,820 --> 00:16:55,340
所以，這裡的所有的小字。

425
00:16:55,340 --> 00:16:58,090
但總的來說，我們已經看到
在過去的8年以上

426
00:16:58,090 --> 00:17:01,510
如此，事實上，幾乎所有的CS50的
學術造假案

427
00:17:01,510 --> 00:17:04,390
一直只是窮人的結果
決策深夜。

428
00:17:04,390 --> 00:17:07,144
應力，其結果的結果
缺乏飲食，睡眠不足，

429
00:17:07,144 --> 00:17:09,560
過多的P組，太多
最後期限，太多的承諾。

430
00:17:09,560 --> 00:17:13,520
應力在2:00 AM建立，3:00
：00,4：00，有一個最後期限迫在眉睫。

431
00:17:13,520 --> 00:17:17,020
大多數學生在這些情況下，
剛剛做出了錯誤的決定

432
00:17:17,020 --> 00:17:20,619
他們很可能會後悔的
第二天早上如果不分鐘後，

433
00:17:20,619 --> 00:17:25,490
但直到去年，沒有
放氣閥，這些學生可以

434
00:17:25,490 --> 00:17:29,140
實際上開闢實際解決
問題的頭不用擔心被

435
00:17:29,140 --> 00:17:30,850
從大學完全啟動。

436
00:17:30,850 --> 00:17:33,260
>> 而且，事實上，我們推出
這個遺憾節最後一年，

437
00:17:33,260 --> 00:17:35,970
它說，如果在
72小時後，三天，

438
00:17:35,970 --> 00:17:37,970
穿越一些線
在規定的教學大綱

439
00:17:37,970 --> 00:17:41,178
你出面了課程之一
頭，我們將有一個關於它的聊天。

440
00:17:41,178 --> 00:17:43,720
目前還有一些
結果，違背了什麼

441
00:17:43,720 --> 00:17:44,990
據報導，與此相反。

442
00:17:44,990 --> 00:17:49,190
還有一些結果是
是可操作的由課程，

443
00:17:49,190 --> 00:17:51,611
一般歸零在P組
或者採取一些其他的措施，

444
00:17:51,611 --> 00:17:53,610
但我們會，事實上，
處理它自己，而不是

445
00:17:53,610 --> 00:17:58,460
指其較高的是結果
可能是更嚴重的。

446
00:17:58,460 --> 00:18:01,810
而且，事實上，分享發生了什麼
去年，在八年，現在

447
00:18:01,810 --> 00:18:04,950
九年，本課程教學
並與各旋鈕擺弄後，

448
00:18:04,950 --> 00:18:07,866
過去轉彎各種刻度盤
幾年來學術誠信，

449
00:18:07,866 --> 00:18:11,920
和每數據沒有明顯看到
影響甚至這樣的演講，

450
00:18:11,920 --> 00:18:15,490
這是手了最好的東西
我們教學上推出

451
00:18:15,490 --> 00:18:18,090
八年來順
這些線路在CS50。

452
00:18:18,090 --> 00:18:21,010
>> 19名學生上前
根據本條款的最後一年。

453
00:18:21,010 --> 00:18:23,389
我們沒有採取行動
7這些學生，

454
00:18:23,389 --> 00:18:25,430
確定它們是
不必要的擔心。

455
00:18:25,430 --> 00:18:27,304
他們沒有，事實上，
越過一條線，但它

456
00:18:27,304 --> 00:18:28,960
是一個很好的聊天都不過。

457
00:18:28,960 --> 00:18:31,190
我們歸零的分數11
該提交。

458
00:18:31,190 --> 00:18:33,840
而在一種情況下，我們問了
學生做習題集。

459
00:18:33,840 --> 00:18:36,370
但更引人注目的，
說實話，這些19的聊天記錄，

460
00:18:36,370 --> 00:18:39,020
這是方式比我
預計將有，他們每個人

461
00:18:39,020 --> 00:18:41,370
10分鐘或許一個
小時多頭，也帶來了

462
00:18:41,370 --> 00:18:44,920
點燃有關的一些問題
家庭問題，朋友的問題，

463
00:18:44,920 --> 00:18:46,940
心理健康問題
我們再搞，

464
00:18:46,940 --> 00:18:50,200
與學生的祝福，居民
院長，或朋友，或任何其它號碼

465
00:18:50,200 --> 00:18:51,450
支持資源。

466
00:18:51,450 --> 00:18:54,454
所以，這是迄今為止1
我們這個時代的最佳用途

467
00:18:54,454 --> 00:18:55,870
和最佳干預措施之一。

468
00:18:55,870 --> 00:18:58,870
>> 隨著中說，它沒有
輸入上檢測的速率

469
00:18:58,870 --> 00:19:00,909
學術造假的更普遍。

470
00:19:00,909 --> 00:19:02,950
我敢說，這個子集
學生去年

471
00:19:02,950 --> 00:19:06,350
是一個人口我們
以前以前從未確定

472
00:19:06,350 --> 00:19:08,140
和從未與之前連接。

473
00:19:08,140 --> 00:19:10,020
所以，這些人
精彩的成功案例

474
00:19:10,020 --> 00:19:13,390
即使他們被帶到光
在低於最佳情況。

475
00:19:13,390 --> 00:19:15,640
所以，記住這一點
當你做，也許，

476
00:19:15,640 --> 00:19:17,390
一些貧困的決定
自己在深夜，

477
00:19:17,390 --> 00:19:20,151
有追索這麼久
作為學生在這種情況

478
00:19:20,151 --> 00:19:23,400
自己並出面使我們能
有那種聊天，並處理它

479
00:19:23,400 --> 00:19:27,310
的方式，是教育，然後
我們可以把它在我們身後的第二天。

480
00:19:27,310 --> 00:19:30,335
>> 因此，事不宜遲，取
緣滅這次談話中，

481
00:19:30,335 --> 00:19:35,080
小狗是上升的原因
只是為了打破僵局了一會兒。

482
00:19:35,080 --> 00:19:39,560
不幸的是，他們都睡覺，
但什麼是應該發生在這裡

483
00:19:39,560 --> 00:19:41,760
是每個人都應該
以敬畏和一種放鬆

484
00:19:41,760 --> 00:19:43,910
在那之後很沉重的談話。

485
00:19:43,910 --> 00:19:46,930
但顯然我把
小狗睡覺。

486
00:19:46,930 --> 00:19:50,070
但是，如果你去到CS50的
網站斜線小狗，

487
00:19:50,070 --> 00:19:51,610
你可以整天看著他們。

488
00:19:51,610 --> 00:19:55,280
特別是，也許2:00，或
3:00，或4:00，晚上

489
00:19:55,280 --> 00:19:57,480
看到一個小的壓力緩解那裡。

490
00:19:57,480 --> 00:19:58,805
所以這是兇多吉少小狗。

491
00:19:58,805 --> 00:20:01,700

492
00:20:01,700 --> 00:20:02,200
好的。

493
00:20:02,200 --> 00:20:03,020
是不是很好玩？

494
00:20:03,020 --> 00:20:04,200
確定。

495
00:20:04,200 --> 00:20:07,140
所以，回到一些電腦
科學，如果我可以。

496
00:20:07,140 --> 00:20:10,600
>> 所以，記得上次我們開始
看著不只是在主，這

497
00:20:10,600 --> 00:20:13,930
是默認的功能，當
綠旗點擊當量，

498
00:20:13,930 --> 00:20:16,999
但是，我們也開始簡要
寫我們自己的一些功能。

499
00:20:16,999 --> 00:20:20,040
因此到目前為止沒有這些功能
已經特別大或肉。

500
00:20:20,040 --> 00:20:24,570
你會惹上這些大
功能可能，P組2，P組3，

501
00:20:24,570 --> 00:20:26,410
肯定P設定4及以後。

502
00:20:26,410 --> 00:20:29,340
現在大部分的節目，
如果不是所有的人，肯定對p

503
00:20:29,340 --> 00:20:31,550
集1可以在主全部完成。

504
00:20:31,550 --> 00:20:33,810
如果你的程序是唯一
五類線，10號線，

505
00:20:33,810 --> 00:20:37,070
甚至20日線長，完美
合理的把它寫

506
00:20:37,070 --> 00:20:40,930
所有的主，不要過分複雜
你的代碼，但我們正在做什麼今天

507
00:20:40,930 --> 00:20:44,360
及以後試圖也
介紹一些好的設計技巧

508
00:20:44,360 --> 00:20:48,660
這樣，當你的代碼變得更
複雜和作為問題

509
00:20:48,660 --> 00:20:51,690
你想解決越來越困難和
更有趣的你有幾分，

510
00:20:51,690 --> 00:20:55,850
在你的工具箱中的工具，其作用
設計良好的解決這些。

511
00:20:55,850 --> 00:21:01,210
>> 所以，讓我們快速回顧一下
這個節目從我的最後一周，這

512
00:21:01,210 --> 00:21:06,550
是函數零點點。和
請注意，很簡單，

513
00:21:06,550 --> 00:21:10,310
它看起來像這樣有兩個
功能，主要和打印的名字。

514
00:21:10,310 --> 00:21:13,160
而回想或者
今天逆向工程，

515
00:21:13,160 --> 00:21:16,880
究竟是什麼動機引入
在第28行稱為函數，

516
00:21:16,880 --> 00:21:18,180
打印的名字嗎？

517
00:21:18,180 --> 00:21:21,745
或者是什麼這的一個例子
宗旨或外賣方面，

518
00:21:21,745 --> 00:21:22,605
如果你會的。

519
00:21:22,605 --> 00:21:26,560

520
00:21:26,560 --> 00:21:27,300
一些雜音。

521
00:21:27,300 --> 00:21:28,830
怎麼辦？

522
00:21:28,830 --> 00:21:32,210
>> 是啊等等功能分解
是怎麼樣的說法了奇特的方式，

523
00:21:32,210 --> 00:21:34,690
分解你的程序
成其組成部分

524
00:21:34,690 --> 00:21:37,530
然後使用這些部件
組裝一個整體。

525
00:21:37,530 --> 00:21:39,620
所以，這也僅僅是一種
已經一口，

526
00:21:39,620 --> 00:21:42,050
但是這也許是連
的東西更好的例子

527
00:21:42,050 --> 00:21:43,081
只是所謂的抽象。

528
00:21:43,081 --> 00:21:43,580
對嗎？

529
00:21:43,580 --> 00:21:46,950
抽象是要為一個
反复出現的主題CS50的

530
00:21:46,950 --> 00:21:49,085
而且計算機科學
更普遍的，因為它是

531
00:21:49,085 --> 00:21:53,060
一種技術，使用它可以解決
問題更有效，因為你

532
00:21:53,060 --> 00:21:56,807
可以編寫解決方案的更多
直觀的方式，縮放

533
00:21:56,807 --> 00:21:58,390
並且是可以理解其他人。

534
00:21:58,390 --> 00:21:59,860
我怎麼意思？

535
00:21:59,860 --> 00:22:04,340
>> 因此，可以說這是更具可讀性
看這樣的節目，

536
00:22:04,340 --> 00:22:05,990
超短雖然它是。

537
00:22:05,990 --> 00:22:10,050
當您在22行看到，有
一個調用的函數，打印的名字。

538
00:22:10,050 --> 00:22:12,620
單單這名字就做什麼。

539
00:22:12,620 --> 00:22:15,780
這個功能顯然需要
它的括號內輸入，

540
00:22:15,780 --> 00:22:18,600
顯然做一些事情，
想必打印的名稱。

541
00:22:18,600 --> 00:22:20,880
因此，儘管我們
絕對可以有

542
00:22:20,880 --> 00:22:25,280
做什麼我們做了一個星期前，這是
只是把這個代碼的實際行，

543
00:22:25,280 --> 00:22:28,710
擺脫了這一點，並獲得
擺脫這一切在一起，

544
00:22:28,710 --> 00:22:31,436
我們之類的抽象出來
打印名的概念。

545
00:22:31,436 --> 00:22:33,060
如果你使用的打印清晰度我不在乎。

546
00:22:33,060 --> 00:22:35,601
我不在乎，如果你有一個
％的S和一個反斜杠N.這些

547
00:22:35,601 --> 00:22:37,270
是令人難以置信的神秘細節。

548
00:22:37,270 --> 00:22:40,090
我所關心的一個
程序員正在打印一個名稱。

549
00:22:40,090 --> 00:22:43,414
所以，要做什麼更好的方式，
不是通過調用一個函數，打印的名字嗎？

550
00:22:43,414 --> 00:22:46,330
因此，這是動機之一
做這樣的事情。

551
00:22:46,330 --> 00:22:50,370
使代碼更易讀，更
可重複使用的，並具有自描述性的。

552
00:22:50,370 --> 00:22:52,120
現在，讓我們一起來看看
在另一實例中，

553
00:22:52,120 --> 00:22:56,220
這是一個功能，
這是我們不得不在這裡。

554
00:22:56,220 --> 00:23:00,367
>> 所以，這一次或許更
引人注目的，因為，在這種情況下，

555
00:23:00,367 --> 00:23:01,700
我不希望只是得到一個int。

556
00:23:01,700 --> 00:23:03,320
我希望得到一個積極的INT。

557
00:23:03,320 --> 00:23:06,470
而事實證明，得到了肯定
詮釋你所要做的一幫跑腿。

558
00:23:06,470 --> 00:23:06,969
對嗎？

559
00:23:06,969 --> 00:23:09,600
這不是一個簡單的一行
調用諸如打印的名字，

560
00:23:09,600 --> 00:23:11,480
這是無可否認的那麼迫切。

561
00:23:11,480 --> 00:23:16,000
>> 為了得到一個積極的INT，logically--
讓我滾動回落隱藏此。

562
00:23:16,000 --> 00:23:18,887
你有什麼做的？

563
00:23:18,887 --> 00:23:20,720
像所有的工具，我們
目前所面對的是

564
00:23:20,720 --> 00:23:24,440
像從標準打印高清
圖書館，也從CS50庫

565
00:23:24,440 --> 00:23:26,990
我們有獲取int和獲取浮動，
獲得長隆，獲取字符串，

566
00:23:26,990 --> 00:23:29,260
但只有一個，鍺，
現在的問題是得到詮釋。

567
00:23:29,260 --> 00:23:32,970
所以，如果唯一的工具，你有
在你的工具盒是獲取智力，

568
00:23:32,970 --> 00:23:35,505
我們怎麼去實現
它得到積極的詮釋？

569
00:23:35,505 --> 00:23:35,929
>> 聽眾：創建一個記錄，並檢查
是否，他們給輸入

570
00:23:35,929 --> 00:23:36,762
為正。

571
00:23:36,762 --> 00:23:39,390

572
00:23:39,390 --> 00:23:40,640
>> 揚聲器1：完美。

573
00:23:40,640 --> 00:23:41,200
沒錯。

574
00:23:41,200 --> 00:23:43,950
我們在另一個工具我們
從兩個星期前的工具箱

575
00:23:43,950 --> 00:23:45,419
僅僅是循環結構。

576
00:23:45,419 --> 00:23:48,210
所以，是的，如果我們使用了一段時間
循環或do while循環，或脫穎而出

577
00:23:48,210 --> 00:23:50,850
循環中，我們也許可以蒙混過關
任何那些某種形式的。

578
00:23:50,850 --> 00:23:55,140
我們可以實現獲取的概念
積極的INT，只需使用Get詮釋，

579
00:23:55,140 --> 00:23:57,830
然後自顧自地調用它
再次，保持纏著用戶

580
00:23:57,830 --> 00:24:00,320
直到他或她實際上
為我們提供了我們想要的。

581
00:24:00,320 --> 00:24:03,260
>> 所以現在，這個
該方法的抽象

582
00:24:03,260 --> 00:24:05,680
中得到肯定的INT
到稱為函數

583
00:24:05,680 --> 00:24:08,930
得到正int是多一點
引人注目的，因為看這個。

584
00:24:08,930 --> 00:24:10,990
這就像10加
行代碼的

585
00:24:10,990 --> 00:24:15,090
參與得到肯定的整型，
我真的不關心你是怎麼做的。

586
00:24:15,090 --> 00:24:17,850
所有我關心的是你
能做到這一點，所以我已經

587
00:24:17,850 --> 00:24:21,660
隱藏所有後面的這些細節
函數調用得到正int值，

588
00:24:21,660 --> 00:24:23,430
事實上，有這個do while循環。

589
00:24:23,430 --> 00:24:27,660
>> 而看到上週的語法
在那裡，但它只是宣告N，

590
00:24:27,660 --> 00:24:29,800
並打印出
指令給用戶。

591
00:24:29,800 --> 00:24:33,330
它要求得到詮釋，然後檢查
再次此條件，並再次，

592
00:24:33,330 --> 00:24:35,230
並再次直到用戶協作。

593
00:24:35,230 --> 00:24:38,000
>> 所以，現在，幾個完整性檢查。

594
00:24:38,000 --> 00:24:40,370
對於那些也許熟悉
有一定編程，

595
00:24:40,370 --> 00:24:46,410
為什麼為N聲明，為什麼我創造
在do while循環氮之外？

596
00:24:46,410 --> 00:24:50,370
為什麼第29行，而不是
像33，例如。

597
00:24:50,370 --> 00:24:53,529
>> 聽眾：因為當你
一種外部聲明，它

598
00:24:53,529 --> 00:24:56,688
的更多，較大scope--

599
00:24:56,688 --> 00:24:58,146
>> 揚聲器1：好。

600
00:24:58,146 --> 00:24:59,604
>> 聽眾： - 並且如果你聲明
它的循環中，[聽不清]

601
00:24:59,604 --> 00:25:00,979
因為它不知道這件事。

602
00:25:00,979 --> 00:25:02,819

603
00:25:02,819 --> 00:25:03,610
揚聲器1：沒錯。

604
00:25:03,610 --> 00:25:06,330
如果我能simplify--
它的範圍的問題。

605
00:25:06,330 --> 00:25:11,530
和範圍是指在上下文
其中一個變量存在或可用。

606
00:25:11,530 --> 00:25:15,050
和拇指這裡的好的規則是，
通常當你聲明或創建

607
00:25:15,050 --> 00:25:21,642
一個變量，你只能內部使用
最親密的擁抱花括號。

608
00:25:21,642 --> 00:25:22,600
那麼，是什麼意思呢？

609
00:25:22,600 --> 00:25:26,551
如果我，相反，撤消此去與
東西，感覺有點簡單。

610
00:25:26,551 --> 00:25:27,050
對嗎？

611
00:25:27,050 --> 00:25:29,360
>> 第32行只是看起來更清潔現在對我。

612
00:25:29,360 --> 00:25:31,500
我正在做兩件事在
一次，然後分配

613
00:25:31,500 --> 00:25:33,070
右手到左手。

614
00:25:33,070 --> 00:25:35,180
現在的問題的基礎上
範圍的界定

615
00:25:35,180 --> 00:25:41,130
是，N能在線路上使用
31和32這循環內，

616
00:25:41,130 --> 00:25:45,100
但如果根據這一定義
可它不能用？

617
00:25:45,100 --> 00:25:45,660
在行是什麼？

618
00:25:45,660 --> 00:25:46,160
是啊。

619
00:25:46,160 --> 00:25:47,490
>> 聽眾：35。

620
00:25:47,490 --> 00:25:49,180
>> 揚聲器1：35。

621
00:25:49,180 --> 00:25:50,480
絕對不是35。

622
00:25:50,480 --> 00:25:52,349
而且還還有什麼地方？

623
00:25:52,349 --> 00:25:52,890
聽眾：34。

624
00:25:52,890 --> 00:25:55,040
揚聲器1：即使34
有問題的，因為它是

625
00:25:55,040 --> 00:25:56,450
外面的大括號。

626
00:25:56,450 --> 00:25:58,200
所以事實上，讓我們看看會發生什麼。

627
00:25:58,200 --> 00:25:58,700
對嗎？

628
00:25:58,700 --> 00:26:00,722
這似乎有點
直觀的，也可能不是，

629
00:26:00,722 --> 00:26:02,680
但是讓我們看看有什麼
編譯器的時候說

630
00:26:02,680 --> 00:26:04,730
我們進入今天的源目錄。

631
00:26:04,730 --> 00:26:08,950
讓功能之一。

632
00:26:08,950 --> 00:26:11,231
哦，我的上帝。

633
00:26:11,231 --> 00:26:12,980
好吧，我終於完成
這，順便說一句。

634
00:26:12,980 --> 00:26:14,030
好的。

635
00:26:14,030 --> 00:26:15,510
這有什麼問題嗎？

636
00:26:15,510 --> 00:26:17,430
很神秘的來看待。

637
00:26:17,430 --> 00:26:19,570
但這裡是我typed--
使功能之一。

638
00:26:19,570 --> 00:26:21,640
下面是做誘導，
這實際上是

639
00:26:21,640 --> 00:26:23,705
使用編譯器鐺
用那些標誌

640
00:26:23,705 --> 00:26:25,080
我們將不久再次看到。

641
00:26:25,080 --> 00:26:26,829
再次，總是期待
在第一個錯誤，

642
00:26:26,829 --> 00:26:30,540
因為它可能只是一個級聯
其他線路毫無意義的作用。

643
00:26:30,540 --> 00:26:34,410
>> 所以，這是什麼意思的是，
問題是在功能1.C.

644
00:26:34,410 --> 00:26:36,890
它是線32。

645
00:26:36,890 --> 00:26:39,712
而且它在列或字符，13。

646
00:26:39,712 --> 00:26:42,670
所以，當你的文本編輯器，可以
幫助您確定的問題是。

647
00:26:42,670 --> 00:26:47,079
所以，如果我向上滾動，什麼是第32行？

648
00:26:47,079 --> 00:26:49,120
這的確是這個
這已經凸顯

649
00:26:49,120 --> 00:26:50,607
右這裡 - 未使用的變量n。

650
00:26:50,607 --> 00:26:51,440
但它不是使用。

651
00:26:51,440 --> 00:26:52,320
我使用它。

652
00:26:52,320 --> 00:26:56,110
但是編譯器的迷惑，因為
它只存在這個範圍內。

653
00:26:56,110 --> 00:26:57,727
所以我不能在這裡使用它。

654
00:26:57,727 --> 00:26:58,560
我不能在這裡使用它。

655
00:26:58,560 --> 00:27:01,320
和編譯器，因此，
甚至不關心我嘗試。

656
00:27:01,320 --> 00:27:03,940
這似乎是不使用的
在其實際範圍。

657
00:27:03,940 --> 00:27:08,854
>> 因此，我們可以通過做擴大範圍
正是我們開始with--詮釋ñ。

658
00:27:08,854 --> 00:27:11,020
即使它不
看起來優雅，也許，

659
00:27:11,020 --> 00:27:15,110
我們正在做一個額外的行
在這裡，現在它的範圍無處不在。

660
00:27:15,110 --> 00:27:15,970
因此，讓我們再試一次。

661
00:27:15,970 --> 00:27:19,040
因此，請功能之一。

662
00:27:19,040 --> 00:27:19,610
美觀大方。

663
00:27:19,610 --> 00:27:23,370
而現在，如果我，如果我運行功能
之一，讓我們給它的負10，

664
00:27:23,370 --> 00:27:27,170
負1，0，1，它確實工作。

665
00:27:27,170 --> 00:27:28,610
>> 所以在這裡另一種解決方案。

666
00:27:28,610 --> 00:27:29,280
你知道嗎？

667
00:27:29,280 --> 00:27:31,230
如果我真的摔跤呢？

668
00:27:31,230 --> 00:27:33,140
我不知道在哪裡
N為應該去。

669
00:27:33,140 --> 00:27:33,723
你知道嗎？

670
00:27:33,723 --> 00:27:39,220
我只是把它所有的
在我的文件的頂部，在這裡的方式。

671
00:27:39,220 --> 00:27:42,835
什麼該做，你覺得呢？

672
00:27:42,835 --> 00:27:43,335
是嗎？

673
00:27:43,335 --> 00:27:44,251
>> 聽眾：[聽不清]。

674
00:27:44,251 --> 00:27:47,964

675
00:27:47,964 --> 00:27:48,630
揚聲器1：是啊。

676
00:27:48,630 --> 00:27:50,560
所以，我做了它全球性的，可以這麼說。

677
00:27:50,560 --> 00:27:54,430
如果你有一個變量的外
所有的功能是允許的，

678
00:27:54,430 --> 00:27:58,780
和代碼應編譯，和n
現在將訪問不僅在獲取

679
00:27:58,780 --> 00:28:02,490
正整型，而且在main--其中
有點令人擔憂，因為有

680
00:28:02,490 --> 00:28:04,864
已經是N的主，所以更
對，在短短一個moment--

681
00:28:04,864 --> 00:28:06,530
但是這會被認為是不好的設計。

682
00:28:06,530 --> 00:28:06,910
好的。

683
00:28:06,910 --> 00:28:08,570
如果你不得不求助於
有點像，哦，我會

684
00:28:08,570 --> 00:28:10,125
只要把它在這裡，因為
代碼看起來編譯

685
00:28:10,125 --> 00:28:12,180
一般不是最好的做法。

686
00:28:12,180 --> 00:28:14,590
而你要選擇
最窄的可能範圍

687
00:28:14,590 --> 00:28:18,720
為你的變量，這將意味著
與我們最初的設計，將其

688
00:28:18,720 --> 00:28:19,920
就在這裡。

689
00:28:19,920 --> 00:28:24,400
>> 現在，順便說一句，如果你確實有
一個同名的變量在這裡，

690
00:28:24,400 --> 00:28:27,750
的C方式將處理this--
雖然這不會發生太大often--

691
00:28:27,750 --> 00:28:30,150
是，這是仍
完全沒有在這裡。

692
00:28:30,150 --> 00:28:35,000
但N的線的定義
22將跟隨全球之一。

693
00:28:35,000 --> 00:28:38,190
所以這個一會工夫內
主要和全球性

694
00:28:38,190 --> 00:28:41,670
當你將實際應用
得到肯定的INT但更多介紹

695
00:28:41,670 --> 00:28:43,890
還有一次，只是
對於那些好奇。

696
00:28:43,890 --> 00:28:45,970
>> 因此，在短期，我們解決這個問題在這裡。

697
00:28:45,970 --> 00:28:49,220
現在，讓我們梳理出另外兩件
我們來看一個代碼最後一行之前

698
00:28:49,220 --> 00:28:50,170
在這個程序。

699
00:28:50,170 --> 00:28:52,170
獲得積極的INT。

700
00:28:52,170 --> 00:28:54,450
上的左側
它的字是字INT。

701
00:28:54,450 --> 00:28:56,860
這是什麼意味著你覺得呢？

702
00:28:56,860 --> 00:28:58,900
到目前為止，我們已經多見無效。

703
00:28:58,900 --> 00:28:59,400
是嗎？

704
00:28:59,400 --> 00:29:01,810
>> 聽眾：這類型的
你問有關的變量。

705
00:29:01,810 --> 00:29:04,550
>> 揚聲器1：是啊這是類型，讓我
不是說變，但值的類型

706
00:29:04,550 --> 00:29:05,990
那我問回來。

707
00:29:05,990 --> 00:29:08,070
事實上，這是
直觀這裡，希望。

708
00:29:08,070 --> 00:29:08,200
對嗎？

709
00:29:08,200 --> 00:29:10,250
如果你想獲得一個
積極的INT，你有什麼事

710
00:29:10,250 --> 00:29:12,920
要像function--我們
從上週的志願者

711
00:29:12,920 --> 00:29:15,720
交給你回來一塊
紙，上面有一個int？

712
00:29:15,720 --> 00:29:19,190
所以，我們指定的
此功能的所謂的返回類型

713
00:29:19,190 --> 00:29:20,450
為得到正的int。

714
00:29:20,450 --> 00:29:22,990
如果我們不希望它
返回任何東西，你說無效。

715
00:29:22,990 --> 00:29:25,270
如果你希望它返回
一個字符串，你說的字符串。

716
00:29:25,270 --> 00:29:27,310
如果你希望它返回
浮子，你說的浮動。

717
00:29:27,310 --> 00:29:30,440
但是，這適用於這裡只有一個
從邏輯上講，因為我使用GET INT，

718
00:29:30,440 --> 00:29:34,130
即使我限制它
正值，是返回一個int。

719
00:29:34,130 --> 00:29:38,380
>> 那麼反過來說，這是什麼意思
這有一個在括號中的空白？

720
00:29:38,380 --> 00:29:40,130
做什麼括號
一般定義？

721
00:29:40,130 --> 00:29:40,588
是嗎？

722
00:29:40,588 --> 00:29:42,880
>> 聽眾：這意味著該功能的
沒有真正得到它。

723
00:29:42,880 --> 00:29:44,650
>> 揚聲器1：表示該功能的
實際上沒有得到什麼？

724
00:29:44,650 --> 00:29:45,430
>> 聽眾：輸入。

725
00:29:45,430 --> 00:29:46,763
>> 揚聲器1：輸入任何責任。

726
00:29:46,763 --> 00:29:49,870
因此，事實上，如果括號
在這裡你指定無效，

727
00:29:49,870 --> 00:29:51,650
這只是意味著我不希望任何輸入。

728
00:29:51,650 --> 00:29:53,269
我會解決自己的問題。

729
00:29:53,269 --> 00:29:55,810
事實上，你不必
告訴得到積極的INT什麼。

730
00:29:55,810 --> 00:29:59,630
你剛才說的，得到積極的INT，那
功能將熄滅，做它的事。

731
00:29:59,630 --> 00:30:02,970
>> 但有過一個小竅門，我已經
一直在這裡玩這個整個時間

732
00:30:02,970 --> 00:30:04,970
以確保該代碼編譯。

733
00:30:04,970 --> 00:30:09,620
請注意，int--得到正
INT void--是第27行。

734
00:30:09,620 --> 00:30:14,530
但是，對於一些看似奇怪的原因
這也是在這裡第16行。

735
00:30:14,530 --> 00:30:18,530
而剛剛好措施，我會重複
此所以這是完全一樣的。

736
00:30:18,530 --> 00:30:21,640
我已經說過原型
有點單行註釋。

737
00:30:21,640 --> 00:30:28,850
如果我刪除了，會發生什麼，以及
現在重新運行使功能1，進入。

738
00:30:28,850 --> 00:30:29,350
哎呦。

739
00:30:29,350 --> 00:30:32,527

740
00:30:32,527 --> 00:30:33,110
等一下。

741
00:30:33,110 --> 00:30:34,764
哪裡是我的卡？

742
00:30:34,764 --> 00:30:35,263
咦？

743
00:30:35,263 --> 00:30:37,969

744
00:30:37,969 --> 00:30:39,620
待機。

745
00:30:39,620 --> 00:30:41,570
讓功能1。

746
00:30:41,570 --> 00:30:42,150
在那裡，我們走了。

747
00:30:42,150 --> 00:30:42,310
確定。

748
00:30:42,310 --> 00:30:43,400
好久沒救了它正常。

749
00:30:43,400 --> 00:30:45,220
所以，我覺得有一點
這裡臭蟲，我不是

750
00:30:45,220 --> 00:30:46,636
看到此刻的選項卡名稱。

751
00:30:46,636 --> 00:30:47,940
那麼，什麼是怎麼回事？

752
00:30:47,940 --> 00:30:52,210
函數隱式聲明
得到肯定的int是在C99無效。

753
00:30:52,210 --> 00:30:53,940
如此混亂了。

754
00:30:53,940 --> 00:30:55,200
所以，這是什麼指示？

755
00:30:55,200 --> 00:30:57,287
嗯，事實證明，
C是非常愚蠢的。

756
00:30:57,287 --> 00:30:59,912
那麼，它的編程
語言，或者說編譯器。

757
00:30:59,912 --> 00:31:02,940
它只知道你有什麼
教它，它只是

758
00:31:02,940 --> 00:31:05,640
要知道的事
如果你以前教它。

759
00:31:05,640 --> 00:31:07,960
換句話說，在
主要的那一刻，我

760
00:31:07,960 --> 00:31:10,900
試圖調用一個函數
所謂得到積極int類型。

761
00:31:10,900 --> 00:31:14,120
但是，編譯器是不會
注意到，獲得積極的INT

762
00:31:14,120 --> 00:31:16,500
一直存在，直到第26行。

763
00:31:16,500 --> 00:31:21,360
還等什麼，編譯器不只是
錯誤一旦它進入第17行，

764
00:31:21,360 --> 00:31:23,700
他說隱式聲明
中得到積極int，它

765
00:31:23,700 --> 00:31:27,740
是的說法只是一種奇特的方式，我不
知道什麼得到積極int是呢。

766
00:31:27,740 --> 00:31:31,240
>> 其他語言如Java和
Python和Ruby可能向前看。

767
00:31:31,240 --> 00:31:32,240
C沒有。

768
00:31:32,240 --> 00:31:35,110
這樣一來，我們的方法解決
這是兩種方法之一。

769
00:31:35,110 --> 00:31:40,160
任一個，如果問題是，得到
積極INT一直沒有見過的，

770
00:31:40,160 --> 00:31:42,150
好了，讓我將它移動到頂部。

771
00:31:42,150 --> 00:31:43,650
這將解決這個問題。

772
00:31:43,650 --> 00:31:46,790
但是總體來說，這是
考慮更好的技術

773
00:31:46,790 --> 00:31:50,220
把你的主要功能在很
頂部，這樣一個人閱讀你的代碼

774
00:31:50,220 --> 00:31:52,710
知道該程序的功能，
因為主要是不埋沒全部

775
00:31:52,710 --> 00:31:53,960
的方式在底部或在中間。

776
00:31:53,960 --> 00:31:55,130
這是在最高層。

777
00:31:55,130 --> 00:31:56,410
這樣就不會覺得理想。

778
00:31:56,410 --> 00:31:58,326
你可以真正得到
成的情況下

779
00:31:58,326 --> 00:32:00,820
如果一個函數調用
另外，它調用了另一​​個，

780
00:32:00,820 --> 00:32:04,630
你可以成為一個問題，即沒有
可以去上面的其它，邏輯上。

781
00:32:04,630 --> 00:32:05,920
這是不可能的。

782
00:32:05,920 --> 00:32:09,290
>> 因此在上班的路上
解決辦法是只取

783
00:32:09,290 --> 00:32:13,200
函數的簽名，所以要speak--
第一行，其中它的declared--

784
00:32:13,200 --> 00:32:16,850
而只是複製，粘貼在
頂，但不與捲曲braces--

785
00:32:16,850 --> 00:32:17,980
只是一個分號。

786
00:32:17,980 --> 00:32:20,840
這就像一個小提示
是什麼來。

787
00:32:20,840 --> 00:32:26,630
而事實上，這一切的時候，我們
已經看到的東西像標準io.h

788
00:32:26,630 --> 00:32:33,040
和cs50.h，類似地，在那些點
.h文件有沒有其他的原型。

789
00:32:33,040 --> 00:32:35,250
我們會看到不久。

790
00:32:35,250 --> 00:32:39,340
>> 因此，在短期，當你有一個程序
在具有多種功能的文件

791
00:32:39,340 --> 00:32:42,300
除了主要的，你幾乎
總是要聲明它們

792
00:32:42,300 --> 00:32:45,360
只是他們的第一個方式
行，後跟一個分號，

793
00:32:45,360 --> 00:32:48,410
在該文件的頂部。

794
00:32:48,410 --> 00:32:50,460
這是一個很大的一次。

795
00:32:50,460 --> 00:32:53,130
有問題嗎？

796
00:32:53,130 --> 00:32:53,920
有問題嗎？

797
00:32:53,920 --> 00:32:54,530
好的。

798
00:32:54,530 --> 00:32:59,760
>> 因此，讓我們繼續前進，然後
為類似咳嗽。

799
00:32:59,760 --> 00:33:00,260
呵呵。

800
00:33:00,260 --> 00:33:00,570
如何裝修。

801
00:33:00,570 --> 00:33:01,220
好的。

802
00:33:01,220 --> 00:33:02,260
咳嗽。

803
00:33:02,260 --> 00:33:05,080
因此，這裡是一個C
實施方案的

804
00:33:05,080 --> 00:33:07,560
我們在做了一天
從頭開始的很乾脆只

805
00:33:07,560 --> 00:33:08,691
說咳，咳，咳。

806
00:33:08,691 --> 00:33:09,190
好的。

807
00:33:09,190 --> 00:33:11,136
有一個人說了幾句
日前，有​​是

808
00:33:11,136 --> 00:33:12,760
可以說已經清理這些代碼起來。

809
00:33:12,760 --> 00:33:12,880
好嗎？

810
00:33:12,880 --> 00:33:15,440
當你複製和
粘貼可能糟糕的設計。

811
00:33:15,440 --> 00:33:18,725
至少有一次，我們到了四，五
或20咳嗽，感覺不好的做法。

812
00:33:18,725 --> 00:33:19,850
我們只是一味地複製，粘貼。

813
00:33:19,850 --> 00:33:22,213
什麼是顯而易見的解決方案
要清理這個計劃嗎？

814
00:33:22,213 --> 00:33:23,120
>> 聽眾：循環。

815
00:33:23,120 --> 00:33:23,350
>> 揚聲器1：是啊。

816
00:33:23,350 --> 00:33:24,070
因此，使用循環。

817
00:33:24,070 --> 00:33:27,697
我們可以用一個for循環，一段時間
循環，任何數量的方法。

818
00:33:27,697 --> 00:33:29,780
事實上，這就是
我們做一個版本在這裡。

819
00:33:29,780 --> 00:33:32,250
我不是重寫它
在一個版本cough.c的

820
00:33:32,250 --> 00:33:35,170
是一個for循環中只是咳嗽。

821
00:33:35,170 --> 00:33:38,240
好了，但有一個
現在機會來樣開始

822
00:33:38,240 --> 00:33:41,630
設計這個有點像
教訓我們教剛才，

823
00:33:41,630 --> 00:33:46,190
這是this--假設，我想
創建一個名為止咳的功能，

824
00:33:46,190 --> 00:33:49,730
讓我們考慮的只是一瞬間
它是怎麼回事的樣子。

825
00:33:49,730 --> 00:33:51,900
所以，如果我想要的東西
咳，我只需要

826
00:33:51,900 --> 00:33:53,800
使用打印f顯示函數內。

827
00:33:53,800 --> 00:33:55,030
事實上我。

828
00:33:55,030 --> 00:33:56,990
而事實上，這一切
時間，任何時候你

829
00:33:56,990 --> 00:33:59,000
打印的東西
屏幕，程序員

830
00:33:59,000 --> 00:34:00,610
將調用的副作用。

831
00:34:00,610 --> 00:34:02,990
這不是我遞過
回別人的值。

832
00:34:02,990 --> 00:34:06,170
這是我採取一些行動
這可能是視覺上明顯的。

833
00:34:06,170 --> 00:34:10,672
但是，這個功能的咳嗽，它返回
任何基於它的第一線？

834
00:34:10,672 --> 00:34:12,880
沒有，因為它的返回類型
是無效的，這只是意味著

835
00:34:12,880 --> 00:34:14,250
它不是遞過來任何東西。

836
00:34:14,250 --> 00:34:16,791
它可能會做什麼
在視覺上，但它不是遞過來

837
00:34:16,791 --> 00:34:18,639
背一紙像上週。

838
00:34:18,639 --> 00:34:21,310
>> 是否需要任何投入？

839
00:34:21,310 --> 00:34:21,810
第

840
00:34:21,810 --> 00:34:23,134
所以它的無效這裡。

841
00:34:23,134 --> 00:34:25,600
所以這也是一種
過工程這一問題。

842
00:34:25,600 --> 00:34:26,099
對嗎？

843
00:34:26,099 --> 00:34:28,820
我做了計劃的更多
複雜的，多行代碼，

844
00:34:28,820 --> 00:34:31,889
我沒有作任何
多個功能，但是這

845
00:34:31,889 --> 00:34:34,210
將是一個敲門磚，
也許，對於更廣泛的

846
00:34:34,210 --> 00:34:36,830
上下文與更複雜的代碼。

847
00:34:36,830 --> 00:34:38,150
可是你知道嗎？

848
00:34:38,150 --> 00:34:42,050
我有什麼done--只是瞥一眼
這不看評論

849
00:34:42,050 --> 00:34:46,076
在file--什麼都有的最頂端
我根本在這裡完成我的咳嗽

850
00:34:46,076 --> 00:34:47,409
實現這有什麼不同？

851
00:34:47,409 --> 00:34:48,327
是啊，在後面？

852
00:34:48,327 --> 00:34:51,384
>> 聽眾：讓它這樣你就可以
有一個字符關閉。

853
00:34:51,384 --> 00:34:52,050
揚聲器1：是啊。

854
00:34:52,050 --> 00:34:53,270
所以，這種感覺挺有意思。

855
00:34:53,270 --> 00:34:53,389
對嗎？

856
00:34:53,389 --> 00:34:56,600
這就像增加一個功能，您
程序或功能，在這種情況下。

857
00:34:56,600 --> 00:34:57,830
它仍然沒有返回值。

858
00:34:57,830 --> 00:35:00,538
它可能具有一個視覺副作用，
因為它調用打印F。

859
00:35:00,538 --> 00:35:02,800
但現在我已經參數化
的功能，這

860
00:35:02,800 --> 00:35:06,470
意味著我指定取
int類型的輸入，並把它稱為N，

861
00:35:06,470 --> 00:35:08,510
但我可以把它叫做什麼，我想要的。

862
00:35:08,510 --> 00:35:11,550
事實上，它可能只是
次，以更加明確。

863
00:35:11,550 --> 00:35:13,310
然後，我可能只是在這裡改變這一點。

864
00:35:13,310 --> 00:35:16,450
但問題是，這就是我
創建一個函數，該函數的輸入。

865
00:35:16,450 --> 00:35:19,530
如果你還記得翻轉
通過在一個或者在線

866
00:35:19,530 --> 00:35:23,000
中穿行時，
第四個也是最後咳嗽例如，

867
00:35:23,000 --> 00:35:27,150
你會發現在這裡，我概括
我的代碼further--那種抽象

868
00:35:27,150 --> 00:35:27,690
它進一步。

869
00:35:27,690 --> 00:35:31,390
像咳嗽，噴嚏，都是
關於好像說什麼或做

870
00:35:31,390 --> 00:35:32,330
某種聲音。

871
00:35:32,330 --> 00:35:34,725
保存將是
相應的划痕塊。

872
00:35:34,725 --> 00:35:37,350
所以我在這個版本中那樣，
而我們只要看一眼，

873
00:35:37,350 --> 00:35:43,170
咳嗽就像是說，[咳嗽]
咳嗽，同時，打噴嚏是

874
00:35:43,170 --> 00:35:44,570
就好比說，[ACHOO]。

875
00:35:44,570 --> 00:35:46,900
所以我概括
這些實施

876
00:35:46,900 --> 00:35:48,970
現在實施
這個通用功能，

877
00:35:48,970 --> 00:35:51,490
說，這是有趣的
對於今天的目的

878
00:35:51,490 --> 00:35:54,300
不僅是因為它仍然
不具有返回類型。

879
00:35:54,300 --> 00:35:56,398
但是，有多少投入它有？

880
00:35:56,398 --> 00:35:56,981
聽眾：兩個。

881
00:35:56,981 --> 00:35:57,430
揚聲器1：兩個。

882
00:35:57,430 --> 00:35:59,263
所以，如果你想
參加兩個參數，

883
00:35:59,263 --> 00:36:00,710
只是將它們分開用逗號隔開。

884
00:36:00,710 --> 00:36:03,110
如果你要那麼
調用該函數，

885
00:36:03,110 --> 00:36:05,800
請注意，您剛才
來電說，報價，引文結束，

886
00:36:05,800 --> 00:36:09,090
第一個參數，常見的
N，第二個參數。

887
00:36:09,090 --> 00:36:12,130
所以，再一次，我們只是現在
積木，使我們實際上可以

888
00:36:12,130 --> 00:36:15,686
實現我們自己的一些功能。

889
00:36:15,686 --> 00:36:16,570
好的。

890
00:36:16,570 --> 00:36:19,690
對這些有問題嗎？

891
00:36:19,690 --> 00:36:22,400
>> 所以，現在，讓我們剝開一層，如果左右。

892
00:36:22,400 --> 00:36:24,840
和目標，最終
是下週的習題集

893
00:36:24,840 --> 00:36:27,710
將是對cryptogrophy--
藝術擾碼信息。

894
00:36:27,710 --> 00:36:30,640
和具體地，信息
將你加密或解密

895
00:36:30,640 --> 00:36:31,605
將是文字。

896
00:36:31,605 --> 00:36:33,980
所以那種的邀請
今天的問題一樣好，

897
00:36:33,980 --> 00:36:38,480
到底是怎麼回事引擎蓋下
文字超越ASCII從零一周，

898
00:36:38,480 --> 00:36:40,730
以及我們如何真正能
開始操作它？

899
00:36:40,730 --> 00:36:43,070
因此，這裡是Zamyla的名字。

900
00:36:43,070 --> 00:36:47,380
和文本中，這可能是輸入
到像的get字符串函數。

901
00:36:47,380 --> 00:36:52,540
而從現在開始，當你看到一個
串像this-- Z-A-M-Y-L-A--

902
00:36:52,540 --> 00:36:56,550
開始想到它，就好像每個
這些字符是在一個盒子的其

903
00:36:56,550 --> 00:36:57,050
自己的。

904
00:36:57,050 --> 00:36:59,460
事實上，在一個星期左右的
時間，每個這些框

905
00:36:59,460 --> 00:37:04,280
是要代表非常明確
memory--內存咬塊。

906
00:37:04,280 --> 00:37:07,050
因此，每個這些信件，
最終，將代表8位。

907
00:37:07,050 --> 00:37:10,560
我們將真正看到這是怎麼回事
在我的電腦的引擎蓋下。

908
00:37:10,560 --> 00:37:13,440
>> 但不是足夠
只是為了看Zamyla

909
00:37:13,440 --> 00:37:17,520
從這個角度，即每
這些信件是在自己的箱子。

910
00:37:17,520 --> 00:37:22,697
並很好地足夠的C語言，我們可以
訪問每個直接這些箱子。

911
00:37:22,697 --> 00:37:25,530
所以，如果你想獲得第一
信中她的名字，在C超方便

912
00:37:25,530 --> 00:37:28,410
如果你想獲得最後的
信中，超級方便以及

913
00:37:28,410 --> 00:37:30,240
用一塊新的語法。

914
00:37:30,240 --> 00:37:36,250
>> 所以我要繼續前進到CS50
IDE和開拓串零點C.

915
00:37:36,250 --> 00:37:40,270
並且在這裡此例中，有
一些新的東西怎麼回事。

916
00:37:40,270 --> 00:37:44,360
因此，先在第19行，我們已經
看到了這一點before-- GET字符串。

917
00:37:44,360 --> 00:37:49,840
因此，正如一個快速的完整性檢查，
如果有人可以提供高達口頭

918
00:37:49,840 --> 00:37:52,662
一個外行的解釋
這是怎麼回事在19行。

919
00:37:52,662 --> 00:37:55,370
像剛才把它理解
英語在CS50一個室友不

920
00:37:55,370 --> 00:37:56,416
可以理解的。

921
00:37:56,416 --> 00:37:56,916
是啊。

922
00:37:56,916 --> 00:37:59,749
>> 聽眾：讓用戶輸入
字符串，並將其存儲在一個變量s。

923
00:37:59,749 --> 00:38:01,934

924
00:38:01,934 --> 00:38:02,600
揚聲器1：好。

925
00:38:02,600 --> 00:38:05,579
有用戶輸入的字符串
並將其存儲在一個變量s。

926
00:38:05,579 --> 00:38:06,120
這是偉大的。

927
00:38:06,120 --> 00:38:08,090
因此，在右側
方面，我們調用get字符串。

928
00:38:08,090 --> 00:38:10,340
返回一個值
未獲得分配

929
00:38:10,340 --> 00:38:14,230
從右手側到左手
側入變量稱為S這

930
00:38:14,230 --> 00:38:15,950
設計用來存儲串。

931
00:38:15,950 --> 00:38:16,800
沒錯。

932
00:38:16,800 --> 00:38:20,000
>> 所以，現在22行，每
在第21行的註釋，

933
00:38:20,000 --> 00:38:22,780
顯然打印出字符串
每行一個字符。

934
00:38:22,780 --> 00:38:23,740
但如何？

935
00:38:23,740 --> 00:38:27,040
所以首先，我們初始化我為0。

936
00:38:27,040 --> 00:38:31,061
然後我們怎麼來
的Zamyla名結束了嗎？

937
00:38:31,061 --> 00:38:32,810
那麼，在年底
Zamyla的名字，我可以

938
00:38:32,810 --> 00:38:38,151
手動輸入的最後一個字符
她的名字在某種程度上，或者它的數量。

939
00:38:38,151 --> 00:38:38,650
對嗎？

940
00:38:38,650 --> 00:38:43,500
如果我們回到這裡 -  Z-A-M-L--
Y型L-A--所以我可以輸入內容。

941
00:38:43,500 --> 00:38:47,340
什麼是指數
Zamyla的最後一封信？

942
00:38:47,340 --> 00:38:52,517
如果這是0--講像
programmer-- 0，1，2，3，4，5，

943
00:38:52,517 --> 00:38:56,570
我heard--所以事實上，最後一個字母
在Zamyla的名字是第六，

944
00:38:56,570 --> 00:38:58,890
但如果我們從0數，
這將是5號。

945
00:38:58,890 --> 00:39:01,320
所以記住這一點在這裡。

946
00:39:01,320 --> 00:39:04,929
>> 原來有一個函數
C中調用strlen的，並在當天回

947
00:39:04,929 --> 00:39:06,720
並以這一天還在，
很多程序員

948
00:39:06,720 --> 00:39:09,524
選擇同步的名稱為自己
聽起來詞功能

949
00:39:09,524 --> 00:39:10,440
他們正試圖說。

950
00:39:10,440 --> 00:39:12,590
所以strlen的是字符串的長度。

951
00:39:12,590 --> 00:39:18,168
所以會是什麼的字符串長度
回歸時Zamyla是輸入？

952
00:39:18,168 --> 00:39:19,569
>> 聽眾：五。

953
00:39:19,569 --> 00:39:22,090
>> 揚聲器1：Z-A-M-Y-L。六。

954
00:39:22,090 --> 00:39:22,590
對嗎？

955
00:39:22,590 --> 00:39:23,940
什麼是對Zamyla姓名的長度？

956
00:39:23,940 --> 00:39:24,440
對嗎？

957
00:39:24,440 --> 00:39:26,240
而就在現實中，六個字母。

958
00:39:26,240 --> 00:39:26,740
對嗎？

959
00:39:26,740 --> 00:39:28,940
所以，這是什麼意思為我們的循環？

960
00:39:28,940 --> 00:39:32,130
我們打算從去
0多達六個，這

961
00:39:32,130 --> 00:39:33,650
將會給我們五次迭代。

962
00:39:33,650 --> 00:39:34,890
我們該怎麼辦在每次迭代？

963
00:39:34,890 --> 00:39:36,870
好了，百分之C，人
日前猜到了，

964
00:39:36,870 --> 00:39:38,710
是指一個佔位符是什麼？

965
00:39:38,710 --> 00:39:39,335
>> 聽眾：字符。

966
00:39:39,335 --> 00:39:40,293
揚聲器1：只是一個字符。

967
00:39:40,293 --> 00:39:42,877
因此，一個單一的character--不
多個字符，像一個字符串。

968
00:39:42,877 --> 00:39:45,251
然後這裡的新生產線
我們已經得到了打印輸出。

969
00:39:45,251 --> 00:39:46,580
然後這裡的新語法。

970
00:39:46,580 --> 00:39:51,130
如果你想打印出的第i個
字符字符串s，可以這麼說，

971
00:39:51,130 --> 00:39:54,060
你可以簡單地說，
帶S的命名，

972
00:39:54,060 --> 00:39:58,230
然後打開括號，然後
然後關閉括號，與我

973
00:39:58,230 --> 00:39:58,780
中間。

974
00:39:58,780 --> 00:40:01,430
而且它是一種很好的在
那種它看起來像一個正方形

975
00:40:01,430 --> 00:40:06,210
就像正方形中Zamyla的
文字上的圖片存在。

976
00:40:06,210 --> 00:40:09,970
>> 所以，如果我實際運行這個
現在，讓我們看看會發生什麼。

977
00:40:09,970 --> 00:40:15,190
使串0點斜線
字符串0，然後我

978
00:40:15,190 --> 00:40:16,720
要在Zamyla的名字輸入。

979
00:40:16,720 --> 00:40:19,428
有沒有提示，因為我沒有
使用打印女，但是這很好。

980
00:40:19,428 --> 00:40:20,660
我知道該怎麼做。

981
00:40:20,660 --> 00:40:23,240
事實上，它打印出
Zamyla的名字，每行一個。

982
00:40:23,240 --> 00:40:25,760
>> 現在，讓我們有點魯莽。

983
00:40:25,760 --> 00:40:28,461
假設我不知道
有關strlen的，我算了一下，

984
00:40:28,461 --> 00:40:31,460
所有的權利，沒有人將有一個
名稱大於像50個字符。

985
00:40:31,460 --> 00:40:36,360
讓我們繼續前進，重新編譯這
並重新運行它，然後鍵入Zamyla

986
00:40:36,360 --> 00:40:37,160
再次。

987
00:40:37,160 --> 00:40:40,850
從邏輯上講，什麼是
程序將嘗試打印？

988
00:40:40,850 --> 00:40:49,545
Z-A-M-Y-L-A然後像45
未知字節的內存。

989
00:40:49,545 --> 00:40:51,670
事實上，我們會回來的
這種想法的記憶。

990
00:40:51,670 --> 00:40:54,180
但是，僅僅從邏輯上講，如果
Zamyla的名字是這樣長，

991
00:40:54,180 --> 00:40:56,450
按照圖片
在這裡，我們在說什麼

992
00:40:56,450 --> 00:40:59,810
就是繼續打印，保留打印，保存
印刷，保持印花，保持印花，

993
00:40:59,810 --> 00:41:03,781
一路第50字符，
這誰知道會發生什麼。

994
00:41:03,781 --> 00:41:05,030
因此，讓我們實際來看看。

995
00:41:05,030 --> 00:41:06,720
讓我們輸入Zamyla。

996
00:41:06,720 --> 00:41:07,250
有趣的。

997
00:41:07,250 --> 00:41:08,190
我們很幸運。

998
00:41:08,190 --> 00:41:09,700
只是一大堆的空白。

999
00:41:09,700 --> 00:41:09,930
呵呵。

1000
00:41:09,930 --> 00:41:11,120
還有一個時髦的人物。

1001
00:41:11,120 --> 00:41:14,577
它看起來有點像一個奇怪的問題
標記存在，但有Zamyla的名字。

1002
00:41:14,577 --> 00:41:15,660
讓我們真的很魯莽。

1003
00:41:15,660 --> 00:41:20,000
怎麼樣，我們打印出500
塊到未知？

1004
00:41:20,000 --> 00:41:24,380
讓我們繼續前進，使這個
以及，然後重新運行。

1005
00:41:24,380 --> 00:41:27,980
而且，我們全屏幕，因為
我們需要看到更多的空間。

1006
00:41:27,980 --> 00:41:30,460
Zamyla。

1007
00:41:30,460 --> 00:41:31,830
又是幸運的。

1008
00:41:31,830 --> 00:41:33,070
>> 敢我們得到更加肆無忌憚？

1009
00:41:33,070 --> 00:41:36,070
讓我們更加肆無忌憚。

1010
00:41:36,070 --> 00:41:39,350
50000字。

1011
00:41:39,350 --> 00:41:41,390
這是最肯定不是一個好主意。

1012
00:41:41,390 --> 00:41:41,890
好的。

1013
00:41:41,890 --> 00:41:42,990
使串0。

1014
00:41:42,990 --> 00:41:44,720
這將是我們最後的演示。

1015
00:41:44,720 --> 00:41:47,261
Zamyla。

1016
00:41:47,261 --> 00:41:48,632
唉。

1017
00:41:48,632 --> 00:41:50,010
唉。

1018
00:41:50,010 --> 00:41:50,680
確定。

1019
00:41:50,680 --> 00:41:54,407
所以，我的記憶真的是空的，現在，
這是一種真正方便。

1020
00:41:54,407 --> 00:41:55,990
我試圖讓用於：沒事。

1021
00:41:55,990 --> 00:41:57,614
而現在我只是要得到魯莽。

1022
00:41:57,614 --> 00:41:58,570
500,000。

1023
00:41:58,570 --> 00:42:03,860
Make--讓全屏它。

1024
00:42:03,860 --> 00:42:04,990
輸入。

1025
00:42:04,990 --> 00:42:05,490
Zamyla。

1026
00:42:05,490 --> 00:42:12,050

1027
00:42:12,050 --> 00:42:13,390
在那裡，我們走了。

1028
00:42:13,390 --> 00:42:15,610
我不知道那是什麼
是的，但它聽起來很糟糕。

1029
00:42:15,610 --> 00:42:16,110
好的。

1030
00:42:16,110 --> 00:42:20,322
而事實上，很快，如果你是中
在辦公時間幸運的少數人

1031
00:42:20,322 --> 00:42:22,780
而在問題設置一個，你
很可能會遇到這樣的。

1032
00:42:22,780 --> 00:42:25,490
段錯誤實際上做
具有良好定義的含義。

1033
00:42:25,490 --> 00:42:28,450
這意味著一些錯誤
有關的存儲器段。

1034
00:42:28,450 --> 00:42:30,490
而在通俗地說，
這意味著我們感動

1035
00:42:30,490 --> 00:42:34,780
memory--我們使用的RAM在我的電腦
我不應該有訪問。

1036
00:42:34,780 --> 00:42:37,050
這就是既是
功能強大，也很危險

1037
00:42:37,050 --> 00:42:39,910
關於C實際上是你
自由訪問

1038
00:42:39,910 --> 00:42:45,910
你的程序的內存的全部
或字節或RAM，更具體。

1039
00:42:45,910 --> 00:42:49,510
>> 因此，即使Zamyla的名字
只有六個字符，

1040
00:42:49,510 --> 00:42:51,450
我還可以去任何地方
在內存我想要的。

1041
00:42:51,450 --> 00:42:53,491
而作為順便說一句，如果你
讀過一些文章

1042
00:42:53,491 --> 00:42:55,610
在一些多年
服務器或某些節目

1043
00:42:55,610 --> 00:42:58,654
盜取或砍死那
東西冤大頭

1044
00:42:58,654 --> 00:43:00,820
所謂的緩衝區溢出
利用這一點，我們會真正

1045
00:43:00,820 --> 00:43:04,970
談談在幾個星期，這是
通常是指以某種方式欺騙

1046
00:43:04,970 --> 00:43:09,090
一台電腦變成進展順利
以外的存儲器的邊界

1047
00:43:09,090 --> 00:43:11,410
它應該有，與
找到的東西多汁

1048
00:43:11,410 --> 00:43:13,530
在memory--一個
密碼，也許，一種方法

1049
00:43:13,530 --> 00:43:16,990
繞過一些序列號的
檢查，或者只是一般都能

1050
00:43:16,990 --> 00:43:20,360
誘騙計算機正在執行
代碼並不打算。

1051
00:43:20,360 --> 00:43:22,360
但是，讓我們回過頭來
現實只是一瞬間

1052
00:43:22,360 --> 00:43:24,550
其中，該計劃是
與strlen的實施，

1053
00:43:24,550 --> 00:43:26,110
並引入一件事在這裡。

1054
00:43:26,110 --> 00:43:30,030
什麼是這些頂級三條線之間新的？

1055
00:43:30,030 --> 00:43:30,910
>> 因此，串點小時。

1056
00:43:30,910 --> 00:43:35,490
原來有這個庫被稱為
串點H，或字符串庫，

1057
00:43:35,490 --> 00:43:38,490
它的頭文件，可以這麼說，
是串點h上給我

1058
00:43:38,490 --> 00:43:40,860
訪問該strlen函數。

1059
00:43:40,860 --> 00:43:43,841
如果我省略，編譯器
要我大聲喊叫以某種形式。

1060
00:43:43,841 --> 00:43:44,590
但是，你知道嗎？

1061
00:43:44,590 --> 00:43:46,090
現在讓我們真的很細緻入微。

1062
00:43:46,090 --> 00:43:50,820
在第22行，有什麼樣的
的inefficient--設計糟糕，

1063
00:43:50,820 --> 00:43:53,990
arguably--關於這行代碼。

1064
00:43:53,990 --> 00:43:56,280
回想一下如何
for循環中實現

1065
00:43:56,280 --> 00:44:00,140
什麼步驟再次發生，
再次again--初始化，

1066
00:44:00,140 --> 00:44:04,110
的情況下，代碼
得到執行，那麼增量

1067
00:44:04,110 --> 00:44:07,880
或變更，則條件，
然後該代碼，則改變，那麼

1068
00:44:07,880 --> 00:44:11,280
的條件，則代碼，
然後將改變，等等。

1069
00:44:11,280 --> 00:44:15,320
那麼，什麼可能有點
令人擔憂的還是在這裡做得不好？

1070
00:44:15,320 --> 00:44:16,387
是啊，在藍色。

1071
00:44:16,387 --> 00:44:18,220
聽眾：strlen的是
所謂的很多很多次。

1072
00:44:18,220 --> 00:44:20,654

1073
00:44:20,654 --> 00:44:21,320
揚聲器1：是啊。

1074
00:44:21,320 --> 00:44:23,700
所以strlen的被稱為
很多次，但什麼是

1075
00:44:23,700 --> 00:44:27,113
的Zamyla的名字長度
第一次循環執行？

1076
00:44:27,113 --> 00:44:27,860
>> 聽眾：六。

1077
00:44:27,860 --> 00:44:28,110
>> 揚聲器1：六。

1078
00:44:28,110 --> 00:44:30,976
那麼，什麼是她的名字長度
代碼執行第二次？

1079
00:44:30,976 --> 00:44:31,432
>> 聽眾：六。

1080
00:44:31,432 --> 00:44:31,890
>> 揚聲器1：所有權利。

1081
00:44:31,890 --> 00:44:32,720
它仍然是六人。

1082
00:44:32,720 --> 00:44:33,220
對嗎？

1083
00:44:33,220 --> 00:44:35,260
Zarla的名字還沒有
改變，即使我在尋找

1084
00:44:35,260 --> 00:44:38,240
在她的名字的字母的一部分。

1085
00:44:38,240 --> 00:44:41,349
這樣一來，其實我是有效的
問這個問題，什麼是

1086
00:44:41,349 --> 00:44:44,640
Zamyla的長度，有什麼長度
Zamyla的，什麼是Zamyla的長度，

1087
00:44:44,640 --> 00:44:47,990
六個獨立倍，或
七連，僅僅是愚蠢的，

1088
00:44:47,990 --> 00:44:50,390
因為這是不變的答案。

1089
00:44:50,390 --> 00:44:53,550
所以，我居然可以
做的是this--在串的一個

1090
00:44:53,550 --> 00:44:55,680
我有一個稍微好一些的版本在這裡。

1091
00:44:55,680 --> 00:45:00,110
那裡 -  whoops--線二我有
一個稍微更好的版本，其中

1092
00:45:00,110 --> 00:45:05,010
我做this--，而不是僅僅
我初始化為0，我也用逗號

1093
00:45:05,010 --> 00:45:07,990
聲明一個叫做第二個變量
N--我沒有再說INT。

1094
00:45:07,990 --> 00:45:09,220
我不應該，事實上。

1095
00:45:09,220 --> 00:45:10,380
但是我要說ñ。

1096
00:45:10,380 --> 00:45:13,610
然後我初始化n至
n的strlen的，所以現在

1097
00:45:13,610 --> 00:45:17,110
多少次的strlen
共得到執行？

1098
00:45:17,110 --> 00:45:17,610
只需一次。

1099
00:45:17,610 --> 00:45:20,257
所以，這就是我們所說的
早期有關更好的設計。

1100
00:45:20,257 --> 00:45:23,090
實際上，一旦你的代碼是正確的，
回去和思考通過，

1101
00:45:23,090 --> 00:45:26,820
我是使用盡可能少
存儲器或幾秒鐘

1102
00:45:26,820 --> 00:45:30,409
電腦的時間或毫秒為單位
可以實現一些問題？

1103
00:45:30,409 --> 00:45:32,200
而且我要滾動
並只提

1104
00:45:32,200 --> 00:45:34,283
還有就是這個提
在這個版本空的，

1105
00:45:34,283 --> 00:45:36,390
但我們會回來的，不久。

1106
00:45:36,390 --> 00:45:41,010
因為現在，讓我們來看看
在其中，這會引導我們。

1107
00:45:41,010 --> 00:45:44,110
所以之一，事實證明，
現在我們有能力

1108
00:45:44,110 --> 00:45:46,860
看單個字符，
我們可以利用的東西

1109
00:45:46,860 --> 00:45:50,807
從0星期是非常神秘和
那種無趣的時間。

1110
00:45:50,807 --> 00:45:53,390
但現在，尤其是當我們
我在一周密碼學，

1111
00:45:53,390 --> 00:45:54,820
這將是非常強大的。

1112
00:45:54,820 --> 00:45:57,450
事實證明，一些
數據types--整型和浮點

1113
00:45:57,450 --> 00:46:00,300
和字符和字符串和
其他things--他們中的一些

1114
00:46:00,300 --> 00:46:02,800
可以很容易地轉化為另一種。

1115
00:46:02,800 --> 00:46:05,840
>> 例如，當我們談到
有關ASCII一段時間ago--這裡

1116
00:46:05,840 --> 00:46:07,796
資本字母A
通過併購，點，點，

1117
00:46:07,796 --> 00:46:12,530
dot--我們說有一個映射
這些字母和數字之間。

1118
00:46:12,530 --> 00:46:14,970
而事實上，它也適用
小寫字母以及。

1119
00:46:14,970 --> 00:46:17,470
小寫a是97，資本為65。

1120
00:46:17,470 --> 00:46:20,860
而且有一些在ASCII碼，
這僅僅是這種映射

1121
00:46:20,860 --> 00:46:23,240
系統的所有這些其他字母。

1122
00:46:23,240 --> 00:46:25,030
那麼，是什麼意思呢？

1123
00:46:25,030 --> 00:46:28,390
好了，我要繼續前進，開
達實快一些所謂

1124
00:46:28,390 --> 00:46:31,240
ASCII 0，其中大部分是註釋。

1125
00:46:31,240 --> 00:46:33,860
並再次在網上可以隨時
翻閱了意見。

1126
00:46:33,860 --> 00:46:36,180
>> 看一看什麼
這是要幹什麼。

1127
00:46:36,180 --> 00:46:38,410
所以它有一個主要功能。

1128
00:46:38,410 --> 00:46:41,490
我硬編碼的數字只為
現在，因為我知道我在做什麼。

1129
00:46:41,490 --> 00:46:42,950
我知道我想在這裡看到。

1130
00:46:42,950 --> 00:46:45,220
而且我初始化我65歲。

1131
00:46:45,220 --> 00:46:48,490
而且我計數
通過26個字母總額。

1132
00:46:48,490 --> 00:46:52,990
而我怎麼來
一次打印一行

1133
00:46:52,990 --> 00:46:54,930
如果你能理解
這個突出的線路？

1134
00:46:54,930 --> 00:46:55,970
什麼被印？

1135
00:46:55,970 --> 00:46:56,797
是啊。

1136
00:46:56,797 --> 00:46:57,264
>> 聽眾：你要
打印的信

1137
00:46:57,264 --> 00:46:59,805
對應的地圖
信中值和整數值？

1138
00:46:59,805 --> 00:47:01,199

1139
00:47:01,199 --> 00:47:01,990
揚聲器1：沒錯。

1140
00:47:01,990 --> 00:47:04,740
我要打印的信
對應於該整數值，

1141
00:47:04,740 --> 00:47:06,131
反之，如下所示。

1142
00:47:06,131 --> 00:47:08,880
嗯，這，有人早些時候說，
只是一個佔位符字符。

1143
00:47:08,880 --> 00:47:09,490
它仍然是。

1144
00:47:09,490 --> 00:47:12,280
當然，這是一個佔位符
對於int--不是一個新的生產線。

1145
00:47:12,280 --> 00:47:18,140
現在發現，我的第一個值
我堵在該佔位符

1146
00:47:18,140 --> 00:47:22,320
不只是我。我是說，
括號，字符我，

1147
00:47:22,320 --> 00:47:26,700
其中括號字符是
告訴編譯器，把我

1148
00:47:26,700 --> 00:47:28,490
不是作為它是什麼，這是一個數字。

1149
00:47:28,490 --> 00:47:30,490
把它作為一個實際的字符。

1150
00:47:30,490 --> 00:47:34,490
而第二個值我堵
in--我 - 應該只是一個數字。

1151
00:47:34,490 --> 00:47:38,140
>> 所以，如果我編譯這個program--
所以這是使ASCII 0，

1152
00:47:38,140 --> 00:47:41,720
點斜線ASCII 0--我只是得到
這個方便的小圖表

1153
00:47:41,720 --> 00:47:44,950
我顯示了所有可能的
映射，而不必認為它

1154
00:47:44,950 --> 00:47:46,450
通過或數字出來我自己。

1155
00:47:46,450 --> 00:47:48,783
而且我還打印出，
注意小寫字母，

1156
00:47:48,783 --> 00:47:51,410
因為幾行後，我
同時打印出這個映射

1157
00:47:51,410 --> 00:47:53,737
還有，這僅僅是
說，一旦你明白

1158
00:47:53,737 --> 00:47:55,570
下面是怎麼回事
引擎蓋，你能

1159
00:47:55,570 --> 00:47:57,111
自動來回轉換。

1160
00:47:57,111 --> 00:48:00,160
而事實上，如果哪
做過這個在小學

1161
00:48:00,160 --> 00:48:03,490
或聽說過有人
神話般服用記

1162
00:48:03,490 --> 00:48:05,620
並將其傳遞給他的
或她在課堂上的朋友，

1163
00:48:05,620 --> 00:48:08,300
但你炒的
按字母如A變成B，

1164
00:48:08,300 --> 00:48:11,240
和B變成C，或某事
複雜多了，好了，

1165
00:48:11,240 --> 00:48:13,410
你會怎麼去
實現了作為一個孩子？

1166
00:48:13,410 --> 00:48:16,340
嗯，你剛才那種知道
A成為B，B變成C，

1167
00:48:16,340 --> 00:48:19,700
但在數學上，
什麼那小子做什麼？

1168
00:48:19,700 --> 00:48:22,050
什麼是你增加了每個字母？

1169
00:48:22,050 --> 00:48:23,340
實際上，1。

1170
00:48:23,340 --> 00:48:27,740
>> 因此，當你改變A到B，這是
有點像改變65到66，

1171
00:48:27,740 --> 00:48:29,590
其中數學意味著只需添加1。

1172
00:48:29,590 --> 00:48:33,300
所以，如果你要實現
那小小的欺騙手段

1173
00:48:33,300 --> 00:48:36,380
在代碼中你的老師，你
可能會做的正是剛剛

1174
00:48:36,380 --> 00:48:38,552
通過增加一個字母在一起。

1175
00:48:38,552 --> 00:48:40,260
那麼過不了多久，我們
要看到我們如何

1176
00:48:40,260 --> 00:48:43,300
可以利用這一點來實際
真正的加密和解密

1177
00:48:43,300 --> 00:48:43,991
信息。

1178
00:48:43,991 --> 00:48:47,240
在此期間，要知道我們已經開始
引進一對夫婦的其他圖書館

1179
00:48:47,240 --> 00:48:48,990
一個今天這裡 - 字符串。

1180
00:48:48,990 --> 00:48:51,180
而一個非常有用的網站
希望你會發現

1181
00:48:51,180 --> 00:48:55,010
被稱為reference.cs50.net，這
教學人員都放在一起，

1182
00:48:55,010 --> 00:48:57,510
因此，如果你想
仰望strlen的是如何工作，

1183
00:48:57,510 --> 00:48:59,300
你可以開始輸入
函數的名字，

1184
00:48:59,300 --> 00:49:02,890
點擊strlen的存在，然後
一個不太舒服的解釋

1185
00:49:02,890 --> 00:49:03,700
將要出現。

1186
00:49:03,700 --> 00:49:06,880
或者，如果你想正式
基於Linux的說明中，

1187
00:49:06,880 --> 00:49:08,945
您可以點擊更舒適
在右上角，它

1188
00:49:08,945 --> 00:49:12,070
將呈現相同的信息，
但在更複雜的條件。

1189
00:49:12,070 --> 00:49:15,070
這是一個有用的資源
實際上知道什麼都做。

1190
00:49:15,070 --> 00:49:17,320
>> 我們要下一次
看看阿華田

1191
00:49:17,320 --> 00:49:20,070
多，自薦
密碼學世界。

1192
00:49:20,070 --> 00:49:21,930
在此之前，我們會看到
您在本週晚些時候。

1193
00:49:21,930 --> 00:49:23,390
而現在，科爾頓奧格登。

1194
00:49:23,390 --> 00:49:26,730
星期三見。

1195
00:49:26,730 --> 00:49:30,216
>> [音樂播放]

1196
00:49:30,216 --> 00:49:33,702
>> [音樂播放]

1197
00:49:33,702 --> 00:49:38,682

1198
00:49:38,682 --> 00:49:42,200
>> 揚聲器1：什麼
[嗶]你在幹什麼？

1199
00:49:42,200 --> 00:49:45,720
>> 揚聲器1：我吃我的甜點？

1200
00:49:45,720 --> 00:49:47,160
你怎麼吃？

1201
00:49:47,160 --> 00:49:47,860
用你的手？

1202
00:49:47,860 --> 00:49:54,050

1203
00:49:54,050 --> 00:49:57,940
>> [音樂播放]

1204
00:49:57,940 --> 00:50:03,453