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