1
00:00:00,000 --> 00:00:10,920
>> [音樂播放]

2
00:00:10,920 --> 00:00:14,680
>> 大衛·馬蘭：所有的權利，
歡迎回到CS50。

3
00:00:14,680 --> 00:00:16,500
這是兩個星期的開始。

4
00:00:16,500 --> 00:00:18,940
從我們的一個字
朋友們在校園 - 

5
00:00:18,940 --> 00:00:22,620
如果你有興趣，可能的話，無論是
現在或將來的某個長期

6
00:00:22,620 --> 00:00:25,670
甚至，一旦更舒適，教學
初中學生一點點

7
00:00:25,670 --> 00:00:27,680
計算機科學的東西，
做頭到該網址。

8
00:00:27,680 --> 00:00:32,360
他們現在特別需要
教師，特別是如果你有

9
00:00:32,360 --> 00:00:34,700
有一些接觸計算機科學。

10
00:00:34,700 --> 00:00:38,060
>> 所以記得，最後一次，我們引入
有一些數據類型在C中，

11
00:00:38,060 --> 00:00:40,590
您可能已經開始讓你的
這些迄今的手臟

12
00:00:40,590 --> 00:00:41,940
設置問題之一。

13
00:00:41,940 --> 00:00:43,230
我們有一個字符。

14
00:00:43,230 --> 00:00:49,100
因此，在有些技術方面，
你今天所知道的是一個char？

15
00:00:49,100 --> 00:00:51,050
>> 所以這是一個字符，但我們的
現在更精確。

16
00:00:51,050 --> 00:00:53,735
字符是什麼意思
或個別字符？

17
00:00:53,735 --> 00:00:56,700

18
00:00:56,700 --> 00:00:59,500
非數字字符 - 

19
00:00:59,500 --> 00:01:00,670
不一定。

20
00:01:00,670 --> 00:01:04,580
事實證明，即使是數字，甚至
標點符號和字母

21
00:01:04,580 --> 00:01:06,980
與此數據表示
類型稱為一個char。

22
00:01:06,980 --> 00:01:09,440
所以它不一定是按字母順序排列。

23
00:01:09,440 --> 00:01:11,100
是嗎？

24
00:01:11,100 --> 00:01:12,275
>> 所以這是一個ASCII字符。

25
00:01:12,275 --> 00:01:15,510
所以，如果你想返回到零週，當
我們有我們的志願者字節

26
00:01:15,510 --> 00:01:19,150
要么上來，握住他們的手
不是全部，他們所代表的位。

27
00:01:19,150 --> 00:01:22,450
但合八為一組，
他們代表一個字節。

28
00:01:22,450 --> 00:01:26,030
我們介紹了概念ASCII
在這次演講中，這簡直是一個

29
00:01:26,030 --> 00:01:28,170
數字和字母之間的映射。

30
00:01:28,170 --> 00:01:32,010
和ASCII用途，因為這些人
暗示，八位

31
00:01:32,010 --> 00:01:33,660
來表示一個字符。

32
00:01:33,660 --> 00:01:36,890
>> 因此，如果8位
每次取兩個值之一 - 

33
00:01:36,890 --> 00:01:38,010
零次或一次 - 

34
00:01:38,010 --> 00:01:40,280
這意味著有兩種可能性
這個人 - 

35
00:01:40,280 --> 00:01:41,230
零次或一次 - 

36
00:01:41,230 --> 00:01:44,070
這個人，這兩個
人，為這一個兩個。

37
00:01:44,070 --> 00:01:47,450
因此，兩次共兩次
兩次兩兩三次 - 

38
00:01:47,450 --> 00:01:49,700
所以兩個總第八。

39
00:01:49,700 --> 00:01:54,320
所以這是一個總的字符數
256種可能，你可以

40
00:01:54,320 --> 00:01:55,750
代表與8位。

41
00:01:55,750 --> 00:01:59,210
>> 現在，那些你們誰講亞洲
語言可能知道，有更多的

42
00:01:59,210 --> 00:02:02,620
不僅僅是在世界上的字符
AS和BS和CS和DS。

43
00:02:02,620 --> 00:02:06,130
事實上，ASCII不足夠
很多世界的語言。

44
00:02:06,130 --> 00:02:07,760
但另一個時間。

45
00:02:07,760 --> 00:02:11,240
現在，知道如果你想在C
代表一個字母，一塊

46
00:02:11,240 --> 00:02:15,780
標點符號，或只是一些字符
在自然界中，我們使用一個字符。

47
00:02:15,780 --> 00:02:18,240
它是一個字節或8位。

48
00:02:18,240 --> 00:02:19,690
>> 一個int怎麼樣？

49
00:02:19,690 --> 00:02:20,780
嗯，一個int是一個整數。

50
00:02:20,780 --> 00:02:23,175
多少位，如果你還記得，
通常是一個整數嗎？

51
00:02:23,175 --> 00:02:25,930

52
00:02:25,930 --> 00:02:27,512
任何人都召回？

53
00:02:27,512 --> 00:02:29,600
因此，它是典型的32。

54
00:02:29,600 --> 00:02:32,120
實際上，它取決於在計算機上
你使用。

55
00:02:32,120 --> 00:02:35,770
但在家電，並在很多
計算機，它是32位或4個

56
00:02:35,770 --> 00:02:37,140
字節 - 八倍四個。

57
00:02:37,140 --> 00:02:39,790
和整數只是用於存儲
數字，要么是負，

58
00:02:39,790 --> 00:02:41,610
陽性，或零。

59
00:02:41,610 --> 00:02:45,250
>> 如果你只得到了32位，你
關心正數，

60
00:02:45,250 --> 00:02:48,960
有人看球多少可能
整數，是一台計算機可以表示從

61
00:02:48,960 --> 00:02:51,820
零，就到了嗎？

62
00:02:51,820 --> 00:02:56,130
因此這將是2到32，這
大約40億。

63
00:02:56,130 --> 00:02:59,720
因此，這些權力的兩個將要
在計算機科學中反复出現的主題。

64
00:02:59,720 --> 00:03:03,930
正如我們所看到的，他們很方便
即使是不太

65
00:03:03,930 --> 00:03:05,790
容易做數學題，在一個人的頭上。

66
00:03:05,790 --> 00:03:07,000
>> 所以我們會說大約40億。

67
00:03:07,000 --> 00:03:08,620
現在，很長很長 - 

68
00:03:08,620 --> 00:03:09,770
你可以猜測的那種。

69
00:03:09,770 --> 00:03:10,480
它長於一個int。

70
00:03:10,480 --> 00:03:12,440
多少位？

71
00:03:12,440 --> 00:03:14,250
因此，64位或8個字節。

72
00:03:14,250 --> 00:03:17,480
這只是意味著你甚至可以代表
更大的數字，更大的積極或

73
00:03:17,480 --> 00:03:19,160
較大的負數。

74
00:03:19,160 --> 00:03:20,060
>> 又有怎樣的浮動？

75
00:03:20,060 --> 00:03:22,260
這是一個浮點
32位的值。

76
00:03:22,260 --> 00:03:25,180
這僅僅是一個實數，東西
小數點。

77
00:03:25,180 --> 00:03:30,100
但是，如果你的地方，而不是需要更多的
小數點後或者你想

78
00:03:30,100 --> 00:03:33,720
一些代表一個更大的數目
分數後，你可以使用一個

79
00:03:33,720 --> 00:03:36,260
雙，這是64位。

80
00:03:36,260 --> 00:03:38,240
>> 但有一個有趣的
這裡的外賣。

81
00:03:38,240 --> 00:03:42,890
是有限的32位，所以，如果整數
64即使是有限的長期多頭

82
00:03:42,890 --> 00:03:46,180
位，那種引出了一個問題，
如果你真的要算

83
00:03:46,180 --> 00:03:48,790
高於4億元為int？

84
00:03:48,790 --> 00:03:50,330
嗯，你只是用很長很長。

85
00:03:50,330 --> 00:03:54,200
但是，如果你要算高
超過兩至第64個，給予或採取？

86
00:03:54,200 --> 00:03:55,810
>> 現在，這是一個龐大的數字。

87
00:03:55,810 --> 00:03:59,250
但最終，你實際上可能
關心這些類型的值，

88
00:03:59,250 --> 00:04:03,070
尤其是如果你正在使用的數據庫
並開始收集很多很多

89
00:04:03,070 --> 00:04:06,190
和大量數據，並且分配唯一的
編號，每一塊的數據。

90
00:04:06,190 --> 00:04:07,430
因此，我們有一個問題。

91
00:04:07,430 --> 00:04:10,700
同樣，浮點運算
價值 - 花車或雙打 - 

92
00:04:10,700 --> 00:04:14,290
如果你只得到了有限數量的
位，你總共有多少個數字

93
00:04:14,290 --> 00:04:16,980
可能代表什麼呢？

94
00:04:16,980 --> 00:04:19,540
>> 嗯，這是不太清楚，當你
涉及小數點。

95
00:04:19,540 --> 00:04:20,899
但它肯定是有限的。

96
00:04:20,899 --> 00:04:24,390
如果你有一個有限的比特數，
有限數量的人類，一個有限的

97
00:04:24,390 --> 00:04:27,350
燈泡的數目，你一定可以
只能表示有限數量的

98
00:04:27,350 --> 00:04:28,510
浮點值。

99
00:04:28,510 --> 00:04:33,170
但究竟有多少真正的數字
是他們在世界上？

100
00:04:33,170 --> 00:04:33,680
有一個無限。

101
00:04:33,680 --> 00:04:37,280
所以這是樣的一個問題，因為我們
不具有無限長的

102
00:04:37,280 --> 00:04:39,970
我們的電腦內的內存或RAM。

103
00:04:39,970 --> 00:04:41,780
所以一些具有挑戰性的事情都可能發生。

104
00:04:41,780 --> 00:04:43,900
>> 所以，讓我們繼續前進，並嘗試
這裡表達。

105
00:04:43,900 --> 00:04:46,240
讓我去進取，不斷開拓gedit的。

106
00:04:46,240 --> 00:04:50,360
我要繼續前進，並保存文件
被稱為“floats0.c”剛需

107
00:04:50,360 --> 00:04:54,630
一致的，例如，即
可在網上，如果你想。

108
00:04:54,630 --> 00:04:58,080
而且我要繼續前進，
它定義如下 - 

109
00:04:58,080 --> 00:05:01,540
我要繼續前進，並說，詮釋
主要無效的，因為我們經常做的。

110
00:05:01,540 --> 00:05:07,190
>> 然後在這個方案中，我要
申報自己的持股量，所以32位

111
00:05:07,190 --> 00:05:09,700
變量稱為F，任意。

112
00:05:09,700 --> 00:05:13,910
然後我要存儲在
我不知道，十分之一，所以0.1。

113
00:05:13,910 --> 00:05:16,590
所以我要表達的是作為一個
除以10，這是完全

114
00:05:16,590 --> 00:05:17,790
C.合法

115
00:05:17,790 --> 00:05:20,460
>> 然後在第二行，我只是
要打印出它的值。

116
00:05:20,460 --> 00:05:22,950
所以，記得，我們​​可以使用
熟悉的printf。

117
00:05:22,950 --> 00:05:25,420
我們不希望使用％i的類型為int。

118
00:05:25,420 --> 00:05:28,360
我們要使用一個浮點數％F。

119
00:05:28,360 --> 00:05:33,080
然後我要做的反斜杠n，
引號，逗號，F，分號。

120
00:05:33,080 --> 00:05:34,400
>> 因此，這裡是我的計劃。

121
00:05:34,400 --> 00:05:35,820
已經有一個錯誤。

122
00:05:35,820 --> 00:05:38,640
是否有人對他們來說，這點擊
早就想點滿

123
00:05:38,640 --> 00:05:40,220
一個bug，我呢？

124
00:05:40,220 --> 00:05:42,470
是嗎？

125
00:05:42,470 --> 00:05:42,800
嗯。

126
00:05:42,800 --> 00:05:47,860
我忘了“＃”
頂，他們的症狀，如果我嘗試

127
00:05:47,860 --> 00:05:50,490
編譯這是怎麼回事，
編譯器會罵我，

128
00:05:50,490 --> 00:05:52,770
說未定義的象徵或
東西的效果。

129
00:05:52,770 --> 00:05:55,360
它不明白的東西
printf的喜歡。

130
00:05:55,360 --> 00:05:59,380
>> 所以我打算做“＃
“，保存該文件。

131
00:05:59,380 --> 00:06:00,400
現在它在更好的形狀。

132
00:06:00,400 --> 00:06:02,690
但我也要去點
出一個新的細節。

133
00:06:02,690 --> 00:06:08,620
除了指定的地方
％F％％s的持有人一樣，你可以

134
00:06:08,620 --> 00:06:12,320
有時會影響行為
這個佔位符。

135
00:06:12,320 --> 00:06:15,540
例如，在一個浮動的情況下
點值，如果我只想

136
00:06:15,540 --> 00:06:22,200
顯示一個小數位後
期間，我其實可以做0.1F。

137
00:06:22,200 --> 00:06:26,830
因此，換句話說，分開f和
0.1，剛百分號

138
00:06:26,830 --> 00:06:30,200
告訴printf的，你可能有一個整體
一串數字的小數點後

139
00:06:30,200 --> 00:06:30,930
指向我。

140
00:06:30,930 --> 00:06:32,870
但我只想看其中之一。

141
00:06:32,870 --> 00:06:36,280
>> 所以，我要繼續前進並保存
這個程序，進入我的終端

142
00:06:36,280 --> 00:06:41,870
窗口，我要繼續前進
和類型浮法0，回車。

143
00:06:41,870 --> 00:06:44,930
我看到有些神秘的線，
因為我們將開始使更多的意義

144
00:06:44,930 --> 00:06:46,900
逗它除了本週和下週。

145
00:06:46,900 --> 00:06:50,480
現在，我要繼續前進
運行浮法零。

146
00:06:50,480 --> 00:06:52,020
而且，該死的。

147
00:06:52,020 --> 00:06:54,880
>> 因此，有另一個錯誤
這裡的一些原因。

148
00:06:54,880 --> 00:07:02,490
我敢肯定，有十分之一，或
除以10，是不是0.0。

149
00:07:02,490 --> 00:07:04,590
也許我只是不找
足夠的位數。

150
00:07:04,590 --> 00:07:08,580
所以我為什麼不說兩個.2看到兩個
小數位，而不只是一個。

151
00:07:08,580 --> 00:07:11,810
讓我回到我的終端窗口
這裡打了幾次

152
00:07:11,810 --> 00:07:12,840
看看我的歷史。

153
00:07:12,840 --> 00:07:15,910
不要使再次零漂浮，
然後再度上升。

154
00:07:15,910 --> 00:07:17,730
現在進入。

155
00:07:17,730 --> 00:07:20,000
>> 現在，我敢肯定，這是錯誤的。

156
00:07:20,000 --> 00:07:23,030
我可以做三和四，而我
可能會看到零。

157
00:07:23,030 --> 00:07:24,880
那麼，是錯誤嗎？

158
00:07:24,880 --> 00:07:27,910
除以10應為0.1。

159
00:07:27,910 --> 00:07:30,310
有人要採取刺在什麼
根本的問題是什麼？

160
00:07:30,310 --> 00:07:32,400
是嗎？

161
00:07:32,400 --> 00:07:33,420
他們倆都是整數。

162
00:07:33,420 --> 00:07:33,920
還等什麼？

163
00:07:33,920 --> 00:07:37,820
因此，除以10，這是
我做算術。

164
00:07:37,820 --> 00:07:41,185
我得到0.1。

165
00:07:41,185 --> 00:07:41,660
>> 嗯。

166
00:07:41,660 --> 00:07:43,240
所以這的確是這個問題。

167
00:07:43,240 --> 00:07:46,700
當你在一台電腦一個整數
它除以另一個整數，

168
00:07:46,700 --> 00:07:50,430
計算機默認情況下，是怎麼回事
假設您想要一個整數。

169
00:07:50,430 --> 00:07:54,620
的問題，雖然，當然是
是0.1，不是一個整數。

170
00:07:54,620 --> 00:07:55,680
這是一個實數。

171
00:07:55,680 --> 00:07:59,610
還等什麼計算機未通過
默認情況下，它只是扔掉

172
00:07:59,610 --> 00:08:01,070
小數點後的一切。

173
00:08:01,070 --> 00:08:03,380
它不向下舍入或本身。

174
00:08:03,380 --> 00:08:06,480
它只是拋出了一切
小數點後。

175
00:08:06,480 --> 00:08:07,430
現在是有道理的。

176
00:08:07,430 --> 00:08:09,740
因為現在我們清楚
留下了零。

177
00:08:09,740 --> 00:08:10,250
>> 但是且慢。

178
00:08:10,250 --> 00:08:11,840
我沒有看到一個int零。

179
00:08:11,840 --> 00:08:14,910
實際上，我看到0.00。

180
00:08:14,910 --> 00:08:16,340
所以，我怎麼調和嗎？

181
00:08:16,340 --> 00:08:22,850
如果除以10是零，但我
看到0.00，它從哪兒得到

182
00:08:22,850 --> 00:08:24,250
轉換回一個實數嗎？

183
00:08:24,250 --> 00:08:25,500
嗯。

184
00:08:25,500 --> 00:08:29,850

185
00:08:29,850 --> 00:08:30,630
沒錯。

186
00:08:30,630 --> 00:08:35,600
>> 所以在這裡5行，當我真正
存儲是0.1，然後

187
00:08:35,600 --> 00:08:39,549
截斷為零，裡面的浮動，
實際上相當於

188
00:08:39,549 --> 00:08:42,100
存儲為int，但是，
的確，作為一個浮動。

189
00:08:42,100 --> 00:08:46,540
此外，我再使用的printf
明確兩個打印該號碼

190
00:08:46,540 --> 00:08:49,740
小數位，即使有
可能實際上沒有任何秘密協議。

191
00:08:49,740 --> 00:08:51,020
>> 所以這種很爛，對不對？

192
00:08:51,020 --> 00:08:53,640
顯然，你不能做數學，
至少在這個級別的

193
00:08:53,640 --> 00:08:55,600
精度，在一台計算機。

194
00:08:55,600 --> 00:08:56,930
但是肯定有一個解決方案。

195
00:08:56,930 --> 00:09:00,410
我們也許可以簡單的解決辦法是什麼
做，甚至只是憑直覺在這裡

196
00:09:00,410 --> 00:09:01,130
解決這個問題？

197
00:09:01,130 --> 00:09:02,380
是嗎？

198
00:09:02,380 --> 00:09:04,700

199
00:09:04,700 --> 00:09:06,574
打開整數 - 

200
00:09:06,574 --> 00:09:06,976
是的。

201
00:09:06,976 --> 00:09:10,420
即使我不太知道什麼是
真的會在這裡，如果它

202
00:09:10,420 --> 00:09:13,440
這些都從根本上做
是整數，好，為什麼不是我

203
00:09:13,440 --> 00:09:18,230
10.0，使得這個
1.0，重新保存該文件。

204
00:09:18,230 --> 00:09:20,990
讓我去回落到
底部並重新編譯。

205
00:09:20,990 --> 00:09:23,030
現在讓我重新運行。

206
00:09:23,030 --> 00:09:23,420
還有 - 

207
00:09:23,420 --> 00:09:27,690
現在，我已經得到了我的十分之一
表示為0.10。

208
00:09:27,690 --> 00:09:28,420
>> 好的。

209
00:09:28,420 --> 00:09:29,220
所以這是不壞。

210
00:09:29,220 --> 00:09:31,730
並讓我指出另一種方式
我們已經解決了這個。

211
00:09:31,730 --> 00:09:35,580
實際上，讓我及時回滾
當我們作為一個

212
00:09:35,580 --> 00:09:36,680
前十片刻。

213
00:09:36,680 --> 00:09:40,800
並讓我繼續前進，重新保存這個文件
作為一個不同的文件名，只是為了

214
00:09:40,800 --> 00:09:41,750
有一點點的檢查點。

215
00:09:41,750 --> 00:09:43,450
所以這是版本之一。

216
00:09:43,450 --> 00:09:45,520
現在讓我繼續前進，
做一個多個版本。

217
00:09:45,520 --> 00:09:48,540
我們稱這個版本
兩個零的索引。

218
00:09:48,540 --> 00:09:51,280
>> 我要去，而不是做
 - 你知道嗎？

219
00:09:51,280 --> 00:09:54,400
添加點零，在這種情況下工作。

220
00:09:54,400 --> 00:09:56,060
但是，假設一個人的變量。

221
00:09:56,060 --> 00:09:57,680
10應該是一個變量。

222
00:09:57,680 --> 00:10:00,680
換句話說，假設我做不到
只是很難在最後的代碼.0

223
00:10:00,680 --> 00:10:02,340
此算術表達式。

224
00:10:02,340 --> 00:10:05,820
好吧，我可以做一些實際的
括號中稱為鑄造。

225
00:10:05,820 --> 00:10:11,920
我可以投一個浮點數，整數10，
我可以投，整一至

226
00:10:11,920 --> 00:10:12,800
浮動，以及。

227
00:10:12,800 --> 00:10:17,190
然後做數學
有效1.0除以10.0，

228
00:10:17,190 --> 00:10:19,250
的結果，其中去
在f前。

229
00:10:19,250 --> 00:10:26,130
所以，如果我重新編譯這使花車
2，現在浮2，我得到同樣的

230
00:10:26,130 --> 00:10:27,020
回答，以及。

231
00:10:27,020 --> 00:10:29,640
>> 因此，這是一個相當做作的例子，
解決這個問題的

232
00:10:29,640 --> 00:10:31,400
通過引進鑄造。

233
00:10:31,400 --> 00:10:34,410
但在一般情況下，鑄造將是
一個強大的東西，特別是對於

234
00:10:34,410 --> 00:10:38,180
問題設置兩個在一個星期的時間，當
你要轉換的一種數據類型

235
00:10:38,180 --> 00:10:41,800
另一種是在一天結束時
以同樣的方式來表示。

236
00:10:41,800 --> 00:10:44,970
在一天結束時，每一單
迄今為止，我們已經談到的事情是

237
00:10:44,970 --> 00:10:46,710
只是整數引擎蓋下。

238
00:10:46,710 --> 00:10:48,950
或者，如果太低級
你，他們只是數字

239
00:10:48,950 --> 00:10:49,750
引擎蓋下。

240
00:10:49,750 --> 00:10:52,850
再次，即使字符記得
週為零，是數字

241
00:10:52,850 --> 00:10:53,990
引擎蓋下。

242
00:10:53,990 --> 00:10:57,240
>> 這是說，我們之間可以轉換
如果不同種類的數字

243
00:10:57,240 --> 00:10:58,060
他們只是位。

244
00:10:58,060 --> 00:11:01,020
我們之間可以轉換數字
和字母，如果他們只是

245
00:11:01,020 --> 00:11:02,580
位，反之亦然。

246
00:11:02,580 --> 00:11:07,170
以這種方式和鑄造是一種機制
在編程中，可以讓你強行

247
00:11:07,170 --> 00:11:10,970
改變一個數據類型到另一個。

248
00:11:10,970 --> 00:11:14,570
不幸的是，這是不
簡單，因為我可能會喜歡。

249
00:11:14,570 --> 00:11:19,220
>> 我要回去花車
如圖1所示，這是更簡單，更

250
00:11:19,220 --> 00:11:22,830
直截了當的與
.0到每個。

251
00:11:22,830 --> 00:11:25,260
而只是作為一個快速複習，
讓我繼續前進，重新編譯

252
00:11:25,260 --> 00:11:27,670
這一點，使花車2  - 

253
00:11:27,670 --> 00:11:30,300
對不起，這是彩車1。

254
00:11:30,300 --> 00:11:32,050
現在讓我們運行彩車1。

255
00:11:32,050 --> 00:11:34,810
而在底部，請注意
我確實得到0.1。

256
00:11:34,810 --> 00:11:36,165
所以，問題就解決了。

257
00:11:36,165 --> 00:11:37,280
>> 但不是現在。

258
00:11:37,280 --> 00:11:40,000
現在，我會得到一點點好奇，
我要回去到我的

259
00:11:40,000 --> 00:11:41,620
printf語句和
說，你知道是什麼嗎？

260
00:11:41,620 --> 00:11:44,090
我想證實這
真的是十分之一。

261
00:11:44,090 --> 00:11:47,890
我希望看到這個
，比方說，小數點後五位。

262
00:11:47,890 --> 00:11:48,570
這不是一個問題。

263
00:11:48,570 --> 00:11:52,020
我改變了兩到五年，
使我重新編譯。

264
00:11:52,020 --> 00:11:53,770
我重新運行它漂浮1。

265
00:11:53,770 --> 00:11:54,990
展望相當不錯的。

266
00:11:54,990 --> 00:11:58,570
我的理智檢查可能結束，但
我得到多一點冒險精神。

267
00:11:58,570 --> 00:12:00,330
我要改變0.5至0.10。

268
00:12:00,330 --> 00:12:03,440
我希望看到10位後
小數位。

269
00:12:03,440 --> 00:12:09,060
>> 而且我要繼續前進，並重新編譯
並重新運行漂浮1。

270
00:12:09,060 --> 00:12:13,060
我有點遺憾經測試此
進一步，因為我的數學也不是那麼

271
00:12:13,060 --> 00:12:14,320
糾正了，它似乎。

272
00:12:14,320 --> 00:12:15,630
但是，等待一分鐘，也許
這只是一個偶然。

273
00:12:15,630 --> 00:12:17,810
也許計算機充當
有點怪。

274
00:12:17,810 --> 00:12:21,810
讓我繼續前進，做20個小數點
安慰自己，我知道

275
00:12:21,810 --> 00:12:22,540
如何做數學。

276
00:12:22,540 --> 00:12:23,460
我知道如何編程。

277
00:12:23,460 --> 00:12:26,960
彩車1，重新編譯，該死的。

278
00:12:26,960 --> 00:12:31,110
這是真的，真的越來越
遠處的標記。

279
00:12:31,110 --> 00:12:32,490
>> 那麼，這是怎麼回事？

280
00:12:32,490 --> 00:12:36,050
直觀地說，根據我們的假設
早期的數據類型的大小，

281
00:12:36,050 --> 00:12:38,040
什麼是必須發生在這裡
引擎蓋下？

282
00:12:38,040 --> 00:12:39,290
是嗎？

283
00:12:39,290 --> 00:12:43,000

284
00:12:43,000 --> 00:12:43,590
沒錯。

285
00:12:43,590 --> 00:12:46,480
如果你要這麼多的精度，
這是一個了不起的很多精密 - 

286
00:12:46,480 --> 00:12:48,770
20小數點後的數字。

287
00:12:48,770 --> 00:12:51,990
你不可能代表
除非你有一個任意數量

288
00:12:51,990 --> 00:12:52,930
任意的比特數。

289
00:12:52,930 --> 00:12:54,190
但我們不這樣做。

290
00:12:54,190 --> 00:12:57,200
對於浮動，我們只有32位。

291
00:12:57,200 --> 00:13:02,260
>> 因此，如果32位只能在置換
的方式 - 就像我們人類，舞台

292
00:13:02,260 --> 00:13:05,780
向上或向下的手 - 在有限數量的
方式中，只有數量有限

293
00:13:05,780 --> 00:13:08,640
實數可以代表
這些位。

294
00:13:08,640 --> 00:13:10,500
因此，計算機最終
將不得不

295
00:13:10,500 --> 00:13:11,730
開始偷工減料。

296
00:13:11,730 --> 00:13:15,500
計算機可以隱藏這些細節
從我們一點點的時間。

297
00:13:15,500 --> 00:13:18,880
但是，如果我們開始戳的數字
並期待在越走越遠

298
00:13:18,880 --> 00:13:23,220
後數字的整數，
然後，我們開始看到它的

299
00:13:23,220 --> 00:13:26,480
實際上接近
十分之一的想法。

300
00:13:26,480 --> 00:13:29,860
>> 所以事實證明，可悲的是，有
無限數量的數字

301
00:13:29,860 --> 00:13:35,060
我們不能代表正是在
計算機，至少在一個有限的

302
00:13:35,060 --> 00:13:38,030
的比特數，一個有限的
RAM的數量。

303
00:13:38,030 --> 00:13:41,210
不幸的是，現在這有時
具有現實世界的後果。

304
00:13:41,210 --> 00:13:45,980
如果人們不很明白這一點
或那種想當然的事實

305
00:13:45,980 --> 00:13:48,310
他們的計算機只是做
他們告訴它做不

306
00:13:48,310 --> 00:13:51,430
了解這些基礎
代表性的細節 - 

307
00:13:51,430 --> 00:13:55,290
坦率地說，在有些語言
對用戶隱藏的，不像在C  - 

308
00:13:55,290 --> 00:13:56,500
一些不好的事情都可能發生。

309
00:13:56,500 --> 00:13:58,650
>> 什麼，我想我們會做
是退後一步。

310
00:13:58,650 --> 00:14:00,420
這是關於
八分鐘的錄像片。

311
00:14:00,420 --> 00:14:04,200
它宣揚了幾年前，它給
其實是可以去的洞察

312
00:14:04,200 --> 00:14:09,290
錯了，當你欣賞這些
各種細節都非常太

313
00:14:09,290 --> 00:14:10,080
真實的世界。

314
00:14:10,080 --> 00:14:12,965
如果我們可以把燈光調暗
了幾分鐘。

315
00:14:12,965 --> 00:14:14,360
>> 揚聲器1：現在我們回到工程

316
00:14:14,360 --> 00:14:17,160
災​​害對現代奇蹟。

317
00:14:17,160 --> 00:14:18,680
>> 電腦 - 

318
00:14:18,680 --> 00:14:21,340
我們都將接受
往往是令人沮喪的問題

319
00:14:21,340 --> 00:14:23,170
，和他們一起去。

320
00:14:23,170 --> 00:14:27,570
錯誤，病毒，軟件故障
小的價格支付

321
00:14:27,570 --> 00:14:28,960
方便。

322
00:14:28,960 --> 00:14:32,040
但是，在高科技和高速
軍事和航天計劃

323
00:14:32,040 --> 00:14:38,650
應用中，最小的問題
可以放大成災難。

324
00:14:38,650 --> 00:14:44,480
>> 1996年6月4日，科學家準備
發射無人駕駛的阿麗亞娜5型火箭。

325
00:14:44,480 --> 00:14:48,700
它攜帶的科學衛星
正是如何建立

326
00:14:48,700 --> 00:14:53,250
地球磁場的相互作用
太陽風。

327
00:14:53,250 --> 00:14:57,540
火箭始建歐洲
航天局和其升空

328
00:14:57,540 --> 00:14:59,906
在海岸設施
法屬圭亞那。

329
00:14:59,906 --> 00:15:03,660
>> JACK GANSSLE：在約37秒
飛行中，他們首先注意到

330
00:15:03,660 --> 00:15:04,910
東西是錯誤的。

331
00:15:04,910 --> 00:15:08,130
噴嘴旋轉
一種方式，他們真的不應該。

332
00:15:08,130 --> 00:15:12,380
進入飛行約40秒，
明確了車輛遇到了麻煩。

333
00:15:12,380 --> 00:15:14,400
這就是當他們做了一個
決定銷毀它。

334
00:15:14,400 --> 00:15:18,520
範圍內的安全人員，
巨大的膽量，按下按鈕，

335
00:15:18,520 --> 00:15:23,900
炸毀了火箭之前，它可以
成為危害公眾安全。

336
00:15:23,900 --> 00:15:27,810
>> 揚聲器1：這是首航
阿麗亞娜5型火箭，它的破壞

337
00:15:27,810 --> 00:15:32,020
因為嵌入一個缺陷發生
在火箭的軟件。

338
00:15:32,020 --> 00:15:33,980
>> JACK GANSSLE：阿麗亞娜問題
的是，有一個數字

339
00:15:33,980 --> 00:15:36,390
，需要64位來表示。

340
00:15:36,390 --> 00:15:39,420
他們想轉換
一個16位的數字。

341
00:15:39,420 --> 00:15:43,130
他們假設的數量從來沒有
將是非常大的，最

342
00:15:43,130 --> 00:15:46,810
那些在64位的位數
數量是零。

343
00:15:46,810 --> 00:15:48,270
但他們錯了。

344
00:15:48,270 --> 00:15:51,380
>> 揚聲器1：一個軟件無法
程序接受的那種

345
00:15:51,380 --> 00:15:55,350
數所產生的另一個
在根目錄的失敗。

346
00:15:55,350 --> 00:15:59,970
軟件開發已經成為一個非常
昂貴的新技術。

347
00:15:59,970 --> 00:16:03,980
阿麗亞娜4型火箭一直非常
成功的，那麼多的軟件

348
00:16:03,980 --> 00:16:07,480
為它創建的也是
用於在阿麗亞娜5型火箭。

349
00:16:07,480 --> 00:16:11,980
>> 菲科伊爾：最根本的問題是
阿麗亞娜5速度更快，

350
00:16:11,980 --> 00:16:13,720
更快地加速。

351
00:16:13,720 --> 00:16:17,250
軟件
佔該。

352
00:16:17,250 --> 00:16:20,770
>> 揚聲器1：破壞火箭
是一個巨大的金融災難，

353
00:16:20,770 --> 00:16:24,200
由於軟件錯誤一分鐘。

354
00:16:24,200 --> 00:16:27,820
但是，這是不是第一次數據
轉換問題一直困擾現代

355
00:16:27,820 --> 00:16:30,620
火箭技術。

356
00:16:30,620 --> 00:16:34,480
>> JACK GANSSLE：開始於1991年，
第一次海灣戰爭中，“愛國者”

357
00:16:34,480 --> 00:16:38,610
導彈經歷了類似
數轉換的問題。

358
00:16:38,610 --> 00:16:44,910
其結果是，28名美國士兵
死亡，約100人受傷

359
00:16:44,910 --> 00:16:48,600
當愛國者，這是應該
以防止傳入飛毛腿，

360
00:16:48,600 --> 00:16:51,630
沒有發射導彈。

361
00:16:51,630 --> 00:16:55,110
>> 揚聲器1：當伊拉克入侵科威特和
美國發動“沙漠風暴”

362
00:16:55,110 --> 00:17:00,570
1991年初，愛國者導彈
被部署到保護沙特

363
00:17:00,570 --> 00:17:04,760
以色列從伊拉克飛毛腿
導彈攻擊。

364
00:17:04,760 --> 00:17:09,720
愛國者是美國的中程
表面空氣系統製造

365
00:17:09,720 --> 00:17:11,569
雷神公司。

366
00:17:11,569 --> 00:17:16,410
>> THEODORE波斯托爾：愛國者的大小
攔截器本身大約是

367
00:17:16,410 --> 00:17:17,710
20英尺長。

368
00:17:17,710 --> 00:17:20,800
它重約2000磅。

369
00:17:20,800 --> 00:17:22,940
它攜帶的彈頭約 - 

370
00:17:22,940 --> 00:17:24,905
我認為這是大約150磅。

371
00:17:24,905 --> 00:17:31,030
和彈頭本身是一個
高爆

372
00:17:31,030 --> 00:17:33,270
它周圍的碎片。

373
00:17:33,270 --> 00:17:37,490
彈頭的殼體設計
像巴克肖特。

374
00:17:37,490 --> 00:17:40,720
>> 導彈進行了四個揚聲器1：
容器和運輸

375
00:17:40,720 --> 00:17:43,050
半拖車。

376
00:17:43,050 --> 00:17:47,490
>> 菲科伊爾：愛國者反導彈
系統可以追溯到

377
00:17:47,490 --> 00:17:50,710
至少有20年了。

378
00:17:50,710 --> 00:17:54,350
它最初被設計為
防空導彈

379
00:17:54,350 --> 00:17:56,190
擊落敵方飛機。

380
00:17:56,190 --> 00:18:02,490
在第一次海灣戰爭，那場戰爭時，
走過來，陸軍想使用它

381
00:18:02,490 --> 00:18:05,535
擊落“飛毛腿”導彈，而不是飛機。

382
00:18:05,535 --> 00:18:09,310
伊拉克空軍沒有
這麼多的問題。

383
00:18:09,310 --> 00:18:12,450
但陸軍擔心飛毛腿導彈。

384
00:18:12,450 --> 00:18:15,950
因此，他們試圖升級
愛國者。

385
00:18:15,950 --> 00:18:18,750
>> 揚聲器1：攔截敵方導彈
在5馬赫

386
00:18:18,750 --> 00:18:20,890
將要足夠的挑戰性。

387
00:18:20,890 --> 00:18:25,590
但是，當愛國者衝進
服務，陸軍不知道的

388
00:18:25,590 --> 00:18:31,710
伊拉克的修改，使他們
打飛毛腿導彈幾乎是不可能的。

389
00:18:31,710 --> 00:18:35,240
>> 西奧多·波斯托爾：發生了什麼事
飛毛腿

390
00:18:35,240 --> 00:18:36,570
進來的是不穩定的。

391
00:18:36,570 --> 00:18:37,532
他們搖晃。

392
00:18:37,532 --> 00:18:43,220
這樣做的原因是伊拉克人，
為了獲得600公里的

393
00:18:43,220 --> 00:18:47,530
300公里的遠程導彈，把
出前彈頭重量。

394
00:18:47,530 --> 00:18:49,290
他們使彈頭打火機。

395
00:18:49,290 --> 00:18:53,110
所以，現在愛國者的嘗試
來的飛毛腿。

396
00:18:53,110 --> 00:18:56,470
而大部分時間，鋪天蓋地的
大部分時間裡，它只是

397
00:18:56,470 --> 00:18:58,730
飛毛腿飛。

398
00:18:58,730 --> 00:19:01,760
>> 揚聲器1：一旦愛國者導彈系統
運營商意識到錯過的愛國者

399
00:19:01,760 --> 00:19:06,690
它的目標，他們引爆了愛國者
彈頭，以避免可能

400
00:19:06,690 --> 00:19:10,300
如果它被允許傷亡
倒在地上。

401
00:19:10,300 --> 00:19:14,540
>> THEODORE波斯托爾：這是最
人們看到大火球在天空中

402
00:19:14,540 --> 00:19:20,350
作為攔截和誤解
飛毛腿彈頭。

403
00:19:20,350 --> 00:19:23,320
>> 揚聲器1：雖然在夜空
愛國者似乎是成功

404
00:19:23,320 --> 00:19:27,530
摧毀“飛毛腿”導彈，在達蘭有
關於它的可能是沒有錯

405
00:19:27,530 --> 00:19:29,140
性能。

406
00:19:29,140 --> 00:19:34,180
有愛國者的雷達系統失去
跟踪傳入飛毛腿從未

407
00:19:34,180 --> 00:19:36,380
由於軟件缺陷而推出。

408
00:19:36,380 --> 00:19:39,890

409
00:19:39,890 --> 00:19:42,700
>> 這是以色列首次發現
的時間越長系統

410
00:19:42,700 --> 00:19:48,020
是，更大的時間差
成為由於時鐘

411
00:19:48,020 --> 00:19:50,470
嵌入式系統的計算機。

412
00:19:50,470 --> 00:19:54,640
>> JACK GANSSLE：大約兩個星期前
在達蘭，以色列人的悲劇

413
00:19:54,640 --> 00:19:58,440
國防部報告
該系統是失去的時間。

414
00:19:58,440 --> 00:20:01,280
經過約8個小時的運行，
他們注意到，該系統是

415
00:20:01,280 --> 00:20:03,530
越來越明顯不準確的。

416
00:20:03,530 --> 00:20:07,710
國防部回應
告訴所有的愛國者電池

417
00:20:07,710 --> 00:20:10,500
不能離開系統
很長一段時間。

418
00:20:10,500 --> 00:20:12,430
他們從來不說，很長一段時間。

419
00:20:12,430 --> 00:20:13,330
8個小時？

420
00:20:13,330 --> 00:20:13,810
10小時？

421
00:20:13,810 --> 00:20:14,990
千小時？

422
00:20:14,990 --> 00:20:17,150
沒有人知道。

423
00:20:17,150 --> 00:20:20,220
>> 揚聲器1：愛國者進駐
在宰赫蘭兵營

424
00:20:20,220 --> 00:20:24,660
一直有問題的內部時鐘
對超過100小時的夜

425
00:20:24,660 --> 00:20:27,470
2月25日。

426
00:20:27,470 --> 00:20:31,770
>> JACK GANSSLE：跟踪時間到
的大約十分之一秒的精度。

427
00:20:31,770 --> 00:20:34,480
現在，十分之一秒為
有趣的數字，因為它不能

428
00:20:34,480 --> 00:20:39,940
以二進制表示完全相同，表示
它不能被精確地表示在

429
00:20:39,940 --> 00:20:42,500
任何現代數字計算機。

430
00:20:42,500 --> 00:20:46,920
這很難相信，但
用這個作為一個例子。

431
00:20:46,920 --> 00:20:49,000
讓拿多少三分之一。

432
00:20:49,000 --> 00:20:53,150
三分之一也無法表達
在小數正是。

433
00:20:53,150 --> 00:20:57,500
三分之一0.333
無窮。

434
00:20:57,500 --> 00:21:02,270
有沒有辦法做到這一點
絕對精度在小數。

435
00:21:02,270 --> 00:21:05,370
這也正是同樣的問題
，在愛國者發生。

436
00:21:05,370 --> 00:21:09,880
系統運行的時間越長，
最壞的時間誤差就成了。

437
00:21:09,880 --> 00:21:13,840
>> 揚聲器1：運行100小時後，
只有時間錯誤

438
00:21:13,840 --> 00:21:16,140
大約三分之一的第二個。

439
00:21:16,140 --> 00:21:20,800
但無論在目標導彈
在5馬赫，它導致

440
00:21:20,800 --> 00:21:24,410
超過600米的跟踪誤差。

441
00:21:24,410 --> 00:21:27,670
這將是一個致命的錯誤
在宰赫蘭的士兵。

442
00:21:27,670 --> 00:21:33,450
>> 西奧多·波斯托爾：發生了什麼事是一個
飛毛腿發射早期檢測

443
00:21:33,450 --> 00:21:34,280
預警衛星。

444
00:21:34,280 --> 00:21:38,550
他們知道，飛毛腿
在他們的大方向。

445
00:21:38,550 --> 00:21:41,000
他們不知道它在哪裡來。

446
00:21:41,000 --> 00:21:43,900
>> 揚聲器1：現在是雷達
“愛國者”系統的組成部分

447
00:21:43,900 --> 00:21:48,910
衛冕達蘭定位，並保持
跟踪來襲的敵方導彈。

448
00:21:48,910 --> 00:21:50,580
>> JACK GANSSLE：雷達
是非常聰明的。

449
00:21:50,580 --> 00:21:53,770
它實際上跟踪的位置
飛毛腿，然後預測

450
00:21:53,770 --> 00:21:57,160
可能會是今後一段時間
雷達發出一個脈衝。

451
00:21:57,160 --> 00:21:58,870
這被稱為距離門。

452
00:21:58,870 --> 00:22:04,020
>> THEODORE波斯托爾：然後，一旦愛國者
決定有足夠的時間已經過去了去

453
00:22:04,020 --> 00:22:09,420
備份和檢查的下一個位置
此檢測對象，它可以追溯到。

454
00:22:09,420 --> 00:22:14,450
因此，當它回到了錯
地方，然後看到沒有對象。

455
00:22:14,450 --> 00:22:18,200
而它決定，沒有任何對象，
這是一個虛假的檢測，並

456
00:22:18,200 --> 00:22:19,680
下降的軌道。

457
00:22:19,680 --> 00:22:22,970
>> 揚聲器1：傳入飛毛腿消失
從雷達屏幕上，

458
00:22:22,970 --> 00:22:26,050
秒鐘後，它抨擊
走進軍營。

459
00:22:26,050 --> 00:22:31,950
飛毛腿殺害28是最後一個
第一次海灣戰爭期間發射。

460
00:22:31,950 --> 00:22:37,700
可悲的是，更新後的軟件到達
在宰赫蘭的第二天。

461
00:22:37,700 --> 00:22:41,800
軟件漏洞已被固定，
關閉一章的困擾

462
00:22:41,800 --> 00:22:43,690
歷史的“愛國者”導彈。

463
00:22:43,690 --> 00:22:46,780

464
00:22:46,780 --> 00:22:50,710
>> 愛國者實際上是一個縮寫
相控陣跟踪

465
00:22:50,710 --> 00:22:51,960
攔截的目標。

466
00:22:51,960 --> 00:22:54,650

467
00:22:54,650 --> 00:23:00,840
>> DAVID J MALAN：所有的權利，所以
發人深省的例子，可以肯定的。

468
00:23:00,840 --> 00:23:03,430
幸運的是，這些較低水平
錯誤是沒有的東西，我們會

469
00:23:03,430 --> 00:23:06,220
通常有升值，當然
不是與我們的一些

470
00:23:06,220 --> 00:23:07,360
最早的方案。

471
00:23:07,360 --> 00:23:10,450
相反，大多數的錯誤，你會
將所遇到的邏輯性，

472
00:23:10,450 --> 00:23:12,900
語法性質，據此，
代碼只是不工作的權利。

473
00:23:12,900 --> 00:23:14,140
而且你知道它相當快的。

474
00:23:14,140 --> 00:23:16,850
>> 但是，尤其是當我們得到的
學期結束時，它會

475
00:23:16,850 --> 00:23:20,620
的可能性變得越來越
真的好好想想的設計

476
00:23:20,620 --> 00:23:22,960
您的程序和底層
表示

477
00:23:22,960 --> 00:23:24,520
有太多的數據。

478
00:23:24,520 --> 00:23:28,010
舉例來說，我們將介紹MySQL中，
這是一個受歡迎的數據庫引擎

479
00:23:28,010 --> 00:23:30,850
您可以使用網站
數據存儲在後端。

480
00:23:30,850 --> 00:23:34,630
你就得開始決定
學期結束的不僅是

481
00:23:34,630 --> 00:23:38,790
沿著這些線路的類型的數據，使用
但究竟有多少位使用，

482
00:23:38,790 --> 00:23:42,740
您是否想存儲日期
隨著時代的日期和時間，也

483
00:23:42,740 --> 00:23:46,890
之類的東西你要多大的
是唯一的ID，也就是說，用戶

484
00:23:46,890 --> 00:23:47,680
在數據庫中。

485
00:23:47,680 --> 00:23:51,210
>> 事實上，如果你有一些有
Facebook的佔了相當長的一段時間，

486
00:23:51,210 --> 00:23:53,680
你知道如何獲得
您的用戶ID  - 

487
00:23:53,680 --> 00:23:57,930
這有時會顯示在你的
除非你選擇了一個配置文件的URL

488
00:23:57,930 --> 00:24:02,070
綽號的URL，或者如果你已經
常用的Facebook的圖形API，

489
00:24:02,070 --> 00:24:05,510
公開可用的API，通過它
可以要求Facebook的原始數據 - 

490
00:24:05,510 --> 00:24:07,580
你可以看到你的數字ID是什麼。

491
00:24:07,580 --> 00:24:10,880
若干年前，Facebook的本質
不得不改變使用

492
00:24:10,880 --> 00:24:15,980
使用長整型相當於
長，因為隨著​​時間的推移，用戶前來

493
00:24:15,980 --> 00:24:19,780
去創建大量的賬戶，
假帳戶，即使他們很容易

494
00:24:19,780 --> 00:24:24,630
能用盡的東西就像一個4
十億可能像一個int值。

495
00:24:24,630 --> 00:24:28,340
>> 所以這些類型的問題
在路上，以及。

496
00:24:28,340 --> 00:24:30,750
所有權利，使被鑄造。

497
00:24:30,750 --> 00:24:31,670
這是不精確的。

498
00:24:31,670 --> 00:24:32,730
一對夫婦迅速公佈。

499
00:24:32,730 --> 00:24:35,710
所以部分正式開始
週日，週一，週二。

500
00:24:35,710 --> 00:24:39,080
你會聽到在本週晚些時候通過電子郵件
為您的部分分配。

501
00:24:39,080 --> 00:24:42,570
你怎麼在這一點也在這裡
改變你的部分，如果你

502
00:24:42,570 --> 00:24:45,660
時間表現在已經改變或
舒適程度現在已經改變。

503
00:24:45,660 --> 00:24:49,380
同時，P-集合一個黑客之一
本週四到期的選項

504
00:24:49,380 --> 00:24:52,450
延長該期限每
規格至週五

505
00:24:52,450 --> 00:24:53,830
在一個典型的方式。

506
00:24:53,830 --> 00:24:57,500
>> 實現的問題，其中包括
集規格說明

507
00:24:57,500 --> 00:25:02,770
如何使用的CS50家電，
以及一些CS50具體工具

508
00:25:02,770 --> 00:25:06,540
50般的風格，可以為您提供
動態與反饋

509
00:25:06,540 --> 00:25:10,230
你的代碼風格和質量也
檢查50個，可為您提供

510
00:25:10,230 --> 00:25:13,160
動態反饋到您的
代碼的正確性。

511
00:25:13,160 --> 00:25:16,850
請原諒，我們仍然熨燙
出幾個扭結支票50。

512
00:25:16,850 --> 00:25:21,490
有幾個你的同學們開始
四點左右，上週五晚上，當

513
00:25:21,490 --> 00:25:25,130
規範上升從那時起已經注意到
一些錯誤，我們正在努力

514
00:25:25,130 --> 00:25:29,010
通過和道歉的人誰
經歷了不必要的挫折。

515
00:25:29,010 --> 00:25:30,340
該故障是我的。

516
00:25:30,340 --> 00:25:34,080
但是我們會跟進CS50
討論何時得到解決。

517
00:25:34,080 --> 00:25:35,700
>> 所以一個字的分數本身。

518
00:25:35,700 --> 00:25:38,990
因此，這將是一兩個星期之前，
開始得到反饋問題集

519
00:25:38,990 --> 00:25:40,640
因為你還沒有
教學研究員。

520
00:25:40,640 --> 00:25:44,510
即使到那時，我們將​​開始評估
C問題之前，我們設置

521
00:25:44,510 --> 00:25:46,970
回去從頭如此評價
你得到更多的有關

522
00:25:46,970 --> 00:25:48,150
更快速的反饋。

523
00:25:48,150 --> 00:25:51,870
但在一般每教學大綱，CS50
習題集一起評估

524
00:25:51,870 --> 00:25:53,580
以下四個軸 - 

525
00:25:53,580 --> 00:25:55,760
範圍，正確性，設計和風格。

526
00:25:55,760 --> 00:25:59,210
>> 範圍將是一個數字通常
0至5，

527
00:25:59,210 --> 00:26:01,830
捕獲多少
一塊咬下。

528
00:26:01,830 --> 00:26:03,750
通常情況下，你想這是五。

529
00:26:03,750 --> 00:26:05,300
至少你嘗試了一切。

530
00:26:05,300 --> 00:26:09,330
並注意到這是一個乘數因子
所以，這樣做只是部分的

531
00:26:09,330 --> 00:26:12,520
問題集是不是最好的策略。

532
00:26:12,520 --> 00:26:15,610
>> 同時，更明顯的是
正確性的重要性 - 

533
00:26:15,610 --> 00:26:18,620
僅僅是你的程序正確
尊重規範？

534
00:26:18,620 --> 00:26:21,510
這是故意加權
重比其他兩個軸由一個

535
00:26:21,510 --> 00:26:24,450
三個因素，因為我們認識
通常你會花

536
00:26:24,450 --> 00:26:28,600
更多的時間追了一些bug，
讓你的代碼工作，那麼你

537
00:26:28,600 --> 00:26:31,540
縮進它並選擇
適當的變量名和

538
00:26:31,540 --> 00:26:33,800
等，這是在另一端
的頻譜風格。

539
00:26:33,800 --> 00:26:36,160
>> 這並不是說風格是不是
重要的，我們會傳過來

540
00:26:36,160 --> 00:26:37,920
講座和部分時間。

541
00:26:37,920 --> 00:26:40,520
式是指美學
你的代碼。

542
00:26:40,520 --> 00:26:43,980
你有選擇的命名變量
很短，但有些

543
00:26:43,980 --> 00:26:44,680
的描述嗎？

544
00:26:44,680 --> 00:26:47,840
你的代碼縮進你見過
講座和一致的方式

545
00:26:47,840 --> 00:26:49,070
風格50？

546
00:26:49,070 --> 00:26:51,220
>> 最後是設計權
還有在中間。

547
00:26:51,220 --> 00:26:54,090
放一個更難的設計
手指上，因為它更

548
00:26:54,090 --> 00:26:55,000
主觀的。

549
00:26:55,000 --> 00:26:58,610
但它也許是最重要的
三個軸在教學方面的

550
00:26:58,610 --> 00:27:02,050
價值隨著時間的推移，這將是
教學研究員的機會

551
00:27:02,050 --> 00:27:04,110
為您提供定性反饋。

552
00:27:04,110 --> 00:27:08,100
事實上，在CS50，即使我們確實有
這些公式和成績，在年底

553
00:27:08,100 --> 00:27:11,350
的一天，這些都是很刻意
非常小水桶 - 點值

554
00:27:11,350 --> 00:27:13,460
0和3之間
零和五​​。

555
00:27:13,460 --> 00:27:17,800
我們不要嘗試畫很粗的線條
之間的問題集之間或

556
00:27:17,800 --> 00:27:21,490
學生而是盡可能集中
我們可以定性，普通的

557
00:27:21,490 --> 00:27:25,490
反饋，無論是打字或口頭
您的特定的教學研究員，

558
00:27:25,490 --> 00:27:27,050
你會得到相當不錯知道。

559
00:27:27,050 --> 00:27:32,340
>> 但在一般情況下，這些權重
各軸。

560
00:27:32,340 --> 00:27:35,480
同時，太，這是值得保持
介意你不應該假設，

561
00:27:35,480 --> 00:27:38,870
五分之三是60％
因此，大致失敗。

562
00:27:38,870 --> 00:27:41,410
三是故意為了
中間的道路好樣的。

563
00:27:41,410 --> 00:27:43,480
如果你在得到三分
從本學期開始，這是

564
00:27:43,480 --> 00:27:46,340
的確意味著是一個很好的
開始的地方。

565
00:27:46,340 --> 00:27:50,510
如果你有三三兩兩，展銷會，
一定工作付出一點

566
00:27:50,510 --> 00:27:53,250
更多的關注，以充分利用
段和辦公時間。

567
00:27:53,250 --> 00:27:54,590
>> 如果你得到四肢
五，偉大的。

568
00:27:54,590 --> 00:27:57,430
不過說真的，我們希望看到的軌跡
學生之間 - 

569
00:27:57,430 --> 00:28:00,575
每名學生的個性化，但啟動
本學期，在這裡排序

570
00:28:00,575 --> 00:28:04,100
兩到三個範圍內，但結束
這裡在四到五的範圍內。

571
00:28:04,100 --> 00:28:05,440
這就是我們真正需要的。

572
00:28:05,440 --> 00:28:09,590
同時，我們也牢記三角洲
週之間的零和週展出

573
00:28:09,590 --> 00:28:12,170
12時，我做的成績。

574
00:28:12,170 --> 00:28:16,380
不要緊，我們絕對怎麼樣
你公平的開始，如果您的

575
00:28:16,380 --> 00:28:19,330
的確軌跡
向上和堅強。

576
00:28:19,330 --> 00:28:24,000
>> 學術誠信 - 所以讓我把我的
更嚴重的只是一瞬間的聲音。

577
00:28:24,000 --> 00:28:28,510
因此，這當然有區別
派遣更多的學生比其他任何

578
00:28:28,510 --> 00:28:30,950
在歷史上的廣告板，我相信。

579
00:28:30,950 --> 00:28:34,220
我們有點記不清
點如何經常發生這種情況。

580
00:28:34,220 --> 00:28:37,090
而這還不是因為學生在50
任何比自己更不誠實

581
00:28:37,090 --> 00:28:38,690
其他地方的同學。

582
00:28:38,690 --> 00:28:42,800
但要意識到，那就是，我們都非常好
在檢測這樣的事情。

583
00:28:42,800 --> 00:28:45,920
>> 而這就是的優點是
計算機科學類，因為我們

584
00:28:45,920 --> 00:28:49,110
可以和我們比較所有學生
問題設置成對對每

585
00:28:49,110 --> 00:28:51,470
，不僅今年
但往年。

586
00:28:51,470 --> 00:28:55,080
我們有能力，像學生
類，谷歌和找到代碼

587
00:28:55,080 --> 00:28:57,440
像GitHub和網站上
討論論壇。

588
00:28:57,440 --> 00:29:00,840
CS50的是絕對有解決方案
P-集合漂浮在那裡。

589
00:29:00,840 --> 00:29:02,710
但是，如果你能找到他們，
我們可以找到他們。

590
00:29:02,710 --> 00:29:07,130
而所有這一切都是非常自動化
和容易和悲傷的為我們找到。

591
00:29:07,130 --> 00:29:10,990
>> 但我想強調的是，也
課程的學術誠信政策

592
00:29:10,990 --> 00:29:13,960
非常意味著是非常
相反的這種精神。

593
00:29:13,960 --> 00:29:17,506
事實上，這一年中，我們改寫的東西
在教學大綱，點

594
00:29:17,506 --> 00:29:19,790
點點，更多的細節
在教學大綱。

595
00:29:19,790 --> 00:29:22,860
但過程中的最重要的主題
真的是要合理。

596
00:29:22,860 --> 00:29:26,160
我們認識到，有一個顯著的
教學量

597
00:29:26,160 --> 00:29:30,550
值在協作，在一定程度上
與同學，讓你

598
00:29:30,550 --> 00:29:33,700
兩個或三個或更多
站在白板

599
00:29:33,700 --> 00:29:35,670
白板，所以
說，你的想法 - 

600
00:29:35,670 --> 00:29:39,480
寫出來的偽代碼的圖片，
圖表馬里奧應該是，如果

601
00:29:39,480 --> 00:29:41,350
你先寫
在偽代碼。

602
00:29:41,350 --> 00:29:43,240
應該採取什麼貪心算法 - 

603
00:29:43,240 --> 00:29:46,100
應該如何表現每
問題設置一個？

604
00:29:46,100 --> 00:29:50,440
>> 等意識到行為
我們鼓勵非常

605
00:29:50,440 --> 00:29:51,470
沿著這些線路大部分。

606
00:29:51,470 --> 00:29:53,890
在教學大綱中，你會看到一個
下一大堆子彈

607
00:29:53,890 --> 00:29:57,740
合理的類別和一個不太合理
類別有助於我們幫助

608
00:29:57,740 --> 00:30:00,740
您所在位置周圍包裹你的心靈
我們畫出這條線。

609
00:30:00,740 --> 00:30:04,340
而在一般情況下，一個體面的經驗法則
是，如果你正在努力解決

610
00:30:04,340 --> 00:30:07,990
一些bug和您的朋友或同學
坐在你旁邊，

611
00:30:07,990 --> 00:30:11,530
合理的為你顯示他或她
你的代碼和說，哎，你能不能幫

612
00:30:11,530 --> 00:30:13,700
我弄清楚發生了什麼事情錯在這裡？

613
00:30:13,700 --> 00:30:17,110
>> 我們通常不擁抱
的相反側。

614
00:30:17,110 --> 00:30:20,730
它不是一個正確的響應為您的
朋友或同學在這裡說，哦，

615
00:30:20,730 --> 00:30:22,510
只要看看礦山和圖
它從。

616
00:30:22,510 --> 00:30:24,400
這是一種不合理。

617
00:30:24,400 --> 00:30:27,750
但有別人，另一個大腦，
另一雙眼睛看

618
00:30:27,750 --> 00:30:31,620
您的屏幕或看看你的代碼
說，你確定你想要的

619
00:30:31,620 --> 00:30:32,760
這裡有一個循環？

620
00:30:32,760 --> 00:30:34,800
或者是你確定要
，分號這裡？

621
00:30:34,800 --> 00:30:37,090
哦，該錯誤消息意味著這一點。

622
00:30:37,090 --> 00:30:39,580
這些都是非常合理的，
鼓勵的行為。

623
00:30:39,580 --> 00:30:44,010
>> 的情況下，我被影射
早期歸結為當學生

624
00:30:44,010 --> 00:30:47,350
深夜判斷力差
決策和收發電子郵件代碼

625
00:30:47,350 --> 00:30:50,130
或者只是別人說，
在這裡，它是在Dropbox或

626
00:30:50,130 --> 00:30:51,610
谷歌搜索在深夜。

627
00:30:51,610 --> 00:30:54,880
所以我會鼓勵，求求你了，
如果你有那些不可避免

628
00:30:54,880 --> 00:30:58,450
緊張的時刻，你撞了
對最後期限，你有沒有後期

629
00:30:58,450 --> 00:31:01,490
一天，因為它已經在星期五
點，發送電子郵件的過程的元首或

630
00:31:01,490 --> 00:31:02,330
自己直接。

631
00:31:02,330 --> 00:31:04,790
說，聽著，我在我的
突破點在這裡。

632
00:31:04,790 --> 00:31:06,660
我們有一個談話
和看著辦吧。

633
00:31:06,660 --> 00:31:10,400
訴諸於網絡或其他一些不
合理的行為從來都不是

634
00:31:10,400 --> 00:31:13,070
解決方案，太多你
同學這裡就不再

635
00:31:13,070 --> 00:31:15,150
校園裡，因為那可憐的判斷。

636
00:31:15,150 --> 00:31:17,840
但它很容易裙子線。

637
00:31:17,840 --> 00:31:22,950
>> 這裡是一個小的圖片來捧場
你從書籤交易，因此現在

638
00:31:22,950 --> 00:31:25,720
一切都會好的。

639
00:31:25,720 --> 00:31:30,210
>> 因此，快速回顧一下，然後，
我們離開的地方。

640
00:31:30,210 --> 00:31:33,690
於是在上週，還記得我們介紹
的條件下，而不是在Scratch

641
00:31:33,690 --> 00:31:34,880
但在C這個時候。

642
00:31:34,880 --> 00:31:38,300
有一些新的語法，但
真的沒有新的想法本身。

643
00:31:38,300 --> 00:31:42,630
我們有布爾表達式，我們可以
或連同兩個垂直

644
00:31:42,630 --> 00:31:46,490
條或連同兩
＆符號，他說，無論是左

645
00:31:46,490 --> 00:31:49,990
和正確的必須是真實的
為這來執行。

646
00:31:49,990 --> 00:31:53,150
然後我們有開關，我們看了
簡單地說，但我建議是真的

647
00:31:53,150 --> 00:31:56,830
只是為實現不同的語法
相同樣的目標，如果你知道在

648
00:31:56,830 --> 00:31:59,270
推進你的案件
將要。

649
00:31:59,270 --> 00:32:00,160
>> 我們著眼於循環。

650
00:32:00,160 --> 00:32:03,340
for循環是可能是最常見的，
或至少​​一個人

651
00:32:03,340 --> 00:32:05,330
通常達到本能。

652
00:32:05,330 --> 00:32:08,240
即使它看起來有點神秘，
你會看到很多很多這樣的例子

653
00:32:08,240 --> 00:32:11,590
過不了多久，你有
已經在上週晚些時候。

654
00:32:11,590 --> 00:32:14,280
While循環同樣可以
達到同樣的事情。

655
00:32:14,280 --> 00:32:17,550
但是，如果你想要做的任何增量
或更新

656
00:32:17,550 --> 00:32:20,230
變量的值，你必須
它比手動

657
00:32:20,230 --> 00:32:22,440
for循環之前允許。

658
00:32:22,440 --> 00:32:25,310
再有就是do-whil​​e循環，
這使我們能夠做點什麼

659
00:32:25,310 --> 00:32:28,460
至少一次，而一些
別人是真實的。

660
00:32:28,460 --> 00:32:31,550
這是特別好
程序或遊戲，你想在哪裡

661
00:32:31,550 --> 00:32:33,810
提示用戶的東西
至少一次。

662
00:32:33,810 --> 00:32:37,110
然後，如果他或她不配合，
你可能會想這樣做

663
00:32:37,110 --> 00:32:38,420
一遍又一遍。

664
00:32:38,420 --> 00:32:41,270
>> 有了變量，同時，我們不得不線
像這樣的代碼，這可能

665
00:32:41,270 --> 00:32:41,950
是兩行。

666
00:32:41,950 --> 00:32:44,830
你可以聲明一個int叫
計數器，分號。

667
00:32:44,830 --> 00:32:47,660
或者，你可以聲明和
定義它，可以這麼說。

668
00:32:47,660 --> 00:32:49,950
給它一個價值在同一時間。

669
00:32:49,950 --> 00:32:51,890
>> 然後最後，我們談到
有關功能。

670
00:32:51,890 --> 00:32:54,270
這是一個很好的例子
某種意義上說，它說明

671
00:32:54,270 --> 00:32:55,840
兩種類型的函數。

672
00:32:55,840 --> 00:32:59,030
一個是的GetString的（），再次
得到了來自用戶的字符串。

673
00:32:59,030 --> 00:33:02,040
但是GetString的（）是一種有趣的，
到目前為止，我們已經用它，

674
00:33:02,040 --> 00:33:05,620
因為我們一直用它
上的東西的左手側的

675
00:33:05,620 --> 00:33:06,600
等號。

676
00:33:06,600 --> 00:33:09,830
也就是說，GetString的（）
返回一個值。

677
00:33:09,830 --> 00:33:11,970
當然，它返回一個字符串。

678
00:33:11,970 --> 00:33:15,130
然後在左側，我們
簡單地保存該字符串裡面的

679
00:33:15,130 --> 00:33:16,580
叫name的變量。

680
00:33:16,580 --> 00:33:21,100
>> 這一點是不同的，在某種意義上說，從
因為printf printf的，至少在我們的

681
00:33:21,100 --> 00:33:23,540
這裡使用，不返回任何東西。

682
00:33:23,540 --> 00:33:24,960
順便說一句，它返回的東西。

683
00:33:24,960 --> 00:33:26,380
我們只是不關心它是什麼。

684
00:33:26,380 --> 00:33:29,090
但它確實有什麼
所謂的一個副作用。

685
00:33:29,090 --> 00:33:31,840
那是什麼副作用，在每
情況下，我們迄今見過嗎？

686
00:33:31,840 --> 00:33:34,720
printf的是什麼？

687
00:33:34,720 --> 00:33:37,780
它打印的東西在屏幕上，
顯示文字或數字或東西

688
00:33:37,780 --> 00:33:38,380
在屏幕上。

689
00:33:38,380 --> 00:33:41,170
認為這只是一個副作用
因為它不是真正交給

690
00:33:41,170 --> 00:33:41,900
還給我。

691
00:33:41,900 --> 00:33:44,770
這裡面不是一個答案
一個黑盒子，然後我就可以

692
00:33:44,770 --> 00:33:46,130
伸入搶。

693
00:33:46,130 --> 00:33:49,160
它只是在做對自己，多
像科爾頓插入此

694
00:33:49,160 --> 00:33:52,560
黑匣子的最後一周，他不知何故
奇蹟般地在黑板上畫

695
00:33:52,560 --> 00:33:54,500
我沒有實際參與。

696
00:33:54,500 --> 00:33:55,560
這將是一個副作用。

697
00:33:55,560 --> 00:33:59,100
但是，如果我真的必須達到回
在這裡，說，哦，這裡是字符串

698
00:33:59,100 --> 00:34:02,040
來自用戶的，會
是一個返回值。

699
00:34:02,040 --> 00:34:05,650
>> 並且到目前為止，我們只使用的功能
其他人都寫了。

700
00:34:05,650 --> 00:34:09,219
但實際上，我們可以做這些
自己種的東西。

701
00:34:09,219 --> 00:34:12,730
所以我要進入
CS50再次電器。

702
00:34:12,730 --> 00:34:16,020
讓我關閉該標籤，
打開了剛才。

703
00:34:16,020 --> 00:34:18,530
讓我繼續前進，
創建一個新的文件。

704
00:34:18,530 --> 00:34:22,400
而且我要繼續前進，
調用這個positive.c。

705
00:34:22,400 --> 00:34:24,770
所以，我想要做的事
這裡正數。

706
00:34:24,770 --> 00:34:27,219
所以，我要繼續前進，做詮釋 - 

707
00:34:27,219 --> 00:34:28,000
對不起 - 

708
00:34:28,000 --> 00:34:31,840
＃。

709
00:34:31,840 --> 00:34:34,280
讓我們不要讓同一
像以前那樣的錯誤。

710
00:34:34,280 --> 00:34:40,020
詮釋的主要（無效），開放式捲髮
撐，封閉大括號。

711
00:34:40,020 --> 00:34:41,639
>> 現在我要做到以下幾點。

712
00:34:41,639 --> 00:34:44,600
我想編寫一個程序，
堅持用戶提供

713
00:34:44,600 --> 00:34:46,770
我的一個正整數。

714
00:34:46,770 --> 00:34:50,969
因此，有沒有GetPositiveInt功能
在CS50庫。

715
00:34:50,969 --> 00:34:52,610
有只調用getInt（）。

716
00:34:52,610 --> 00:34:55,790
不過沒關係，因為我有
我可以並處的結構

717
00:34:55,790 --> 00:34:59,360
小該值約束。

718
00:34:59,360 --> 00:35:00,990
我可以做這樣的事情。

719
00:35:00,990 --> 00:35:02,780
>> 所以INT N  - 

720
00:35:02,780 --> 00:35:04,920
如果你敲字，只是實現
我要回去

721
00:35:04,920 --> 00:35:06,430
改變一些東西在一瞬間 - 

722
00:35:06,430 --> 00:35:09,960
所以整數n等於調用getInt（）。

723
00:35:09,960 --> 00:35:11,780
這就是要放
一個int n的內部。

724
00:35:11,780 --> 00:35:13,830
讓我成為一個更具描述。

725
00:35:13,830 --> 00:35:23,270
讓我說，像我要求的東西
你給我一個正整數。

726
00:35:23,270 --> 00:35:23,550
>> 好的。

727
00:35:23,550 --> 00:35:25,250
因此，只是一點點的指令。

728
00:35:25,250 --> 00:35:26,270
現在我能做些什麼呢？

729
00:35:26,270 --> 00:35:29,840
好吧，我已經知道我的簡單
條件或分支機構，就像我

730
00:35:29,840 --> 00:35:36,100
有划痕，我能說些什麼
等，當n是小於或等於

731
00:35:36,100 --> 00:35:44,460
零的話，我想要做的事
喜歡，那不積極。

732
00:35:44,460 --> 00:35:45,560
然後，我可以做的 - 

733
00:35:45,560 --> 00:35:47,310
OK，但我真的很想得到詮釋。

734
00:35:47,310 --> 00:35:52,020
所以我可以去這裡，我可以種
複製和縮進。

735
00:35:52,020 --> 00:35:52,570
，然後“確定”。

736
00:35:52,570 --> 00:35:56,990
因此，如果n是小於或
等於零做到這一點。

737
00:35:56,990 --> 00:35:58,900
>> 現在，如果用戶
不配合？

738
00:35:58,900 --> 00:36:01,560
好吧，那麼我要
借用在這裡。

739
00:36:01,560 --> 00:36:03,130
然後我在這裡
這裡和這裡。

740
00:36:03,130 --> 00:36:06,420
因此，這顯然是不
的解決方案，對不對？

741
00:36:06,420 --> 00:36:07,810
因為有沒有結束的跡象。

742
00:36:07,810 --> 00:36:13,100
如果我想要求用戶提供
我一個正整數，我可以

743
00:36:13,100 --> 00:36:14,150
實際上得到的int。

744
00:36:14,150 --> 00:36:15,620
然後我就可以檢查這個int。

745
00:36:15,620 --> 00:36:18,570
但後​​來我想再次檢查和
再次檢查，並重新進行檢查。

746
00:36:18,570 --> 00:36:21,680
所以，很顯然，什麼是更好的
建造在這裡使用？

747
00:36:21,680 --> 00:36:22,840
所有的權利，所以某種循環。

748
00:36:22,840 --> 00:36:25,430
>> 所以，我要擺脫
幾乎所有這一切。

749
00:36:25,430 --> 00:36:27,320
我想要得到這個
int類型至少一次。

750
00:36:27,320 --> 00:36:28,890
所以我說的去做 - 

751
00:36:28,890 --> 00:36:32,110
我會回來的
而在短短的時刻 - 

752
00:36:32,110 --> 00:36:33,050
現在做什麼呢？

753
00:36:33,050 --> 00:36:35,860
我打算做INT N獲取調用getInt（）。

754
00:36:35,860 --> 00:36:36,080
確定。

755
00:36:36,080 --> 00:36:37,250
所以這是相當不錯的。

756
00:36:37,250 --> 00:36:39,750
現在怎麼經常做
我想這樣做嗎？

757
00:36:39,750 --> 00:36:45,770
>> 讓我把裡面的printf循環
這樣我就可以要求一遍又一遍，

758
00:36:45,770 --> 00:36:46,740
如果需要的話。

759
00:36:46,740 --> 00:36:49,720
什麼我想這
while條件怎麼辦？

760
00:36:49,720 --> 00:36:53,870
我想繼續這樣做
而事件是什麼？

761
00:36:53,870 --> 00:36:54,125
嗯。

762
00:36:54,125 --> 00:36:55,390
N是小於或等於零。

763
00:36:55,390 --> 00:36:58,180
的話，我們已經顯著
清理這個代碼。

764
00:36:58,180 --> 00:37:00,700
我們借了一個非常簡單的構建 - 
do-whil​​e循環。

765
00:37:00,700 --> 00:37:04,690
我剛剛被盜重要的行
我開始複製和代碼

766
00:37:04,690 --> 00:37:05,960
粘貼，這是不明智的。

767
00:37:05,960 --> 00:37:09,790
所以現在我要以實際粘貼
在這裡，只是做一次。

768
00:37:09,790 --> 00:37:12,990
>> 現在做什麼我想要做的
這個程序結束？

769
00:37:12,990 --> 00:37:16,810
我就簡單的說一下
喜歡，感謝 - 

770
00:37:16,810 --> 00:37:18,980
我會盡我為int％ - 

771
00:37:18,980 --> 00:37:23,270
反斜杠N，逗號，然後
插頭N，分號。

772
00:37:23,270 --> 00:37:23,910
>> 好的。

773
00:37:23,910 --> 00:37:27,290
因此，讓我們看看會發生什麼現在
當我運行這個程序。

774
00:37:27,290 --> 00:37:30,600
我要繼續前進，
做積極的。

775
00:37:30,600 --> 00:37:30,880
該死的。

776
00:37:30,880 --> 00:37:31,600
有幾個錯誤。

777
00:37:31,600 --> 00:37:32,960
因此，讓我向後滾動到第一。

778
00:37:32,960 --> 00:37:34,020
不要通過他們的工作倒退。

779
00:37:34,020 --> 00:37:37,000
通過他們的工作從上而下
免得他們級聯和

780
00:37:37,000 --> 00:37:38,630
有一件事是錯誤的。

781
00:37:38,630 --> 00:37:42,532
隱式聲明
函數調用getInt（）。

782
00:37:42,532 --> 00:37:43,020
嗯。

783
00:37:43,020 --> 00:37:44,420
因此，它是不夠的。

784
00:37:44,420 --> 00:37:46,760
我有點犯同樣的錯誤，但
這次有點不同。

785
00:37:46,760 --> 00:37:51,940
我不僅要包括stdio.h中，但
也cs50.h，其中包括

786
00:37:51,940 --> 00:37:56,770
所謂的聲明int時，其
教設備，或教

787
00:37:56,770 --> 00:37:58,760
C有什麼調用getInt（）。

788
00:37:58,760 --> 00:37:59,550
>> 因此，讓我重新保存。

789
00:37:59,550 --> 00:38:02,040
我要忽略其他錯誤
因為我希望他們

790
00:38:02,040 --> 00:38:05,210
主題相關的錯誤
我已經固定。

791
00:38:05,210 --> 00:38:08,710
因此，讓我繼續前進，重新編譯
與作出積極，回車。

792
00:38:08,710 --> 00:38:09,020
該死的。

793
00:38:09,020 --> 00:38:09,985
誤區三，仍然。

794
00:38:09,985 --> 00:38:12,650
讓我向上滾動到第一。

795
00:38:12,650 --> 00:38:14,320
未使用的變量n。

796
00:38:14,320 --> 00:38:15,850
我們從來沒見過此之前。

797
00:38:15,850 --> 00:38:17,200
而這，也同樣是一個有點神秘。

798
00:38:17,200 --> 00:38:18,850
這是編譯器的輸出。

799
00:38:18,850 --> 00:38:23,610
什麼，強調線
 -  positive.c :9:13  - 

800
00:38:23,610 --> 00:38:28,960
是說，它的上線九說
positive.c，在第13個字符，

801
00:38:28,960 --> 00:38:31,510
13列，你犯了這個錯誤。

802
00:38:31,510 --> 00:38:34,230
>> ，特別是，它告訴
我未使用的變量n。

803
00:38:34,230 --> 00:38:35,790
因此，讓我們來看看 - 

804
00:38:35,790 --> 00:38:37,150
九號線。

805
00:38:37,150 --> 00:38:40,430
我在這個意義上使用n
我給它一個值。

806
00:38:40,430 --> 00:38:44,200
但編譯不喜歡的是
我不是看似使用它。

807
00:38:44,200 --> 00:38:45,560
但是且慢，我使用它。

808
00:38:45,560 --> 00:38:48,170
在第11行，我在這裡使用。

809
00:38:48,170 --> 00:38:52,430
但是，如果我繼續向下滾動
於:11 positive.c  - 

810
00:38:52,430 --> 00:38:56,230
因此在第11行，12字符的
編譯器告訴我，使用

811
00:38:56,230 --> 00:38:58,670
未聲明的標識符N。

812
00:38:58,670 --> 00:39:02,760
>> 因此，未申報的手段，我有
不指定它作為一個

813
00:39:02,760 --> 00:39:04,970
變量的數據類型。

814
00:39:04,970 --> 00:39:05,500
但是且慢。

815
00:39:05,500 --> 00:39:09,150
我確實做到了，在九號線。

816
00:39:09,150 --> 00:39:11,100
所以有人在這裡真的很困惑。

817
00:39:11,100 --> 00:39:14,900
這是我或者編譯器，因為
九號線，再次，我聲明

818
00:39:14,900 --> 00:39:18,650
INT N，和我分配的
調用getInt（）的返回值。

819
00:39:18,650 --> 00:39:22,930
然後，我使用的變量n行
11和檢查，如果其值小於

820
00:39:22,930 --> 00:39:24,050
大於或等於零。

821
00:39:24,050 --> 00:39:27,430
但是，這顯然是
壞破為什麼？

822
00:39:27,430 --> 00:39:30,630

823
00:39:30,630 --> 00:39:32,490
再說一遍嗎？

824
00:39:32,490 --> 00:39:35,690
>> 啊，我要申報前N
進入循環。

825
00:39:35,690 --> 00:39:36,370
但是為什麼呢？

826
00:39:36,370 --> 00:39:39,830
我的意思是，我們只是提出了一點前，
聲明變量，它的罰款

827
00:39:39,830 --> 00:39:43,600
在一個行，然後
他們分配一定的價值。

828
00:39:43,600 --> 00:39:46,790
全局變量 - 讓我們回來
那只是一瞬間的想法。

829
00:39:46,790 --> 00:39:48,690
你為什麼要我把
它的循環之外？

830
00:39:48,690 --> 00:40:03,170

831
00:40:03,170 --> 00:40:03,830
它是。

832
00:40:03,830 --> 00:40:06,780
沒錯。

833
00:40:06,780 --> 00:40:09,610
>> 所以，雖然有點違反直覺，
讓我總結一下。

834
00:40:09,610 --> 00:40:13,510
當你聲明Ñ裡面
，do塊的 - 

835
00:40:13,510 --> 00:40:16,320
具體的內部
那些花括號 - 

836
00:40:16,320 --> 00:40:19,210
該變量n有什麼
所謂的範圍 - 

837
00:40:19,210 --> 00:40:23,210
我們的評分系統在無關
當然 - 但有一個範圍

838
00:40:23,210 --> 00:40:25,190
限於那些大括號。

839
00:40:25,190 --> 00:40:28,460
換句話說，通常如果你聲明
一組內的變量

840
00:40:28,460 --> 00:40:33,370
大括號，即變量只存在
那些大括號內。

841
00:40:33,370 --> 00:40:37,320
所以，儘管這個邏輯單
我宣布n在九號線，

842
00:40:37,320 --> 00:40:41,910
基本上消失，從範圍，
從內存中消失，可以這麼說，

843
00:40:41,910 --> 00:40:43,370
的時候，我打了11行。

844
00:40:43,370 --> 00:40:47,370
因為不幸的是，11號線，
外面那些大括號。

845
00:40:47,370 --> 00:40:51,540
>> 所以，我遺憾的是不能修復這個
回去我做了什麼之前。

846
00:40:51,540 --> 00:40:53,370
起初，你可能做到這一點。

847
00:40:53,370 --> 00:40:56,370
但什麼是你現在不
循環做？

848
00:40:56,370 --> 00:40:58,260
顯然，你沒有得到
的INT週期性。

849
00:40:58,260 --> 00:41:01,320
因此，我們可以離開調用getInt（），我們
應該離開調用getInt（）裡面的

850
00:41:01,320 --> 00:41:04,420
循環，因為這就是我們要
一次又一次纏著用戶。

851
00:41:04,420 --> 00:41:08,660
但它確實足以去
上升到線，比方說6。

852
00:41:08,660 --> 00:41:10,150
INT N，分號。

853
00:41:10,150 --> 00:41:12,990
不要給它的值，但由於
你不需要只是還沒有。

854
00:41:12,990 --> 00:41:16,220
>> 但是現在這裡，請注意 - 
將是一個非常容易犯的錯誤。

855
00:41:16,220 --> 00:41:19,440
我不想影子我以前
n的聲明。

856
00:41:19,440 --> 00:41:22,830
我想使用n
確實存在。

857
00:41:22,830 --> 00:41:25,780
所以現在10號線，
我給你N個值。

858
00:41:25,780 --> 00:41:28,580
但是，六行，我宣布N。

859
00:41:28,580 --> 00:41:32,940
所以我或我不能
使用它現在在第12行嗎？

860
00:41:32,940 --> 00:41:37,120
我行，因為它們之間捲髮
括號是n現在宣布呢？

861
00:41:37,120 --> 00:41:38,770
一起來這裡第五行。

862
00:41:38,770 --> 00:41:40,330
到這裡的人在第14行。

863
00:41:40,330 --> 00:41:49,770
所以，如果我現在縮小，保存此文件，請
備份和運行做出積極的，它

864
00:41:49,770 --> 00:41:50,820
編譯這個時候。

865
00:41:50,820 --> 00:41:51,940
因此，這已經進步。

866
00:41:51,940 --> 00:41:53,640
斜線。 /積極，回車。

867
00:41:53,640 --> 00:41:56,060
>> 我要求你給我
一個正整數。

868
00:41:56,060 --> 00:41:57,750
負1。

869
00:41:57,750 --> 00:41:59,020
負2。

870
00:41:59,020 --> 00:42:00,680
負3。

871
00:42:00,680 --> 00:42:01,760
為零。

872
00:42:01,760 --> 00:42:03,000
一。

873
00:42:03,000 --> 00:42:05,130
感謝一個
現在印。

874
00:42:05,130 --> 00:42:07,400
>> 讓我試試別的，
出於好奇。

875
00:42:07,400 --> 00:42:09,600
我被告知要輸入一個整數。

876
00:42:09,600 --> 00:42:12,870
但是，如果我，而不是鍵入羊肉？

877
00:42:12,870 --> 00:42:14,460
所以，你現在可以看到一個不同的提示 - 

878
00:42:14,460 --> 00:42:15,350
試。

879
00:42:15,350 --> 00:42:17,670
但無處在我的代碼
我寫重試。

880
00:42:17,670 --> 00:42:22,320
所以，據推測，這是重試
來自提示，你會說嗎？

881
00:42:22,320 --> 00:42:23,540
是啊，從調用getInt（）本身。

882
00:42:23,540 --> 00:42:26,650
所以CS50的員工做的事情之一
適合你，至少在這些最初的幾個

883
00:42:26,650 --> 00:42:30,400
週，我們已經寫了一些量
錯誤檢查，以確保，如果

884
00:42:30,400 --> 00:42:34,260
你叫調用getInt（），你會至少
從用戶得到一個int。

885
00:42:34,260 --> 00:42:35,460
你不會得到一個字符串。

886
00:42:35,460 --> 00:42:36,440
你不會得到一個字符。

887
00:42:36,440 --> 00:42:39,660
你不會得到的東西
否則乾脆。

888
00:42:39,660 --> 00:42:40,510
你會得到一個int。

889
00:42:40,510 --> 00:42:41,890
>> 現在，它可能不會是積極的。

890
00:42:41,890 --> 00:42:42,770
它可能不會是負數。

891
00:42:42,770 --> 00:42:44,550
解決這一問題，我們不作任何保證。

892
00:42:44,550 --> 00:42:48,960
但我們會糾纏使用者重試，
重試，重試，直到他或她居然

893
00:42:48,960 --> 00:42:49,810
合作。

894
00:42:49,810 --> 00:42:53,085
同樣，如果我做1.23，
這是不是一個int。

895
00:42:53,085 --> 00:42:58,400
但是，如果我不輸入，也就是說，50，
給我的價值，我想。

896
00:42:58,400 --> 00:42:59,050
>> 好的。

897
00:42:59,050 --> 00:43:01,380
所以不壞。

898
00:43:01,380 --> 00:43:04,780
上的任何問題，我們剛剛做了什麼？

899
00:43:04,780 --> 00:43:07,930
關鍵的外賣，是明確的，而不是
這麼多的循環，這是我們見過的

900
00:43:07,930 --> 00:43:10,880
即使之前，我們還沒有真正
使用它，但是範圍的問題，其中

901
00:43:10,880 --> 00:43:17,045
變量只能只能使用
一些指定的範圍內。

902
00:43:17,045 --> 00:43:19,830
>> 好吧，讓我解決的建議
你所說，一個

903
00:43:19,830 --> 00:43:20,860
全局變量。

904
00:43:20,860 --> 00:43:24,880
順便說一句，事實證明，另一
解決這個問題的，但

905
00:43:24,880 --> 00:43:28,880
通常是一個不正確的解決方案或
設計不佳的解決方案，

906
00:43:28,880 --> 00:43:31,670
什麼宣告變數
所謂的一個全局變量。

907
00:43:31,670 --> 00:43:34,610
現在，我有點違反我的定義
的範圍，因為有

908
00:43:34,610 --> 00:43:37,680
在最高層沒有大括號
最底部的文件。

909
00:43:37,680 --> 00:43:40,190
但含意，
是，現在第四行，

910
00:43:40,190 --> 00:43:41,710
n是一個全局變量。

911
00:43:41,710 --> 00:43:44,460
顧名思義，這是
只是到處訪問。

912
00:43:44,460 --> 00:43:45,790
>> 划痕實際上有這些。

913
00:43:45,790 --> 00:43:48,650
如果你使用一個變量，您可能還記得
你不得不選擇，如果它是為

914
00:43:48,650 --> 00:43:50,780
這個精靈或所有精靈。

915
00:43:50,780 --> 00:43:54,270
那麼，所有的精靈只是更清晰
說全球。

916
00:43:54,270 --> 00:43:55,520
是嗎？

917
00:43:55,520 --> 00:44:09,690

918
00:44:09,690 --> 00:44:10,990
啊，非常好的問題。

919
00:44:10,990 --> 00:44:14,310
>> 所以記得，在第一次版本
我的代碼，當我不正確

920
00:44:14,310 --> 00:44:17,700
聲明和定義的n行九 - 

921
00:44:17,700 --> 00:44:19,980
我宣布它作為一個變量
我給它一個價值

922
00:44:19,980 --> 00:44:21,160
賦值運算符 - 

923
00:44:21,160 --> 00:44:22,520
這給了我兩個錯誤。

924
00:44:22,520 --> 00:44:26,560
其中，事實是n不使用
和兩個，即在第11行

925
00:44:26,560 --> 00:44:27,770
它只是沒有宣布。

926
00:44:27,770 --> 00:44:31,120
因此，第一個我沒有
地址的時間。

927
00:44:31,120 --> 00:44:35,130
它不是嚴格意義上的錯誤申報
一個變量，但不能使用它。

928
00:44:35,130 --> 00:44:38,540
但其中的事情，我們已經做了
CS50設備，故意

929
00:44:38,540 --> 00:44:43,340
教學，是我們已經拍成了
預期的編譯器

930
00:44:43,340 --> 00:44:46,970
確保你正在做的事情不只是
正確的，但真正正確的。

931
00:44:46,970 --> 00:44:51,520
>> 因為如果你聲明一個變量
如n和從來沒有使用它，或使用

932
00:44:51,520 --> 00:44:53,700
正確的話，那麼什麼
它是做什麼呢？

933
00:44:53,700 --> 00:44:55,650
它真正沒有目的。

934
00:44:55,650 --> 00:44:58,980
而且它很容易隨著時間的推移，如果你
不配置您自己的電腦

935
00:44:58,980 --> 00:45:01,960
這樣一來，只是有代碼
這裡一點殘存，殘存有。

936
00:45:01,960 --> 00:45:04,390
然後，幾個月後你回頭看，
你像，這是為什麼行

937
00:45:04,390 --> 00:45:05,060
有代碼嗎？

938
00:45:05,060 --> 00:45:07,940
如果沒有很好的理由，
不利於你或你的同事

939
00:45:07,940 --> 00:45:10,650
在路上有
然後絆倒。

940
00:45:10,650 --> 00:45:12,540
>> 順便說一句，哪裡是
來自？

941
00:45:12,540 --> 00:45:16,410
嗯，記得我們每次編譯
計劃，所有這東西

942
00:45:16,410 --> 00:45:17,380
正在打印。

943
00:45:17,380 --> 00:45:18,350
所以，我們會回來的。

944
00:45:18,350 --> 00:45:22,230
但同樣，是一種實用工具，
自動編譯的過程中，由

945
00:45:22,230 --> 00:45:24,830
實際運行的編譯器
鐺。

946
00:45:24,830 --> 00:45:27,650
這件事情，我們最終會看到，有
做一個特殊的調試

947
00:45:27,650 --> 00:45:29,060
程序調用調試器。

948
00:45:29,060 --> 00:45:32,150
這具有與優化
代碼 - 未來。

949
00:45:32,150 --> 00:45:33,620
STD = C99  - 

950
00:45:33,620 --> 00:45:37,870
這也就意味著使用1999年版
C. C'S左右甚至更長的時間比

951
00:45:37,870 --> 00:45:40,830
，但他們提出了一些不錯的
變化10多年以前。

952
00:45:40,830 --> 00:45:42,690
>> 這裡是相關的。

953
00:45:42,690 --> 00:45:45,880
我們說做任何事情，
以前本來是一個警告

954
00:45:45,880 --> 00:45:48,560
防止學生的錯誤
從編譯。

955
00:45:48,560 --> 00:45:51,400
掛壁方式，對於一個
一大堆的東西，而不是

956
00:45:51,400 --> 00:45:53,060
只是涉及到的變量。

957
00:45:53,060 --> 00:45:54,700
然後讓我滾動
此行的末尾。

958
00:45:54,700 --> 00:45:56,430
這也，我們最終會
回來。

959
00:45:56,430 --> 00:45:59,040
這是很明顯的名稱
我編譯的文件。

960
00:45:59,040 --> 00:46:02,160
這回顧的文件的名稱
我輸出作為名稱的

961
00:46:02,160 --> 00:46:04,070
我的可運行程序。

962
00:46:04,070 --> 00:46:08,970
這只是意味著lcs50使用CS50
庫，以及任何的零和那些

963
00:46:08,970 --> 00:46:12,390
工作人員寫了先前編譯
今年，整合

964
00:46:12,390 --> 00:46:13,490
他們到我的程序。

965
00:46:13,490 --> 00:46:16,130
>> 有誰知道-LM是什麼？

966
00:46:16,130 --> 00:46:18,150
這是數學庫，這是
就在那裡，即使你

967
00:46:18,150 --> 00:46:19,320
沒有做任何數學。

968
00:46:19,320 --> 00:46:22,620
這只是自動提供
我們做。

969
00:46:22,620 --> 00:46:26,540
>> 好吧，讓我做一個其他的例子
在這裡開闢一個新的文件。

970
00:46:26,540 --> 00:46:30,560
讓我保存這個string.c。

971
00:46:30,560 --> 00:46:37,980
事實證明，作為我們談論的數據
類型的今天，甚至還有更多

972
00:46:37,980 --> 00:46:40,630
引擎蓋下
比我們迄今為止見過。

973
00:46:40,630 --> 00:46:42,290
因此，讓我很快做一個快速的程序。

974
00:46:42,290 --> 00:46:44,510
包括stdio.h中。

975
00:46:44,510 --> 00:46:45,730
我來救。

976
00:46:45,730 --> 00:46:48,110
而且你知道，讓我不能使
一次又一次地犯同樣的錯誤。

977
00:46:48,110 --> 00:46:50,540
包括cs50.h.

978
00:46:50,540 --> 00:46:54,870
讓我現在繼續
做詮釋的主要（無效）。

979
00:46:54,870 --> 00:46:58,790
>> 現在我只想做一個程序
這 - ​​聲明一個字符串

980
00:46:58,790 --> 00:47:03,610
s和得到一個字符串
從用戶。

981
00:47:03,610 --> 00:47:05,820
讓我做一個小小的
這裡說明 - 

982
00:47:05,820 --> 00:47:09,960
請給我一個字符串 - 
用戶知道該怎麼做。

983
00:47:09,960 --> 00:47:13,190
這裡再向下低於此，
我要做到以下幾點 - 

984
00:47:13,190 --> 00:47:16,060
INT I會變為零。

985
00:47:16,060 --> 00:47:18,580
同樣，計算機科學家通常
開始計數為零，但我們可以

986
00:47:18,580 --> 00:47:20,340
使那一個，如果我們真的想。

987
00:47:20,340 --> 00:47:27,240
現在我要做的i小於
比字符串s的長度。

988
00:47:27,240 --> 00:47:28,430
所以strlen的 - 

989
00:47:28,430 --> 00:47:29,510
S-T-R-L-E-Ñ - 

990
00:47:29,510 --> 00:47:31,650
再次，它的簡潔，因為它更容易
打字，即使它是一個

991
00:47:31,650 --> 00:47:32,590
有點神秘。

992
00:47:32,590 --> 00:47:35,290
>> 這是一個我們還沒有使用的功能
但字面上 - 

993
00:47:35,290 --> 00:47:37,810
我返回一個數字，表示
字符串的長度

994
00:47:37,810 --> 00:47:38,690
用戶鍵入。

995
00:47:38,690 --> 00:47:41,740
如果他們中鍵入“你好”，它會返回
五，因為有五

996
00:47:41,740 --> 00:47:42,890
字母打招呼。

997
00:47:42,890 --> 00:47:45,390
然後，在每一次迭代中
這個循環中，i再加加。

998
00:47:45,390 --> 00:47:49,170
如此反复，即使一個標準的構建
你不太舒服或太

999
00:47:49,170 --> 00:47:50,420
熟悉它。

1000
00:47:50,420 --> 00:47:53,220
>> 但是，現在在此循環中的每一次迭代，
注意什麼，我要做的事情。

1001
00:47:53,220 --> 00:47:56,690
我想去和打印
出單個字符 - 

1002
00:47:56,690 --> 00:47:59,940
所以％C反斜杠n在一個新行。

1003
00:47:59,940 --> 00:48:00,990
然後，你知道我想要做什麼？

1004
00:48:00,990 --> 00:48:05,090
無論字的用戶類型
，像你好，我想打印

1005
00:48:05,090 --> 00:48:09,530
H-E-L-L-O，每行一個字符。

1006
00:48:09,530 --> 00:48:13,080
換句話說，我希望得到的
單個字符串中的字符，

1007
00:48:13,080 --> 00:48:16,770
據此，到現在為止字符串
是一個字符序列。

1008
00:48:16,770 --> 00:48:21,690
>> 事實證明，我可以做，支架，
，密切支架，關閉

1009
00:48:21,690 --> 00:48:23,580
括號，分號。

1010
00:48:23,580 --> 00:48:25,640
我必須做的一件事。

1011
00:48:25,640 --> 00:48:30,570
這是在一個名為string.h中
，strlen的宣布。

1012
00:48:30,570 --> 00:48:33,190
所以，如果我想使用該功能，
我需要告訴編譯器，

1013
00:48:33,190 --> 00:48:34,450
希望使用它。

1014
00:48:34,450 --> 00:48:37,040
現在讓我繼續前進，使
字符串調用的程序。

1015
00:48:37,040 --> 00:48:39,150
點，斜線，字符串。

1016
00:48:39,150 --> 00:48:40,130
>> 請給我一個字符串。

1017
00:48:40,130 --> 00:48:40,900
我會繼續前進，鍵入它。

1018
00:48:40,900 --> 00:48:43,040
你好，在全部大寫，回車。

1019
00:48:43,040 --> 00:48:47,390
現在發現我已經印
後一個字符。

1020
00:48:47,390 --> 00:48:51,450
因此，新的細節在這裡是一個字符串，
在一天結束時，可

1021
00:48:51,450 --> 00:48:54,810
其個別方式訪問
字符引入廣場

1022
00:48:54,810 --> 00:48:55,840
支架符號。

1023
00:48:55,840 --> 00:48:59,090
那是因為一個字符串下方
引擎蓋的確是一個序列

1024
00:48:59,090 --> 00:48:59,810
字符。

1025
00:48:59,810 --> 00:49:02,010
但什麼是整齊的是
在您的計算機的RAM  - 

1026
00:49:02,010 --> 00:49:05,300
的Mac，PC，不管它是什麼 - 他們
從字面上回背靠背 - 

1027
00:49:05,300 --> 00:49:06,225
H-E-L-L-O  - 

1028
00:49:06,225 --> 00:49:09,920
個人，相鄰
在內存中的字節。

1029
00:49:09,920 --> 00:49:13,210
>> 所以，如果你想獲得等在第八屆
字節，它在這個循環中，將很

1030
00:49:13,210 --> 00:49:16,900
零支架，支架，支架兩個，
三支架，支架四 - 

1031
00:49:16,900 --> 00:49:18,890
零索引，直到五 - 

1032
00:49:18,890 --> 00:49:23,330
將打印出H-E-L-L-ø
在自己的行。

1033
00:49:23,330 --> 00:49:26,320
>> 現在，作為一個傳情，讓我告訴你
各種各樣的事情，你會最終

1034
00:49:26,320 --> 00:49:31,950
能夠理解，至少
與一些密切尋找。

1035
00:49:31,950 --> 00:49:35,610
為一體，包括在今天的
的例子，如果你願意，實際上是

1036
00:49:35,610 --> 00:49:38,300
第一越獄
為iPhone。

1037
00:49:38,300 --> 00:49:40,800
越獄是指破解手機
所以實際上，你可以用它在一個

1038
00:49:40,800 --> 00:49:43,380
不同的運營商或安裝
自己的軟件。

1039
00:49:43,380 --> 00:49:45,660
你會發現這看起來完全
神秘，最有可能的。

1040
00:49:45,660 --> 00:49:46,520
但是看看這個。

1041
00:49:46,520 --> 00:49:50,420
iPhone顯然破獲
一個for循環，如果條件，其他

1042
00:49:50,420 --> 00:49:52,580
條件下，一組函數
我們從來沒見過的。

1043
00:49:52,580 --> 00:49:54,230
>> 再次，你不會在
乍一看可能

1044
00:49:54,230 --> 00:49:55,620
明白這是怎麼工作的。

1045
00:49:55,620 --> 00:49:58,940
但是我們採取的一切
授予在我們的現代生活

1046
00:49:58,940 --> 00:50:02,040
實際上趨於減少，甚至一些
這些基本面，我們已經

1047
00:50:02,040 --> 00:50:02,820
看著。

1048
00:50:02,820 --> 00:50:06,680
讓我繼續前進，打開一個
其他程序，holloway.c。

1049
00:50:06,680 --> 00:50:08,970
，也因此，這是你
真的不應該知道。

1050
00:50:08,970 --> 00:50:12,440
甚至沒有工作人員或者我可以
大概弄清楚了這一點，通過觀察

1051
00:50:12,440 --> 00:50:15,450
，因為這是別人的代碼
提交什麼

1052
00:50:15,450 --> 00:50:19,630
歷史上被稱為一個模糊處理C
比賽，在那裡你寫一個程序

1053
00:50:19,630 --> 00:50:24,670
編譯和運行，但這麼該死的
神秘的無人能明白什麼

1054
00:50:24,670 --> 00:50:27,530
它這樣做，直到
他們實際上運行它。

1055
00:50:27,530 --> 00:50:29,940
>> 因此，我們確實，如果你看一下
代碼中，我看到一個開關。

1056
00:50:29,940 --> 00:50:30,870
我看到主。

1057
00:50:30,870 --> 00:50:33,800
我看到這些方括號暗示
某種類型的一個數組。

1058
00:50:33,800 --> 00:50:35,970
有誰不想去猜測什麼
實際上這個程序

1059
00:50:35,970 --> 00:50:37,220
如果我跑霍洛威？

1060
00:50:37,220 --> 00:50:39,940

1061
00:50:39,940 --> 00:50:40,750
是。

1062
00:50:40,750 --> 00:50:43,050
確定。

1063
00:50:43,050 --> 00:50:44,690
幹得好。

1064
00:50:44,690 --> 00:50:48,090
因此，只有工作人員和我想不通
出這些東西做什麼。

1065
00:50:48,090 --> 00:50:51,670
>> 最後，讓我繼續
並開拓其他程序。

1066
00:50:51,670 --> 00:50:53,440
這一次 - 

1067
00:50:53,440 --> 00:50:55,550
再次，我們就會使源代碼
可在網上 - 這就是

1068
00:50:55,550 --> 00:50:57,480
樣靚來看待。

1069
00:50:57,480 --> 00:50:59,750
他們所做的一切被擊中
空格鍵頗有幾分。

1070
00:50:59,750 --> 00:51:01,320
但是，這是真正的代碼。

1071
00:51:01,320 --> 00:51:04,790
所以，如果你認為那是相當，如果我們
實際運行此提示，

1072
00:51:04,790 --> 00:51:08,970
最終你將看到我們如何
可能做這樣的事情。

1073
00:51:08,970 --> 00:51:14,008
>> 因此，我們將離開你，說明
看到你在週三。

1074
00:51:14,008 --> 00:51:18,440
>> [音樂播放]

1075
00:51:18,440 --> 00:51:23,380
>> 揚聲器2：在接下來的CS50，
TFS上演一場兵變。

1076
00:51:23,380 --> 00:51:24,112
>> 揚聲器3：在那裡，他是。

1077
00:51:24,112 --> 00:51:25,362
抓住他！

1078
00:51:25,362 --> 00:51:29,912

1079
00:51:29,912 --> 00:51:32,074
>> [音樂播放]