1
00:00:00,000 --> 00:00:10,940

2
00:00:10,940 --> 00:00:13,060
>> 大衛·馬蘭：所有
沒錯，所以這是CS50。

3
00:00:13,060 --> 00:00:15,040
而這顯然是一個星期五。

4
00:00:15,040 --> 00:00:16,850
而這是一個星期的末端。

5
00:00:16,850 --> 00:00:21,020
所以，你可能還記得，我們​​不放過，
最後一次，有各種各樣的懸念。

6
00:00:21,020 --> 00:00:25,020
我們藉以揭露這個謊言，沒有
不管你被教導成長

7
00:00:25,020 --> 00:00:31,610
向上，1除以10不是在
事實上，0.1或0.100或0.10000。

8
00:00:31,610 --> 00:00:35,270
事實上，如果我們編譯這個
計劃，因為我們沒有昨天，有，

9
00:00:35,270 --> 00:00:39,770
使不精確性，然後
做點，斜線，不精確，

10
00:00:39,770 --> 00:00:43,600
我們了解到，這是什麼
1除以10實際上是。

11
00:00:43,600 --> 00:00:46,140
所以這不是真的相當的情況下。

12
00:00:46,140 --> 00:00:49,014
但是，這確實暗示了一些
電腦的基本限制。

13
00:00:49,014 --> 00:00:50,930
事實上，中
我們將要做的事情

14
00:00:50,930 --> 00:00:55,130
今天就來看看為什麼這有
事情發生了，有什麼意義這有，

15
00:00:55,130 --> 00:00:58,430
人類如何失敗
掌握這一些很

16
00:00:58,430 --> 00:01:00,410
嚴重situations--
在其結果

17
00:01:00,410 --> 00:01:03,141
已經相當慘烈
和expensive--也

18
00:01:03,141 --> 00:01:04,849
看看我們如何
實際上可以捍衛

19
00:01:04,849 --> 00:01:06,530
針對這些種類的限制。

20
00:01:06,530 --> 00:01:10,940
所以直覺，也許，
為什麼是1除以10，

21
00:01:10,940 --> 00:01:15,480
根據我的電腦
這裡，不只是的1/10，0.10？

22
00:01:15,480 --> 00:01:15,980
是啊。

23
00:01:15,980 --> 00:01:16,530
你怎麼看？

24
00:01:16,530 --> 00:01:17,860
>> 觀眾：基數是不同的？

25
00:01:17,860 --> 00:01:18,550
>> 大衛·馬蘭：該是什麼？

26
00:01:18,550 --> 00:01:19,730
呵呵，基數是不同的？

27
00:01:19,730 --> 00:01:20,720
因此，不完全是。

28
00:01:20,720 --> 00:01:23,200
它實際上更多
基本的硬件。

29
00:01:23,200 --> 00:01:23,980
其他的想法？

30
00:01:23,980 --> 00:01:24,584
是啊。

31
00:01:24,584 --> 00:01:26,750
觀眾：他們
表示數字不同？

32
00:01:26,750 --> 00:01:27,880
大衛·馬蘭：所以they--權。

33
00:01:27,880 --> 00:01:29,338
他們代表的數字不同。

34
00:01:29,338 --> 00:01:30,700
不準確，很明顯。

35
00:01:30,700 --> 00:01:33,190
這樣is--好，
不同於什麼？

36
00:01:33,190 --> 00:01:34,490
或者從誰？

37
00:01:34,490 --> 00:01:35,050
從我們呢？

38
00:01:35,050 --> 00:01:35,966
觀眾：是啊。

39
00:01:35,966 --> 00:01:38,930
它們不使用小數
系統[聽不清]。

40
00:01:38,930 --> 00:01:39,680
大衛·馬蘭：OK。

41
00:01:39,680 --> 00:01:41,560
因此，從某種意義上說，他們不
使用十進制系統。

42
00:01:41,560 --> 00:01:43,720
在系統底層，
一切，的確，二進制，

43
00:01:43,720 --> 00:01:45,510
這就是相關的，其實。

44
00:01:45,510 --> 00:01:48,135
但是，它甚至更簡單
解釋比。

45
00:01:48,135 --> 00:01:48,635
是啊。

46
00:01:48,635 --> 00:01:49,970
>> 觀眾：他們
只有這麼多的位。

47
00:01:49,970 --> 00:01:52,370
他們最多只能存儲一定
某種程度上，像小數。

48
00:01:52,370 --> 00:01:52,780
>> 大衛·馬蘭：是的。

49
00:01:52,780 --> 00:01:54,420
這是什麼真正得到它。

50
00:01:54,420 --> 00:01:57,180
事實證明，計算機
通常情況下，將永遠只有

51
00:01:57,180 --> 00:01:59,690
使用的信息的有限數量
代表什麼。

52
00:01:59,690 --> 00:01:59,870
對嗎？

53
00:01:59,870 --> 00:02:02,110
畢竟，我們只有一個固定的
量的硬盤空間。

54
00:02:02,110 --> 00:02:04,210
我們只有一個固定量
的RAM，或計算機的內存。

55
00:02:04,210 --> 00:02:06,251
如果你只有一個
固定金額的東西，

56
00:02:06,251 --> 00:02:09,611
當然你不能真正計數
到無窮大或任何你想要的數字。

57
00:02:09,611 --> 00:02:11,610
你有種，有
挑選什麼範圍

58
00:02:11,610 --> 00:02:13,220
值你要支持。

59
00:02:13,220 --> 00:02:18,100
>> 因此，例如，一兩個星期
以前，當我們談到ASCII，

60
00:02:18,100 --> 00:02:21,610
我們談了8位，
或字節，可以這麼說，

61
00:02:21,610 --> 00:02:26,360
最大數我們可以
有8位表示是什麼呢？

62
00:02:26,360 --> 00:02:28,350
255。

63
00:02:28,350 --> 00:02:31,850
我們可以表示256個總價值
但如果我們把其中的一個

64
00:02:31,850 --> 00:02:34,190
在0--好了，但如果我們
花其中的一個0，

65
00:02:34,190 --> 00:02:36,830
那麼最大的數
是，當然，255。

66
00:02:36,830 --> 00:02:39,410
>> 所以，事實證明，這是
的情況下也一樣，在這種情況下。

67
00:02:39,410 --> 00:02:42,350
我們開始談，最後一次，
有關浮點數字，

68
00:02:42,350 --> 00:02:44,640
來自整數不同，在
他們有一個小數點

69
00:02:44,640 --> 00:02:47,056
並希望一些數字
在這之後，但是它們太。

70
00:02:47,056 --> 00:02:51,730
一台計算機通常只打算
使用32位，也許64位

71
00:02:51,730 --> 00:02:53,497
來表示一個浮點值。

72
00:02:53,497 --> 00:02:56,080
因此，即使我們已經長大了
學習數學和了解

73
00:02:56,080 --> 00:02:58,750
你絕對可以有
數的無限數量

74
00:02:58,750 --> 00:03:01,650
小數點後不
如果你有有限的內存。

75
00:03:01,650 --> 00:03:03,930
你有種，有圓形，
或者挑選哪些

76
00:03:03,930 --> 00:03:05,346
你會數來表示。

77
00:03:05,346 --> 00:03:08,710
所以，你能想到的，從某種意義上說，
這是計算機的最接近

78
00:03:08,710 --> 00:03:14,050
近似​​的值的1/10
它可以得到，只有32左右位。

79
00:03:14,050 --> 00:03:15,300
而且它不只是1/10。

80
00:03:15,300 --> 00:03:19,820
>> 舉例來說，如果我改變這
1/3，我們認為這是更簡單。

81
00:03:19,820 --> 00:03:21,300
因此，1除以3。

82
00:03:21,300 --> 00:03:22,355
讓我保存文件。

83
00:03:22,355 --> 00:03:24,680
讓我繼續前進，重新編譯它。

84
00:03:24,680 --> 00:03:25,820
讓我重新運行它。

85
00:03:25,820 --> 00:03:30,000
在這裡，顯然，三分之一沒有0.3
然後3的無限數量

86
00:03:30,000 --> 00:03:30,770
其後。

87
00:03:30,770 --> 00:03:32,540
你有這樣的不精確性在最後。

88
00:03:32,540 --> 00:03:35,544
所以，我們人類是正確的，什麼
你了解，其實，正確的，

89
00:03:35,544 --> 00:03:37,460
但是我們撞了
針對一些限制。

90
00:03:37,460 --> 00:03:39,420
>> 而我的想法
我們今天會做，是開始

91
00:03:39,420 --> 00:03:42,190
通過看，坦率地說，在
這種悲慘的後果

92
00:03:42,190 --> 00:03:45,490
有時，人類的時候
並不完全實現

93
00:03:45,490 --> 00:03:48,460
針對這一現實，這些限制。

94
00:03:48,460 --> 00:03:52,360
而且我們會看到一系列的小插圖
從歷史頻道的需要

95
00:03:52,360 --> 00:03:53,950
一起來看看如何事情已經出了問題。

96
00:03:53,950 --> 00:03:56,340
這是約8分鐘之久，
我們將在這之後回來

97
00:03:56,340 --> 00:03:59,439
看一看在完全相同
還有什麼可能出錯。

98
00:03:59,439 --> 00:04:00,605
如果我們能昏暗的lights--

99
00:04:00,605 --> 00:04:02,350
>> [視頻回放]

100
00:04:02,350 --> 00:04:06,310
>> -Computers，我們都逐漸接受
經常令人沮喪的問題，

101
00:04:06,310 --> 00:04:07,750
和他們一起去。

102
00:04:07,750 --> 00:04:11,370
錯誤，病毒，和軟件
故障都是小的價格

103
00:04:11,370 --> 00:04:13,230
支付的便利。

104
00:04:13,230 --> 00:04:17,519
但是，在高科技和高速
軍事和航天計劃的應用，

105
00:04:17,519 --> 00:04:22,130
可以最小的問題
被放大成災難。

106
00:04:22,130 --> 00:04:27,750
1996年6月4日，科學家準備
啟動一個無人阿麗亞娜5型火箭。

107
00:04:27,750 --> 00:04:29,890
它攜帶的科學
衛星設計

108
00:04:29,890 --> 00:04:33,030
建立精確如何
地球的磁場相互作用

109
00:04:33,030 --> 00:04:35,600
與太陽風。

110
00:04:35,600 --> 00:04:37,930
火箭是專為
歐洲航天局

111
00:04:37,930 --> 00:04:41,620
並從其工廠升空
在法屬圭亞那的海岸。

112
00:04:41,620 --> 00:04:44,924
>>  - 和大約30秒後進入
飛行中，他們首先

113
00:04:44,924 --> 00:04:46,340
發現了一些打算錯了。

114
00:04:46,340 --> 00:04:49,280
使噴嘴被旋轉
在某種程度上，他們真的不應該。

115
00:04:49,280 --> 00:04:53,042
約40秒後進入飛行，
明確了車輛遇到了麻煩，

116
00:04:53,042 --> 00:04:55,250
而當他們提出的
決定摧毀它。

117
00:04:55,250 --> 00:04:58,970
隨著一系列安全主任
巨大的勇氣按下按鈕，

118
00:04:58,970 --> 00:05:03,940
炸毀了火箭之前，它可能
成為危害公眾安全。

119
00:05:03,940 --> 00:05:06,600
>>  - 這是處女
阿麗亞娜5的航程，

120
00:05:06,600 --> 00:05:09,270
它破壞了
地方，因為一個缺陷

121
00:05:09,270 --> 00:05:10,992
嵌在火箭的軟件。

122
00:05:10,992 --> 00:05:12,700
在-The問題
阿麗亞娜是，有

123
00:05:12,700 --> 00:05:15,370
是一個數字，需要
64位表示，

124
00:05:15,370 --> 00:05:18,150
他想轉換
它以一個16位的數。

125
00:05:18,150 --> 00:05:21,160
他們假定數
從來沒有將是非常大的，

126
00:05:21,160 --> 00:05:25,020
大多數的這些數字中
64位數字是0。

127
00:05:25,020 --> 00:05:26,310
但他們錯了。

128
00:05:26,310 --> 00:05:28,680
>> 一-The無力
軟件程序接受

129
00:05:28,680 --> 00:05:32,820
所產生的那種數
另一種是在失敗的根源。

130
00:05:32,820 --> 00:05:37,190
軟件開發已經成為一個
的新技術非常昂貴的部分。

131
00:05:37,190 --> 00:05:40,760
阿麗亞娜-4火箭一直非常
成功的，那麼多的軟件

132
00:05:40,760 --> 00:05:43,990
創造這也是
用在阿麗亞娜5。

133
00:05:43,990 --> 00:05:49,750
>> -The基本的問題是，阿麗亞娜
5增快，加速快。

134
00:05:49,750 --> 00:05:53,000
而且軟件早已不是
佔了這一點。

135
00:05:53,000 --> 00:05:56,330
>> 火箭-The破壞
是一個巨大的金融災難，

136
00:05:56,330 --> 00:05:59,670
全因一分鐘，軟件錯誤。

137
00:05:59,670 --> 00:06:01,990
但是，這是不是第一次
實時數據轉換問題

138
00:06:01,990 --> 00:06:05,310
一直困擾現代火箭技術。

139
00:06:05,310 --> 00:06:08,300
>> -in 1991，在開始
第一次海灣戰爭中，

140
00:06:08,300 --> 00:06:10,650
愛國者導彈
經歷了類似的一種

141
00:06:10,650 --> 00:06:12,650
數轉換的問題。

142
00:06:12,650 --> 00:06:15,620
其結果是，28人，
28美國士兵

143
00:06:15,620 --> 00:06:18,440
被打死，約
100人受傷，

144
00:06:18,440 --> 00:06:21,900
當愛國者，這是應該
以防止傳入的飛毛腿導彈，

145
00:06:21,900 --> 00:06:24,630
沒有發射導彈。

146
00:06:24,630 --> 00:06:29,440
>>  - 當伊拉克入侵科威特和美國
在1991年年初推出沙漠風暴，

147
00:06:29,440 --> 00:06:33,800
愛國者導彈部署
保護沙特阿拉伯和以色列

148
00:06:33,800 --> 00:06:37,000
從伊拉克飛毛腿導彈攻擊。

149
00:06:37,000 --> 00:06:40,610
愛國者是美國，中程
表面對空氣系統

150
00:06:40,610 --> 00:06:43,010
由雷神公司製造。

151
00:06:43,010 --> 00:06:49,080
>> 愛國者攔截-The大小，
本身就是約，約20英尺長。

152
00:06:49,080 --> 00:06:51,250
而且它的重量約2000磅。

153
00:06:51,250 --> 00:06:55,195
同時還可以進行about--的彈頭
我認為這是約150磅。

154
00:06:55,195 --> 00:06:59,500
和彈頭本身，
是一種高爆炸藥，

155
00:06:59,500 --> 00:07:02,570
它有它周圍的碎片。

156
00:07:02,570 --> 00:07:06,890
彈頭的外殼是
設計像鹿彈。

157
00:07:06,890 --> 00:07:09,130
>> -The導彈
進行，4％的集裝箱，

158
00:07:09,130 --> 00:07:12,080
並通過半拖車被運送。

159
00:07:12,080 --> 00:07:19,100
>> -The愛國者反導彈系統
追溯到現在至少需要20年。

160
00:07:19,100 --> 00:07:22,320
它最初的設計
作為防空導彈

161
00:07:22,320 --> 00:07:24,180
擊落敵人的飛機。

162
00:07:24,180 --> 00:07:27,860
在第一次海灣戰爭，
當戰爭來了，

163
00:07:27,860 --> 00:07:32,745
陸軍希望用它來
擊落飛毛腿導彈，而不是飛機。

164
00:07:32,745 --> 00:07:36,150
伊拉克隊還是沒有
這麼多的問題，

165
00:07:36,150 --> 00:07:39,110
但陸軍擔心飛毛腿導彈。

166
00:07:39,110 --> 00:07:42,340
因此，他們試圖
升級愛國者。

167
00:07:42,340 --> 00:07:44,760
>> -Intercepting敵人
導彈行駛在馬赫5

168
00:07:44,760 --> 00:07:47,250
將要進行足夠的挑戰。

169
00:07:47,250 --> 00:07:50,000
但是愛國者的時候
被衝進服務，

170
00:07:50,000 --> 00:07:54,030
陸軍不知道的
，使得伊拉克修改

171
00:07:54,030 --> 00:07:56,840
他們的飛毛腿導彈幾乎是不可能的打擊。

172
00:07:56,840 --> 00:08:01,020
>>  - 什麼事，是飛毛腿的
要來的，是不穩定的，

173
00:08:01,020 --> 00:08:02,310
他們搖晃。

174
00:08:02,310 --> 00:08:05,140
這樣做的原因，
是伊拉克人，為了

175
00:08:05,140 --> 00:08:09,450
讓600公里出
300公里的射程導彈，

176
00:08:09,450 --> 00:08:12,930
把重出前彈頭
並提出彈頭更輕。

177
00:08:12,930 --> 00:08:17,710
所以，現在，愛國者的苦思
在飛毛腿，並且大多數時候，

178
00:08:17,710 --> 00:08:21,700
絕大多數的
時間，它只是由飛毛腿飛。

179
00:08:21,700 --> 00:08:25,700
>>  - 一旦愛國者系統運營商
實現了愛國者偏離目標，

180
00:08:25,700 --> 00:08:29,790
他們引爆了愛國者彈頭，
為了避免可能的人員傷亡，如果它

181
00:08:29,790 --> 00:08:32,380
被允許倒在地上。

182
00:08:32,380 --> 00:08:36,340
>>  - 那是大多數人所看到的，
那些大火球在天空中，

183
00:08:36,340 --> 00:08:41,289
和誤解為
飛毛腿彈頭的攔截。

184
00:08:41,289 --> 00:08:43,590
雖然在夜間
天空，愛國者亮相

185
00:08:43,590 --> 00:08:47,020
要成功地
摧毀飛毛腿導彈，在達蘭，

186
00:08:47,020 --> 00:08:49,730
有可能是沒有錯
關於它的性能。

187
00:08:49,730 --> 00:08:53,990
在那裡，愛國者的雷達系統
失去了進入的飛毛腿的軌道，

188
00:08:53,990 --> 00:08:56,650
永不推出，
由於軟件缺陷。

189
00:08:56,650 --> 00:08:59,650

190
00:08:59,650 --> 00:09:04,100
這是誰首先發現了以色列人
該系統不再是上，

191
00:09:04,100 --> 00:09:07,510
越大時間差異
成為，由於一個時鐘的嵌入式

192
00:09:07,510 --> 00:09:09,490
在系統的計算機。

193
00:09:09,490 --> 00:09:12,670
>>  - 關於前2週
悲劇發生在宰赫蘭，

194
00:09:12,670 --> 00:09:15,010
以色列人報
國防部，

195
00:09:15,010 --> 00:09:17,940
該系統是浪費時間，
該後約8小時的運行，

196
00:09:17,940 --> 00:09:21,410
他們注意到，該系統
變得明顯不太準確。

197
00:09:21,410 --> 00:09:25,290
國防部回應
告訴所有的愛國者電池

198
00:09:25,290 --> 00:09:28,070
不離開系統
上很長一段時間。

199
00:09:28,070 --> 00:09:29,960
他們從來不說什麼很長一段時間了。

200
00:09:29,960 --> 00:09:30,460
8小時？

201
00:09:30,460 --> 00:09:30,960
10小時？

202
00:09:30,960 --> 00:09:31,870
千小時？

203
00:09:31,870 --> 00:09:33,734
沒有人知道。

204
00:09:33,734 --> 00:09:35,650
-The愛國者電池
駐紮在軍營

205
00:09:35,650 --> 00:09:40,410
在宰赫蘭的，其有缺陷的內部
時鐘，已經在超過100小時

206
00:09:40,410 --> 00:09:43,041
2月25日的晚上。

207
00:09:43,041 --> 00:09:47,416
>>  - 它跟踪時間精度
約一秒的1/10。

208
00:09:47,416 --> 00:09:49,290
現在1/10秒是
一個有趣的數字

209
00:09:49,290 --> 00:09:52,700
因為它不能
按二進制，沒錯。

210
00:09:52,700 --> 00:09:54,820
這意味著，它不能
表示，準確地說，

211
00:09:54,820 --> 00:09:57,420
在任何現代數字計算機。

212
00:09:57,420 --> 00:10:01,460
很難相信，但
使用這個作為一個例子。

213
00:10:01,460 --> 00:10:03,520
讓我們來數的1/3。

214
00:10:03,520 --> 00:10:07,110
三分之一不能表示
十進制，沒錯。

215
00:10:07,110 --> 00:10:11,490
1/3是0.333持續了無窮大。

216
00:10:11,490 --> 00:10:15,486
有沒有辦法做到這一點，有
絕對精度，十進制。

217
00:10:15,486 --> 00:10:18,360
這正是相同種類的
問題發生在愛國者。

218
00:10:18,360 --> 00:10:22,510
該系統運行更長的
更糟糕的時間誤差成了。

219
00:10:22,510 --> 00:10:28,420
>> -After運行100小時，誤差
在時間只有一秒鐘的約1/3。

220
00:10:28,420 --> 00:10:31,830
但是，在針對一個方面
導彈5馬赫旅行，

221
00:10:31,830 --> 00:10:35,890
它導致了跟踪
對600多萬米的錯誤。

222
00:10:35,890 --> 00:10:38,970
這將是一個致命的錯誤
對於戰士在宰赫蘭。

223
00:10:38,970 --> 00:10:45,035
>>  - 什麼事，是飛毛腿發射是
通過預警衛星探測，

224
00:10:45,035 --> 00:10:48,930
他們新的飛毛腿是
即將在他們的大方向。

225
00:10:48,930 --> 00:10:51,170
他們不知道有人來了。

226
00:10:51,170 --> 00:10:53,990
>> 現在 - 它要由雷達
愛國者系統的組成部分，

227
00:10:53,990 --> 00:10:58,520
保衛達蘭，定位和保持
跟踪來襲的敵方導彈。

228
00:10:58,520 --> 00:10:59,690
>> -The雷達是非常聰明的。

229
00:10:59,690 --> 00:11:01,710
它實際上跟踪
飛毛腿的位置

230
00:11:01,710 --> 00:11:04,040
然後預測哪裡
它很可能是，

231
00:11:04,040 --> 00:11:06,140
接下來的時間，該
雷達發送的脈衝輸出。

232
00:11:06,140 --> 00:11:07,660
這被稱為距離門。

233
00:11:07,660 --> 00:11:11,870
>>  - 然後，一旦愛國者
決定時間已夠

234
00:11:11,870 --> 00:11:16,280
傳遞回去檢查下
具體地址為檢測對象，

235
00:11:16,280 --> 00:11:17,280
它可以追溯到。

236
00:11:17,280 --> 00:11:21,690
因此，當它回到了錯
地方，然後看到沒有對象

237
00:11:21,690 --> 00:11:25,230
和它決定，沒有
對象，這是一個錯誤的檢測，

238
00:11:25,230 --> 00:11:26,650
和下降的軌道。

239
00:11:26,650 --> 00:11:29,690
傳入飛毛腿消失
從雷達屏幕上，

240
00:11:29,690 --> 00:11:32,670
幾秒鐘後，它
撞上了軍營。

241
00:11:32,670 --> 00:11:38,100
飛毛腿殺害28是最後一個
第一次海灣戰爭期間，人開火。

242
00:11:38,100 --> 00:11:43,460
可悲的是，更新的軟件
抵達宰赫蘭的第二天。

243
00:11:43,460 --> 00:11:46,150
軟件缺陷有
得到修復，閉合

244
00:11:46,150 --> 00:11:48,940
在陷入困境的一章
愛國者導彈的歷史。

245
00:11:48,940 --> 00:11:50,220
>> [結束播放]

246
00:11:50,220 --> 00:11:54,340
>> 大衛·馬蘭：所以我們就來看看
一些類似的限制，只是有點。

247
00:11:54,340 --> 00:11:58,470
但首先，讓我們來
過渡到一些僅供參考的。

248
00:11:58,470 --> 00:12:01,575
因此，埃德蒙頓這個週末，有
將超級部分，

249
00:12:01,575 --> 00:12:04,200
這意味著可以​​取代
定期的部分，這

250
00:12:04,200 --> 00:12:05,460
將一個星期，因此啟動。

251
00:12:05,460 --> 00:12:08,204
看看在CS50的網站
對於這些詳細信息。

252
00:12:08,204 --> 00:12:11,120
他們也將被拍攝下來，流
住那些無法參加。

253
00:12:11,120 --> 00:12:12,980
問題1是關於
當然，本已網站，

254
00:12:12,980 --> 00:12:15,105
我們將看看
在只是一點點。

255
00:12:15,105 --> 00:12:18,350
而辦公時間也將採取
至週四把這個星期一。

256
00:12:18,350 --> 00:12:20,960
>> 因此，這是最典型
節目中，我們看了最後一次。

257
00:12:20,960 --> 00:12:23,590
這就像最簡單
程序，你可以用C寫的，

258
00:12:23,590 --> 00:12:25,250
即使這是一個有點大膽索賠。

259
00:12:25,250 --> 00:12:25,750
對嗎？

260
00:12:25,750 --> 00:12:28,070
因為有很多的
似乎複雜此。

261
00:12:28,070 --> 00:12:30,445
所以，讓我們快速瀏覽一下
什麼一些這些元件中的

262
00:12:30,445 --> 00:12:33,080
分別為，然後嘗試提供
如何的心理模型

263
00:12:33,080 --> 00:12:35,710
這些簡單的程序
工作，然後我們將開始

264
00:12:35,710 --> 00:12:38,050
看事情越來越複雜。

265
00:12:38,050 --> 00:12:41,280
因此，這條線在這裡，現在強調的，
在黃色的，沒有大家說什麼，最後一次，

266
00:12:41,280 --> 00:12:43,200
這為我們做？

267
00:12:43,200 --> 00:12:45,220
什麼是它服務的目的是什麼？

268
00:12:45,220 --> 00:12:46,984
任何人從更遠了？

269
00:12:46,984 --> 00:12:47,483
是啊。

270
00:12:47,483 --> 00:12:48,649
>> 觀眾：[聽不清]

271
00:12:48,649 --> 00:12:50,871

272
00:12:50,871 --> 00:12:51,704
大衛·馬蘭：好。

273
00:12:51,704 --> 00:12:53,537
所以，它給你的訪問
為命令，或讓我們

274
00:12:53,537 --> 00:12:56,750
給他們打電話的功能，有人
別人寫的，被聲明，

275
00:12:56,750 --> 00:12:58,350
可以這麼說，在一些其他的文件。

276
00:12:58,350 --> 00:13:02,370
所以我們會看到什麼.h文件
是對.c文件，最終。

277
00:13:02,370 --> 00:13:04,710
但現在，只知道
該printf的，例如，

278
00:13:04,710 --> 00:13:08,370
是其中已被功能
在其他文件中聲明，在某處

279
00:13:08,370 --> 00:13:12,930
否則雲計算的硬盤​​驅動器上
允許我們訪問printf和使用

280
00:13:12,930 --> 00:13:15,240
而不必重新發明
那個輪子自己。

281
00:13:15,240 --> 00:13:16,930
同時，主要的。

282
00:13:16,930 --> 00:13:19,690
什麼是主要的，上週的模擬？

283
00:13:19,690 --> 00:13:20,190
是啊。

284
00:13:20,190 --> 00:13:21,460
>> 觀眾：綠旗點擊。

285
00:13:21,460 --> 00:13:21,740
>> 大衛·馬蘭：是的。

286
00:13:21,740 --> 00:13:23,490
划痕的，當綠旗點擊。

287
00:13:23,490 --> 00:13:25,560
這就像一塊拼圖
該踢東西了。

288
00:13:25,560 --> 00:13:28,306
所以同樣，做世界
幾年前的決定C，

289
00:13:28,306 --> 00:13:30,930
和一堆其他語言，
如果你想編寫一個程序，

290
00:13:30,930 --> 00:13:33,410
你的第一個功能
已被調用，主。

291
00:13:33,410 --> 00:13:34,641
而且它有看起來像這樣。

292
00:13:34,641 --> 00:13:36,640
但是，我們會回來的，
另一次，是什麼，INT，

293
00:13:36,640 --> 00:13:38,690
並且，無效的，意味著在這方面。

294
00:13:38,690 --> 00:13:42,860
就目前而言，花括號樣
像划痕的拼圖形狀

295
00:13:42,860 --> 00:13:45,080
它封裝線的一些數字。

296
00:13:45,080 --> 00:13:47,070
而就在電線之間
在這裡，這是一個在這裡。

297
00:13:47,070 --> 00:13:51,610
printf的是，其目的在一個函數
生活是打印的格式化字符串。

298
00:13:51,610 --> 00:13:55,010
而到格式化的，我的意思是你
可以在佔位符值堵塞，

299
00:13:55,010 --> 00:13:58,360
你可以指定多個小數
點，有多少數字打印

300
00:13:58,360 --> 00:14:00,040
後一個小數點等。

301
00:14:00,040 --> 00:14:05,040
和printf，當然，需要一個
以上參數或參數，

302
00:14:05,040 --> 00:14:06,770
否則已知的，更簡單地說，作為輸入。

303
00:14:06,770 --> 00:14:09,230
>> 所以printf的，想了很多
函數的輸入參數。

304
00:14:09,230 --> 00:14:12,730
而這些輸入被接受
由兩個括號這裡。

305
00:14:12,730 --> 00:14:15,180
而那些裡面是一個輸入。

306
00:14:15,180 --> 00:14:18,600
這是一個字符串，因為我們已經把它稱為，
這是一個字符的只是一個序列，

307
00:14:18,600 --> 00:14:22,310
像一個字，或短語，或整個
文章甚至在雙引號之間。

308
00:14:22,310 --> 00:14:25,712
這就是發生了什麼事情來影響
當然，printf的行為，因為，

309
00:14:25,712 --> 00:14:27,170
它只是一個普通的打印功能。

310
00:14:27,170 --> 00:14:29,600
它不會知道是什麼
打印，除非你告訴它。

311
00:14:29,600 --> 00:14:31,000
然後，一些細枝末節。

312
00:14:31,000 --> 00:14:34,056
那麼，我們能說這個奇怪
的符號序列是？

313
00:14:34,056 --> 00:14:34,556
是啊。

314
00:14:34,556 --> 00:14:35,410
>> 觀眾：新行。

315
00:14:35,410 --> 00:14:35,990
>> 大衛·馬蘭：新行。

316
00:14:35,990 --> 00:14:39,340
所以，事實證明，你不能只打，
進入，當你寫的程序。

317
00:14:39,340 --> 00:14:42,590
通常，編譯器是會得到
有點困惑，你的意思。

318
00:14:42,590 --> 00:14:45,340
相反，你必須從字面上
說，給我一個新的生產線在這裡。

319
00:14:45,340 --> 00:14:49,506
所以/ N是我們一般
調用一個轉義字符。

320
00:14:49,506 --> 00:14:50,870
因此n，新線路。

321
00:14:50,870 --> 00:14:53,810
而編譯器知道
當它看到/ N，

322
00:14:53,810 --> 00:14:57,420
它實際上應該誘導計算機，
最終，或printf，在這種情況下，

323
00:14:57,420 --> 00:15:00,260
打印出一個新的實際
行，像打了，進入，

324
00:15:00,260 --> 00:15:01,480
鍵盤上的鍵。

325
00:15:01,480 --> 00:15:05,620
最後，做什麼我們說
這一塊的語法是什麼？

326
00:15:05,620 --> 00:15:06,591
這是什麼代表什麼呢？

327
00:15:06,591 --> 00:15:07,090
是啊。

328
00:15:07,090 --> 00:15:07,490
>> 觀眾：[聽不清]

329
00:15:07,490 --> 00:15:08,660
>> 大衛·馬蘭：這只是
該行的末尾。

330
00:15:08,660 --> 00:15:09,909
它是語句的末尾。

331
00:15:09,909 --> 00:15:11,890
並認識到我們不
把它們無處不在。

332
00:15:11,890 --> 00:15:13,900
我們當然不會把他們
在每行的末端。

333
00:15:13,900 --> 00:15:16,680
舉例來說，有沒有對
第一行，有沒有上線

334
00:15:16,680 --> 00:15:18,680
有，主，有沒有
花括號後，

335
00:15:18,680 --> 00:15:21,740
但你會開始看到並獲得
熟悉的地方，它被稱為為。

336
00:15:21,740 --> 00:15:26,014
它是一個功能之後幾乎總是
致電或發表聲明，一些行動

337
00:15:26,014 --> 00:15:27,180
你的確服用。

338
00:15:27,180 --> 00:15:29,520
>> 而現在知道，特別是如果
在那些不太舒服，

339
00:15:29,520 --> 00:15:32,540
這些都是種愚蠢的事情
你會最終不小心撞

340
00:15:32,540 --> 00:15:33,873
你的頭撞牆了。

341
00:15:33,873 --> 00:15:36,107
因為你會在邏輯上
相信在某些問題

342
00:15:36,107 --> 00:15:38,440
你已經解決了問題
集，該死的東西只是

343
00:15:38,440 --> 00:15:40,187
將無法編譯，甚至運行。

344
00:15:40,187 --> 00:15:43,270
所以通常情況下，在初期，它會
是因為你錯過了一個括號，

345
00:15:43,270 --> 00:15:44,455
或者你錯過了一個分號。

346
00:15:44,455 --> 00:15:46,547
所以只是留心
中，這樣的東西

347
00:15:46,547 --> 00:15:49,380
並盡量不要被沮喪
因為他們很快做到這一點

348
00:15:49,380 --> 00:15:50,640
成為舊帽子。

349
00:15:50,640 --> 00:15:53,910
但它很容易得到
受挫早上，作為一個結果。

350
00:15:53,910 --> 00:15:57,020
>> 所以，現在，讓我們來看看如何
這條線是實際工作

351
00:15:57,020 --> 00:15:59,170
再看看一個稍微
更複雜的之一。

352
00:15:59,170 --> 00:16:02,017
所以我們在這裡，在
能夠得出這樣的屏幕上。

353
00:16:02,017 --> 00:16:04,100
讓我們假設
這是我的電腦屏幕，

354
00:16:04,100 --> 00:16:08,589
但我寫的，你好程序，
而我還沒有實現，printf的。

355
00:16:08,589 --> 00:16:10,130
別人已經實施，printf的。

356
00:16:10,130 --> 00:16:12,420
誰願意自稱
已經實施了，printf的？

357
00:16:12,420 --> 00:16:12,920
如果我們可能嗎？

358
00:16:12,920 --> 00:16:13,830
好吧，你叫什麼名字？

359
00:16:13,830 --> 00:16:14,155
>> 學生1：[？柯巴。 ？]

360
00:16:14,155 --> 00:16:15,529
>> 大衛·馬蘭：Copal的，拜託了。

361
00:16:15,529 --> 00:16:16,430
上來吧。

362
00:16:16,430 --> 00:16:17,070
好的。

363
00:16:17,070 --> 00:16:22,260
因此，我們有，在這裡，一些名稱標籤，
因為我們會做出這樣的小遊戲。

364
00:16:22,260 --> 00:16:26,270
我們會打電話給你，printf的。

365
00:16:26,270 --> 00:16:30,170
如果你想要到這裡來，
我剛剛在屏幕上繪製，

366
00:16:30,170 --> 00:16:32,340
這是相當簡單的，還有我，這。

367
00:16:32,340 --> 00:16:35,550
>> 所有的權利，所以，你好我的名字是，
printf的，如果你想要把那。

368
00:16:35,550 --> 00:16:35,740
好的。

369
00:16:35,740 --> 00:16:37,360
如果你可以去展台
通過在計算機屏幕

370
00:16:37,360 --> 00:16:39,730
就好像你是功能
來到這個計算機系統。

371
00:16:39,730 --> 00:16:42,063
而你的人生目標是
實際打印的東西。

372
00:16:42,063 --> 00:16:44,560
但是，就像節目我們
剛剛在屏幕上，在這裡，

373
00:16:44,560 --> 00:16:47,060
我們將不得不
實際上給你一些意見。

374
00:16:47,060 --> 00:16:51,810
>> 所以，如果我的輸入，在這裡，
顯然，什麼是傳遞給printf，

375
00:16:51,810 --> 00:16:53,730
讓我們種的譏笑它是這樣的。

376
00:16:53,730 --> 00:16:58,720
我將字面上寫上
一張紙，“你好，世界”

377
00:16:58,720 --> 00:17:03,020
反斜線N.而且要明確，什麼樣
我剛剛畫在這張紙上，

378
00:17:03,020 --> 00:17:04,020
看起來是這樣的。

379
00:17:04,020 --> 00:17:08,730
所以，當我運行這個程序，而這
代碼黃線被執行，

380
00:17:08,730 --> 00:17:12,970
就好像我，hello程序，
我交給一些輸入開了一個功能

381
00:17:12,970 --> 00:17:13,970
別人寫的。

382
00:17:13,970 --> 00:17:16,595
>> 如果你與你的手指，
居然可以，用你的手指，

383
00:17:16,595 --> 00:17:21,520
在屏幕上繪製什麼
這是你一直在流傳，

384
00:17:21,520 --> 00:17:27,465
的效果，最終，是
看到正是這樣，在屏幕上。

385
00:17:27,465 --> 00:17:29,140
和一個小角落的情況下在這裡。

386
00:17:29,140 --> 00:17:31,540
而良好的，我們不應該看到
的，新線，在這一點上。

387
00:17:31,540 --> 00:17:33,900
這將是不正確的你
明確地得出新行。

388
00:17:33,900 --> 00:17:36,810
但是，如果我們不停地寫上的字
屏幕上，他們最終會低於。

389
00:17:36,810 --> 00:17:39,560
>> 所以，非常感謝你，但堅持
這裡只是一個瞬間各地。

390
00:17:39,560 --> 00:17:42,860
我們現在需要一個其他
志願者，如果我們能，

391
00:17:42,860 --> 00:17:46,830
那將需要發揮的作用
of--這只是人們在樂團

392
00:17:46,830 --> 00:17:47,355
現在。

393
00:17:47,355 --> 00:17:47,980
如何about--確定。

394
00:17:47,980 --> 00:17:48,480
就在這裡。

395
00:17:48,480 --> 00:17:49,180
上來吧。

396
00:17:49,180 --> 00:17:49,955
你叫什麼名字？

397
00:17:49,955 --> 00:17:50,922
>> 學生2：[？ Ivay。 ？]

398
00:17:50,922 --> 00:17:51,796
大衛·馬蘭：對不起？

399
00:17:51,796 --> 00:17:52,990
學生2：[？ Ivay。 ？]

400
00:17:52,990 --> 00:17:55,320
大衛·馬蘭：阮經天，上來吧。

401
00:17:55,320 --> 00:17:55,820
沒有？

402
00:17:55,820 --> 00:17:58,390
難道我得到的錯誤，甚至
你說了兩遍之後？

403
00:17:58,390 --> 00:17:58,890
上來吧。

404
00:17:58,890 --> 00:18:00,030
這是很難聽到了這裡。

405
00:18:00,030 --> 00:18:05,240

406
00:18:05,240 --> 00:18:05,740
確定。

407
00:18:05,740 --> 00:18:07,190
我很抱歉，你叫什麼名字？

408
00:18:07,190 --> 00:18:07,680
>> 學生2：[？ Ivay。 ？]

409
00:18:07,680 --> 00:18:08,790
>> [？大衛·馬蘭：Ivay。 ？]確定。

410
00:18:08,790 --> 00:18:10,430
現在，如果你不
心，你的GetString。

411
00:18:10,430 --> 00:18:11,013
>> 學生2：確定。

412
00:18:11,013 --> 00:18:11,797
酷。

413
00:18:11,797 --> 00:18:14,630
大衛·馬蘭：所以，如果你想
站在這裡只是一瞬間，

414
00:18:14,630 --> 00:18:17,100
讓我們來看看一個稍微
更複雜的程序，即

415
00:18:17,100 --> 00:18:18,670
現在有三行代碼。

416
00:18:18,670 --> 00:18:24,080
因此，我們有，其一，說明用你的名字
printf的;二，一個電話給GetString，

417
00:18:24,080 --> 00:18:28,060
隨後分配到一個
變量調用，字符串s，或稱為S;

418
00:18:28,060 --> 00:18:31,260
然後再次調用，printf的，
但是這次使用兩個輸入。

419
00:18:31,260 --> 00:18:33,646
>> 因此，我們已經做狀態
你的名字，或者更確切地說，我們已經

420
00:18:33,646 --> 00:18:34,770
已經做了printf的電話。

421
00:18:34,770 --> 00:18:38,960
所以我會寫，說出你的名字。

422
00:18:38,960 --> 00:18:42,089
所以，有什麼我要去
通，printf的，在短短的時刻，

423
00:18:42,089 --> 00:18:43,005
是很簡單，這一點。

424
00:18:43,005 --> 00:18:47,760
所以，如果你想繼續前進，得出這樣的
在屏幕上，這是現在你的輸入。

425
00:18:47,760 --> 00:18:48,260
好的。

426
00:18:48,260 --> 00:18:51,160
而忘記字符串，我們現在有
我們自己的行代碼在這裡。

427
00:18:51,160 --> 00:18:54,470
所以，GetString的，我們需要
實際調用，GetString的。

428
00:18:54,470 --> 00:18:57,920
所以，你的人生目標是只走
外面的樂團，如果你能，

429
00:18:57,920 --> 00:18:58,980
並得到某人的名字。

430
00:18:58,980 --> 00:19:00,860
但是，讓我們給你
東西把它。

431
00:19:00,860 --> 00:19:02,908
如果你想，去
進取，得到一個字符串，

432
00:19:02,908 --> 00:19:05,241
得到某人的名字上
一張紙，如果你能。

433
00:19:05,241 --> 00:19:12,940

434
00:19:12,940 --> 00:19:13,530
>> 好的。

435
00:19:13,530 --> 00:19:15,250
我們將看到，在短短的時刻，
他的名字我們得到。

436
00:19:15,250 --> 00:19:17,630
同時，我所要
有現成的，是一張空白

437
00:19:17,630 --> 00:19:21,340
紙，其中，我要去
存儲任何值它

438
00:19:21,340 --> 00:19:25,752
是，GetString的是返回給我，
我，作為一個所謂的字符串變量，S。

439
00:19:25,752 --> 00:19:26,252
好的。

440
00:19:26,252 --> 00:19:27,293
所以，你有什麼嗎？

441
00:19:27,293 --> 00:19:27,950
聶。

442
00:19:27,950 --> 00:19:28,450
好的。

443
00:19:28,450 --> 00:19:30,910
因此，我們有聶的名字在這裡。

444
00:19:30,910 --> 00:19:33,750
因此，這是字面上
已返回

445
00:19:33,750 --> 00:19:35,810
對我來說，可以這麼說，通過GetString的。

446
00:19:35,810 --> 00:19:38,720
>> 我，現在，我準備
執行左手側

447
00:19:38,720 --> 00:19:43,440
那表情，在這裡我簡單的
抄下來，今天的目的，聶。

448
00:19:43,440 --> 00:19:46,470
所以，現在，我有一個變量
所謂，S，存儲聶的名字。

449
00:19:46,470 --> 00:19:49,520
我已經交給
printf的，以前的說法。

450
00:19:49,520 --> 00:19:52,800
但是，在我們的第三個，也是最後的行
代碼，我實際上是手的printf

451
00:19:52,800 --> 00:19:58,500
東西有點different--
“你好，％S，”反斜線ñ。

452
00:19:58,500 --> 00:20:01,510
>> 這樣一來，最後一行我要去
到send--的最後一件事，我

453
00:20:01,510 --> 00:20:03,060
要現在寫下來，是這樣的。

454
00:20:03,060 --> 00:20:06,310
所以兩行代碼，或
而代碼的最後一行，

455
00:20:06,310 --> 00:20:10,690
要求兩inputs--
之一，這和兩個，這一點。

456
00:20:10,690 --> 00:20:13,330
所以，如果我們的printf函數
現在可以把這些作為輸入，

457
00:20:13,330 --> 00:20:16,000
讓我清除屏幕為您服務。

458
00:20:16,000 --> 00:20:17,250
其實也沒什麼，你可以繼續。

459
00:20:17,250 --> 00:20:19,333
我們會離開它，因為
它是在相同的程序。

460
00:20:19,333 --> 00:20:21,760

461
00:20:21,760 --> 00:20:27,380
我們應該看到，你好，聶。

462
00:20:27,380 --> 00:20:27,880
好的。

463
00:20:27,880 --> 00:20:29,670
因此，這是相當多的
箍跳通過，只

464
00:20:29,670 --> 00:20:31,620
寫，說明你的
名稱和，你好，聶。

465
00:20:31,620 --> 00:20:37,210
但消息傳遞的這個簡單的想法，
輸入的傳球和輸出接收的，

466
00:20:37,210 --> 00:20:40,430
正是我們將不得不模型
即使是最複雜的功能。

467
00:20:40,430 --> 00:20:41,804
所以，謝謝你這麼多，你倆。

468
00:20:41,804 --> 00:20:43,730
我們有一個可愛的壓力
球在這裡為你。

469
00:20:43,730 --> 00:20:48,890
謝謝你對我們的GetString
和printf志願者的一致好評。

470
00:20:48,890 --> 00:20:49,551
謝謝。

471
00:20:49,551 --> 00:20:50,050
好的。

472
00:20:50,050 --> 00:20:50,966
謝謝你們。

473
00:20:50,966 --> 00:20:56,640

474
00:20:56,640 --> 00:21:00,430
>> 因此，我們一直在談論
迄今為止，大部分是關於串。

475
00:21:00,430 --> 00:21:06,550
而事實證明，C能實際
了解幾個不同的數據類型。

476
00:21:06,550 --> 00:21:08,860
事實上，讓我們
一起來看看這些在這裡。

477
00:21:08,860 --> 00:21:12,490
因此，C，和很多語言，
認識事物稱為字符。

478
00:21:12,490 --> 00:21:16,852
一個char通常一個是
單字節或8位。

479
00:21:16,852 --> 00:21:19,810
它代表一個字符，
像字母A或資本

480
00:21:19,810 --> 00:21:21,990
字母A，或小寫字母
A，或感嘆號，

481
00:21:21,990 --> 00:21:25,440
或任何字符，你可以鍵入
你的鍵盤，有時甚至更多。

482
00:21:25,440 --> 00:21:26,795
我們也碰巧看到彩車。

483
00:21:26,795 --> 00:21:31,160
浮子是，一般情況下，
32位值，或四個字節

484
00:21:31,160 --> 00:21:33,660
因為再次，一個字節是8比特。

485
00:21:33,660 --> 00:21:36,675
>> 所以一個float是一個浮點值，
大一些的小數點。

486
00:21:36,675 --> 00:21:38,550
事實上，這就是
這部電影是說

487
00:21:38,550 --> 00:21:42,240
，當他們談到浮動
點值，一些固定位的數目

488
00:21:42,240 --> 00:21:43,940
被用於表示一個實數。

489
00:21:43,940 --> 00:21:45,740
但也有東西叫做雙打。

490
00:21:45,740 --> 00:21:47,860
這些存在於Java中，
如果你已經採取了APCS，

491
00:21:47,860 --> 00:21:51,540
和雙，正如其名字令人欣慰
顧名思義，是兩次大如浮動。

492
00:21:51,540 --> 00:21:54,540
它仍然是一個實數，
它只是有更多的位

493
00:21:54,540 --> 00:21:58,390
與要更加精確，
或存儲更大的數字。

494
00:21:58,390 --> 00:21:58,890
int是容易的。

495
00:21:58,890 --> 00:22:00,181
我們談到了這最後的時間。

496
00:22:00,181 --> 00:22:01,160
這只是一個整數。

497
00:22:01,160 --> 00:22:03,980
而且它是一般32
位，或四個字節。

498
00:22:03,980 --> 00:22:07,850
>> 所以，如果你有，我們現在看到的，
32 bits--我們0週這樣做，

499
00:22:07,850 --> 00:22:10,820
曾經如此briefly--，如果您有
32位，什麼是最大的

500
00:22:10,820 --> 00:22:13,580
數可以表示為一個整數？

501
00:22:13,580 --> 00:22:16,080
給予或採取？

502
00:22:16,080 --> 00:22:18,380
這樣4十億，
而這只有當我們

503
00:22:18,380 --> 00:22:20,690
僅代表正數。

504
00:22:20,690 --> 00:22:23,930
如果你有32位，並且要
表示負數為好，

505
00:22:23,930 --> 00:22:27,100
你的範圍是，從本質上講，負
2十億轉正2十億。

506
00:22:27,100 --> 00:22:29,250
但是總體來說，我們將開始
在0升至4十億。

507
00:22:29,250 --> 00:22:32,400
>> 你不必準確地知道，但
我們可以看到這一點，事實上，如果我只是

508
00:22:32,400 --> 00:22:36,400
開了一個小計算器，點擊這裡。

509
00:22:36,400 --> 00:22:41,070
我可以做2的32，和
這正是有多大，

510
00:22:41,070 --> 00:22:43,190
有多少價值，你可以
表示，具有32位。

511
00:22:43,190 --> 00:22:44,442
而且它的約4十億。

512
00:22:44,442 --> 00:22:46,900
因此，我們會繼續看到這個數字
在幾個不同的地方。

513
00:22:46,900 --> 00:22:48,890
但是如果你需要更長的
數比，

514
00:22:48,890 --> 00:22:51,670
原來有
一些所謂的很長很長。

515
00:22:51,670 --> 00:22:54,005
而一個很長很長的
通常64位，這

516
00:22:54,005 --> 00:22:56,380
意味著它是一個數量級
比int更大。

517
00:22:56,380 --> 00:22:59,510
>> 所以，我甚至不能發音最大
你可以代表數字，

518
00:22:59,510 --> 00:23:01,340
但它明顯更大。

519
00:23:01,340 --> 00:23:05,190
現在，順便說一句，從歷史上看，
如果一個int是32位，

520
00:23:05,190 --> 00:23:12,780
和很長很長為64位，怎麼樣
大是一個長期的，而不是一個很長很長？

521
00:23:12,780 --> 00:23:16,500

522
00:23:16,500 --> 00:23:20,330
你會認為這是比int長
但也許少長不是很長很長，

523
00:23:20,330 --> 00:23:21,400
但它實際上依賴。

524
00:23:21,400 --> 00:23:23,400
>> 所以它變成一顆顆
過的挫折，

525
00:23:23,400 --> 00:23:26,830
對某些系統編寫代碼，
是，並不是所有的這些數據類型的

526
00:23:26,830 --> 00:23:28,440
有預先確定的值。

527
00:23:28,440 --> 00:23:29,771
有時候，這多少位。

528
00:23:29,771 --> 00:23:31,020
有時候，很多位。

529
00:23:31,020 --> 00:23:32,750
所以，你居然要知道，
有時，哪些硬件

530
00:23:32,750 --> 00:23:34,083
您正在運行的軟件。

531
00:23:34,083 --> 00:23:36,960
值得慶幸的是，其他語言和
現在還存在著其他的數據類型，

532
00:23:36,960 --> 00:23:38,400
讓您更精確。

533
00:23:38,400 --> 00:23:41,220
好了，我們看到的字符串，
而我們看到的布爾也

534
00:23:41,220 --> 00:23:43,960
但事實證明，這些都
只與CS50庫。

535
00:23:43,960 --> 00:23:46,240
因此，那些不建
到C.這些替代，

536
00:23:46,240 --> 00:23:49,340
進來叫該文件
CS50.h，我們最終會

537
00:23:49,340 --> 00:23:51,831
剝開的層。

538
00:23:51,831 --> 00:23:53,830
但現在，他們只是
附加數據類型。

539
00:23:53,830 --> 00:23:57,060
一個布爾值是真還是假，和
串是字符序列，

540
00:23:57,060 --> 00:23:57,970
就像一個字。

541
00:23:57,970 --> 00:24:01,690
現在printf的，我們已經看到，有
佔位符，％S就是其中之一。

542
00:24:01,690 --> 00:24:05,430
你也許可以，到現在為止，
從這些其它實例中，如何推斷

543
00:24:05,430 --> 00:24:07,720
你可以有一個佔位符
對於不同的數據類型。

544
00:24:07,720 --> 00:24:11,150
例如，以此來猜測，如果你
想使用打印出單個字符

545
00:24:11,150 --> 00:24:15,270
printf的，佔位符大概％C。

546
00:24:15,270 --> 00:24:19,650
如果你想打印出
整數的佔位符，％我。

547
00:24:19,650 --> 00:24:25,150
％LLD是一個很長很長的十進制值，
但很長很長，所以映射到這一點。

548
00:24:25,150 --> 00:24:28,640
然後％f浮點
點值或雙，

549
00:24:28,640 --> 00:24:31,270
所以有時候他們重新使用
在不同的上下文。

550
00:24:31,270 --> 00:24:33,350
所以我們會看到和使用
其中一些隨著時間的推移。

551
00:24:33,350 --> 00:24:36,420
和printf等功能也
支持別人的轉義序列，

552
00:24:36,420 --> 00:24:38,080
有時，這些都是必要的。

553
00:24:38,080 --> 00:24:39,770
所以反斜杠n是一個新的生產線。

554
00:24:39,770 --> 00:24:42,886
反斜杠T，沒有任何人
要採取刺？

555
00:24:42,886 --> 00:24:43,760
觀眾：標籤。

556
00:24:43,760 --> 00:24:44,551
大衛·馬蘭：標籤。

557
00:24:44,551 --> 00:24:46,810
所以，如果你真的想
打印出標籤，而不是

558
00:24:46,810 --> 00:24:49,940
的空間的固定號碼，但實際的
製表符，你不打你，

559
00:24:49,940 --> 00:24:53,490
標籤上，在鍵盤上鍵，通常，
你其實反斜杠噸。

560
00:24:53,490 --> 00:24:57,750
反斜杠雙引號，
為什麼我會永遠想的？

561
00:24:57,750 --> 00:24:58,250
對嗎？

562
00:24:58,250 --> 00:25:00,417
為什麼我不能只是輸入
我的鍵盤上雙引號？

563
00:25:00,417 --> 00:25:02,124
觀眾：
因為，否則，它是

564
00:25:02,124 --> 00:25:04,830
會認為這是結束
對喜歡您的打印[？文本。 ？]

565
00:25:04,830 --> 00:25:05,420
>> 大衛·馬蘭：沒錯。

566
00:25:05,420 --> 00:25:07,211
請記住，我們的
printf的例子，當我們

567
00:25:07,211 --> 00:25:10,075
被傳遞的輸入對printf，
在該輸入字符串的左

568
00:25:10,075 --> 00:25:12,950
並在該輸入的右
春天，當然，是一個雙引號。

569
00:25:12,950 --> 00:25:16,270
如果你自己輸入有雙重
報價在中間的那個，

570
00:25:16,270 --> 00:25:18,920
計算機可能潛在地
感到困惑，因為到，

571
00:25:18,920 --> 00:25:20,760
這是否雙引號
屬於中間？

572
00:25:20,760 --> 00:25:22,150
它是否與左邊的歸屬？

573
00:25:22,150 --> 00:25:23,566
是否有一個正確的歸屬？

574
00:25:23,566 --> 00:25:26,780
所以，如果你想使超
明確的，你做的反斜線雙引號，

575
00:25:26,780 --> 00:25:30,480
因此，它的逃脫了，可以這麼說，和
它不是混為一談別的東西。

576
00:25:30,480 --> 00:25:34,400
而且還有其他幾個人在這裡，
反斜線R，單引號，0，

577
00:25:34,400 --> 00:25:36,510
我們可以看到隨著時間的推移，以及。

578
00:25:36,510 --> 00:25:37,760
而現在，怎麼樣的功能呢？

579
00:25:37,760 --> 00:25:41,630
>> 這樣我們就可以採取迄今的行動
在這種語言，C，好了，我們已經看到，

580
00:25:41,630 --> 00:25:44,320
printf的，當然，所有的
屏幕上的其他人的，

581
00:25:44,320 --> 00:25:47,140
在這裡，我們將使用的
當然第一個只有少數幾個星期，

582
00:25:47,140 --> 00:25:48,485
來當CS50庫。

583
00:25:48,485 --> 00:25:51,850
他們能夠更容易，在
C，實際獲取用戶輸入。

584
00:25:51,850 --> 00:25:54,200
事實證明，在C和
坦率地說在幾種語言，

585
00:25:54,200 --> 00:25:57,450
它在脖子上做一個真正的痛苦
簡單的東西，比如提示用戶

586
00:25:57,450 --> 00:26:01,310
為鍵盤，為他或她的輸入。

587
00:26:01,310 --> 00:26:03,240
所以，這些功能更容易。

588
00:26:03,240 --> 00:26:05,472
>> 它也有錯誤
在整個檢查，

589
00:26:05,472 --> 00:26:07,180
這樣一來，當你
記得上週三，我們

590
00:26:07,180 --> 00:26:09,740
看到了，重試，警告，
當我不配合，

591
00:26:09,740 --> 00:26:11,700
而我輸入一個字，而不是數字？

592
00:26:11,700 --> 00:26:15,402
我們早做了繁重
在確保用戶合作。

593
00:26:15,402 --> 00:26:17,860
但這些都只是培訓
車輪，我們將最終，

594
00:26:17,860 --> 00:26:19,640
並迅速，起飛。

595
00:26:19,640 --> 00:26:22,630
>> 因此，要回顧一下，然後，
讓我們快速瀏覽一下，

596
00:26:22,630 --> 00:26:26,620
就像我們有划痕，在沒有
C.在一些典型結構

597
00:26:26,620 --> 00:26:28,580
這是為了，排序
的，是一個旋風之旅，

598
00:26:28,580 --> 00:26:30,990
只是讓你有一個參考
那你首先看到的東西。

599
00:26:30,990 --> 00:26:34,100
但是，我們來看看實際的編碼
使用其中的一些積木。

600
00:26:34,100 --> 00:26:36,710
所以，就像在刮，
當我們已經報表喜歡，

601
00:26:36,710 --> 00:26:41,570
或者說，等待，在C，我們確實有
功能以及，如printf。

602
00:26:41,570 --> 00:26:45,350
>> 如果我們想表達的條件
在C，它是類似的，在精神上，

603
00:26:45,350 --> 00:26:47,840
該拼圖的
看起來是這樣的划痕。

604
00:26:47,840 --> 00:26:49,850
但是相反，我們
從字面上只寫，如果。

605
00:26:49,850 --> 00:26:51,830
然後，在括號
我們把一個條件，

606
00:26:51,830 --> 00:26:54,807
其中，該條件是我們將
打電話，再次，一個布爾表達式。

607
00:26:54,807 --> 00:26:56,390
再次，這是有點偽的。

608
00:26:56,390 --> 00:26:58,830
而且，事實上，//是註釋。

609
00:26:58,830 --> 00:27:00,550
這只是英語單詞我自己。

610
00:27:00,550 --> 00:27:03,000
但是，這是一般
的一個，如果，條件結構。

611
00:27:03,000 --> 00:27:05,220
但是，我們會看到具體的
例子在短短的時刻。

612
00:27:05,220 --> 00:27:07,960
>> 如果你想有一個
兩路的岔路口，

613
00:27:07,960 --> 00:27:11,740
就像我們與我們的志願者在做
週三，你可以有一個，否則，如果。

614
00:27:11,740 --> 00:27:16,020
如果你想有一個第三和
最後一個條件，或者默認的情況下，

615
00:27:16,020 --> 00:27:19,006
你可以只是一個其他塊，還有。

616
00:27:19,006 --> 00:27:21,880
同樣，用布爾表達式，
你可以，而且，它們在一起。

617
00:27:21,880 --> 00:27:24,296
而且我們看到在週三，即
它不是一個單一的符號，

618
00:27:24,296 --> 00:27:28,220
它的2，為低級別的原因
我們最終會看到和發揮。

619
00:27:28,220 --> 00:27:30,410
的OR-ing的東西放在一起
是2豎條。

620
00:27:30,410 --> 00:27:32,240
根據美國的鍵盤，這
通常是一個關鍵

621
00:27:32,240 --> 00:27:35,730
與上面的Shift鍵
您的Enter鍵或Return鍵。

622
00:27:35,730 --> 00:27:38,620
>> 此外，還有這些東西
我們將使用也許一次或兩次。

623
00:27:38,620 --> 00:27:42,570
它們是功能上等同於
你可以用做的，如果，否則，如果，

624
00:27:42,570 --> 00:27:44,950
否則，如果其他人，建設，
但他們稱為交換機。

625
00:27:44,950 --> 00:27:48,020
他們看起來非常不同，但我們會
看到我們的一些分配代碼，

626
00:27:48,020 --> 00:27:51,890
對於未來的習題集，最有可能的，
它有時只是一個漂亮

627
00:27:51,890 --> 00:27:54,060
表達一個整體的方式
一堆條件，

628
00:27:54,060 --> 00:27:57,590
無需大量的花括號和
很多括號和縮進的。

629
00:27:57,590 --> 00:28:01,910
但他們給我們沒有更多的
功率比我們已經。

630
00:28:01,910 --> 00:28:02,550
現在循環。

631
00:28:02,550 --> 00:28:05,020
而這其中，我們來看看
在慢一點。

632
00:28:05,020 --> 00:28:08,470
但隨後，我們將開始使用這些，
特別是對於那些已經熟悉。

633
00:28:08,470 --> 00:28:13,830
這是規範的方式，如果難以置信
神秘的方式，用C編寫一個循環

634
00:28:13,830 --> 00:28:15,896
>> 現在，在划痕一個循環是
很簡單。

635
00:28:15,896 --> 00:28:17,020
你有一個，永遠塊。

636
00:28:17,020 --> 00:28:19,760
你有一個，重複，塊與
只是一個數字，你必須輸入內容。

637
00:28:19,760 --> 00:28:22,220
而伴隨著，for循環，可以
同時實現這些想法，

638
00:28:22,220 --> 00:28:23,595
但它是一個多一點的技術。

639
00:28:23,595 --> 00:28:25,994
但坦率地說，這也是
相對簡單。

640
00:28:25,994 --> 00:28:28,160
一旦你知道的順序
操作，你從字面上

641
00:28:28,160 --> 00:28:30,910
只是要在價值觀堵塞
並告訴計算機做什麼。

642
00:28:30,910 --> 00:28:32,800
因此，這裡有一個例子。

643
00:28:32,800 --> 00:28:38,040
這是一個循環的是，相當
簡單地說，從一個人數多達計算

644
00:28:38,040 --> 00:28:40,187
通過另一個。

645
00:28:40,187 --> 00:28:42,020
而就掃一眼
它，即使你有

646
00:28:42,020 --> 00:28:44,660
沒有以往的經驗
這種語言，什麼號碼

647
00:28:44,660 --> 00:28:46,920
它可能開始計數？

648
00:28:46,920 --> 00:28:47,730
OK，0。

649
00:28:47,730 --> 00:28:50,240
我猜那是因為你
看到有一個int和我，

650
00:28:50,240 --> 00:28:51,073
這是一個變量。

651
00:28:51,073 --> 00:28:52,390
它初始化為0。

652
00:28:52,390 --> 00:28:55,670
>> 再後來，它看起來像
我們傳遞的printf，一個值。

653
00:28:55,670 --> 00:28:58,000
而且，事實上，我在這裡做一個小錯字。

654
00:28:58,000 --> 00:28:59,850
但是，這容易固定。

655
00:28:59,850 --> 00:29:02,390
我要補充的，我在這裡。

656
00:29:02,390 --> 00:29:06,150
我們現在有printf的存在
通過該佔位符值。

657
00:29:06,150 --> 00:29:08,299
這有什麼經歷來算呢？

658
00:29:08,299 --> 00:29:08,840
聽眾：50。

659
00:29:08,840 --> 00:29:09,340
50。

660
00:29:09,340 --> 00:29:10,160
49。

661
00:29:10,160 --> 00:29:10,910
大衛·馬蘭：49。

662
00:29:10,910 --> 00:29:13,340
所以50，乍一看，似乎是正確的。

663
00:29:13,340 --> 00:29:16,990
但是，事實證明，將是
我們的條件，我們繼續檢查。

664
00:29:16,990 --> 00:29:21,740
而且我們要停止一次
i是不再小於50。

665
00:29:21,740 --> 00:29:24,920
所以這個循環中，反之，應
執行，只要i小於50。

666
00:29:24,920 --> 00:29:28,891
但只要它變為50，或51，
或者更糟，它應該自動停止。

667
00:29:28,891 --> 00:29:29,390
好的。

668
00:29:29,390 --> 00:29:31,200
>> 那麼究竟是什麼發生在這裡？

669
00:29:31,200 --> 00:29:33,160
因此，這是秩序
操作為一個循環。

670
00:29:33,160 --> 00:29:35,440
一，你有
所謂初始化。

671
00:29:35,440 --> 00:29:38,264
這種黃色高亮塊
代碼首先執行，

672
00:29:38,264 --> 00:29:40,930
並且它有一個，每效果
週三，你可能想像。

673
00:29:40,930 --> 00:29:45,500
它創建了一個名為i和它的變量
在變量存儲值0。

674
00:29:45,500 --> 00:29:47,560
所以i為0，在這一點上的故事。

675
00:29:47,560 --> 00:29:49,680
>> 接下來的事情，
發生在這個結構，

676
00:29:49,680 --> 00:29:51,540
是該條件被檢查。

677
00:29:51,540 --> 00:29:54,325
於是我立即檢查，
為i小於50？

678
00:29:54,325 --> 00:29:57,700
當然，答案
現在來看，毫無疑問，是的。

679
00:29:57,700 --> 00:30:00,710
是的，因為我是0，
這是肯定小於50。

680
00:30:00,710 --> 00:30:03,866
然後發生了什麼，是這
行代碼被執行。

681
00:30:03,866 --> 00:30:06,740
而事實上，如果有多個
的代碼中的那些大括號線，

682
00:30:06,740 --> 00:30:09,020
他們都得到執行此起彼伏。

683
00:30:09,020 --> 00:30:11,450
>> 並且在這裡的效果，是
顯然，打印出

684
00:30:11,450 --> 00:30:15,365
的編號i，這是會
為0，然後1，然後2。

685
00:30:15,365 --> 00:30:15,865
但是，為什麼？

686
00:30:15,865 --> 00:30:17,410
它為什麼會得到增加？

687
00:30:17,410 --> 00:30:20,680
那麼，第四件事，
碰巧的是，這個語法

688
00:30:20,680 --> 00:30:22,610
被執行，分號之後。

689
00:30:22,610 --> 00:30:27,506
我++是一個說速記的方式;
取的i的值，並把它加1;

690
00:30:27,506 --> 00:30:30,380
再下一次，加
1到它;而下一次，

691
00:30:30,380 --> 00:30:31,330
其加1。

692
00:30:31,330 --> 00:30:33,640
>> 因此，如果我們繼續下去，
什麼會發生

693
00:30:33,640 --> 00:30:35,890
接下來就是我不打算
以後再初始化我。

694
00:30:35,890 --> 00:30:38,290
如果我一直在初始化
i到0，本實施例

695
00:30:38,290 --> 00:30:41,110
永遠不會結束，因為
我會停留在0。

696
00:30:41,110 --> 00:30:43,870
但什麼事情發生是
該條件將被檢查，

697
00:30:43,870 --> 00:30:54,280
該行代碼會被執行，
在我將增加，

698
00:30:54,280 --> 00:30:56,970
條件將被檢查，
代碼會被執行。

699
00:30:56,970 --> 00:30:59,790
它再次保持騎自行車，
又一次，又一次，

700
00:30:59,790 --> 00:31:03,340
直到我++誘導值50。

701
00:31:03,340 --> 00:31:05,870
>> 條件接著說，
比50 50少了呢？

702
00:31:05,870 --> 00:31:09,360
當然，答案是否定的，
所以整個代碼停止執行。

703
00:31:09,360 --> 00:31:13,020
如果你有在屏幕上更多的代碼
向下跌破，那接下來會發生什麼。

704
00:31:13,020 --> 00:31:17,530
它彈出來，這些花括號和
繼續打印後更多。

705
00:31:17,530 --> 00:31:20,470
>> 所以，現在開個玩笑，從狐步舞，那
你也許現在明白了。

706
00:31:20,470 --> 00:31:30,810

707
00:31:30,810 --> 00:31:31,560
它總是有趣的。

708
00:31:31,560 --> 00:31:34,110
這就像笑
樣的過濾，

709
00:31:34,110 --> 00:31:38,370
然後你意識到你不應該
是笑的幽默是這樣。

710
00:31:38,370 --> 00:31:41,160
但是，有一些外賣
在這裡，教學法，太。

711
00:31:41,160 --> 00:31:43,577
所以，事實證明，我
缺了一塊的語法，

712
00:31:43,577 --> 00:31:45,410
或狐步舞的失踪
一塊語法在這裡。

713
00:31:45,410 --> 00:31:48,076
現在缺少的，我們已經有
在每一個其他實施例，從而多遠？

714
00:31:48,076 --> 00:31:51,599

715
00:31:51,599 --> 00:31:53,390
返回，在那裡，所以
這是別的東西，

716
00:31:53,390 --> 00:31:54,440
我們再回過頭來不久。

717
00:31:54,440 --> 00:31:55,398
缺少了什麼有關係嗎？

718
00:31:55,398 --> 00:31:55,908
是啊。

719
00:31:55,908 --> 00:31:58,150
>> 觀眾：該
初始化[聽不清]。

720
00:31:58,150 --> 00:31:58,470
>> 大衛·馬蘭：OK。

721
00:31:58,470 --> 00:31:58,980
所以呀。

722
00:31:58,980 --> 00:32:03,210
所以實際上，這個is--嘛，
和計數初始化

723
00:32:03,210 --> 00:32:05,470
上述起來，或者說，上述宣布了起來。

724
00:32:05,470 --> 00:32:06,960
因此，這是做的另一種方式。

725
00:32:06,960 --> 00:32:08,685
但不是在一條線是有效的，但。

726
00:32:08,685 --> 00:32:09,310
怎麼在這裡？

727
00:32:09,310 --> 00:32:10,196
>> 觀眾：是不是大括號？

728
00:32:10,196 --> 00:32:10,640
>> 大衛·馬蘭：是的。

729
00:32:10,640 --> 00:32:12,080
因此，大括號丟失。

730
00:32:12,080 --> 00:32:15,495
但是這個代碼，我的意思是，他們的信用，
實際上，語法上有效。

731
00:32:15,495 --> 00:32:17,610
事實證明，你不
需要花括號

732
00:32:17,610 --> 00:32:21,691
如果你只有一行代碼
要在循環內執行。

733
00:32:21,691 --> 00:32:24,190
現在我們總是在課堂上和
我們所有的分銷代碼，

734
00:32:24,190 --> 00:32:26,730
包括大括號
無論如何，僅僅是為了清楚起見。

735
00:32:26,730 --> 00:32:29,010
但要意識到，在教科書
和網上的例子，

736
00:32:29,010 --> 00:32:31,300
你很可能看到大
牙套有時失踪。

737
00:32:31,300 --> 00:32:34,850
這沒關係，如果你
已經縮進和預期

738
00:32:34,850 --> 00:32:38,650
是代碼只是一個單一的線，而不是
多行代碼，潛在的。

739
00:32:38,650 --> 00:32:39,150
好的。

740
00:32:39,150 --> 00:32:44,500
所以相關的問題
不精確，溢出的問題，

741
00:32:44,500 --> 00:32:48,560
在這個意義上，類似地，
確實整數必須限制他們

742
00:32:48,560 --> 00:32:49,970
就像浮點值？

743
00:32:49,970 --> 00:32:53,120
在世界上的浮點
價值觀，我們只能是如此精確，

744
00:32:53,120 --> 00:32:55,710
在此之後，有時
不好的事情都可能發生，

745
00:32:55,710 --> 00:32:57,760
而我們的方案可以是越野車和錯誤。

746
00:32:57,760 --> 00:33:00,050
現在，即使是整數，
你會遇到的問題。

747
00:33:00,050 --> 00:33:03,820
現在的整數不具有
小數點或之後的數字。

748
00:33:03,820 --> 00:33:07,130
它只是一個自然數，一般。

749
00:33:07,130 --> 00:33:09,430
那麼，什麼可以去錯了一個int？

750
00:33:09,430 --> 00:33:12,210
如果我用一個int來
計數，有什麼可以去錯了嗎？

751
00:33:12,210 --> 00:33:13,230
似乎簡單了很多。

752
00:33:13,230 --> 00:33:13,873
是啊。

753
00:33:13,873 --> 00:33:16,240
>> 觀眾：如果
數字變[聽不清]

754
00:33:16,240 --> 00:33:17,073
>> 大衛·馬蘭：是的。

755
00:33:17,073 --> 00:33:20,820
如果算上如此之高，你有什麼
無法用語言表達的真正的大數目。

756
00:33:20,820 --> 00:33:21,320
對嗎？

757
00:33:21,320 --> 00:33:23,910
在某些時候，你會
超過界限

758
00:33:23,910 --> 00:33:27,077
的一個32位值或64位的值。

759
00:33:27,077 --> 00:33:29,410
現在，再次，我不知道怎麼樣
發音一個64位的值，

760
00:33:29,410 --> 00:33:32,230
但我知道，有一個32位整數，
它可以是最大的值，

761
00:33:32,230 --> 00:33:35,490
如果它是唯一積極的
值，是約4十億。

762
00:33:35,490 --> 00:33:39,000
所以，如果我嘗試數到5十億，
事情將要發生。

763
00:33:39,000 --> 00:33:41,050
但是，讓我們看看，其實都有可能發生。

764
00:33:41,050 --> 00:33:44,570
在整數世界
溢出，在那裡你，從某種意義上說，

765
00:33:44,570 --> 00:33:48,270
溢出的能力
整數，會發生什麼事情？

766
00:33:48,270 --> 00:33:51,190
>> 所以這裡有一個二進制數，
這是一個倒退到0。

767
00:33:51,190 --> 00:33:54,630
這是全1，和佔位符
在那裡，有2的冪，

768
00:33:54,630 --> 00:33:55,980
所以這是二進制的。

769
00:33:55,980 --> 00:33:59,416
因此，這些都是8,1位在屏幕上。

770
00:33:59,416 --> 00:34:01,290
如果你還記得或
你快做數學題，

771
00:34:01,290 --> 00:34:06,074
什麼樣的價值正在被代表
這裡這八個1位？

772
00:34:06,074 --> 00:34:06,950
255。

773
00:34:06,950 --> 00:34:09,260
即使你是不是很確定
數學的，你可以做出來。

774
00:34:09,260 --> 00:34:10,550
或者你可以只種
原因通過它，

775
00:34:10,550 --> 00:34:12,633
等一下，如果我
較8位值，

776
00:34:12,633 --> 00:34:17,750
我已經得到了256個可能的值，
但其中第一是0，

777
00:34:17,750 --> 00:34:19,909
我只知道，
最大的將是255，

778
00:34:19,909 --> 00:34:21,510
而這正是這一個可能。

779
00:34:21,510 --> 00:34:26,060
>> 因此，假設我嘗試添加1到這個值。

780
00:34:26,060 --> 00:34:28,750
你會在年級做
加入學校的時候1，而且

781
00:34:28,750 --> 00:34:31,139
並不真正適合，因為
你必須隨身攜帶的1？

782
00:34:31,139 --> 00:34:34,380
這是什麼數將
當你加1變成什麼？

783
00:34:34,380 --> 00:34:37,030
這將變為0。

784
00:34:37,030 --> 00:34:37,530
對嗎？

785
00:34:37,530 --> 00:34:41,139
因為如果你有更多的bits--，我會
嘗試，種，它這裡 - 打出來

786
00:34:41,139 --> 00:34:44,710
如果我們有更多的位，我們
可以在這裡做的是添加1，

787
00:34:44,710 --> 00:34:47,370
然後我們會得到這一點。

788
00:34:47,370 --> 00:34:48,739
哎呦。

789
00:34:48,739 --> 00:34:52,250
我們希望有一個1位一路看過來。

790
00:34:52,250 --> 00:34:55,530
>> 但是，如果這是一個有限
值，這是只有8位，

791
00:34:55,530 --> 00:34:57,480
這就是預先確定
由計算機，

792
00:34:57,480 --> 00:34:59,370
這1實際上是不存在的。

793
00:34:59,370 --> 00:35:00,980
正中下懷它掉下懸崖。

794
00:35:00,980 --> 00:35:05,480
所以，如果你添加1到255，有什麼
值你顯然得到什麼呢？

795
00:35:05,480 --> 00:35:06,180
0。

796
00:35:06,180 --> 00:35:09,700
所以意外的數字，
或許，無意間，

797
00:35:09,700 --> 00:35:12,040
最終披著這樣。

798
00:35:12,040 --> 00:35:14,079
那麼什麼可以是這意味著什麼呢？

799
00:35:14,079 --> 00:35:15,620
嗯，有一些不同的東西。

800
00:35:15,620 --> 00:35:18,751
所以之一，它最終看起來
如0，無意間，

801
00:35:18,751 --> 00:35:20,750
但你可以種看，
即使在現實世界中，

802
00:35:20,750 --> 00:35:23,416
是好還是壞，
表現這種思想的限制。

803
00:35:23,416 --> 00:35:26,630
例如，任何你誰
玩過樂高星球大戰，

804
00:35:26,630 --> 00:35:28,880
沒有人知道發生
硬幣的最大數目

805
00:35:28,880 --> 00:35:32,032
您可以在樂高星球大戰收集？

806
00:35:32,032 --> 00:35:35,640
以基於猜測
當今領先的問題。

807
00:35:35,640 --> 00:35:39,140
這是大於256或255。

808
00:35:39,140 --> 00:35:40,330
它的4間十億。

809
00:35:40,330 --> 00:35:42,080
所以，事實證明，和
有一些people--

810
00:35:42,080 --> 00:35:46,080
一些谷歌上搜索確認最後night--
已經得到了4個十億金幣，

811
00:35:46,080 --> 00:35:47,730
或者諸如此類的東西，在樂高星球大戰。

812
00:35:47,730 --> 00:35:49,860
雖然很明顯，有
一種方法來欺騙遊戲，

813
00:35:49,860 --> 00:35:53,222
有一個錯誤或功能，可以讓你
只是累積很多很多的點。

814
00:35:53,222 --> 00:35:54,930
但最大的可能
值，根據

815
00:35:54,930 --> 00:35:58,360
這個屏幕截圖的人，我
網上找到的，確實是，4個十億。

816
00:35:58,360 --> 00:35:59,240
>> 現在，這是為什麼？

817
00:35:59,240 --> 00:36:03,040
這正是4個十億，
可能是因為有人決定，

818
00:36:03,040 --> 00:36:05,500
誰在寫本場比賽，
他們可以做4組十億，

819
00:36:05,500 --> 00:36:07,340
什麼，什麼，什麼，
像值我忍了

820
00:36:07,340 --> 00:36:10,256
用計算器較早，但
它只是一個少許清潔劑對人類

821
00:36:10,256 --> 00:36:12,610
說的最大數量
的coins--或螺栓，

822
00:36:12,610 --> 00:36:14,860
他們稱之為them--你
可以收集4十億。

823
00:36:14,860 --> 00:36:16,290
所以，這是為什麼？

824
00:36:16,290 --> 00:36:20,310
如何為樂高遊戲
實施反

825
00:36:20,310 --> 00:36:23,420
那就是維持軌道的
硬幣有多少？

826
00:36:23,420 --> 00:36:24,266
他們使用的是什麼？

827
00:36:24,266 --> 00:36:26,390
觀眾：它停止
4個十億後計數。

828
00:36:26,390 --> 00:36:27,720
大衛·馬蘭：它停止
4個十億計數後，

829
00:36:27,720 --> 00:36:29,525
這意味著你可以
推斷，作為一個程序員，

830
00:36:29,525 --> 00:36:31,960
他們很可能
使用32位的整數。

831
00:36:31,960 --> 00:36:35,380
就像程序員真的只是
類型化，INT，在他或她的代碼，

832
00:36:35,380 --> 00:36:39,620
這就是可變的類型
他們使用存儲別人的代碼。

833
00:36:39,620 --> 00:36:42,230
因此，有其他表現
這些類型的限制。

834
00:36:42,230 --> 00:36:45,063
>> 所以，我沒有玩過這個game--
而我讀了歷史

835
00:36:45,063 --> 00:36:48,470
確認作為muc​​h--但在
文明，那裡的原始版本

836
00:36:48,470 --> 00:36:53,240
你顯然與每個互動
另外，可以發動戰爭或和平，

837
00:36:53,240 --> 00:36:56,590
甘地被認為是一個
最和平的角色，因為我

838
00:36:56,590 --> 00:36:59,280
理解，在第一
版本文明。

839
00:36:59,280 --> 00:37:03,250
而事實上，在範圍為1至10，
他的侵略性只是一個1。

840
00:37:03,250 --> 00:37:05,620
所以永遠是那麼溫和
侵略性，顯然。

841
00:37:05,620 --> 00:37:11,590
>> 但是，在某些時候，你可以很明顯
在地理上安裝民主。

842
00:37:11,590 --> 00:37:14,900
如果你安裝的民主
到你的遊戲版本，

843
00:37:14,900 --> 00:37:17,320
那麼你的攻擊水平下降。

844
00:37:17,320 --> 00:37:18,460
這是一個很好的事情。

845
00:37:18,460 --> 00:37:20,890
人們更安靜
顯然，在這種情況下。

846
00:37:20,890 --> 00:37:23,190
但很顯然，有人做
沒有一個，如果，條件

847
00:37:23,190 --> 00:37:24,780
在代碼中的原始版本。

848
00:37:24,780 --> 00:37:30,650
>> 所以，甘地的侵略水平由去
正1，負2，負1，

849
00:37:30,650 --> 00:37:33,840
但遊戲不
了解負數。

850
00:37:33,840 --> 00:37:38,680
所以，事情的經過是甘地的侵略
從1級去了，到0，負1，

851
00:37:38,680 --> 00:37:40,900
這具有的效果
折回是

852
00:37:40,900 --> 00:37:44,690
最積極的角色
在比賽中，以255的值，

853
00:37:44,690 --> 00:37:46,630
上的比例為1至10。

854
00:37:46,630 --> 00:37:49,887
從那時起，還有的是
更化身這場比賽，

855
00:37:49,887 --> 00:37:51,720
他們已經把它作為
一種復活節彩蛋的，

856
00:37:51,720 --> 00:37:53,870
甘地顯然是
這麼可怕的攻擊性。

857
00:37:53,870 --> 00:37:56,740
但它是一個結果
很簡單的編程錯誤

858
00:37:56,740 --> 00:37:58,630
在遊戲中的該非常早期版本。

859
00:37:58,630 --> 00:38:02,860
>> 現在更令人不安的是，多
最近，波音787

860
00:38:02,860 --> 00:38:05,720
被記錄為具有
錯誤，不是那種設備

861
00:38:05,720 --> 00:38:07,340
你特別想有一個bug。

862
00:38:07,340 --> 00:38:10,130
且症狀，我會讀
在這裡，從網上的文章，

863
00:38:10,130 --> 00:38:13,840
是這樣的，一個模型787飛機
已連續供電

864
00:38:13,840 --> 00:38:18,030
248天就失去了所有
交變電流，交流，

865
00:38:18,030 --> 00:38:20,850
電功率，由於
發電機控制單元，

866
00:38:20,850 --> 00:38:23,330
GCUs，同時
進入故障安全模式。

867
00:38:23,330 --> 00:38:26,790
因此，這是發出警告
當這個問題被發現。

868
00:38:26,790 --> 00:38:28,750
這種情況是由於
通過軟件計數器，

869
00:38:28,750 --> 00:38:32,230
內部的GCUs，所以
整數或一個變量，

870
00:38:32,230 --> 00:38:36,850
248之後溢出
連續功率天。

871
00:38:36,850 --> 00:38:40,350
波音是在過程中
開發GCU軟件升級

872
00:38:40,350 --> 00:38:42,350
將彌補的不安全狀態。

873
00:38:42,350 --> 00:38:44,226
>> 那麼像導彈
方案中，其中，

874
00:38:44,226 --> 00:38:46,850
他們有一些類型的變量
被計數，計數，

875
00:38:46,850 --> 00:38:50,720
和計數，但漸漸溢滿
其能力的界限，

876
00:38:50,720 --> 00:38:54,890
同樣做了該死的飛機
具有可變的溢出

877
00:38:54,890 --> 00:38:56,410
經過足夠的時間運行。

878
00:38:56,410 --> 00:38:59,240
這樣一來，舌頭在臉頰的方式
解決此問題的工作

879
00:38:59,240 --> 00:39:04,400
是真正的，重新啟動，你的飛機每
247個天，使得存儲器被擦拭

880
00:39:04,400 --> 00:39:06,100
和可變回到0。

881
00:39:06,100 --> 00:39:09,410
但要意識到，這是一個非常
大型化身軟件，

882
00:39:09,410 --> 00:39:14,070
但特別是當我們聽到蘋果
操作系統進入汽車，

883
00:39:14,070 --> 00:39:18,030
並從谷歌自駕車車，
任意數量的軟件的化身

884
00:39:18,030 --> 00:39:21,000
在我們的日常生活中，電視
和手錶等，

885
00:39:21,000 --> 00:39:24,950
實現由軟件所包圍，
所有這一切都寫的是我們人類。

886
00:39:24,950 --> 00:39:28,150
>> 正如我們都會很快就會發現，
它很容易和非常典型

887
00:39:28,150 --> 00:39:30,250
編寫軟件時犯錯誤。

888
00:39:30,250 --> 00:39:32,745
如果你不抓住他們，
一些不好的事情都可能發生。

889
00:39:32,745 --> 00:39:35,400
現在有時，一些
有趣的事情都可能發生，

890
00:39:35,400 --> 00:39:38,280
或者至少有時候我們
知道會發生一些不良。

891
00:39:38,280 --> 00:39:41,550
因此，0除以0，從等級
學校，一般是一件壞事。

892
00:39:41,550 --> 00:39:43,050
這是不確定的。

893
00:39:43,050 --> 00:39:46,440
而事實證明out--，讓如果我們看
我的麥克風可以選擇此up--蘋果

894
00:39:46,440 --> 00:39:47,790
曾與這一些有趣的最近。

895
00:39:47,790 --> 00:39:48,850
所以，我有一個iPhone在這裡。

896
00:39:48,850 --> 00:39:54,160
我要談的Siri，問她
給我的答案0除以0。

897
00:39:54,160 --> 00:39:55,850
什麼是0除以0？

898
00:39:55,850 --> 00:39:59,350

899
00:39:59,350 --> 00:40:02,230
>> SIRI：假設您有0
餅乾，和你平分他們

900
00:40:02,230 --> 00:40:03,540
在0朋友。

901
00:40:03,540 --> 00:40:05,810
多少餅乾確實每個人得到什麼呢？

902
00:40:05,810 --> 00:40:06,350
看到了嗎？

903
00:40:06,350 --> 00:40:07,660
它沒有意義。

904
00:40:07,660 --> 00:40:10,540
而且餅乾怪獸是悲哀
有沒有餅乾。

905
00:40:10,540 --> 00:40:13,987
而你傷心，
你有沒有朋友。

906
00:40:13,987 --> 00:40:15,570
大衛·馬蘭：這是一種令人厭惡的。

907
00:40:15,570 --> 00:40:17,550
所以這就是剛才說有。

908
00:40:17,550 --> 00:40:21,380
這是不確定的，它沒有定義，
而事實上，許多編程語言

909
00:40:21,380 --> 00:40:24,950
或者，真的，編譯器會
當您，檢測程序，

910
00:40:24,950 --> 00:40:27,050
試圖除以0 0。

911
00:40:27,050 --> 00:40:29,830
更多樂趣比這雖然是
，顯然，餅乾怪獸

912
00:40:29,830 --> 00:40:31,270
是在Twitter上的這些日子。

913
00:40:31,270 --> 00:40:37,610
他回答了，這一點，
這是絕對可愛。

914
00:40:37,610 --> 00:40:40,110
但是，讓我們快速瀏覽一下
一對夫婦的其他構造，

915
00:40:40,110 --> 00:40:43,459
然後把一些這方面的
代碼中使用，以良好的方式。

916
00:40:43,459 --> 00:40:45,250
所以，事實證明，除了
對循環，有

917
00:40:45,250 --> 00:40:49,174
一種叫做while循環，即
看起來不同的，是實現

918
00:40:49,174 --> 00:40:51,590
一個小differently--和
我們最終會看到examples--

919
00:40:51,590 --> 00:40:53,500
但在某種意義上，
它的簡單，因為它

920
00:40:53,500 --> 00:40:56,670
不允許初始化和
環路的邊界之內更新。

921
00:40:56,670 --> 00:40:57,794
你仍然可以實現它。

922
00:40:57,794 --> 00:41:01,219
所以，你可以做同樣的事情
與while循環，與一個for循環，

923
00:41:01,219 --> 00:41:03,260
但你的語法，ultimately--
因為我們最終會

924
00:41:03,260 --> 00:41:04,551
see--將是不同的。

925
00:41:04,551 --> 00:41:07,450
甚至還有一個do while循環，這
其實是有一點不同，

926
00:41:07,450 --> 00:41:09,640
在而一個for循環
和while循環總是

927
00:41:09,640 --> 00:41:13,005
首先檢查自己的條件，如果
你看過這個東西從上到下，

928
00:41:13,005 --> 00:41:16,440
那種看起來它會
檢查它的情況最後，因為它是

929
00:41:16,440 --> 00:41:17,910
真正的最後一行代碼。

930
00:41:17,910 --> 00:41:20,580
事實上，這將是有益的
在我們編寫某些程序，

931
00:41:20,580 --> 00:41:23,746
如果你想只是盲目地做一些事情
最終檢查的條件。

932
00:41:23,746 --> 00:41:25,205
這不一定是壞事。

933
00:41:25,205 --> 00:41:27,912
如果我們想要的變量，我們可以做
它在幾個不同的方式。

934
00:41:27,912 --> 00:41:30,290
而我們的狐步舞看見
卡通，做的一種方法，

935
00:41:30,290 --> 00:41:33,400
在這裡你聲明的變量，
如int計數器分號，

936
00:41:33,400 --> 00:41:36,570
然後later--說不定下
行，也許10線later--

937
00:41:36,570 --> 00:41:37,800
你居然初始化。

938
00:41:37,800 --> 00:41:42,230
因此，這2行代碼
聲明一個int類型的變量

939
00:41:42,230 --> 00:41:44,930
並稱之為反，所以它給
我足夠的​​位來容納一個int。

940
00:41:44,930 --> 00:41:48,230
然後最終，它把
值0到該變量。

941
00:41:48,230 --> 00:41:51,250
它排列0和1的在一個
模式，我們知道上週，

942
00:41:51,250 --> 00:41:53,260
代表我們所知道的0號。

943
00:41:53,260 --> 00:41:56,920
或者坦白地說，你可以做這麼多
更簡潔地說，就這樣。

944
00:41:56,920 --> 00:41:59,390
>> 現在，我們也有
能夠調用函數。

945
00:41:59,390 --> 00:42:03,070
而事實上，這裡有一個2線
程序，或它們的摘錄，

946
00:42:03,070 --> 00:42:06,157
這使我們能夠真正
編寫一些代碼，

947
00:42:06,157 --> 00:42:08,990
得到來自user--字符串多
就像我們的志願者一時ago--

948
00:42:08,990 --> 00:42:11,320
結果存儲到
一個名為名稱的變量，

949
00:42:11,320 --> 00:42:15,470
和then--很像我們的志願者
與printf--打印出這些值

950
00:42:15,470 --> 00:42:19,180
通過傳遞兩個參數，
串，其次是可變

951
00:42:19,180 --> 00:42:20,781
叫，名稱本身。

952
00:42:20,781 --> 00:42:23,155
因此，讓我們來看看，前
我們再回過頭來馬里奧那裡，

953
00:42:23,155 --> 00:42:26,010
在一對夫婦的這個現在的例子。

954
00:42:26,010 --> 00:42:30,537
>> 我要繼續前進，開
了，讓我們說，功能0.c。

955
00:42:30,537 --> 00:42:33,120
和往常一樣，這個代碼是
可在球場上的網站，

956
00:42:33,120 --> 00:42:35,660
這樣你就可以在一起玩
回家看它以後。

957
00:42:35,660 --> 00:42:40,400
但這裡有一個程序在它的
本質上，從線17至22。

958
00:42:40,400 --> 00:42:43,270
主程序所在
計劃總是會啟動。

959
00:42:43,270 --> 00:42:46,980
這一方案，顯然，是怎麼回事
打印出你的名字，冒號。

960
00:42:46,980 --> 00:42:50,320
它隨後將打電話的GetString，
就像我們做了與我們的志願者。

961
00:42:50,320 --> 00:42:53,365
然後，這是有趣的，
它會調用PrintName。

962
00:42:53,365 --> 00:42:56,490
事實證明，這一切的時候，有
似乎是被稱為PrintName函數。

963
00:42:56,490 --> 00:42:57,614
可打印某人的名字。

964
00:42:57,614 --> 00:43:01,210
我們並不需要用printf從
昔日，有PrintName。

965
00:43:01,210 --> 00:43:03,500
>> 但是，這是誤導
因為PrintName不

966
00:43:03,500 --> 00:43:06,760
配備了C.人們不
一些40年或50年前發明了它，

967
00:43:06,760 --> 00:43:07,990
我這樣做，而不是。

968
00:43:07,990 --> 00:43:10,330
而事實上，如果我滾動
進一步下降，通知

969
00:43:10,330 --> 00:43:14,200
我怎麼能寫我自己
在C函數我們最終會

970
00:43:14,200 --> 00:43:16,319
解釋為什麼我們一直在說，
無效，在少數地方，

971
00:43:16,319 --> 00:43:18,110
但今天，讓我們
光看這個名字。

972
00:43:18,110 --> 00:43:20,905
>> 在第24行，如果你想
創建自己的功能，

973
00:43:20,905 --> 00:43:22,780
你從字面上寫的
功能的命名。

974
00:43:22,780 --> 00:43:24,340
我選擇了PrintName。

975
00:43:24,340 --> 00:43:26,159
在括號，你
然後指定哪幾種

976
00:43:26,159 --> 00:43:28,450
投入，有多少你
希望此功能可走。

977
00:43:28,450 --> 00:43:31,906
在這種情況下，我想帶
1變量調用，名稱，

978
00:43:31,906 --> 00:43:34,030
而這將是
型，字符串，因此它會

979
00:43:34,030 --> 00:43:35,780
是一串字符。

980
00:43:35,780 --> 00:43:39,170
然後，這個program--
就像在刮，

981
00:43:39,170 --> 00:43:42,590
你可以定制拼圖pieces--
將有這種自定義行為。

982
00:43:42,590 --> 00:43:46,760
這將調用printf
傳遞，你好，佔位符，

983
00:43:46,760 --> 00:43:49,110
然後它會堵塞
在任何用戶調用。

984
00:43:49,110 --> 00:43:51,450
>> 所以這是一個例子是什麼
計算機科學家會

985
00:43:51,450 --> 00:43:55,090
調用抽象或功能
分解，這只是

986
00:43:55,090 --> 00:43:58,110
花哨的方式saying--是，如果
你喜歡這個高層次的想法，

987
00:43:58,110 --> 00:44:01,569
像我想功能，
打印某人的名字，絕對是你

988
00:44:01,569 --> 00:44:04,360
可以從字面上寫的printf然後
通過在你想要的參數，

989
00:44:04,360 --> 00:44:07,340
並計劃將工作，
因為它有自週三。

990
00:44:07,340 --> 00:44:10,510
但是，你可以開始抽象掉
打印名的概念。

991
00:44:10,510 --> 00:44:13,270
你可以給它一個名字，
像PrintName，和這

992
00:44:13,270 --> 00:44:15,280
這種想法從0週分層的。

993
00:44:15,280 --> 00:44:19,910
>> 從今往後，我和你不必知道
或護理PrintName是如何實現的。

994
00:44:19,910 --> 00:44:22,470
是的，它使用printf的，也許它
不，誰知道什麼用？

995
00:44:22,470 --> 00:44:23,410
誰在乎呢？

996
00:44:23,410 --> 00:44:26,034
現在，我說在這裡，
而不是到這裡的。

997
00:44:26,034 --> 00:44:28,700
事實上，作為我們的計劃獲得
更加先進和複雜，

998
00:44:28,700 --> 00:44:32,550
我們將繼續採取理所當然
較低級別的拼圖存在。

999
00:44:32,550 --> 00:44:34,780
因為我們寫了他們
或者別人沒有，所以

1000
00:44:34,780 --> 00:44:36,910
我們可以再建在它們上面。

1001
00:44:36,910 --> 00:44:39,430
讓我們來看看這個
變型，功能之一。

1002
00:44:39,430 --> 00:44:41,780
>> 所以這一塊是一個有點多
先進的，但事實證明，

1003
00:44:41,780 --> 00:44:44,570
在CS50的圖書館，
這裡只有一個調用getInt功能。

1004
00:44:44,570 --> 00:44:47,720
我們沒有想到，幾年前，到
實現GetPositiveInt功能。

1005
00:44:47,720 --> 00:44:50,970
這是一個有點惱人，因為如果
你們正在編寫一個程序，其中

1006
00:44:50,970 --> 00:44:53,325
你想獲得一個積極的
從用戶的整數，

1007
00:44:53,325 --> 00:44:55,010
你完全可以使用調用getInt。

1008
00:44:55,010 --> 00:44:57,840
你完全可以用檢查
條件，也許一個循環

1009
00:44:57,840 --> 00:45:00,320
如果int是更大
比0和罵的用戶

1010
00:45:00,320 --> 00:45:02,699
如果他或她不給
你正數。

1011
00:45:02,699 --> 00:45:04,740
但是，讓我們建立這個
建築擋住自己，一，

1012
00:45:04,740 --> 00:45:06,555
定制刮片，如果你願意。

1013
00:45:06,555 --> 00:45:08,680
我將有一個程序
在這裡，最終，我

1014
00:45:08,680 --> 00:45:11,780
希望能夠調用
GetPositiveInt，我想成為

1015
00:45:11,780 --> 00:45:14,200
能夠打印出什麼那int是。

1016
00:45:14,200 --> 00:45:16,240
但是，這是現在的抽象化了。

1017
00:45:16,240 --> 00:45:19,050
它只是被賦予了很高的水平
名稱它做什麼，

1018
00:45:19,050 --> 00:45:21,780
這是美妙的，因為它是
非常直觀，現在讀。

1019
00:45:21,780 --> 00:45:24,710
如果我做不在乎什麼是底下
引擎蓋，讓我向下滾動。

1020
00:45:24,710 --> 00:45:27,140
這是一個有點嚇人
在第一，尤其

1021
00:45:27,140 --> 00:45:29,470
如果這是你的第一個程序，
但讓​​我們一起來看看。

1022
00:45:29,470 --> 00:45:32,860
>> 我不再說的，無效的，
因為事實證明功能，

1023
00:45:32,860 --> 00:45:34,777
就像GetString的，可
返回一個值給我。

1024
00:45:34,777 --> 00:45:36,610
他們不只是有
打印到屏幕上，

1025
00:45:36,610 --> 00:45:38,410
他們實際上可以手
我的東西回來。

1026
00:45:38,410 --> 00:45:41,535
和而PrintName之前，
我沒回來需要什麼。

1027
00:45:41,535 --> 00:45:44,160
我需要的副作用
東西顯示在屏幕上，

1028
00:45:44,160 --> 00:45:46,570
但我並不需要一個人
遞給我的東西回來。

1029
00:45:46,570 --> 00:45:48,840
這裡，與GetPositiveInt，
像調用getInt，

1030
00:45:48,840 --> 00:45:50,640
我想交到東西回來。

1031
00:45:50,640 --> 00:45:53,220
所以我說不是的，無效的，
在線路23，但整型，

1032
00:45:53,220 --> 00:45:55,570
它說，該功能
我正在寫，

1033
00:45:55,570 --> 00:45:58,860
稱為GetPositiveInt是要
遞給我回一個整數，沒有什麼，

1034
00:45:58,860 --> 00:45:59,890
不作廢。

1035
00:45:59,890 --> 00:46:03,280
>> 同時，要採取不
投入，所以我，善良，推翻它。

1036
00:46:03,280 --> 00:46:08,280
我不給GetPositiveInt任何
輸入時，我希望它給我的輸出。

1037
00:46:08,280 --> 00:46:09,800
然後現在會發生什麼？

1038
00:46:09,800 --> 00:46:11,640
因此，這裡就是我可以聲明一個變量。

1039
00:46:11,640 --> 00:46:15,090
我一直在循環之外做了，
對於原因，我們最終會看到，

1040
00:46:15,090 --> 00:46:17,700
但是這只是給
我的32位調用，N，

1041
00:46:17,700 --> 00:46:20,952
我已經預先確定
他們存儲的整數。

1042
00:46:20,952 --> 00:46:23,660
而下面這一點，做while結構，
這就是為什麼它是非常有用的。

1043
00:46:23,660 --> 00:46:26,700
從字面上做到這一點，
而n小於1。

1044
00:46:26,700 --> 00:46:28,030
因此，讓我們看看會發生什麼。

1045
00:46:28,030 --> 00:46:30,760
我打印出來，請
給我一個積極的INT。

1046
00:46:30,760 --> 00:46:34,300
然後我得到一個int，使用CS50的
功能與存儲在n個。

1047
00:46:34,300 --> 00:46:38,990
>> 然後，什麼樣的代碼行可能
下一個被執行，邏輯？

1048
00:46:38,990 --> 00:46:41,890
哪條線是多少？

1049
00:46:41,890 --> 00:46:42,571
是啊，所以31。

1050
00:46:42,571 --> 00:46:45,320
你不會知道，直到你
被告知或排序的推斷是，

1051
00:46:45,320 --> 00:46:45,986
但是這是真的。

1052
00:46:45,986 --> 00:46:48,280
不言而喻從上到下
然後不斷重複。

1053
00:46:48,280 --> 00:46:55,840
所以，如果我已經輸入中說，數
負1，為n比1負少？

1054
00:46:55,840 --> 00:46:56,340
是啊。

1055
00:46:56,340 --> 00:46:58,470
因為負1小於1。

1056
00:46:58,470 --> 00:46:59,510
那麼會發生什麼情況？

1057
00:46:59,510 --> 00:47:03,260
我要做到這一點
而n是小於1，

1058
00:47:03,260 --> 00:47:05,760
所以我打算回去線28。

1059
00:47:05,760 --> 00:47:09,530
>> 而每一個時間 - 讓我們運行this--
讓功能1編譯它，

1060
00:47:09,530 --> 00:47:11,340
現在點斜線功能1。

1061
00:47:11,340 --> 00:47:14,280
如果我型負1，這是
要保持吼我

1062
00:47:14,280 --> 00:47:17,530
直到我合作，因為每個
我的輸入小於1

1063
00:47:17,530 --> 00:47:20,070
如果它而小於1，
我將繼續這樣做。

1064
00:47:20,070 --> 00:47:24,240
如果我終於給它一些像50，
值得慶幸的是，它說，感謝50。

1065
00:47:24,240 --> 00:47:24,970
為什麼呢？

1066
00:47:24,970 --> 00:47:30,640
因為只要n是不小於
1，我停止陷在這個循環中，

1067
00:47:30,640 --> 00:47:33,840
而這種新的關鍵字的今天，
返回時，從字面上做到這一點。

1068
00:47:33,840 --> 00:47:36,800
所以，我剛剛實施，在
感，GetString的相當於，

1069
00:47:36,800 --> 00:47:40,590
在那裡我遞回
不管是誰用我的，一定的價值。

1070
00:47:40,590 --> 00:47:42,820
它並不必須是
一個字符串，它是一個int。

1071
00:47:42,820 --> 00:47:44,990
因此，一個簡單，快捷
舉例來說，但我們會很快

1072
00:47:44,990 --> 00:47:47,930
看到一些更複雜
版本還在。

1073
00:47:47,930 --> 00:47:53,882
事實上，讓我們來看看一個
數字1，這是所​​謂return.c。

1074
00:47:53,882 --> 00:47:55,590
而這其中實際上
簡單一點。

1075
00:47:55,590 --> 00:47:59,010
因此，在這個方案的目的
life--讓我們編譯並運行它，

1076
00:47:59,010 --> 00:48:03,090
所以要回報，點
斜線，return--通知

1077
00:48:03,090 --> 00:48:05,530
程序簡單立方體的價值2。

1078
00:48:05,530 --> 00:48:08,410
它是非常愚蠢的，這是很難
代碼，它沒有採取任何投入，

1079
00:48:08,410 --> 00:48:12,220
但它確實說明另一個
我寫我自己的功能。

1080
00:48:12,220 --> 00:48:15,760
所以在這裡，我宣布一個
可變的，所謂的類型為int x，，

1081
00:48:15,760 --> 00:48:17,840
等於數字2，
完全是任意的。

1082
00:48:17,840 --> 00:48:19,530
這僅僅是一些蓬鬆打印。

1083
00:48:19,530 --> 00:48:23,070
它說，x是現在，這樣的和
這樣，多維數據點點點。

1084
00:48:23,070 --> 00:48:26,390
而神奇的是顯然的第21行。

1085
00:48:26,390 --> 00:48:30,120
我打電話調用的函數，立方體，
我交給它的一張紙

1086
00:48:30,120 --> 00:48:32,890
用數字2寫在上面，
和什麼樣的價值，數學，

1087
00:48:32,890 --> 00:48:34,860
我想出來的嗎？

1088
00:48:34,860 --> 00:48:36,570
正如完整性檢查？

1089
00:48:36,570 --> 00:48:37,070
8。

1090
00:48:37,070 --> 00:48:37,570
對嗎？

1091
00:48:37,570 --> 00:48:40,160
我想2立方回，2〜
3的力量，所以8回。

1092
00:48:40,160 --> 00:48:42,570
>> 那麼，是立方體實現？

1093
00:48:42,570 --> 00:48:44,349
好吧，發現它在這裡實現了。

1094
00:48:44,349 --> 00:48:47,140
就如同之前，從邏輯上講，
即使語法可能是

1095
00:48:47,140 --> 00:48:49,320
很新，你們中許多人，
我想這個功能

1096
00:48:49,320 --> 00:48:51,780
遞給我回來的片
紙，上面有一個int。

1097
00:48:51,780 --> 00:48:53,990
所以，我有一個int，該
名字是隨意，

1098
00:48:53,990 --> 00:48:55,530
可方便地稱為立方體。

1099
00:48:55,530 --> 00:48:58,430
輸入到它，是n
整型，所以這是

1100
00:48:58,430 --> 00:49:00,800
我怎麼可以通過在數
2上一張紙。

1101
00:49:00,800 --> 00:49:03,910
然後事實證明C支持
數學，所以你不用X的的時間，

1102
00:49:03,910 --> 00:49:06,680
你只需要使用星號
乘法。

1103
00:49:06,680 --> 00:49:11,070
而這個返回n次n次
N，這是一個簡單的立方值。

1104
00:49:11,070 --> 00:49:12,840
>> 那麼，我們要與這一切？

1105
00:49:12,840 --> 00:49:14,570
這絕對是一個
旋風之旅，放心，

1106
00:49:14,570 --> 00:49:16,410
在超級節
而在問題設置1，

1107
00:49:16,410 --> 00:49:18,368
你可以通過走
這一切全愈。

1108
00:49:18,368 --> 00:49:22,490
而在問題設置1，我們將過渡
從頭開始的圖形世界

1109
00:49:22,490 --> 00:49:25,640
到更多的東西命令行
在C.但我們會汲取靈感

1110
00:49:25,640 --> 00:49:27,680
從此這裡的遊戲
從昔日的，其中，

1111
00:49:27,680 --> 00:49:31,591
使用C和的標準版
p將您將實現馬里奧的金字塔。

1112
00:49:31,591 --> 00:49:34,340
而在的黑客版
p將，如果你選擇選舉，

1113
00:49:34,340 --> 00:49:38,280
您將實現多一點
有兩個高峰挑戰金字塔。

1114
00:49:38,280 --> 00:49:41,239
您還可以實施
算法，貪婪算法。

1115
00:49:41,239 --> 00:49:43,030
原來有
一些有趣的邏輯

1116
00:49:43,030 --> 00:49:45,640
過程背後
運行出納站

1117
00:49:45,640 --> 00:49:47,410
實際上交給
有人背的變化。

1118
00:49:47,410 --> 00:49:50,410
有一種算法，是相當
簡單的，你甚至可能

1119
00:49:50,410 --> 00:49:53,576
直觀地把握，當你第一次讀到
它 - 意識到這就是我一直

1120
00:49:53,576 --> 00:49:57,110
做我已經給了一些人的任何時間
錢back--，讓你永遠

1121
00:49:57,110 --> 00:50:00,679
最小化的數量
紙幣或金屬幣

1122
00:50:00,679 --> 00:50:02,220
您正在移交給用戶。

1123
00:50:02,220 --> 00:50:04,610
而這，當然，是引人注目
因為如果你去CVS或諸如此類的東西，

1124
00:50:04,610 --> 00:50:06,430
你不想成為手
一大堆的人

1125
00:50:06,430 --> 00:50:07,596
或者一大堆便士。

1126
00:50:07,596 --> 00:50:10,120
你想最少
硬幣，大概，可能。

1127
00:50:10,120 --> 00:50:13,070
>> 最後，你也可以挑戰
在水世界玩水

1128
00:50:13,070 --> 00:50:17,220
而實際上得到升值
對於流動速率之間的映射，

1129
00:50:17,220 --> 00:50:19,890
都喜歡，水淋浴，
到底有多少水被使用。

1130
00:50:19,890 --> 00:50:22,640
而其中的典故，
將這個片段在這裡，

1131
00:50:22,640 --> 00:50:24,840
我們將結束對
短短60秒，即

1132
00:50:24,840 --> 00:50:29,070
描繪了一幅圖片
低流量的淋浴噴頭。

1133
00:50:29,070 --> 00:50:30,886
>> [視頻回放]

1134
00:50:30,886 --> 00:50:31,385
 - 所有權利。

1135
00:50:31,385 --> 00:50:32,774
我在這裡得到的一切。

1136
00:50:32,774 --> 00:50:35,800
我得到了旋風F系列，
水潤，Jetflow，斯德哥爾摩

1137
00:50:35,800 --> 00:50:37,660
Supersteam，你的名字。

1138
00:50:37,660 --> 00:50:39,265
>>  - 和你有什麼建議？

1139
00:50:39,265 --> 00:50:40,460
>>  - 什麼是你找誰？

1140
00:50:40,460 --> 00:50:41,300
>> -Power的人。

1141
00:50:41,300 --> 00:50:42,285
電源。

1142
00:50:42,285 --> 00:50:42,910
樣絲克伍事件。

1143
00:50:42,910 --> 00:50:44,520
 - 這就是輻射。

1144
00:50:44,520 --> 00:50:46,335
 - 那是正確的。

1145
00:50:46,335 --> 00:50:48,275
 - 現在這是什麼？

1146
00:50:48,275 --> 00:50:49,704
 - 這就是特種兵450。

1147
00:50:49,704 --> 00:50:50,620
我不賣這個。

1148
00:50:50,620 --> 00:50:51,700
>>  - 但是，這就是我們想要的。

1149
00:50:51,700 --> 00:50:52,680
這是一個突擊隊450。

1150
00:50:52,680 --> 00:50:53,882
>>  - 不相信我。

1151
00:50:53,882 --> 00:50:55,090
它僅用於馬戲團。

1152
00:50:55,090 --> 00:50:56,512
這是大象。

1153
00:50:56,512 --> 00:50:59,356
>> -I'll支付任何費用。

1154
00:50:59,356 --> 00:51:01,252
>>  - 什麼對傑里？

1155
00:51:01,252 --> 00:51:02,760
>>  - 他不能處理。

1156
00:51:02,760 --> 00:51:04,910
他細膩。

1157
00:51:04,910 --> 00:51:05,750
哦，是的。

1158
00:51:05,750 --> 00:51:36,737

1159
00:51:36,737 --> 00:51:37,320
[結束播放]

1160
00:51:37,320 --> 00:51:37,700
大衛·馬蘭：好的。

1161
00:51:37,700 --> 00:51:38,820
那如果CS50。

1162
00:51:38,820 --> 00:51:40,050
我們會看到你下週。

1163
00:51:40,050 --> 00:51:45,910

1164
00:51:45,910 --> 00:51:49,029
>> 揚聲器1：[？斯卡利？]，[？伊恩？]
只要這個尾奏項目，

1165
00:51:49,029 --> 00:51:50,362
你有什麼傢伙想出了？

1166
00:51:50,362 --> 00:51:51,990
>> 揚聲器2：好了，我們已經給
它的各種思想，

1167
00:51:51,990 --> 00:51:53,250
我們認為，最好的辦法用於：

1168
00:51:53,250 --> 00:51:53,660
>> 揚聲器3：我？

1169
00:51:53,660 --> 00:51:54,326
>> 揚聲器2：是的。

1170
00:51:54,326 --> 00:51:56,360
通過一切手段，其實。

1171
00:51:56,360 --> 00:51:59,425
>> 揚聲器3：所以我覺得
我們可以總結一下我們的想法

1172
00:51:59,425 --> 00:52:05,450
對於一個word--什麼的片尾。

1173
00:52:05,450 --> 00:52:08,950

1174
00:52:08,950 --> 00:52:10,409
>> 大衛·馬蘭：沒事？

1175
00:52:10,409 --> 00:52:11,200
揚聲器3：沒有。

1176
00:52:11,200 --> 00:52:12,990
大衛·馬蘭：這是什麼意思？

1177
00:52:12,990 --> 00:52:16,260
SPEAKER 3：片尾是關於什麼。

1178
00:52:16,260 --> 00:52:21,720
揚聲器2：嗯，我的意思是，在哲學，
我的意思是，沒有什麼是永遠的東西。

1179
00:52:21,720 --> 00:52:24,200
揚聲器1：所以what's--
有什麼前提？

1180
00:52:24,200 --> 00:52:25,720
揚聲器3：所以它就像生活。

1181
00:52:25,720 --> 00:52:26,680
確定。

1182
00:52:26,680 --> 00:52:28,294
今天你做了什麼？

1183
00:52:28,294 --> 00:52:31,811
>> 大衛·馬蘭：我站起來，有
早餐，來到工作。

1184
00:52:31,811 --> 00:52:34,056
>> 揚聲器3：這是一個片尾曲。

1185
00:52:34,056 --> 00:52:36,806
揚聲器2：但是，我的意思是，不應該
事情發生在他身上的the--

1186
00:52:36,806 --> 00:52:37,889
揚聲器3：不，不，不，不。

1187
00:52:37,889 --> 00:52:40,220
什麼也沒有發生。

1188
00:52:40,220 --> 00:52:42,910
>> 揚聲器1：那麼，為什麼我們看什麼？

1189
00:52:42,910 --> 00:52:46,956
>> 揚聲器3：因為
這是一個尾奏的CS50。

1190
00:52:46,956 --> 00:52:48,652
>> 大衛·馬蘭：還沒有。

1191
00:52:48,652 --> 00:52:49,151