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

2
00:00:10,550 --> 00:00:14,050
>> DAVID J.馬蘭：這是CS50和
這是4週的開始。

3
00:00:14,050 --> 00:00:18,630
而且，男孩，是大眾汽車
都是因為軟件的麻煩。

4
00:00:18,630 --> 00:00:20,264
讓我們一起來看看。

5
00:00:20,264 --> 00:00:20,930
[視頻回放]

6
00:00:20,930 --> 00:00:25,560
-Cars，最聰明的人物
在速度與激情的電影。

7
00:00:25,560 --> 00:00:29,100
本週，德國汽車製造商
大眾發現自己

8
00:00:29,100 --> 00:00:32,490
在醜聞的中間
潛在犯罪的比例。

9
00:00:32,490 --> 00:00:36,060
>> -Volkswagen是支撐數十億
罰款，可能的刑事指控

10
00:00:36,060 --> 00:00:38,560
它的高管，如
該公司道歉

11
00:00:38,560 --> 00:00:41,840
為索具1100多萬輛汽車，以
幫助它戰勝排放測試。

12
00:00:41,840 --> 00:00:44,950
>>  - 某些柴油車型分別為
設計與先進的軟件

13
00:00:44,950 --> 00:00:48,440
即使用信息，包括
轉向和車輛的位置

14
00:00:48,440 --> 00:00:51,870
速度來確定賽車
進行排放檢測。

15
00:00:51,870 --> 00:00:55,650
該種情況下，發動機
會減少有毒物質的排放。

16
00:00:55,650 --> 00:00:59,070
但車被人做了手腳旁路
當它被驅動。

17
00:00:59,070 --> 00:01:03,320
排放量增加10至40
次以上可以接受的EPA水平。

18
00:01:03,320 --> 00:01:04,280
>> [結束播放]

19
00:01:04,280 --> 00:01:05,220
>> DAVID J.馬蘭：所以，讓我們
看看這個

20
00:01:05,220 --> 00:01:07,250
看看這是怎樣
可能實施

21
00:01:07,250 --> 00:01:09,680
以及如何這可能會影響
這麼多車這樣。

22
00:01:09,680 --> 00:01:12,840
所以在我的手裡這裡的新聞
釋放由EPA--發行

23
00:01:12,840 --> 00:01:14,620
環境
保護機構這

24
00:01:14,620 --> 00:01:18,032
是美國的監管機構，
處理環境問題，

25
00:01:18,032 --> 00:01:19,740
然後將實際
這是法律聲明

26
00:01:19,740 --> 00:01:22,420
短短數天前發送給大眾。

27
00:01:22,420 --> 00:01:26,530
>> 因此，EPA寫道，現在公開
公開，一個成熟的軟件

28
00:01:26,530 --> 00:01:29,390
算法的某些
大眾汽車檢測

29
00:01:29,390 --> 00:01:32,630
當汽車發生
官方的排放測試

30
00:01:32,630 --> 00:01:36,505
和原來完全排放
只在測試過程中控制上。

31
00:01:36,505 --> 00:01:38,380
的有效性
這些車輛污染

32
00:01:38,380 --> 00:01:43,260
排放控制設備是很大的
在所有正常行駛減少

33
00:01:43,260 --> 00:01:44,320
的情況。

34
00:01:44,320 --> 00:01:48,190
這導致符合汽車
在實驗室或測試標準

35
00:01:48,190 --> 00:01:52,790
站，但在正常操作期間
排出的氮oxides--或NOx--

36
00:01:52,790 --> 00:01:54,950
在高達40倍的標準。

37
00:01:54,950 --> 00:01:58,220
由大眾汽車公司生產的軟件
是報價引文結束，落敗的設備，

38
00:01:58,220 --> 00:02:00,650
由清潔的定義
美國空氣法案。

39
00:02:00,650 --> 00:02:03,410
>> 他們接著說，
EPA和其他機構

40
00:02:03,410 --> 00:02:07,020
發現的失利裝置
後獨立分析軟件

41
00:02:07,020 --> 00:02:09,660
研究人員在西
弗吉尼亞大學。

42
00:02:09,660 --> 00:02:14,160
氮氧化物污染有利於
二氧化氮，地面臭氧，

43
00:02:14,160 --> 00:02:15,700
和細小顆粒物質。

44
00:02:15,700 --> 00:02:18,090
暴露於這些
污染物已被鏈接

45
00:02:18,090 --> 00:02:20,870
具有廣泛的
嚴重的健康影響，

46
00:02:20,870 --> 00:02:23,637
包括增加哮喘
攻擊等呼吸道

47
00:02:23,637 --> 00:02:26,470
疾病，可以足夠嚴重
派人到醫院就診。

48
00:02:26,470 --> 00:02:28,660
暴露於臭氧和
顆粒物質還具有

49
00:02:28,660 --> 00:02:31,960
過早被相關
死亡是由於呼吸相關

50
00:02:31,960 --> 00:02:35,690
或心血管相關的影響。

51
00:02:35,690 --> 00:02:38,940
兒童，老人，殘疾人
預先存在的呼吸系統疾病

52
00:02:38,940 --> 00:02:42,840
尤其在風險
這些污染物對健康的影響。

53
00:02:42,840 --> 00:02:45,056
>> 我只想是說，這是相當嚴重的。

54
00:02:45,056 --> 00:02:46,930
讓我們繼續閱讀
只是多一個節選

55
00:02:46,930 --> 00:02:49,370
然後我們將看看
潛在影響

56
00:02:49,370 --> 00:02:50,920
這在汽車的情況下。

57
00:02:50,920 --> 00:02:53,730
具體而言，大眾汽車
製造和安裝

58
00:02:53,730 --> 00:02:56,210
軟件在所謂的
電子控制

59
00:02:56,210 --> 00:02:59,320
module--或ECM--
這些車輛感測

60
00:02:59,320 --> 00:03:03,580
當車輛正在測試為
符合EPA排放標準。

61
00:03:03,580 --> 00:03:07,510
基於各種輸入，包括
方向盤的位置時，車輛

62
00:03:07,510 --> 00:03:11,280
速，發動機的持續時間
操作，並且大氣壓力，

63
00:03:11,280 --> 00:03:13,720
這些輸入準確
跟踪參數

64
00:03:13,720 --> 00:03:17,600
用於聯邦測試程序的
對於EPA認證排放測試

65
00:03:17,600 --> 00:03:18,400
的目的。

66
00:03:18,400 --> 00:03:21,850
>> 在美國環保局的排放測試，
車輛ECM軟件

67
00:03:21,850 --> 00:03:25,060
然其生產的軟件
標準的排放結果。

68
00:03:25,060 --> 00:03:28,340
在其他時候，
車輛ECM軟件

69
00:03:28,340 --> 00:03:31,090
跑了獨立的道路
校準從而減少

70
00:03:31,090 --> 00:03:34,360
的有效性
整體排放控制系統，

71
00:03:34,360 --> 00:03:37,864
具體地，選擇性催化
降低貧NO x的trap--

72
00:03:37,864 --> 00:03:39,280
我們將看到在某一時刻。

73
00:03:39,280 --> 00:03:43,040
NO x的結果，排放
增加10至40倍的因子

74
00:03:43,040 --> 00:03:47,450
上面的EPA標準的水平
根據驅動週期的類型。

75
00:03:47,450 --> 00:03:50,800
>> 那麼這到底是什麼意思，和
源代碼的軟件的運行

76
00:03:50,800 --> 00:03:53,190
在大眾汽車的還沒有
尚未公開披露，

77
00:03:53,190 --> 00:03:56,460
是，有效地，這
相當於是冥冥之中有內

78
00:03:56,460 --> 00:03:57,830
大眾的代碼。

79
00:03:57,830 --> 00:04:02,200
如果正在測試，和如果車
檢測某些環境因素

80
00:04:02,200 --> 00:04:04,330
像方向盤
位置或運動

81
00:04:04,330 --> 00:04:06,710
或缺乏的車或
任何數量的其它因素

82
00:04:06,710 --> 00:04:09,940
當前假設
是這個配方的一部分，

83
00:04:09,940 --> 00:04:12,370
他們只需打開
全排放控制。

84
00:04:12,370 --> 00:04:15,670
換言之，便開始
排放減少污染物。

85
00:04:15,670 --> 00:04:18,769
>> 否則，在每一個其它情況
當它不被檢測為

86
00:04:18,769 --> 00:04:20,790
在實驗室裡，他們只是不。

87
00:04:20,790 --> 00:04:24,320
所以你可以簡化成多
具體的偽代碼的東西

88
00:04:24,320 --> 00:04:24,820
這樣的。

89
00:04:24,820 --> 00:04:27,810
如果車輪轉動，但
方向盤不是，暗示

90
00:04:27,810 --> 00:04:30,060
這輛車是一些
一種轉筒

91
00:04:30,060 --> 00:04:32,550
但在某種
倉庫正在測試中，

92
00:04:32,550 --> 00:04:36,070
然後表現為
EPA想你。

93
00:04:36,070 --> 00:04:37,960
否則不。

94
00:04:37,960 --> 00:04:40,420
因此，讓我們一起來看看
在短視頻的

95
00:04:40,420 --> 00:04:45,391
考慮看看哪些影響
是這實際上機械。

96
00:04:45,391 --> 00:04:48,620
>> [視頻回放]

97
00:04:48,620 --> 00:04:52,800
>> -Last週五美國環保署宣布部分
2009年之間進行大眾奧迪汽車

98
00:04:52,800 --> 00:04:55,840
而今年用
所謂敗設備

99
00:04:55,840 --> 00:04:59,060
要解決排放法規
旨在保持空氣清潔。

100
00:04:59,060 --> 00:05:01,700
但是，這是什麼意思是什麼呢？

101
00:05:01,700 --> 00:05:04,666
>> 那麼，現代汽車有幾十個
裡面他們的計算機。

102
00:05:04,666 --> 00:05:07,040
而其中的一些計算機
幫助協調功能

103
00:05:07,040 --> 00:05:09,590
發動機為最佳的
同時確保性能

104
00:05:09,590 --> 00:05:12,340
有沒有太垃圾了
走出排氣管。

105
00:05:12,340 --> 00:05:15,170
他們實際上已經工作
這種方式對於現在幾十年。

106
00:05:15,170 --> 00:05:17,380
基本上，每一個部分
現代汽車的發動機

107
00:05:17,380 --> 00:05:20,080
具有傳感器或控制器
就可以了，而這些計算機

108
00:05:20,080 --> 00:05:23,460
正在閱讀數據數千
每秒進行調整時間

109
00:05:23,460 --> 00:05:26,220
像燃料與空氣的比率
那將會進入汽缸。

110
00:05:26,220 --> 00:05:28,730
>> 這些欺騙大眾
和奧迪車型都是柴油車，

111
00:05:28,730 --> 00:05:30,890
和柴油多了一個
真正重要的計算機

112
00:05:30,890 --> 00:05:34,030
控制參數，這是
未燃燃料的去量

113
00:05:34,030 --> 00:05:35,200
到排氣。

114
00:05:35,200 --> 00:05:36,310
現在，聽起來很糟糕。

115
00:05:36,310 --> 00:05:39,642
聽起來並不像你想
未燃燒的燃料在進入排氣。

116
00:05:39,642 --> 00:05:41,600
但在一個的情況下
柴油，你有什麼

117
00:05:41,600 --> 00:05:46,110
所謂的NOx捕集器是一種裝置，其
吸收和陷阱的氮氧化物

118
00:05:46,110 --> 00:05:48,880
這是污染物會
否則進入大氣中。

119
00:05:48,880 --> 00:05:53,040
這NOx捕集效果
是加強與未燃燒的燃料。

120
00:05:53,040 --> 00:05:56,650
所以一場失利設備是一個特殊的程序
裡面的這些計算機，可以使

121
00:05:56,650 --> 00:05:59,527
看起來像汽車達到排放
標準，即使它沒有。

122
00:05:59,527 --> 00:06:01,110
大眾汽車有一個問題就煩。

123
00:06:01,110 --> 00:06:04,050
它的柴油發動機被稱為
獲取巨大的燃油經濟性，

124
00:06:04,050 --> 00:06:07,510
但NOx捕集僅工作良好
當更多的燃料正被使用。

125
00:06:07,510 --> 00:06:10,460
所以車子就發現，
使用這種設備的失利，

126
00:06:10,460 --> 00:06:13,870
當它得到了一個排放
測試中，它會使用更多的燃料，

127
00:06:13,870 --> 00:06:16,830
使NOx捕集工作做好，
排放量將被罰款。

128
00:06:16,830 --> 00:06:21,130
但你得到的道路上，該裝置
關閉時，你燃燒更少的燃料

129
00:06:21,130 --> 00:06:24,256
但是你把高達40倍
更多的污染物進入大氣。

130
00:06:24,256 --> 00:06:26,130
但到底如何做
轎廂知道是

131
00:06:26,130 --> 00:06:27,720
被測試的排放標準？

132
00:06:27,720 --> 00:06:30,590
環保局說，這是一個複雜的
系統檢查的事

133
00:06:30,590 --> 00:06:34,090
像方向盤的位置，
速度快，發動機有多長時，

134
00:06:34,090 --> 00:06:35,507
甚至大氣壓。

135
00:06:35,507 --> 00:06:37,673
換句話說，有
沒辦法，這是意外

136
00:06:37,673 --> 00:06:40,260
因為軟件是
設計得非常仔細地檢測

137
00:06:40,260 --> 00:06:41,630
正式排放測試。

138
00:06:41,630 --> 00:06:43,588
這是一些相當嚴重
欺騙，這就是

139
00:06:43,588 --> 00:06:45,420
為什麼大眾在
如此嚴重的麻煩。

140
00:06:45,420 --> 00:06:48,600
事實上，他們的CEO，馬丁
文德恩，剛剛卸任。

141
00:06:48,600 --> 00:06:49,820
>> 那麼接下來會發生什麼？

142
00:06:49,820 --> 00:06:53,900
好吧，如果你的一半萬分之一
柴油捷達，甲殼蟲，的高爾夫，帕薩特，

143
00:06:53,900 --> 00:06:56,220
或者奧迪A3S影響，
好在是

144
00:06:56,220 --> 00:06:57,886
你的車仍然是安全駕駛。

145
00:06:57,886 --> 00:07:00,510
你不必把它扔掉
直到大眾汽車發布召回。

146
00:07:00,510 --> 00:07:02,509
但在某些時候，他們是
可能將不得不

147
00:07:02,509 --> 00:07:04,230
更新你的車裡面的軟件。

148
00:07:04,230 --> 00:07:06,927
當發生這種情況你可能
得到每罐少英里。

149
00:07:06,927 --> 00:07:09,260
律師們早已摩拳擦掌
彌補集體訴訟

150
00:07:09,260 --> 00:07:12,500
因此，業主可以得到補償
在未來的某個時候。

151
00:07:12,500 --> 00:07:15,832
但是，這不會
發生任何時間很快。

152
00:07:15,832 --> 00:07:16,711
>> [結束播放]

153
00:07:16,711 --> 00:07:19,960
DAVID J.馬蘭：所以這實際上提高了
一個有趣的大局觀問題

154
00:07:19,960 --> 00:07:20,660
作為信任。

155
00:07:20,660 --> 00:07:21,160
對嗎？

156
00:07:21,160 --> 00:07:24,300
我們每個人都有的iPhone或機器人或
東西在我們的口袋裡最有可能

157
00:07:24,300 --> 00:07:26,500
這些天來，或筆記本電腦
在我們圈是

158
00:07:26,500 --> 00:07:28,510
發運行的軟件
蘋果和微軟

159
00:07:28,510 --> 00:07:30,710
其他公司和束。

160
00:07:30,710 --> 00:07:34,240
但是我們怎麼知道什麼
這些軟件產品都在做

161
00:07:34,240 --> 00:07:37,680
實際上是什麼，這些
公司表示，他們正在做什麼？

162
00:07:37,680 --> 00:07:39,610
>> 舉例來說，誰的
說，你每次

163
00:07:39,610 --> 00:07:42,200
打個電話在您的iPhone
或Android手機或類似，

164
00:07:42,200 --> 00:07:45,650
，這一電話號碼也不是
被上傳到一些公司的服務器

165
00:07:45,650 --> 00:07:48,399
因為有些節目你已經
寫的，無論是操作

166
00:07:48,399 --> 00:07:51,070
系統本身喜歡的iOS或Android，
還是因為你已經下載

167
00:07:51,070 --> 00:07:53,880
一些第三方應用程序
不知怎的被監聽

168
00:07:53,880 --> 00:07:57,120
一切你打字或
一切你實際上說。

169
00:07:57,120 --> 00:07:59,500
你怎麼知道的是，當
你們正在運行鏘

170
00:07:59,500 --> 00:08:02,590
或者讓編譯您
在CS50，怎麼自己的軟件

171
00:08:02,590 --> 00:08:06,080
你認為CS50自己的員工，
由CS50庫的方式，

172
00:08:06,080 --> 00:08:08,690
一直沒有記錄每
你收到的字符串

173
00:08:08,690 --> 00:08:10,276
還是地地道道你收到？

174
00:08:10,276 --> 00:08:12,900
那麼，你當然可以看
在東西的源代碼

175
00:08:12,900 --> 00:08:15,233
像CS50庫，
可以看看源代碼

176
00:08:15,233 --> 00:08:18,170
對於Linux操作系統
在CS50 IDE中運行。

177
00:08:18,170 --> 00:08:23,090
但是，一個驚人的表現
給予早在1984年

178
00:08:23,090 --> 00:08:26,730
在收到的圖靈獎由
已知的非常著名的計算機科學家

179
00:08:26,730 --> 00:08:29,750
as--叫肯·湯普森誰
獲得了圖靈獎哪些

180
00:08:29,750 --> 00:08:33,500
是有點計算機科學的
諾貝爾文學獎，如果你願意，

181
00:08:33,500 --> 00:08:35,309
他在一個工作
操作系統被稱為

182
00:08:35,309 --> 00:08:39,039
Unix的，這是在非常相似
精神，我們使用的是Linux操作系統。

183
00:08:39,039 --> 00:08:41,960
他問的問題，他的
獲獎感言，基本上

184
00:08:41,960 --> 00:08:44,910
放下了框架
年復一年的討論

185
00:08:44,910 --> 00:08:46,970
關於信任和安全，是這樣的。

186
00:08:46,970 --> 00:08:50,410
應在多大程度上一個信任一個
聲明一program--一塊

187
00:08:50,410 --> 00:08:53,010
的software--是免費的木馬？

188
00:08:53,010 --> 00:08:56,500
也許是信任更重要
誰寫的軟件的人。

189
00:08:56,500 --> 00:08:58,650
>> 而事實上，我們已經鏈接
該傳言稱，他

190
00:08:58,650 --> 00:09:02,400
在接受這一獎項時，給了
在CS50網站上的80年代

191
00:09:02,400 --> 00:09:04,030
在今天的講座頁。

192
00:09:04,030 --> 00:09:06,071
因為你會看到什麼
是，他居然給

193
00:09:06,071 --> 00:09:09,430
怎麼連一個​​相當簡單的例子
編譯器像鏘或什麼

194
00:09:09,430 --> 00:09:13,950
編譯器他人已經使用在過去，
如果嵌入了編譯器，我們什麼

195
00:09:13,950 --> 00:09:18,190
自己使用是一個幾乎沒有
條件，基本上說，

196
00:09:18,190 --> 00:09:22,360
如果您發現該代碼使用
在GetString函數或調用getInt

197
00:09:22,360 --> 00:09:26,600
功能，繼續前進，插入
後門或木馬

198
00:09:26,600 --> 00:09:29,340
這樣該程序
現在有一些零

199
00:09:29,340 --> 00:09:30,930
和那些做一些惡意的。

200
00:09:30,930 --> 00:09:33,080
記錄你的所有
按鍵，上傳數據

201
00:09:33,080 --> 00:09:35,100
一些服務器，還是真的什麼。

202
00:09:35,100 --> 00:09:37,290
>> 什麼肯·湯普森
繼續做他的談話

203
00:09:37,290 --> 00:09:40,580
是要證明，即使
您可以訪問源

204
00:09:40,580 --> 00:09:43,794
編譯器的代碼
惡意可能會做這個，

205
00:09:43,794 --> 00:09:46,210
這並不重要，因為
有這種雞與蛋

206
00:09:46,210 --> 00:09:49,500
過去的許多現實
年即編譯器

207
00:09:49,500 --> 00:09:51,960
用於編譯自己。

208
00:09:51,960 --> 00:09:55,440
換句話說，一個人回來的路上時，
只好寫了第一個編譯器。

209
00:09:55,440 --> 00:09:59,060
此後，任何時候他們已經更新
一個編譯器，通過改變它的源代碼，

210
00:09:59,060 --> 00:10:02,020
增加功能並重新編譯
對於我們這樣的人使用，那麼，

211
00:10:02,020 --> 00:10:04,270
他們使用舊的
版本的編譯器

212
00:10:04,270 --> 00:10:06,370
編譯新
版本的編譯器。

213
00:10:06,370 --> 00:10:08,370
如果你看看
在他給了談話，

214
00:10:08,370 --> 00:10:10,970
你會看到，由於
那個圓的，

215
00:10:10,970 --> 00:10:14,330
你其實可以有錯誤或
木馬嵌入軟件

216
00:10:14,330 --> 00:10:14,990
我們使用。

217
00:10:14,990 --> 00:10:18,010
而且，即使你看
源代碼的程序，

218
00:10:18,010 --> 00:10:21,550
它甚至可能不是顯而易見
因為掛羊頭賣狗肉實際上是

219
00:10:21,550 --> 00:10:24,710
在一個有些舊版本
編譯器，從此便

220
00:10:24,710 --> 00:10:27,340
注入威脅到我們的軟件。

221
00:10:27,340 --> 00:10:29,740
>> 這僅僅是說，我們
真的不能也不應該

222
00:10:29,740 --> 00:10:32,939
在我們的筆記本電腦信任的軟件運行
或電話或任何數量的位。

223
00:10:32,939 --> 00:10:36,230
而事實上，後來在這個學期的時候
我們開始談論網絡編程

224
00:10:36,230 --> 00:10:38,521
而真正開始建設
Web應用程序自己，

225
00:10:38,521 --> 00:10:40,285
我們將談論這些
威脅和其他。

226
00:10:40,285 --> 00:10:43,410
現在，你可能想知道，發現
，有一個小小的達斯

227
00:10:43,410 --> 00:10:45,842
維達的剪輯
邊緣是顯示有

228
00:10:45,842 --> 00:10:47,550
關於大眾。是否
你從來沒有見過，我

229
00:10:47,550 --> 00:10:49,190
認為我們應該減輕
心情，因為這是所有

230
00:10:49,190 --> 00:10:50,780
很鬱悶的和可怕的。

231
00:10:50,780 --> 00:10:52,910
我要回頭看
在超級杯2011

232
00:10:52,910 --> 00:10:55,300
當一個商業用
Volkswagen--這

233
00:10:55,300 --> 00:10:59,620
幾乎讓他們可愛的again--
播出，第一次在電視上。

234
00:10:59,620 --> 00:11:04,039
這是60秒的剪輯
我想你會喜歡。

235
00:11:04,039 --> 00:11:04,705
[視頻回放]

236
00:11:04,705 --> 00:11:08,198
[MUSIC  - 題材從“星球大戰”]

237
00:11:08,198 --> 00:11:35,643

238
00:11:35,643 --> 00:11:38,138
[狗叫]

239
00:11:38,138 --> 00:11:50,114

240
00:11:50,114 --> 00:11:53,607
[汽車啟動]

241
00:11:53,607 --> 00:12:04,086

242
00:12:04,086 --> 00:12:05,955
[結束播放]

243
00:12:05,955 --> 00:12:06,830
DAVID J.馬蘭：是的。

244
00:12:06,830 --> 00:12:07,663
我只是檢查。

245
00:12:07,663 --> 00:12:11,360
這車是違規的名單上。

246
00:12:11,360 --> 00:12:12,000
好的。

247
00:12:12,000 --> 00:12:14,040
所以我們看一些
前偽片刻。

248
00:12:14,040 --> 00:12:15,380
這裡是一個更大的
的偽代碼段

249
00:12:15,380 --> 00:12:16,921
我們已經見過幾次迄今。

250
00:12:16,921 --> 00:12:19,970
而讓我們使用這是一個機會
現在來介紹一種新的編程

251
00:12:19,970 --> 00:12:23,776
我們做技術
見算法

252
00:12:23,776 --> 00:12:25,400
上週，當我們看著歸併排序。

253
00:12:25,400 --> 00:12:28,270
但是，讓我們正式確定一下，看看如何
我們可以使用它在實際的代碼，

254
00:12:28,270 --> 00:12:30,350
然後我們將使用這個
技術的道路最

255
00:12:30,350 --> 00:12:32,000
可能解決某些其他問題。

256
00:12:32,000 --> 00:12:35,790
>> 所以這是第一個項目之一，我們
曾經寫道，儘管在偽代碼。

257
00:12:35,790 --> 00:12:37,790
而這是什麼程序
讓我們做課程

258
00:12:37,790 --> 00:12:41,510
是要找到麥克·史密斯在電話簿。

259
00:12:41,510 --> 00:12:46,216
同時注意在特定行8
和11有這樣轉到聲明。

260
00:12:46,216 --> 00:12:48,090
而事實上，某些
語言，C其中，

261
00:12:48,090 --> 00:12:50,006
實際上確實有
聲明字面上

262
00:12:50,006 --> 00:12:52,710
去，讓你
跳轉到指定的行。

263
00:12:52,710 --> 00:12:55,470
一旦因為它是一般不贊成
它可以很容易被濫用

264
00:12:55,470 --> 00:12:58,490
你就可以開始你的跳躍
項目所有的地方，而不是

265
00:12:58,490 --> 00:13:00,690
使用的那種
邏輯和控制流

266
00:13:00,690 --> 00:13:04,000
我們已經使用迄今只
循環和條件等。

267
00:13:04,000 --> 00:13:08,660
>> 但是，我們可以簡化這個算法
在偽代碼如下。

268
00:13:08,660 --> 00:13:11,250
相反，這種反复的
或循環的方法

269
00:13:11,250 --> 00:13:14,160
我們一直走去，
回來，回到線三條，

270
00:13:14,160 --> 00:13:18,300
正中下懷我們為什麼不踢多
一般說，在七號線和10，

271
00:13:18,300 --> 00:13:20,570
只需更換這兩個
對用線，

272
00:13:20,570 --> 00:13:22,810
否則，如果史密斯早
在本書中，我們將

273
00:13:22,810 --> 00:13:25,110
搜索麥克在
書的左半邊。

274
00:13:25,110 --> 00:13:28,560
否則，如果史密斯後來在
書，在右邊的搜索麥克

275
00:13:28,560 --> 00:13:29,540
一半的書。

276
00:13:29,540 --> 00:13:31,180
同時注意已圓。

277
00:13:31,180 --> 00:13:31,680
對嗎？

278
00:13:31,680 --> 00:13:34,250
我在尋找邁克
電話簿，然後

279
00:13:34,250 --> 00:13:37,090
我最終也許打
七號線或者10號線

280
00:13:37,090 --> 00:13:41,089
和我的指令對自己的搜索
麥克一半的電話簿。

281
00:13:41,089 --> 00:13:42,380
好了，我怎麼尋找邁克？

282
00:13:42,380 --> 00:13:44,213
我在中間
搜索麥克，為什麼

283
00:13:44,213 --> 00:13:45,860
樣的，你給我轉了一圈？

284
00:13:45,860 --> 00:13:49,590
但是，這是因為什麼是確定
情況發生的問題的大小，

285
00:13:49,590 --> 00:13:52,630
寫在管線7和10？

286
00:13:52,630 --> 00:13:54,989
我們不只是說搜索
麥克，搜索麥克。

287
00:13:54,989 --> 00:13:56,280
我們具體說了什麼？

288
00:13:56,280 --> 00:13:58,694

289
00:13:58,694 --> 00:14:01,610
在左半邊尋找他
右半邊是有效

290
00:14:01,610 --> 00:14:03,440
該問題的一半大小。

291
00:14:03,440 --> 00:14:07,170
所以沒關係，我們是那種
搞這個循環，

292
00:14:07,170 --> 00:14:09,180
這種循環論證，
因為至少我們

293
00:14:09,180 --> 00:14:11,090
使問題越來越小。

294
00:14:11,090 --> 00:14:14,220
而最終我們將到達
即所謂的基的情況下

295
00:14:14,220 --> 00:14:16,780
我們只有一個頁面left--
上週我們的志願者

296
00:14:16,780 --> 00:14:18,684
did--我們有一個頁面
離開，然後我們不

297
00:14:18,684 --> 00:14:21,600
要不斷尋找麥克·史密斯
因為他無論是在該網頁上

298
00:14:21,600 --> 00:14:23,080
或者他是不是。

299
00:14:23,080 --> 00:14:27,480
>> 那麼我們怎樣才能實現這個想法，這個
排序圓在實際的代碼嗎？

300
00:14:27,480 --> 00:14:31,030
好了，我們可以利用技術
該真實一般被稱為遞歸。

301
00:14:31,030 --> 00:14:33,960
我們已經看到了這個在
偽代碼歸併排序最後一周。

302
00:14:33,960 --> 00:14:37,190
回想一下，這是
偽代碼歸併排序。

303
00:14:37,190 --> 00:14:40,560
這可以說是比更簡單
泡沫或選擇或插入排序

304
00:14:40,560 --> 00:14:43,310
只是在簡單計
使用它可以表達出來。

305
00:14:43,310 --> 00:14:46,750
>> 但是，這是因為
我們是那種圓

306
00:14:46,750 --> 00:14:51,350
他說，搜索的東西
通過再次尋找它。

307
00:14:51,350 --> 00:14:53,960
但是，我們正在尋找無論是在
左半或右半

308
00:14:53,960 --> 00:14:56,070
然後最終我們
合併在此情況下。

309
00:14:56,070 --> 00:14:58,520
但在這裡，也與
這兩種類型的線條，

310
00:14:58,520 --> 00:15:01,320
沒有我們再次有這樣的
想法遞歸。

311
00:15:01,320 --> 00:15:05,350
而具體是什麼意思，
在一個算法的上下文中，

312
00:15:05,350 --> 00:15:10,880
是一個算法是遞歸
如果使用或調用本身。

313
00:15:10,880 --> 00:15:14,330
>> 或用C方面，一個功能是
recursive--一個調用的函數

314
00:15:14,330 --> 00:15:18,510
foo是遞歸的，如果FOO，
某處它的源代碼，

315
00:15:18,510 --> 00:15:21,250
調用函數foo本身。

316
00:15:21,250 --> 00:15:25,790
而這一切的話永遠富不壞
是一次次給自己。

317
00:15:25,790 --> 00:15:30,600
這是確定的，如果FOO最終停止，一樣
歸併排序，說，等一下，

318
00:15:30,600 --> 00:15:32,980
如果這個問題是超
小，例如，

319
00:15:32,980 --> 00:15:35,840
或者我發現他的人，我
尋找，只是返回。

320
00:15:35,840 --> 00:15:41,000
不要遞歸，不
週期性再次調用自己。

321
00:15:41,000 --> 00:15:44,200
>> 因此，讓我們一起來看看
這是如何實際工作。

322
00:15:44,200 --> 00:15:48,430
所以，我要繼續前進，開
在這裡兩個源代碼示例。

323
00:15:48,430 --> 00:15:50,321
其中之一稱為西格瑪0。

324
00:15:50,321 --> 00:15:52,320
這是不是在所有
遞歸，但讓我們

325
00:15:52,320 --> 00:15:53,694
一起來看看這是什麼程序做。

326
00:15:53,694 --> 00:15:55,737
我已經去除了所有
從中但所有評論

327
00:15:55,737 --> 00:15:58,070
對CS50的源代碼
網站上有，如果你的意見

328
00:15:58,070 --> 00:15:59,570
希望通過它來讀取一次。

329
00:15:59,570 --> 00:16:02,010
而讓我們做一對夫婦
神智檢查這裡。

330
00:16:02,010 --> 00:16:06,640
>> 因此，在這段代碼的頂部，
我們有包括CS50.h.

331
00:16:06,640 --> 00:16:07,650
這是什麼呢？

332
00:16:07,650 --> 00:16:08,990
這裡為什麼是它？

333
00:16:08,990 --> 00:16:11,740
在合理通俗地說。

334
00:16:11,740 --> 00:16:12,424
它有什麼作用？

335
00:16:12,424 --> 00:16:12,858
是啊。

336
00:16:12,858 --> 00:16:14,160
>> 聽眾：所以調用getInt功能工作。

337
00:16:14,160 --> 00:16:16,243
>> DAVID J.馬蘭：所以這
調用getInt功能工作。

338
00:16:16,243 --> 00:16:18,115
因為這裡面
文件CS50.h，這

339
00:16:18,115 --> 00:16:20,950
不久的我們會看到
它的源代碼方面，

340
00:16:20,950 --> 00:16:23,270
有一堆的功能
declared--調用getInt，GetString的，

341
00:16:23,270 --> 00:16:26,950
和一幫others--的除非
我們實際上有包括線路，

342
00:16:26,950 --> 00:16:29,320
編譯鏘不
要知道它的存在。

343
00:16:29,320 --> 00:16:32,400
而且同樣適用於線
2其中int定義

344
00:16:32,400 --> 00:16:35,101
printf的，這是一個功能
我們繼續使用相當多。

345
00:16:35,101 --> 00:16:37,850
現在，四線似乎有點時髦
因為它只是一個單行。

346
00:16:37,850 --> 00:16:41,570
它有一個分號，沒有捲曲
牙套，它裡面沒有任何代碼。

347
00:16:41,570 --> 00:16:44,640
但是，我們才稱之為
這件事情在過去的幾個星期？

348
00:16:44,640 --> 00:16:45,140
是啊。

349
00:16:45,140 --> 00:16:46,060
因此，一個原型。

350
00:16:46,060 --> 00:16:48,390
為什麼我們有一個
原型，這似乎

351
00:16:48,390 --> 00:16:51,050
是有點多餘
通常是因為我們平時

352
00:16:51,050 --> 00:16:53,474
再次查看功能
後來在該文件中，對不對？

353
00:16:53,474 --> 00:16:56,390
那麼，為什麼我們have--你只是
抓你的頭，但我會接受它。

354
00:16:56,390 --> 00:16:57,302
是啊。

355
00:16:57,302 --> 00:17:00,000
>> 聽眾：[聽不清]
主後功能。

356
00:17:00,000 --> 00:17:01,000
DAVID J.馬蘭：沒錯。

357
00:17:01,000 --> 00:17:04,089
這樣編譯器知道你
最終確定或實施

358
00:17:04,089 --> 00:17:06,579
之後，主要的功能，大概是。

359
00:17:06,579 --> 00:17:08,462
所以鏘最
編譯器是一種愚蠢的

360
00:17:08,462 --> 00:17:10,510
他們會只知道
你告訴他們。

361
00:17:10,510 --> 00:17:12,569
如果你想使用
一個名為西格瑪功能，

362
00:17:12,569 --> 00:17:15,710
你最好教的編譯器
它存在於提前。

363
00:17:15,710 --> 00:17:17,970
>> 現在，主本身，甚至
雖然這是一幫行，

364
00:17:17,970 --> 00:17:19,839
是現在非常熟悉的希望。

365
00:17:19,839 --> 00:17:21,942
它有一個do while循環
在生活中，其目的

366
00:17:21,942 --> 00:17:24,400
這裡顯然是獲得一個
從用戶正整數。

367
00:17:24,400 --> 00:17:27,349
而只是一味地纏著他
或她，直到他們合作。

368
00:17:27,349 --> 00:17:30,670
隨後在第16行我有
一個有趣的電話。

369
00:17:30,670 --> 00:17:31,570
IntAnswer。

370
00:17:31,570 --> 00:17:33,710
這在左手
邊給了我一個Int

371
00:17:33,710 --> 00:17:36,650
它可以store--稱為Answer--
這是要以存儲，顯然，

372
00:17:36,650 --> 00:17:39,090
西格瑪的返回值。

373
00:17:39,090 --> 00:17:41,840
所以適馬只是一個
任意但有意義的名稱

374
00:17:41,840 --> 00:17:44,500
我已經給一個函數
在生活中，其目的

375
00:17:44,500 --> 00:17:47,680
是需要一個argument--
我們把它叫做N的這個case--

376
00:17:47,680 --> 00:17:52,280
和剛採取這一數目的總和
再加上每一個正數的

377
00:17:52,280 --> 00:17:53,200
比它小。

378
00:17:53,200 --> 00:17:58,140
>> 所以，如果我通過了2號線到
西格瑪，我要加2加1

379
00:17:58,140 --> 00:18:00,240
加上0--不0--這樣給我3。

380
00:18:00,240 --> 00:18:05,320
如果我通過在3個西格瑪，我想
有3加2加1，這給了我6。

381
00:18:05,320 --> 00:18:05,900
等等。

382
00:18:05,900 --> 00:18:09,750
因此，它只是增加了所有的
數小於或等於它。

383
00:18:09,750 --> 00:18:12,040
>> 現在，到這裡我只是去
打印出來的答案。

384
00:18:12,040 --> 00:18:17,330
因此，作為一個快速的完整性檢查，讓我們
使六西格瑪0--點斜線西格瑪0--

385
00:18:17,330 --> 00:18:18,690
並讓我在2型。

386
00:18:18,690 --> 00:18:19,960
而我確實拿到3。

387
00:18:19,960 --> 00:18:21,240
讓我輸入3。

388
00:18:21,240 --> 00:18:22,860
我確實得到6。

389
00:18:22,860 --> 00:18:27,636
如果任何人都可以快速地做數學題，
如果我做50我該怎麼弄？

390
00:18:27,636 --> 00:18:29,839
>> 聽眾：[聽不清]。

391
00:18:29,839 --> 00:18:30,880
DAVID J.馬蘭：哦，不。

392
00:18:30,880 --> 00:18:33,340
但是1275這是非常密切的。

393
00:18:33,340 --> 00:18:38,850
因此，這是在做50的結果
加49加48加47加46

394
00:18:38,850 --> 00:18:40,349
一路下跌至1。

395
00:18:40,349 --> 00:18:41,390
所以這是所有六西格瑪一樣。

396
00:18:41,390 --> 00:18:43,350
但是，讓我們看看怎麼樣了
現在已經實現了。

397
00:18:43,350 --> 00:18:45,790
所以到這裡是函數本身。

398
00:18:45,790 --> 00:18:49,000
而這似乎並不有
任何與遞歸呢。

399
00:18:49,000 --> 00:18:51,070
事實上，我們正​​在使用
老派技術。

400
00:18:51,070 --> 00:18:56,680
我初始化的變量稱為總和
到零，然後我有一個foreloop在這裡，

401
00:18:56,680 --> 00:19:00,790
而我所謂的聲明一個Int
我，將其設置等於1--

402
00:19:00,790 --> 00:19:04,080
雖然我可以將其設置為
零，但由於我在做加法，

403
00:19:04,080 --> 00:19:05,340
誰在乎，如果是0或1。

404
00:19:05,340 --> 00:19:06,660
這將沒有任何效果。

405
00:19:06,660 --> 00:19:10,110
>> 所以我迭代，​​只要我是
小於或等於m，其中

406
00:19:10,110 --> 00:19:11,671
是傳入的參數。

407
00:19:11,671 --> 00:19:13,670
然後，我只是不停
一，增量和Insight

408
00:19:13,670 --> 00:19:20,010
循環的所有我做的是做總和
加等於一，這就是故意的。

409
00:19:20,010 --> 00:19:22,326
我並不想這樣做，在這
情況下，像總和加上加。

410
00:19:22,326 --> 00:19:24,790
我想實際添加
I的電流值

411
00:19:24,790 --> 00:19:28,190
這使越來越大
做大到正在運行的理貨。

412
00:19:28,190 --> 00:19:30,210
>> 然後我返回總和。

413
00:19:30,210 --> 00:19:33,850
所以回答得的價值總和。

414
00:19:33,850 --> 00:19:35,282
然後，我把它打印出來。

415
00:19:35,282 --> 00:19:37,740
因此，有一個機會，在這裡，
雖然，那種簡化

416
00:19:37,740 --> 00:19:41,260
這段代碼概念
而那種打擊一個人的

417
00:19:41,260 --> 00:19:43,250
介意條款
簡單，即使它

418
00:19:43,250 --> 00:19:45,700
需要一段時間來排序
中明白為什麼這

419
00:19:45,700 --> 00:19:47,330
就是在這些小例子強大。

420
00:19:47,330 --> 00:19:50,380
這裡是西格瑪埃德蒙頓所以
第二個版本的代碼。

421
00:19:50,380 --> 00:19:55,290
一切都往上頂是相同的，從而
同樣的故事，適用於前。

422
00:19:55,290 --> 00:19:59,220
但是，現在讓我們來看看
實施六西格瑪的哪些

423
00:19:59,220 --> 00:20:05,040
我已經削減到只有這
lines--四行代碼，真的，

424
00:20:05,040 --> 00:20:06,980
再加上一些大括號和空白。

425
00:20:06,980 --> 00:20:07,930
>> 但是我在做什麼？

426
00:20:07,930 --> 00:20:11,050
如果m小於或等於
零，我需要那種處理

427
00:20:11,050 --> 00:20:12,490
該超級簡單的情況。

428
00:20:12,490 --> 00:20:15,450
如果你把我零或任何東西
負這只是奇怪，

429
00:20:15,450 --> 00:20:17,909
我只是隨意
但始終返回零。

430
00:20:17,909 --> 00:20:20,200
我不希望這件事
進入一些奇怪的無限

431
00:20:20,200 --> 00:20:21,810
因為負值循環。

432
00:20:21,810 --> 00:20:25,070
所以，我只是說，如果你給我
小於或等於0，我回零。

433
00:20:25,070 --> 00:20:28,220
>> 但是，這是好事，因為這是
電話簿中的單頁

434
00:20:28,220 --> 00:20:28,790
剩下的。

435
00:20:28,790 --> 00:20:32,660
我咬過一個很具體的問題，
並沒有要求什麼遞歸。

436
00:20:32,660 --> 00:20:36,580
但在第31行，什麼
我似乎是在做什麼？

437
00:20:36,580 --> 00:20:39,780
括號只是保持
事情，希望更清晰一點。

438
00:20:39,780 --> 00:20:42,110
但是，所有我做的是我
返回M--什麼

439
00:20:42,110 --> 00:20:45,790
你的手我 - 加
M--遺憾的價值，

440
00:20:45,790 --> 00:20:49,052
加為m減1西格瑪的價值。

441
00:20:49,052 --> 00:20:50,010
所以，這是什麼意思？

442
00:20:50,010 --> 00:20:53,965
如果你給我3號作為輸入，
答案我想獲得最終

443
00:20:53,965 --> 00:20:57,307
6，因為3加2加1給了我6。

444
00:20:57,307 --> 00:20:59,390
但我怎麼想
如何代碼運行？

445
00:20:59,390 --> 00:21:03,070
我第一次打電話西格瑪
我傳遞值3，

446
00:21:03,070 --> 00:21:07,960
這等於是說了一塊
紙，這裡的值3

447
00:21:07,960 --> 00:21:09,920
我一直在傳遞這是西格瑪。

448
00:21:09,920 --> 00:21:13,090
顯然3不小於0，所以
IF條件不適用。

449
00:21:13,090 --> 00:21:14,020
的人這樣做。

450
00:21:14,020 --> 00:21:14,990
所以，我該怎麼辦？

451
00:21:14,990 --> 00:21:19,902
我想回到米，這是
3，加西格瑪為m減1。

452
00:21:19,902 --> 00:21:21,110
因此，讓我跟踪了這一點。

453
00:21:21,110 --> 00:21:22,710
我打算把這個
一張紙了。

454
00:21:22,710 --> 00:21:24,668
而什麼樣的價值，是
清晰的，我是要通過

455
00:21:24,668 --> 00:21:26,540
進入適馬在這一點上的故事？

456
00:21:26,540 --> 00:21:28,080
什麼號碼？

457
00:21:28,080 --> 00:21:28,610
2，對不對？

458
00:21:28,610 --> 00:21:29,670
3減1，2。

459
00:21:29,670 --> 00:21:32,000
所以，我只是需要一點點
紙片在這裡。

460
00:21:32,000 --> 00:21:33,931
所以，現在西格瑪是越來越再次調用。

461
00:21:33,931 --> 00:21:35,930
我也故意放
下來，因為它是

462
00:21:35,930 --> 00:21:38,070
有點像暫停
該版本的故事

463
00:21:38,070 --> 00:21:40,720
因為現在我專注
對m的減1的信號。

464
00:21:40,720 --> 00:21:42,660
因此，M的3，M減1，2。

465
00:21:42,660 --> 00:21:45,110
因此，這裡是2，我已經通過了。

466
00:21:45,110 --> 00:21:48,510
2顯然是不小於
0，這樣的情況下不適用。

467
00:21:48,510 --> 00:21:53,445
否則我回到米，這是這個
的事情，再加上西格瑪還有什麼價值呢？

468
00:21:53,445 --> 00:21:56,160

469
00:21:56,160 --> 00:21:59,650
因此，如果1--的西格瑪因為m是
現在2 SO 2減1為1。

470
00:21:59,650 --> 00:22:01,950
所以，現在我只值1。

471
00:22:01,950 --> 00:22:04,810
我只是路過的數量
1到函數sigma--

472
00:22:04,810 --> 00:22:09,120
還是我自己這裡 - 所以1顯然是不
小於零，仍然不適用。

473
00:22:09,120 --> 00:22:12,970
>> 否則返回1加什麼西格瑪？

474
00:22:12,970 --> 00:22:13,470
0。

475
00:22:13,470 --> 00:22:14,678
因此，讓我只記得。

476
00:22:14,678 --> 00:22:15,920
我會回來以後。

477
00:22:15,920 --> 00:22:18,060
現在我要繼續前進，並記
向下數0，因為這是

478
00:22:18,060 --> 00:22:19,470
我的論點或參數。

479
00:22:19,470 --> 00:22:22,400
我順利通過了數0
最後這個過程

480
00:22:22,400 --> 00:22:25,760
只是重複自己的廣告
nauseum不會停止，因為什麼

481
00:22:25,760 --> 00:22:28,820
我馬上做一次，我看到這個0？

482
00:22:28,820 --> 00:22:29,790
我回零。

483
00:22:29,790 --> 00:22:31,790
所以，現在你必須倒回的故事。

484
00:22:31,790 --> 00:22:34,430
>> 如果我現在往回走的時候，
什麼是最近的事

485
00:22:34,430 --> 00:22:36,670
我做了，如果你是從字面上
倒帶視頻？

486
00:22:36,670 --> 00:22:41,630
我要拿起最新的
1這給了我1加0就是1。

487
00:22:41,630 --> 00:22:44,100
如果我繼續倒帶
故事，那將會給我

488
00:22:44,100 --> 00:22:46,880
2加上該運行值，這是1。

489
00:22:46,880 --> 00:22:47,789
所以這是3。

490
00:22:47,789 --> 00:22:49,330
然後，我會繼續後退。

491
00:22:49,330 --> 00:22:54,220
當我第一次放下數量
3--所以3 + 3給了我6。

492
00:22:54,220 --> 00:22:57,272
>> 而現在，如果你倒帶
視頻，直到這一點，

493
00:22:57,272 --> 00:22:58,980
這是很
第一個問題我問。

494
00:22:58,980 --> 00:23:01,450
當傳遞3，什麼是3西格瑪？

495
00:23:01,450 --> 00:23:04,204
它們也確實6的總和
所有這些紙片。

496
00:23:04,204 --> 00:23:07,120
因此，如果這需要一點時間來
包裝你的頭腦圍繞，這很好。

497
00:23:07,120 --> 00:23:10,700
但認為這是一個little--它
是非常謹慎的，我疊

498
00:23:10,700 --> 00:23:12,990
在彼此的頂部，這些數字。

499
00:23:12,990 --> 00:23:17,440
這有點像有一個
memory--創紀錄的時間，

500
00:23:17,440 --> 00:23:19,940
像在視頻洗滌器，
我的確可以倒帶研究。

501
00:23:19,940 --> 00:23:24,350
而且我們要回來
隱喻的只是一點點。

502
00:23:24,350 --> 00:23:28,240
>> 但首先，事實證明，有
很多愛好者和有趣的人，

503
00:23:28,240 --> 00:23:29,614
我想，在谷歌。

504
00:23:29,614 --> 00:23:31,530
會有人誰是非常
擅長谷歌搜索的頭腦

505
00:23:31,530 --> 00:23:34,270
上來就一會兒和
幫我尋找的東西？

506
00:23:34,270 --> 00:23:35,650
非常，非常低調。

507
00:23:35,650 --> 00:23:37,870
有人誰是從來沒有
來之前，也許吧。

508
00:23:37,870 --> 00:23:38,370
確定。

509
00:23:38,370 --> 00:23:39,030
是嗎？

510
00:23:39,030 --> 00:23:39,530
來吧。

511
00:23:39,530 --> 00:23:41,410
下來吧。

512
00:23:41,410 --> 00:23:42,183
你叫什麼名字？

513
00:23:42,183 --> 00:23:42,870
>> SAM：山姆。

514
00:23:42,870 --> 00:23:44,290
>> DAVID J.馬蘭：薩姆，下來吧。

515
00:23:44,290 --> 00:23:45,320
這是相同的。

516
00:23:45,320 --> 00:23:46,280
認識你很高興。

517
00:23:46,280 --> 00:23:46,780
嘿。

518
00:23:46,780 --> 00:23:47,580
你過來吧。

519
00:23:47,580 --> 00:23:51,290
所以，我需要你做，如果
你可以，山姆，這裡是谷歌。

520
00:23:51,290 --> 00:23:53,240
您可以搜索術語遞歸？

521
00:23:53,240 --> 00:23:55,770

522
00:23:55,770 --> 00:23:56,270
不要糟蹋。

523
00:23:56,270 --> 00:23:59,940

524
00:23:59,940 --> 00:24:00,970
>> 現在let's--是的。

525
00:24:00,970 --> 00:24:03,380
單擊OK了。

526
00:24:03,380 --> 00:24:04,315
更好單擊。

527
00:24:04,315 --> 00:24:07,020

528
00:24:07,020 --> 00:24:08,020
啊，明白這一點。

529
00:24:08,020 --> 00:24:08,520
沒有？

530
00:24:08,520 --> 00:24:09,050
確定。

531
00:24:09,050 --> 00:24:10,430
因此，讓我們做一對夫婦的人。

532
00:24:10,430 --> 00:24:12,830
與其說相關
學術在這裡，但你

533
00:24:12,830 --> 00:24:14,520
曾經搜查谷歌的字謎？

534
00:24:14,520 --> 00:24:15,280
>> SAM：第

535
00:24:15,280 --> 00:24:15,520
>> DAVID J.馬蘭：OK。

536
00:24:15,520 --> 00:24:17,186
搜索字謎，而不是遞歸。

537
00:24:17,186 --> 00:24:22,540

538
00:24:22,540 --> 00:24:23,790
怎麼樣歪斜。

539
00:24:23,790 --> 00:24:25,515
你有沒有搜索歪？

540
00:24:25,515 --> 00:24:29,260

541
00:24:29,260 --> 00:24:32,692
現在，這個有點困難
見但希望everything's--確定。

542
00:24:32,692 --> 00:24:34,150
這只是你和我享受這個。

543
00:24:34,150 --> 00:24:34,690
確定。

544
00:24:34,690 --> 00:24:38,950
>> 那麼最後，這個one's--
這是一個有點歪。

545
00:24:38,950 --> 00:24:40,810
現在做一個桶滾。

546
00:24:40,810 --> 00:24:44,460

547
00:24:44,460 --> 00:24:45,310
太好了。

548
00:24:45,310 --> 00:24:45,910
好的。

549
00:24:45,910 --> 00:24:47,110
非常感謝薩姆。

550
00:24:47,110 --> 00:24:49,416
在這裡你去。

551
00:24:49,416 --> 00:24:50,400
謝謝。

552
00:24:50,400 --> 00:24:52,807
>> 那麼是什麼在所有事情
這些愚蠢的例子嗎？

553
00:24:52,807 --> 00:24:55,640
因此，其實，引擎蓋下
谷歌的數百萬行代碼

554
00:24:55,640 --> 00:24:58,860
顯然是一些愚蠢的IF
這本質上是條件

555
00:24:58,860 --> 00:25:01,160
檢查用戶是否具有
鍵入這句話，

556
00:25:01,160 --> 00:25:03,760
做一些事情，大概花了
時間的非平凡量

557
00:25:03,760 --> 00:25:06,080
實施只是為了
有趣的是這種方式。

558
00:25:06,080 --> 00:25:08,430
但是，這一切都沸騰
向下至罩下方。

559
00:25:08,430 --> 00:25:11,570
但是，當然，遞歸
更的更老派

560
00:25:11,570 --> 00:25:13,880
例如在那些特殊的技巧。

561
00:25:13,880 --> 00:25:16,880
而且肯定有其他人在那裡
同時，我們也許甚至還沒有

562
00:25:16,880 --> 00:25:18,230
發現只是還沒有。

563
00:25:18,230 --> 00:25:22,830
>> 因此，採取一看，還是考慮
現在下面的程序，

564
00:25:22,830 --> 00:25:24,830
當然抓住任何
這些對你的出路。

565
00:25:24,830 --> 00:25:28,820
我要繼續前進，
打開一個程序，是

566
00:25:28,820 --> 00:25:30,920
要嘗試交換兩個值。

567
00:25:30,920 --> 00:25:33,210
但在此之前，我們去那裡，讓我們做到這一點。

568
00:25:33,210 --> 00:25:38,500
我們可以多一個獲得
志願者，我覺得呢？

569
00:25:38,500 --> 00:25:40,480
你願意做志願者？

570
00:25:40,480 --> 00:25:40,980
沒有？

571
00:25:40,980 --> 00:25:41,890
上來吧。

572
00:25:41,890 --> 00:25:42,390
上來吧。

573
00:25:42,390 --> 00:25:42,890
好的。

574
00:25:42,890 --> 00:25:44,136
所以，你的名字是什麼？

575
00:25:44,136 --> 00:25:44,810
>> LAUREN：勞倫。

576
00:25:44,810 --> 00:25:45,768
>> DAVID J.馬蘭：勞倫。

577
00:25:45,768 --> 00:25:46,890
上來吧，勞倫。

578
00:25:46,890 --> 00:25:50,140
所以勞倫正在
這裡的挑戰如下。

579
00:25:50,140 --> 00:25:52,310
認識你很高興。

580
00:25:52,310 --> 00:25:55,730
因此，勞倫在這裡有在前面
她的兩個空杯子。

581
00:25:55,730 --> 00:25:57,570
而且我們有一些橙色
果汁和一些牛奶

582
00:25:57,570 --> 00:26:00,301
我們打算去
進取，做到以下幾點。

583
00:26:00,301 --> 00:26:01,550
我們只是要填補這個。

584
00:26:01,550 --> 00:26:07,840
在這裡幾盎司的牛奶，讓我們
補一點橙汁在這裡。

585
00:26:07,840 --> 00:26:11,475
>> 而在所有的前
這些觀眾，

586
00:26:11,475 --> 00:26:13,550
交換這些杯的兩個值。

587
00:26:13,550 --> 00:26:16,970
把橙汁中的奶杯
而牛奶中的橙汁杯。

588
00:26:16,970 --> 00:26:22,380

589
00:26:22,380 --> 00:26:26,150
你會怎樣做，如果你在
家庭和能夠獲得其他用品？

590
00:26:26,150 --> 00:26:27,400
LAUREN：把它放在另一個杯中。

591
00:26:27,400 --> 00:26:28,191
DAVID J.馬蘭：OK。

592
00:26:28,191 --> 00:26:31,940
因此，讓我們有一個臨時的
可變的，如果我們的意願。

593
00:26:31,940 --> 00:26:35,871
現在繼續前進，實現
同樣的交換過程。

594
00:26:35,871 --> 00:26:36,370
所以，好。

595
00:26:36,370 --> 00:26:41,490
我們已經把OJ到臨時
變量，牛奶倒入OJ變量，

596
00:26:41,490 --> 00:26:44,481
現在的臨時變量
到牛奶變量。

597
00:26:44,481 --> 00:26:44,980
確定。

598
00:26:44,980 --> 00:26:48,740
所以非常好，到目前為止完成的。

599
00:26:48,740 --> 00:26:50,990
因此，原來out--認為，
想了一會兒就好了。

600
00:26:50,990 --> 00:26:54,479
在這裡，只是怪胎它了一下，這
將相應的C代碼

601
00:26:54,479 --> 00:26:55,520
我們只是執行。

602
00:26:55,520 --> 00:26:58,650
我們有兩個輸入，a和b，這兩個
我們只想說的簡單是

603
00:26:58,650 --> 00:26:59,260
廉政局。

604
00:26:59,260 --> 00:27:02,780
並注意在這裡，如果我想交換
兩個變量，a和b的值，

605
00:27:02,780 --> 00:27:06,890
我們的確需要一個中間人，一
臨時變量，暫時杯，

606
00:27:06,890 --> 00:27:10,830
到其中的傾的一個值
因此，我們有一個佔位符吧。

607
00:27:10,830 --> 00:27:13,480
但隨後的代碼正好是
作為勞倫這裡實現。

608
00:27:13,480 --> 00:27:15,500
>> 現在，只是為了獲得一個
有點瘋狂，原來

609
00:27:15,500 --> 00:27:20,930
你可以做到這一點沒有
一個臨時變量。

610
00:27:20,930 --> 00:27:24,870
要做到這一點正確的，但是，我們要
有騙一些化學反應。

611
00:27:24,870 --> 00:27:26,380
我們這裡有一些額外的杯子。

612
00:27:26,380 --> 00:27:29,600
所以最接近看起來
像牛奶和水perhaps--

613
00:27:29,600 --> 00:27:34,090
或牛奶和OJ--是我們有一些
水，所以我們要填補這一個

614
00:27:34,090 --> 00:27:36,486
有幾盎司的清水。

615
00:27:36,486 --> 00:27:38,332
這可能是太多了。

616
00:27:38,332 --> 00:27:38,832
是啊。

617
00:27:38,832 --> 00:27:39,934
這是肯定吃不消。

618
00:27:39,934 --> 00:27:40,600
保持在一秒鐘。

619
00:27:40,600 --> 00:27:43,520

620
00:27:43,520 --> 00:27:48,420
>> 而現在我們有油，我記得
初中化學課，

621
00:27:48,420 --> 00:27:49,990
但願它不會與水混合。

622
00:27:49,990 --> 00:27:53,650
但是，它像是一種
看起來像牛奶和OJ。

623
00:27:53,650 --> 00:27:55,760
所以，現在，無需使用
一個臨時變量，

624
00:27:55,760 --> 00:27:59,260
你可以交換這兩個值？

625
00:27:59,260 --> 00:28:03,884
因此，油進入水杯，
水進入油杯。

626
00:28:03,884 --> 00:28:04,800
LAUREN：沒有其他的杯子？

627
00:28:04,800 --> 00:28:05,940
DAVID J.馬蘭：沒有其他的杯子。

628
00:28:05,940 --> 00:28:07,860
而且我已經不實際
今年前測試這

629
00:28:07,860 --> 00:28:10,110
所以我不知道這是否會
實際工作化學。

630
00:28:10,110 --> 00:28:16,130

631
00:28:16,130 --> 00:28:18,650
這是不應該發生的。

632
00:28:18,650 --> 00:28:19,761
難道它的工作？

633
00:28:19,761 --> 00:28:20,260
好的。

634
00:28:20,260 --> 00:28:20,990
因此，分離？

635
00:28:20,990 --> 00:28:21,490
好。

636
00:28:21,490 --> 00:28:24,714
現在，我們得到得到
水倒入另一個杯子。

637
00:28:24,714 --> 00:28:27,630
智慧的化學濃縮可能
可能做到這一點比我強。

638
00:28:27,630 --> 00:28:28,510
>> LAUREN：水的底部。

639
00:28:28,510 --> 00:28:31,910
>> DAVID J.馬蘭：這是該water--
什麼是關鍵的最後一次，我們這樣做。

640
00:28:31,910 --> 00:28:33,950
你必須做正確的順序。

641
00:28:33,950 --> 00:28:34,450
是啊。

642
00:28:34,450 --> 00:28:35,270
That's--確定。

643
00:28:35,270 --> 00:28:37,290
所以，現在我們有油兩杯。

644
00:28:37,290 --> 00:28:37,790
確定。

645
00:28:37,790 --> 00:28:38,510
這是確定的。

646
00:28:38,510 --> 00:28:40,110
但是，化學，如果這工作不是我 - 

647
00:28:40,110 --> 00:28:41,200
>> LAUREN：這是水。

648
00:28:41,200 --> 00:28:41,930
>> DAVID J.馬蘭：這主要是水。

649
00:28:41,930 --> 00:28:42,430
好的。

650
00:28:42,430 --> 00:28:44,210
但是，這仍然是相同的杯子和以前一樣。

651
00:28:44,210 --> 00:28:47,570
所以倒它 - 嘗試在那邊。

652
00:28:47,570 --> 00:28:49,300
確定。

653
00:28:49,300 --> 00:28:51,010
這是一個很好用的上課時間今天。

654
00:28:51,010 --> 00:28:51,510
確定。

655
00:28:51,510 --> 00:28:53,890
所以，現在we--不錯。

656
00:28:53,890 --> 00:28:55,460
排序的。

657
00:28:55,460 --> 00:28:55,960
好的。

658
00:28:55,960 --> 00:28:56,690
所以非常好。

659
00:28:56,690 --> 00:29:00,006
謝謝勞倫。

660
00:29:00,006 --> 00:29:01,950
非常出色地完成。

661
00:29:01,950 --> 00:29:04,570
>> 所以為了使你的頭腦，
這也許是東西

662
00:29:04,570 --> 00:29:08,660
有，如果你喜歡CS50 ID玩，
你可以，事實上，交換兩個變量

663
00:29:08,660 --> 00:29:11,470
不使用臨時整數。

664
00:29:11,470 --> 00:29:13,060
這是相應的C代碼。

665
00:29:13,060 --> 00:29:16,110
如果你從過去的回憶
週三，我們介紹了，如果簡單地說，

666
00:29:16,110 --> 00:29:19,720
一些新的運營商℃，不
有人回憶一下那個小胡蘿蔔

667
00:29:19,720 --> 00:29:23,660
符號是，那個小三角
從鍵盤符號表示？

668
00:29:23,660 --> 00:29:26,003
什麼位運算符？

669
00:29:26,003 --> 00:29:26,770
>> 聽眾：EXOR。

670
00:29:26,770 --> 00:29:27,645
>> DAVID J.馬蘭：EXOR。

671
00:29:27,645 --> 00:29:28,560
異或。

672
00:29:28,560 --> 00:29:32,920
所以，如果你想，只是為了好玩。
回家，給a和b兩個任意

673
00:29:32,920 --> 00:29:36,072
像任何eight--和I值
會選擇八位值。

674
00:29:36,072 --> 00:29:38,530
如果你有32位做到這一點，
你會很快感到厭倦。

675
00:29:38,530 --> 00:29:42,150
但是，只要給一個八位
值是什麼，一，二，

676
00:29:42,150 --> 00:29:43,790
並給B A類似的價值。

677
00:29:43,790 --> 00:29:46,810
然後使用定義
XOR從上週三，

678
00:29:46,810 --> 00:29:52,560
應用該的點點滴滴，每
那些八位在每個a和b，

679
00:29:52,560 --> 00:29:54,980
然後根據此代碼，這樣做完全。

680
00:29:54,980 --> 00:29:58,170
而且這不是什麼不正確
你在這裡看到的屏幕上。

681
00:29:58,170 --> 00:30:02,100
它確實可以歸結
三XOR運算

682
00:30:02,100 --> 00:30:05,910
不知何故神奇地一和
b目錄都會交換職位

683
00:30:05,910 --> 00:30:08,010
而不丟失任何信息。

684
00:30:08,010 --> 00:30:11,580
>> 因此，油和水的技巧是
最接近真實世界的化身

685
00:30:11,580 --> 00:30:12,980
我能想到的模仿。

686
00:30:12,980 --> 00:30:15,950
但它肯定更容易
使用一個臨時變量，

687
00:30:15,950 --> 00:30:16,920
在這裡這種情況下。

688
00:30:16,920 --> 00:30:21,190
而這也是一個機會說，
太，這種微優化，

689
00:30:21,190 --> 00:30:23,590
作為一名計算機科學家
可以說，雖然一種樂趣

690
00:30:23,590 --> 00:30:27,060
吹噓你如何做到這一點沒有
像一個額外的變量交換，

691
00:30:27,060 --> 00:30:28,640
這還不是所有的說服力。

692
00:30:28,640 --> 00:30:31,619
由於保存32位，如
在實際的整型的情況下，

693
00:30:31,619 --> 00:30:33,410
是不是所有的吸引力
一個系統，其中上

694
00:30:33,410 --> 00:30:36,722
你可能會使用幾十兆
甚至更多的內存等這幾天。

695
00:30:36,722 --> 00:30:38,680
而事實上，當我們得到
到後來問題集

696
00:30:38,680 --> 00:30:41,010
而要實現咒語
檢查你會

697
00:30:41,010 --> 00:30:43,550
被質疑這樣做有
這是小的RAM和盡可能少

698
00:30:43,550 --> 00:30:46,820
時間盡可能的
還是computer--您

699
00:30:46,820 --> 00:30:50,160
有一個星期來實現
它 - 你會have--你會

700
00:30:50,160 --> 00:30:51,799
面臨的挑戰是減少這些資源。

701
00:30:51,799 --> 00:30:53,840
而這真的是唯一的
時報到本學期

702
00:30:53,840 --> 00:30:57,940
在那裡你會被鼓勵刮鬍子
關閉即使是最優秀的性能

703
00:30:57,940 --> 00:30:59,340
成本並非如此。

704
00:30:59,340 --> 00:31:02,200
>> 那麼what--怎樣才能
看到這樣的實際代碼？

705
00:31:02,200 --> 00:31:04,530
現在讓我繼續前進
並開闢一個例子

706
00:31:04,530 --> 00:31:07,700
故意叫
沒有交換，因為它不

707
00:31:07,700 --> 00:31:10,670
其實交換變量
因為你實際上可能期望。

708
00:31:10,670 --> 00:31:12,260
因此，讓我們一起來看看。

709
00:31:12,260 --> 00:31:17,050
這裡有一個程序，沒有CS50
庫回事，只是標準的I / O。

710
00:31:17,050 --> 00:31:19,560
現在我們有一個原型
用於交換往上頂剛剛

711
00:31:19,560 --> 00:31:21,540
意味著它一定是在後面定義。

712
00:31:21,540 --> 00:31:22,550
而這裡的主力。

713
00:31:22,550 --> 00:31:26,000
>> 我任意分配x和y，
分別值之一和兩個

714
00:31:26,000 --> 00:31:28,590
只是因為他們是小
易去想。

715
00:31:28,590 --> 00:31:32,280
然後，我只是有一堆用printfs的
在那裡我有一個全面的檢查。 x是1

716
00:31:32,280 --> 00:31:35,110
y是2大概是
什麼樣的printfs輸出會說。

717
00:31:35,110 --> 00:31:36,530
因此，沒有魔法迄今。

718
00:31:36,530 --> 00:31:40,100
>> 然後，我要索賠
打印清晰度，交換點點點。

719
00:31:40,100 --> 00:31:43,730
我會打電話給交換
功能，通過在x和y。

720
00:31:43,730 --> 00:31:47,350
而且，我們現在假設
掉期完全實現

721
00:31:47,350 --> 00:31:49,930
因為這是一個時刻前
用臨時變量。

722
00:31:49,930 --> 00:31:52,670
所以我要求大膽，調換。

723
00:31:52,670 --> 00:31:55,429
x是現在這個y是現在。

724
00:31:55,429 --> 00:31:57,220
但該文件，當然，
被稱為沒有交換。

725
00:31:57,220 --> 00:31:58,678
因此，讓我們其實看看會發生什麼。

726
00:31:58,678 --> 00:32:04,450
如果我編譯沒有交換，然後
做./noswap，x是1，y是2。

727
00:32:04,450 --> 00:32:05,770
交換交換。

728
00:32:05,770 --> 00:32:07,200
x是1，y是2。

729
00:32:07,200 --> 00:32:11,980
因此，它實際上似乎是，即使有缺陷
雖然swap--讓我們向下滾動now--

730
00:32:11,980 --> 00:32:16,542
是按照完全實現
代碼我剛才提出的。

731
00:32:16,542 --> 00:32:19,000
所以我們不會獲得幻想
與XOR的東西現在。

732
00:32:19,000 --> 00:32:21,890
這也正常吧
像牛奶和OJ，

733
00:32:21,890 --> 00:32:25,820
但它似乎並不奏效。

734
00:32:25,820 --> 00:32:27,180
>> 因此，讓我們再次做到這一點。

735
00:32:27,180 --> 00:32:29,310
也許我只是不運行它的權利。

736
00:32:29,310 --> 00:32:32,010
因此，讓我們再次運行沒有交換。

737
00:32:32,010 --> 00:32:32,900
或許我 - 沒有。

738
00:32:32,900 --> 00:32:34,400
所以它只是不工作。

739
00:32:34,400 --> 00:32:36,060
因此，讓我們做一個小的完整性檢查。

740
00:32:36,060 --> 00:32:39,690
讓我在這裡交換繼續
並且只需添加，等待一分鐘，

741
00:32:39,690 --> 00:32:43,856
一個是％I / N，讓我們
插件的一個的值。

742
00:32:43,856 --> 00:32:45,730
因為我真的想
看看發生了什麼事情。

743
00:32:45,730 --> 00:32:47,570
事實上，這是
調試技術

744
00:32:47,570 --> 00:32:50,028
你可能會使用
辦公時間或在家已經，

745
00:32:50,028 --> 00:32:53,560
類似於第一丹的一半
Armendariz環的視頻在PSET3

746
00:32:53,560 --> 00:32:56,870
其中，我們介紹了打印清晰度為
推薦的技術中，至少

747
00:32:56,870 --> 00:32:58,080
對於簡單的情況。

748
00:32:58,080 --> 00:33:01,720
讓我繼續前進，運行make
再沒有交換，./noswap。

749
00:33:01,720 --> 00:33:04,370

750
00:33:04,370 --> 00:33:05,840
>> 有趣的。

751
00:33:05,840 --> 00:33:11,670
所以，注意什麼似乎是正確的。 x
為1，y是2，但a為2時b為1。

752
00:33:11,670 --> 00:33:16,790
因此，這兩個不知何故交換
但x和y是沒有得到交換。

753
00:33:16,790 --> 00:33:21,090
所以要清楚，發生了什麼
是，在這裡我有X和Y

754
00:33:21,090 --> 00:33:25,380
而這些都是局部變量，在
主要適用範圍，我傳遞的x和y

755
00:33:25,380 --> 00:33:26,170
交換。

756
00:33:26,170 --> 00:33:29,080
現在，掉期，作為一個單獨的功能，
可以自由地調用它的參數

757
00:33:29,080 --> 00:33:30,590
或者它的參數什麼就是了。

758
00:33:30,590 --> 00:33:33,280
富或酒吧或x或y或a或b。

759
00:33:33,280 --> 00:33:36,870
只是為了清楚，他們是
不相同的x和y本身

760
00:33:36,870 --> 00:33:38,020
我已經說過了a和b。

761
00:33:38,020 --> 00:33:40,040
但是，我們可以打電話給他們任何我們想要的。

762
00:33:40,040 --> 00:33:43,960
>> 所以它看起來像
交換被傳遞

763
00:33:43,960 --> 00:33:48,980
x-- AKA A--和它的
傳遞y-- AKA灣

764
00:33:48,980 --> 00:33:51,900
不知怎的，這三條線都
正是這些交換價值

765
00:33:51,900 --> 00:33:53,510
作為勞倫就與牛奶和OJ。

766
00:33:53,510 --> 00:33:56,010
但是，當我們打印出
的值，a和b

767
00:33:56,010 --> 00:34:01,340
的確交換，但X和
y的不改變它們。

768
00:34:01,340 --> 00:34:03,150
回想一下，x和y是在這裡。

769
00:34:03,150 --> 00:34:05,320
>> 因此，我們可以通過看這
另一種技術為好。

770
00:34:05,320 --> 00:34:08,110
而這也是一個技術
嵌入在問題設定了三個。

771
00:34:08,110 --> 00:34:10,780
讓我們繼續前進，並為此在
CS50 ID，如果你還沒有。

772
00:34:10,780 --> 00:34:13,730
在右側我們
有這樣的調試器選項卡。

773
00:34:13,730 --> 00:34:16,159
如果你打開這個了，
有一些神秘的信息

774
00:34:16,159 --> 00:34:17,530
多數民眾贊成在投擲您最初。

775
00:34:17,530 --> 00:34:19,310
但是，讓我們取笑這除了真正的快。

776
00:34:19,310 --> 00:34:21,620
>> 所以一個，你看到的局部變量。

777
00:34:21,620 --> 00:34:26,230
原來，打造成為CS50 IDE和
很多編程環境的更多

778
00:34:26,230 --> 00:34:28,060
一般是一個調試器。

779
00:34:28,060 --> 00:34:31,340
一種工具，可以讓你直觀地看到
什麼是你的節目裡面發生

780
00:34:31,340 --> 00:34:34,380
而不必訴諸於添加
printfs輸出和編譯並運行

781
00:34:34,380 --> 00:34:37,588
和添加的printf的，編制和
運行時，它已經在辦公時間

782
00:34:37,588 --> 00:34:40,070
或家庭，大概是
越來越漂亮乏味。

783
00:34:40,070 --> 00:34:43,090
>> 所以在這裡，在短短的時刻，我們
要看到的實時

784
00:34:43,090 --> 00:34:44,760
我們的局部變量的值。

785
00:34:44,760 --> 00:34:47,880
我們也將能夠設置
所謂的斷點這

786
00:34:47,880 --> 00:34:52,570
有機會在我的計劃暫停
執行在特定的代碼行

787
00:34:52,570 --> 00:34:53,710
我很好奇。

788
00:34:53,710 --> 00:34:54,210
對嗎？

789
00:34:54,210 --> 00:34:55,969
這些方案在瞬間運行。

790
00:34:55,969 --> 00:35:00,450
它是一種很好的為我們人類更慢
要能夠暫停，花一點時間，看看

791
00:35:00,450 --> 00:35:02,380
什麼是圍繞回事
一定行的代碼

792
00:35:02,380 --> 00:35:05,050
沒有程序耕翻
通過它，完成全部。

793
00:35:05,050 --> 00:35:08,510
因此，一個斷點將允許我們
打破和暫停在某一點。

794
00:35:08,510 --> 00:35:12,990
>> 調用堆棧是一個奇特的方式
說功能是什麼目前

795
00:35:12,990 --> 00:35:14,140
被調用的時刻。

796
00:35:14,140 --> 00:35:15,370
主總是首先調用。

797
00:35:15,370 --> 00:35:17,230
但是，如果主調用
函數稱為交換，

798
00:35:17,230 --> 00:35:20,470
我們真的要看到這
塔的功能，已

799
00:35:20,470 --> 00:35:22,400
所謂逆時間順序。

800
00:35:22,400 --> 00:35:23,310
因此，讓我們看到這一點。

801
00:35:23,310 --> 00:35:24,327
>> 我要縮小。

802
00:35:24,327 --> 00:35:25,660
我要回到我的代碼。

803
00:35:25,660 --> 00:35:27,540
而只是因為我想
這裡是迂腐，

804
00:35:27,540 --> 00:35:31,100
我要繼續前進，然後點擊
只是五號線的左側。

805
00:35:31,100 --> 00:35:32,830
這創建了一個紅點。

806
00:35:32,830 --> 00:35:36,200
並注意在右手側
調試器知道，哎，

807
00:35:36,200 --> 00:35:41,020
我剛才說了一個斷點
noswap.c五號線，特別是

808
00:35:41,020 --> 00:35:42,480
在這行代碼。

809
00:35:42,480 --> 00:35:45,090
因此，調試器知道我
有請下一次

810
00:35:45,090 --> 00:35:48,530
我跑我的程序就暫停
在此執行，而不是僅僅

811
00:35:48,530 --> 00:35:50,390
運行整個事情的超級快。

812
00:35:50,390 --> 00:35:53,889
>> 所以，現在我要點擊調試
在IDE的頂部按鈕

813
00:35:53,889 --> 00:35:55,430
而這要做到以下幾點。

814
00:35:55,430 --> 00:36:00,680
這將打開一個最初有點
可怕看第二終端window--

815
00:36:00,680 --> 00:36:02,679
從遠程調試
舉辦這樣和such--

816
00:36:02,679 --> 00:36:04,970
我們會回來的是什麼
所有這意味著不久。

817
00:36:04,970 --> 00:36:09,020
但是，什麼是重要的，現在
是那個紅點被擊中，

818
00:36:09,020 --> 00:36:11,735
調試器具有故意
暫停execution--

819
00:36:11,735 --> 00:36:15,560
不是本身該行，但是，從第一
線的在該函數中的實際代碼。

820
00:36:15,560 --> 00:36:18,040
這就是為什麼七號線是
現在，以黃色突出顯示。

821
00:36:18,040 --> 00:36:20,550
>> 現在，讓我們來看看
在右手側。

822
00:36:20,550 --> 00:36:27,300
它看起來像，在默認情況下，
好聽的是，x具有什麼價值？

823
00:36:27,300 --> 00:36:27,860
0。

824
00:36:27,860 --> 00:36:29,750
和Y有什麼價值？

825
00:36:29,750 --> 00:36:30,410
零。

826
00:36:30,410 --> 00:36:35,540
這是可以預料的意義
x和y--的黃色line--有

827
00:36:35,540 --> 00:36:36,770
還沒有執行。

828
00:36:36,770 --> 00:36:38,510
的SO x不應該具有值1。

829
00:36:38,510 --> 00:36:41,470
它可能具有任何其他值，
所謂的垃圾值。

830
00:36:41,470 --> 00:36:44,320
我們很幸運，因為它是
在這一點上為零，基本上是。

831
00:36:44,320 --> 00:36:46,400
>> 所以，現在這裡只有少數
按鈕，我們需要照顧

832
00:36:46,400 --> 00:36:48,100
關於這種方式調試時。

833
00:36:48,100 --> 00:36:49,970
請注意，在這裡，我們有一個播放按鈕。

834
00:36:49,970 --> 00:36:51,877
如果我們發揮，或打
恢復，這只是

835
00:36:51,877 --> 00:36:53,710
經過運行
該程序的其餘部分

836
00:36:53,710 --> 00:36:55,300
或者直到遇到另一個斷點。

837
00:36:55,300 --> 00:36:56,910
但我沒有設置任何其他
斷點所以它只是

838
00:36:56,910 --> 00:36:58,118
經過運行結束。

839
00:36:58,118 --> 00:37:00,280
那種連敗的
閒逛的目的。

840
00:37:00,280 --> 00:37:03,290
>> 所以，相反，我很在乎
這些圖標右側。

841
00:37:03,290 --> 00:37:05,360
如果我將鼠標懸停在
他們，你也應該這麼做，

842
00:37:05,360 --> 00:37:07,450
你會看到小tips--工具提示。

843
00:37:07,450 --> 00:37:09,020
這一個是步過。

844
00:37:09,020 --> 00:37:11,290
現在，這並不意味著跳躍
下面的一行代碼。

845
00:37:11,290 --> 00:37:14,840
這只是意味著執行它，
移動到下一個，移動到下一個，

846
00:37:14,840 --> 00:37:15,580
移動到下一個。

847
00:37:15,580 --> 00:37:17,610
換句話說，通過
那個按鈕，我可以走

848
00:37:17,610 --> 00:37:20,390
通過我的代碼，一步一個腳印的時間。

849
00:37:20,390 --> 00:37:21,914
逐行逐字地。

850
00:37:21,914 --> 00:37:23,830
現在，到右側
這，還有另外一個

851
00:37:23,830 --> 00:37:25,163
我們會看到在短短的時刻。

852
00:37:25,163 --> 00:37:27,820
這就是所謂的
步入圖標的

853
00:37:27,820 --> 00:37:30,300
要允許我潛水
成另一種功能。

854
00:37:30,300 --> 00:37:31,800
但是，讓我們來看看在短短的時刻。

855
00:37:31,800 --> 00:37:33,280
所以，我要點擊跳過。

856
00:37:33,280 --> 00:37:35,820
而現在發現，我點擊
這個按鈕在右上角，

857
00:37:35,820 --> 00:37:41,260
保持你的眼睛大致在本地
變量和看看會發生到x什麼。

858
00:37:41,260 --> 00:37:44,115
x是現在的1，因為
黃線目前已執行

859
00:37:44,115 --> 00:37:45,840
我們已經轉移到8號線。

860
00:37:45,840 --> 00:37:49,840
而在短短的一瞬間ÿ
應該有希望成為2。

861
00:37:49,840 --> 00:37:52,330
>> 現在，沒有什麼有趣
發生了一點。

862
00:37:52,330 --> 00:37:53,390
這一切是printf的。

863
00:37:53,390 --> 00:37:58,010
同時注意，在我的副終端
窗口，我看到打印高清輸出。

864
00:37:58,010 --> 00:38:01,080
而現在我必須做出一個
決定程序員。

865
00:38:01,080 --> 00:38:04,360
我能跨過這條線的
代碼執行，但不

866
00:38:04,360 --> 00:38:06,220
越來越好奇裡面有什麼。

867
00:38:06,220 --> 00:38:11,130
或者，我可以真正踏進去
去交換本身的內部。

868
00:38:11,130 --> 00:38:12,340
因此，讓我們做後者。

869
00:38:12,340 --> 00:38:15,550
>> 讓我繼續前進，點擊
不踩過去，但步入。

870
00:38:15,550 --> 00:38:17,300
請注意，突然
窗口變化

871
00:38:17,300 --> 00:38:19,330
以突出所述第一
線的交換代碼。

872
00:38:19,330 --> 00:38:20,710
這是第21行。

873
00:38:20,710 --> 00:38:25,220
而現在，有什麼樣的時髦的是，
如果你看過來，符合市場預期，

874
00:38:25,220 --> 00:38:29,720
逗號b為1和2。

875
00:38:29,720 --> 00:38:33,840
為什麼是臨時32,767？

876
00:38:33,840 --> 00:38:36,560
回顧溫度，很像
空杯剛才，

877
00:38:36,560 --> 00:38:38,980
這裡宣布第21行。

878
00:38:38,980 --> 00:38:43,390
為什麼32,000-我的意思是，這是為什麼
它只是一些奇怪的值？

879
00:38:43,390 --> 00:38:43,890
是嗎？

880
00:38:43,890 --> 00:38:45,190
>> 聽眾：這不是初始化。

881
00:38:45,190 --> 00:38:46,940
>> DAVID J.馬蘭：這是
未被初始化。

882
00:38:46,940 --> 00:38:49,370
因此，我們的電腦總是
有物理內存。

883
00:38:49,370 --> 00:38:50,544
它總是有物理RAM。

884
00:38:50,544 --> 00:38:52,710
而總有為零的
和一個人在那裡，對不對？

885
00:38:52,710 --> 00:38:54,626
因為我們使用我們的
計算機整天，

886
00:38:54,626 --> 00:38:57,210
您使用的是CS50 IDE
或服務器整天。

887
00:38:57,210 --> 00:39:01,159
這樣RAM或者有一些零或
有些人的或者一些零和一。

888
00:39:01,159 --> 00:39:02,950
不管是否
不是你使用它們。

889
00:39:02,950 --> 00:39:05,270
你不能只是有空白
空間，您要位。

890
00:39:05,270 --> 00:39:06,850
他們要么零和一。

891
00:39:06,850 --> 00:39:09,610
>> 所以，事實證明，臨時的，因為
我們沒有初始化它，

892
00:39:09,610 --> 00:39:14,580
我們這些32位，但他們還沒有
被初始化到任何已知的值。

893
00:39:14,580 --> 00:39:18,110
所以，無論他們是最
最近使用for--的32 bits--

894
00:39:18,110 --> 00:39:23,000
我們只是看到一些文物
以前使用這些特定的32

895
00:39:23,000 --> 00:39:23,500
位。

896
00:39:23,500 --> 00:39:27,780
當我點擊步過，雖然，
唷，溫度將會獲得價值1。

897
00:39:27,780 --> 00:39:31,600
如果我再這樣做，一個是
將要給出的值2

898
00:39:31,600 --> 00:39:33,830
然後b為要
被賦予值1。

899
00:39:33,830 --> 00:39:36,390
>> 還等什麼高興現在
這點在故事

900
00:39:36,390 --> 00:39:39,750
是調試器是
給我看，超級慢

901
00:39:39,750 --> 00:39:42,640
在我自己的節奏，有什麼
交換的狀態。

902
00:39:42,640 --> 00:39:47,490
但是請注意，在這裡的頂部，通知
該調用堆棧實際上

903
00:39:47,490 --> 00:39:49,180
有兩層到它。

904
00:39:49,180 --> 00:39:53,240
現在，這突出顯示為一
交換，如果我在主營點擊相反，

905
00:39:53,240 --> 00:39:57,100
注意局部變量如何變化
因為開發人員可以只跳

906
00:39:57,100 --> 00:39:59,740
各地去到任何不同的範圍。

907
00:39:59,740 --> 00:40:04,070
因此，即使我們正在做這一切
工作，並正確地交換a和b，

908
00:40:04,070 --> 00:40:09,080
如果我去來回交換之間
其中a是2，b是1和主，

909
00:40:09,080 --> 00:40:11,851
一直主要受到影響呢？

910
00:40:11,851 --> 00:40:12,350
第

911
00:40:12,350 --> 00:40:13,930
那麼，有什麼外賣嗎？

912
00:40:13,930 --> 00:40:18,200
嗯，事實證明，任何時候
你調用一個函數像交換，

913
00:40:18,200 --> 00:40:21,600
你通過它的參數，是什麼
你傳遞的交換功能

914
00:40:21,600 --> 00:40:24,730
在這種情況下是一個拷貝
這些論點。

915
00:40:24,730 --> 00:40:28,620
因此，如果x和y分別是每個
32位，什麼交換也越來越

916
00:40:28,620 --> 00:40:30,760
是兩個新的地方
變量或參數，

917
00:40:30,760 --> 00:40:34,380
稱為一個和b--但這些都是任意的
names--但是零點的圖案

918
00:40:34,380 --> 00:40:39,520
和1的內部a和b是
排隊是相同的x和y

919
00:40:39,520 --> 00:40:42,610
但它們不是
同樣的事情，x和y。

920
00:40:42,610 --> 00:40:46,880
>> 就好像主在其片
紙張的數量1和2為x和y，

921
00:40:46,880 --> 00:40:49,260
然後當它手中那
一張紙來交換，

922
00:40:49,260 --> 00:40:51,970
交換非常快變
自己的筆，記

923
00:40:51,970 --> 00:40:56,240
圖1和2自身的紙片
手回原來的XY主

924
00:40:56,240 --> 00:40:58,790
然後做自己的
與a和b的事情。

925
00:40:58,790 --> 00:41:01,940
這是因為現在的超級重要
這有平凡的意義

926
00:41:01,940 --> 00:41:06,260
對於實際編寫正確的代碼
因為它似乎我們不能互換

927
00:41:06,260 --> 00:41:07,500
兩個變量。

928
00:41:07,500 --> 00:41:09,150
>> 我寫了一個正確的交換功能。

929
00:41:09,150 --> 00:41:12,770
我們與勞倫實現了它作為
正確的交換功能，在現實中，

930
00:41:12,770 --> 00:41:16,700
但顯然沒有了
如果事情你不能真正

931
00:41:16,700 --> 00:41:19,530
交換兩個值永久。

932
00:41:19,530 --> 00:41:21,970
因此，我們需要另一種方式
真正得到這個，

933
00:41:21,970 --> 00:41:24,472
我們需要能夠
實際上解決這個問題。

934
00:41:24,472 --> 00:41:27,180
而事實證明out--，我們會來
回到這個特定圖片

935
00:41:27,180 --> 00:41:30,500
long--之前，這是一種方式
你可以畫出你的計算機的內存。

936
00:41:30,500 --> 00:41:31,460
這只是一個矩形。

937
00:41:31,460 --> 00:41:32,960
你可以任意繪製
的方式，但它的數量

938
00:41:32,960 --> 00:41:35,740
先畫出它作為
矩形的理由如下。

939
00:41:35,740 --> 00:41:40,040
>> 我們要開始今天及以後
談到所謂的棧。

940
00:41:40,040 --> 00:41:43,870
且堆棧只是一大塊
的RAM-- memory--的一大塊

941
00:41:43,870 --> 00:41:47,100
該功能可訪問
當他們是所謂的。

942
00:41:47,100 --> 00:41:49,800
所以，事實證明，在
這個堆棧的底部

943
00:41:49,800 --> 00:41:53,590
是所有主要的局部變量
和org C和有機V和所有的東西

944
00:41:53,590 --> 00:41:56,950
是要去默認。如果主
調用其他一些功能像掉期，

945
00:41:56,950 --> 00:42:00,330
同時，交換是會得到另一個
層的上面記憶起來。

946
00:42:00,330 --> 00:42:04,490
>> 所以只給你一個快速粗略
這個畫面，如果我去了這裡 - 

947
00:42:04,490 --> 00:42:09,450
讓我這反映在
開銷well--真正讓我有，

948
00:42:09,450 --> 00:42:12,100
如果我們只關心
這幅畫的底部，現在，

949
00:42:12,100 --> 00:42:15,070
是，當我運行一個程序
而主要被調用，

950
00:42:15,070 --> 00:42:18,330
主要被給予一個組塊
內存在我的電腦是

951
00:42:18,330 --> 00:42:20,060
在此所謂的堆疊的底部。

952
00:42:20,060 --> 00:42:22,143
而且我要畫它
特意為正方形。

953
00:42:22,143 --> 00:42:24,540
因此，這就像32位或4個字節。

954
00:42:24,540 --> 00:42:28,790
如果這主要功能有一個
變量名為x為1的值

955
00:42:28,790 --> 00:42:32,626
並且它有一個稱為可變
y隨的2的值，這是

956
00:42:32,626 --> 00:42:35,750
喜歡採取這種條子的內存
主已經通過操作定

957
00:42:35,750 --> 00:42:38,850
系統並瓜分，使
第一本地變量超出這裡，

958
00:42:38,850 --> 00:42:40,930
第二個放在這裡，這就是它。

959
00:42:40,930 --> 00:42:45,590
>> 當主呼叫交換，交換
都有自己的內存片

960
00:42:45,590 --> 00:42:48,280
我們將得出這樣的
從操作系統，

961
00:42:48,280 --> 00:42:50,820
而這將有其
根據自己的局部變量

962
00:42:50,820 --> 00:42:53,825
我們實施早期
與局部變量

963
00:42:53,825 --> 00:42:58,010
和b，最初
得到的值1和2。

964
00:42:58,010 --> 00:43:00,450
不過，只要
在交換代碼執行，

965
00:43:00,450 --> 00:43:03,760
和勞倫實際交換的
辛普森和牛奶，發生了什麼？

966
00:43:03,760 --> 00:43:09,030
那麼，這2成為1，本
1正在成為2，和，順便說一下，

967
00:43:09,030 --> 00:43:13,360
有一個臨時變量，正在被
使用的整個過程中，最終

968
00:43:13,360 --> 00:43:14,470
消失。

969
00:43:14,470 --> 00:43:16,720
但它並不重要
多少工作你做

970
00:43:16,720 --> 00:43:22,160
在這條線在此內存空間of--，
x和y是完全不變。

971
00:43:22,160 --> 00:43:26,320
>> 因此，我們需要給予一些方法
交換和功能，例如它

972
00:43:26,320 --> 00:43:32,640
秘密訪問，如果你願意，給
功能li​​ke--到存儲器像x和y。

973
00:43:32,640 --> 00:43:35,110
因此，讓我們一起來看看
一個例子，可為

974
00:43:35,110 --> 00:43:38,220
我們來看看到底是什麼一直
怎麼回事這整個時間。

975
00:43:38,220 --> 00:43:40,284
我要繼續前進
開拓比較為零。

976
00:43:40,284 --> 00:43:42,200
而且我要關閉
我們的調試器，我要去

977
00:43:42,200 --> 00:43:44,360
關閉這個面目可憎消息
剛說，等一下，

978
00:43:44,360 --> 00:43:45,800
你在中間的調試。

979
00:43:45,800 --> 00:43:48,383
我要在這裡隱藏此選項卡
剛回到簡單。

980
00:43:48,383 --> 00:43:50,160
如果GDB被殺害所以不要擔心。

981
00:43:50,160 --> 00:43:53,910
這只是意味著，該方案具有
已經辭職，故意在這種情況下，

982
00:43:53,910 --> 00:43:54,820
由我。

983
00:43:54,820 --> 00:43:57,700
>> 而現在比較零做到這一點。

984
00:43:57,700 --> 00:44:00,110
我使用的是CS50
庫中的標準I / O。

985
00:44:00,110 --> 00:44:04,319
我有一個主要功能第一
說，說些什麼，並得到一個字符串。

986
00:44:04,319 --> 00:44:06,110
然後再和說
得到另一個字符串。

987
00:44:06,110 --> 00:44:09,910
並注意這兩個字符串
被稱為s和t分別。

988
00:44:09,910 --> 00:44:12,910
而現在這個方案，比較
零，它在生命的目的，

989
00:44:12,910 --> 00:44:15,470
它應該告訴我，
我才鍵入同樣的事情？

990
00:44:15,470 --> 00:44:16,910
所以我要回一個星期。

991
00:44:16,910 --> 00:44:19,950
我用我等於等於運算符
這是質量運算符。

992
00:44:19,950 --> 00:44:22,220
不是賦值運算符，
等號運算符。

993
00:44:22,220 --> 00:44:23,890
我只是比較s和t。

994
00:44:23,890 --> 00:44:27,470
>> 因此，讓我們真正去前進，做到這一點。

995
00:44:27,470 --> 00:44:32,680
而且我要繼續前進
並進行比較為零。

996
00:44:32,680 --> 00:44:35,110
我該怎麼辦./comparezero。

997
00:44:35,110 --> 00:44:37,150
我要去
前進，說些什麼

998
00:44:37,150 --> 00:44:43,450
喜歡，讓我們做媽媽的小寫
怎麼樣的媽媽大寫。

999
00:44:43,450 --> 00:44:45,034
當然我型不同的東西。

1000
00:44:45,034 --> 00:44:45,533
好的。

1001
00:44:45,533 --> 00:44:46,570
這是可以預料的。

1002
00:44:46,570 --> 00:44:47,640
>> 讓我們再次運行它。

1003
00:44:47,640 --> 00:44:49,740
這兩次做小寫字母，小寫字母。

1004
00:44:49,740 --> 00:44:51,490
這看起來超一樣對我。

1005
00:44:51,490 --> 00:44:52,930
輸入。

1006
00:44:52,930 --> 00:44:53,430
確定。

1007
00:44:53,430 --> 00:44:55,804
也許這只是奇怪，因為
它不喜歡我的語法。

1008
00:44:55,804 --> 00:44:59,930
因此，讓我們做一個大寫媽媽，
資本媽媽，是相同的。

1009
00:44:59,930 --> 00:45:01,490
不同的事情。

1010
00:45:01,490 --> 00:45:03,907
>> 那麼，為什麼會這樣？

1011
00:45:03,907 --> 00:45:06,240
那麼，什麼是實際去
在這裡引擎蓋下？

1012
00:45:06,240 --> 00:45:08,180
因此，讓我們回去了
這裡只是一個時刻

1013
00:45:08,180 --> 00:45:10,910
並且考慮什麼的GetString
其實這樣做。

1014
00:45:10,910 --> 00:45:13,385
當你打電話的GetString，
這是一個函數，我們

1015
00:45:13,385 --> 00:45:16,510
自己寫的，它以某種方式得到了
序列來自用戶的字符。

1016
00:45:16,510 --> 00:45:20,280
而且，我們認為第一
一次我打電話的GetString，這給了我

1017
00:45:20,280 --> 00:45:21,930
一個內存塊，看起來像這樣。

1018
00:45:21,930 --> 00:45:26,990
如果我輸入全部小寫
M-O-M--和之後發生的事情？

1019
00:45:26,990 --> 00:45:28,840
只是一個快速的完整性檢查。

1020
00:45:28,840 --> 00:45:29,780
>> 反斜杠零。

1021
00:45:29,780 --> 00:45:30,510
我們知道這一點。

1022
00:45:30,510 --> 00:45:32,784
而記得我們打了
與Zamila名左右

1023
00:45:32,784 --> 00:45:34,950
和一堆其他的名字
當羅布在這裡尋找

1024
00:45:34,950 --> 00:45:36,280
在什麼內存裡面發生。

1025
00:45:36,280 --> 00:45:37,780
所以，這個故事是完全一樣的。

1026
00:45:37,780 --> 00:45:40,160
這是什麼的GetString
將返回給我。

1027
00:45:40,160 --> 00:45:44,780
現在，我的代碼剛才存儲
GetString的返回值

1028
00:45:44,780 --> 00:45:47,510
在一個變量被稱為第

1029
00:45:47,510 --> 00:45:51,390
然後我第二次把它稱為，
它存儲在一個變量稱為T。

1030
00:45:51,390 --> 00:45:55,070
>> 所以，如果我在這裡走了過來，我需要
作出這樣的本地變量 - 

1031
00:45:55,070 --> 00:45:59,610
而我一般會
畫一個字符串作為just--我們

1032
00:45:59,610 --> 00:46:02,360
稱之為S--這裡作為一個小廣場。

1033
00:46:02,360 --> 00:46:09,760
而現在，somehow--怎麼做媽媽
去這個變量s裡面？

1034
00:46:09,760 --> 00:46:12,010
好了，我們要回去
這裡首要原則。

1035
00:46:12,010 --> 00:46:15,660
什麼是的GetString實際上返回？

1036
00:46:15,660 --> 00:46:19,030
>> 所以，事實證明，M-O-M
反斜杠零，和任何數目的

1037
00:46:19,030 --> 00:46:22,364
在內存像其他字符串
Zamila和Rob或安迪或任何其他人，

1038
00:46:22,364 --> 00:46:24,280
當然在我們的
計算機的RAM或存儲器。

1039
00:46:24,280 --> 00:46:27,760
而你的內存有like--你有
RAM的演出，內存2演出，

1040
00:46:27,760 --> 00:46:30,860
或十億或兩個十億字節，
或者甚至更多，這些天。

1041
00:46:30,860 --> 00:46:34,070
因此，讓我們假設，對於今天的目的，
這不要緊，我們如何編號

1042
00:46:34,070 --> 00:46:36,640
他們，但我們可以號每
這十億兩十億的

1043
00:46:36,640 --> 00:46:37,880
三四十億字節。

1044
00:46:37,880 --> 00:46:42,240
>> 而我們只是武斷地說，
這是第一個咬，咬第二口，

1045
00:46:42,240 --> 00:46:43,380
第三，第四。

1046
00:46:43,380 --> 00:46:46,570
我故意不使用零
今天，但我們會回來的。

1047
00:46:46,570 --> 00:46:49,570
因此，換句話說，如果是這樣的
第一次我正在使用的程序，

1048
00:46:49,570 --> 00:46:52,715
我剛開始運氣和第一
咬是位置的一個那麼雙

1049
00:46:52,715 --> 00:46:53,590
那三四十。

1050
00:46:53,590 --> 00:46:57,430
如果我不停地畫，箱號
的兩個十億會的方式在這裡。

1051
00:46:57,430 --> 00:47:02,200
>> 所以，你怎麼想的話，
的GetString實際上返回？

1052
00:47:02,200 --> 00:47:06,010
它沒有返回M-O-M反斜杠
零本身，因為這明顯

1053
00:47:06,010 --> 00:47:08,180
我已經開箱子不會格格不入。

1054
00:47:08,180 --> 00:47:11,210
那麼還有什麼可以真正的GetString
將返回所有這幾個星期？

1055
00:47:11,210 --> 00:47:14,410

1056
00:47:14,410 --> 00:47:16,820
答案是上
董事會這裡的某個地方。

1057
00:47:16,820 --> 00:47:20,390
你可以不適合M-O-M反斜杠零，
那麼，什麼可能是有意義的呢？

1058
00:47:20,390 --> 00:47:23,424
如果你必須是超級聰明，把
上的所謂的工程帽，

1059
00:47:23,424 --> 00:47:24,340
什麼你能回來嗎？

1060
00:47:24,340 --> 00:47:27,340
什麼是最少量的信息
你仍然可以返回會

1061
00:47:27,340 --> 00:47:30,610
讓你找到M-O-M的內存？

1062
00:47:30,610 --> 00:47:31,270
是嗎？

1063
00:47:31,270 --> 00:47:31,950
>> 聽眾：一。

1064
00:47:31,950 --> 00:47:32,200
>> DAVID J.馬蘭：一。

1065
00:47:32,200 --> 00:47:33,021
為什麼呢？

1066
00:47:33,021 --> 00:47:35,520
聽眾：因為它會告訴
你去哪裡[聽不清]。

1067
00:47:35,520 --> 00:47:38,391

1068
00:47:38,391 --> 00:47:39,390
DAVID J.馬蘭：沒錯。

1069
00:47:39,390 --> 00:47:44,300
我只是要返回地址
我所得到的字符串。

1070
00:47:44,300 --> 00:47:46,570
在這個地址
此案的位置之一。

1071
00:47:46,570 --> 00:47:51,280
所以，真正被存儲在S--
和每一個字符串變量從而far--

1072
00:47:51,280 --> 00:47:53,430
剛剛被
該字符串的地址。

1073
00:47:53,430 --> 00:47:57,840
>> 同時，如果我叫
GetString的第二次，我

1074
00:47:57,840 --> 00:48:03,300
請在字面上相同件事 - 
M-O-M與lowercase-- M-O-M

1075
00:48:03,300 --> 00:48:06,200
而另一個反斜杠零，
現在也許我的程序

1076
00:48:06,200 --> 00:48:09,820
已經運行了一段時間，所以也許這
是10，這是位置11，這是12，

1077
00:48:09,820 --> 00:48:10,700
這是13。

1078
00:48:10,700 --> 00:48:13,590
使用一些其他的計算機
內存無論出於何種原因。

1079
00:48:13,590 --> 00:48:18,172
怎麼現在去我的第二個
在我的節目T變量？

1080
00:48:18,172 --> 00:48:19,390
10。

1081
00:48:19,390 --> 00:48:20,050
沒錯。

1082
00:48:20,050 --> 00:48:23,910
>> 所以，當我們在看
這個程序源代碼

1083
00:48:23,910 --> 00:48:26,550
在這裡我只是想
比較這兩個值，

1084
00:48:26,550 --> 00:48:32,180
是S等於等於T，什麼是
明顯的人的答案是什麼？

1085
00:48:32,180 --> 00:48:34,890
只是沒有因為1不等於10。

1086
00:48:34,890 --> 00:48:36,861
所以，這裡存在一個
對我們的機會真的

1087
00:48:36,861 --> 00:48:39,610
剛回去，再一次，第一次
原則想想，算了，

1088
00:48:39,610 --> 00:48:41,110
這是怎麼回事引擎蓋下？

1089
00:48:41,110 --> 00:48:43,240
我們一直在談論
位和字節和存儲器，

1090
00:48:43,240 --> 00:48:46,820
但實際上它是有用的了解
因為當你打電話的GetString，

1091
00:48:46,820 --> 00:48:50,280
即使我們認為它是
返回M-O-M或字符串的媽媽

1092
00:48:50,280 --> 00:48:53,120
或者安迪或Zamila或
等，在技術上

1093
00:48:53,120 --> 00:48:55,510
它只是返回的地址
的內存塊。

1094
00:48:55,510 --> 00:48:56,910
>> 但是，這是確定的。

1095
00:48:56,910 --> 00:49:00,570
因為我怎麼知道
其中字符串結束？

1096
00:49:00,570 --> 00:49:03,840
如果我只給的開始？

1097
00:49:03,840 --> 00:49:05,380
那麼，反斜線零，對不對？

1098
00:49:05,380 --> 00:49:08,800
就在線性時間我可以
與印刷清晰度M-O-M打印出來。

1099
00:49:08,800 --> 00:49:11,820
而當我看到反斜線
零，我不在乎，我開始，

1100
00:49:11,820 --> 00:49:14,950
我已經知道含蓄
在這裡我需要結束。

1101
00:49:14,950 --> 00:49:18,700
>> 所以，今天標誌著beginning--和
讓我做這將大大因為我們

1102
00:49:18,700 --> 00:49:21,800
經歷了很多的麻煩，
這些在這裡訓練wheels--得到

1103
00:49:21,800 --> 00:49:29,840
所以今天的訓練輪開始
脫落，我們揭示了在least--

1104
00:49:29,840 --> 00:49:31,373
>> [掌聲]

1105
00:49:31,373 --> 00:49:33,220

1106
00:49:33,220 --> 00:49:36,160
>> 這是值得一遊
瞄準這一早上，是嗎？

1107
00:49:36,160 --> 00:49:39,600
所以now--有，原來
出，沒有這樣的事情串。

1108
00:49:39,600 --> 00:49:41,140
字符串不存在。

1109
00:49:41,140 --> 00:49:43,760
這是我們已經有代名詞
裡面的CS50庫。

1110
00:49:43,760 --> 00:49:48,660
今後，我們將開始打電話
s和t不是字符串，但字符明星。

1111
00:49:48,660 --> 00:49:51,180
與焦炭星，我們將
梳理出前長。

1112
00:49:51,180 --> 00:49:53,510
但是這並不是說，
即使我們繼續

1113
00:49:53,510 --> 00:49:56,180
使用的GetString現在，
技術上我應該

1114
00:49:56,180 --> 00:49:59,010
可以說，炭星和焦炭的明星。

1115
00:49:59,010 --> 00:50:01,720
>> 而事實證明那是什麼星
是要表示的東西

1116
00:50:01,720 --> 00:50:04,340
所謂的指針或地址。

1117
00:50:04,340 --> 00:50:06,110
而事實上，一個傳情
面對未來

1118
00:50:06,110 --> 00:50:09,760
是這20秒的剪輯我們
朋友尼克Parlante在斯坦福

1119
00:50:09,760 --> 00:50:12,927
誰，前一段時間，花
一段荒謬的數額，

1120
00:50:12,927 --> 00:50:15,010
作為最好的，我可以告訴他
廚房或他的地下室，

1121
00:50:15,010 --> 00:50:17,140
製作粘土動畫
引進世界

1122
00:50:17,140 --> 00:50:20,010
指定的字符
賓基與我們將

1123
00:50:20,010 --> 00:50:22,010
下一次被介紹給指針。

1124
00:50:22,010 --> 00:50:24,588
因此，這裡是一個什麼樣的來預覽。

1125
00:50:24,588 --> 00:50:26,370
>> [視頻回放]

1126
00:50:26,370 --> 00:50:27,510
>>  - 嘿，賓基。

1127
00:50:27,510 --> 00:50:28,260
醒來。

1128
00:50:28,260 --> 00:50:30,672
現在是時候為指針樂趣。

1129
00:50:30,672 --> 00:50:31,616
>>  - 什麼事？

1130
00:50:31,616 --> 00:50:33,032
了解指針？

1131
00:50:33,032 --> 00:50:34,450
哦，好極了。

1132
00:50:34,450 --> 00:50:35,431
>> [結束播放]

1133
00:50:35,431 --> 00:50:38,055
DAVID J.馬蘭：而關於這一點，
我們會看到你在週三。

1134
00:50:38,055 --> 00:50:47,590

1135
00:50:47,590 --> 00:50:48,090
好的。

1136
00:50:48,090 --> 00:50:48,740
誰是跳舞？

1137
00:50:48,740 --> 00:50:49,240
來吧。

1138
00:50:49,240 --> 00:50:50,330
誰是跳舞？

1139
00:50:50,330 --> 00:50:51,820
你想讓我得到它開始了嗎？

1140
00:50:51,820 --> 00:50:53,770
我會得到它開始。

1141
00:50:53,770 --> 00:50:54,270
Woooo！

1142
00:50:54,270 --> 00:51:04,070

1143
00:51:04,070 --> 00:51:07,580
>> LAUREN：甜花哨的摩西。