1
00:00:07,590 --> 00:00:09,920
[Powered by Google Translate] DAVID J.馬蘭：好吧，這是CS50，這是

2
00:00:09,920 --> 00:00:15,250
結束第1週，所以研究卡的總數

3
00:00:15,250 --> 00:00:18,640
同學，你今年是745。

4
00:00:18,640 --> 00:00:20,920
我們很高興能有這麼多的過程中，

5
00:00:20,920 --> 00:00:23,680
這學期，但即使這個過程是如此之大，

6
00:00:23,680 --> 00:00:26,090
認識到，它的這些事情，比如週五的午餐，

7
00:00:26,090 --> 00:00:29,020
辦公時間，15人的部分，等等，

8
00:00:29,020 --> 00:00:30,590
真正的意思創造這更親密

9
00:00:30,590 --> 00:00:31,140
環境。

10
00:00:31,140 --> 00:00:34,070
因此，即使我們可能會收集每週一次或兩次，在這裡

11
00:00:34,070 --> 00:00:36,420
桑德斯知道這麼多你的經驗，在此過程

12
00:00:36,420 --> 00:00:39,330
非常動手的同時，你的同學

13
00:00:39,330 --> 00:00:40,730
和師資隊伍建設。

14
00:00:40,730 --> 00:00:43,960
>> 所以，在這裡，我們走了，秋天2012年。

15
00:00:43,960 --> 00:00:47,530
所以，記得我們最後一次上記下結束

16
00:00:47,530 --> 00:00:50,460
不精確，談論的數字表示。

17
00:00:50,460 --> 00:00:52,950
同時，我們也發生的故障之一，在

18
00:00:52,950 --> 00:00:54,920
現實世界中，當它來到誤解

19
00:00:54,920 --> 00:00:55,890
計算機如何工作。

20
00:00:55,890 --> 00:00:58,590
那麼，今天我們將重新審視這些想法另一個

21
00:00:58,590 --> 00:01:01,410
繼續我們的討論的CS50客戶端的

22
00:01:01,410 --> 00:01:04,090
和C，這意味著什麼真正的程序。

23
00:01:04,090 --> 00:01:06,430
但是，第一，只是一對夫婦的旋風公告。

24
00:01:06,430 --> 00:01:08,930
>> 節本週日開始的第一週始終是一個

25
00:01:08,930 --> 00:01:11,030
位的快速啟動，因為我們剛剛在

26
00:01:11,030 --> 00:01:12,620
您的截面形式。

27
00:01:12,620 --> 00:01:14,450
我們正在做的是相同的，現在的教學研究員，現在

28
00:01:14,450 --> 00:01:16,410
他們知道他們的日程安排，所以我們的目標是，通過

29
00:01:16,410 --> 00:01:19,380
星期六的早上，跟進你與你的部分

30
00:01:19,380 --> 00:01:20,760
轉讓和TF。

31
00:01:20,760 --> 00:01:22,770
要認識到，他們就會開始第二天，週日

32
00:01:22,770 --> 00:01:24,510
週一或週二。

33
00:01:24,510 --> 00:01:27,730
然後，我們將容納部分出現的變化，因為他們

34
00:01:27,730 --> 00:01:28,690
在未來的日子裡。

35
00:01:28,690 --> 00:01:31,590
辦公時間，同時，再次，今晚8日下午至11日，在

36
00:01:31,590 --> 00:01:33,740
安嫩伯格，以及明天晚上。

37
00:01:33,740 --> 00:01:36,150
即使問題集一般是由於上週四

38
00:01:36,150 --> 00:01:39,020
中午，意識到你有五遲花，

39
00:01:39,020 --> 00:01:42,430
因此，可用性，星期四辦公時間

40
00:01:42,430 --> 00:01:45,930
你的現金在那些已故的日子，因此，提交

41
00:01:45,930 --> 00:01:47,070
上週五的東西。

42
00:01:47,070 --> 00:01:50,850
讓我從頭開始更多的樂趣之中，其中

43
00:01:50,850 --> 00:01:52,390
更低調的習題集。

44
00:01:52,390 --> 00:01:55,160
我會掛到那些遲交天數，在戰略上，只

45
00:01:55,160 --> 00:01:57,380
在本學期後，當生活開始得到的方式

46
00:01:57,380 --> 00:01:59,470
期中考試和其他類。

47
00:01:59,470 --> 00:02:01,580
問題1，同時，將發布在球場上的

48
00:02:01,580 --> 00:02:06,080
本網站將在課程的步行路程，

49
00:02:06,080 --> 00:02:08,789
通過視頻，這將被拍攝下來，在上週五下午2點30分

50
00:02:08,789 --> 00:02:11,890
然後在網上發布的第二天。

51
00:02:11,890 --> 00:02:13,880
>> 因此，我們於週一結束。

52
00:02:13,880 --> 00:02:15,450
我想 - 實際上，注意這裡。

53
00:02:15,450 --> 00:02:18,870
由於類 - 因為，桑德斯並不完全借給

54
00:02:18,870 --> 00:02:22,220
本身以休閒Q＆A回，來回非常好，我們

55
00:02:22,220 --> 00:02:24,030
要嘗試一些新今年，據此，

56
00:02:24,030 --> 00:02:26,160
如果你不舒服提高你的手或你只是

57
00:02:26,160 --> 00:02:28,800
寧可不要這樣在一個房間裡，舉起你的手

58
00:02:28,800 --> 00:02:30,710
我們將有一定的教學研究員和CA

59
00:02:30,710 --> 00:02:33,260
在演講的人員編制cs50.net/discuss。

60
00:02:33,260 --> 00:02:35,440
所以，如果你有一個問題，因為我完全

61
00:02:35,440 --> 00:02:37,510
一些不清楚的東西或你很好奇

62
00:02:37,510 --> 00:02:39,640
主題，嘗試張貼在那裡。

63
00:02:39,640 --> 00:02:42,670
標記，它與標籤的演講，我們將竭盡所能

64
00:02:42,670 --> 00:02:45,430
今天和下週 - 我們就會試試這個 - 到外地

65
00:02:45,430 --> 00:02:47,990
無論是電子，網絡，或者如果它感覺就像是我們應該

66
00:02:47,990 --> 00:02:50,430
真正解決這個集體，教學研究員之一

67
00:02:50,430 --> 00:02:52,080
CA將提高他們的手，問

68
00:02:52,080 --> 00:02:53,480
匿名您的代表。

69
00:02:53,480 --> 00:02:55,650
所以，我們可以給它一個嘗試，看看它的原理。

70
00:02:55,650 --> 00:02:58,540
但是，通過各種手段，不斷舉手，你想。

71
00:02:58,540 --> 00:03:11,420
>> 所以我們最後一次發現，10％的十分之一，

72
00:03:11,420 --> 00:03:13,840
事實上，0.1，就像你教多年以前。

73
00:03:13,840 --> 00:03:15,390
其實，這樣的值。

74
00:03:15,390 --> 00:03:16,970
但是這還不是全部都是真實的，對不對？

75
00:03:16,970 --> 00:03:19,585
我們只是有這樣的約束，在計算機，據此，如果你

76
00:03:19,585 --> 00:03:22,450
只有在有限的記憶體，RAM，或更多

77
00:03:22,450 --> 00:03:25,220
特別是位很好，有只有有限數量

78
00:03:25,220 --> 00:03:26,980
的事情，你可以代表。

79
00:03:26,980 --> 00:03:29,780
例如，如果我們的零的個數，我們要

80
00:03:29,780 --> 00:03:32,790
代表二進位，8位，位，

81
00:03:32,790 --> 00:03:34,710
又是一個0或1，我們可能會

82
00:03:34,710 --> 00:03:39,240
它表示為00000000。

83
00:03:39,240 --> 00:03:41,160
這是一個有點不必要的冗長。

84
00:03:41,160 --> 00:03:43,700
就像在現實世界中的十進位制，

85
00:03:43,700 --> 00:03:47,040
一般地，如果你想要寫的編號為123，我們

86
00:03:47,040 --> 00:03:52,240
人類也許並不即使寫00000123，

87
00:03:52,240 --> 00:03:53,940
功能，這是完全一樣的。

88
00:03:53,940 --> 00:03:56,580
我們只是刪除前導零，可以這麼說。

89
00:03:56,580 --> 00:03:58,270
>> 在二進制中，我們可以做的是一樣的。

90
00:03:58,270 --> 00:04:01,440
二進制零，零和二進制為零。

91
00:04:01,440 --> 00:04:02,870
你只需要一個單一的位。

92
00:04:02,870 --> 00:04:05,020
但同樣，最常見的在世界上的度量單位

93
00:04:05,020 --> 00:04:07,820
的計算是字節，8個位。

94
00:04:07,820 --> 00:04:09,720
僅僅因為一個位，好看不中用。

95
00:04:09,720 --> 00:04:12,020
八位，而不是非常有用的，但至少，它更重要的是

96
00:04:12,020 --> 00:04:14,280
有用的度量比一個單一的單元。

97
00:04:14,280 --> 00:04:17,100
因此，用8位，我們通常會代表的二進制文件。

98
00:04:17,100 --> 00:04:20,459
所以，在這裡，我們有數字零，一，二，那麼，作為

99
00:04:20,459 --> 00:04:24,200
內特在我們的視頻最後一個星期三，我們可以繼續

100
00:04:24,200 --> 00:04:25,940
向上計數到7，8。

101
00:04:25,940 --> 00:04:27,860
然後，如果我們使用越來越多的位，我們

102
00:04:27,860 --> 00:04:29,880
可計數到無窮大。

103
00:04:29,880 --> 00:04:32,800
但是，如果你只有有限數量的這些位，因為是

104
00:04:32,800 --> 00:04:35,030
任何計算機系統中的情況下，甚至導彈

105
00:04:35,030 --> 00:04:36,670
系統，很好，你確實只有一個

106
00:04:36,670 --> 00:04:37,900
有限數量的精度。

107
00:04:37,900 --> 00:04:41,290
所以，如果你想代表的數字（如0.1），以及，

108
00:04:41,290 --> 00:04:43,410
電腦挑選。

109
00:04:43,410 --> 00:04:45,970
並且如果它僅具有有限數量的數字，它可以

110
00:04:45,970 --> 00:04:50,490
代表，它可以接近0.1，但它不能

111
00:04:50,490 --> 00:04:53,730
一定給你正是你想要的值。

112
00:04:53,730 --> 00:04:55,660
而這僅僅是一個電腦的挑戰，

113
00:04:55,660 --> 00:04:57,090
引擎蓋下的，令人欣慰的。

114
00:04:57,090 --> 00:04:59,110
>> 在本學期我們得更遠，這些較低的水平

115
00:04:59,110 --> 00:05:02,310
變得不那麼有趣的細節，但可以肯定的

116
00:05:02,310 --> 00:05:05,700
運用這些思想可以有一些非常現實的世界

117
00:05:05,700 --> 00:05:06,760
的後果。

118
00:05:06,760 --> 00:05:08,190
一個是一點樂趣。

119
00:05:08,190 --> 00:05:12,150
你們有多少人看到了驚人的電影的辦公空間嗎？

120
00:05:12,150 --> 00:05:13,620
如果你還沒有，那是你的非官方

121
00:05:13,620 --> 00:05:14,370
功課的一周。

122
00:05:14,370 --> 00:05:16,730
但是，在辦公空間中，研究人員在那部電影

123
00:05:16,730 --> 00:05:19,900
優勢，正是這種想法，但他們實際上偷

124
00:05:19,900 --> 00:05:21,270
從另一部電影，你可能有

125
00:05:21,270 --> 00:05:22,760
可見，甚至幾年前。

126
00:05:22,760 --> 00:05:24,920
因此，讓我給你幾秒鐘的這個預告片

127
00:05:24,920 --> 00:05:27,470
這個驚人的電影，這是非常

128
00:05:27,470 --> 00:05:28,340
學術有關。

129
00:05:28,340 --> 00:05:30,310
>> [播放影片]

130
00:05:30,310 --> 00:05:32,240
其實，我被提拔。

131
00:05:32,240 --> 00:05:33,360
我可以編寫一個病毒，它們會撕裂，

132
00:05:33,360 --> 00:05:34,460
將大的時間。

133
00:05:34,460 --> 00:05:35,770
那麼，它是如何工作的？

134
00:05:35,770 --> 00:05:37,836
每當有一銀行交易的興趣是

135
00:05:37,836 --> 00:05:40,154
計算，每天有成千上萬的計算機結束

136
00:05:40,154 --> 00:05:41,040
這些不足一仙。

137
00:05:41,040 --> 00:05:43,050
但我不會做任何違法的事情。

138
00:05:43,050 --> 00:05:46,730
非法？薩米爾，這是美國。

139
00:05:46,730 --> 00:05:48,010
你必須向上帝發誓。

140
00:05:48,010 --> 00:05:51,870
如果沒有人知道這一點，但我們，所有的權利嗎？沒有家人，沒有

141
00:05:51,870 --> 00:05:52,490
女朋友，沒有人。

142
00:05:52,490 --> 00:05:53,882
[聽不清]。

143
00:05:53,882 --> 00:05:57,594
不要擔心，人，我不會告訴任何人，無論是。

144
00:05:57,594 --> 00:05:59,680
[電影結束]

145
00:05:59,680 --> 00:06:01,900
>> 好吧，也許我比大多數人更好地發現這部電影

146
00:06:01,900 --> 00:06:05,530
這裡的人，但在任何情況下，他們的病毒

147
00:06:05,530 --> 00:06:06,400
努力創造 - 

148
00:06:06,400 --> 00:06:08,410
在電影中，隨時會打電話給一些病毒，

149
00:06:08,410 --> 00:06:09,770
它通常不是真正的病毒。

150
00:06:09,770 --> 00:06:11,600
這只是有人寫了一個程序，做一些事情。

151
00:06:11,600 --> 00:06:13,800
在這種情況下，球員試圖寫一個程序

152
00:06:13,800 --> 00:06:16,610
趁著他們的公司叫Innotech公司的

153
00:06:16,610 --> 00:06:19,740
計算系統，從而計算機，也一樣，甚至當它

154
00:06:19,740 --> 00:06:21,350
說到錢，可不一定

155
00:06:21,350 --> 00:06:23,490
正是代表錢。

156
00:06:23,490 --> 00:06:27,630
因此，即使你可能有您的銀行帳戶0.10美元，

157
00:06:27,630 --> 00:06:31,060
0.10，好了，電腦實際上可能會認為你有

158
00:06:31,060 --> 00:06:33,560
這美分，在您的銀行帳戶。

159
00:06:33,560 --> 00:06:35,750
所以這些人是有志於做的 - 和他們

160
00:06:35,750 --> 00:06:38,240
偷的想法，事實證明超人III，其中

161
00:06:38,240 --> 00:06:41,210
理查德·普賴爾做同樣的事情 - 他們基本上是

162
00:06:41,210 --> 00:06:44,880
編寫程序，渴望採取一切尾隨

163
00:06:44,880 --> 00:06:46,930
號，所有的微小的，微小的，微小的分數

164
00:06:46,930 --> 00:06:50,160
便士，及虹吸關閉，因此人類

165
00:06:50,160 --> 00:06:52,620
想，哦，這是唯一的0.10美元存在，但所有這些

166
00:06:52,620 --> 00:06:54,410
尾隨數字，最終增加。

167
00:06:54,410 --> 00:06:57,490
因此，一個絕妙的主意，它事與願違歡快的，

168
00:06:57,490 --> 00:06:58,250
尤其是電影。

169
00:06:58,250 --> 00:07:01,800
>> 但在現實世界中，也有更多的關於

170
00:07:01,800 --> 00:07:03,190
這些事情的影響。

171
00:07:03,190 --> 00:07:05,450
的原因之一潛入計算機領域的

172
00:07:05,450 --> 00:07:07,620
再次，是科學，其適用性不

173
00:07:07,620 --> 00:07:09,740
僅工程科學，但只是為了

174
00:07:09,740 --> 00:07:10,650
其他領域。

175
00:07:10,650 --> 00:07:14,760
因此，這是一個不太輕鬆的看看什麼可以去錯了，但

176
00:07:14,760 --> 00:07:17,630
這也是相當睜眼，我認為，當涉及到

177
00:07:17,630 --> 00:07:20,760
如何準確理解無所不在的技術，如

178
00:07:20,760 --> 00:07:22,870
計算機和編程這些天來，

179
00:07:22,870 --> 00:07:23,930
的軟件的形式。

180
00:07:23,930 --> 00:07:26,500
因此，這下一個剪輯是剛剛約為6分鐘，繼續

181
00:07:26,500 --> 00:07:30,320
最後一次我們離開的地方，但讓我們看看一點

182
00:07:30,320 --> 00:07:33,370
在這樣一個對這些問題的深入。

183
00:07:33,370 --> 00:07:35,270
讓我跳到我們離開的地方，

184
00:07:35,270 --> 00:07:37,780
這是在這裡。

185
00:07:37,780 --> 00:07:41,580
我們有兩個部分，約六分鐘在這裡。

186
00:07:41,580 --> 00:07:41,980
>> [播放電影]

187
00:07:41,980 --> 00:07:45,430
困擾現代火箭技術。

188
00:07:45,430 --> 00:07:49,280
在1991年，開始第一次海灣戰爭中，“愛國者”

189
00:07:49,280 --> 00:07:51,350
導彈經歷了類似的種

190
00:07:51,350 --> 00:07:52,645
數字轉換問題。

191
00:07:52,645 --> 00:07:57,460
而作為一個結果，20人，20名美國士兵被打死

192
00:07:57,460 --> 00:08:01,130
約100人受傷，“愛國者”，這是應該

193
00:08:01,130 --> 00:08:03,400
以防止傳入的飛毛腿導彈，

194
00:08:03,400 --> 00:08:06,020
沒有發射導彈。

195
00:08:06,020 --> 00:08:09,350
>> 在伊拉克入侵科威特，美國發動的沙漠

196
00:08:09,350 --> 00:08:13,530
風暴在1991年初，愛國者導彈

197
00:08:13,530 --> 00:08:16,970
從伊拉克部署，以保護沙特阿拉伯和以色列

198
00:08:16,970 --> 00:08:19,810
“飛毛腿”導彈的襲擊。

199
00:08:19,810 --> 00:08:23,740
“愛國者”是美國的中程表面空氣系統，

200
00:08:23,740 --> 00:08:26,370
由雷神公司製造。

201
00:08:26,370 --> 00:08:30,860
“愛國者”攔截器本身的大小，它是關於

202
00:08:30,860 --> 00:08:35,650
大約20英尺長，重約2000磅。

203
00:08:35,650 --> 00:08:38,809
它攜帶的彈頭，約 - 我認為這是大約

204
00:08:38,809 --> 00:08:40,169
150磅。

205
00:08:40,169 --> 00:08:45,820
和彈頭本身就是一種高爆炸藥，

206
00:08:45,820 --> 00:08:48,120
它周圍的碎片。

207
00:08:48,120 --> 00:08:51,870
像霰彈的彈頭外殼的設計。

208
00:08:51,870 --> 00:08:54,920
該型導彈進行4每個容器

209
00:08:54,920 --> 00:08:57,850
半拖車運輸。

210
00:08:57,850 --> 00:09:02,940
>> “愛國者”反導彈系統至少可以追溯到

211
00:09:02,940 --> 00:09:05,530
20年了。

212
00:09:05,530 --> 00:09:09,150
它最初被設計為防空導彈，以

213
00:09:09,150 --> 00:09:12,920
擊落敵方飛機，在第一次海灣戰爭。

214
00:09:12,920 --> 00:09:17,700
當那場戰爭以來，陸軍希望用它來拍攝

215
00:09:17,700 --> 00:09:19,880
跌飛毛腿“導彈，而不是飛機。

216
00:09:19,880 --> 00:09:24,860
空氣伊拉克隊就沒有那麼多的問題，但是陸軍

217
00:09:24,860 --> 00:09:27,260
飛毛腿擔心。

218
00:09:27,260 --> 00:09:30,810
因此，他們試圖升級“愛國者”。

219
00:09:30,810 --> 00:09:33,770
攔截敵方導彈在5馬赫的速度行駛會

220
00:09:33,770 --> 00:09:35,790
足夠的挑戰性。

221
00:09:35,790 --> 00:09:39,460
但是，在的愛國者被送往服務時，陸軍

222
00:09:39,460 --> 00:09:43,730
不知道的伊拉克修改了他們的

223
00:09:43,730 --> 00:09:46,510
打飛毛腿導彈幾乎是不可能的。

224
00:09:46,510 --> 00:09:50,040
>> 發生了什麼事，是飛毛腿導彈，

225
00:09:50,040 --> 00:09:51,360
未來是不穩定的。

226
00:09:51,360 --> 00:09:52,266
他們搖晃。

227
00:09:52,266 --> 00:09:56,300
這樣做的原因是伊拉克人，以獲得600

228
00:09:56,300 --> 00:10:00,650
公里，有300公里的射程導彈，花

229
00:10:00,650 --> 00:10:02,423
重量的前彈頭和

230
00:10:02,423 --> 00:10:03,990
彈頭更輕。

231
00:10:03,990 --> 00:10:08,700
所以，現在的愛國者的努力來飛毛腿，和大多數

232
00:10:08,700 --> 00:10:11,192
的時候，絕大多數的時候，它會

233
00:10:11,192 --> 00:10:13,450
只是飛的飛毛腿。

234
00:10:13,450 --> 00:10:16,300
一旦運營商“愛國者”系統實現“愛國者”

235
00:10:16,300 --> 00:10:20,160
錯過了它的目標，引爆的愛國者彈頭。

236
00:10:20,160 --> 00:10:22,760
為了避免可能出現的傷亡，它被允許

237
00:10:22,760 --> 00:10:25,100
倒在地上。

238
00:10:25,100 --> 00:10:29,400
這是大多數人所看到的，大火球在天空中，

239
00:10:29,400 --> 00:10:34,930
攔截飛毛腿彈頭和誤解。

240
00:10:34,930 --> 00:10:37,490
>> 雖然，在夜空中，似乎是

241
00:10:37,490 --> 00:10:41,570
在宰赫蘭，成功地摧毀了飛毛腿導彈，有可能是沒有

242
00:10:41,570 --> 00:10:43,730
錯誤關於它的性能。

243
00:10:43,730 --> 00:10:46,370
在那裡，愛國者的雷達系統失去一個曲目

244
00:10:46,370 --> 00:10:50,090
傳入的飛毛腿從未發起因

245
00:10:50,090 --> 00:10:51,340
一個軟件缺陷。

246
00:10:54,030 --> 00:10:57,050
這是以色列首次發現的時間越長

247
00:10:57,050 --> 00:11:02,000
系統上，更大的時間差成為，

248
00:11:02,000 --> 00:11:05,530
由於系統的計算機中的嵌入的時鐘。

249
00:11:05,530 --> 00:11:09,060
在慘劇發生前大約兩個星期，在宰赫蘭，

250
00:11:09,060 --> 00:11:11,730
以色列國防部報告說，

251
00:11:11,730 --> 00:11:13,250
系統失去的時間。

252
00:11:13,250 --> 00:11:15,610
經過約8個小時的運行，他們發現，

253
00:11:15,610 --> 00:11:18,330
制度越來越明顯不準確的。

254
00:11:18,330 --> 00:11:20,910
國防部回應，告訴所有的

255
00:11:20,910 --> 00:11:23,710
愛國者不會離開系統

256
00:11:23,710 --> 00:11:25,450
很長一段時間。

257
00:11:25,450 --> 00:11:28,010
他們從來不說，很長一段時間 -  8小時，10

258
00:11:28,010 --> 00:11:29,690
小時，千小時。

259
00:11:29,690 --> 00:11:31,940
沒有人知道。

260
00:11:31,940 --> 00:11:35,020
>> 在宰赫蘭的軍營駐紮在愛國者

261
00:11:35,020 --> 00:11:39,030
有問題的內部時鐘已經超過100小時

262
00:11:39,030 --> 00:11:42,240
二月25日的夜晚。

263
00:11:42,240 --> 00:11:46,580
它跟踪的約十分之一秒的精確度。

264
00:11:46,580 --> 00:11:48,830
現在的十分之一，二是因為一個有趣的數字

265
00:11:48,830 --> 00:11:52,660
它不能被以二進制表示，完全相同，這意味著

266
00:11:52,660 --> 00:11:54,940
它不能被正好在任何表達

267
00:11:54,940 --> 00:11:57,330
現代數字計算機。

268
00:11:57,330 --> 00:11:59,130
這是很難相信。

269
00:11:59,130 --> 00:12:01,720
但使用這個作為一個例子。

270
00:12:01,720 --> 00:12:04,090
>> 讓我們來數的三分之一。

271
00:12:04,090 --> 00:12:07,950
，究竟有三分之一不能以十進制表示。

272
00:12:07,950 --> 00:12:12,710
三分之一是0.333是無限的。

273
00:12:12,710 --> 00:12:17,050
有沒有辦法做到這一點的絕對精度十進制的。

274
00:12:17,050 --> 00:12:19,340
這也正是同樣的問題發生在

275
00:12:19,340 --> 00:12:20,190
“愛國者”。

276
00:12:20,190 --> 00:12:24,680
系統運行的時間越長，成為時間更糟糕的錯誤。

277
00:12:24,680 --> 00:12:28,640
運行100小時後，時間中的錯誤是只

278
00:12:28,640 --> 00:12:29,870
大約三分之一的第二個。

279
00:12:29,870 --> 00:12:34,790
但在5馬赫的速度行駛在導彈的目標，

280
00:12:34,790 --> 00:12:39,140
這導致跟踪誤差超過600米。

281
00:12:39,140 --> 00:12:42,510
在宰赫蘭的士兵，這將是一個致命的錯誤。

282
00:12:42,510 --> 00:12:48,680
>> 現在的情況是飛毛腿發射檢測預警

283
00:12:48,680 --> 00:12:52,440
衛星，他們知道，飛毛腿在他們的

284
00:12:52,440 --> 00:12:53,350
大方向。

285
00:12:53,350 --> 00:12:55,470
他們不知道有人來了。

286
00:12:55,470 --> 00:12:58,210
這是現在的愛國者的雷達組件

287
00:12:58,210 --> 00:13:01,920
系統，保衛達蘭，定位和跟踪

288
00:13:01,920 --> 00:13:03,700
來襲的敵方導彈。

289
00:13:03,700 --> 00:13:05,390
該雷達是很聰明的。

290
00:13:05,390 --> 00:13:07,570
實際上，你會跟踪的位置，飛毛腿，然後

291
00:13:07,570 --> 00:13:10,340
預測它可能會是今後一段時間

292
00:13:10,340 --> 00:13:12,040
雷達發出一個脈衝。

293
00:13:12,040 --> 00:13:13,730
這是所謂的的範圍內的柵極。

294
00:13:13,730 --> 00:13:18,820
然後，一旦決定有足夠的時間已經過去了，去愛國者

295
00:13:18,820 --> 00:13:22,600
該檢測到的備份和檢查的下一個位置

296
00:13:22,600 --> 00:13:24,190
對象，它可以追溯到。

297
00:13:24,190 --> 00:13:27,940
因此，當去到錯誤的地方，然後看到沒有

298
00:13:27,940 --> 00:13:31,000
反對，並決定，有沒有對象。

299
00:13:31,000 --> 00:13:34,370
這是一個虛假的檢測和下降的軌道。

300
00:13:34,370 --> 00:13:37,630
>> 傳入的飛毛腿從雷達屏幕上消失。

301
00:13:37,630 --> 00:13:41,300
幾秒鐘後，砰的一聲走進軍營。飛毛腿

302
00:13:41,300 --> 00:13:44,730
殺害了28和發射過程中是最後一個

303
00:13:44,730 --> 00:13:46,450
第一次海灣戰爭。

304
00:13:46,450 --> 00:13:50,570
可悲的是，更新後的軟件在宰赫蘭

305
00:13:50,570 --> 00:13:52,060
次日。

306
00:13:52,060 --> 00:13:56,210
而軟件漏洞已被固定，關閉中的一個章節

307
00:13:56,210 --> 00:13:58,370
多災多難的歷史的“愛國者”導彈。

308
00:14:01,790 --> 00:14:04,990
愛國者實際上是一個縮寫為“相控陣跟踪

309
00:14:04,990 --> 00:14:08,516
攔截的目標。“

310
00:14:08,516 --> 00:14:13,390
>> 所有權利，更悲哀的結果不太

311
00:14:13,390 --> 00:14:14,430
了解這個世界。

312
00:14:14,430 --> 00:14:18,180
外賣，從電影，真的是該解決方案

313
00:14:18,180 --> 00:14:20,790
有被重新啟動您的導彈防禦系統

314
00:14:20,790 --> 00:14:21,770
每一次在一段時間內。

315
00:14:21,770 --> 00:14:24,280
如此反复，這門課程的目的之一，當然

316
00:14:24,280 --> 00:14:26,900
一種更謙遜的規模比這些應用程序，

317
00:14:26,900 --> 00:14:30,710
真正的開放究竟如何，你去了解每個人的眼睛

318
00:14:30,710 --> 00:14:34,380
使機器做你希望他們做什麼，以及你如何去

319
00:14:34,380 --> 00:14:37,180
這樣做是正確的，而沿途做

320
00:14:37,180 --> 00:14:38,810
好吧，優雅，等等。

321
00:14:38,810 --> 00:14:41,680
所以今天，讓我們多一點點，這潛入，但

322
00:14:41,680 --> 00:14:44,210
所以，我們不要走的太快，特別是那些少

323
00:14:44,210 --> 00:14:46,590
舒適，而且還使我們能夠保留的利益

324
00:14:46,590 --> 00:14:49,390
那些更舒適，讓我們迅速開始位

325
00:14:49,390 --> 00:14:50,970
回顧一下其中的一些想法。

326
00:14:50,970 --> 00:14:53,710
再次，要求離開，無論是在個人或網上，如果你有

327
00:14:53,710 --> 00:14:56,320
的問題，所以我們可以讓每個人都在同一頁上。

328
00:14:56,320 --> 00:14:58,820
>> 因此，CS50電器，快速退後一步，

329
00:14:58,820 --> 00:15:02,360
什麼，你自己的話怎麼辦？

330
00:15:02,360 --> 00:15:06,454
這是確定的，如果你不知道那些話，可能是還沒有。

331
00:15:06,454 --> 00:15:07,830
[聽不清]

332
00:15:07,830 --> 00:15:10,950
好了，所以通用接口 - 

333
00:15:10,950 --> 00:15:11,900
我們都可以共享。

334
00:15:11,900 --> 00:15:12,470
當然可以。

335
00:15:12,470 --> 00:15:14,840
因此，我們可以，例如，告訴你去一些

336
00:15:14,840 --> 00:15:16,910
網站，下載該軟件適用於Mac OS。

337
00:15:16,910 --> 00:15:19,140
下載該軟件適用於Windows，配置

338
00:15:19,140 --> 00:15:20,100
這條路上。

339
00:15:20,100 --> 00:15:22,370
但現實情況是，我們遇到無數的技術

340
00:15:22,370 --> 00:15:23,200
支持的問題。

341
00:15:23,200 --> 00:15:26,630
這些天，許多正在做什麼的服務器端，

342
00:15:26,630 --> 00:15:28,490
在計算世界中，特別是當它涉及到

343
00:15:28,490 --> 00:15:31,460
Web開發和Web的應用程序，實際上是

344
00:15:31,460 --> 00:15:35,110
經常在Unix或Linux計算機上，而不是

345
00:15:35,110 --> 00:15:36,800
Mac或Windows電腦。

346
00:15:36,800 --> 00:15:39,240
>> 之間有利的一面，那麼，這件事情被稱為

347
00:15:39,240 --> 00:15:41,500
CS50設備是我們將所有具有相同的環境。

348
00:15:41,500 --> 00:15:43,670
因此，每個人都在同一頁上，無論什麼樣的硬件，你

349
00:15:43,670 --> 00:15:46,650
來到校園，但也將涉足準確

350
00:15:46,650 --> 00:15:48,230
同樣的環境下，你會使用朝

351
00:15:48,230 --> 00:15:51,080
學期結束，以及網絡的發展，以及在

352
00:15:51,080 --> 00:15:53,580
其未來真實世界的應用。

353
00:15:53,580 --> 00:15:56,350
因此，更具體而言，CS50電器是免費的一塊

354
00:15:56,350 --> 00:15:59,400
軟件，可以讓您運行其他操作系統，

355
00:15:59,400 --> 00:16:02,670
Linux操作系統，在這種情況下，在自己的計算機上，在一個窗口中。

356
00:16:02,670 --> 00:16:04,750
現在，你不能只是下載設備。

357
00:16:04,750 --> 00:16:08,170
你需要一個程序，播放或運行設備。

358
00:16:08,170 --> 00:16:11,220
而這一塊的軟件一般稱為

359
00:16:11,220 --> 00:16:11,520
虛擬機管理程序。

360
00:16:11,520 --> 00:16:14,050
虛擬機管理程序的形式，如VMware的產品，

361
00:16:14,050 --> 00:16:15,820
虛擬保險箱，相似之處。

362
00:16:15,820 --> 00:16:18,390
所有的公司的各種軟件，包括免費的和

363
00:16:18,390 --> 00:16:19,310
商業的一致好評。

364
00:16:19,310 --> 00:16:21,480
你會看到什麼問題說明如何設置1

365
00:16:21,480 --> 00:16:23,440
獲得免費的軟件，用以

366
00:16:23,440 --> 00:16:25,000
執行CS50電器。

367
00:16:25,000 --> 00:16:28,060
一旦你，你就必須在你的Mac或PC上的一個窗口，

368
00:16:28,060 --> 00:16:30,710
一個桌面環境，看起來很喜歡這個，

369
00:16:30,710 --> 00:16:33,100
它在開始菜單​​一樣的東西

370
00:16:33,100 --> 00:16:34,510
底部的左上角。

371
00:16:34,510 --> 00:16:38,030
它有一個Home文件夾，或主目錄，在左上角

372
00:16:38,030 --> 00:16:40,280
在那裡，一個垃圾桶，等等。

373
00:16:40,280 --> 00:16:43,450
因此，我們除了恥笑，因為我們去的必要的細節。

374
00:16:43,450 --> 00:16:46,430
>> 但現在讓我們開始潛入C.

375
00:16:46,430 --> 00:16:49,200
因此，C是這樣的編程語言，精神，

376
00:16:49,200 --> 00:16:52,390
從頭開始，但遠不如圖形，但具有諷刺意味的是，遠

377
00:16:52,390 --> 00:16:54,730
更強大的，一旦你得到它精明。

378
00:16:54,730 --> 00:16:58,970
因此，在C中，我們編寫的程序編寫源代碼，這是

379
00:16:58,970 --> 00:17:01,640
這類似英語的語法，類似的襪子

380
00:17:01,640 --> 00:17:05,609
我們做了示範，最後一次，可讓您

381
00:17:05,609 --> 00:17:07,910
表達自己相當精確，如果

382
00:17:07,910 --> 00:17:09,760
arcanely，到計算機。

383
00:17:09,760 --> 00:17:11,960
>> 那麼，什麼樣的軟件產品，你實際需要

384
00:17:11,960 --> 00:17:15,520
編寫程序的語言，如C，根據我們的

385
00:17:15,520 --> 00:17:17,492
在週一的談話嗎？

386
00:17:17,492 --> 00:17:19,650
[聽不清]

387
00:17:19,650 --> 00:17:21,079
OK，你只需要一個文本編輯器。

388
00:17:21,079 --> 00:17:22,890
你不需要任何特殊的軟件

389
00:17:22,890 --> 00:17:24,460
本身編寫程序。

390
00:17:24,460 --> 00:17:27,220
你只需要一個文本編輯器（如記事本），在Windows，

391
00:17:27,220 --> 00:17:30,450
文字編輯在Mac上，或稱為gedit的東西，在世界上的

392
00:17:30,450 --> 00:17:32,020
Linux中，我們將在這裡使用。

393
00:17:32,020 --> 00:17:33,750
就是這樣，寫的程序。

394
00:17:33,750 --> 00:17:35,480
>> 但寫作只有一半的方程。

395
00:17:35,480 --> 00:17:36,630
然後，您需要運行它們。

396
00:17:36,630 --> 00:17:38,320
但是，為了運行程序 - 

397
00:17:38,320 --> 00:17:39,600
你不能運行的源代碼。

398
00:17:39,600 --> 00:17:41,500
你，而不是必須做什麼它？

399
00:17:41,500 --> 00:17:41,900
是啊。

400
00:17:41,900 --> 00:17:43,200
DAVID J.馬蘭：您需要

401
00:17:43,200 --> 00:17:44,130
編譯它。

402
00:17:44,130 --> 00:17:49,010
而且，別人編譯的源代碼是指 - 

403
00:17:49,010 --> 00:17:50,260
[聽不清]

404
00:17:52,300 --> 00:17:52,700
DAVID J.馬蘭：沒錯。

405
00:17:52,700 --> 00:17:54,430
把它轉換成零和一。

406
00:17:54,430 --> 00:17:57,150
因為我們所有的人，這些天來，有電腦，有CPU的，

407
00:17:57,150 --> 00:18:00,350
幾乎全部是由一家名為英特爾，

408
00:18:00,350 --> 00:18:03,320
英特爾內部，有你的這個大腦內

409
00:18:03,320 --> 00:18:04,990
計算機，稱為CPU。

410
00:18:04,990 --> 00:18:07,570
，大腦做的事情之一是，它知道

411
00:18:07,570 --> 00:18:10,390
如何理解零和一的模式。

412
00:18:10,390 --> 00:18:13,240
它知道什麼圖案位代表另外，什麼

413
00:18:13,240 --> 00:18:15,500
圖案代表減法，什麼圖案

414
00:18:15,500 --> 00:18:18,890
位代表打印，並創建一個可聽見的聲音。

415
00:18:18,890 --> 00:18:22,450
>> 因此，在短期中，CPU，加上與操作系統，

416
00:18:22,450 --> 00:18:25,230
這是一塊的CPU上運行的軟件，

417
00:18:25,230 --> 00:18:26,050
可以這麼說。

418
00:18:26,050 --> 00:18:29,850
總之，這兩條都知道如何來運行程序，

419
00:18:29,850 --> 00:18:31,070
我們人類寫。

420
00:18:31,070 --> 00:18:34,040
>> 所以，如果我去到CS50電器在這裡，我需要打開

421
00:18:34,040 --> 00:18:35,660
一個文本編輯器，我可以訪問

422
00:18:35,660 --> 00:18:36,560
一對夫婦的方式。

423
00:18:36,560 --> 00:18:39,060
我可以進入菜單，編程，

424
00:18:39,060 --> 00:18:40,230
然後我就可以選擇 - 

425
00:18:40,230 --> 00:18:40,810
不，不是的菜單。

426
00:18:40,810 --> 00:18:43,860
我可以去配件/ gedit的打開

427
00:18:43,860 --> 00:18:45,090
我的小文本編輯器。

428
00:18:45,090 --> 00:18:48,030
或者更簡單地說，我可以點擊這個小圖標在底部

429
00:18:48,030 --> 00:18:48,970
左上角。

430
00:18:48,970 --> 00:18:50,430
現在我這裡的環境。

431
00:18:50,430 --> 00:18:52,590
這是非常讓人聯想到的，只有一個簡單的文本編輯器

432
00:18:52,590 --> 00:18:53,820
一個或兩個的差異。

433
00:18:53,820 --> 00:18:56,420
在頂部，光標閃爍，這是

434
00:18:56,420 --> 00:18:57,900
我可以開始寫我的代碼。

435
00:18:57,900 --> 00:19:00,415
在底部的這個東西叫做終端窗口。

436
00:19:00,415 --> 00:19:03,400
我可以做什麼樣的事情在這

437
00:19:03,400 --> 00:19:04,960
所謂的終端窗口？

438
00:19:04,960 --> 00:19:06,680
[聽不清]

439
00:19:06,680 --> 00:19:07,890
>> 好吧，我會運行命令。

440
00:19:07,890 --> 00:19:10,300
週一上運行的一些命令，我​​們是一個小

441
00:19:10,300 --> 00:19:15,070
神秘第一，但“列表中的ls，cd命令更改目錄，

442
00:19:15,070 --> 00:19:16,540
RM，刪除。

443
00:19:16,540 --> 00:19:19,680
因此，這是一個老派的方式瀏覽您的

444
00:19:19,680 --> 00:19:22,310
電腦，只用你的鍵盤和文本命令，

445
00:19:22,310 --> 00:19:24,130
不大，一般，使用鼠標。

446
00:19:24,130 --> 00:19:25,960
但我們所看到的，用不了多久，這實際上是給了我們一個

447
00:19:25,960 --> 00:19:28,520
多一點力量，其中一個更精確一點

448
00:19:28,520 --> 00:19:29,600
表達自己。

449
00:19:29,600 --> 00:19:31,330
然後在左邊，我們只是去看看，

450
00:19:31,330 --> 00:19:34,360
當我們開始寫作軟件，一個小小的總結

451
00:19:34,360 --> 00:19:36,350
程序，我們已經寫在左上角。

452
00:19:36,350 --> 00:19:38,360
但我們會再次看到，在不久的。

453
00:19:38,360 --> 00:19:40,050
>> 因此，讓我們在這裡做一些比較簡單的。

454
00:19:40,050 --> 00:19:43,440
首先，讓我繼續前進，到文件，保存，我只是

455
00:19:43,440 --> 00:19:45,970
點擊jharvard，在左，

456
00:19:45,970 --> 00:19:48,930
再次，jharvard，我的主文件夾的名稱，我

457
00:19:48,930 --> 00:19:52,110
所有的個人檔案，我現在是約翰·哈佛，

458
00:19:52,110 --> 00:19:54,230
很快就會約翰·哈佛在這樣的環境中。

459
00:19:54,230 --> 00:19:57,360
他有主目錄，我的文檔等等，

460
00:19:57,360 --> 00:19:58,900
我想保存，現在，這個文件中。

461
00:19:58,900 --> 00:20:01,520
所以，我會打電話給它的hello.c。然後，我會去

462
00:20:01,520 --> 00:20:05,770
進取，單擊“保存”，現在我這裡是一個標籤

463
00:20:05,770 --> 00:20:09,440
名為hello.c，這麼多喜歡另一種類型的編輯器。

464
00:20:09,440 --> 00:20:11,760
>> 所以，現在讓我繼續前進，開始編寫程序。

465
00:20:11,760 --> 00:20:14,440
詮釋的主要（無效）。

466
00:20:14,440 --> 00:20:18,150
然後，我只是做了最後一次，輸出，打印的格式，

467
00:20:18,150 --> 00:20:22,120
（“你好，世界！”

468
00:20:22,120 --> 00:20:24,500
。）;

469
00:20:24,500 --> 00:20:25,630
幾乎可以完成。

470
00:20:25,630 --> 00:20:27,130
但是，我錯過了幾個細節。

471
00:20:27,130 --> 00:20:30,210
從這項計劃中，我真正需要的是缺少什麼

472
00:20:30,210 --> 00:20:31,890
它實際上編譯？

473
00:20:31,890 --> 00:20:32,130
是啊。

474
00:20:32,130 --> 00:20:33,980
[聽不見的？

475
00:20:33,980 --> 00:20:35,770
>> DAVID J.馬蘭：是啊，所以我需要包括標準

476
00:20:35,770 --> 00:20:36,700
I / O庫。

477
00:20:36,700 --> 00:20:39,470
因此，這需要去以上的主，所以我只是要

478
00:20:39,470 --> 00:20:40,790
它有一些空間。

479
00:20:40,790 --> 00:20:44,420
我要去，做＃包括<stdio.h>。

480
00:20:44,420 --> 00:20:46,570
注意尖括號。

481
00:20:46,570 --> 00:20:49,410
順便說一句，gedit是一個小的用戶友好，如果

482
00:20:49,410 --> 00:20:52,420
有時有點混亂，因為它試圖幫助

483
00:20:52,420 --> 00:20:54,770
眼睛注意哪些行了什麼。

484
00:20:54,770 --> 00:20:57,760
因此，事實上，我的光標旁邊這個角度

485
00:20:57,760 --> 00:21:00,600
支架，請注意它是如何突出等角度

486
00:21:00,600 --> 00:21:01,920
支架加上這一個。

487
00:21:01,920 --> 00:21:03,770
而這只是為了引起我的注意這樣的事實，我

488
00:21:03,770 --> 00:21:04,460
具有對稱性。

489
00:21:04,460 --> 00:21:07,010
對稱的編程通常是一件好事。

490
00:21:07,010 --> 00:21:10,270
同樣，如果我將我的光標到最後，如何通知

491
00:21:10,270 --> 00:21:13,630
花括號，是的，我有一個開放的

492
00:21:13,630 --> 00:21:15,160
和封閉的，可以這麼說。

493
00:21:15,160 --> 00:21:16,640
>> 好吧，我可以做一件事。

494
00:21:16,640 --> 00:21:20,090
這不是絕對必要的，但良好做法，說

495
00:21:20,090 --> 00:21:21,250
返回0。

496
00:21:21,250 --> 00:21:24,140
返回0為我們做什麼呢？

497
00:21:24,140 --> 00:21:25,584
或者意味著什麼？

498
00:21:25,584 --> 00:21:27,480
[聽不清]

499
00:21:27,480 --> 00:21:28,300
DAVID J.馬蘭，但沒有什麼是錯的。

500
00:21:28,300 --> 00:21:30,280
坦白地說，這是很難的大部分時間去錯在

501
00:21:30,280 --> 00:21:31,250
編程這短暫的。

502
00:21:31,250 --> 00:21:33,930
所以，我只是超級明確的，一切都很好。

503
00:21:33,930 --> 00:21:36,740
我的人，當我運行這個程序時，可能永遠都不會

504
00:21:36,740 --> 00:21:38,150
看到0。

505
00:21:38,150 --> 00:21:41,070
一般來說，這些數字被返回從主

506
00:21:41,070 --> 00:21:43,540
只有撫養他們的頭的人

507
00:21:43,540 --> 00:21:44,360
出現錯誤。

508
00:21:44,360 --> 00:21:46,640
你會得到一個小的彈出提示說系統錯誤，一，

509
00:21:46,640 --> 00:21:48,760
兩個，三個，或任何的數量是

510
00:21:48,760 --> 00:21:50,100
實際上返回。

511
00:21:50,100 --> 00:21:52,870
所以別的問題？

512
00:21:52,870 --> 00:21:55,300
[聽不清]

513
00:21:55,300 --> 00:21:58,100
>> DAVID J.馬蘭：這是沒有這麼多的功能錯誤

514
00:21:58,100 --> 00:21:59,240
但一個審美的。

515
00:21:59,240 --> 00:22:02,340
我或許應該有一個換行符

516
00:22:02,340 --> 00:22:05,240
這個字符串結束，所以，我們實際上是將光標移動到

517
00:22:05,240 --> 00:22:08,340
下一行，並計劃只是看起來有點漂亮。

518
00:22:08,340 --> 00:22:10,340
>> 所以，現在讓我走我的終端窗口

519
00:22:10,340 --> 00:22:11,490
和放大。

520
00:22:11,490 --> 00:22:13,390
而這種事情在這裡，這就是所謂的提示。

521
00:22:13,390 --> 00:22:16,760
它只是提醒我，我是誰，jharvard設備，

522
00:22:16,760 --> 00:22:18,850
器具是我在計算機的名稱。

523
00:22:18,850 --> 00:22:22,380
括號中的波浪線，波浪線符號，

524
00:22:22,380 --> 00:22:24,160
代表著什麼？

525
00:22:24,160 --> 00:22:25,590
觀眾：主目錄。

526
00:22:25,590 --> 00:22:26,350
DAVID J.馬蘭：主目錄。

527
00:22:26,350 --> 00:22:29,350
所以，這只是說，你是在一個速記符號

528
00:22:29,350 --> 00:22:32,780
您的個人文件夾中的所有文件的默認位置。

529
00:22:32,780 --> 00:22:36,080
所以，現在，在這裡，我可以輸入ls列表。

530
00:22:36,080 --> 00:22:40,020
我在這裡看到的那一刻唯一的hello.c。

531
00:22:40,020 --> 00:22:41,770
這是很好的，因為我剛才寫的。

532
00:22:41,770 --> 00:22:44,380
>> 因此，讓我繼續前進，不要讓你好。

533
00:22:44,380 --> 00:22:46,830
請注意，我不打字使hello.c的。

534
00:22:46,830 --> 00:22:50,300
相反，我只需要輸入該文件的基本名稱，你好。

535
00:22:50,300 --> 00:22:53,690
做，因為我們看到在週一，也只是推斷，我想

536
00:22:53,690 --> 00:22:54,920
c文件。

537
00:22:54,920 --> 00:22:56,820
所以現在我已經輸入招呼。

538
00:22:56,820 --> 00:22:59,280
現在，我看到這個相當長的命令，並會繼續

539
00:22:59,280 --> 00:23:00,480
看到這一遍又一遍。

540
00:23:00,480 --> 00:23:03,620
但要清楚，鐺，這個詞剛剛出現，

541
00:23:03,620 --> 00:23:05,340
這是實際的編譯器。

542
00:23:05,340 --> 00:23:08,200
Make是一個生成實用程序。

543
00:23:08,200 --> 00:23:11,900
這只是一個更加用戶友好的程序，節省了我，

544
00:23:11,900 --> 00:23:15,310
從長遠來看，鍵入了令人難以置信的乏味的長

545
00:23:15,310 --> 00:23:17,020
這樣的一個命令。

546
00:23:17,020 --> 00:23:18,950
所以，你可以手動運行鐺。

547
00:23:18,950 --> 00:23:20,530
你可以輸入，手動。

548
00:23:20,530 --> 00:23:21,580
只是變得非常乏味的。

549
00:23:21,580 --> 00:23:24,720
，所以一定要僅僅是一個程序，可以簡化我們的生活，

550
00:23:24,720 --> 00:23:27,120
運行更複雜的命令給我們。

551
00:23:27,120 --> 00:23:29,410
>> 好吧，所以現在我應該有什麼文件

552
00:23:29,410 --> 00:23:31,540
在當前目錄？

553
00:23:31,540 --> 00:23:36,310
不只是hello.c的，但也打招呼。

554
00:23:36,310 --> 00:23:39,710
所以，如果我要運行你好，還記得我說點斜線，

555
00:23:39,710 --> 00:23:42,220
點手段去到當前文件夾，無論你

556
00:23:42,220 --> 00:23:46,060
，然後運行該程序名為hello的，而事實上，現在，

557
00:23:46,060 --> 00:23:48,080
我的Hello World。

558
00:23:48,080 --> 00:23:51,640
所有的權利，任何對工作流的問題或語法

559
00:23:51,640 --> 00:23:52,890
我們只是做了什麼？

560
00:23:55,380 --> 00:23:57,040
>> 好吧，讓我們再次上升了一個檔次的東西。

561
00:23:57,040 --> 00:24:00,430
因此，這給人留下深刻印象，只寫一個程序，只

562
00:24:00,430 --> 00:24:01,790
曾經說：“你好，世界。

563
00:24:01,790 --> 00:24:03,920
所以，我們改變了它，在星期一，說，你好，大衛。

564
00:24:03,920 --> 00:24:06,560
這是一個有點多個人，但只是作為硬編碼為

565
00:24:06,560 --> 00:24:07,410
第一個版本。

566
00:24:07,410 --> 00:24:08,780
所以不是所有的引人注目。

567
00:24:08,780 --> 00:24:13,120
但是存在，在C，功能當然除了

568
00:24:13,120 --> 00:24:15,700
打印功能，可以讓您的用戶輸入。

569
00:24:15,700 --> 00:24:17,990
的方式，我們這樣做，有一天，情況如下。

570
00:24:17,990 --> 00:24:21,440
其實我之前打印出來的東西，我第一次

571
00:24:21,440 --> 00:24:22,410
從用戶的東西。

572
00:24:22,410 --> 00:24:23,370
因此，讓我再這樣做。

573
00:24:23,370 --> 00:24:26,580
>> 字符串s，其中s是只是一個任意的名稱，在這裡，對於一個

574
00:24:26,580 --> 00:24:30,600
字符串，等於GetString的。

575
00:24:30,600 --> 00:24:32,070
那麼，什麼是GetString的？

576
00:24:32,070 --> 00:24:34,630
顯然，它獲取一個字符串，根據其名稱。

577
00:24:34,630 --> 00:24:37,560
但究竟是什麼，技術上呢？

578
00:24:37,560 --> 00:24:38,440
這是一個函數。

579
00:24:38,440 --> 00:24:41,790
所以這是一個使用C本身功能不來。

580
00:24:41,790 --> 00:24:43,660
CS50人員寫了這個。

581
00:24:43,660 --> 00:24:46,940
因此，對於使用這個，你不能只包括stdio.h中，

582
00:24:46,940 --> 00:24:49,630
您還需要包括什麼？

583
00:24:49,630 --> 00:24:50,060
是啊。

584
00:24:50,060 --> 00:24:54,210
因此，cs50.h，這僅僅是一個文件，我們幾年前寫的。

585
00:24:54,210 --> 00:24:57,130
我們把它安裝在你一起家電

586
00:24:57,130 --> 00:24:58,490
所有的標準文件。

587
00:24:58,490 --> 00:25:00,500
因此，在這些最初的幾個星期之類的，我們將使用

588
00:25:00,500 --> 00:25:02,820
這只是為了簡化的過程中，做的非常基本的

589
00:25:02,820 --> 00:25:04,600
之類的東西獲取用戶輸入。

590
00:25:04,600 --> 00:25:07,370
因為在幾個星期內我們會看到，在獲取用戶輸入

591
00:25:07,370 --> 00:25:10,180
像C語言實際上是出奇的複雜，

592
00:25:10,180 --> 00:25:14,360
特別是因為你不事先知道的，通常情況下，如何

593
00:25:14,360 --> 00:25:17,030
太多的東西，用戶要輸入英寸

594
00:25:17,030 --> 00:25:20,340
當你不知道多少數據，你不

595
00:25:20,340 --> 00:25:22,380
我知道如何分配多少內存。

596
00:25:22,380 --> 00:25:25,480
如果你真的有對抗性的用戶是誰試圖

597
00:25:25,480 --> 00:25:28,180
入侵到你的系統，你的電腦崩潰，好了，

598
00:25:28,180 --> 00:25:31,600
一般的攻擊方法是，就像我一樣

599
00:25:31,600 --> 00:25:34,950
週一，鍵入一個長序列的隨機字符，

600
00:25:34,950 --> 00:25:37,020
按下回車鍵，看什麼打破。

601
00:25:37,020 --> 00:25:40,800
因為一般來說，如果程序中斷，這暗示

602
00:25:40,800 --> 00:25:42,650
，潛在的安全漏洞。

603
00:25:42,650 --> 00:25:45,250
這當然暗示了你，程序員，做了

604
00:25:45,250 --> 00:25:49,050
錯誤，但更危險的是，你可能已經做了

605
00:25:49,050 --> 00:25:52,430
與安全相關的錯誤，而且通常我們會看到，

606
00:25:52,430 --> 00:25:54,840
機被攻破這一天，

607
00:25:54,840 --> 00:25:56,620
在世界上的網頁和方案，

608
00:25:56,620 --> 00:25:58,070
命令行，像這樣。

609
00:25:58,070 --> 00:25:58,350
>> 好的。

610
00:25:58,350 --> 00:26:00,460
因此，字符串s = GetString的。

611
00:26:00,460 --> 00:26:03,380
所以更具體，第6行做什麼嗎？

612
00:26:03,380 --> 00:26:05,640
因此，在右邊的功能得到字符串，

613
00:26:05,640 --> 00:26:06,890
需要多少個參數？

614
00:26:09,458 --> 00:26:09,900
好吧。

615
00:26:09,900 --> 00:26:10,400
所以，沒有。

616
00:26:10,400 --> 00:26:11,360
一點點神智檢查。

617
00:26:11,360 --> 00:26:15,380
再次，是一個參數，只是輸入到函數改變

618
00:26:15,380 --> 00:26:17,250
在某種程度上，它的默認行為。

619
00:26:17,250 --> 00:26:19,540
但是，在這種情況下，我並不想改變

620
00:26:19,540 --> 00:26:20,650
GetString的行為。

621
00:26:20,650 --> 00:26:22,430
我只想得到一個字符串。

622
00:26:22,430 --> 00:26:25,190
所以，我什麼也沒有括號中的，然後我把一個

623
00:26:25,190 --> 00:26:27,550
分號demarking的代碼行的末尾。

624
00:26:27,550 --> 00:26:29,840
現在，等號，不等於，本身。

625
00:26:29,840 --> 00:26:32,690
這意味著分配，這意味著把任何得到

626
00:26:32,690 --> 00:26:36,060
無論是在左邊上的右內側輸出。

627
00:26:36,060 --> 00:26:39,400
>> 因此，在左邊，我們說，我們已經宣布一個

628
00:26:39,400 --> 00:26:41,630
字符串調用。

629
00:26:41,630 --> 00:26:44,240
更特別的是，我們已經分配內存裡面的

630
00:26:44,240 --> 00:26:46,340
我們可以把位序列

631
00:26:46,340 --> 00:26:46,850
字符。

632
00:26:46,850 --> 00:26:49,400
但今天，我們已撥出

633
00:26:49,400 --> 00:26:51,450
或宣布一個字符串。

634
00:26:51,450 --> 00:26:51,790
好的。

635
00:26:51,790 --> 00:26:54,760
所以，現在一旦我這樣做，我想插入的價值

636
00:26:54,760 --> 00:26:56,535
，而不是大衛的價值。

637
00:26:56,535 --> 00:27:00,200
因此，這是錯誤的，為什麼呢？

638
00:27:03,060 --> 00:27:04,870
因此，這只是字面上的硬編碼的小號。

639
00:27:04,870 --> 00:27:06,870
這是說“你好，”這是不是我想要的。

640
00:27:06,870 --> 00:27:07,790
所以，我可以做到這一點。

641
00:27:07,790 --> 00:27:10,330
百分號是一個佔位符，但現在我需要

642
00:27:10,330 --> 00:27:12,520
打印第二個參數傳入。

643
00:27:12,520 --> 00:27:15,160
回想一下，函數的參數分離

644
00:27:15,160 --> 00:27:20,300
逗號，所以這裡的一個逗號後，我把這個字母s。

645
00:27:20,300 --> 00:27:23,740
在這方面，S是可變的，和printf，

646
00:27:23,740 --> 00:27:25,550
在收到這兩個輸入 - 

647
00:27:25,550 --> 00:27:29,440
上的字符串的左側，而在右邊的變量名稱s  - 

648
00:27:29,440 --> 00:27:32,750
它會堵塞後者成為前者對我們來說，

649
00:27:32,750 --> 00:27:34,600
只是打印出一個漂亮的美麗的字符串，其中包含

650
00:27:34,600 --> 00:27:36,770
不管它是什麼，我們鍵入。

651
00:27:36,770 --> 00:27:37,560
>> 所以，讓我們來試試這個。

652
00:27:37,560 --> 00:27:38,860
要繼續前進，放大了出來，回到

653
00:27:38,860 --> 00:27:40,250
我的終端窗口。

654
00:27:40,250 --> 00:27:41,840
在底部放大了。

655
00:27:41,840 --> 00:27:44,070
重新輸入使招呼。

656
00:27:44,070 --> 00:27:45,870
鐺似乎已經重新運行。

657
00:27:45,870 --> 00:27:49,280
我要鍵入。/你好，回車。

658
00:27:49,280 --> 00:27:52,145
似乎沒有發生，但在此提示

659
00:27:52,145 --> 00:27:55,700
我可以鍵入一些東西，像內特，輸入，而現在我們有

660
00:27:55,700 --> 00:27:56,380
你好，內特。

661
00:27:56,380 --> 00:27:59,600
，我還可以再與Rob，等等。

662
00:27:59,600 --> 00:28:03,410
所以希望現在這個程序的行為，我打算。

663
00:28:03,410 --> 00:28:05,720
>> 現在，不是所有的用戶友好。

664
00:28:05,720 --> 00:28:07,930
我不知道什麼是對我的期望。

665
00:28:07,930 --> 00:28:09,620
因此，我們可以肯定清理了一點點。

666
00:28:09,620 --> 00:28:13,270
讓我回到了這裡，而不是只是潛水，

667
00:28:13,270 --> 00:28:16,480
要求用戶為一個字符串，讓我明確地告訴

668
00:28:16,480 --> 00:28:17,750
用戶，我期待的是什麼。

669
00:28:17,750 --> 00:28:21,610
所以printf（“請輸入一個字符串：”

670
00:28:21,610 --> 00:28:24,080
）;

671
00:28:24,080 --> 00:28:25,510
所以這裡不變量。

672
00:28:25,510 --> 00:28:26,750
沒有百分號。

673
00:28:26,750 --> 00:28:28,550
只是簡單的英語短語。

674
00:28:28,550 --> 00:28:34,030
現在讓我去的底部，然後重新運行我的程序。

675
00:28:34,030 --> 00:28:35,380
但似乎什麼都沒有發生了變化。

676
00:28:35,380 --> 00:28:37,350
為什麼呢？

677
00:28:37,350 --> 00:28:38,380
我必須重新編譯它。

678
00:28:38,380 --> 00:28:39,570
所以容易犯的錯誤。

679
00:28:39,570 --> 00:28:41,700
但是，你不僅要保存該文件，但

680
00:28:41,700 --> 00:28:43,260
重新編譯程序。

681
00:28:43,260 --> 00:28:46,640
所以，如果我重新運行make您好，現在鐺運行。

682
00:28:46,640 --> 00:28:51,800
現在，我可以運行。/打招呼。現在我看到“輸入一個字符串：”。

683
00:28:51,800 --> 00:28:52,050
好吧。

684
00:28:52,050 --> 00:28:53,440
現在，這是一個有點更加人性化。

685
00:28:53,440 --> 00:28:55,850
內特，輸入，你好，內特。

686
00:28:55,850 --> 00:28:57,310
>> 好吧，讓我們再試一次，並開始思考

687
00:28:57,310 --> 00:28:58,080
關於角落的情況下。

688
00:28:58,080 --> 00:29:00,520
所以就像在刮，我們鼓勵你或正在

689
00:29:00,520 --> 00:29:03,180
鼓勵在規範中那種認為什麼可以去

690
00:29:03,180 --> 00:29:06,610
錯了，如果你沒有預料到用戶可能做的一切。

691
00:29:06,610 --> 00:29:08,050
因此，錯誤，可能會隨之而來。

692
00:29:08,050 --> 00:29:09,710
因此，輸入一個字符串 - 

693
00:29:09,710 --> 00:29:11,130
這裡一個角落的情況是什麼？

694
00:29:11,130 --> 00:29:13,320
有一個場景，我的程序員，可能不會有什麼

695
00:29:13,320 --> 00:29:16,070
預期？

696
00:29:16,070 --> 00:29:17,600
是啊。

697
00:29:17,600 --> 00:29:17,920
好吧。

698
00:29:17,920 --> 00:29:22,060
那麼，如果我輸入一個像這樣的數字呢？

699
00:29:22,060 --> 00:29:22,500
好的。

700
00:29:22,500 --> 00:29:24,490
因此，它仍然有效。

701
00:29:24,490 --> 00:29:25,880
Gramatically是沒有意義的。

702
00:29:25,880 --> 00:29:27,180
但至少在程序的工作原理。

703
00:29:27,180 --> 00:29:28,650
>> 什麼是另一個角落的情況嗎？

704
00:29:28,650 --> 00:29:29,610
我沒想到的東西。

705
00:29:29,610 --> 00:29:31,590
是嗎？

706
00:29:31,590 --> 00:29:31,940
好吧。

707
00:29:31,940 --> 00:29:34,950
所以，我們可以做一些事情是一個非常，非常大的數字。

708
00:29:34,950 --> 00:29:37,270
因此，讓我們在這裡做。

709
00:29:37,270 --> 00:29:40,880
讓我們我縮小為第二，我要強調。

710
00:29:40,880 --> 00:29:42,250
無法複製並粘貼到這裡。

711
00:29:42,250 --> 00:29:42,470
好的。

712
00:29:42,470 --> 00:29:44,440
所以我不能複製和粘貼在這個終端窗口，因此，我們將

713
00:29:44,440 --> 00:29:46,950
它只是模擬。

714
00:29:46,950 --> 00:29:51,340
讓我放大了，要包裝。

715
00:29:51,340 --> 00:29:52,700
我不打算這樣做太長時間，因為它不會

716
00:29:52,700 --> 00:29:54,440
實際上打破了這一計劃。

717
00:29:54,440 --> 00:29:55,260
但它可能。

718
00:29:55,260 --> 00:29:55,830
輸入。

719
00:29:55,830 --> 00:29:56,580
但事實並非如此。

720
00:29:56,580 --> 00:29:57,050
好的。

721
00:29:57,050 --> 00:29:58,440
但它是一個真正的角落的情況。

722
00:29:58,440 --> 00:30:01,610
唯一的正確行為的原因，這樣一來

723
00:30:01,610 --> 00:30:05,820
說話，是因為CS50功能的GetString實際上是

724
00:30:05,820 --> 00:30:08,040
引擎蓋下的設計，我們將在幾個星期內看到，

725
00:30:08,040 --> 00:30:11,570
自動分配越來越多的RAM，越來越多的

726
00:30:11,570 --> 00:30:14,330
從操作系統的內存，當它發現，哇，

727
00:30:14,330 --> 00:30:16,670
你真的輸入在相當長的東西。

728
00:30:16,670 --> 00:30:18,500
現在，這是一個善意的謊言一點點。

729
00:30:18,500 --> 00:30:22,020
如果我們確實暫停相當長的一段時間，我輸入了

730
00:30:22,020 --> 00:30:24,640
在鍵盤上像5十億個字符

731
00:30:24,640 --> 00:30:28,060
在這裡，真的打複製 - 粘貼了不少，我們很可能

732
00:30:28,060 --> 00:30:29,730
可能會導致程序崩潰。

733
00:30:29,730 --> 00:30:32,130
只是有點難以模擬，用有限

734
00:30:32,130 --> 00:30:33,740
的時間量。

735
00:30:33,740 --> 00:30:37,320
>> 另一個角落的情況下，我們可以嘗試什麼？

736
00:30:37,320 --> 00:30:38,730
是嗎？

737
00:30:38,730 --> 00:30:39,020
是啊。

738
00:30:39,020 --> 00:30:40,360
那麼，為什麼我們不回答什麼？

739
00:30:40,360 --> 00:30:43,130
因此，我們必須採取一些行動，因為否則

740
00:30:43,130 --> 00:30:45,060
該方案的，要整天坐在那裡閃爍。

741
00:30:45,060 --> 00:30:46,860
但是，如果我只需要敲擊回車 - 

742
00:30:46,860 --> 00:30:48,780
好了，現在，看起來還是錯誤的。

743
00:30:48,780 --> 00:30:51,670
沒出事，但也許現在有一個機會，

744
00:30:51,670 --> 00:30:54,190
開始實施更嚴格的程序

745
00:30:54,190 --> 00:30:55,290
實際檢查。

746
00:30:55,290 --> 00:30:57,640
而且，如果該字符串，這句話，我的字

747
00:30:57,640 --> 00:31:00,890
輸入的長度為0，好，也許我應該喊的

748
00:31:00,890 --> 00:31:03,770
用戶，或者告訴他或她再次輸入一個字符串，從而使

749
00:31:03,770 --> 00:31:06,560
我們得到正確的行為是什麼樣子，而不是

750
00:31:06,560 --> 00:31:08,570
只是我的一部分的完整的監督。

751
00:31:08,570 --> 00:31:11,130
>> 問題在後面呢？

752
00:31:11,130 --> 00:31:11,970
十進制數。

753
00:31:11,970 --> 00:31:13,120
因此，我們可以嘗試了。

754
00:31:13,120 --> 00:31:16,840
1.10000005。

755
00:31:16,840 --> 00:31:19,470
好像，只是工作其實沒關係。

756
00:31:19,470 --> 00:31:21,160
這實際上是預期。

757
00:31:21,160 --> 00:31:24,550
儘管我們可能已經輸入了數字，則或

758
00:31:24,550 --> 00:31:28,200
數字越大所說，意識到，當我們輸入用戶

759
00:31:28,200 --> 00:31:31,070
輸入和我們使用的是GetString函數，不

760
00:31:31,070 --> 00:31:34,380
無論什麼我打字看起來像數字。

761
00:31:34,380 --> 00:31:36,720
回想一下，根據ASCII，一切都在您的

762
00:31:36,720 --> 00:31:39,920
鍵盤可以被映射到一個數值，

763
00:31:39,920 --> 00:31:41,480
字符，一個字符。

764
00:31:41,480 --> 00:31:44,490
因此，在這種情況下，即使我可能會輸入一個數字，

765
00:31:44,490 --> 00:31:48,190
計算機將想起來了，可以這麼說，作為一個字符串 - 

766
00:31:48,190 --> 00:31:49,870
的東西，看起來像一個數字，但

767
00:31:49,870 --> 00:31:51,090
實際上不是一個數字。

768
00:31:51,090 --> 00:31:53,450
但是，這實際上是一個完美的SEGUE，因為現在我們可以

769
00:31:53,450 --> 00:31:55,450
其實過渡到編寫程序，

770
00:31:55,450 --> 00:31:56,730
使用其他數據類型。

771
00:31:56,730 --> 00:32:01,840
>> 因此，除了使用字符，或者更確切地說，除了使用字符串，

772
00:32:01,840 --> 00:32:04,510
認識到，我們在C具有其他數據類型，以及在

773
00:32:04,510 --> 00:32:05,230
其他語言。

774
00:32:05,230 --> 00:32:08,480
一個char，顧名思義，僅僅是一個單個字符。

775
00:32:08,480 --> 00:32:12,150
一個浮點數浮點值，而這只是看中

776
00:32:12,150 --> 00:32:14,470
說實數的方式 - 有小數點的東西，

777
00:32:14,470 --> 00:32:17,410
在它與點的左和/或右的一些數字。

778
00:32:17,410 --> 00:32:21,370
int是一個整數，它只是一個數字123。

779
00:32:21,370 --> 00:32:24,170
而現在更有趣的事情，如雙。

780
00:32:24,170 --> 00:32:28,540
我們說什麼了雙是最後一次嗎？

781
00:32:28,540 --> 00:32:30,050
它是64，正確的。

782
00:32:30,050 --> 00:32:33,560
而通常一個浮點數是32位 - 

783
00:32:33,560 --> 00:32:37,340
所以它的這個長在內存中，它使用32個零和的，

784
00:32:37,340 --> 00:32:40,530
代表值 - 雙是名副其實的兩倍，

785
00:32:40,530 --> 00:32:43,810
意味著你可以代表更大的數字，

786
00:32:43,810 --> 00:32:45,810
你能代表更精確的數字。

787
00:32:45,810 --> 00:32:48,690
所以，你可以有更多的數字小數點後的，但

788
00:32:48,690 --> 00:32:51,520
在視頻中說的傢伙，即使是簡單的東西

789
00:32:51,520 --> 00:32:55,360
概念上有1/3不能代表正是由

790
00:32:55,360 --> 00:32:58,330
電腦，因為最終你用完位，和

791
00:32:58,330 --> 00:33:02,510
因此，你只能做0.33333333所以很多時候，在

792
00:33:02,510 --> 00:33:05,050
這一點你只需要說我的代表

793
00:33:05,050 --> 00:33:08,120
空間，我要的只是收工，並代表它

794
00:33:08,120 --> 00:33:10,200
有些不準確。

795
00:33:10,200 --> 00:33:11,110
很長很長 - 

796
00:33:11,110 --> 00:33:13,880
愚蠢的名字，但它是因為有一個數據類型被稱為

797
00:33:13,880 --> 00:33:19,350
而巧合的是32位，就像一個經常在C

798
00:33:19,350 --> 00:33:21,670
int是32位，但很長很長的

799
00:33:21,670 --> 00:33:23,560
一般為64位。

800
00:33:23,560 --> 00:33:25,740
因此，它只是意味著你可以代表大

801
00:33:25,740 --> 00:33:26,990
超過這個數字。

802
00:33:26,990 --> 00:33:27,410
>> 好的。

803
00:33:27,410 --> 00:33:29,390
所以，如果我們真的要開始代表的東西，我們

804
00:33:29,390 --> 00:33:31,030
可能需要更複雜的類型，並

805
00:33:31,030 --> 00:33:32,340
這就是為什麼我們有字符串。

806
00:33:32,340 --> 00:33:36,450
因此，在的CS50庫，文件名為cs50.h，我們

807
00:33:36,450 --> 00:33:41,110
實際上宣布的數據類型，可以這麼說，叫串，

808
00:33:41,110 --> 00:33:42,710
但字符串實際上並不存在。

809
00:33:42,710 --> 00:33:44,780
再次，這是這些層我們要剝離

810
00:33:44,780 --> 00:33:47,490
早在一兩個星期，把它扔掉，和實際

811
00:33:47,490 --> 00:33:49,640
看看下面的罩實際上是一個字符串，

812
00:33:49,640 --> 00:33:50,840
它是如何派代表出席了會議。

813
00:33:50,840 --> 00:33:53,520
我們也去看看布爾值。

814
00:33:53,520 --> 00:33:56,040
>> 那麼什麼是一個布爾值的背景下，從頭開始嗎？

815
00:33:59,154 --> 00:34:00,300
這是真還是假。

816
00:34:00,300 --> 00:34:03,900
因此，它只是一個值是真還是假，開啟或關閉，或

817
00:34:03,900 --> 00:34:06,140
0，但是你要查看的世界。

818
00:34:06,140 --> 00:34:09,739
因此，在C，這要感謝的CS50庫，這反過來又

819
00:34:09,739 --> 00:34:12,179
包括引擎蓋下方的另一個庫，我們有

820
00:34:12,179 --> 00:34:14,909
訪問的數據類型，被稱為布爾值，

821
00:34:14,909 --> 00:34:18,730
從字面上讓我們到指定的值true或false

822
00:34:18,730 --> 00:34:20,219
在一個程序中的事情。

823
00:34:20,219 --> 00:34:23,880
>> 所以，讓我們繼續在這裡寫一個小程序，

824
00:34:23,880 --> 00:34:26,330
涉及數字，而不是做一些事情。

825
00:34:26,330 --> 00:34:29,840
因此，讓我回去CS50電器，讓我繼續前進，

826
00:34:29,840 --> 00:34:32,770
創建一個新的文件，這裡所說的 - 

827
00:34:32,770 --> 00:34:35,460
讓我們只說簡單的東西，像math.c.

828
00:34:38,270 --> 00:34:38,710
好的。

829
00:34:38,710 --> 00:34:41,600
而現在我的程序上去的，我

830
00:34:41,600 --> 00:34:42,510
通常要做的 - 

831
00:34:42,510 --> 00:34:44,780
＃<stdio.h>中，這樣我就可以使用

832
00:34:44,780 --> 00:34:46,860
printf的，詮釋的主要（無效） - 

833
00:34:46,860 --> 00:34:49,270
我們會回來，最終，詮釋意味著什麼

834
00:34:49,270 --> 00:34:52,389
在這裡，在這裡的意思是什麼無效，但就目前而言，只是知道，

835
00:34:52,389 --> 00:34:54,270
你要啟動這樣的程序。

836
00:34:54,270 --> 00:34:56,280
現在，我要繼續前進，說的東西一點點

837
00:34:56,280 --> 00:35:02,110
不同的 -  printf（“請給我一個數字：

838
00:35:02,110 --> 00:35:03,570
。）;

839
00:35:03,570 --> 00:35:09,220
然後，我該怎麼辦廉政n =調用getInt，因為它

840
00:35:09,220 --> 00:35:12,770
原來調用getInt是另一個函數，在CS50庫

841
00:35:12,770 --> 00:35:14,060
除了getString。

842
00:35:14,060 --> 00:35:17,340
而現在，我會做一些愚蠢的，像“感謝

843
00:35:17,340 --> 00:35:25,760
的％d“，為十進制整數，然後逗號N，

844
00:35:25,760 --> 00:35:26,620
然後返回0。

845
00:35:26,620 --> 00:35:28,940
所以，再一次，返回0，有沒有做我的

846
00:35:28,940 --> 00:35:30,080
詢問用戶。

847
00:35:30,080 --> 00:35:33,620
只是表示，大概，是在年底。

848
00:35:33,620 --> 00:35:36,290
>> 所以，讓我去到我的終端窗口。

849
00:35:36,290 --> 00:35:39,590
讓我的類型進行數學，輸入。

850
00:35:39,590 --> 00:35:41,360
東西是錯誤的。

851
00:35:41,360 --> 00:35:44,620
使數學不工作。

852
00:35:44,620 --> 00:35:46,170
這是第一個錯誤消息。

853
00:35:46,170 --> 00:35:46,570
為什麼呢？

854
00:35:46,570 --> 00:35:49,720
有點神秘，但是 - 

855
00:35:49,720 --> 00:35:50,060
是啊。

856
00:35:50,060 --> 00:35:51,240
所以cs50.h.

857
00:35:51,240 --> 00:35:53,900
如此反复，特別是早期，你會寫你的第一個

858
00:35:53,900 --> 00:35:56,590
程序的pset 1節，於辦公時間內，

859
00:35:56,590 --> 00:35:59,050
坦率地說，這將是壓倒性的，有時這些事是什麼

860
00:35:59,050 --> 00:36:00,000
實際上說。

861
00:36:00,000 --> 00:36:01,890
不過，你就會意識到非常快，他們開始下降

862
00:36:01,890 --> 00:36:06,120
據此，這意味著你離開到桶

863
00:36:06,120 --> 00:36:08,290
＃包括的文件的頂部。

864
00:36:08,290 --> 00:36:10,960
鐺，編譯器，通知你的

865
00:36:10,960 --> 00:36:14,090
說，而美麗的，隱含的聲明

866
00:36:14,090 --> 00:36:15,990
函數調用getInt是無效的。

867
00:36:15,990 --> 00:36:16,310
>> 好的。

868
00:36:16,310 --> 00:36:17,520
那麼，是什麼意思呢？

869
00:36:17,520 --> 00:36:22,080
它只是意味著你已經隱式聲明的調用getInt在

870
00:36:22,080 --> 00:36:24,850
這個意義上，你沒有明確宣布它。

871
00:36:24,850 --> 00:36:27,300
要明確地聲明int，你必須教

872
00:36:27,300 --> 00:36:28,740
鐺它的存在。

873
00:36:28,740 --> 00:36:32,020
非常簡單的解決方案就是教

874
00:36:32,020 --> 00:36:34,780
包括本其他的的文件，cs50.h，

875
00:36:34,780 --> 00:36:35,850
文件的開頭。

876
00:36:35,850 --> 00:36:40,380
因為從字面上看，哪些＃include是告訴鐺

877
00:36:40,380 --> 00:36:44,030
幾乎去找到該文件名為cs50.h，複印，

878
00:36:44,030 --> 00:36:48,150
對我來說，它會自動粘貼到我的程序的頂部，

879
00:36:48,150 --> 00:36:50,850
然後將其轉換的源代碼，零和的。

880
00:36:50,850 --> 00:36:52,850
但是，這顯然是非常乏味的，如果我們人類有

881
00:36:52,850 --> 00:36:55,370
去複製和粘貼這些大文件的時間，

882
00:36:55,370 --> 00:36:58,540
所以＃包括所有的情況下自動

883
00:36:58,540 --> 00:37:01,550
弄髒我的代碼用別人的庫。

884
00:37:01,550 --> 00:37:06,370
圖書館是另一個文件包含的功能和

885
00:37:06,370 --> 00:37:08,340
其他的東西，別人寫的，我們是

886
00:37:08,340 --> 00:37:10,270
利用我們自己的利益。

887
00:37:10,270 --> 00:37:10,580
>> 好的。

888
00:37:10,580 --> 00:37:11,200
讓我們再試一次。

889
00:37:11,200 --> 00:37:12,250
使數學。

890
00:37:12,250 --> 00:37:13,120
輸入。

891
00:37:13,120 --> 00:37:13,530
好。

892
00:37:13,530 --> 00:37:14,880
因此，這似乎發揮了作用。

893
00:37:14,880 --> 00:37:18,330
因此，讓我現在運行的數學/數學。

894
00:37:18,330 --> 00:37:21,100
輸入給了我一個號碼，123。

895
00:37:21,100 --> 00:37:22,620
感謝為123。

896
00:37:22,620 --> 00:37:24,490
現在，讓我們嘗試另一個角落的情況。

897
00:37:24,490 --> 00:37:26,530
一個字符串是非常慷慨的，因為

898
00:37:26,530 --> 00:37:27,620
字符串可以是任何東西。

899
00:37:27,620 --> 00:37:28,910
可以像數字，看起來像

900
00:37:28,910 --> 00:37:30,600
字符，看起來都像是單詞。

901
00:37:30,600 --> 00:37:31,900
但是，int類型是int。

902
00:37:31,900 --> 00:37:34,370
所以，現在如果我困難的用戶，它說：“給我

903
00:37:34,370 --> 00:37:38,730
一個數字，“如果我嘗試做一些事情（如0.1）？

904
00:37:38,730 --> 00:37:41,510
嗯，這是一個數字，這是符合

905
00:37:41,510 --> 00:37:44,180
語法我在這裡使用，但引擎蓋下的，我的

906
00:37:44,180 --> 00:37:45,610
當然，使用函數調用getInt。

907
00:37:45,610 --> 00:37:46,610
>> 因此，讓我們看看會發生什麼。

908
00:37:46,610 --> 00:37:48,250
回車鍵，然後重試。

909
00:37:48,250 --> 00:37:48,560
好的。

910
00:37:48,560 --> 00:37:50,570
讓我是困難的，只需要敲擊回車再次。

911
00:37:50,570 --> 00:37:51,700
輸入，回車。

912
00:37:51,700 --> 00:37:53,890
因此，現在看來，調用getInt多一點

913
00:37:53,890 --> 00:37:55,240
強大的比GetString的。

914
00:37:55,240 --> 00:37:58,540
我們的工作人員，在這樣一種方式，如果我們注意到實施

915
00:37:58,540 --> 00:38:02,100
你有沒有給我們一個int  - 一個int是一個十進制數

916
00:38:02,100 --> 00:38:04,785
包含零的人，三三兩兩，三，四，五，六人木球賽，

917
00:38:04,785 --> 00:38:05,540
七，八，九。

918
00:38:05,540 --> 00:38:06,310
就是這樣。

919
00:38:06,310 --> 00:38:08,810
沒有小數點，沒有人物，沒有標點符號。

920
00:38:08,810 --> 00:38:10,390
看來，我們有合作。

921
00:38:10,390 --> 00:38:13,680
所以，讓我來試試四，五，六，讓我通過。

922
00:38:13,680 --> 00:38:16,760
所以，真的，是肛這裡，我可能會說：“給我

923
00:38:16,760 --> 00:38:20,310
為了傳達給用戶一個整數“

924
00:38:20,310 --> 00:38:22,620
正是我打算。

925
00:38:22,620 --> 00:38:24,090
>> 現在，讓我們覺得引擎蓋下的。

926
00:38:24,090 --> 00:38:27,930
我們不打算在，如何cs50.h實施今天，

927
00:38:27,930 --> 00:38:29,080
該庫。

928
00:38:29,080 --> 00:38:33,600
但是，如果它口口聲聲說重試，重試，重試，什麼編程

929
00:38:33,600 --> 00:38:36,970
構建我大概用下面的罩

930
00:38:36,970 --> 00:38:39,000
實現了嗎？

931
00:38:39,000 --> 00:38:39,980
因此，只要一個循環，對不對？

932
00:38:39,980 --> 00:38:41,930
其中一個最簡單的想法，我們從頭看到。

933
00:38:41,930 --> 00:38:45,050
永遠的建設，重複建設。

934
00:38:45,050 --> 00:38:47,320
據推測，在這個程序中，引擎蓋下的，即使

935
00:38:47,320 --> 00:38:49,470
雖然它的C語言編寫的，而不是從頭開始，它在做什麼

936
00:38:49,470 --> 00:38:54,300
什麼叫如果用戶永遠不

937
00:38:54,300 --> 00:38:58,710
輸入整數，說重試，重試，重試，重試，所以

938
00:38:58,710 --> 00:39:01,220
最後，當我們這麼做的時候得到一個整數，那麼你

939
00:39:01,220 --> 00:39:02,970
跳出這個循環。

940
00:39:02,970 --> 00:39:05,610
>> 那麼，還有什麼其他的功能，我們可以使用在這裡在CS50的圖書館？

941
00:39:05,610 --> 00:39:07,880
好了，種明顯的，至少基礎上，

942
00:39:07,880 --> 00:39:09,570
數據類型，我們現在知道存在。

943
00:39:09,570 --> 00:39:12,900
我們實施GetString時，調用getInt，但在整個

944
00:39:12,900 --> 00:39:15,680
這個詞的第一個星期，你也可以使用getFloat先把及

945
00:39:15,680 --> 00:39:18,870
為了得到精確的GetDouble和GetLongLong

946
00:39:18,870 --> 00:39:20,030
數據類型，你想要的。

947
00:39:20,030 --> 00:39:24,030
因為這裡的關鍵細節是，不像某些語言中，

948
00:39:24,030 --> 00:39:26,630
Python和Ruby等，在那裡你不一定要

949
00:39:26,630 --> 00:39:29,730
聲明變量的數據類型 - 

950
00:39:29,730 --> 00:39:32,390
你不必告訴計算機什麼樣的東西

951
00:39:32,390 --> 00:39:34,000
你要放入變量 - 

952
00:39:34,000 --> 00:39:36,640
C，你必須要非常精確。

953
00:39:36,640 --> 00:39:40,060
所以，如果你想有一個變量n，一大塊存儲

954
00:39:40,060 --> 00:39:42,900
在這種情況下，恰好是32位的，按照慣例，你

955
00:39:42,900 --> 00:39:45,660
必須告訴電腦，這些位是

956
00:39:45,660 --> 00:39:47,840
要存儲一個數字 - 

957
00:39:47,840 --> 00:39:50,630
不是一個字符，而不是一個字符串，而不是一個float。

958
00:39:50,630 --> 00:39:52,620
這解決了問題，我們有效地

959
00:39:52,620 --> 00:39:53,760
跑進上週。

960
00:39:53,760 --> 00:39:57,050
如果我們使用的是零和的數字，不只是代表

961
00:39:57,050 --> 00:40:00,770
電話號碼，但由於BS和CS，如何在世界上是一個

962
00:40:00,770 --> 00:40:03,460
電腦要知道，這種模式實際使用的位

963
00:40:03,460 --> 00:40:07,650
表示數字65，而不是代表

964
00:40:07,650 --> 00:40:09,860
字母A，巧合的是，根據

965
00:40:09,860 --> 00:40:13,440
ASCII，記得，相當於65？

966
00:40:13,440 --> 00:40:16,550
>> 因此，這些數據類型提供了上下文到電腦上，所以

967
00:40:16,550 --> 00:40:18,810
它知道，如果這些位應該被解釋為

968
00:40:18,810 --> 00:40:23,660
int或一個字符串。

969
00:40:23,660 --> 00:40:26,500
如有任何疑問，然後，在此嗎？

970
00:40:26,500 --> 00:40:28,149
是嗎？

971
00:40:34,780 --> 00:40:35,270
DAVID J.馬蘭：好問題。

972
00:40:35,270 --> 00:40:39,140
如果我們採取了stdio.h中，我們保存文件 - 

973
00:40:39,140 --> 00:40:44,360
讓我去到終端窗口，並運行數學，放大

974
00:40:44,360 --> 00:40:45,530
在進入 - 

975
00:40:45,530 --> 00:40:47,700
現在，我得到一個不同的錯誤，因為我含蓄地

976
00:40:47,700 --> 00:40:49,650
聲明現在什麼功能？

977
00:40:49,650 --> 00:40:50,700
printf的。

978
00:40:50,700 --> 00:40:52,970
所以，現在我已經創建了一個新的問題，它的解決方案是

979
00:40:52,970 --> 00:40:53,890
本質上是相同的。

980
00:40:53,890 --> 00:40:55,365
我需要把回來。

981
00:40:55,365 --> 00:40:56,615
觀眾：[聽不清]

982
00:41:03,534 --> 00:41:04,030
DAVID J.馬蘭：哦。

983
00:41:04,030 --> 00:41:04,850
所以，如果我拿出 - 

984
00:41:04,850 --> 00:41:05,360
好吧，是的。

985
00:41:05,360 --> 00:41:08,960
所以，如果我刪除的標準I / O庫包含

986
00:41:08,960 --> 00:41:12,020
在這裡，然後你說，如果我擺脫的printf，得到

987
00:41:12,020 --> 00:41:13,450
擺脫了printf？

988
00:41:13,450 --> 00:41:13,810
是。

989
00:41:13,810 --> 00:41:18,450
這應該工作，因為我不再使用任何 - 哎呦。

990
00:41:18,450 --> 00:41:20,110
我只是撒了謊？

991
00:41:20,110 --> 00:41:21,650
哦，好吧。

992
00:41:21,650 --> 00:41:25,640
這是不行的，因為我們剛剛推出了一個新的錯誤。

993
00:41:25,640 --> 00:41:28,390
這是一個小更不言自明。

994
00:41:28,390 --> 00:41:29,440
>> 有什麼問題嗎？

995
00:41:29,440 --> 00:41:30,680
未使用的變量n。

996
00:41:30,680 --> 00:41:34,040
因此，這個錯誤是由於我們配置了

997
00:41:34,040 --> 00:41:36,640
家電特別是迂腐，要真正大喊大叫

998
00:41:36,640 --> 00:41:39,060
你的每一個可能的錯誤，即使它的種

999
00:41:39,060 --> 00:41:41,950
這樣一個非致命的錯誤 - 是不是真的這麼大的

1000
00:41:41,950 --> 00:41:44,820
處理，我分配一個int，提出了一些，然後

1001
00:41:44,820 --> 00:41:46,030
只是做了什麼呢？

1002
00:41:46,030 --> 00:41:47,020
因此，在功能上，沒有。

1003
00:41:47,020 --> 00:41:50,410
這並不是要打破計劃。

1004
00:41:50,410 --> 00:41:51,490
這只是一種愚蠢的，對不對？

1005
00:41:51,490 --> 00:41:54,220
有沒有要求數量，存儲的值

1006
00:41:54,220 --> 00:41:56,370
在一個變量中，如果你永遠也不會做任何事情

1007
00:41:56,370 --> 00:41:58,000
有了它，無論它打印或保存。

1008
00:41:58,000 --> 00:42:00,270
因此，在這種情況下，鏘確認一樣多，並

1009
00:42:00,270 --> 00:42:02,010
它說未使用的變量n。

1010
00:42:02,010 --> 00:42:05,380
>> 因此，我們可以解決這個問題，如果我們真正想要的。

1011
00:42:05,380 --> 00:42:07,250
但是，這是不是一種好的編程。

1012
00:42:07,250 --> 00:42:09,310
所以，我可以做到這一點 - 

1013
00:42:09,310 --> 00:42:12,060
在這裡，讓我清楚的畫面，使數學。

1014
00:42:12,060 --> 00:42:13,090
該工程。

1015
00:42:13,090 --> 00:42:18,110
我現在可以運行我的數學程序，需要輸入 - 

1016
00:42:18,110 --> 00:42:18,700
嗯，這是不好的。

1017
00:42:18,700 --> 00:42:23,450
接受輸入，那就是，在這種情況下，所有它。

1018
00:42:23,450 --> 00:42:25,220
>> 因此，實際上，讓我們嘗試另外一個角落的情況，我們

1019
00:42:25,220 --> 00:42:26,300
沒想到的早期。

1020
00:42:26,300 --> 00:42:28,220
在這種情況下 - 在這裡，讓我們回到一個，這是一個

1021
00:42:28,220 --> 00:42:29,500
對用戶來說更加友好。

1022
00:42:29,500 --> 00:42:32,580
讓我回到這裡，再次運行make數學。

1023
00:42:32,580 --> 00:42:34,190
哎呀，我做了什麼錯了嗎？

1024
00:42:34,190 --> 00:42:35,400
得到進一步回滾。

1025
00:42:35,400 --> 00:42:36,390
好吧。

1026
00:42:36,390 --> 00:42:38,490
現在我們又回到了原來的狀態，所有

1027
00:42:38,490 --> 00:42:39,990
是希望。

1028
00:42:39,990 --> 00:42:43,360
而現在，如果我遇到數學，123似乎工作。

1029
00:42:43,360 --> 00:42:46,010
但是，這不是一個真正的有效的證據，只是說

1030
00:42:46,010 --> 00:42:47,930
好吧，這工作的。

1031
00:42:47,930 --> 00:42:49,120
789的作品。

1032
00:42:49,120 --> 00:42:50,100
提交時間。

1033
00:42:50,100 --> 00:42:51,870
因為有其他角落的情況下。

1034
00:42:51,870 --> 00:42:55,040
一個字符串，沒有真正給我們太多的麻煩通過鍵入

1035
00:42:55,040 --> 00:42:56,510
一大堆的字符。

1036
00:42:56,510 --> 00:42:59,580
但是，如果我輸入？

1037
00:42:59,580 --> 00:43:04,850
擊中了一大堆，這裡的很多 - 

1038
00:43:04,850 --> 00:43:06,300
所有權利，它變得有點無聊，所以我要

1039
00:43:06,300 --> 00:43:10,040
停在這裡，我要按下回車鍵。

1040
00:43:10,040 --> 00:43:11,290
>> 你到底發生了什麼？

1041
00:43:14,110 --> 00:43:17,680
所以，這其實是可以解釋的。

1042
00:43:17,680 --> 00:43:18,920
所以沒有把它作為二進制嗎？

1043
00:43:18,920 --> 00:43:21,130
一個好的想法，但沒有，這是不是事實，即它把它

1044
00:43:21,130 --> 00:43:22,815
二進制，因為事實上，這僅僅是一個怎樣的

1045
00:43:22,815 --> 00:43:23,080
巧合。

1046
00:43:23,080 --> 00:43:23,930
我們可以做到這一點。

1047
00:43:23,930 --> 00:43:26,530
因此，有沒有，這是二進位制

1048
00:43:26,530 --> 00:43:27,420
可能是足夠的了。

1049
00:43:27,420 --> 00:43:28,780
輸入。

1050
00:43:28,780 --> 00:43:30,140
所以這是沒有問題的。

1051
00:43:30,140 --> 00:43:31,390
還有什麼呢？

1052
00:43:34,650 --> 00:43:35,400
沒錯。

1053
00:43:35,400 --> 00:43:37,830
>> 所以想返回一個int實際上是什麼。

1054
00:43:37,830 --> 00:43:40,970
這是32位解釋

1055
00:43:40,970 --> 00:43:42,090
為一個數字。

1056
00:43:42,090 --> 00:43:44,730
如果您有32位，這意味著每個比特可以

1057
00:43:44,730 --> 00:43:46,690
是0或1，0或1。

1058
00:43:46,690 --> 00:43:49,090
因此，這意味著有兩種可能性，該位，

1059
00:43:49,090 --> 00:43:51,140
這兩種可能性，這兩種可能性

1060
00:43:51,140 --> 00:43:52,570
位 - 所以這是2倍，2倍 - 

1061
00:43:52,570 --> 00:43:55,480
所以這是2的32次冪的總數

1062
00:43:55,480 --> 00:43:58,960
排列零和的，如果你有32

1063
00:43:58,960 --> 00:44:01,400
佔位符，0或1，在你的面前。

1064
00:44:01,400 --> 00:44:04,250
所以，如果我有2到32個，數學，那是什麼？

1065
00:44:07,080 --> 00:44:07,840
因此，這是一個很大。

1066
00:44:07,840 --> 00:44:09,910
這是4億元，給予或採取。

1067
00:44:09,910 --> 00:44:13,510
和4億美元似乎並沒有被打印出來在這裡。

1068
00:44:13,510 --> 00:44:16,290
事實上，這看起來更接近至2億美元。

1069
00:44:16,290 --> 00:44:17,970
但是，這是不是一個巧合。

1070
00:44:17,970 --> 00:44:21,590
事實上，電腦已經誤解了我的大量，

1071
00:44:21,590 --> 00:44:24,260
我巨大的，然後我巨大的二進制補碼序列，序列

1072
00:44:24,260 --> 00:44:26,880
大約2億元，是如何解釋的呢？

1073
00:44:30,250 --> 00:44:32,180
有一個上限的int。

1074
00:44:32,180 --> 00:44:34,970
有一個肯定，你可以代表的最大值。

1075
00:44:34,970 --> 00:44:36,370
但它通常為4億元，對不對？

1076
00:44:36,370 --> 00:44:39,100
如果是2到32的約4億美元，這似乎是

1077
00:44:39,100 --> 00:44:40,350
這是最大的數。

1078
00:44:42,420 --> 00:44:45,240
因此，沒有餘數，但一個好的想法。

1079
00:44:45,240 --> 00:44:46,340
負數。

1080
00:44:46,340 --> 00:44:49,570
所以，如果你有4億的事情，你可以

1081
00:44:49,570 --> 00:44:52,970
代表這些不同排列的32 0

1082
00:44:52,970 --> 00:44:55,600
1秒，以及，它會隨時原因，我們人類可能要

1083
00:44:55,600 --> 00:44:57,110
不只是代表正整數

1084
00:44:57,110 --> 00:44:58,240
但負整數。

1085
00:44:58,240 --> 00:45:00,410
事實上，這是假設的C。

1086
00:45:00,410 --> 00:45:03,550
因此，32位，你可以代表大致負2

1087
00:45:03,550 --> 00:45:06,630
十億一路正2億元。

1088
00:45:06,630 --> 00:45:08,750
因此，在這種情況下，我們真正看到的僅僅是

1089
00:45:08,750 --> 00:45:13,600
附帶的能力，我們的整數，並且，因此我們有

1090
00:45:13,600 --> 00:45:15,860
可以說，溢出了整數。

1091
00:45:15,860 --> 00:45:19,180
我們試圖把它塞進更多的位比實際上可以適合。

1092
00:45:19,180 --> 00:45:22,960
所以，最終的結果是，我們基本上都為1的位。

1093
00:45:22,960 --> 00:45:25,280
我們所有的位翻轉，我們一直在努力，代表

1094
00:45:25,280 --> 00:45:27,630
最大的可能，但它顯然不是近

1095
00:45:27,630 --> 00:45:30,960
大到足以代表兩件事情，我剛剛輸入的字詞。

1096
00:45:30,960 --> 00:45:31,730
是嗎？

1097
00:45:31,730 --> 00:45:32,980
觀眾：[聽不清]

1098
00:45:37,230 --> 00:45:37,830
>> DAVID J.馬蘭：好問題。

1099
00:45:37,830 --> 00:45:40,080
為什麼我們不能只是表示該負

1100
00:45:40,080 --> 00:45:41,500
簽名只是一個字符嗎？

1101
00:45:41,500 --> 00:45:44,200
所以，我們絕對可以，我們可以然後保存

1102
00:45:44,200 --> 00:45:45,470
一個附加位。

1103
00:45:45,470 --> 00:45:49,100
但你仍然要代表破折號，和

1104
00:45:49,100 --> 00:45:50,700
這要花費你至少東西，

1105
00:45:50,700 --> 00:45:52,220
想必位。

1106
00:45:52,220 --> 00:45:55,610
所以，是的，我們可以為我們的數32位，但現在

1107
00:45:55,610 --> 00:45:57,610
我們需要另一位用於我們的破折號

1108
00:45:57,610 --> 00:45:58,810
符號，減號。

1109
00:45:58,810 --> 00:46:01,470
所以，現在我們有33位的值，我們可以這樣做，但它的

1110
00:46:01,470 --> 00:46:02,570
只是沒有辦法做這項工作。

1111
00:46:02,570 --> 00:46:05,140
我們做了一個判斷調用年前，32位是排序的

1112
00:46:05,140 --> 00:46:06,170
在這裡的度量單位。

1113
00:46:06,170 --> 00:46:08,120
因此，我們將使用這些位有效

1114
00:46:08,120 --> 00:46:12,950
代表消極，31位代表的數量。

1115
00:46:12,950 --> 00:46:15,550
其他問題嗎？

1116
00:46:15,550 --> 00:46:15,670
好的。

1117
00:46:15,670 --> 00:46:16,030
這是一個很大。

1118
00:46:16,030 --> 00:46:17,930
我們為什麼不繼續在這裡我們五分鐘的休息時間嗎？

1119
00:46:23,580 --> 00:46:24,270
>> 好的。

1120
00:46:24,270 --> 00:46:31,250
所以，再一次，不要過分強調數學的應用

1121
00:46:31,250 --> 00:46:33,840
的節目，就讓我們把她的一個例子

1122
00:46:33,840 --> 00:46:36,590
在我們進入其他結構，只是因為它

1123
00:46:36,590 --> 00:46:39,430
將一些常見的障礙點上的一些說明

1124
00:46:39,430 --> 00:46:41,520
當它涉及到編寫程序的基本。

1125
00:46:41,520 --> 00:46:44,360
在這種情況下，這樣做的算術表達式，有一些

1126
00:46:44,360 --> 00:46:48,010
有趣的語法的相關性。

1127
00:46:48,010 --> 00:46:50,430
>> 因此，這只是一個公式，我們可以將

1128
00:46:50,430 --> 00:46:52,690
溫度從華氏攝氏度。

1129
00:46:52,690 --> 00:46:54,600
如果你不記得，這僅僅是一個公式。

1130
00:46:54,600 --> 00:46:58,870
因此，如果我們插在華氏32度，這是

1131
00:46:58,870 --> 00:47:02,850
凍結，這將是32減去32是0，而事實上，

1132
00:47:02,850 --> 00:47:05,130
0攝氏度也凍結。

1133
00:47:05,130 --> 00:47:08,210
這麼快的完整性檢查 - 這是熟悉的公式。

1134
00:47:08,210 --> 00:47:10,880
讓我去到設備，但是，並開始

1135
00:47:10,880 --> 00:47:13,920
寫一個程序稱為一樣，F2C“華氏

1136
00:47:13,920 --> 00:47:15,920
攝氏點C“。

1137
00:47:15,920 --> 00:47:18,930
在這裡的頂部，我要開始用＃include

1138
00:47:18,930 --> 00:47:22,190
stdio.h中，我要詮釋的主要（無效），並

1139
00:47:22,190 --> 00:47:24,680
再次，我們將在未來回來整數意味著什麼

1140
00:47:24,680 --> 00:47:26,820
有無效意味著什麼。

1141
00:47:26,820 --> 00:47:28,770
現在讓我繼續前進，執行一個程序，

1142
00:47:28,770 --> 00:47:31,170
基本上沒有我們這個轉換。

1143
00:47:31,170 --> 00:47:36,830
>> 因此我們知道printf，比方說，華氏溫度。

1144
00:47:36,830 --> 00:47:40,140
然後讓我繼續前進，從用戶的價值。

1145
00:47:40,140 --> 00:47:43,120
我應該得到什麼樣的價值，如果我想從用戶

1146
00:47:43,120 --> 00:47:45,620
他們給我一個華氏溫度？

1147
00:47:45,620 --> 00:47:48,090
是嗎？

1148
00:47:48,090 --> 00:47:50,090
你會建議什麼？

1149
00:47:50,090 --> 00:47:50,410
是啊。

1150
00:47:50,410 --> 00:47:51,960
因此，浮動的感覺相當合理的。

1151
00:47:51,960 --> 00:47:53,950
再次，我們有幾個選項，

1152
00:47:53,950 --> 00:47:55,310
迄今為止，我們已經看到了。

1153
00:47:55,310 --> 00:48:00,100
我們有些事如char，雙，浮點型，整型，很長很長，

1154
00:48:00,100 --> 00:48:01,150
布爾，字符串。

1155
00:48:01,150 --> 00:48:03,510
所以這些，的浮動感覺很合理的。

1156
00:48:03,510 --> 00:48:06,340
我們可以用一個雙，正確的，因為如果我們真的要

1157
00:48:06,340 --> 00:48:07,580
代表一個人的溫度 - 

1158
00:48:07,580 --> 00:48:10,730
98.60000  - 

1159
00:48:10,730 --> 00:48:12,990
要做到這一點，我們可以使用64位，但感覺像

1160
00:48:12,990 --> 00:48:14,200
矯枉過正的溫度。

1161
00:48:14,200 --> 00:48:16,380
因此，讓我們一起去浮動。

1162
00:48:16,380 --> 00:48:18,100
現在，我需要一個變量。

1163
00:48:18,100 --> 00:48:20,500
只是為了讓事情簡單，我會打電話給它f，但我

1164
00:48:20,500 --> 00:48:23,370
可以很正確地調用它的溫度，

1165
00:48:23,370 --> 00:48:24,600
但無論是好的。

1166
00:48:24,600 --> 00:48:27,610
因此，浮動f = getFloat先把。

1167
00:48:27,610 --> 00:48:30,220
只要我現在已經決定了，不過，我使用getFloat先把

1168
00:48:30,220 --> 00:48:33,340
需要做一個修正。

1169
00:48:33,340 --> 00:48:33,720
是啊。

1170
00:48:33,720 --> 00:48:37,460
因此，我們需要＃包括<cs50.h>的，否則編譯器

1171
00:48:37,460 --> 00:48:39,000
要罵我們。

1172
00:48:39,000 --> 00:48:41,720
現在，我有一個浮動，讓我繼續做

1173
00:48:41,720 --> 00:48:42,460
轉換。

1174
00:48:42,460 --> 00:48:44,980
>> 因此，首先讓我還養成早睡早起的習慣在這裡

1175
00:48:44,980 --> 00:48:46,310
評論我的代碼。

1176
00:48:46,310 --> 00:48:49,820
所以，再一次，評論的人，只是一個符號

1177
00:48:49,820 --> 00:48:52,600
不是程序本身的一部分，但它一個，幫助您

1178
00:48:52,600 --> 00:48:55,010
明白你做了什麼，第二天早上，或下

1179
00:48:55,010 --> 00:48:57,570
月，它可以幫助你的教學同胞知道你做了什麼

1180
00:48:57,570 --> 00:48:59,230
或者你打算做什麼，所以它的

1181
00:48:59,230 --> 00:49:00,950
通常是非常好的做法。

1182
00:49:00,950 --> 00:49:02,940
每隔幾行代碼，寫評論

1183
00:49:02,940 --> 00:49:04,490
你或你的同事。

1184
00:49:04,490 --> 00:49:08,460
所以在這裡，我會說，“詢問用戶的溫度。”

1185
00:49:08,460 --> 00:49:10,890
不必是一個完整的句子，只是一個簡單的短語。

1186
00:49:10,890 --> 00:49:14,270
但在C註釋背後的想法是，你的每一個

1187
00:49:14,270 --> 00:49:17,980
意見應賦予你 - 或說，，TF或同事的 - 

1188
00:49:17,980 --> 00:49:21,290
撇去你的程序，不知道它究竟是什麼

1189
00:49:21,290 --> 00:49:24,650
這麼多的閱讀代碼，但通過閱讀註釋，

1190
00:49:24,650 --> 00:49:26,220
應該是簡潔明了。

1191
00:49:26,220 --> 00:49:29,030
好了，所以現在讓我繼續說，“轉換

1192
00:49:29,030 --> 00:49:32,660
華氏攝氏度。“所以我要繼續做，

1193
00:49:32,660 --> 00:49:34,340
比方說，浮動Ç。

1194
00:49:34,340 --> 00:49:36,610
我們將保持攝氏浮點值。

1195
00:49:36,610 --> 00:49:37,630
>> ，讓我帶刺在此。

1196
00:49:37,630 --> 00:49:40,350
其計算公式為，再次在這裡。

1197
00:49:40,350 --> 00:49:45,510
5/9次F零下32。

1198
00:49:45,510 --> 00:49:46,360
因此，讓我們做到這一點。

1199
00:49:46,360 --> 00:49:50,450
因此，5除以9，減 - 

1200
00:49:50,450 --> 00:49:52,330
哎呦，我把事情搞糟了。

1201
00:49:52,330 --> 00:49:53,070
時報。

1202
00:49:53,070 --> 00:49:56,550
因此，5/9倍f零下32。

1203
00:49:56,550 --> 00:49:59,650
所以F減去32，分號。

1204
00:49:59,650 --> 00:50:02,000
而現在，在這裡，我要繼續前進

1205
00:50:02,000 --> 00:50:03,220
並說，打印結果。

1206
00:50:03,220 --> 00:50:05,160
而這部分很簡單。 printf的。

1207
00:50:05,160 --> 00:50:07,980
我該如何去打印此？

1208
00:50:07,980 --> 00:50:16,890
好吧，我可以說，“在攝氏這個數字是％f \ n”，

1209
00:50:16,890 --> 00:50:18,060
只是一些美學。

1210
00:50:18,060 --> 00:50:20,450
什麼樣的價值，我想在這裡插入printf的

1211
00:50:20,450 --> 00:50:21,360
第二個參數？

1212
00:50:21,360 --> 00:50:21,650
好吧。

1213
00:50:21,650 --> 00:50:22,540
因此，只要C。

1214
00:50:22,540 --> 00:50:24,760
因此，我們將從這裡開始，然後就返回0。

1215
00:50:24,760 --> 00:50:25,960
再次，它具有與數學無關。

1216
00:50:25,960 --> 00:50:27,610
它只是意味著一切都很好。

1217
00:50:27,610 --> 00:50:31,210
>> 現在，這是正確的，這個程序嗎？

1218
00:50:31,210 --> 00:50:31,520
好的。

1219
00:50:31,520 --> 00:50:33,630
所以，我犯了一些錯誤。

1220
00:50:33,630 --> 00:50:35,980
即使你不知道是什麼程序，您可以排序

1221
00:50:35,980 --> 00:50:37,120
的推斷回到小學

1222
00:50:37,120 --> 00:50:38,740
可能的錯誤在這裡。

1223
00:50:38,740 --> 00:50:40,050
第一個是什麼？

1224
00:50:40,050 --> 00:50:41,256
觀眾：[聽不清]

1225
00:50:41,256 --> 00:50:41,660
DAVID J.馬蘭：是的。

1226
00:50:41,660 --> 00:50:42,940
因此，我們漏掉括號內。

1227
00:50:42,940 --> 00:50:45,420
這是故意的，我沒有括號的基調

1228
00:50:45,420 --> 00:50:48,130
滑動這裡，因為這裡實際上這個概念的，

1229
00:50:48,130 --> 00:50:51,590
操作，或優先級，使某些操作 - 

1230
00:50:51,590 --> 00:50:52,890
乘法 - 

1231
00:50:52,890 --> 00:50:56,000
有較高的結合，具有較高的優先級，比東西

1232
00:50:56,000 --> 00:50:58,050
如加法或減法。

1233
00:50:58,050 --> 00:51:00,550
因此，我們所做的這幾年，只是為了清晰準確

1234
00:51:00,550 --> 00:51:02,840
首先應該做的是什麼數學運算。

1235
00:51:02,840 --> 00:51:05,010
所以，我也許應該模仿的正是這一點。

1236
00:51:05,010 --> 00:51:08,990
否則，電腦大概要嘗試做

1237
00:51:08,990 --> 00:51:13,090
類似9鴻溝5，再乘以F，然後減去

1238
00:51:13,090 --> 00:51:14,850
32從整個事情。

1239
00:51:14,850 --> 00:51:16,480
這不，事實上，我們想要做的是什麼。

1240
00:51:16,480 --> 00:51:17,340
因此，讓我們括號。

1241
00:51:17,340 --> 00:51:20,860
讓我們添加我的括號，括號在這裡。

1242
00:51:20,860 --> 00:51:22,670
讓我們把這個在這裡。

1243
00:51:22,670 --> 00:51:25,130
在這裡，我只注意到另一個錯誤，我一路走來。

1244
00:51:25,130 --> 00:51:25,680
是嗎？

1245
00:51:25,680 --> 00:51:26,930
觀眾：[聽不清]

1246
00:51:29,632 --> 00:51:30,130
>> DAVID J.馬蘭啊。

1247
00:51:30,130 --> 00:51:30,470
好。

1248
00:51:30,470 --> 00:51:32,400
所以，我們其實有相同的整數

1249
00:51:32,400 --> 00:51:34,020
從之前的分工問題。

1250
00:51:34,020 --> 00:51:35,800
我糾正這個問題，讓我們來看看是什麼症狀。

1251
00:51:35,800 --> 00:51:36,990
但是我們要糾正一個

1252
00:51:36,990 --> 00:51:37,680
這裡的其他錯誤。

1253
00:51:37,680 --> 00:51:38,015
是嗎？

1254
00:51:38,015 --> 00:51:39,540
觀眾：[聽不清]

1255
00:51:39,540 --> 00:51:40,070
DAVID J.馬蘭：是的。

1256
00:51:40,070 --> 00:51:43,130
所以，我做了愚蠢的錯誤，但非常重要的。

1257
00:51:43,130 --> 00:51:45,870
電腦是不會視而不見，只是讓

1258
00:51:45,870 --> 00:51:48,770
我用大寫F，當我宣布變量

1259
00:51:48,770 --> 00:51:51,360
作為一個小寫f，在第8行。

1260
00:51:51,360 --> 00:51:54,470
因此，我需要糾正在第11行我的資本，哪一個

1261
00:51:54,470 --> 00:51:56,820
剛才是一個大寫F誤。

1262
00:51:56,820 --> 00:51:57,610
這裡怎麼樣？

1263
00:51:57,610 --> 00:51:59,980
這應該是小寫的呢？

1264
00:51:59,980 --> 00:52:02,260
這是應該的，但是這是一個巧合。

1265
00:52:02,260 --> 00:52:05,070
，％f有沒有做的變量。

1266
00:52:05,070 --> 00:52:07,980
因此，只要是超清晰，讓我繼續前進，

1267
00:52:07,980 --> 00:52:10,710
重命名，簡單地說，“溫度”。讓我重新命名

1268
00:52:10,710 --> 00:52:15,050
此“溫度”。讓我不能重命名。

1269
00:52:15,050 --> 00:52:18,180
因為，再次，％f全球範圍內的意思，“浮點值。”

1270
00:52:18,180 --> 00:52:19,950
有沒有做我的變量。

1271
00:52:19,950 --> 00:52:23,080
但“溫度”的地方只是一個小羅嗦，

1272
00:52:23,080 --> 00:52:25,370
所以，我要回到我的小寫字母“f”。

1273
00:52:25,370 --> 00:52:27,890
>> 現在，讓我繼續我的窗前。

1274
00:52:27,890 --> 00:52:29,190
請F2C  - 

1275
00:52:29,190 --> 00:52:31,200
這是，再次，我的任意名稱

1276
00:52:31,200 --> 00:52:32,590
給這個文件。

1277
00:52:32,590 --> 00:52:33,690
似乎已經編譯。

1278
00:52:33,690 --> 00:52:35,080
讓我跑F2C。

1279
00:52:35,080 --> 00:52:35,780
輸入。

1280
00:52:35,780 --> 00:52:37,786
華氏溫度 - 讓我們做一個簡單的一個。

1281
00:52:37,786 --> 00:52:39,370
32。

1282
00:52:39,370 --> 00:52:40,910
OK，糾正。

1283
00:52:40,910 --> 00:52:45,910
但是，如果我現在做的212沸騰 - 

1284
00:52:45,910 --> 00:52:46,630
該死的。

1285
00:52:46,630 --> 00:52:47,030
好的。

1286
00:52:47,030 --> 00:52:50,780
所以，這顯然不是正確的，如果你的TF嘗試

1287
00:52:50,780 --> 00:52:51,800
至少兩個值。

1288
00:52:51,800 --> 00:52:53,340
那麼，是什麼問題呢？

1289
00:52:53,340 --> 00:52:55,970
好了，你已經把你的手指上是什麼問題。

1290
00:52:55,970 --> 00:52:57,600
但是，為什麼是這樣呢？

1291
00:52:57,600 --> 00:53:00,630
在這裡，當我在做數學5分9。

1292
00:53:00,630 --> 00:53:02,190
因此，從理論上講，是完全正確的。

1293
00:53:02,190 --> 00:53:03,690
完全一致的公式。

1294
00:53:03,690 --> 00:53:05,940
但是，計算機只能做正是你

1295
00:53:05,940 --> 00:53:06,760
告訴他們做什麼。

1296
00:53:06,760 --> 00:53:08,940
我們有效地在這裡告訴計算機

1297
00:53:08,940 --> 00:53:12,320
除以整數5的整數9

1298
00:53:12,320 --> 00:53:13,670
給我的結果。

1299
00:53:13,670 --> 00:53:16,230
問題是，但是，如果你做除法數據

1300
00:53:16,230 --> 00:53:20,220
類型，輸出是輸入的相同的數據類型。

1301
00:53:20,220 --> 00:53:23,670
因此，如果兩個輸入是這兩種類型為int，輸出將

1302
00:53:23,670 --> 00:53:25,110
是一個int。

1303
00:53:25,110 --> 00:53:28,770
因此，5除以9點東西。

1304
00:53:28,770 --> 00:53:32,320
但是，什麼是最接近的整數點東西嗎？

1305
00:53:32,320 --> 00:53:33,630
因此，它實際上是0。

1306
00:53:33,630 --> 00:53:36,620
所以，當我們討論星期一，一切都小數點後

1307
00:53:36,620 --> 00:53:37,940
點被截斷。

1308
00:53:37,940 --> 00:53:39,495
它只是被丟棄。

1309
00:53:39,495 --> 00:53:42,760
所以這是一個完全錯誤的，因為我可能也只是

1310
00:53:42,760 --> 00:53:44,700
乘0這裡的一切。

1311
00:53:44,700 --> 00:53:46,550
>> 現在，我可以在一對夫婦的方式來解決這個問題。

1312
00:53:46,550 --> 00:53:48,080
我能做到這一點。

1313
00:53:48,080 --> 00:53:50,490
5.0除以9.0。

1314
00:53:50,490 --> 00:53:52,110
從技術上講，我什至不需要做的。

1315
00:53:52,110 --> 00:53:55,780
它足以使一個浮動的數字之一 - 

1316
00:53:55,780 --> 00:53:58,290
或雙 - 通過把小數點這裡。

1317
00:53:58,290 --> 00:54:01,740
因為發生的事情是，當你將整數

1318
00:54:01,740 --> 00:54:04,670
一個浮點數或雙，計算機的實現

1319
00:54:04,670 --> 00:54:06,830
哦，其中之一是更加精確。

1320
00:54:06,830 --> 00:54:09,420
我寧可讓你更精確的比側

1321
00:54:09,420 --> 00:54:10,310
您所想。

1322
00:54:10,310 --> 00:54:12,700
因此，將轉換的結果 - 

1323
00:54:12,700 --> 00:54:16,240
將一個浮點值，以及返回的結果。

1324
00:54:16,240 --> 00:54:17,330
因此，這將工作。

1325
00:54:17,330 --> 00:54:18,060
這將工作。

1326
00:54:18,060 --> 00:54:20,010
還有另外一個機制，我們將看到在

1327
00:54:20,010 --> 00:54:21,390
更詳細的下週。

1328
00:54:21,390 --> 00:54:24,690
作為程序員，實際上，你可以告訴電腦

1329
00:54:24,690 --> 00:54:27,930
實際處理一個數據類型

1330
00:54:27,930 --> 00:54:29,260
雖然它是另一個。

1331
00:54:29,260 --> 00:54:30,990
>> 所以，我可以真正做到這一點。

1332
00:54:30,990 --> 00:54:35,280
在括號中，我可以這樣說（浮動），開

1333
00:54:35,280 --> 00:54:36,350
括號，關閉括號。

1334
00:54:36,350 --> 00:54:39,050
這是所謂的“鑄造”。同樣，

1335
00:54:39,050 --> 00:54:39,940
在此下週。

1336
00:54:39,940 --> 00:54:42,280
但是，這僅僅是一個綱領性的方式告訴

1337
00:54:42,280 --> 00:54:45,910
電腦，是的，我知道9是一個整數或長。

1338
00:54:45,910 --> 00:54:47,700
我不知道這是一個浮點值。

1339
00:54:47,700 --> 00:54:49,420
但把它作為這樣呢。

1340
00:54:49,420 --> 00:54:52,000
因此，投的數據類型轉換成

1341
00:54:52,000 --> 00:54:53,310
從一個到另一個。

1342
00:54:53,310 --> 00:54:55,790
坦率地說，這只是一個小的醜陋，所以我會建議我們去

1343
00:54:55,790 --> 00:54:58,830
只是轉換回原來的建議

1344
00:54:58,830 --> 00:55:00,770
這些東西手動浮點值。

1345
00:55:00,770 --> 00:55:02,890
因為現在只是超級清楚是怎麼回事，和

1346
00:55:02,890 --> 00:55:04,280
它不是所有的分心。

1347
00:55:04,280 --> 00:55:06,710
>> 現在讓我們回去到我的終端窗口中。

1348
00:55:06,710 --> 00:55:07,990
請F2C。

1349
00:55:07,990 --> 00:55:09,430
讓我去，繼續運行。

1350
00:55:09,430 --> 00:55:12,340
而且，順便說一句，你感到厭倦，輸入這些命令

1351
00:55:12,340 --> 00:55:14,910
一遍又一遍，認識到計算機，如Linux，

1352
00:55:14,910 --> 00:55:16,010
往往是很聰明的。

1353
00:55:16,010 --> 00:55:18,890
如果我撞了上去，我們可以通過我的整個歷史

1354
00:55:18,890 --> 00:55:20,380
命令，向上和向下。

1355
00:55:20,380 --> 00:55:23,840
因此，在這種情況下，在這裡，我可以去運行F2C。

1356
00:55:23,840 --> 00:55:25,830
我被大聲訓斥，因為我只是做了一秒鐘前。

1357
00:55:25,830 --> 00:55:27,030
這已經是最新的。

1358
00:55:27,030 --> 00:55:30,720
所以，現在我可以再次運行F2C。

1359
00:55:30,720 --> 00:55:33,260
讓我們嘗試32華氏度。

1360
00:55:33,260 --> 00:55:36,720
現在，讓我們嘗試212華氏度。

1361
00:55:36,720 --> 00:55:37,250
>> 唷。

1362
00:55:37,250 --> 00:55:38,250
似乎工作。

1363
00:55:38,250 --> 00:55:41,760
現在，這是很好的，但是感覺有點任意的，

1364
00:55:41,760 --> 00:55:44,890
我顯示小數點後六位數字。

1365
00:55:44,890 --> 00:55:45,070
對嗎？

1366
00:55:45,070 --> 00:55:47,830
如果你人在電視上的天氣，你的doofus的

1367
00:55:47,830 --> 00:55:49,150
如果你正在讀的溫度

1368
00:55:49,150 --> 00:55:50,070
這個精確度。

1369
00:55:50,070 --> 00:55:51,270
所以，讓我們簡化這。

1370
00:55:51,270 --> 00:55:53,880
因此，讓我們其實在這裡，我的printf。

1371
00:55:53,880 --> 00:55:55,490
是的，我想自由浮動。

1372
00:55:55,490 --> 00:55:57,570
不過，我想現在指定的精度。

1373
00:55:57,570 --> 00:55:59,070
我是一個小的簡潔。

1374
00:55:59,070 --> 00:56:03,090
我說，給我一個點後的小數位。

1375
00:56:03,090 --> 00:56:07,590
因此，而不是說％F，我會說％.1 F。

1376
00:56:07,590 --> 00:56:09,760
而這只是給我一個位置

1377
00:56:09,760 --> 00:56:11,410
小數點後。

1378
00:56:11,410 --> 00:56:11,700
好的。

1379
00:56:11,700 --> 00:56:12,570
讓我們再試一次。

1380
00:56:12,570 --> 00:56:15,590
讓我重新編譯後運行。

1381
00:56:15,590 --> 00:56:18,160
現在我輸入32，我得到一個

1382
00:56:18,160 --> 00:56:19,310
更簡潔的價值。

1383
00:56:19,310 --> 00:56:22,480
我可以輸入，現在，212，和得到一個更簡潔

1384
00:56:22,480 --> 00:56:23,260
價值。

1385
00:56:23,260 --> 00:56:25,190
還有其他的事情可以做，用printf。

1386
00:56:25,190 --> 00:56:27,950
實際上，你可以指定數目應該有多寬。

1387
00:56:27,950 --> 00:56:30,900
如果你想，有填充就可以了，所以你可以用鼠標右鍵調整或

1388
00:56:30,900 --> 00:56:32,360
左對齊所有的數字或

1389
00:56:32,360 --> 00:56:33,400
嘗試為中心的東西。

1390
00:56:33,400 --> 00:56:35,340
因此，實現有小動作就做什麼。

1391
00:56:35,340 --> 00:56:38,420
但他們只是歸結為格式代碼，

1392
00:56:38,420 --> 00:56:39,600
像我們有。

1393
00:56:39,600 --> 00:56:41,090
>> 因此，在這個問題的優先方面。

1394
00:56:41,090 --> 00:56:43,820
這是一個很無聊的表中去，通過有條不紊。

1395
00:56:43,820 --> 00:56:46,780
但認識到，紛紛拿出了作者的C

1396
00:56:46,780 --> 00:56:50,190
規則，指定運營商有更高的

1397
00:56:50,190 --> 00:56:53,680
優先，更多的結合力，比其他人。

1398
00:56:53,680 --> 00:56:55,890
因此而小學的時候，我們一般知道這是

1399
00:56:55,890 --> 00:56:58,930
乘法和除法，加法和減法，

1400
00:56:58,930 --> 00:56:59,950
然後一些其他的東西。

1401
00:56:59,950 --> 00:57:01,720
在編程的世界中，有一個更

1402
00:57:01,720 --> 00:57:03,360
更長的事情的清單。

1403
00:57:03,360 --> 00:57:05,150
這是不是現在值得記憶的東西。

1404
00:57:05,150 --> 00:57:07,310
用不了多久，你會得到馴化。

1405
00:57:07,310 --> 00:57:10,690
但就像小學的時候，括號一般解決

1406
00:57:10,690 --> 00:57:12,990
問題的優先級，超清晰的

1407
00:57:12,990 --> 00:57:15,620
計算機和人類一樣的目的是什麼。

1408
00:57:15,620 --> 00:57:17,770
因此，考慮這只是一個小的小抄。

1409
00:57:17,770 --> 00:57:21,690
但最重要的那些細節，我們不會去一段時間。

1410
00:57:21,690 --> 00:57:21,900
>> 好的。

1411
00:57:21,900 --> 00:57:24,120
現在，讓我們建立和遠離這些無聊的小

1412
00:57:24,120 --> 00:57:25,460
數學的例子。

1413
00:57:25,460 --> 00:57:27,500
仍然使用相同的基本面，但啟動

1414
00:57:27,500 --> 00:57:29,960
表達自己有點像刮。

1415
00:57:29,960 --> 00:57:31,660
因此，在從頭開始，我們這些布爾表達式。

1416
00:57:31,660 --> 00:57:34,890
而在英語中，布爾表達式是什麼？

1417
00:57:34,890 --> 00:57:35,580
TRUE或FALSE。

1418
00:57:35,580 --> 00:57:38,300
這件事情的計算結果為true或false。

1419
00:57:38,300 --> 00:57:39,060
1或0。

1420
00:57:39,060 --> 00:57:39,870
“開”或“關”。

1421
00:57:39,870 --> 00:57:41,000
無論你怎麼稱呼它。

1422
00:57:41,000 --> 00:57:43,210
現在在刮，的拼圖看起來像這樣的。

1423
00:57:43,210 --> 00:57:45,850
這相結合，在底部有三個，

1424
00:57:45,850 --> 00:57:47,980
拼圖。

1425
00:57:47,980 --> 00:57:48,980
一個結合 - 

1426
00:57:48,980 --> 00:57:51,710
的東西，有空白和空白。

1427
00:57:51,710 --> 00:57:53,970
然後它裡面的布爾表達式。

1428
00:57:53,970 --> 00:57:56,460
所以，你可以窩的布爾表達式，以獲得更多的

1429
00:57:56,460 --> 00:57:59,360
複雜的布爾表達式。

1430
00:57:59,360 --> 00:58:03,930
例如，如果它是星期六，它是很好的

1431
00:58:03,930 --> 00:58:06,180
天氣，然後到外面去。

1432
00:58:06,180 --> 00:58:07,500
什麼的任意那樣。

1433
00:58:07,500 --> 00:58:10,090
所以，你可以加入了一個布爾表達式來

1434
00:58:10,090 --> 00:58:12,780
真值較大，其答案是基於

1435
00:58:12,780 --> 00:58:13,800
較小的。

1436
00:58:13,800 --> 00:58:15,770
>> 現在，在C，幸運的是，這個映射

1437
00:58:15,770 --> 00:58:16,720
其實很簡單。

1438
00:58:16,720 --> 00:58:18,820
括號把事情說清楚在這裡。

1439
00:58:18,820 --> 00:58:21,700
&&是什麼意思“和”。所以，這就是

1440
00:58:21,700 --> 00:58:24,700
我們要轉換這些塊從白手起家到C.

1441
00:58:24,700 --> 00:58:27,590
的條件下，我們看到了從無到有，在左手

1442
00:58:27,590 --> 00:58:31,150
側有，我可以將它們堆疊同樣C.如果x小於

1443
00:58:31,150 --> 00:58:32,970
除y，然後做到這一點。

1444
00:58:32,970 --> 00:58:35,100
否則，如果x是大於y，那麼這樣做。

1445
00:58:35,100 --> 00:58:38,030
否則在邏輯上他們必須是平等的，所以說

1446
00:58:38,030 --> 00:58:39,140
他們是平等的。

1447
00:58:39,140 --> 00:58:41,210
所以，我們現在可以開始構建這些東西。

1448
00:58:41,210 --> 00:58:42,170
>> 因此，讓我們做一個實例。

1449
00:58:42,170 --> 00:58:45,550
讓我打開了一個文件，該文件了課程網站，

1450
00:58:45,550 --> 00:58:47,270
我寫的提前。

1451
00:58:47,270 --> 00:58:50,540
這就是所謂的nonswitch.c。

1452
00:58:50,540 --> 00:58:52,270
我們會看到為什麼在短短的時刻。

1453
00:58:52,270 --> 00:58:54,770
因此，在這個文件 -  nonswitch.c  - 

1454
00:58:54,770 --> 00:58:56,830
第一次認識到，有一大堆的

1455
00:58:56,830 --> 00:58:58,460
在上面的意見。

1456
00:58:58,460 --> 00:59:00,110
這只是解釋的文件名，它是什麼

1457
00:59:00,110 --> 00:59:01,260
，等等。

1458
00:59:01,260 --> 00:59:04,390
它顯然說明了如何使用布爾AND-ING  - 

1459
00:59:04,390 --> 00:59:06,220
交接兩個表達式。

1460
00:59:06,220 --> 00:59:07,670
>> 因此，讓我們來看看這個程序是如何工作的。

1461
00:59:07,670 --> 00:59:10,840
我包括我的兩個的文件，cs50.h和stdio.h中。

1462
00:59:10,840 --> 00:59:13,180
如果我向下滾動，現在的程序，它是一個小

1463
00:59:13,180 --> 00:59:15,730
比我們之前寫的，但非常可讀。

1464
00:59:15,730 --> 00:59:18,360
所以，我第一次打印的用戶，第18行，

1465
00:59:18,360 --> 00:59:20,460
“給我一個1和10之間的整數。”所以

1466
00:59:20,460 --> 00:59:21,530
這是正確的。

1467
00:59:21,530 --> 00:59:23,410
現在，我得到的整數。

1468
00:59:23,410 --> 00:59:25,380
但認識到，調用getInt  - 很簡單。

1469
00:59:25,380 --> 00:59:26,510
它只是將一個int。

1470
00:59:26,510 --> 00:59:28,830
這將確保，它並獲得一個int，而不是一個

1471
00:59:28,830 --> 00:59:30,060
字符串或浮點數。

1472
00:59:30,060 --> 00:59:32,390
但它不會做任何形式的邊界檢查。

1473
00:59:32,390 --> 00:59:34,750
這不是要過濾的號碼之間的

1474
00:59:34,750 --> 00:59:35,630
一定範圍內。

1475
00:59:35,630 --> 00:59:37,730
因此，我們必須實施自己。

1476
00:59:37,730 --> 00:59:40,680
所以就像在刮，在那裡我可以做一個結合的

1477
00:59:40,680 --> 00:59:43,560
兩個表達式，我可以做的，在C如下。

1478
00:59:43,560 --> 00:59:48,660
如果n大於或等於1，和n是小於和

1479
00:59:48,660 --> 00:59:52,220
或等於3，我會很隨意法令，

1480
00:59:52,220 --> 00:59:53,830
數是一個小數目。

1481
00:59:53,830 --> 00:59:56,730
只是為了一份聲明。

1482
00:59:56,730 --> 01:00:00,210
否則，如果n為4和6，打印“你選擇了一個中等

1483
01:00:00,210 --> 01:00:03,440
號“。否則，如果n為7和10之間，打印”你挑了

1484
01:00:03,440 --> 01:00:06,390
大的數字。“ELSE PRINT”你挑一個無效的號碼。“

1485
01:00:06,390 --> 01:00:07,900
因為從邏輯上講，後面如果我們

1486
01:00:07,900 --> 01:00:09,230
用盡了我們的範圍。

1487
01:00:09,230 --> 01:00:12,400
>> 因此，認識到這一點倒不怎麼寫大於或

1488
01:00:12,400 --> 01:00:15,000
等於在上數學課。

1489
01:00:15,000 --> 01:00:15,160
對嗎？

1490
01:00:15,160 --> 01:00:17,430
您通常像這樣繪製，與線下。

1491
01:00:17,430 --> 01:00:19,250
但是，我的鍵盤上有沒有這樣的關鍵。

1492
01:00:19,250 --> 01:00:22,390
因此，在C的符號用於表示大於或

1493
01:00:22,390 --> 01:00:25,770
等於是兩個字符，和符號為小於

1494
01:00:25,770 --> 01:00:29,100
或等於兩個字符。

1495
01:00:29,100 --> 01:00:29,330
好的。

1496
01:00:29,330 --> 01:00:31,910
所以，如果我運行這個程序，你大概可以猜出這是什麼

1497
01:00:31,910 --> 01:00:32,650
要做的事情。

1498
01:00:32,650 --> 01:00:36,180
如果我先走，使nonswitch，Enter鍵。

1499
01:00:36,180 --> 01:00:38,130
然後運行nonswitch。

1500
01:00:38,130 --> 01:00:39,530
給我1和10之間的一個數。

1501
01:00:39,530 --> 01:00:40,870
我要去給它11。

1502
01:00:40,870 --> 01:00:42,280
我拿起一個無效的數字。

1503
01:00:42,280 --> 01:00:44,090
讓我試試3號。

1504
01:00:44,090 --> 01:00:45,990
我拿起一個小數目。

1505
01:00:45,990 --> 01:00:48,360
所以相當簡單。

1506
01:00:48,360 --> 01:00:52,230
>> 如果我想改變這個程序的行為，

1507
01:00:52,230 --> 01:00:54,250
做的東西有點不同呢？

1508
01:00:54,250 --> 01:00:57,620
讓我繼續前進，說這句話。

1509
01:00:57,620 --> 01:00:59,480
讓我擺脫這一切。

1510
01:00:59,480 --> 01:01:03,780
如果讓我說（N = 42）。

1511
01:01:03,780 --> 01:01:08,730
然後我要繼續前進，並說打印“你選

1512
01:01:08,730 --> 01:01:16,340
正確的答案。“不然，我們要繼續前進，並說，

1513
01:01:16,340 --> 01:01:18,460
printf（“請你選

1514
01:01:18,460 --> 01:01:21,170
錯誤的答案。“）;好了。

1515
01:01:21,170 --> 01:01:22,040
只是因為。

1516
01:01:22,040 --> 01:01:23,890
>> 現在，有幾點我們可以在這裡提出。

1517
01:01:23,890 --> 01:01:26,570
一，我沒有鍵入符號，你會認為這是

1518
01:01:26,570 --> 01:01:27,390
最合理的。

1519
01:01:27,390 --> 01:01:30,110
當我要檢查平等，原來你不使用

1520
01:01:30,110 --> 01:01:30,910
等號。

1521
01:01:30,910 --> 01:01:34,000
您可以使用等於等號。

1522
01:01:34,000 --> 01:01:36,440
而原因可能是，只是憑直覺呢？

1523
01:01:36,440 --> 01:01:37,030
是啊。

1524
01:01:37,030 --> 01:01:39,330
觀眾：[聽不清]

1525
01:01:39,330 --> 01:01:39,615
DAVID J.馬蘭：正確。

1526
01:01:39,615 --> 01:01:41,630
已經用於分配等號。

1527
01:01:41,630 --> 01:01:43,020
有人真的沒有想到。

1528
01:01:43,020 --> 01:01:45,820
所以現在，當它涉及到平等的測試中，我們必須

1529
01:01:45,820 --> 01:01:48,850
更加明確，並說等於平等的。

1530
01:01:48,850 --> 01:01:52,110
一個很常見的錯誤是做到這一點。

1531
01:01:52,110 --> 01:01:54,800
而且，如果在辦公時間或下週的某個時候或在

1532
01:01:54,800 --> 01:01:58,340
接下來的兩個星期，你做這樣的事情，然後

1533
01:01:58,340 --> 01:02:00,920
它奮鬥了10年，20分鐘，試圖找出

1534
01:02:00,920 --> 01:02:03,330
該死的錯誤是什麼，認識到，你是其中的一個

1535
01:02:03,330 --> 01:02:04,470
誰犯了這個錯誤的人。

1536
01:02:04,470 --> 01:02:06,030
因此，超級容易做。

1537
01:02:06,030 --> 01:02:08,240
但現在的目標是抵擋這樣的錯誤。

1538
01:02:08,240 --> 01:02:11,840
這可以評估，因為這是真正的意思嗎？

1539
01:02:11,840 --> 01:02:15,010
如果n得到42。

1540
01:02:15,010 --> 01:02:18,250
因此，動詞的人使用，口頭，以表達對

1541
01:02:18,250 --> 01:02:21,800
分配的概念是“得到”。因此，如果n得到42。

1542
01:02:21,800 --> 01:02:24,060
因此，這意味著到n分配42。

1543
01:02:24,060 --> 01:02:26,250
現在我有一個布爾表達式中括號，

1544
01:02:26,250 --> 01:02:30,230
此條件下的內部，它的數值是42。

1545
01:02:30,230 --> 01:02:30,390
對嗎？

1546
01:02:30,390 --> 01:02:32,690
因為如果你評估它從內到外，總

1547
01:02:32,690 --> 01:02:34,100
答案，現在是42。

1548
01:02:34,100 --> 01:02:37,360
>> 所以，如果我問你的問題，“如果（42），”什麼是

1549
01:02:37,360 --> 01:02:38,410
真正在說什麼？

1550
01:02:38,410 --> 01:02:40,990
那麼，布爾表達式只能是真或假。

1551
01:02:40,990 --> 01:02:42,010
1或0。

1552
01:02:42,010 --> 01:02:43,010
“開”或“關”。

1553
01:02:43,010 --> 01:02:45,240
因此，我們似乎在這裡，有一個角落的情況下，讓所有的

1554
01:02:45,240 --> 01:02:50,060
突然，我說：“如果（42）”。這不是一個布爾值。

1555
01:02:50,060 --> 01:02:54,500
因此，電腦做什麼，但是，它基本上等同於

1556
01:02:54,500 --> 01:02:58,620
任何不為0的解釋是正確的。

1557
01:02:58,620 --> 01:02:59,340
1。

1558
01:02:59,340 --> 01:02:59,690
在。

1559
01:02:59,690 --> 01:03:01,510
它們是等價的所有功能。

1560
01:03:01,510 --> 01:03:05,070
只有值為0，或關鍵字假的，因為我們會

1561
01:03:05,070 --> 01:03:07,860
最終看到的，實際上是錯誤的。

1562
01:03:07,860 --> 01:03:15,040
因此，“（42）”，實際上是真實的，因為它是非零。

1563
01:03:15,040 --> 01:03:18,620
因此，為了更精確地在這裡，一個布爾值是真的不

1564
01:03:18,620 --> 01:03:20,680
的真或假，但在本

1565
01:03:20,680 --> 01:03:24,650
情況下，如果是0或非零。

1566
01:03:24,650 --> 01:03:26,330
因此，虛假或不假。

1567
01:03:26,330 --> 01:03:28,640
這使我們能夠涵蓋所有的

1568
01:03:28,640 --> 01:03:30,980
在括號表達式中的可能性。

1569
01:03:30,980 --> 01:03:33,840
因此，我們需要非常仔細，說 - 

1570
01:03:33,840 --> 01:03:35,620
（N = 42）。

1571
01:03:35,620 --> 01:03:39,100
很簡單，因為我們需要指定測試的平等，

1572
01:03:39,100 --> 01:03:40,930
不分配的值。

1573
01:03:40,930 --> 01:03:42,830
>> 在這裡值得一提的是什麼？

1574
01:03:42,830 --> 01:03:46,030
這些花括號實際上是沒有必要的。

1575
01:03:46,030 --> 01:03:48,650
我一直在做，只是為了在這裡挑剔挑剔。

1576
01:03:48,650 --> 01:03:51,350
但是，當你有一個條件，只有一行

1577
01:03:51,350 --> 01:03:55,100
代碼的方便，程序員並不需要使用

1578
01:03:55,100 --> 01:03:56,030
大括號。

1579
01:03:56,030 --> 01:03:59,370
總之，只是縮進，出於美觀的考慮，

1580
01:03:59,370 --> 01:04:01,050
然後再編寫一行代碼。

1581
01:04:01,050 --> 01:04:04,160
只有當你想要寫的兩行代碼 - 

1582
01:04:04,160 --> 01:04:08,230
例如，否則輸出（“細則”）。如果你想做的事

1583
01:04:08,230 --> 01:04:09,540
的是，這被打破了。

1584
01:04:09,540 --> 01:04:11,700
您可以縮進想要的一切，但事實上，你有

1585
01:04:11,700 --> 01:04:14,600
輸入的兩行代碼，而無需使用花括號

1586
01:04:14,600 --> 01:04:16,860
意味著這個程序將無法正常運行或可能

1587
01:04:16,860 --> 01:04:18,530
甚至沒有正確編譯。

1588
01:04:18,530 --> 01:04:21,040
所以現在，說實話，我認為最好的習慣是

1589
01:04:21,040 --> 01:04:24,460
使用大括號，你會發現，他們

1590
01:04:24,460 --> 01:04:25,750
超清晰是怎麼回事。

1591
01:04:25,750 --> 01:04:29,410
>> 另外，順便說一句 - 特別是如果你在那些誰使用

1592
01:04:29,410 --> 01:04:31,700
推薦的書籍或在線資源 - 

1593
01:04:31,700 --> 01:04:33,480
意識到有這個概念的風格

1594
01:04:33,480 --> 01:04:34,130
編程。

1595
01:04:34,130 --> 01:04:37,280
有些人喜歡把花括號

1596
01:04:37,280 --> 01:04:38,720
在這裡上線。

1597
01:04:38,720 --> 01:04:41,520
有些人喜歡做可笑的事情，

1598
01:04:41,520 --> 01:04:43,830
我喜歡把它們放在這裡。

1599
01:04:43,830 --> 01:04:45,140
有沒有錯誤的答案，當涉及到

1600
01:04:45,140 --> 01:04:46,710
風格，但是這是錯誤的。

1601
01:04:46,710 --> 01:04:47,700
但是，有些人做到這一點。

1602
01:04:47,700 --> 01:04:49,160
[笑]

1603
01:04:49,160 --> 01:04:51,760
DAVID J.馬蘭：所以我現在提到這一點，僅僅是因為作為

1604
01:04:51,760 --> 01:04:54,400
你讀的書籍或網上的事情，你會得到

1605
01:04:54,400 --> 01:04:55,990
從不同的老師，不同的消息

1606
01:04:55,990 --> 01:04:56,730
不同的作者。

1607
01:04:56,730 --> 01:04:58,640
而剛剛意識到這一點，在功能上，他們

1608
01:04:58,640 --> 01:05:00,740
一般等價的，但是一致的。

1609
01:05:00,740 --> 01:05:02,850
因此，在這種情況下，我們將標準化的花

1610
01:05:02,850 --> 01:05:04,650
括號這裡排隊的左邊。

1611
01:05:04,650 --> 01:05:04,910
>> 好的。

1612
01:05:04,910 --> 01:05:07,040
因此，讓我們繼續前進，現在和運行它，看看會發生什麼

1613
01:05:07,040 --> 01:05:07,780
這一計劃。

1614
01:05:07,780 --> 01:05:09,970
請nonswitch。

1615
01:05:09,970 --> 01:05:11,040
然後運行nonswitch。

1616
01:05:11,040 --> 01:05:13,900
給我一個介於0和 - 所以這是不相關的

1617
01:05:13,900 --> 01:05:16,480
了，但我只是隨意說42。

1618
01:05:16,480 --> 01:05:17,850
我選擇了正確的答案。

1619
01:05:17,850 --> 01:05:20,430
現在好了，讓我們藉此在不同的方向。

1620
01:05:20,430 --> 01:05:22,070
原來，有一些其他語法

1621
01:05:22,070 --> 01:05:23,480
可以在程序中使用。

1622
01:05:23,480 --> 01:05:27,310
這裡有一個新的語法，在功能上是相同的，

1623
01:05:27,310 --> 01:05:30,680
但只是介紹了另一種方式表達自己。

1624
01:05:30,680 --> 01:05:32,830
因此，這是什麼所謂的“switch語句”。和

1625
01:05:32,830 --> 01:05:34,820
switch語句如下。

1626
01:05:34,820 --> 01:05:37,580
它需要在括號中的數值要

1627
01:05:37,580 --> 01:05:38,860
“開關”。

1628
01:05:38,860 --> 01:05:41,490
你想不同的表現，根據其值。

1629
01:05:41,490 --> 01:05:44,360
因此，這意味著開關n的值。

1630
01:05:44,360 --> 01:05:45,480
這是什麼意思？

1631
01:05:45,480 --> 01:05:50,530
好了，如果n為1或2或3，繼續前進，並打印出“您

1632
01:05:50,530 --> 01:05:52,680
挑一個大數目“，然後打破。

1633
01:05:52,680 --> 01:05:55,720
突破的原因是，C工作

1634
01:05:55,720 --> 01:05:59,790
盡快找到相匹配的情況下，它開始執行

1635
01:05:59,790 --> 01:06:01,610
它下面的所有的代碼。

1636
01:06:01,610 --> 01:06:04,580
所以，如果我有，我在這裡做的第27行，一行代碼

1637
01:06:04,580 --> 01:06:05,360
被執行。

1638
01:06:05,360 --> 01:06:07,520
如果我在這裡增加一條生產線，它就會被執行。

1639
01:06:07,520 --> 01:06:09,350
另一條線，它就會被執行。

1640
01:06:09,350 --> 01:06:12,460
該方案只停止執行下面的是什麼

1641
01:06:12,460 --> 01:06:14,680
當我明確的適用case語句

1642
01:06:14,680 --> 01:06:17,210
說“分手”。所以是錯誤的。

1643
01:06:17,210 --> 01:06:19,220
右，在這種情況下，作為一個結果。

1644
01:06:19,220 --> 01:06:22,130
殼體4或5或6，同樣地，將

1645
01:06:22,130 --> 01:06:23,160
打印出的信息。

1646
01:06:23,160 --> 01:06:24,410
在這種情況下，介質編號。

1647
01:06:24,410 --> 01:06:25,200
打破。

1648
01:06:25,200 --> 01:06:28,160
案例7，8，9，10，它會打印出“你選擇了一個大

1649
01:06:28,160 --> 01:06:28,950
號“。突破。

1650
01:06:28,950 --> 01:06:31,290
再有就是名副其實的關鍵字被稱為“默認”

1651
01:06:31,290 --> 01:06:34,090
這是有效像“別人”的建設。

1652
01:06:34,090 --> 01:06:36,010
因此，新的語法，但在智力上，

1653
01:06:36,010 --> 01:06:37,060
沒有在所有新來的。

1654
01:06:37,060 --> 01:06:38,280
這就像擦除。

1655
01:06:38,280 --> 01:06:41,040
如果，否則的話，否則的話，代碼塊。

1656
01:06:41,040 --> 01:06:44,560
>> 所以這是這個程序的切換版本。

1657
01:06:44,560 --> 01:06:46,280
但是請注意，我們這樣做，是這裡的數字。

1658
01:06:46,280 --> 01:06:49,040
讓我打開了第二個版本，只是為了顯示

1659
01:06:49,040 --> 01:06:50,670
更具體一點的東西。

1660
01:06:50,670 --> 01:06:52,840
所以，在這裡，我們有檔次。

1661
01:06:52,840 --> 01:06:55,540
原來，你可以使用交換機，不只是整數，但在

1662
01:06:55,540 --> 01:06:56,340
字符。

1663
01:06:56,340 --> 01:06:58,930
不是所有的數據類型，但至少在字符。

1664
01:06:58,930 --> 01:07:02,670
所以在這裡，我們可以做這樣的事情，如果C的值，

1665
01:07:02,670 --> 01:07:06,230
使用者輸入，在第19行中，通過使用GetChar函數，

1666
01:07:06,230 --> 01:07:09,410
是資本或小寫字母a，讓我們把它解釋為一個檔次，

1667
01:07:09,410 --> 01:07:11,340
並說，他們拿起一個優異的成績。

1668
01:07:11,340 --> 01:07:14,690
順著switch語句，我們還有其他的

1669
01:07:14,690 --> 01:07:17,950
為“B”和“C”，以及等等的情況下。

1670
01:07:17,950 --> 01:07:19,780
但是，現在讓我們圓了另一件事情。

1671
01:07:19,780 --> 01:07:21,130
再次，種飛行

1672
01:07:21,130 --> 01:07:22,200
一些這些實施例。

1673
01:07:22,200 --> 01:07:26,990
但它確實使我們可以將它們應用，現在 - 

1674
01:07:26,990 --> 01:07:28,880
真的，只是他們現在翻譯 - 

1675
01:07:28,880 --> 01:07:32,220
為C。

1676
01:07:32,220 --> 01:07:33,310
>> 所以，讓我繼續這樣做。

1677
01:07:33,310 --> 01:07:34,830
我要打開一個新的文件。

1678
01:07:34,830 --> 01:07:39,430
我要去做包括<stdio.h>。

1679
01:07:39,430 --> 01:07:42,770
然後我要詮釋的主要（無效）。

1680
01:07:42,770 --> 01:07:46,390
讓我將此文件保存為一個loop.c.

1681
01:07:46,390 --> 01:07:48,280
只是作為一個例子。

1682
01:07:48,280 --> 01:07:49,910
我要繼續前進並執行以下操作。

1683
01:07:49,910 --> 01:07:54,180
我想寫一個非常繁瑣的程序。

1684
01:07:54,180 --> 01:07:56,170
因此，10。

1685
01:07:56,170 --> 01:07:58,862
讓我們這樣做。

1686
01:07:58,862 --> 01:07:59,320
9。

1687
01:07:59,320 --> 01:08:00,360
好的。

1688
01:08:00,360 --> 01:08:02,120
只要你開始做這在編程中，你

1689
01:08:02,120 --> 01:08:03,490
可能做錯了什麼。

1690
01:08:03,490 --> 01:08:04,950
但我們會從這裡開始了。

1691
01:08:04,950 --> 01:08:05,430
哎呀。

1692
01:08:05,430 --> 01:08:06,950
這實際上是錯誤的。

1693
01:08:06,950 --> 01:08:08,230
7。

1694
01:08:08,230 --> 01:08:09,440
6。

1695
01:08:09,440 --> 01:08:10,750
5。

1696
01:08:10,750 --> 01:08:11,200
4。

1697
01:08:11,200 --> 01:08:12,450
沒有什麼會發生什麼，當我們到達0。

1698
01:08:12,450 --> 01:08:13,290
3。

1699
01:08:13,290 --> 01:08:14,590
2。

1700
01:08:14,590 --> 01:08:15,630
1。

1701
01:08:15,630 --> 01:08:16,020
好吧。

1702
01:08:16,020 --> 01:08:17,560
0。

1703
01:08:17,560 --> 01:08:18,689
刪除。

1704
01:08:18,689 --> 01:08:19,029
>> 好的。

1705
01:08:19,029 --> 01:08:20,029
因此，返回0。

1706
01:08:20,029 --> 01:08:22,010
因此，這一計劃顯然會做什麼，很

1707
01:08:22,010 --> 01:08:23,310
不厭其煩地說，這是要做的。

1708
01:08:23,310 --> 01:08:24,060
這將打印所有這些

1709
01:08:24,060 --> 01:08:25,290
值，由上到下。

1710
01:08:25,290 --> 01:08:27,140
因此，讓我做循環。

1711
01:08:27,140 --> 01:08:28,640
然後 - 哎呦。

1712
01:08:28,640 --> 01:08:29,700
使環路。

1713
01:08:29,700 --> 01:08:31,479
我是在錯誤的目錄。

1714
01:08:31,479 --> 01:08:33,300
現在讓我跑環。

1715
01:08:33,300 --> 01:08:34,140
輸入。

1716
01:08:34,140 --> 01:08:34,620
嗚呼。

1717
01:08:34,620 --> 01:08:35,270
很不錯的。

1718
01:08:35,270 --> 01:08:36,279
不錯，長的節目。

1719
01:08:36,279 --> 01:08:38,109
>> 所有的權利，但現在讓我們做到這一點。

1720
01:08:38,109 --> 01:08:40,810
就像在刮，當你開始使用一個循環

1721
01:08:40,810 --> 01:08:43,149
建設，而不是僅僅複製和粘貼所有的

1722
01:08:43,149 --> 01:08:45,580
拼圖，讓我​​介紹一下這件事情。

1723
01:08:45,580 --> 01:08:48,609
因此，在C，有不同的循環結構，

1724
01:08:48,609 --> 01:08:50,540
其中一個看起來是這樣的。

1725
01:08:50,540 --> 01:08:55,069
一個“for”循環有三樣東西，用兩個分號分隔。

1726
01:08:55,069 --> 01:08:57,770
然後，身體內部的循環，所以說 - 

1727
01:08:57,770 --> 01:08:59,390
花括號裡面的東西 - 

1728
01:08:59,390 --> 01:09:01,010
我們可以做一些事情一遍又一遍。

1729
01:09:01,010 --> 01:09:02,310
所以我就在屏幕上，這是

1730
01:09:02,310 --> 01:09:03,300
從字面上評論。

1731
01:09:03,300 --> 01:09:05,380
/ /在這裡的意思來評論。

1732
01:09:05,380 --> 01:09:06,180
這是不是代碼。

1733
01:09:06,180 --> 01:09:08,890
這僅僅是英文說明，對我來說，人的。

1734
01:09:08,890 --> 01:09:11,300
>> 所以，初始化，條件和更新。

1735
01:09:11,300 --> 01:09:12,770
那麼，讓我們來看看它是如何工作的。

1736
01:09:12,770 --> 01:09:15,520
這讓我重寫程序如下。

1737
01:09:15,520 --> 01:09:16,399
對於 - 

1738
01:09:16,399 --> 01:09:18,029
所以這裡是我的循環 - 

1739
01:09:18,029 --> 01:09:19,439
INT I  - 

1740
01:09:19,439 --> 01:09:21,330
來了一個變量命名為“i”的 - 

1741
01:09:21,330 --> 01:09:23,140
得到初始化為10。

1742
01:09:23,140 --> 01:09:25,260
因此，有我的初始化。

1743
01:09:25,260 --> 01:09:29,450
我想要做的這個循環中，只要“我”是大於或等於

1744
01:09:29,450 --> 01:09:30,899
等於0。

1745
01:09:30,899 --> 01:09:32,880
這個循環的每一次迭代的，我想

1746
01:09:32,880 --> 01:09:34,979
做我 - 。

1747
01:09:34,979 --> 01:09:36,310
於是，我們看到了+ +（星期一）。

1748
01:09:36,310 --> 01:09:37,660
 - 是相反的。

1749
01:09:37,660 --> 01:09:39,410
它的值遞減1。

1750
01:09:39,410 --> 01:09:43,319
這個循環裡面，我希望做一些事情。

1751
01:09:43,319 --> 01:09:46,390
所以我要像printf說些什麼。

1752
01:09:46,390 --> 01:09:48,939
我不想說10了，因為這顯然是剛

1753
01:09:48,939 --> 01:09:50,000
要打印相同的值。

1754
01:09:50,000 --> 01:09:52,246
我想要什麼，而不是打印，可能嗎？

1755
01:09:52,246 --> 01:09:52,590
是啊。

1756
01:09:52,590 --> 01:09:55,270
因此，“我”。因此，％D，I。

1757
01:09:55,270 --> 01:09:57,340
>> 所以我要偷到一從早期的那些想法 - 

1758
01:09:57,340 --> 01:09:59,640
這種偷梁換柱的格式代碼 - 

1759
01:09:59,640 --> 01:10:01,620
，然後在這裡，在底部，我將返回0，只

1760
01:10:01,620 --> 01:10:02,710
良好的措施。

1761
01:10:02,710 --> 01:10:04,740
但現在，我有一個更簡潔的方案。

1762
01:10:04,740 --> 01:10:07,490
這是只有幾行字，而不是一些10或11號線。

1763
01:10:07,490 --> 01:10:09,440
讓我去我的提示下來。

1764
01:10:09,440 --> 01:10:10,630
翻拍循環。

1765
01:10:10,630 --> 01:10:12,140
重新運行循環。

1766
01:10:12,140 --> 01:10:13,570
和它似乎是相同的。

1767
01:10:13,570 --> 01:10:15,550
現在，該方案沒有更有趣。

1768
01:10:15,550 --> 01:10:17,180
但現在我可以鍵入這樣的事情。

1769
01:10:17,180 --> 01:10:18,970
我可以更改為100。

1770
01:10:18,970 --> 01:10:21,400
然後我就可以重新編譯我的程序。

1771
01:10:21,400 --> 01:10:23,360
然後我就可以重新運行我的程序。

1772
01:10:23,360 --> 01:10:26,390
而現在“超高速今天的計算機上。

1773
01:10:26,390 --> 01:10:27,820
然而，有我有 - 

1774
01:10:27,820 --> 01:10:29,620
而實際上，我的屏幕緩存不

1775
01:10:29,620 --> 01:10:30,890
遠不止這些。

1776
01:10:30,890 --> 01:10:31,680
我們走吧。

1777
01:10:31,680 --> 01:10:34,090
因此，我們有所有100個。

1778
01:10:34,090 --> 01:10:35,880
但它很容易在這裡犯錯。

1779
01:10:35,880 --> 01:10:37,920
這是怎麼回事，是預期的行為，如果我

1780
01:10:37,920 --> 01:10:41,150
不小心這樣做呢？

1781
01:10:41,150 --> 01:10:42,550
因此，它感覺就像是無限的。

1782
01:10:42,550 --> 01:10:44,670
因此，讓我們來看看，如果在計算機的行為。

1783
01:10:44,670 --> 01:10:47,020
>> 因此，讓我繼續前進，使循環。

1784
01:10:47,020 --> 01:10:48,355
讓我跑環。

1785
01:10:53,590 --> 01:10:55,210
因此，讓我們回來，在短短的時刻。

1786
01:10:55,210 --> 01:10:56,720
我們將讓這個運行。

1787
01:10:56,720 --> 01:10:59,520
因為，我們應該算什麼，微創？

1788
01:10:59,520 --> 01:11:02,200
大概至少2個十億，如果我們有多少位，和

1789
01:11:02,200 --> 01:11:03,660
我們使用的是正面的價值觀。

1790
01:11:03,660 --> 01:11:04,890
所以，讓我們跳回到這裡。

1791
01:11:04,890 --> 01:11:07,810
除了這些類型的循環，我們有什麼時，被稱為

1792
01:11:07,810 --> 01:11:09,430
循環。所以，就像在刮，你永遠

1793
01:11:09,430 --> 01:11:11,240
塊，你不得不重複塊。

1794
01:11:11,240 --> 01:11:13,270
同樣，在C中，你有其他的方式

1795
01:11:13,270 --> 01:11:14,260
表達自己。

1796
01:11:14,260 --> 01:11:17,110
所以，你有這個概念的一個while循環，可讓您

1797
01:11:17,110 --> 01:11:18,860
表達自己的一點點不同。

1798
01:11:18,860 --> 01:11:21,490
然後你有一些所謂的do-whil​​e循環，

1799
01:11:21,490 --> 01:11:24,200
經營略有不同。

1800
01:11:24,200 --> 01:11:25,320
而我們除了恥笑這些隨著時間的推移。

1801
01:11:25,320 --> 01:11:28,630
>> 但是，讓我們來看看在這最後一個在這裡。

1802
01:11:28,630 --> 01:11:30,160
如果我們去 - 

1803
01:11:30,160 --> 01:11:31,466
仍在運行。

1804
01:11:31,466 --> 01:11:32,770
這是相當無限的。

1805
01:11:32,770 --> 01:11:36,870
因此，讓我進入正面，並顯示如何，我們實際上可以

1806
01:11:36,870 --> 01:11:39,410
一點點更有效地治理用戶輸入。

1807
01:11:39,410 --> 01:11:40,910
這是一個很短的程序。

1808
01:11:40,910 --> 01:11:43,730
在這裡，我們有，在主，廉政n聲明。

1809
01:11:43,730 --> 01:11:46,570
所以給我一個變量n。現在，我從字面上說

1810
01:11:46,570 --> 01:11:48,340
“做的。”然後，我有左大

1811
01:11:48,340 --> 01:11:49,630
括號，靠近大括號。

1812
01:11:49,630 --> 01:11:52,000
然後請注意，右後，它說，當n

1813
01:11:52,000 --> 01:11:53,790
是小於1。

1814
01:11:53,790 --> 01:11:55,300
所以注意到，這些線 - 

1815
01:11:55,300 --> 01:11:56,740
19至24  - 

1816
01:11:56,740 --> 01:11:59,450
共同組成一個do-whil​​e循環。

1817
01:11:59,450 --> 01:12:01,280
再次，新的語法，而不是一個新的想法。

1818
01:12:01,280 --> 01:12:03,740
它只是另一種方式的循環，語法。

1819
01:12:03,740 --> 01:12:04,890
那麼，這是什麼做的？

1820
01:12:04,890 --> 01:12:08,000
而n是小於1，執行下列操作。

1821
01:12:08,000 --> 01:12:09,080
那麼，我該怎麼辦？

1822
01:12:09,080 --> 01:12:11,390
我要求你給我一個正整數。

1823
01:12:11,390 --> 01:12:14,110
然後我嘗試從用戶得到一個整數。

1824
01:12:14,110 --> 01:12:16,740
但在這裡的操作順序，因為

1825
01:12:16,740 --> 01:12:21,850
而條件是在這裡，我要檢查，是n

1826
01:12:21,850 --> 01:12:23,100
小於1？

1827
01:12:23,100 --> 01:12:24,600
因此，假設用戶 - 

1828
01:12:24,600 --> 01:12:26,450
在這樣的要求後 - 

1829
01:12:26,450 --> 01:12:29,190
類型中的值0。

1830
01:12:29,190 --> 01:12:34,510
這種情況是怎麼回事，是真還是假？

1831
01:12:34,510 --> 01:12:35,820
那麼，它是真實的。

1832
01:12:35,820 --> 01:12:38,700
因為n是0，和0小於1。

1833
01:12:38,700 --> 01:12:40,140
那麼，這意味著什麼呢？

1834
01:12:40,140 --> 01:12:41,160
再次這樣做。

1835
01:12:41,160 --> 01:12:41,990
再次這樣做。

1836
01:12:41,990 --> 01:12:42,640
再次這樣做。

1837
01:12:42,640 --> 01:12:46,080
只有當該條件的計算結果為false。

1838
01:12:46,080 --> 01:12:47,510
如果我輸入42。

1839
01:12:47,510 --> 01:12:49,690
好了沒有，42是不小於1。

1840
01:12:49,690 --> 01:12:52,320
因此，這個循環被執行。

1841
01:12:52,320 --> 01:12:54,650
因此，在這一點上，該程序會說，感謝

1842
01:12:54,650 --> 01:12:57,530
42，在這種情況下。

1843
01:12:57,530 --> 01:13:00,320
既然你有這樣的方式表達自己 - 

1844
01:13:00,320 --> 01:13:02,360
我們不應該等待完成。

1845
01:13:02,360 --> 01:13:03,620
這將需要一些時間。

1846
01:13:03,620 --> 01:13:04,990
要繼續下一次，也許吧。

1847
01:13:04,990 --> 01:13:08,050
>> 但現在，你有能力，希望了解一個

1848
01:13:08,050 --> 01:13:09,060
位的怪胎幽默。

1849
01:13:09,060 --> 01:13:11,560
抱歉。

1850
01:13:11,560 --> 01:13:13,620
在計算機科學的幽默，這是不是代表

1851
01:13:13,620 --> 01:13:14,870
世界，但它很可愛。

1852
01:13:21,020 --> 01:13:23,890
[笑]讓我們結束關於這一點。

1853
01:13:23,890 --> 01:13:25,750
我們星期一見。

1854
01:13:25,750 --> 01:13:31,629
[掌聲]