1
00:00:00,000 --> 00:00:12,410
>> [音樂播放]

2
00:00:12,410 --> 00:00:12,830
>> 國寶馬蘭所有權利。

3
00:00:12,830 --> 00:00:13,370
歡迎回來。

4
00:00:13,370 --> 00:00:16,510
這是CS50，這是
本週一，續。

5
00:00:16,510 --> 00:00:20,050
因此，我們已經通過的原因之一
圍繞技術，如

6
00:00:20,050 --> 00:00:24,120
谷歌玻璃是他們與
已知的東西作為一個API，

7
00:00:24,120 --> 00:00:25,980
應用程序編程接口。

8
00:00:25,980 --> 00:00:28,830
而這句話的意思是，隨著
正確的文件和用正確的

9
00:00:28,830 --> 00:00:32,850
文檔，你其實可以寫
甚至這樣的設備的軟件。

10
00:00:32,850 --> 00:00:36,200
>> 還等什麼，我們心裡有朝
學期結束，如果一個項目

11
00:00:36,200 --> 00:00:39,310
涉及，也就是說，谷歌的玻璃可能
上訴時，我們會看到我們能做些什麼

12
00:00:39,310 --> 00:00:42,220
掛鉤了一些
借用的硬件以及

13
00:00:42,220 --> 00:00:46,500
公開訪問的API，這樣就可以
真正開始建立軟件

14
00:00:46,500 --> 00:00:48,630
上運行的谷歌相同的玻璃。

15
00:00:48,630 --> 00:00:51,710
>> 另一個設備，我們已經打了
後期，我們認為可能是

16
00:00:51,710 --> 00:00:53,910
在學期結束的樂趣
這個小東西在這裡。

17
00:00:53,910 --> 00:00:56,860
這就是所謂的大躍進運動，你是什麼
看到在技術上是一個

18
00:00:56,860 --> 00:01:00,280
廣告設備，但它
不說這是什麼特別的

19
00:01:00,280 --> 00:01:01,240
設備的能力。

20
00:01:01,240 --> 00:01:05,550
，也配備了一個API通過
你可以寫軟件

21
00:01:05,550 --> 00:01:10,545
控制自己的電腦的方式
挺喜歡這個一分鐘的電影在這裡。

22
00:01:10,545 --> 00:01:12,070
>> [視頻回放]

23
00:01:12,070 --> 00:02:08,002

24
00:02:08,002 --> 00:02:08,590
>> [END視頻播放]

25
00:02:08,590 --> 00:02:11,190
>> 所以現在，該裝置發生
被實現為一個小的USB

26
00:02:11,190 --> 00:02:14,290
連接器，你可以插入到您的
電腦，但我不會感到驚訝，

27
00:02:14,290 --> 00:02:17,930
如果用不了多久，我們有這些類型的
在下一批次的PC技術

28
00:02:17,930 --> 00:02:20,510
和Mac電腦，這樣就可以，事實上，
與它交互

29
00:02:20,510 --> 00:02:21,650
這樣的一個方式。

30
00:02:21,650 --> 00:02:24,250
事實上，我想我會做，太，
我拉起一個小演示

31
00:02:24,250 --> 00:02:25,860
程序，用這個軟件。

32
00:02:25,860 --> 00:02:28,700
所以，我把小的傳感器
在我的筆記本電腦前。

33
00:02:28,700 --> 00:02:32,420
>> 你可以看到，它已經實現
我手中有

34
00:02:32,420 --> 00:02:33,400
控制它。

35
00:02:33,400 --> 00:02:37,900
而這一切的應用程序確實是
順順噹噹的小事情是這樣的。

36
00:02:37,900 --> 00:02:41,080
但是你可以看到，的確，
我有五個手指。

37
00:02:41,080 --> 00:02:44,270
如果我們可以得到它做的所有10個，
你能想像一個整潔的鋼琴

38
00:02:44,270 --> 00:02:45,390
應用程序或等。

39
00:02:45,390 --> 00:02:47,820
所以，如果你想下課
今天和發揮，作為

40
00:02:47,820 --> 00:02:49,720
好了，歡迎你。

41
00:02:49,720 --> 00:02:52,930
所以朝學期結束。

42
00:02:52,930 --> 00:02:54,420
>> 因此，一對夫婦的行政
公告。

43
00:02:54,420 --> 00:02:58,690
一，辦節這個星期五
中午在cs60.net/section。

44
00:02:58,690 --> 00:03:01,260
這個URL是在球場上的
主頁。

45
00:03:01,260 --> 00:03:04,010
雖然，在此期間，supersections
將亮相這個星期天。

46
00:03:04,010 --> 00:03:07,800
Supersections是一次性的事情，
因為它需要我們工作一段時間

47
00:03:07,800 --> 00:03:09,470
是誰在這部分和。

48
00:03:09,470 --> 00:03:12,280
>> 因此，這個星期天，將是一個
對於那些不舒服的部分，

49
00:03:12,280 --> 00:03:14,040
那些一節
更舒適。

50
00:03:14,040 --> 00:03:16,110
那些你在某處
之間，歡迎去

51
00:03:16,110 --> 00:03:17,850
其中一個或兩個或兩者都不是。

52
00:03:17,850 --> 00:03:19,150
這些都將被拍攝下來。

53
00:03:19,150 --> 00:03:22,740
他們將在一個較大的觀眾席比
通常會一節的。

54
00:03:22,740 --> 00:03:26,110
但是，這裡的目標是使你
一些安慰與問題設置，

55
00:03:26,110 --> 00:03:29,910
用C，與CS50設備中，這
週末，甚至在你發現你的

56
00:03:29,910 --> 00:03:31,050
正式部分分配。

57
00:03:31,050 --> 00:03:34,700
所以，你會滿足您的TF和較小
在大約sectionmates組

58
00:03:34,700 --> 00:03:36,350
一個星期的時間。

59
00:03:36,350 --> 00:03:38,200
>> 辦公時間，同時，
已經持續了。

60
00:03:38,200 --> 00:03:41,020
利用他們今晚或
明天晚上，如果你想。

61
00:03:41,020 --> 00:03:43,460
習題集0，是因為上週五。

62
00:03:43,460 --> 00:03:46,680
這一天遲
定期舉行的星期四。

63
00:03:46,680 --> 00:03:50,410
但問題集1，你會看到
它包括一些熱身

64
00:03:50,410 --> 00:03:52,770
演習你自己
可以擴展您的

65
00:03:52,770 --> 00:03:54,660
週四截止至星期五。

66
00:03:54,660 --> 00:03:58,410
習題集1，同時，將首次亮相
課程的網站上，這個未來

67
00:03:58,410 --> 00:04:02,000
週五，如果你想蜷縮著
它，因為我從前一段時間晚

68
00:04:02,000 --> 00:04:04,370
星期五晚上，在你的房間。

69
00:04:04,370 --> 00:04:07,660
>> 所以cs50.net/appliance的地方
你可以得到CS50家電

70
00:04:07,660 --> 00:04:09,040
上週一，我們開始使用。

71
00:04:09,040 --> 00:04:10,140
我們將使用它今天多一點。

72
00:04:10,140 --> 00:04:14,040
不過放心，問題設置1
規範將引導您完成

73
00:04:14,040 --> 00:04:16,490
正是你所需要的步驟
得到啟動和運行。

74
00:04:16,490 --> 00:04:22,120
所以不用擔心這樣做之前，
習題集1，如果你寧願不要。

75
00:04:22,120 --> 00:04:22,660
>> 好的。

76
00:04:22,660 --> 00:04:27,180
因此，我們期待在源代碼上週一，
但在一個新的上下文中

77
00:04:27,180 --> 00:04:30,895
編程語言，即C.和C，
不像划痕，是不是圖形。

78
00:04:30,895 --> 00:04:32,270
這不是拼圖碎片。

79
00:04:32,270 --> 00:04:34,450
它更類似英語的語法。

80
00:04:34,450 --> 00:04:37,140
有一對夫婦涉及的步驟
在實際編寫和運行

81
00:04:37,140 --> 00:04:41,650
在C程序問題，因為除了源
這樣的代碼，你需要的東西

82
00:04:41,650 --> 00:04:42,890
被稱為編譯器。

83
00:04:42,890 --> 00:04:46,682
通俗地說，是什麼
編譯器為我們做什麼？

84
00:04:46,682 --> 00:04:47,650
嗯。

85
00:04:47,650 --> 00:04:51,040
>> 學生：它的代碼轉換
你寫的0和1。

86
00:04:51,040 --> 00:04:51,151
>> 國寶馬蘭：好。

87
00:04:51,151 --> 00:04:53,580
因此，它的代碼轉換
我們寫0和1。

88
00:04:53,580 --> 00:04:57,730
所謂的源代碼轉換
目標代碼，其中後者看起來

89
00:04:57,730 --> 00:04:59,140
有點這樣的事情。

90
00:04:59,140 --> 00:05:02,860
這是你的CPU，大腦內部
你的電腦，因為

91
00:05:02,860 --> 00:05:06,280
誰創造了這些計算機的人，
知道這些序列

92
00:05:06,280 --> 00:05:07,460
0和1的平均值。

93
00:05:07,460 --> 00:05:08,640
>> 也許這意味著打印。

94
00:05:08,640 --> 00:05:10,265
也許這意味著除了。

95
00:05:10,265 --> 00:05:11,610
也許這意味著減法。

96
00:05:11,610 --> 00:05:13,350
也許這意味著顯示的圖形。

97
00:05:13,350 --> 00:05:16,870
有預定義的位模式
世界已經決定意味著

98
00:05:16,870 --> 00:05:17,700
某些事情。

99
00:05:17,700 --> 00:05:20,760
但是，在這個過程中，大部分
我們將繼續努力在一個更高的水平，

100
00:05:20,760 --> 00:05:24,180
我們會想當然地存在
比如編譯器，可以

101
00:05:24,180 --> 00:05:27,670
使我們的源代碼功能
在路上，我們的打算。

102
00:05:27,670 --> 00:05:31,660
>> 所以我們第一次寫程序上週
然後開始端口，從而達到

103
00:05:31,660 --> 00:05:33,920
說話，到C過去的這個
週一，是這樣的。

104
00:05:33,920 --> 00:05:35,700
當綠旗時，打招呼。

105
00:05:35,700 --> 00:05:37,430
這是，當然
從頭開始寫的。

106
00:05:37,430 --> 00:05:40,710
我聲稱，相當於
在C程序看起來有點

107
00:05:40,710 --> 00:05:41,520
這樣的事情。

108
00:05:41,520 --> 00:05:45,050
>> 所以，我一直以為我們起初做的是什麼，
讓我們梳理除了什麼樣子，在第一

109
00:05:45,050 --> 00:05:48,790
誠然，一目了然，相當神秘
語法，但你會開始注意到

110
00:05:48,790 --> 00:05:50,160
圖案相當快。

111
00:05:50,160 --> 00:05:53,770
今天我們還會做的是提供
你的心理模型對一些

112
00:05:53,770 --> 00:05:57,280
規範，一些標準結構
在編程。

113
00:05:57,280 --> 00:06:00,420
然後我們將實際拿到手
臟以及一些例子。

114
00:06:00,420 --> 00:06:04,140
>> 因此，對於那些你更舒適，
認識到這星期，然後下一個

115
00:06:04,140 --> 00:06:05,940
本週很可能是有點。

116
00:06:05,940 --> 00:06:08,810
但是，尤其是當黑客版
問題集1熄滅

117
00:06:08,810 --> 00:06:12,330
當然網站上週五，我認為
你會發現，即使你填寫

118
00:06:12,330 --> 00:06:15,390
在未來的兩個星期的一些空白，
你會開始得到越來越

119
00:06:15,390 --> 00:06:18,410
挑戰和遇到
新的，新的東西。

120
00:06:18,410 --> 00:06:21,310
>> 因此，讓我們逗這個程序除了
在一個時間的幾行。

121
00:06:21,310 --> 00:06:24,140
在最高層，我們有什麼
技術上稱為

122
00:06:24,140 --> 00:06:25,950
預處理指令。

123
00:06:25,950 --> 00:06:30,510
這僅僅是一個說的代碼行
包括一個文件的內容，

124
00:06:30,510 --> 00:06:35,080
稱為標準I / N標準輸入 - 
對不起，標準I / O標準

125
00:06:35,080 --> 00:06:38,670
輸入/輸出。小時，內部
我自己的計劃。

126
00:06:38,670 --> 00:06:41,670
>> 因此，換句話說，如果我寫了這
用一個簡單的文本編輯器如計劃

127
00:06:41,670 --> 00:06:45,260
gedit中，簡單的等同於
如Microsoft Word的東西，

128
00:06:45,260 --> 00:06:50,970
指令的＃include stdio.h中，僅僅​​是
要告訴編譯器，搶

129
00:06:50,970 --> 00:06:56,080
其他文件，stdio.h中的內容，
並將其粘貼在這裡。

130
00:06:56,080 --> 00:06:57,090
>> 現在，為什麼我照顧？

131
00:06:57,090 --> 00:07:01,850
什麼我們要求的是這個文件裡面
stdio.h中，這是存儲

132
00:07:01,850 --> 00:07:05,490
我的硬盤驅動器上的某個地方，或在這種
的情況下，在CS50家電某處？

133
00:07:05,490 --> 00:07:06,635
別人為我把它放在那裡。

134
00:07:06,635 --> 00:07:09,910
但是，什麼是它嗎？

135
00:07:09,910 --> 00:07:13,020
>> 是啊，所以這是一個宣言
一個函數調用printf的。

136
00:07:13,020 --> 00:07:17,400
因此我們知道printf回憶的功能
顯示單詞和字符，

137
00:07:17,400 --> 00:07:20,160
屏幕上的數字在我的招投標。

138
00:07:20,160 --> 00:07:21,220
但我沒有把它寫。

139
00:07:21,220 --> 00:07:22,230
CS50沒有把它寫。

140
00:07:22,230 --> 00:07:26,990
有人幾年前寫的，他們
基本上給了我們幾招吧

141
00:07:26,990 --> 00:07:29,110
在一個文件名為stdio.h中。

142
00:07:29,110 --> 00:07:33,240
所以，第一行只是給了我訪問
功能，別人

143
00:07:33,240 --> 00:07:36,500
幾年前寫的，其中
這是printf的。

144
00:07:36,500 --> 00:07:39,450
>> 現在，下一行，我要揮揮
手，至少要等到下週。

145
00:07:39,450 --> 00:07:43,620
但是現在，知道詮釋的主要（無效）
本質上相當於這

146
00:07:43,620 --> 00:07:46,310
黃色的一塊拼圖時，
綠旗點擊。

147
00:07:46,310 --> 00:07:49,510
這個世界，幾年前，決定，如果
你正在編寫一個程序

148
00:07:49,510 --> 00:07:53,150
語言稱為C，你開始
您的程序行

149
00:07:53,150 --> 00:07:54,410
看起來這樣。

150
00:07:54,410 --> 00:07:57,650
在短短的一個星期的時間，它會讓
感int是什麼，什麼是無效的。

151
00:07:57,650 --> 00:08:00,840
不過，現在才想起來
作為這個黃色的一塊拼圖。

152
00:08:00,840 --> 00:08:04,550
>> 現在未來，我們有一個大括號其次
另一個接近大括號，

153
00:08:04,550 --> 00:08:05,240
可以這麼說。

154
00:08:05,240 --> 00:08:07,430
我們將看到這些整個
C程序，以及

155
00:08:07,430 --> 00:08:08,930
JavaScript和PHP。

156
00:08:08,930 --> 00:08:11,345
而這些只是封裝
相關的代碼行。

157
00:08:11,345 --> 00:08:14,600
基本上是開放的大括號
說，這裡談到的一些代碼。

158
00:08:14,600 --> 00:08:17,590
而封閉的大括號，這是
成一定的角度放置，在另一個方向上，只需

159
00:08:17,590 --> 00:08:19,920
手段，它
相關的代碼。

160
00:08:19,920 --> 00:08:22,970
>> 所以在此先多汁線
程序是最後的printf

161
00:08:22,970 --> 00:08:25,080
報價引文結束，世界，你好。

162
00:08:25,080 --> 00:08:30,670
我叫之間的事情
引號什麼最後一次？

163
00:08:30,670 --> 00:08:31,285
因此，它是一個字符串。

164
00:08:31,285 --> 00:08:35,309
一個字符串就是技術人員的
一個序列的術語

165
00:08:35,309 --> 00:08:37,169
字，一個詞，一個短語。

166
00:08:37,169 --> 00:08:39,380
即使是一個單一的字母
用雙引號。

167
00:08:39,380 --> 00:08:41,840
但它是一個零序列
或多個字符。

168
00:08:41,840 --> 00:08:43,650
>> 反斜杠-N，雖然，看起來
有點怪。

169
00:08:43,650 --> 00:08:46,290
但它只是意味著什麼
簡單到計算機。

170
00:08:46,290 --> 00:08:48,060
反斜杠-N是什麼？

171
00:08:48,060 --> 00:08:48,570
新線。

172
00:08:48,570 --> 00:08:52,490
所以，這只是特殊序列
世界已經決定的字符

173
00:08:52,490 --> 00:08:56,880
手段在那裡，把換行符
因為編譯器實際上會得到

174
00:08:56,880 --> 00:09:02,280
困惑，通常情況下，如果你很
可以理解，但不正確，只是

175
00:09:02,280 --> 00:09:04,570
按下回車鍵把
新的生產線在你的代碼中。

176
00:09:04,570 --> 00:09:07,150
你需要多一點
明確用反斜杠-N。

177
00:09:07,150 --> 00:09:10,540
>> 我們會看到有等其他幾個
特殊字符的模式。

178
00:09:10,540 --> 00:09:14,340
例如，如果你想要讓你的
介意漂移到一個角落的情況下，

179
00:09:14,340 --> 00:09:18,080
假設，我想打印
在屏幕上的雙引號

180
00:09:18,080 --> 00:09:21,840
不管什麼原因，似乎
是一個小問題，正確的嗎？

181
00:09:21,840 --> 00:09:24,990
因為如果我把一個雙引號
“你好，世界的中間，”無論出於何種

182
00:09:24,990 --> 00:09:30,120
原因，為什麼，似乎
潛在的問題？

183
00:09:30,120 --> 00:09:32,180
它打破了字符串。

184
00:09:32,180 --> 00:09:34,700
>> 編譯器只是一個程序。

185
00:09:34,700 --> 00:09:37,210
像一個編譯器只是走一個程序
讀你的代碼從上到下，

186
00:09:37,210 --> 00:09:37,990
左到右。

187
00:09:37,990 --> 00:09:41,850
如果看到三雙引號，而不是
二，它是不會知道

188
00:09:41,850 --> 00:09:45,210
如果你的意思是左的東西
應該是字符串，或東西

189
00:09:45,210 --> 00:09:46,570
右，或整個事情。

190
00:09:46,570 --> 00:09:50,560
這是含糊的，所以是一個典型的
編譯器會做的只是嚇壞了，

191
00:09:50,560 --> 00:09:53,710
並給你一些錯誤信息，
讓你處理這個問題。

192
00:09:53,710 --> 00:09:58,120
>> 所以反斜杠n表示新
行，你會有什麼本能

193
00:09:58,120 --> 00:10:02,610
開始，如果你想包括
反常的東西像一個雙

194
00:10:02,610 --> 00:10:06,210
引用裡面的其他報價
字符串？

195
00:10:06,210 --> 00:10:07,640
反斜杠雙引號。

196
00:10:07,640 --> 00:10:09,630
因此，我們會看到這個
一種模式。

197
00:10:09,630 --> 00:10:12,490
>> 如果你想要做的東西一點點
奇怪了，你會發現，

198
00:10:12,490 --> 00:10:15,060
解決方案往往遵循一個模式，
反斜線

199
00:10:15,060 --> 00:10:17,150
表示一個轉義序列。

200
00:10:17,150 --> 00:10:20,320
它只是意味著一些特別的東西
我們需要在代表

201
00:10:20,320 --> 00:10:21,060
不同的方式。

202
00:10:21,060 --> 00:10:23,830
至於你怎麼代表
一個反斜杠，好了，我們會

203
00:10:23,830 --> 00:10:24,550
回來。

204
00:10:24,550 --> 00:10:26,930
但得到的答复，也實際上是
有點明顯。

205
00:10:26,930 --> 00:10:31,080
>> 現在讓我們介紹一些其他的
編程結構

206
00:10:31,080 --> 00:10:31,915
你看到划痕。

207
00:10:31,915 --> 00:10:34,790
您可能已經理所當然的
如果你已經已經潛入

208
00:10:34,790 --> 00:10:36,060
問題設置為0。

209
00:10:36,060 --> 00:10:40,950
但是，我們現在介紹的語法在C
這些原本相當直觀

210
00:10:40,950 --> 00:10:42,300
的想法，它們中的至少一些。

211
00:10:42,300 --> 00:10:45,570
>> 所以這個概念的條件或
的一個分支，而以前我們

212
00:10:45,570 --> 00:10:49,330
代表了它與代碼看起來
像這種划痕左邊 - 

213
00:10:49,330 --> 00:10:52,200
如果x小於y，然後這樣說 - 

214
00:10:52,200 --> 00:10:56,760
而現在在C  - 讓我磨練
在最簡單的情況下 - 

215
00:10:56,760 --> 00:11:01,235
我們只是說，如果打開
括號，什麼是真實的 - 

216
00:11:01,235 --> 00:11:04,190
布爾表達式是要去
我已經說過條件 - 

217
00:11:04,190 --> 00:11:08,170
密切括號，然後做什麼
那些大括號內。

218
00:11:08,170 --> 00:11:11,020
>> 所以在這裡，太，大括號
有點像划痕

219
00:11:11,020 --> 00:11:12,460
U形拼圖。

220
00:11:12,460 --> 00:11:14,890
做這些大括號內。

221
00:11:14,890 --> 00:11:16,790
在這種情況下，削減兇多吉少。

222
00:11:16,790 --> 00:11:19,720
並注意到這是向前
斜線，而不是一個反斜杠。

223
00:11:19,720 --> 00:11:21,440
斜杠，斜杠，
對於那些已經編程的人

224
00:11:21,440 --> 00:11:23,370
之前，只是意味著 - 

225
00:11:23,370 --> 00:11:24,190
它只是一個評論。

226
00:11:24,190 --> 00:11:26,630
註釋是不是一條線
代碼本身。

227
00:11:26,630 --> 00:11:30,200
這是一個說你，一行英文
人，寫自己

228
00:11:30,200 --> 00:11:33,540
也許是提醒你做某件事，
自己解釋，解釋

229
00:11:33,540 --> 00:11:35,260
別人，你的代碼是做什麼。

230
00:11:35,260 --> 00:11:37,050
這只是一個描述性的註釋。

231
00:11:37,050 --> 00:11:40,880
>> 現在，當然，我們可以有一個雙向的
岔路口，僅僅通過這樣做，

232
00:11:40,880 --> 00:11:43,930
三路岔路做
這一點，如果你繼續這樣

233
00:11:43,930 --> 00:11:47,570
模式，你可以有四種方式，
五，六岔路，如果

234
00:11:47,570 --> 00:11:50,150
的確，你需要處理，
有很多條件。

235
00:11:50,150 --> 00:11:52,010
然後請注意這裡的並行 - 

236
00:11:52,010 --> 00:11:55,070
if（條件），否則，如果（條件），
和只有一個，這是一個有點

237
00:11:55,070 --> 00:11:58,010
奇怪的是，最後，
只是別人。

238
00:11:58,010 --> 00:12:01,170
但是，這是相同的，
從概念上講，我們已經做了什麼

239
00:12:01,170 --> 00:12:04,690
已經，儘管語法
需要一點點時間來適應。

240
00:12:04,690 --> 00:12:07,730
>> 現在，在這個例子中，有
其他一些奇怪的語法。

241
00:12:07,730 --> 00:12:11,220
我們再次看到printf的，開放的括號，
和緊密括號。

242
00:12:11,220 --> 00:12:13,190
裡面有
帶引號的字符串。

243
00:12:13,190 --> 00:12:17,060
括號，在上下文中
printf的，在左邊

244
00:12:17,060 --> 00:12:18,160
和右是什麼？

245
00:12:18,160 --> 00:12:22,190
什麼我們描述報價
更普遍的字符串？

246
00:12:22,190 --> 00:12:23,320
>> 所以這是一個參數。

247
00:12:23,320 --> 00:12:26,620
任何時候你有一個函數，如
printf的，然後一個開放的括號和

248
00:12:26,620 --> 00:12:30,330
密切括號裡面的東西
它，無論它是一個字符串，或

249
00:12:30,330 --> 00:12:34,420
整數，或其他任何東西，這件事
那些括號之間被稱為

250
00:12:34,420 --> 00:12:35,110
的說法。

251
00:12:35,110 --> 00:12:37,910
>> 和參數只是影響
函數的行為。

252
00:12:37,910 --> 00:12:39,990
在這種情況下，這是很清楚。

253
00:12:39,990 --> 00:12:44,480
x <y是什麼被傳遞，
可以這麼說，作為一個參數。

254
00:12:44,480 --> 00:12:47,720
printf是要
打印正是這麼做的。

255
00:12:47,720 --> 00:12:51,590
因為可以肯定，這個人多年前
printf的實現有沒有想法

256
00:12:51,590 --> 00:12:55,000
我們人類的接班人
要使用printf。

257
00:12:55,000 --> 00:12:58,610
所以這就是為什麼論據存在，
後功能的影響行為

258
00:12:58,610 --> 00:12:59,450
被寫入。

259
00:12:59,450 --> 00:13:00,780
>> 現在，布林表達。

260
00:13:00,780 --> 00:13:02,470
我們已經看到了這些以前在划痕。

261
00:13:02,470 --> 00:13:06,680
事實證明，在C，你也可以“或”
它們放在一起，可以這麼說。

262
00:13:06,680 --> 00:13:10,930
兩條豎線意味著該塊
代碼，這樣做，

263
00:13:10,930 --> 00:13:15,350
如果執行的第一個條件是真實的
第二個條件是真實的。

264
00:13:15,350 --> 00:13:17,710
即使你可能沒有做
這划痕，確實可以

265
00:13:17,710 --> 00:13:20,580
做到這一點划痕，而且還可以
表達自己的不同 - 

266
00:13:20,580 --> 00:13:25,300
如果所述第一條件和第二
條件是真實的，那麼做

267
00:13:25,300 --> 00:13:27,160
花括號內。

268
00:13:27,160 --> 00:13:31,210
>> 就像不談，它的原因是
一個雙符號和雙

269
00:13:31,210 --> 00:13:34,610
豎線，我們最終會看到
一個單一的垂直酒吧和一個

270
00:13:34,610 --> 00:13:38,710
單一符號實際上有不同的
在C中的意思所以現在，

271
00:13:38,710 --> 00:13:41,840
那重複的符號
是故意的。

272
00:13:41,840 --> 00:13:45,070
>> 因此，讓我們的介紹，簡單地說，
此位語法。

273
00:13:45,070 --> 00:13:48,940
這並不完全結轉到
從頭開始，但我要求，我可以

274
00:13:48,940 --> 00:13:55,190
如果別人實現的概念，如果
別的，如果是別的，如果else語句使用

275
00:13:55,190 --> 00:13:56,760
一種叫做switch語句。

276
00:13:56,760 --> 00:14:00,820
唯一的原因，這確實存在
只是給你，程序員，

277
00:14:00,820 --> 00:14:05,470
稍微不同的方式解決一些
問題，儘管在邏輯上

278
00:14:05,470 --> 00:14:07,340
不給你任何新的功能。

279
00:14:07,340 --> 00:14:08,530
>> 我的意思是這一點。

280
00:14:08,530 --> 00:14:13,330
當你說開關，然後一個空格，
然後一對括號，裡面

281
00:14:13,330 --> 00:14:14,570
“表達 - 

282
00:14:14,570 --> 00:14:18,010
這可能是一個小非明顯
在第一，但是這不是一個參數，

283
00:14:18,010 --> 00:14:20,680
從技術上說，因為開關
不是一個函數。

284
00:14:20,680 --> 00:14:24,230
所以現在，假設我們正在使用
在不同的地方括號

285
00:14:24,230 --> 00:14:25,250
不同的原因。

286
00:14:25,250 --> 00:14:29,310
>> 因此，開關的表達意味著我可以
把一個變量裡面的那些

287
00:14:29,310 --> 00:14:31,350
如果說表達括號。

288
00:14:31,350 --> 00:14:33,090
然後，如果該變量 - 

289
00:14:33,090 --> 00:14:35,400
假設它被稱為X，
它僅僅是一個整數 - 

290
00:14:35,400 --> 00:14:38,900
然後我就可以在我的幻燈片列舉
在這裡，像這樣的東西。

291
00:14:38,900 --> 00:14:41,690
如果x是我的變量，我
想要做的事，如果x

292
00:14:41,690 --> 00:14:43,480
等於1，我可以做到這一點。

293
00:14:43,480 --> 00:14:46,660
>> 如果我不是想要做的事
如果x是2，我可以做到這一點。

294
00:14:46,660 --> 00:14:50,390
否則，如果我想做些別的事情
完全，我可以有一個默認的情況下，

295
00:14:50,390 --> 00:14:52,750
這種情況下，我這樣做其他的事情。

296
00:14:52,750 --> 00:14:58,730
因此，在這個意義上說，它是等效於一個
如果x等於等於1，否則，如果別的，

297
00:14:58,730 --> 00:15:01,150
但我提到這一點，現在只是因為
我們會再次看到它。

298
00:15:01,150 --> 00:15:03,720
但現在，只知道它的存在。

299
00:15:03,720 --> 00:15:04,220
>> 好的。

300
00:15:04,220 --> 00:15:07,660
因此，這些近一多一點
乍一看複雜，但他們

301
00:15:07,660 --> 00:15:09,385
相當簡單的東西。

302
00:15:09,385 --> 00:15:14,410
一個循環在C是一大塊的代碼，
少了點東西，

303
00:15:14,410 --> 00:15:15,330
一遍又一遍。

304
00:15:15,330 --> 00:15:17,590
唯一惱人的事情是
那就是它是一個有點神秘

305
00:15:17,590 --> 00:15:21,380
來表達自己的這種週期性
圖案，但世界標準化

306
00:15:21,380 --> 00:15:22,450
通過以下方式。

307
00:15:22,450 --> 00:15:25,760
>> 當你使用一個for循環，你已經有了
再次一對括號。

308
00:15:25,760 --> 00:15:27,570
並注意兩個分號
在那裡。

309
00:15:27,570 --> 00:15:34,380
那兩個分號分開三
內部的不同的表達式

310
00:15:34,380 --> 00:15:35,020
括號中。

311
00:15:35,020 --> 00:15:37,170
一種是所謂的初始化。

312
00:15:37,170 --> 00:15:38,830
一種是所謂的條件。

313
00:15:38,830 --> 00:15:40,210
一種是所謂的更新。

314
00:15:40,210 --> 00:15:43,240
>> 看著抽象，這是
完全非顯而易見的，所以讓我們來看看

315
00:15:43,240 --> 00:15:44,630
一個具體的例子。

316
00:15:44,630 --> 00:15:46,720
在划痕中，我們有一個重複塊。

317
00:15:46,720 --> 00:15:50,670
此塊說，重複10次，說
“你好，世界”。讓我索賠

318
00:15:50,670 --> 00:15:53,810
現在，我們會回來，和
這也將獲得更多的熟悉

319
00:15:53,810 --> 00:15:57,345
過不了多久，等價的C
代碼可以說是這樣的 - 

320
00:15:57,345 --> 00:16:02,320
一個聲明和一個空格，一個對
括號中的分號，注意

321
00:16:02,320 --> 00:16:05,730
有分開三個不同的
的東西，初始化

322
00:16:05,730 --> 00:16:07,320
條件，而更新。

323
00:16:07,320 --> 00:16:08,840
>> 並採取一種猜測是什麼
首先是做什麼。

324
00:16:08,840 --> 00:16:10,690
INT I = 0。

325
00:16:10,690 --> 00:16:15,120
粗糙通俗地說，是什麼
這樣做對我們來說，可能嗎？

326
00:16:15,120 --> 00:16:15,590
所以，是的。

327
00:16:15,590 --> 00:16:19,630
它聲明一個變量叫我，
它給什麼樣的價值？

328
00:16:19,630 --> 00:16:20,220
0。

329
00:16:20,220 --> 00:16:24,280
所以它創建一個變量
，存儲在它的值為0。

330
00:16:24,280 --> 00:16:26,420
這就是所謂的初始化。

331
00:16:26,420 --> 00:16:29,360
>> 好吧，我現在聲稱前
這中間的東西，我

332
00:16:29,360 --> 00:16:31,760
<10的條件。

333
00:16:31,760 --> 00:16:32,730
那麼，什麼是做什麼？

334
00:16:32,730 --> 00:16:36,560
那麼，什麼for循環做時，
一個for循環程序運行時，

335
00:16:36,560 --> 00:16:41,050
每次電腦貫穿
這個循環中，從頂部至底部，頂部

336
00:16:41,050 --> 00:16:43,740
底部，就像你們做的時候
計數自己坐了下來，

337
00:16:43,740 --> 00:16:47,090
一遍又一遍，
電腦是怎麼回事

338
00:16:47,090 --> 00:16:48,560
檢查條件。

339
00:16:48,560 --> 00:16:51,140
而且，如果i小於10，
它會再次這樣做。

340
00:16:51,140 --> 00:16:53,100
如果i小於10，
它會再次這樣做。

341
00:16:53,100 --> 00:16:55,030
如果我是小於10，
它會再次這樣做。

342
00:16:55,030 --> 00:16:57,330
所以，似乎表明
希望我改變。

343
00:16:57,330 --> 00:16:59,010
否則，我們就會有一個無限循環。

344
00:16:59,010 --> 00:17:02,590
事實上，我正在改變，因為
最後一件事，分號後有

345
00:17:02,590 --> 00:17:05,569
是略帶神秘的i + +的語法。

346
00:17:05,569 --> 00:17:07,630
但是那些你們誰已經這樣做
之前，這只是意味著

347
00:17:07,630 --> 00:17:08,609
很簡單，是什麼？

348
00:17:08,609 --> 00:17:09,730
>> 學生：[插入聲音]。

349
00:17:09,730 --> 00:17:10,740
>> DAVID馬蘭：加1到i。

350
00:17:10,740 --> 00:17:11,819
增加i。

351
00:17:11,819 --> 00:17:13,910
於是，我們看到了一個刮拼圖
一塊，實際上。

352
00:17:13,910 --> 00:17:18,230
它看起來並不像我+ +，但只是
手段很簡單，遞增

353
00:17:18,230 --> 00:17:24,040
1的價值，我每一次這樣做。

354
00:17:24,040 --> 00:17:26,910
所以，從字面上看，你開始
初始化i來0。

355
00:17:26,910 --> 00:17:29,520
然後，您可以檢查你的病情。

356
00:17:29,520 --> 00:17:31,070
0小於10？

357
00:17:31,070 --> 00:17:31,730
是。

358
00:17:31,730 --> 00:17:32,910
我們經過循環。

359
00:17:32,910 --> 00:17:35,150
>> 接下來的事情，我要求電腦的
要做的是它會

360
00:17:35,150 --> 00:17:35,910
增加i。

361
00:17:35,910 --> 00:17:37,080
所以，我現在是1。

362
00:17:37,080 --> 00:17:37,940
檢查條件。

363
00:17:37,940 --> 00:17:39,290
是不到10 1？

364
00:17:39,290 --> 00:17:39,930
當然。

365
00:17:39,930 --> 00:17:41,030
所以做了一遍。

366
00:17:41,030 --> 00:17:43,580
然後，它遞增i + 2。

367
00:17:43,580 --> 00:17:44,610
2小於10？

368
00:17:44,610 --> 00:17:45,230
是。

369
00:17:45,230 --> 00:17:46,670
一遍又一遍。

370
00:17:46,670 --> 00:17:50,070
最終，由於
加plussing的，我們得到i等於10。

371
00:17:50,070 --> 00:17:51,675
10小於10？

372
00:17:51,675 --> 00:17:52,990
嗯，顯然不是。

373
00:17:52,990 --> 00:17:55,320
這就是在哪個點
for循環停止。

374
00:17:55,320 --> 00:17:58,320
如果你有更多的代碼
屏幕下，電腦

375
00:17:58,320 --> 00:18:01,620
運行該代碼，而不是收益。

376
00:18:01,620 --> 00:18:05,380
>> 如此反复，即使這將
外觀和感覺有點怪

377
00:18:05,380 --> 00:18:07,830
第一，當然對於那些你誰
從來沒有編程之前，

378
00:18:07,830 --> 00:18:11,640
從字面上減少概念
否則一個非常

379
00:18:11,640 --> 00:18:14,330
簡單的拼圖
刮片。

380
00:18:14,330 --> 00:18:19,130
>> 好吧，我答應了，有好多
其他類似物從無到有。

381
00:18:19,130 --> 00:18:20,060
有這一個了。

382
00:18:20,060 --> 00:18:21,700
我們看到了這短暫的最後一次。

383
00:18:21,700 --> 00:18:23,530
但要記住永遠
從頭阻止？

384
00:18:23,530 --> 00:18:25,490
它只是做一些事情永遠不會消失？

385
00:18:25,490 --> 00:18:27,470
我要求，你可以實現
此以這種方式。

386
00:18:27,470 --> 00:18:29,740
實際上，你可以實現這個
在一堆不同的方式。

387
00:18:29,740 --> 00:18:34,260
>> 但在while循環不同的僅僅是
在C的方式表達自己。

388
00:18:34,260 --> 00:18:37,080
在一天結束的時候，你不能這樣做
任何一個while循環

389
00:18:37,080 --> 00:18:38,360
不能用一個for循環。

390
00:18:38,360 --> 00:18:41,430
因此，他們在結束的
天功能上是相同的。

391
00:18:41,430 --> 00:18:43,840
但它可以讓你表達自己
有點不同於

392
00:18:43,840 --> 00:18:44,850
通過以下方式。

393
00:18:44,850 --> 00:18:49,720
>> while循環，這是什麼在
括號檢查了一遍，

394
00:18:49,720 --> 00:18:51,050
一遍又一遍。

395
00:18:51,050 --> 00:18:55,100
只要該表達式為假，
然後循環停止執行，

396
00:18:55,100 --> 00:18:57,890
和計算機進到
運行任何其他代碼

397
00:18:57,890 --> 00:18:59,230
有您的文件。

398
00:18:59,230 --> 00:19:02,180
>> 但是，什麼是有趣的
我簡直輸入真。

399
00:19:02,180 --> 00:19:06,680
和真正的是一種類型的布爾值，
真或假的值。

400
00:19:06,680 --> 00:19:09,750
所以真正成為過
假的，如果我從字面上

401
00:19:09,750 --> 00:19:11,970
硬編碼到我的程序嗎？

402
00:19:11,970 --> 00:19:12,470
因此，沒有。

403
00:19:12,470 --> 00:19:13,730
這是一個有些奇怪的是，我這樣做。

404
00:19:13,730 --> 00:19:15,190
但是，真正的是真實的。

405
00:19:15,190 --> 00:19:16,320
有沒有加plussing。

406
00:19:16,320 --> 00:19:17,820
有沒有用在這裡的變量。

407
00:19:17,820 --> 00:19:22,740
所以，因為我硬編碼，而真實的，這
循環總是要評估的

408
00:19:22,740 --> 00:19:24,090
一遍又一遍。

409
00:19:24,090 --> 00:19:27,660
>> 所以多少次“世界，你好
要打印在屏幕上？

410
00:19:27,660 --> 00:19:28,170
永遠。

411
00:19:28,170 --> 00:19:31,980
次，直到無限數量的
電池模具或其他一些外部

412
00:19:31,980 --> 00:19:32,730
事件發生。

413
00:19:32,730 --> 00:19:35,880
所以這可能不是最好的方案
寫的，因為如果用戶

414
00:19:35,880 --> 00:19:38,660
永遠不能放棄你的程序，這是
可能不是你所希望的。

415
00:19:38,660 --> 00:19:41,070
>> 但有時，程序應該
有一個無限循環。

416
00:19:41,070 --> 00:19:44,050
例如，如果您的電腦有
時鐘就可以了，它肯定會

417
00:19:44,050 --> 00:19:48,130
不錯，如果你的時鐘不斷更新
本身永遠，儘管一次

418
00:19:48,130 --> 00:19:50,500
第二次或一次一分鐘
類似的東西。

419
00:19:50,500 --> 00:19:53,690
因此，即使無限循環
的確有其地位。

420
00:19:53,690 --> 00:19:54,360
>> 好的。

421
00:19:54,360 --> 00:19:55,190
最後，這一個。

422
00:19:55,190 --> 00:19:57,770
而這一次有點不同
功能，我們會回來到

423
00:19:57,770 --> 00:19:59,460
這大概Pset中1。

424
00:19:59,460 --> 00:20:02,370
但還有另一種類型的循環
稱為do while循環。

425
00:20:02,370 --> 00:20:07,100
而之間唯一的區別就在這裡
while循環，也就是說，一個while循環，

426
00:20:07,100 --> 00:20:11,120
是，檢查條件的不
之前執行的代碼，但後

427
00:20:11,120 --> 00:20:12,080
你執行的代碼。

428
00:20:12,080 --> 00:20:15,380
因此，在最上方的一段時間
循環，而做的，而

429
00:20:15,380 --> 00:20:16,560
檢查它的底部。

430
00:20:16,560 --> 00:20:21,370
>> 而這只是意味著，在while循環
通常會執行多次

431
00:20:21,370 --> 00:20:24,630
或更少的時間比一個while循環？

432
00:20:24,630 --> 00:20:30,810
可能需要更多的時間，因為一做
而循環顯然是說這樣做，

433
00:20:30,810 --> 00:20:34,600
其中後，才點你檢查
如果條件裡面的

434
00:20:34,600 --> 00:20:35,980
括號中是真實的。

435
00:20:35,980 --> 00:20:37,940
>> 因此，我們將再次看到這
大概在習題集1。

436
00:20:37,940 --> 00:20:41,150
如果你想要做的事在
至少一次，那麼也許更多一些

437
00:20:41,150 --> 00:20:43,350
倍，這是一個很好的
構建使用。

438
00:20:43,350 --> 00:20:46,970
但一個while循環，與此相反，將
首先檢查其狀況。

439
00:20:46,970 --> 00:20:50,660
這就是它在C循環，
同時，while和for循環。

440
00:20:50,660 --> 00:20:54,700
再次，它們映射相當好聽回
從無到有，除了這一個不

441
00:20:54,700 --> 00:20:57,350
相同的模擬相當有划痕。

442
00:20:57,350 --> 00:20:58,880
>> 那麼，怎麼樣，現在，變量？

443
00:20:58,880 --> 00:21:02,600
所以，這是怎麼了，我聲明了一個變量
語法的一天。

444
00:21:02,600 --> 00:21:06,440
我有一個int，我認領
是一個整數。

445
00:21:06,440 --> 00:21:09,690
然後，我有一個變量稱為計數器，
然後一個分號。

446
00:21:09,690 --> 00:21:11,070
那麼，什麼是做這行代碼？

447
00:21:11,070 --> 00:21:14,540
這是很簡單，宣告
一個變量 - 

448
00:21:14,540 --> 00:21:17,940
即，要求計算機，給我
一些內存，給我點位 - 

449
00:21:17,940 --> 00:21:19,450
我可以存儲是什麼？

450
00:21:19,450 --> 00:21:20,300
一個int。

451
00:21:20,300 --> 00:21:23,570
和分號只是意味著
代碼行結束。

452
00:21:23,570 --> 00:21:25,500
>> 現在，第二行是可能
相當猜測的。

453
00:21:25,500 --> 00:21:29,710
什麼是反= 0;在做什麼？

454
00:21:29,710 --> 00:21:31,690
它的分配0反擊。

455
00:21:31,690 --> 00:21:33,470
所以這是另外一件事
這是一個有點惱人

456
00:21:33,470 --> 00:21:34,540
銀兩，說，代數。

457
00:21:34,540 --> 00:21:39,110
而在代數中，等號意味著
，在這裡等於C，等於

458
00:21:39,110 --> 00:21:40,470
標誌意味著分配。

459
00:21:40,470 --> 00:21:45,380
因此，這意味著在右邊放什麼
成什麼在左邊。

460
00:21:45,380 --> 00:21:49,030
我們將看到另一種象徵，等於
等於，當我們要實際測試

461
00:21:49,030 --> 00:21:50,570
質量，有些煩人。

462
00:21:50,570 --> 00:21:52,590
>> 但是，這是一個有點低效。

463
00:21:52,590 --> 00:21:55,090
這是一種煩人的，我有
聲明一個變量並

464
00:21:55,090 --> 00:21:56,110
然後給它一個值。

465
00:21:56,110 --> 00:21:59,380
所以C實際上讓我們簡化這
只是做一次全部。

466
00:21:59,380 --> 00:22:01,330
你可以聲明變量
在左邊。

467
00:22:01,330 --> 00:22:04,590
您仍然可以在做作業
把那個等號權

468
00:22:04,590 --> 00:22:05,030
中間。

469
00:22:05,030 --> 00:22:08,740
因此，在一天結束時，這兩個
相當於，但是這一次，坦率地說，

470
00:22:08,740 --> 00:22:11,840
可能是更好的習慣進入
只是因為它是有點少

471
00:22:11,840 --> 00:22:15,040
代碼，這是一個有點容易閱讀，
它只是收緊

472
00:22:15,040 --> 00:22:17,470
你的代碼，可以這麼說。

473
00:22:17,470 --> 00:22:22,120
>> 有任何疑問迄今循環，
變量，條件，

474
00:22:22,120 --> 00:22:27,001
布爾值，無論是從技術上
或概念呢？

475
00:22:27,001 --> 00:22:28,010
好的。

476
00:22:28,010 --> 00:22:30,690
所以，現在這個下一個得到
更有趣一點。

477
00:22:30,690 --> 00:22:34,790
這是例子我把去年
時間，只是一個划痕的例子映射

478
00:22:34,790 --> 00:22:35,820
超過三

479
00:22:35,820 --> 00:22:36,580
>> 因此，一個函數。

480
00:22:36,580 --> 00:22:38,110
通俗地說，有什麼功能？

481
00:22:38,110 --> 00:22:42,900

482
00:22:42,900 --> 00:22:44,350
得到了大膽的與你的答案。

483
00:22:44,350 --> 00:22:45,020
有什麼功能？

484
00:22:45,020 --> 00:22:46,320
>> 學生：請問東西。

485
00:22:46,320 --> 00:22:46,780
>> DAVID馬蘭：那是什麼？

486
00:22:46,780 --> 00:22:48,000
>> 學生：請問東西。

487
00:22:48,000 --> 00:22:48,710
>> 國寶MALAN：有些事情。

488
00:22:48,710 --> 00:22:49,000
確定。

489
00:22:49,000 --> 00:22:49,590
我們就從這裡開始。

490
00:22:49,590 --> 00:22:51,270
因此，一個功能做一些事情。

491
00:22:51,270 --> 00:22:55,160
所以這是一塊代碼
基本上其他地方實施

492
00:22:55,160 --> 00:22:56,620
的確東西。

493
00:22:56,620 --> 00:23:00,180
現在，有什麼有趣的功能
是，它可以採用輸入，

494
00:23:00,180 --> 00:23:02,710
，並且可以產生輸出。

495
00:23:02,710 --> 00:23:05,090
，讓我們採取實際
看看這個。

496
00:23:05,090 --> 00:23:09,030
>> 因此，該名男子背後的窗簾
剛才是故意的。

497
00:23:09,030 --> 00:23:10,320
在這裡，我們有一個表。

498
00:23:10,320 --> 00:23:13,010
但是，假如這實際上
代表一個大箱子。

499
00:23:13,010 --> 00:23:14,940
所以這是一個所謂的黑盒。

500
00:23:14,940 --> 00:23:19,800
而在一般情況下，在設計上，在計算機
科學，黑盒只是參考

501
00:23:19,800 --> 00:23:22,510
件的功能，有人
已經落實，你不這樣做

502
00:23:22,510 --> 00:23:26,140
不一定知道或不關心它是如何
引擎蓋下實施。

503
00:23:26,140 --> 00:23:28,960
你只關心這個黑盒子，
現在我們將開始調用

504
00:23:28,960 --> 00:23:30,730
功能，做一些事情。

505
00:23:30,730 --> 00:23:34,710
>> 所以，舉例來說，如果這個黑色的框
這裡的舞台printf的代表，

506
00:23:34,710 --> 00:23:38,040
功能，我知道，從前面的例子
printf的需要的一個或多個

507
00:23:38,040 --> 00:23:40,910
參數，並在最前面的那
論點應該是一個字符串，如

508
00:23:40,910 --> 00:23:44,780
“你好，世界”。好吧，如果我這個人
編寫程序，我想

509
00:23:44,780 --> 00:23:50,460
用printf，以我來說，不妨
這裡需要一張白紙和一個

510
00:23:50,460 --> 00:23:55,060
黑色標記，並寫上 - 

511
00:23:55,060 --> 00:23:56,580
我拼錯了“世界” - 

512
00:23:56,580 --> 00:23:59,560
H-E-L-L-O。

513
00:23:59,560 --> 00:24:04,220
>> 所以，我帶你去我的黑色標記，我會
寫的，又大又清楚，我可以

514
00:24:04,220 --> 00:24:07,260
這張紙，“你好，世界”
現在我要求，這是我的觀點。

515
00:24:07,260 --> 00:24:09,740
這是一個字符串，代表
一塊白紙。

516
00:24:09,740 --> 00:24:13,030
和我現在輸入功能
printf是會是這樣。

517
00:24:13,030 --> 00:24:18,250
所以我調用printf，路過
這樣的說法作為它的輸入。

518
00:24:18,250 --> 00:24:22,110

519
00:24:22,110 --> 00:24:26,740
>> 而現在，我不知道怎樣的人誰
寫到printf的做了幾年前，但

520
00:24:26,740 --> 00:24:31,110
我知道其文檔
在生活中，其目的是打印我

521
00:24:31,110 --> 00:24:34,410
作為輸入提供給它。

522
00:24:34,410 --> 00:24:40,630
於是，儘管本實施
我並不知道

523
00:24:40,630 --> 00:24:44,170
引擎蓋下，現在
哦，我明白了，是做。

524
00:24:44,170 --> 00:24:45,740
印刷的東西
在屏幕上。

525
00:24:45,740 --> 00:24:49,070
和控制的程序，如果有
多行代碼，

526
00:24:49,070 --> 00:24:51,070
現在已經歸還給我。

527
00:24:51,070 --> 00:24:52,290
等的事實，科爾頓 - 

528
00:24:52,290 --> 00:24:55,370
保佑他的心，躲在這裡，
一個表在大家面前 - 

529
00:24:55,370 --> 00:24:59,530
是故意的，我不知道
我不在乎的printf

530
00:24:59,530 --> 00:25:00,100
實施。

531
00:25:00,100 --> 00:25:03,390
我只知道，再從它的
文檔，它做什麼，我怎麼

532
00:25:03,390 --> 00:25:05,040
我應該使用它。

533
00:25:05,040 --> 00:25:09,140
>> 現在，記得printf的能拿
更複雜一點。

534
00:25:09,140 --> 00:25:12,220
同樣，我們只是在談論
相當於划痕的言論塊。

535
00:25:12,220 --> 00:25:14,230
但我也做了這最後的時間。

536
00:25:14,230 --> 00:25:17,270
我想，以我的hello程序一
更加動感一點，不只是硬

537
00:25:17,270 --> 00:25:19,740
代碼的東西，如“世界”
絕對不是硬代碼的東西

538
00:25:19,740 --> 00:25:22,520
任意像D-A-V-I-D
到程序中。

539
00:25:22,520 --> 00:25:27,510
我想問問他或她的用戶
名稱，然後做一些與

540
00:25:27,510 --> 00:25:29,720
該字符串，他們提供的。

541
00:25:29,720 --> 00:25:32,690
>> 因此，有一點不同的東西
在這裡。 printf的，剛才，

542
00:25:32,690 --> 00:25:35,860
確實，做一些事情，但它
不返回任何東西給我。

543
00:25:35,860 --> 00:25:36,020
對嗎？

544
00:25:36,020 --> 00:25:38,910
科爾頓沒有手我什麼
回，沒有一張紙。

545
00:25:38,910 --> 00:25:40,320
只是有一個副作用。

546
00:25:40,320 --> 00:25:44,510
我提供的“你好，世界”為
參數科爾頓導致

547
00:25:44,510 --> 00:25:48,420
副作用的詞語，一些詞語，
出現在屏幕上。

548
00:25:48,420 --> 00:25:51,350
>> GetString的，雖然是一點點
不同的。 GetString的也是一個

549
00:25:51,350 --> 00:25:54,590
功能，但它會返回一些值。

550
00:25:54,590 --> 00:25:56,370
它不只是有一個
審美的副作用。

551
00:25:56,370 --> 00:26:00,230
實際上，它給我的人
打電話或使用的功能，

552
00:26:00,230 --> 00:26:01,320
東西回來。

553
00:26:01,320 --> 00:26:05,740
因此，在這種情況下是，GetString
調用GetString的開放

554
00:26:05,740 --> 00:26:07,510
括號，括號密切。

555
00:26:07,510 --> 00:26:11,370
是否GetString的，因此，應採取
任何參數或輸入？

556
00:26:11,370 --> 00:26:12,340
不，它似乎沒有。

557
00:26:12,340 --> 00:26:14,460
其目的在生活中是
只是為了得到一個字符串。

558
00:26:14,460 --> 00:26:16,910
它需要比沒有更多的細節。

559
00:26:16,910 --> 00:26:20,430
因此，讓我去，假裝，
再次，這個黑盒子是不是printf的，

560
00:26:20,430 --> 00:26:25,160
但GetString的，讓我，人
寫這個程序，調用或使用

561
00:26:25,160 --> 00:26:29,720
只是寫的GetString
G-E-T-S-T-R-I-N-G，開括號，靠近

562
00:26:29,720 --> 00:26:32,170
括號是，GetString。

563
00:26:32,170 --> 00:26:36,920
>> 現在，我不知道如何CS50員工
實施GetString的，但我知道，

564
00:26:36,920 --> 00:26:41,240
如果我等待足夠長的時間，它會做
引擎蓋下的東西，也許使用

565
00:26:41,240 --> 00:26:44,940
一些變量，可能使用一些
條件下，可能使用一些循環，

566
00:26:44,940 --> 00:26:48,170
也許使用某些功能，
也許使用 - 

567
00:26:48,170 --> 00:26:52,290
只是想擺攤 - 也許使用
其他一些編程功能。

568
00:26:52,290 --> 00:26:55,350
但是，如果我等待足夠長的時間 - 在現實中，
在計算機中，發生這種情況

569
00:26:55,350 --> 00:26:56,270
超級快 - 

570
00:26:56,270 --> 00:26:59,910
如果我等待足夠長的時間，這個功能
，GetString的是要得到一個字符串

571
00:26:59,910 --> 00:27:04,060
來自用戶的，大概鍵入
鍵盤上，

572
00:27:04,060 --> 00:27:08,090
然後，當你的GetString越來越
從用戶的那些字符

573
00:27:08,090 --> 00:27:14,080
並將其存儲到一個字符串，
功能是，GetString，將不得不

574
00:27:14,080 --> 00:27:17,990
一些輸出，我為我準備好
要檢索的方式

575
00:27:17,990 --> 00:27:19,470
賦值運算符。

576
00:27:19,470 --> 00:27:25,390
>> 如果我去的，的確，到輸出
在這裡，Obosi慷慨

577
00:27:25,390 --> 00:27:29,900
參加了，不知道這個
前進，他的名字寫入到這個

578
00:27:29,900 --> 00:27:33,100
變量，它是代表
一個字符串。

579
00:27:33,100 --> 00:27:35,640
現在，賦值運算符表示，即使
雖然這可能會感到有點

580
00:27:35,640 --> 00:27:38,790
多餘的，其實，我做的需要
讓我自己的副本。

581
00:27:38,790 --> 00:27:40,700
由於在左手
側 - 哎呦！ - 

582
00:27:40,700 --> 00:27:45,760
注意到，我基本上有字符串
命名左側。

583
00:27:45,760 --> 00:27:48,280
所以，我也要去
我自己的副本。

584
00:27:48,280 --> 00:27:50,990
這是一個有點白色的謊言，
因為我們會看到一兩個星期的

585
00:27:50,990 --> 00:27:54,100
時間的字符串實際上是不
他們似乎是什麼。

586
00:27:54,100 --> 00:27:56,700
>> 但現在，這裡的返回值。

587
00:27:56,700 --> 00:28:00,160
這裡是我自己的副本後
使用賦值運算符。

588
00:28:00,160 --> 00:28:01,790
而現在，我想下一步要做？

589
00:28:01,790 --> 00:28:04,080
我們現在有第二個
兩行代碼。

590
00:28:04,080 --> 00:28:05,640
所以我現在要調用printf。

591
00:28:05,640 --> 00:28:08,500
讓我們假裝現在，黑
框又回來了被

592
00:28:08,500 --> 00:28:10,210
printf和GetString的。

593
00:28:10,210 --> 00:28:12,200
>> printf的這段時間要
拿多少個參數？

594
00:28:12,200 --> 00:28:14,890

595
00:28:14,890 --> 00:28:16,770
所以，看起來，它就像兩個。

596
00:28:16,770 --> 00:28:18,860
有兩個逗號，在那裡，但
那些逗號，它是

597
00:28:18,860 --> 00:28:20,220
裡面的引號。

598
00:28:20,220 --> 00:28:23,190
所以第一個參數是從字面上
是這樣的。

599
00:28:23,190 --> 00:28:31,850
H-E-L-L-O，逗號％
，反斜杠-N。

600
00:28:31,850 --> 00:28:36,560
現在我提供一個參數，
但兩個參數的printf。

601
00:28:36,560 --> 00:28:39,530
>> 什麼樣的printf應該做的
這兩個輸入後，我把它們放入

602
00:28:39,530 --> 00:28:42,050
作為參數？

603
00:28:42,050 --> 00:28:45,360
它應該採取的第二個
他們，我把它叫做名稱，所以

604
00:28:45,360 --> 00:28:48,660
我寫了第二張紙
剛才叫名字。

605
00:28:48,660 --> 00:28:53,550
這將插頭裡面的值
該變量到佔位符，

606
00:28:53,550 --> 00:28:58,310
％s，因此，只是一瞬間
時間的推移，我們將看到一個副作用

607
00:28:58,310 --> 00:29:04,180
printf的調用，而現在我們
見不是“你好，世界”，但“你好，

608
00:29:04,180 --> 00:29:04,710
obosi“。

609
00:29:04,710 --> 00:29:08,730
>> 所以兩個又大又圓的掌聲
我們的志願者，只有一個人知道

610
00:29:08,730 --> 00:29:12,010
這將發生。

611
00:29:12,010 --> 00:29:12,990
好的。

612
00:29:12,990 --> 00:29:16,480
所以，也許，因為這是簡單的，
當然，如果你已經熟悉

613
00:29:16,480 --> 00:29:20,190
這樣的，希望你永遠不會
如何忘記，尤其是視覺

614
00:29:20,190 --> 00:29:21,220
功能的工作。

615
00:29:21,220 --> 00:29:23,000
>> 所以有更多的不僅僅是GetString的。

616
00:29:23,000 --> 00:29:26,020
CS50庫裡面，有一個
一大堆的功能，所有這一切

617
00:29:26,020 --> 00:29:29,510
只是做出明確予以資本化
我們寫了這些功能。

618
00:29:29,510 --> 00:29:33,610
通常情況下，在C中，幾乎每一個其他
你會使用的功能是小寫。

619
00:29:33,610 --> 00:29:36,190
但是，我們特意使用大寫字母
顯然，這些只是為了讓

620
00:29:36,190 --> 00:29:39,880
是，我們將各種訓練車輪
用短短的幾個星期，

621
00:29:39,880 --> 00:29:42,890
簡化的過程中獲得
來自用戶的輸入。

622
00:29:42,890 --> 00:29:46,740
>> CS50庫不會做任何事情
你們不能做

623
00:29:46,740 --> 00:29:50,230
只是從使用C代碼
老校友教材。

624
00:29:50,230 --> 00:29:53,310
但是，再次，我們使用它們作為訓練
只是一對夫婦的各種車輪

625
00:29:53,310 --> 00:29:57,250
，週這樣我們就可以擺脫了
複雜性，你很快就會明白

626
00:29:57,250 --> 00:30:00,460
自己做的事情為
相對越來越簡單

627
00:30:00,460 --> 00:30:02,080
來自用戶的輸入。

628
00:30:02,080 --> 00:30:05,540
>> 所以，知道你將有機會獲得
的GETCHAR，GetDouble  - 

629
00:30:05,540 --> 00:30:06,050
翻一番。

630
00:30:06,050 --> 00:30:07,050
的消閒節目 - 然後getFloat先把。

631
00:30:07,050 --> 00:30:07,600
什麼是浮動？

632
00:30:07,600 --> 00:30:09,382
我們從這裡開始。

633
00:30:09,382 --> 00:30:10,600
>> 學生：[聽不清]。

634
00:30:10,600 --> 00:30:10,790
>> DAVID馬蘭：是啊。

635
00:30:10,790 --> 00:30:12,120
這是一個帶小數點。

636
00:30:12,120 --> 00:30:15,930
因此，而一個int是一個整數，該
僅僅是一個數字0到9，

637
00:30:15,930 --> 00:30:18,940
一些重複的次數，其
是一個浮動

638
00:30:18,940 --> 00:30:20,100
小數點。

639
00:30:20,100 --> 00:30:26,090
雙，同時，也是一個
一些帶有小數點，但更

640
00:30:26,090 --> 00:30:28,160
小數點後的數字
點，有可能。

641
00:30:28,160 --> 00:30:30,040
>> 所以我們會得到回此之前長。

642
00:30:30,040 --> 00:30:34,560
但通常情況下，這些類型的
數據，這些類型的變量

643
00:30:34,560 --> 00:30:39,380
像我們這樣的一個庫，可以返回到
你，用不同數量的位

644
00:30:39,380 --> 00:30:40,290
存儲信息。

645
00:30:40,290 --> 00:30:43,910
通常情況下，煤焦，這只是意味著
一個字符，使用8位。

646
00:30:43,910 --> 00:30:47,490
這實際上是符合我們
字節志願者上週

647
00:30:47,490 --> 00:30:50,410
走上前來，代表一
ASCII字符的時間。

648
00:30:50,410 --> 00:30:51,850
因此char是8位。

649
00:30:51,850 --> 00:30:54,430
>> 一個浮動的恰好是
，通常為32位。

650
00:30:54,430 --> 00:30:59,230
和雙，您可能已經猜到，是
實際上是64位，這是只是更多的，

651
00:30:59,230 --> 00:31:01,360
這意味著你可以有更大的
數字或更精確。

652
00:31:01,360 --> 00:31:03,000
但同樣，在另一個時間。

653
00:31:03,000 --> 00:31:06,550
GetLongLong，同時，雖然愚蠢
而得名，是真的只是一個

654
00:31:06,550 --> 00:31:10,770
整數的兩倍大，兩倍
長，潛在的，作為一個普通的

655
00:31:10,770 --> 00:31:12,940
整數，64位，而不是32。

656
00:31:12,940 --> 00:31:14,560
和GetString我們一直在使用。

657
00:31:14,560 --> 00:31:18,870
>> 但事實證明，在CS50庫，
這是實施，正如我們所看到的，在

658
00:31:18,870 --> 00:31:23,560
這兩個文件的形式，其中一個
被稱為cs50.h，還有兩個

659
00:31:23,560 --> 00:31:24,770
在它的數據類型。

660
00:31:24,770 --> 00:31:29,700
C.您可以布爾值中不存在
模擬他們只是用0和1

661
00:31:29,700 --> 00:31:30,850
整個節目。

662
00:31:30,850 --> 00:31:35,500
但是，我們在創建CS50庫
符號“真”和“假”

663
00:31:35,500 --> 00:31:38,580
代表1和0讓你不
有硬編碼的東西

664
00:31:38,580 --> 00:31:39,810
從字面上像1和0。

665
00:31:39,810 --> 00:31:40,980
但是，我們將再次看到那些。

666
00:31:40,980 --> 00:31:42,330
>> 的字符串，也不存在。

667
00:31:42,330 --> 00:31:44,520
這就是為什麼我提到這是
一點點善意的謊言現在。

668
00:31:44,520 --> 00:31:46,660
但我們會剝開，
沒過多久層。

669
00:31:46,660 --> 00:31:49,540
但現在，一個字符串是一個
字符序列。

670
00:31:49,540 --> 00:31:51,790
>> 同時，在C，你確實
有不同的數據類型。

671
00:31:51,790 --> 00:31:53,200
請注意這些都是小寫的。

672
00:31:53,200 --> 00:31:56,960
所以的功能，你剛才也看到了
CS50，寫的函數

673
00:31:56,960 --> 00:32:02,310
你將返回到值下降
到這些類別之一。

674
00:32:02,310 --> 00:32:06,730
>> 一對夫婦小抄只是種植
這裡的種子。 printf的不只是

675
00:32:06,730 --> 00:32:08,600
％S用作佔位符。

676
00:32:08,600 --> 00:32:13,490
％d為十進制整數，
或％，我會正常工作。

677
00:32:13,490 --> 00:32:19,450
％f是浮點值。 ％c是
一個字符，如果你只想堵塞

678
00:32:19,450 --> 00:32:23,510
字符到一個預先格式化字符串
就像我們一直在做的，你可以使用％C。

679
00:32:23,510 --> 00:32:28,490
>> 然後，有些煩人，LLD
很長很長的十進制整數，

680
00:32:28,490 --> 00:32:31,050
這意味著，如果你需要一個真正的
大的數字，你正在使用的東西

681
00:32:31,050 --> 00:32:35,450
所謂很長很長，我們還會回來的
回在pset中，您可以使用％LLD

682
00:32:35,450 --> 00:32:40,700
告訴printf的，插上一個真正的大
整數，在這裡通過其第二或

683
00:32:40,700 --> 00:32:41,830
其他一些參數。

684
00:32:41,830 --> 00:32:45,700
>> 最後，我答應了，
還有其他一些逃生

685
00:32:45,700 --> 00:32:47,670
printf的支持序列。

686
00:32:47,670 --> 00:32:49,160
我們已經看到反斜杠-N。

687
00:32:49,160 --> 00:32:50,510
反斜杠-R，您可能會看到。

688
00:32:50,510 --> 00:32:51,780
這是一個老派的東西。

689
00:32:51,780 --> 00:32:55,920
如果您使用過一個真正的打字機年
以前，你拉在曲柄

690
00:32:55,920 --> 00:32:59,810
這不僅旋轉的車輪
移動陣容，也感動了

691
00:32:59,810 --> 00:33:03,730
整個事情的所有的方式回到到
左，反斜杠-R

692
00:33:03,730 --> 00:33:06,480
本質上移動光標回
開始線

693
00:33:06,480 --> 00:33:07,830
沒有向下移動。

694
00:33:07,830 --> 00:33:09,780
但同樣，更多的，
也許在將來。

695
00:33:09,780 --> 00:33:13,670
>> 反斜杠反斜杠報價，雙引號，
反斜杠反斜杠是

696
00:33:13,670 --> 00:33:16,600
解決小小的謎語
我前面提到的。

697
00:33:16,600 --> 00:33:18,920
反斜杠0實際上是
挺有意思的。

698
00:33:18,920 --> 00:33:21,470
但是，我們會回來
用不了多久。

699
00:33:21,470 --> 00:33:25,640
>> 因此，讓我進入，如今，CS50
家電，讓我們真正做到一個

700
00:33:25,640 --> 00:33:28,930
快速升溫的例子之一
我們已經沒有，然後移動到

701
00:33:28,930 --> 00:33:31,160
稍微複雜一些的東西。

702
00:33:31,160 --> 00:33:34,980
所以，如果我打開了我的程序
gedit的 - 

703
00:33:34,980 --> 00:33:36,840
這是我的圖形編輯器。

704
00:33:36,840 --> 00:33:38,460
我可以做到這一點 - 

705
00:33:38,460 --> 00:33:39,820
讓我關閉該窗口 - 

706
00:33:39,820 --> 00:33:42,720
此圖標的方式在這裡，
gedit中，在左下角

707
00:33:42,720 --> 00:33:44,170
菜單旁邊的角落。

708
00:33:44,170 --> 00:33:48,670
>> 我要繼續前進，前進，
保存這個例子，說，約翰

709
00:33:48,670 --> 00:33:49,660
哈佛的文件夾。

710
00:33:49,660 --> 00:33:52,690
約翰·哈佛的文件夾就是他的家
住在他的所有文件目錄

711
00:33:52,690 --> 00:33:53,340
默認情況下。

712
00:33:53,340 --> 00:33:58,410
我要保存為
一個名為HELLO 0.C。

713
00:33:58,410 --> 00:34:01,260
而且我選擇了這個名字，只是如此
線與示例代碼

714
00:34:01,260 --> 00:34:04,210
當然的網站，並在
YouTube的在線視頻。

715
00:34:04,210 --> 00:34:06,320
>> 所以，現在我要開始
寫我的第一個程序。

716
00:34:06,320 --> 00:34:08,469
讓我放大可讀性。

717
00:34:08,469 --> 00:34:12,760
而且我要繼續前進並說詮釋
主要無效，就像

718
00:34:12,760 --> 00:34:14,900
黃一塊拼圖
啟動程序。

719
00:34:14,900 --> 00:34:18,290
我已經得到了成習慣
多年來，然後打開我的花括號

720
00:34:18,290 --> 00:34:22,000
同時也關閉它，然後回去
我希望把我的代碼，只需

721
00:34:22,000 --> 00:34:24,630
因為它幫助我保持一切
平衡，尤其是我

722
00:34:24,630 --> 00:34:25,880
程序變長。

723
00:34:25,880 --> 00:34:29,239
>> 而現在，在這裡，我要繼續前進
說的是printf，報價引文結束，

724
00:34:29,239 --> 00:34:34,330
你好世界，反斜杠-N，密切報價，
接近括號，分號。

725
00:34:34,330 --> 00:34:38,100
所以，我只是重複我們的一切
被授予迄今為止的。

726
00:34:38,100 --> 00:34:39,270
現在，我要以縮小。

727
00:34:39,270 --> 00:34:43,030
>> 這個終端窗口在這裡，
我可以做這個黑色

728
00:34:43,030 --> 00:34:44,389
和白色的窗口？

729
00:34:44,389 --> 00:34:46,977
我可以用它來做什麼？

730
00:34:46,977 --> 00:34:49,770
所以這是我運行命令和
在這裡我可以編譯的東西。

731
00:34:49,770 --> 00:34:50,620
我要保持它的簡單。

732
00:34:50,620 --> 00:34:52,780
我要使用一個程序
名為make，這是不

733
00:34:52,780 --> 00:34:54,020
技術上是一個編譯器。

734
00:34:54,020 --> 00:34:56,360
編譯器的稱為鐺，但
我們會回來，在一個

735
00:34:56,360 --> 00:34:57,190
一周或2的時間。

736
00:34:57,190 --> 00:35:03,410
>> 現在，我只是輸入make
HELLO-0，但那些誰

737
00:35:03,410 --> 00:35:07,050
比較我剛才在你們心中
輸入我應該輸入什麼可

738
00:35:07,050 --> 00:35:10,180
已經知道，我做了
錯誤的東西在這裡。

739
00:35:10,180 --> 00:35:12,160
現在，顯然有一些錯誤。

740
00:35:12,160 --> 00:35:16,742
之前，我連看都不看他們是什麼，任何
的想法，因為我做錯了什麼？

741
00:35:16,742 --> 00:35:18,590
>> 學生：[插入聲音]。

742
00:35:18,590 --> 00:35:18,840
>> DAVID馬蘭：是啊。

743
00:35:18,840 --> 00:35:20,640
我缺少庫的頭文件。

744
00:35:20,640 --> 00:35:24,240
這些文件被稱為頭
文件，和他們共同

745
00:35:24,240 --> 00:35:25,680
屬於東西叫做庫。

746
00:35:25,680 --> 00:35:28,030
圖書館只是大塊的代碼
其他人寫的。

747
00:35:28,030 --> 00:35:32,140
因此，標準的[？我？]庫是一個
收集包含代碼的文件

748
00:35:32,140 --> 00:35:33,330
其他人寫的。

749
00:35:33,330 --> 00:35:34,820
>> 所以我失踪了。

750
00:35:34,820 --> 00:35:36,520
那麼，為什麼我得到一個錯誤？

751
00:35:36,520 --> 00:35:40,840
好吧，讓我回來在滾動
我的終端窗口。

752
00:35:40,840 --> 00:35:44,310
不幸的是，在C中，在很多
編程語言，特別是

753
00:35:44,310 --> 00:35:47,830
如果它是所有新的給你，誤差
消息是精確的，但他們也

754
00:35:47,830 --> 00:35:48,620
相當神秘。

755
00:35:48,620 --> 00:35:51,720
和錯誤在這裡，在紅色，
“隱式聲明的庫函數

756
00:35:51,720 --> 00:35:57,660
printf輸出類型“，然後滾動
到下一行，“詮釋為const char *，

757
00:35:57,660 --> 00:36:00,220
“這只是變得非常
很快鋪天蓋地。

758
00:36:00,220 --> 00:36:04,420
>> 可是你應該開始做的，如果，
再次，新的這一切，只是為了

759
00:36:04,420 --> 00:36:06,010
開始尋找關鍵字。

760
00:36:06,010 --> 00:36:08,770
很顯然，我可能不明白一半
的話，我只是還沒有看到。

761
00:36:08,770 --> 00:36:10,140
你會的，不過，在一個星期的時間。

762
00:36:10,140 --> 00:36:11,230
但我看到的printf。

763
00:36:11,230 --> 00:36:14,310
應該開始，用不了多久，
喚起你的記憶，所有的權利中，將printf。

764
00:36:14,310 --> 00:36:15,210
用printf出事了。

765
00:36:15,210 --> 00:36:16,580
我拼寫錯了呢？

766
00:36:16,580 --> 00:36:18,130
不，它不是看起來像 - 哦。

767
00:36:18,130 --> 00:36:21,350
我無法使用它，除非我教
編譯它的存在。

768
00:36:21,350 --> 00:36:25,220
所以，再說一次，去自己的直覺，
即使你不真正了解

769
00:36:25,220 --> 00:36:26,510
真正的錯誤訊息。

770
00:36:26,510 --> 00:36:30,240
>> 的確，這裡的解決方案是只
包含在該文件的頂部

771
00:36:30,240 --> 00:36:34,340
這樣，我的文件重新保存
控制-S或“文件”菜單上。

772
00:36:34,340 --> 00:36:36,730
如果我現在回到這裡，
我要及時清除。

773
00:36:36,730 --> 00:36:39,150
控制-L是一個不錯的方式
清除屏幕。

774
00:36:39,150 --> 00:36:44,870
然後我要輸入“你好
0“輸入，現在我還是看到了

775
00:36:44,870 --> 00:36:47,710
隱秘的符號序列，但
我們會回來的。

776
00:36:47,710 --> 00:36:49,230
那是什麼使為你做的。

777
00:36:49,230 --> 00:36:52,590
服用過程自動化
涉及相當惱人的命令

778
00:36:52,590 --> 00:36:54,050
鏘，實際的編譯器。

779
00:36:54,050 --> 00:36:57,460
但事實證明，我沒有錯誤
這件事情應該工作。

780
00:36:57,460 --> 00:37:00,630
>> 所以，我現在要做的事情 - 
讓我再次放大 - 

781
00:37:00,630 --> 00:37:07,070
./hello-0輸入，而事實上，我看到
“你好，世界”。現在讓我們增強

782
00:37:07,070 --> 00:37:12,105
這只是非常輕微複製
步驟，我們打算。

783
00:37:12,105 --> 00:37:15,370
我要重新命名此
另存為hello1.c。

784
00:37:15,370 --> 00:37:20,300
現在我要聲明一個變量
叫名字，所以字符串名稱，

785
00:37:20,300 --> 00:37:23,420
我打算把它
值報價引文結束

786
00:37:23,420 --> 00:37:27,030
D-A-V-I-D收盤報價分號。

787
00:37:27,030 --> 00:37:31,150
現在我要更換“世界”
什麼佔位符的字符串？

788
00:37:31,150 --> 00:37:32,200
％S。

789
00:37:32,200 --> 00:37:35,040
>> 而現在，許多參數應該如何
printf的利用這個時間嗎？

790
00:37:35,040 --> 00:37:35,700
所以兩個。

791
00:37:35,700 --> 00:37:37,090
所以，我去外面的引號。

792
00:37:37,090 --> 00:37:39,330
我鍵入“名稱”後的逗號。

793
00:37:39,330 --> 00:37:41,550
但我已經做了一些
別人錯了，這時候。

794
00:37:41,550 --> 00:37:43,940
但是，讓我們假設，我沒有
尚未實現。

795
00:37:43,940 --> 00:37:44,910
讓我上去此處。

796
00:37:44,910 --> 00:37:48,850
>> 通知過，我開始有點
無聊的打字打招呼“0”

797
00:37:48,850 --> 00:37:50,180
時間，“使”，而這一切。

798
00:37:50,180 --> 00:37:53,270
所以，事實證明，在萊納斯你可以
經常打的向上箭頭您

799
00:37:53,270 --> 00:37:56,850
鍵盤，實際上，你可以滾動
我通過所有的命令

800
00:37:56,850 --> 00:37:58,830
執行早先剛才。

801
00:37:58,830 --> 00:38:02,040
所以，如果我這樣做了，起床了，
有打招呼0。

802
00:38:02,040 --> 00:38:02,610
我不希望出現這種情況。

803
00:38:02,610 --> 00:38:05,450
我只是想改變這種狀況
你好1，回車。

804
00:38:05,450 --> 00:38:07,620
最後，將
為您節省一些時間。

805
00:38:07,620 --> 00:38:08,150
>> 好的。

806
00:38:08,150 --> 00:38:09,520
不幸的是，有一個錯誤。

807
00:38:09,520 --> 00:38:10,980
因此，讓我向上滾動。

808
00:38:10,980 --> 00:38:13,120
這看起來像我真的
宰了這個節目。

809
00:38:13,120 --> 00:38:16,530
我的意思是，我的上帝，這是兩行代碼，
10行的錯誤。

810
00:38:16,530 --> 00:38:18,800
不過看在頂一個先。

811
00:38:18,800 --> 00:38:21,640
使用未聲明的標識符字符串。

812
00:38:21,640 --> 00:38:23,270
我的意思是標準I N？

813
00:38:23,270 --> 00:38:23,930
不，我沒有。

814
00:38:23,930 --> 00:38:24,940
我的意思是字符串。

815
00:38:24,940 --> 00:38:29,390
>> 但如果是字符串變量
聲明的類型，DD我們說？

816
00:38:29,390 --> 00:38:30,730
因此，它是在CS50圖書館。

817
00:38:30,730 --> 00:38:33,740
因此，它是不夠的，在這些第一
幾個星期，只是使用

818
00:38:33,740 --> 00:38:34,860
什麼C給我們。

819
00:38:34,860 --> 00:38:38,120
我也要去這裡，我
可以把它的上方或下方，但我會

820
00:38:38,120 --> 00:38:40,340
只要保持它的英文字母
保持有序的事情。

821
00:38:40,340 --> 00:38:43,470
我要去包括cs50.h，
這是預先安裝的

822
00:38:43,470 --> 00:38:44,900
你的CS50家電。

823
00:38:44,900 --> 00:38:47,640
而且它是開源的，所以即使人
在互聯網上可以使用他們的

824
00:38:47,640 --> 00:38:48,450
自己的電腦。

825
00:38:48,450 --> 00:38:50,700
不過，來自與CS50家電。

826
00:38:50,700 --> 00:38:55,320
>> 所以，現在讓我回去，並重新編譯
這與讓您好1。

827
00:38:55,320 --> 00:38:55,710
該死的。

828
00:38:55,710 --> 00:38:57,240
還有一個錯誤。

829
00:38:57,240 --> 00:38:59,370
讓我向上滾動到第一，雖然。

830
00:38:59,370 --> 00:39:00,630
這是一個有點複雜的。

831
00:39:00,630 --> 00:39:03,830
多字字符常量。

832
00:39:03,830 --> 00:39:04,890
這不是我的幫助。

833
00:39:04,890 --> 00:39:08,220
但是請注意，鐺至少有一點
有點體面的，一點點

834
00:39:08,220 --> 00:39:11,890
綠色插入符號的象徵，它的說法
這裡是我搞砸了。

835
00:39:11,890 --> 00:39:16,160
為什麼會指著那個小
綠色箭頭，旁邊的單引號

836
00:39:16,160 --> 00:39:18,290
我的名字嗎？

837
00:39:18,290 --> 00:39:20,880
>> 因此，這是您剛才的事情之一
習慣了，尤其是如果你已經

838
00:39:20,880 --> 00:39:23,980
在Python或JavaScript編程，
或其他語言，這個細節

839
00:39:23,980 --> 00:39:24,560
不要緊。

840
00:39:24,560 --> 00:39:25,740
在C語言中，它的問題。

841
00:39:25,740 --> 00:39:29,520
如果你聲明一個字符串，它是
在一個序列中的0個或更多個字符，

842
00:39:29,520 --> 00:39:32,280
你實際上必須用雙引號。

843
00:39:32,280 --> 00:39:36,670
所以，我確實需要改回
開報價，收報價，

844
00:39:36,670 --> 00:39:37,800
雙引號。

845
00:39:37,800 --> 00:39:41,610
單引號做有他們的地方，但
只有當你使用個人

846
00:39:41,610 --> 00:39:44,100
個字符，但更多的，另一個時間。

847
00:39:44,100 --> 00:39:46,550
就目前而言，雙引號
是必要的。

848
00:39:46,550 --> 00:39:50,460
>> 所以，現在，讓我回到我的終端
窗口，您好1。

849
00:39:50,460 --> 00:39:51,450
誰的信心？

850
00:39:51,450 --> 00:39:53,800
這是程序現在
正確編譯？

851
00:39:53,800 --> 00:39:58,250

852
00:39:58,250 --> 00:39:58,540
確定。

853
00:39:58,540 --> 00:39:59,780
所以我們三個人認為這。

854
00:39:59,780 --> 00:40:00,280
好的。

855
00:40:00,280 --> 00:40:01,190
回車鍵。

856
00:40:01,190 --> 00:40:02,440
它實際上做到了。

857
00:40:02,440 --> 00:40:05,130
因此，有沒有錯誤，這個時候，即使
雖然這個方案得到位

858
00:40:05,130 --> 00:40:05,840
更為複雜。

859
00:40:05,840 --> 00:40:10,110
如果我現在做的點斜線打招呼1，回車，
它會說“你好，戴維。”

860
00:40:10,110 --> 00:40:11,750
>> 但是，讓我們做第三次迭代
這一點，其中的

861
00:40:11,750 --> 00:40:13,380
程序是真正的動態。

862
00:40:13,380 --> 00:40:16,770
讓我繼續前進，更改文件
名稱，只是為了與一致性

863
00:40:16,770 --> 00:40:20,410
你就必須提供的文件
你後來在網上。

864
00:40:20,410 --> 00:40:21,620
回車鍵。

865
00:40:21,620 --> 00:40:25,510
現在我要去和
存儲“大衛”硬編碼。

866
00:40:25,510 --> 00:40:28,826
我能做些什麼，很簡單地
提高這個程序？

867
00:40:28,826 --> 00:40:30,520
>> 我可以打電話的getString。

868
00:40:30,520 --> 00:40:33,240
這可能是一個小的非顯而易見的是什麼
即將發生的事情，所以我要去

869
00:40:33,240 --> 00:40:38,470
實際添加另一條線路中，將printf
並說名，冒號，引號，只是

870
00:40:38,470 --> 00:40:40,790
提示給用戶
在屏幕上。

871
00:40:40,790 --> 00:40:42,980
現在我要去這裡，我
要使用我的鍵盤快捷鍵。

872
00:40:42,980 --> 00:40:47,680
我要去UP，UP和更改
您好1至2個招呼，回車。

873
00:40:47,680 --> 00:40:49,260
令人欣慰的是，我在進步。

874
00:40:49,260 --> 00:40:52,720
>> 現在我要去
點斜線打招呼，

875
00:40:52,720 --> 00:40:54,690
改變，2，回車。

876
00:40:54,690 --> 00:40:55,650
現在我的計劃 - 

877
00:40:55,650 --> 00:40:57,700
我會放大 - 越來越
漂亮一點。

878
00:40:57,700 --> 00:41:02,190
名稱將是，讓我們說，羅布
這個時候，輸入，你好，羅布。

879
00:41:02,190 --> 00:41:03,260
我們可以再次做到這一點。

880
00:41:03,260 --> 00:41:05,360
名稱，勞倫，回車。

881
00:41:05,360 --> 00:41:07,820
名稱，約瑟夫，回車。

882
00:41:07,820 --> 00:41:11,596
名稱，讓我們嘗試
困難，回車。

883
00:41:11,596 --> 00:41:12,410
誒。

884
00:41:12,410 --> 00:41:14,680
這不是一個真正的錯誤。

885
00:41:14,680 --> 00:41:16,090
所以它只是一個有點難看。

886
00:41:16,090 --> 00:41:18,640
因此，也許我們可以解決這個問題
在未來，而不是現在。

887
00:41:18,640 --> 00:41:20,840
>> 但如何將你本能地
去解決

888
00:41:20,840 --> 00:41:21,990
那個特殊的挑戰？

889
00:41:21,990 --> 00:41:23,710
它只是看起來愚蠢的。

890
00:41:23,710 --> 00:41:27,320
你如何避免的事情
尋找愚蠢嗎？

891
00:41:27,320 --> 00:41:29,890
因此，我們可以這樣做，OK，我聽到一對夫婦
的事情，條件和循環。

892
00:41:29,890 --> 00:41:33,340
我們可以使用一個條件，要檢查
字符串的長度是什麼

893
00:41:33,340 --> 00:41:34,190
用戶給我們嗎？

894
00:41:34,190 --> 00:41:37,100
如果它是0，它只是引述引文結束，
他們只投中，然後輸入

895
00:41:37,100 --> 00:41:38,930
也許我應該大聲喝斥
並促使他們再次。

896
00:41:38,930 --> 00:41:39,970
但如何做一個提示嗎？

897
00:41:39,970 --> 00:41:44,230
嗯，我也聽到了循環，然後我就可以
再這樣做一遍又一遍

898
00:41:44,230 --> 00:41:47,010
提示用戶同樣的事情。

899
00:41:47,010 --> 00:41:48,880
>> 好吧，讓我們做一個其他的例子
使用不同的

900
00:41:48,880 --> 00:41:50,620
功能在CS50庫。

901
00:41:50,620 --> 00:41:52,330
讓我關閉這個文件。

902
00:41:52,330 --> 00:41:53,510
讓我創建一個新的。

903
00:41:53,510 --> 00:41:58,510
我會打電話給它adder.c，只是因為
它很容易做簡單的算術題，

904
00:41:58,510 --> 00:42:00,890
即使這將完全
給人留下深刻印象的，你可以做什麼

905
00:42:00,890 --> 00:42:02,250
任何現代電腦。

906
00:42:02,250 --> 00:42:03,750
>> 不過，讓我繼續前進，現在 - 

907
00:42:03,750 --> 00:42:10,680
我吸取了教訓最後一次 - 包括
cs50.h，包括stdio.h中，INT

908
00:42:10,680 --> 00:42:14,170
主要無效，現在，我只是
盲目的信仰，但我們假設

909
00:42:14,170 --> 00:42:16,380
將了解
這意味著在不久的。

910
00:42:16,380 --> 00:42:21,030
我要說點什麼
像“給我一個int。”

911
00:42:21,030 --> 00:42:22,140
>> 而現在，我如何獲得一個int？

912
00:42:22,140 --> 00:42:26,820
我想最終聲明一個變量
名為x int類型

913
00:42:26,820 --> 00:42:29,240
存儲在它的用戶之間的一個整數。

914
00:42:29,240 --> 00:42:29,970
所以這是一口。

915
00:42:29,970 --> 00:42:35,680
但是，如果有人想提出，如何
我聲明一個整型名為x？

916
00:42:35,680 --> 00:42:36,310
詮釋X。

917
00:42:36,310 --> 00:42:37,430
>> 所以，這真的就是這麼簡單。

918
00:42:37,430 --> 00:42:38,240
給我一個int。

919
00:42:38,240 --> 00:42:39,070
x。

920
00:42:39,070 --> 00:42:40,580
現在，我使用賦值運算符。

921
00:42:40,580 --> 00:42:43,400
我如何從存儲
離開的用戶的值？

922
00:42:43,400 --> 00:42:47,310
我不想調用的getString
很明顯，而是調用getInt。

923
00:42:47,310 --> 00:42:49,060
任何參數？

924
00:42:49,060 --> 00:42:49,350
號

925
00:42:49,350 --> 00:42:51,870
所以它是開放的括號，靠近括號
立刻，並且然後

926
00:42:51,870 --> 00:42:53,440
分號結束就行了。

927
00:42:53,440 --> 00:42:54,930
>> 現在讓我再次做到這一點。

928
00:42:54,930 --> 00:42:57,070
給我另一種詮釋。

929
00:42:57,070 --> 00:43:01,850
這一次，我會做詮釋，讓我們
叫它Y，等於調用getInt。

930
00:43:01,850 --> 00:43:05,060
現在讓我做些事情超簡單
像一些數學。

931
00:43:05,060 --> 00:43:14,340
所以printf的％D的總和
類型為int的佔位符。

932
00:43:14,340 --> 00:43:20,030
％D，期間，反斜杠-N。

933
00:43:20,030 --> 00:43:20,360
>> 好的。

934
00:43:20,360 --> 00:43:21,670
所以這不是真正的數學。

935
00:43:21,670 --> 00:43:25,500
但是，如果我想說的總和
價值加上這個值等於這個

936
00:43:25,500 --> 00:43:29,320
其他值，進多少個參數
總，我應該給printf的，

937
00:43:29,320 --> 00:43:30,520
最終呢？

938
00:43:30,520 --> 00:43:31,420
所以四，對不對？

939
00:43:31,420 --> 00:43:33,790
此字符串，然後這三個值。

940
00:43:33,790 --> 00:43:37,560
因此，x是第一個，我想成為
插在％D第一。

941
00:43:37,560 --> 00:43:39,270
y是會成為下一個。

942
00:43:39,270 --> 00:43:42,030
>> 現在我想說的
z以及Z不存在。

943
00:43:42,030 --> 00:43:43,190
但是，這並不是什麼大不了的。

944
00:43:43,190 --> 00:43:45,440
因為本能，你會做什麼，
特別是如果你有一個

945
00:43:45,440 --> 00:43:47,820
圖形計算器，你怎麼輸入？

946
00:43:47,820 --> 00:43:48,760
X加Y如何？

947
00:43:48,760 --> 00:43:50,200
因此，它不是一個實際的變量。

948
00:43:50,200 --> 00:43:51,820
這只是兩個的總和
其他變量。

949
00:43:51,820 --> 00:43:53,170
這是完全合法的。

950
00:43:53,170 --> 00:43:56,630
Ç當然明白簡單
像這樣的算術。

951
00:43:56,630 --> 00:43:58,450
>> 分號，保存。

952
00:43:58,450 --> 00:44:02,080
現在讓我去這裡，
輸入加法器，輸入。

953
00:44:02,080 --> 00:44:04,100
沒有錯誤，所以這是太進步。

954
00:44:04,100 --> 00:44:04,890
輸入加法器。

955
00:44:04,890 --> 00:44:07,100
與另一個鍵盤快捷鍵，
如果你開始感到厭倦

956
00:44:07,100 --> 00:44:08,760
與所有的命令 - 

957
00:44:08,760 --> 00:44:12,650
如果你開始鍵入一個命令，像點
削減廣告，而這也正是你的

958
00:44:12,650 --> 00:44:16,020
無聊踢，你通常可以打
Tab鍵計算機完成

959
00:44:16,020 --> 00:44:20,510
休息的那句，如果它不
曖昧的，以後要來的廣告。

960
00:44:20,510 --> 00:44:23,950
>> 因此，讓我現在繼續
你按一下回車鍵。

961
00:44:23,950 --> 00:44:27,490
給我一個int，1，2，
令人欣慰的是，它的3。

962
00:44:27,490 --> 00:44:29,900
但一如既往，測試計劃
不應該減少

963
00:44:29,900 --> 00:44:30,820
只是嘗試一次。

964
00:44:30,820 --> 00:44:35,560
讓我嘗試一個角落的情況下，像負
1，給1，有

965
00:44:35,560 --> 00:44:36,210
檢查為好。

966
00:44:36,210 --> 00:44:38,870
我可能要多做一些
嚴格的測試，但我敢

967
00:44:38,870 --> 00:44:40,630
舒適，這是哪裡。

968
00:44:40,630 --> 00:44:43,110
>> 好了，現在讓我們嘗試另一個程序
這一次使用一個

969
00:44:43,110 --> 00:44:44,620
位的其他語法。

970
00:44:44,620 --> 00:44:46,100
讓我創建一個新的文件。

971
00:44:46,100 --> 00:44:51,050
我會打電話給排隊conditions0.c
了網上一些示例代碼。

972
00:44:51,050 --> 00:44:55,550
讓我繼續做
包括cs50.h，包括

973
00:44:55,550 --> 00:45:00,320
stdio.h中，在主無效 - 

974
00:45:00,320 --> 00:45:01,030
確定。

975
00:45:01,030 --> 00:45:01,850
我們去那裡。

976
00:45:01,850 --> 00:45:03,010
我們有我們的標準樣板。

977
00:45:03,010 --> 00:45:08,170
>> 而這個時候我會說的printf
“我想請一個int”，只是為了

978
00:45:08,170 --> 00:45:10,030
的提示一點點
更友好。

979
00:45:10,030 --> 00:45:11,620
現在我要得到一個
int的來自用戶的。

980
00:45:11,620 --> 00:45:15,010
我要打電話n這個時間，只是
因為n聽起來像數。

981
00:45:15,010 --> 00:45:18,140
調用getInt，而現在，做什麼
我想用它做什麼？

982
00:45:18,140 --> 00:45:21,640
好吧，如果n是 - 我會放大 - 

983
00:45:21,640 --> 00:45:25,930
如果n是大於0的，我想
做到以下幾點 - 

984
00:45:25,930 --> 00:45:36,060
printf的“你挑了個正數。”
否則，我要輸入的printf“

985
00:45:36,060 --> 00:45:37,870
挑了負

986
00:45:37,870 --> 00:45:39,650
號碼“。所有權利。

987
00:45:39,650 --> 00:45:44,410
所以這個程序，即使我做到了
速度快，看起來正確的語法。

988
00:45:44,410 --> 00:45:45,010
讓我試試這個。

989
00:45:45,010 --> 00:45:46,890
條件0。

990
00:45:46,890 --> 00:45:47,710
似乎運行。

991
00:45:47,710 --> 00:45:49,230
，輸入條件0。

992
00:45:49,230 --> 00:45:51,910
讓我們給它一個int 50。

993
00:45:51,910 --> 00:45:53,160
我拿起一個正數。

994
00:45:53,160 --> 00:45:54,230
讓我們嘗試了一遍。

995
00:45:54,230 --> 00:45:54,930
條件0。

996
00:45:54,930 --> 00:45:56,260
負50。

997
00:45:56,260 --> 00:45:57,290
我挑了負數。

998
00:45:57,290 --> 00:46:00,350
>> 但現在，讓我挑什麼，我們將保持
調用一個角落的情況下，這是更

999
00:46:00,350 --> 00:46:04,702
一個有趣的案例，你認為
可能會給你一些麻煩，0。

1000
00:46:04,702 --> 00:46:07,940
現在，我敢肯定，這是一個
那些角落零的情況下，

1001
00:46:07,940 --> 00:46:12,330
既不是正面或負面，所以我
程序，但在語法上

1002
00:46:12,330 --> 00:46:15,440
糾正 - 它編譯，運行 - 
邏輯上是不正確的。

1003
00:46:15,440 --> 00:46:21,050
那麼，有什麼簡單的修復在這裡，如果我想
檢測，如果我想要來處理n

1004
00:46:21,050 --> 00:46:23,840
分別等於0？

1005
00:46:23,840 --> 00:46:32,980
>> 因此，如果n等於0，那麼我想說
如printf的東西“，你選0。”

1006
00:46:32,980 --> 00:46:33,990
讓我試試這個。

1007
00:46:33,990 --> 00:46:38,320
讓我回到這裡，清除
我的窗口，並重新編譯。

1008
00:46:38,320 --> 00:46:38,690
嗯。

1009
00:46:38,690 --> 00:46:39,770
產生一個錯誤。

1010
00:46:39,770 --> 00:46:41,630
但我要檢查
如果n等於0。

1011
00:46:41,630 --> 00:46:44,230

1012
00:46:44,230 --> 00:46:47,720
>> 如此反复，另一個愚蠢的事
習慣於等號

1013
00:46:47,720 --> 00:46:48,910
賦值運算符。

1014
00:46:48,910 --> 00:46:52,240
因此，這其實是錯誤的，
在技​​術上，即使編譯器

1015
00:46:52,240 --> 00:46:56,450
保護我自己，我們會
在技​​術上被複製成n 0

1016
00:46:56,450 --> 00:46:57,590
是不是我想要的。

1017
00:46:57,590 --> 00:47:00,950
我想測試平等
等於平等。

1018
00:47:00,950 --> 00:47:03,390
所以，現在可能是
我的更好的解決方案。

1019
00:47:03,390 --> 00:47:07,810
>> 讓我重新保存，也就是說，
條件下，新的和改進的。

1020
00:47:07,810 --> 00:47:10,480
所以，現在如果我重新編譯，
它將使條件 - 

1021
00:47:10,480 --> 00:47:16,960
哎呦 - 條件下點斜線
條件1，回車，“我想一個int

1022
00:47:16,960 --> 00:47:18,760
請。“我要去
並鍵入50。

1023
00:47:18,760 --> 00:47:19,660
這還是不錯的。

1024
00:47:19,660 --> 00:47:21,200
50負，還是不錯的。

1025
00:47:21,200 --> 00:47:24,920
0，並且，事實上，檢測
我拿起0。

1026
00:47:24,920 --> 00:47:28,200
>> 所以，什麼我現在做的與此有關嗎？

1027
00:47:28,200 --> 00:47:32,280
好了，我們當然可以做的越來越多
複雜的事情。

1028
00:47:32,280 --> 00:47:37,240
但我想提出的是
我們結束這說明在這裡。

1029
00:47:37,240 --> 00:47:41,680
如果我們拉起這個，你會看到，也許，
你最喜愛的卡通

1030
00:47:41,680 --> 00:47:43,326
直到今天，你可能會
從來沒有理解。

1031
00:47:43,326 --> 00:47:46,550

1032
00:47:46,550 --> 00:47:49,520
而這是關於質量的笑聲
你應該得到與CS的笑話。

1033
00:47:49,520 --> 00:47:51,060
所以這是對的。

1034
00:47:51,060 --> 00:47:54,900
>> 但更令人信服的是，我想我會
給我們一點週一傳情。

1035
00:47:54,900 --> 00:47:56,430
因此，我們已經開始使用整數。

1036
00:47:56,430 --> 00:47:57,510
我們已經提到彩車。

1037
00:47:57,510 --> 00:48:00,120
我們甚至被稱為雙打，
再次，給你的數字

1038
00:48:00,120 --> 00:48:01,390
小數點後。

1039
00:48:01,390 --> 00:48:04,230
>> 但事實證明，花車和
雙打，真的，電腦，

1040
00:48:04,230 --> 00:48:08,470
從根本上說，不能表達
正是一些值。

1041
00:48:08,470 --> 00:48:12,840
我們知道，從數學課，你可以
後有任何數量的數字

1042
00:48:12,840 --> 00:48:13,510
小數點。

1043
00:48:13,510 --> 00:48:16,460
你甚至可以把豎線
說這些永遠持續下去。

1044
00:48:16,460 --> 00:48:18,810
>> 不幸的是，你不能真正
這樣做，在一台計算機。

1045
00:48:18,810 --> 00:48:20,400
所以角情況下出現的。

1046
00:48:20,400 --> 00:48:23,120
舉例來說，假設你
做財務的東西。

1047
00:48:23,120 --> 00:48:25,700
你做數學
用百分比和

1048
00:48:25,700 --> 00:48:27,030
與美元和美分。

1049
00:48:27,030 --> 00:48:29,230
和那些仙不
一定排隊。

1050
00:48:29,230 --> 00:48:34,120
嗯，事實證明，分數
便士可以開始添加時

1051
00:48:34,120 --> 00:48:37,250
與計算機系統建模
在這樣一種方式，聰明

1052
00:48:37,250 --> 00:48:39,100
人類可以利用。

1053
00:48:39,100 --> 00:48:42,650
>> 而那些你沒有見過的人，我會
想給你一個30秒的傳情

1054
00:48:42,650 --> 00:48:48,290
精彩的電影，被稱為辦公空間，
畫了一幅

1055
00:48:48,290 --> 00:48:51,205
我們要解決的問題
在週一的第一件事。

1056
00:48:51,205 --> 00:48:53,960
如果我們能夠提高音量
一點點，我給你30

1057
00:48:53,960 --> 00:48:55,495
秒的辦公空間。

1058
00:48:55,495 --> 00:48:55,770
>> [視頻回放]

1059
00:48:55,770 --> 00:48:59,000
>> 我的意思是，你，你沒有一直呈現
起來，你會得到你的工作保持。

1060
00:48:59,000 --> 00:49:00,620
>> 其實，我被晉升。

1061
00:49:00,620 --> 00:49:03,240
>> 我可以編寫一個病毒，最好
RIP關閉大的時候那個地方。

1062
00:49:03,240 --> 00:49:04,430
>> 那麼，它是如何工作的？

1063
00:49:04,430 --> 00:49:06,782
>> 每次有銀行交易
在計算利息，並有

1064
00:49:06,782 --> 00:49:10,160
成千上萬一天，電腦結束
與這些不足一仙。

1065
00:49:10,160 --> 00:49:12,030
>> 但我不會
做任何違法的事。

1066
00:49:12,030 --> 00:49:12,660
>> 非法？

1067
00:49:12,660 --> 00:49:15,075
薩米爾，這是美國。

1068
00:49:15,075 --> 00:49:16,570
>> 我們必須向上帝發誓。

1069
00:49:16,570 --> 00:49:19,070
>> 如果沒有人知道這
但我們，好嗎？

1070
00:49:19,070 --> 00:49:21,920
沒有家人，沒有
女朋友，沒有人。

1071
00:49:21,920 --> 00:49:22,700
>> 當然。

1072
00:49:22,700 --> 00:49:23,320
>> 商定。

1073
00:49:23,320 --> 00:49:24,280
>>  - 別擔心，男人。

1074
00:49:24,280 --> 00:49:25,640
我不會告訴任何人。

1075
00:49:25,640 --> 00:49:26,504
>> [END視頻播放]

1076
00:49:26,504 --> 00:49:30,030
>> 國寶馬蘭：所以這個的話，是CS50，
這是辦公空間，它都將

1077
00:49:30,030 --> 00:49:31,465
使意義上週一。

1078
00:49:31,465 --> 00:49:33,940
到時候見。

1079
00:49:33,940 --> 00:49:37,880
>> 旁白：在接下來的CS50，羅布
調整被關閉的

1080
00:49:37,880 --> 00:49:39,130
哈佛膳食計劃。

1081
00:49:39,130 --> 00:49:56,160