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

2
00:00:12,040 --> 00:00:16,460
>> 揚聲器1：好的，這是CS50，
這就是本週四開始，

3
00:00:16,460 --> 00:00:20,420
正如你可能已經聽說過或
看，世界已經結束。

4
00:00:20,420 --> 00:00:23,520
去所有的互聯網附近
已經了解和認識

5
00:00:23,520 --> 00:00:27,100
在程序中，一個錯誤的
編程語言，稱為擊。

6
00:00:27,100 --> 00:00:32,729
這已經奇妙的品牌
作為Shellshock，或猛砸門，

7
00:00:32,729 --> 00:00:35,485
但像這些文章
尚未少見。

8
00:00:35,485 --> 00:00:38,807
而事實上，很多人把
Heartbleed回的記憶，

9
00:00:38,807 --> 00:00:41,640
您可能已經注意到，在
按回到過去的這個春天，這

10
00:00:41,640 --> 00:00:43,980
同樣是相當驚人的。

11
00:00:43,980 --> 00:00:47,110
現在，那些你在這裡
今天，你們有多少人有，

12
00:00:47,110 --> 00:00:50,330
即使你不明白
它是所有關於，聽說Shellshock嗎？

13
00:00:50,330 --> 00:00:51,370

14
00:00:51,370 --> 00:00:54,245
沒事了，你們有多少人
有那些易受攻擊的計算機？

15
00:00:54,245 --> 00:00:55,680

16
00:00:55,680 --> 00:01:00,250
好吧，應該是遠遠多動手
了現在，其中的原因，我們將拭​​目以待。

17
00:01:00,250 --> 00:01:02,580
>> 讓我們來看看什麼是
在媒體一直在進行

18
00:01:02,580 --> 00:01:05,304
然後解釋了一下
在這裡，我們在技術上。

19
00:01:05,304 --> 00:01:07,670

20
00:01:07,670 --> 00:01:11,250
>> 揚聲器2：安全專家
警告說，嚴重的缺陷可能

21
00:01:11,250 --> 00:01:15,650
即將影響數百
數以百萬計的全球的網絡用戶。

22
00:01:15,650 --> 00:01:20,600
那麼究竟是一直的錯誤
被稱為Shellshock，並且它有什麼作用？

23
00:01:20,600 --> 00:01:23,720

24
00:01:23,720 --> 00:01:28,910
好，Shellshock也被稱為
Bash的錯誤，它利用該軟件。

25
00:01:28,910 --> 00:01:33,230
黑客利用病毒掃描弱勢
運行Linux和Unix系統

26
00:01:33,230 --> 00:01:36,300
操作系統和再感染它們。

27
00:01:36,300 --> 00:01:38,730
Bash是一個命令行shell。

28
00:01:38,730 --> 00:01:43,460
這使用戶可以發出命令啟動
在軟件程序和功能

29
00:01:43,460 --> 00:01:45,250
通過鍵入文本。

30
00:01:45,250 --> 00:01:49,980
它通常由程序員，
不應該開到更廣闊的世界，

31
00:01:49,980 --> 00:01:51,590
雖然Shellshock改變這一點。

32
00:01:51,590 --> 00:01:54,160

33
00:01:54,160 --> 00:01:57,910
>> 好吧，worringly，一些分析師
警告它可能是一個更大的威脅，

34
00:01:57,910 --> 00:02:01,580
因為Shellshock允許完整
受感染機器的控制權，

35
00:02:01,580 --> 00:02:06,030
而Heartbleed只允許
黑客間諜的計算機上。

36
00:02:06,030 --> 00:02:09,130
它是如此嚴重，它的
被評為10出10

37
00:02:09,130 --> 00:02:11,900
對於由國家嚴重性
漏洞數據庫。

38
00:02:11,900 --> 00:02:15,530

39
00:02:15,530 --> 00:02:20,015
所有Web服務器三分之二是在
風險，包括一些Mac電腦。

40
00:02:20,015 --> 00:02:22,760

41
00:02:22,760 --> 00:02:25,600
好吧，請確保您
現在修補的系統。

42
00:02:25,600 --> 00:02:29,330
任何人託管網站運行
受影響的操作系統

43
00:02:29,330 --> 00:02:31,800
應該盡快採取行動。

44
00:02:31,800 --> 00:02:35,390
任何人誰買得起它應該
他們的監​​控和Web應用程序

45
00:02:35,390 --> 00:02:37,355
防火牆看出來的任何攻擊。

46
00:02:37,355 --> 00:02:39,979

47
00:02:39,979 --> 00:02:41,770
揚聲器3：最壞的事情
可能出現的情況是

48
00:02:41,770 --> 00:02:45,080
有人會寫代碼，
會自動去掃描

49
00:02:45,080 --> 00:02:48,280
互聯網和會影響
所有的這些計算機。

50
00:02:48,280 --> 00:02:50,710
而一旦他們這樣做了，好了，
他們可以做的最糟糕的事情

51
00:02:50,710 --> 00:02:53,300
只是刪除了一切，
或關閉的網站了。

52
00:02:53,300 --> 00:02:55,360
所以我們可以看到損壞
從這個角度看，

53
00:02:55,360 --> 00:02:58,300
在這裡我們將有惡意的人
誰剛剛決定要興風作浪

54
00:02:58,300 --> 00:03:02,534
通過將系統關閉或刪除
文件和類似的東西。

55
00:03:02,534 --> 00:03:05,200
揚聲器2：有人說這是
最難以測量

56
00:03:05,200 --> 00:03:08,080
蟲子多年了，它
可能需要數週甚至數

57
00:03:08,080 --> 00:03:10,820
個月，以確定它的最終影響。

58
00:03:10,820 --> 00:03:12,180

59
00:03:12,180 --> 00:03:15,560
>> 揚聲器1：所以這一切是真實的，
但有趣的是，幾乎所有的

60
00:03:15,560 --> 00:03:18,330
意象你剛才看到的，
也許除了鍵盤，

61
00:03:18,330 --> 00:03:20,930
無關與
臭蟲任何責任。

62
00:03:20,930 --> 00:03:23,960
服務器和電線等，
這有點切向有關，

63
00:03:23,960 --> 00:03:27,410
但在核心實際上很
熟悉的東西是怎麼回事。

64
00:03:27,410 --> 00:03:30,050
其實，讓我進入
我們CS50設備。

65
00:03:30,050 --> 00:03:32,910
讓我繼續前進，最大限度地
在終端窗口中點擊這裡。

66
00:03:32,910 --> 00:03:36,020
而你們一直在用這個，
或嵌入版物，

67
00:03:36,020 --> 00:03:39,460
在以寫程序gedit的，
輸入命令，等等，

68
00:03:39,460 --> 00:03:43,690
這實際上是，具有
已經好幾個星期，猛砸，B-A-S-H。

69
00:03:43,690 --> 00:03:46,890
這是伯恩再次殼，
這是說只是一種奇特的方式，

70
00:03:46,890 --> 00:03:50,220
這是一個程序，有一個
閃爍提示，有效，

71
00:03:50,220 --> 00:03:51,970
，坐在那裡等待
輸入你。

72
00:03:51,970 --> 00:03:53,920
而且它是命令
通過該線路接口

73
00:03:53,920 --> 00:03:57,650
你們已經運行的命令和
最終編譯，然後運行

74
00:03:57,650 --> 00:03:58,400
程序。

75
00:03:58,400 --> 00:04:01,320
>> 但擊也是一種編程
在以下意義上的語言。

76
00:04:01,320 --> 00:04:05,460
你知道，有喜歡的命令
CD和LS也鐺等人，

77
00:04:05,460 --> 00:04:09,580
但你可以定義自己的命令
通過實施這些猛砸。

78
00:04:09,580 --> 00:04:11,420
現在我們不打算
詳談了

79
00:04:11,420 --> 00:04:16,089
作為來砸的編程語言，但
知道，例如，在目前，

80
00:04:16,089 --> 00:04:17,607
有沒有所謂的命令，“你好。”

81
00:04:17,607 --> 00:04:19,440
因此可以發現
其中的一個包。

82
00:04:19,440 --> 00:04:20,856
它不是安裝在我的電腦上。

83
00:04:20,856 --> 00:04:21,870
請詢問您的管理員。

84
00:04:21,870 --> 00:04:26,030
但是，如果我想在那裡是一個程序
Bash或在我的提示叫“你好”，

85
00:04:26,030 --> 00:04:30,810
其實我可以用的語法是
很喜歡C.它是不太一樣的，

86
00:04:30,810 --> 00:04:35,020
但它看起來很相似，
功能，雖然缺少一些細節。

87
00:04:35,020 --> 00:04:38,090
似乎什麼都沒有發生，
但現在如果我輸入“你好”，

88
00:04:38,090 --> 00:04:40,960
你其實可以寫一
方案，而不是在C中，而不是在Java中，

89
00:04:40,960 --> 00:04:44,280
不以其它程序
語言，但在擊本身。

90
00:04:44,280 --> 00:04:47,630
>> 現在，這裡的關鍵是，我寫的
名字我想給這個新的命令，

91
00:04:47,630 --> 00:04:50,820
而括號也
象徵這是一個函數。

92
00:04:50,820 --> 00:04:54,010
順便說一句，你還可以做的樂趣
的事情，而事實上，即使是在Mac OS上，

93
00:04:54,010 --> 00:04:55,620
這是一個叫做終端程序。

94
00:04:55,620 --> 00:04:58,800
它配備內置到任何人的
電腦有一台Mac在這個房間裡，

95
00:04:58,800 --> 00:05:03,640
你可以做的Mac類似的事情
操作系統，但你可以去更不止於此。

96
00:05:03,640 --> 00:05:07,110
這是一個小切，
但它是一種樂趣。

97
00:05:07,110 --> 00:05:09,715
今天早上我被提醒，
想通過這種時候，

98
00:05:09,715 --> 00:05:13,279
一個小遊戲我經常玩
與CS50的前轉錄因子1

99
00:05:13,279 --> 00:05:16,570
因此任何時候，他會走出來
他的鍵盤和他的屏幕解鎖，

100
00:05:16,570 --> 00:05:23,611
我想執行命令
像this--“打招呼”。

101
00:05:23,611 --> 00:05:26,610
現在，任何時候他回來了
鍵盤後，我清屏

102
00:05:26,610 --> 00:05:27,985
他會坐下來，
試著做了一些工作，

103
00:05:27,985 --> 00:05:29,250
列出他directory--的內容

104
00:05:29,250 --> 00:05:29,510
>> [音頻播放]

105
00:05:29,510 --> 00:05:30,010
>>  - 你好。

106
00:05:30,010 --> 00:05:31,621

107
00:05:31,621 --> 00:05:32,120
你好。

108
00:05:32,120 --> 00:05:35,030
>> 揚聲器1：那麼，在公平，
這本來就不是“你好。”

109
00:05:35,030 --> 00:05:36,894
這是一般的東西
更類似於that--

110
00:05:36,894 --> 00:05:37,560
[音頻播放]

111
00:05:37,560 --> 00:05:37,750
-Beep。

112
00:05:37,750 --> 00:05:39,320
揚聲器1：--thatìwould--
所以他的電腦會

113
00:05:39,320 --> 00:05:42,170
任何時候亂罵他，他居然
在他的鍵盤上坐下。

114
00:05:42,170 --> 00:05:46,265
而很快，他想通了
不要離開他的屏幕解鎖。

115
00:05:46,265 --> 00:05:48,730
但這個建議的那種
愚蠢的樂趣，你

116
00:05:48,730 --> 00:05:50,210
可以有類似猛砸。

117
00:05:50,210 --> 00:05:52,770
但它是一個多一點
嚴重的，可以肯定的，不止於此。

118
00:05:52,770 --> 00:05:57,235
而事實上，這是一
最危險和最持久的bug

119
00:05:57,235 --> 00:05:58,860
這確實擊中了世界全球。

120
00:05:58,860 --> 00:06:02,060
這個bug已經存在了
大約20年，

121
00:06:02,060 --> 00:06:05,780
你會在短短的被擊中
此刻，通過相對簡單。

122
00:06:05,780 --> 00:06:07,990
>> 所以這是一個代表
命令，如果你

123
00:06:07,990 --> 00:06:10,448
擁有一台Mac，從字面上現在
當你有你的蓋子打開，

124
00:06:10,448 --> 00:06:12,940
你可以嘗試輸入成
程序調用終端。

125
00:06:12,940 --> 00:06:15,410
終端下
應用Utilities--

126
00:06:15,410 --> 00:06:18,790
這一次，Windows用戶不必
擔心這個特殊threat--

127
00:06:18,790 --> 00:06:22,310
但那些你用Mac電腦可以輸入
這成為一個窗口，像我在這裡做的，

128
00:06:22,310 --> 00:06:24,210
如果你鍵入
在這個程序

129
00:06:24,210 --> 00:06:28,830
所謂的終端，像我現在這樣，
如果您看到這個詞“弱勢”

130
00:06:28,830 --> 00:06:32,200
你的電腦
容易受到剝削。

131
00:06:32,200 --> 00:06:33,850
>> 現在是什麼的意思？

132
00:06:33,850 --> 00:06:35,870
這是無可否認的
一些很瘋狂的語法，

133
00:06:35,870 --> 00:06:39,050
但我們至少抽出
一些有趣的方面。

134
00:06:39,050 --> 00:06:42,567
因此，有一些語法看起來
有點眼熟，至少在C

135
00:06:42,567 --> 00:06:43,950
和編程更普遍。

136
00:06:43,950 --> 00:06:47,550
我看到一些括號，
分號，大括號，而這樣，

137
00:06:47,550 --> 00:06:50,820
但事實證明，這
愚蠢的事情在這裡黃

138
00:06:50,820 --> 00:06:53,580
本質上是一種功能
什麼也不做。

139
00:06:53,580 --> 00:06:57,840
結腸手段做任何事情，
分號表示停止做什麼。

140
00:06:57,840 --> 00:07:00,250
因此，這些內
大括號，事實

141
00:07:00,250 --> 00:07:02,440
我有一個平等
登錄到左邊，這

142
00:07:02,440 --> 00:07:05,500
本質上是創造
一個命令或一個變量，

143
00:07:05,500 --> 00:07:09,520
所謂的X，然後分配
代碼，黃位在那裡。

144
00:07:09,520 --> 00:07:14,040
這可能是像“迴聲
你好“或”說嘟“什麼的

145
00:07:14,040 --> 00:07:15,120
類似的。

146
00:07:15,120 --> 00:07:17,780
但是，如果你的眼睛發現
再漫步到右側，

147
00:07:17,780 --> 00:07:22,150
有更多的這條線比
該分號剛剛結束。

148
00:07:22,150 --> 00:07:25,160
“迴聲脆弱”，然後
除此之外，還有更多的。

149
00:07:25,160 --> 00:07:26,530
另外分號時，bash  -  C：。

150
00:07:26,530 --> 00:07:28,120

151
00:07:28,120 --> 00:07:34,050
>> 所以長話短說，
這行代碼是

152
00:07:34,050 --> 00:07:36,660
足以令人信服
一台電腦，是

153
00:07:36,660 --> 00:07:39,830
容易被做的事情
你想要它做的事，

154
00:07:39,830 --> 00:07:44,290
因為有在擊即中的錯誤
即使猛砸應該停止

155
00:07:44,290 --> 00:07:48,980
命令正確讀線
後有黃色的文字，

156
00:07:48,980 --> 00:07:52,520
一個20多歲的bug，
巴什實際上已讀

157
00:07:52,520 --> 00:07:56,780
除此之外，分號和漂亮
很多做的是什麼告訴我。

158
00:07:56,780 --> 00:07:59,070
>> 那麼，有什麼寓意
的最終？

159
00:07:59,070 --> 00:08:01,340
我剛才說的“迴聲你好”
或“迴聲脆弱，”

160
00:08:01,340 --> 00:08:05,449
但如果你做了什麼
實際惡意，如室射頻*

161
00:08:05,449 --> 00:08:07,240
你可能不
曾經輸入之前，

162
00:08:07,240 --> 00:08:08,920
坦率地說，你可能
不宜太快，

163
00:08:08,920 --> 00:08:10,700
因為你可以做一個
很多與它的傷害。

164
00:08:10,700 --> 00:08:11,210
為什麼呢？

165
00:08:11,210 --> 00:08:12,990
RM做什麼，當然？

166
00:08:12,990 --> 00:08:14,270
刪除。

167
00:08:14,270 --> 00:08:15,930
*意味著什麼？

168
00:08:15,930 --> 00:08:16,430
所有。

169
00:08:16,430 --> 00:08:18,180
所以這是一個所謂的
百搭卡，所以這意味著

170
00:08:18,180 --> 00:08:20,410
在刪除一切
當前目錄。

171
00:08:20,410 --> 00:08:23,379
-r恰好意味著遞歸，
這意味著，如果你刪除了

172
00:08:23,379 --> 00:08:26,420
是一個目錄，並有內
是其他的文件和其他目錄，

173
00:08:26,420 --> 00:08:28,950
遞歸潛入有
並刪除了這一切。

174
00:08:28,950 --> 00:08:31,040
和-f是最糟糕的這一切。

175
00:08:31,040 --> 00:08:32,580
任何人都知道是什麼意思-f在這裡？

176
00:08:32,580 --> 00:08:33,690

177
00:08:33,690 --> 00:08:34,360
力。

178
00:08:34,360 --> 00:08:37,830
所以強制手段，甚至
如果這是一個壞主意，

179
00:08:37,830 --> 00:08:40,939
做到這一點，而不會提示我
為進一步確認。

180
00:08:40,939 --> 00:08:43,230
所以，你知道，我們笑
這一點，但坦率地說，我大概

181
00:08:43,230 --> 00:08:44,972
鍵入此多次
一天，因為現實

182
00:08:44,972 --> 00:08:47,210
是它的最快的方法
刪除一大堆東西。

183
00:08:47,210 --> 00:08:48,590
但是，即使我做了一些損害。

184
00:08:48,590 --> 00:08:53,100
>> 但是，如果你是欺騙電腦
為確定一些愚蠢的變量

185
00:08:53,100 --> 00:08:56,810
或函數調用X，但隨後
欺騙電腦進入執行

186
00:08:56,810 --> 00:09:00,030
超出該界限
功能，超越了分號，

187
00:09:00,030 --> 00:09:04,430
你確實可以欺騙計算機
進入執行類似室射頻

188
00:09:04,430 --> 00:09:07,810
或電郵命令
或複製命令。

189
00:09:07,810 --> 00:09:11,400
凡是從字面上就可以用做
計算機，無論是刪除文件，

190
00:09:11,400 --> 00:09:15,350
創建文件，發送垃圾郵件的人，
遠程攻擊某些服務器，

191
00:09:15,350 --> 00:09:17,190
如果你能表達出來
用命令

192
00:09:17,190 --> 00:09:19,120
可以欺騙計算機變成這樣做。

193
00:09:19,120 --> 00:09:21,510
>> 現在有什麼的一個例子
你怎麼可以這樣做？

194
00:09:21,510 --> 00:09:24,300
嗯，有很多計算機
在互聯網上運行bash。

195
00:09:24,300 --> 00:09:26,390
我們所有的Mac用戶都在其中。

196
00:09:26,390 --> 00:09:30,390
許多Linux服務器中
他們以及和Unix服務器。

197
00:09:30,390 --> 00:09:32,630
Windows再次得到
相對打爆

198
00:09:32,630 --> 00:09:34,590
除非你已經安裝了
特殊的軟件。

199
00:09:34,590 --> 00:09:37,130
現在很多的服務器，為
例如，運行Web服務器，

200
00:09:37,130 --> 00:09:39,840
事實上Linux的也許是
最流行的操作系統

201
00:09:39,840 --> 00:09:43,060
到因特網上的計算機上運行
這是煮好的網頁。

202
00:09:43,060 --> 00:09:44,910
現在，我們將在後​​面看到
在學期中，當

203
00:09:44,910 --> 00:09:48,470
您發送的請求
您browser--鉻，

204
00:09:48,470 --> 00:09:50,790
Internet Explorer中，whatever--
到遠程服務器，

205
00:09:50,790 --> 00:09:53,730
事實證明，即使
你剛才輸入www.example.com，

206
00:09:53,730 --> 00:09:59,590
您的瀏覽器發送消息
這是一個有點神秘的，是這樣的。

207
00:09:59,590 --> 00:10:01,239
>> 但是請注意一點東西奇怪。

208
00:10:01,239 --> 00:10:03,030
前兩行
我從來沒有見過的，

209
00:10:03,030 --> 00:10:04,904
但他們不看
特別危險。

210
00:10:04,904 --> 00:10:08,030
但是請注意，我已經偷
對於這裡的第三行。

211
00:10:08,030 --> 00:10:13,390
如果一個壞傢伙要發送消息
像這樣從他或她的計算機

212
00:10:13,390 --> 00:10:17,270
一個脆弱的Mac或
脆弱的Linux服務器，

213
00:10:17,270 --> 00:10:21,580
有趣的是，猛砸，
這麼簡單的小命令提示符下，

214
00:10:21,580 --> 00:10:27,450
是無所不在的，往往是
使用基本上執行

215
00:10:27,450 --> 00:10:30,020
的內容
它接收消息。

216
00:10:30,020 --> 00:10:33,490
並通過這種邏輯，你可以
欺騙Web服務器，因此，

217
00:10:33,490 --> 00:10:36,370
通過發送類似
用戶代理，通常

218
00:10:36,370 --> 00:10:38,300
應該說
您的瀏覽器的名稱。

219
00:10:38,300 --> 00:10:42,420
用戶代理瀏覽器，用戶代理上網
資源管理器的User-Agent的Firefox，這

220
00:10:42,420 --> 00:10:44,590
只是你的瀏覽器
確定自己的方式。

221
00:10:44,590 --> 00:10:46,605
但是，如果一個壞傢伙很
巧妙地說，毫米毫米，我

222
00:10:46,605 --> 00:10:47,930
不告訴你
什麼我的瀏覽器，

223
00:10:47,930 --> 00:10:50,888
我不是要你送這個
神秘的前瞻性的東西與室射頻

224
00:10:50,888 --> 00:10:55,840
*在裡面，你可以從字面上欺騙
在互聯網上易受攻擊的Web服務器

225
00:10:55,840 --> 00:10:59,055
為正是在執行
有刪除的所有文件。

226
00:10:59,055 --> 00:11:00,930
坦率地說，這不是
即使是最糟糕的。

227
00:11:00,930 --> 00:11:01,763
你可以做任何事情。

228
00:11:01,763 --> 00:11:04,480
你可以啟動一個分佈式
拒絕服務攻擊

229
00:11:04,480 --> 00:11:07,030
如果您收到此消息
Web服務器的整個串

230
00:11:07,030 --> 00:11:10,256
然後讓他們全部下降，為
舉例來說，在Harvard.edu服務器

231
00:11:10,256 --> 00:11:12,130
您可以排序爆炸
赫克了出來

232
00:11:12,130 --> 00:11:15,490
通過這是一個網絡流量
這個壞傢伙，否則觸發。

233
00:11:15,490 --> 00:11:18,760
>> 所以，長話短說，幾乎
每個人都在這個房間裡誰擁有一台Mac

234
00:11:18,760 --> 00:11:20,240
是受到此。

235
00:11:20,240 --> 00:11:24,100
的一線希望是，除非你
在筆記本電腦上運行一個Web服務器，

236
00:11:24,100 --> 00:11:27,780
除非你實際配置
它允許像SSH進去，

237
00:11:27,780 --> 00:11:28,670
你是真正安全的。

238
00:11:28,670 --> 00:11:31,710
它是脆弱的，但沒有
1試圖進入你的筆記本電腦，

239
00:11:31,710 --> 00:11:33,290
這樣你就可以排序的放心。

240
00:11:33,290 --> 00:11:36,210
不過，蘋果將很快
要更新此修復程序。

241
00:11:36,210 --> 00:11:39,660
Linux的世界已經發布
一些修復Fedora和Ubuntu的

242
00:11:39,660 --> 00:11:43,790
和其他版本的Linux，甚至
如果您在設備上運行更新50，

243
00:11:43,790 --> 00:11:45,930
即使是過會
更新和修正。

244
00:11:45,930 --> 00:11:47,764
但也有不
真的是脆弱的，

245
00:11:47,764 --> 00:11:49,804
因為除非你
修補了家電

246
00:11:49,804 --> 00:11:52,770
並公開了你的筆記本電腦
的網絡技術，這是不上訪問

247
00:11:52,770 --> 00:11:54,910
默認情況下，你
其實一直很好，因為

248
00:11:54,910 --> 00:11:56,890
對防火牆和其他技術。

249
00:11:56,890 --> 00:12:01,000
>> 但這是一個錯誤的極端例子
我們已經住在字面上20

250
00:12:01,000 --> 00:12:04,050
多年來，誰知道是否有人
這一切的時候已經知道這件事？

251
00:12:04,050 --> 00:12:06,300
而事實上，這是一
根本的挑戰

252
00:12:06,300 --> 00:12:08,690
我們將在後​​面看到
學期有關安全，

253
00:12:08,690 --> 00:12:13,020
是，就像在真實世界中，
好人都處於劣勢。

254
00:12:13,020 --> 00:12:16,500
為了使壞人，我們必須
確保每個門是鎖著的，

255
00:12:16,500 --> 00:12:20,340
每個窗口是安全的，那
每一個入口點進入家庭

256
00:12:20,340 --> 00:12:21,980
是安全的，以保持壞人。

257
00:12:21,980 --> 00:12:26,870
但到底是什麼壞人要
這樣做實際上損害你的家

258
00:12:26,870 --> 00:12:28,200
從你偷的？

259
00:12:28,200 --> 00:12:32,574
他或她只是要找到一個解鎖
門一破窗戶，還是

260
00:12:32,574 --> 00:12:35,240
沿著這些線路，並且它的
同樣的事情在計算機安全。

261
00:12:35,240 --> 00:12:37,660
我們可以寫幾百萬
的編程代碼行

262
00:12:37,660 --> 00:12:40,570
並花費數百或數千
小時好一會才正確，

263
00:12:40,570 --> 00:12:43,370
但如果你做只有一個
錯誤的正確性，

264
00:12:43,370 --> 00:12:47,030
你可以把整個系統，
實際上在這種情況下，整個互聯網

265
00:12:47,030 --> 00:12:48,660
與世界處於危險之中。

266
00:12:48,660 --> 00:12:51,950
>> 所以，如果你想了解更多
關於這一點，去這個網址在這裡。

267
00:12:51,950 --> 00:12:54,450
有沒有必要採取行動
今晚，除非你

268
00:12:54,450 --> 00:12:57,116
在那些比較舒服的
一直在運行自己的網站

269
00:12:57,116 --> 00:12:59,810
服務器，在這種情況下，你應該，
實際上，更新您的軟件。

270
00:12:59,810 --> 00:13:03,244
>> 而這也是標題
的演講，現在的文件，

271
00:13:03,244 --> 00:13:05,410
我們對所鏈接
當然網站今天。

272
00:13:05,410 --> 00:13:07,600
它是由一個老鄉
名為肯·湯普森，誰

273
00:13:07,600 --> 00:13:10,120
接受了一個非常有名的
獎勵在計算機科學中，

274
00:13:10,120 --> 00:13:13,495
他給了這一番話有些年頭
以前，基本上是在這同一主題。

275
00:13:13,495 --> 00:13:18,250

276
00:13:18,250 --> 00:13:20,520
問人的問題，
如果你真的

277
00:13:20,520 --> 00:13:23,480
信任，最終，
軟件，你已經給？

278
00:13:23,480 --> 00:13:26,100
舉例來說，我們都有
在寫程序，

279
00:13:26,100 --> 00:13:27,820
我們已經編制
他們鏘。

280
00:13:27,820 --> 00:13:31,830
和你的知識，你寫過
任何方案CS50那裡的

281
00:13:31,830 --> 00:13:35,310
各種各樣的後門，有一種方法
一個壞人，如果你運行的程序，

282
00:13:35,310 --> 00:13:37,410
可以接管你的電腦？

283
00:13:37,410 --> 00:13:38,310
或許不會，對吧？

284
00:13:38,310 --> 00:13:40,180
馬里奧和貪婪，以及信用。

285
00:13:40,180 --> 00:13:41,680
這些都是非常小的程序。

286
00:13:41,680 --> 00:13:43,910
你必須非常
如果你真的不好

287
00:13:43,910 --> 00:13:47,310
使你的整個電腦易受攻擊
寫10個或20行代碼後，

288
00:13:47,310 --> 00:13:49,690
或至少​​不知道的一些
對安全的影響。

289
00:13:49,690 --> 00:13:52,023
我說，開玩笑，
但我們要看到今天

290
00:13:52,023 --> 00:13:54,600
而本週它的實際
真的，真的很方便

291
00:13:54,600 --> 00:13:57,980
是壞的，讓即使是
短節目脆弱。

292
00:13:57,980 --> 00:14:02,880
>> 但現在，至少，實現
那在這裡被問的問題

293
00:14:02,880 --> 00:14:04,850
即將鏘的編譯器。

294
00:14:04,850 --> 00:14:08,360
為什麼我們一直相信鏘
在過去兩，三個星期？

295
00:14:08,360 --> 00:14:12,650
誰在說，誰寫鏘
沒有一個“if”條件在那裡

296
00:14:12,650 --> 00:14:17,680
這本質上注入了一些零
和那些到每一個程序在編譯

297
00:14:17,680 --> 00:14:21,180
這將讓他或她訪問
您的電腦，當你睡著了

298
00:14:21,180 --> 00:14:23,580
和你的筆記本電腦的蓋子是打開的
和您的計算機運行的是？

299
00:14:23,580 --> 00:14:24,080
對不對？

300
00:14:24,080 --> 00:14:28,350
我們有這樣的榮譽制度的權利
現在，我們相信鏘是合法的。

301
00:14:28,350 --> 00:14:30,000
你相信這些設備是合法的。

302
00:14:30,000 --> 00:14:34,430
你相信字面上每一個程序
在您的Mac或PC上是值得信賴的。

303
00:14:34,430 --> 00:14:37,510
而作為這個簡單的錯誤提示，
即使它沒有惡意，

304
00:14:37,510 --> 00:14:40,580
這絕對不是
可能是這種情況。

305
00:14:40,580 --> 00:14:42,350
>> 所以，你應該害怕得要命。

306
00:14:42,350 --> 00:14:45,560
坦率地說，有沒有簡單的
解決這個其他

307
00:14:45,560 --> 00:14:48,185
不是某種社會意識
日益增加的複雜性

308
00:14:48,185 --> 00:14:50,310
我們正在構建頂部
我們的電腦系統，

309
00:14:50,310 --> 00:14:53,740
怎麼越來越脆弱
我們很可能是。

310
00:14:53,740 --> 00:14:55,570
>> 現在，隨著中說，突圍。

311
00:14:55,570 --> 00:14:59,889
因此，突圍是設置的問題三，
突圍是從昔日的遊戲

312
00:14:59,889 --> 00:15:02,180
你可能還記得，但
對我們的問題集3，

313
00:15:02,180 --> 00:15:04,450
它使我們能夠
東西回來了一個檔次

314
00:15:04,450 --> 00:15:08,880
所以，當我們在寫程序，
即使是在這樣一個終端窗口，

315
00:15:08,880 --> 00:15:14,670
我們實際上可以運行，最終，
圖形化程序不

316
00:15:14,670 --> 00:15:17,800
不像我們有
訪問的划痕。

317
00:15:17,800 --> 00:15:20,910
因此，這是員工的
實現突圍，

318
00:15:20,910 --> 00:15:23,930
這僅僅是這種磚破
遊戲中，您將您的槳回

319
00:15:23,930 --> 00:15:27,590
來回，你擊出的球
對這些顏色的磚塊往上頂。

320
00:15:27,590 --> 00:15:30,020
因此，這也給我們帶來
排序回哪裡

321
00:15:30,020 --> 00:15:33,180
我們能夠非常迅速地
有划痕的，現在用C，

322
00:15:33,180 --> 00:15:35,800
實現我們自己的
圖形用戶界面。

323
00:15:35,800 --> 00:15:38,960
>> 但更重要的是，這
問題集代表第一

324
00:15:38,960 --> 00:15:41,000
在我們給
你一串代碼。

325
00:15:41,000 --> 00:15:43,940
而事實上，我帶來了明確的
注意這一點，因為特別是

326
00:15:43,940 --> 00:15:47,090
對於那些不太舒服，這
問題集，至少第一眼看上去，

327
00:15:47,090 --> 00:15:49,170
會感覺像
我們已經採取了一個檔次。

328
00:15:49,170 --> 00:15:51,540
因為我們已經給你，
對於一些搜索的

329
00:15:51,540 --> 00:15:54,930
而在PSET排序問題，
一幫我們寫的代碼，

330
00:15:54,930 --> 00:15:56,680
和一對夫婦的意見
該說“做”

331
00:15:56,680 --> 00:15:58,221
你必須填補空白。

332
00:15:58,221 --> 00:16:00,020
所以不要太嚇人，但
這是第一次

333
00:16:00,020 --> 00:16:03,370
我們交給你的代碼，你需要
先閱讀，理解，然後添加到

334
00:16:03,370 --> 00:16:04,290
並完成它。

335
00:16:04,290 --> 00:16:05,940
>> 再與突破，
我們要做的是相同的，

336
00:16:05,940 --> 00:16:08,740
給你幾十多行
的代碼，坦率地說，給你

337
00:16:08,740 --> 00:16:11,490
很多框架的
本場比賽，但站短

338
00:16:11,490 --> 00:16:14,304
在實施磚塊
和球和擋板，

339
00:16:14,304 --> 00:16:15,970
但我們實現一些其他功能。

340
00:16:15,970 --> 00:16:18,280
甚至，在乍看之下，再一次，
尤其是如果不舒服，

341
00:16:18,280 --> 00:16:21,480
似乎特別艱鉅，
你認為有這麼多的新功能

342
00:16:21,480 --> 00:16:24,070
你需要用你的頭腦
四周，這是真的。

343
00:16:24,070 --> 00:16:26,281
但請記住，這是
很喜歡划痕。

344
00:16:26,281 --> 00:16:28,780
奇怪的是，你並沒有使用所有的
在拼圖的划痕。

345
00:16:28,780 --> 00:16:31,120
奇怪的是，你並不在乎包
周圍所有的人你的心

346
00:16:31,120 --> 00:16:33,617
因為所有的花是
看一眼就明白了，呵呵，

347
00:16:33,617 --> 00:16:35,450
這就是我能做的
與拼圖。

348
00:16:35,450 --> 00:16:38,260
事實上，在問題設置
3規格，我們將向您

349
00:16:38,260 --> 00:16:41,370
在文檔會
給你介紹一些新的功能，

350
00:16:41,370 --> 00:16:43,570
最終編程
構建你使用。

351
00:16:43,570 --> 00:16:47,610
條件，循環，
變量和函數

352
00:16:47,610 --> 00:16:50,720
將是相同的，以
我們已經看到迄今。

353
00:16:50,720 --> 00:16:53,560
>> 所以事實上，我們會給
你的是一些示例代碼

354
00:16:53,560 --> 00:16:56,110
讓您創建一個窗口
看起來沒有什麼不同這一點，

355
00:16:56,110 --> 00:16:59,540
並最終把它變成
東西很喜歡這個。

356
00:16:59,540 --> 00:17:02,250
所以要CS50的優勢，
討論上班時間多，

357
00:17:02,250 --> 00:17:05,290
和安慰的事實，
代碼你寫的金額

358
00:17:05,290 --> 00:17:06,760
其實並沒有那麼多。

359
00:17:06,760 --> 00:17:10,359
第一個挑戰是只是為了適應
自己的一些代碼，我們已經寫了。

360
00:17:10,359 --> 00:17:11,450

361
00:17:11,450 --> 00:17:15,810
>> 在pset3任何問題，
Shellshock，或以其它方式？

362
00:17:15,810 --> 00:17:19,226
>> 聽眾：這似乎是
與突圍經歷

363
00:17:19,226 --> 00:17:22,154
該代碼是幾乎
一種面向對象的風格，

364
00:17:22,154 --> 00:17:24,675
但我認為C組的
面向對象的程序。

365
00:17:24,675 --> 00:17:26,050
揚聲器1：一個很好的問題。

366
00:17:26,050 --> 00:17:28,258
因此，在翻翻
分配代碼，代碼

367
00:17:28,258 --> 00:17:30,180
我們寫了pset3，
對於那些熟悉的，它

368
00:17:30,180 --> 00:17:32,230
看起來就像是一個
有點面向對象的。

369
00:17:32,230 --> 00:17:33,800
簡短的回答是，這是。

370
00:17:33,800 --> 00:17:38,130
這是如何的近似值
使用可能做的面向對象的代碼

371
00:17:38,130 --> 00:17:41,850
如C語言，但它是
還是最終的程序。

372
00:17:41,850 --> 00:17:44,900
有內部沒有方法
變量，你會看到的。

373
00:17:44,900 --> 00:17:46,180
但是，讓人聯想到這一點。

374
00:17:46,180 --> 00:17:48,780
我們將再次看到那個功能
當我們到PHP和JavaScript

375
00:17:48,780 --> 00:17:49,946
朝結束學期。

376
00:17:49,946 --> 00:17:53,667
但是現在，把它想成
一個什麼樣的暗示來。

377
00:17:53,667 --> 00:17:54,250
這個問題問得好。

378
00:17:54,250 --> 00:17:56,051

379
00:17:56,051 --> 00:17:56,550
好吧。

380
00:17:56,550 --> 00:17:59,730
所以，歸併排序是我們如何
左的東西最後一次。

381
00:17:59,730 --> 00:18:03,250
和歸併排序是涼
某種意義上說，它是如此之快，

382
00:18:03,250 --> 00:18:07,100
至少基於所述粗略測試
我們上週所做的，比說，泡

383
00:18:07,100 --> 00:18:08,710
排序，選擇排序，插入排序。

384
00:18:08,710 --> 00:18:11,780
什麼是整潔也是剛
如何簡潔和乾淨

385
00:18:11,780 --> 00:18:12,810
你可以表達出來。

386
00:18:12,810 --> 00:18:15,840
並沒有說什麼，這是一個上
勢必對合併的運行時間

387
00:18:15,840 --> 00:18:16,340
排序？

388
00:18:16,340 --> 00:18:17,633

389
00:18:17,633 --> 00:18:18,495
是嗎？

390
00:18:18,495 --> 00:18:19,360
>> 聽眾：N日誌N？

391
00:18:19,360 --> 00:18:20,819
>> 揚聲器1：N日誌N吧。 Ñ​​日誌N。

392
00:18:20,819 --> 00:18:23,776
我們會回來的是什麼
真正的意思或者是從何而來，

393
00:18:23,776 --> 00:18:25,570
但是，這是更好的
比運行時間

394
00:18:25,570 --> 00:18:28,440
我們看到了泡沫
選擇和插入排序？

395
00:18:28,440 --> 00:18:30,610
因此n的平方。 Ñ​​平方
大於這個，

396
00:18:30,610 --> 00:18:34,650
即使它不是很明顯，
知道日誌n是小於n，

397
00:18:34,650 --> 00:18:36,910
因此，如果你做了N次
東西小於n，

398
00:18:36,910 --> 00:18:38,680
這將是小於n的平方。

399
00:18:38,680 --> 00:18:40,130
這是一個有點直覺的存在。

400
00:18:40,130 --> 00:18:42,190
但是，我們為此付出了代價。

401
00:18:42,190 --> 00:18:47,000
那是快，但一個主題，開始
上週出現了這種折衷。

402
00:18:47,000 --> 00:18:49,804
我有更好的性能
一次明智的，但

403
00:18:49,804 --> 00:18:52,470
我才不得不花費在其他
另一方面，為了實現呢？

404
00:18:52,470 --> 00:18:53,591
>> 聽眾：內存。

405
00:18:53,591 --> 00:18:54,465
揚聲器1：再說一遍嗎？

406
00:18:54,465 --> 00:18:55,173
聽眾：內存。

407
00:18:55,173 --> 00:18:57,040
揚聲器1：記憶，或
空間比較一般。

408
00:18:57,040 --> 00:18:59,040
而這是不是超
很明顯我們的人，

409
00:18:59,040 --> 00:19:02,240
但記得，我們​​的志願者
是挺身而出，並加強

410
00:19:02,240 --> 00:19:04,780
回來好像有一個數組
在這裡，與作為雖然有

411
00:19:04,780 --> 00:19:07,130
在這裡，第二個陣列
他們可以使用的，因為我們

412
00:19:07,130 --> 00:19:09,080
需要的地方可合併那些人。

413
00:19:09,080 --> 00:19:11,480
我們不能只是交換他們的地方。

414
00:19:11,480 --> 00:19:13,800
所以，歸併排序槓桿
是更多的空間，這

415
00:19:13,800 --> 00:19:15,620
我們並不需要用
其它算法，

416
00:19:15,620 --> 00:19:17,410
但好處是，它的速度更快。

417
00:19:17,410 --> 00:19:20,780
坦率地說，在現實世界中的空間
這些days-- RAM，硬盤space--

418
00:19:20,780 --> 00:19:25,030
是價格相對便宜，所以這
並不一定是壞事。

419
00:19:25,030 --> 00:19:28,320
>> 因此，讓我們快速瀏覽一下，有點
更有條不紊，在我們所做的事情

420
00:19:28,320 --> 00:19:30,220
為什麼我們說，這是N日誌ñ。

421
00:19:30,220 --> 00:19:33,260
因此，這裡的8號和
8名志願者，我們有最後一次。

422
00:19:33,260 --> 00:19:35,718
和合併的第一件事
排序叫我們做的是什麼？

423
00:19:35,718 --> 00:19:37,010

424
00:19:37,010 --> 00:19:38,010
聽眾：分兩種。

425
00:19:38,010 --> 00:19:38,663
揚聲器1：再說一遍嗎？

426
00:19:38,663 --> 00:19:39,650
聽眾：分兩種。

427
00:19:39,650 --> 00:19:40,610
揚聲器1：分兩種，對吧。

428
00:19:40,610 --> 00:19:42,818
這很容易讓人想起的
電話簿鴻溝，

429
00:19:42,818 --> 00:19:44,220
征服更普遍。

430
00:19:44,220 --> 00:19:45,640
因此，我們看了看左半邊。

431
00:19:45,640 --> 00:19:48,700
再一次，我們說，排序
元件的左半

432
00:19:48,700 --> 00:19:49,690
沒有什麼我們接下來說什麼？

433
00:19:49,690 --> 00:19:51,210

434
00:19:51,210 --> 00:19:54,860
排序左側的左半邊
一半，這使我們能夠，

435
00:19:54,860 --> 00:19:57,570
兩分後，
專注於四個和兩個。

436
00:19:57,570 --> 00:20:01,280
>> 你如何排序的列表現在，在
大小二，使用合併排序的黃色，？

437
00:20:01,280 --> 00:20:02,330

438
00:20:02,330 --> 00:20:04,580
以及分成兩半，
和排序的左半部分。

439
00:20:04,580 --> 00:20:07,100
這是哪裡的東西
有點愚蠢的簡要介紹。

440
00:20:07,100 --> 00:20:10,720
你如何排序的列表是的
大小為一，像這樣的數字4在這裡？

441
00:20:10,720 --> 00:20:12,330

442
00:20:12,330 --> 00:20:13,210
它的排序。

443
00:20:13,210 --> 00:20:14,200
你就大功告成了。

444
00:20:14,200 --> 00:20:17,300
>> 但是你怎麼排序的列表
尺寸之一，當它的兩個數？

445
00:20:17,300 --> 00:20:21,640
那麼，同樣的事情，但現在究竟是什麼
第三和歸併排序的關鍵步驟？

446
00:20:21,640 --> 00:20:24,020
你必須合併左
半部和右半部。

447
00:20:24,020 --> 00:20:26,580
一旦我們這樣做，我們看
下午四，我們看著二人。

448
00:20:26,580 --> 00:20:28,750
我們決定所有的權利，
明明2至上，

449
00:20:28,750 --> 00:20:31,840
所以我們把兩個在其
的地方，後面跟著四個。

450
00:20:31,840 --> 00:20:35,010
現在你有一種倒帶，
這就是那種特性

451
00:20:35,010 --> 00:20:37,570
像合併的算法的
排序，快退在內存中。

452
00:20:37,570 --> 00:20:40,240
什麼是故事的下一行？

453
00:20:40,240 --> 00:20:41,780
我應該把重點放在下一個？

454
00:20:41,780 --> 00:20:43,110

455
00:20:43,110 --> 00:20:47,350
左的右半邊
一半，這是六，八。

456
00:20:47,350 --> 00:20:50,320
>> 所以，我只想通過這個步驟
無需操勞點太多。

457
00:20:50,320 --> 00:20:53,330
六，八，然後六是
整理，八排序。

458
00:20:53,330 --> 00:20:57,190
把它們合併起來那樣，
現在下一大步

459
00:20:57,190 --> 00:21:00,990
是，當然，排序由右半
該算法的第一個步驟。

460
00:21:00,990 --> 00:21:02,870
因此，我們專注於一，三，七，五。

461
00:21:02,870 --> 00:21:04,540
然後，我們專注於左半部。

462
00:21:04,540 --> 00:21:09,400
的該左半側，右半
即，然後合併在一個和三個。

463
00:21:09,400 --> 00:21:13,100
然後右半邊，則左一半
的話，那麼它的右半邊。

464
00:21:13,100 --> 00:21:15,985
合併它，現在哪一步依然？

465
00:21:15,985 --> 00:21:18,040

466
00:21:18,040 --> 00:21:22,460
合併大的左半邊和大
右半邊，所以一去那裡，

467
00:21:22,460 --> 00:21:27,330
然後二，然後三天，4，然後
5，然後6，那麼7，然後8。

468
00:21:27,330 --> 00:21:31,990
>> 所以，現在這是為什麼最終揭示，
特別是如果n和對數多

469
00:21:31,990 --> 00:21:35,487
一般而逃避你，
至少在最近的記憶？

470
00:21:35,487 --> 00:21:37,070
好了，看到這個東西的高度。

471
00:21:37,070 --> 00:21:41,230
我們有八個元素，而我們
除以它由兩個，用兩個，用兩個。

472
00:21:41,230 --> 00:21:44,590
所以日誌基地二期八給了我們三種。

473
00:21:44,590 --> 00:21:45,640

474
00:21:45,640 --> 00:21:48,540
而且相信我，如果
一點點朦朧的說。

475
00:21:48,540 --> 00:21:54,710
但是日誌基地二期八為三，
所以我們做了合併的三層。

476
00:21:54,710 --> 00:21:57,170
而當我們合併
元素，有多少個元素

477
00:21:57,170 --> 00:21:58,950
沒有我們看一下每個這些行嗎？

478
00:21:58,950 --> 00:22:00,212

479
00:22:00,212 --> 00:22:01,437
一共有n個，對不對？

480
00:22:01,437 --> 00:22:04,020
因為合併的頂行
即使我們這樣做，是零碎的，

481
00:22:04,020 --> 00:22:05,990
我們最終感動了每一個數字一次。

482
00:22:05,990 --> 00:22:09,054
和第二行中，以
合併大小兩個的名單，

483
00:22:09,054 --> 00:22:10,470
我們不得不接觸的每個元素一次。

484
00:22:10,470 --> 00:22:12,690
然後在這裡真的
清楚的最後一行中，

485
00:22:12,690 --> 00:22:15,430
我們必須相互接觸那些
元素一次，但只有一次，

486
00:22:15,430 --> 00:22:18,400
所以就在這裡，那麼，我們的n logñ。

487
00:22:18,400 --> 00:22:21,780
>> 而現在只是為了讓事情變得
更正式的就一下，如果你

488
00:22:21,780 --> 00:22:24,260
是目前分析這
在一種更高層次

489
00:22:24,260 --> 00:22:28,340
並嘗試決定，以及如何
也許你去表達

490
00:22:28,340 --> 00:22:31,780
該算法的運行時間
只是看著它，而不是

491
00:22:31,780 --> 00:22:33,590
通過使用一個人為的例子嗎？

492
00:22:33,590 --> 00:22:36,590
那麼，多少時間，你會說
步驟是這樣的黃色會採取，

493
00:22:36,590 --> 00:22:37,173
如果n <2的回報？

494
00:22:37,173 --> 00:22:38,840

495
00:22:38,840 --> 00:22:39,830
這是一個什麼樣的大O？

496
00:22:39,830 --> 00:22:41,450

497
00:22:41,450 --> 00:22:44,540
所以，我看到一個，所以一步到位，
也許兩個步驟，因為它是，如果

498
00:22:44,540 --> 00:22:47,110
然後返回，但它的
固定的時間，對不對？

499
00:22:47,110 --> 00:22:49,960
所以我們說的O（1），這是
我以後怎麼表達這一點。

500
00:22:49,960 --> 00:22:51,480
T，只是運行時間。

501
00:22:51,480 --> 00:22:54,150
n是輸入的大小，
因此T（n）的，只是一種奇特的方式

502
00:22:54,150 --> 00:22:56,330
的說法運行
大小為n的時間給定的輸入

503
00:22:56,330 --> 00:23:00,220
將是在順序上
的恆定時間，在O（1）。

504
00:23:00,220 --> 00:23:01,970
>> 但除此之外，這個怎麼樣？

505
00:23:01,970 --> 00:23:05,660
你會如何表達
運行這個黃線的時間呢？

506
00:23:05,660 --> 00:23:06,250
什麼T'

507
00:23:06,250 --> 00:23:09,440

508
00:23:09,440 --> 00:23:12,665
有種你可以欺騙這裡
週期性地回答我的問題。

509
00:23:12,665 --> 00:23:14,770

510
00:23:14,770 --> 00:23:17,900
因此，如果在運行時間
一般我們只說是T（N）。

511
00:23:17,900 --> 00:23:18,950

512
00:23:18,950 --> 00:23:22,490
現在你種撐船這裡
他說，好了，只是排序的左半部分，

513
00:23:22,490 --> 00:23:23,920
然後排序的右半​​部分。

514
00:23:23,920 --> 00:23:27,520
怎麼可能，我們象徵性地代表
此黃色線的運行時間？

515
00:23:27,520 --> 00:23:28,020
什麼T'

516
00:23:28,020 --> 00:23:29,360
什麼是輸入的大小？

517
00:23:29,360 --> 00:23:30,510

518
00:23:30,510 --> 00:23:31,057
Ñ​​了兩個。

519
00:23:31,057 --> 00:23:32,140
為什麼不讓我說？

520
00:23:32,140 --> 00:23:36,449
然後，這是另一個T（N / 2），然後
再次，如果我合併兩個排序的一半，

521
00:23:36,449 --> 00:23:38,615
有多少個元素我要去
有觸摸總？

522
00:23:38,615 --> 00:23:39,780

523
00:23:39,780 --> 00:23:40,320
ñ。

524
00:23:40,320 --> 00:23:42,790
所以，我可以表達這一點，
僅僅是種幻想，

525
00:23:42,790 --> 00:23:44,430
如在一般的運行時間。

526
00:23:44,430 --> 00:23:51,140
T（n）為T（N / 2）的僅有的運行時間，
加T（N / 2），左半部和右半部，

527
00:23:51,140 --> 00:23:55,360
加為O（n），這可能是n步，
但也許，如果我用兩個手指，

528
00:23:55,360 --> 00:23:57,960
它的兩倍多
步，但它是線性的。

529
00:23:57,960 --> 00:24:00,440
這步一定數目
這是n倍，

530
00:24:00,440 --> 00:24:02,270
因此，我們可以表達這是這一點。

531
00:24:02,270 --> 00:24:05,550
而這正是現在我們要踢的
回到我們的高中數學教科書

532
00:24:05,550 --> 00:24:10,290
我們認為最終的復發
最終這等於n次日誌N，

533
00:24:10,290 --> 00:24:12,530
如果你真的這樣做了
數學更正式。

534
00:24:12,530 --> 00:24:13,950
>> 所以，這只是兩種觀點。

535
00:24:13,950 --> 00:24:17,500
一個數字用
硬編碼的有代表性的例子

536
00:24:17,500 --> 00:24:21,140
用八個數字，更
總體來看，我們是如何到達那裡。

537
00:24:21,140 --> 00:24:25,670
但是，什麼是真正有趣的在這裡
是再次循環這個概念。

538
00:24:25,670 --> 00:24:26,900
我不使用for循環。

539
00:24:26,900 --> 00:24:29,860
我有點確定
事情的本身而言，

540
00:24:29,860 --> 00:24:31,950
不僅與此
數學函數，

541
00:24:31,950 --> 00:24:34,860
而且在此偽代碼方面。

542
00:24:34,860 --> 00:24:38,260
這個偽代碼是遞歸
在其兩個線

543
00:24:38,260 --> 00:24:42,310
基本上是告訴它去
用自身來解決小

544
00:24:42,310 --> 00:24:45,400
較小尺寸的問題，
然後連連

545
00:24:45,400 --> 00:24:48,820
又一次，直到我們消減它
下降到這個所謂的基本情況。

546
00:24:48,820 --> 00:24:52,810
>> 因此，讓我們實際繪製一個更引人注目
外賣從這個如下。

547
00:24:52,810 --> 00:24:58,420
讓我進入gedit的，並採取
看看今天的一些源代碼，

548
00:24:58,420 --> 00:24:59,930
尤其是這個例子在這裡。

549
00:24:59,930 --> 00:25:03,709
西格瑪0，這顯然增加了
數字1到n。

550
00:25:03,709 --> 00:25:05,750
因此，讓我們看看有什麼熟悉的
和不熟悉的位置。

551
00:25:05,750 --> 00:25:08,690
首先，我們有幾個
包括，所以沒有什麼新的存在。

552
00:25:08,690 --> 00:25:09,190
原型。

553
00:25:09,190 --> 00:25:11,370
我在一點點朦朧
這之後的幾天裡，

554
00:25:11,370 --> 00:25:13,790
但沒有我們說什麼
樣機的功能是？

555
00:25:13,790 --> 00:25:15,099

556
00:25:15,099 --> 00:25:16,015
聽眾：[聽不清]。

557
00:25:16,015 --> 00:25:16,905
揚聲器1：那是什麼？

558
00:25:16,905 --> 00:25:17,800
聽眾：我們公佈。

559
00:25:17,800 --> 00:25:18,883
揚聲器1：我們公佈。

560
00:25:18,883 --> 00:25:22,290
那麼，你是教鏘，嘿嘿，
沒有真正落實這事，

561
00:25:22,290 --> 00:25:25,740
但地方在這個文件中，據推測，
將要被調用什麼函數？

562
00:25:25,740 --> 00:25:26,930

563
00:25:26,930 --> 00:25:27,540
西格瑪。

564
00:25:27,540 --> 00:25:30,540
而這僅僅是一個承諾，
它會是這樣的。

565
00:25:30,540 --> 00:25:33,720
這將需要一個整數作為
input--，我可以更明確

566
00:25:33,720 --> 00:25:36,570
說INTÑ - 並且它的
會返回一個int，

567
00:25:36,570 --> 00:25:39,900
但分號手段，毫米，我會避開
要實現這一稍晚。

568
00:25:39,900 --> 00:25:40,989
再次，鏘是啞巴。

569
00:25:40,989 --> 00:25:43,280
它一定會知道
頂你告訴它底部，

570
00:25:43,280 --> 00:25:45,765
所以我們需要至少給
是一個什麼樣的暗示來。

571
00:25:45,765 --> 00:25:47,330
>> 現在，讓我們來看看主這裡

572
00:25:47,330 --> 00:25:50,040
讓我們在這裡向下滾動並
看到主在做什麼。

573
00:25:50,040 --> 00:25:53,780
這並不是說很長的函數，而
其實這裡的結構很熟悉。

574
00:25:53,780 --> 00:25:57,590
我宣布變量n，然後
我一再糾纏用戶

575
00:25:57,590 --> 00:26:01,880
使用調用getInt正整數，
和唯一的出口退出此循環

576
00:26:01,880 --> 00:26:03,280
一旦用戶已遵從。

577
00:26:03,280 --> 00:26:05,670
這樣做雖然，我們已經用
糾纏以這種方式給用戶。

578
00:26:05,670 --> 00:26:06,670
現在，這是有趣的。

579
00:26:06,670 --> 00:26:08,510
我宣布所謂的int“的答案。”

580
00:26:08,510 --> 00:26:11,420
我給它的返回值
一個所謂的功能“西格瑪”。

581
00:26:11,420 --> 00:26:15,200
我不知道做什麼呢，但
我記得剛才宣布的。

582
00:26:15,200 --> 00:26:18,310
然後我通過在
值，用戶在鍵入N，

583
00:26:18,310 --> 00:26:20,420
然後我就報了答案。

584
00:26:20,420 --> 00:26:22,260
那麼讓我們來回滾
只是一瞬間。

585
00:26:22,260 --> 00:26:28,620
讓我們繼續在這個目錄中，使
適馬0，實際上運行該程序

586
00:26:28,620 --> 00:26:30,490
看看會發生什麼。

587
00:26:30,490 --> 00:26:35,930
所以，如果我繼續運行
這個程序，./sigma-0，

588
00:26:35,930 --> 00:26:40,139
我輸入一個正
就像兩個整數，適馬，

589
00:26:40,139 --> 00:26:43,180
作為希臘象徵意味，只是
要由添加了所有的數

590
00:26:43,180 --> 00:26:44,320
零上最多兩個。

591
00:26:44,320 --> 00:26:46,560
所以，0加1加2。

592
00:26:46,560 --> 00:26:48,830
所以這應該有希望給我3。

593
00:26:48,830 --> 00:26:49,750
這一切都在做。

594
00:26:49,750 --> 00:26:52,690
同樣，如果我跑這又
我給這三個數，

595
00:26:52,690 --> 00:26:56,721
這是3加2，所以這
5，加1應該給我6。

596
00:26:56,721 --> 00:26:59,470
然後，如果我真的瘋了，
開始輸入更大的數字，

597
00:26:59,470 --> 00:27:01,290
它應該給我
越來越大的款項。

598
00:27:01,290 --> 00:27:02,250
因此，僅此而已。

599
00:27:02,250 --> 00:27:04,010
>> 那麼什麼是六西格瑪是什麼樣子？

600
00:27:04,010 --> 00:27:05,430
嗯，這是非常簡單的。

601
00:27:05,430 --> 00:27:08,940
這是我們如何可能實現
這在過去的幾個星期。

602
00:27:08,940 --> 00:27:11,120
“INT”將是返回類型。

603
00:27:11,120 --> 00:27:14,330
西格瑪是名字，它以
可變米替代N。

604
00:27:14,330 --> 00:27:15,940
我頂改變了。

605
00:27:15,940 --> 00:27:17,340
然後，這僅僅是一個全面的檢查。

606
00:27:17,340 --> 00:27:18,430

607
00:27:18,430 --> 00:27:19,950
我們會在某一時刻明白。

608
00:27:19,950 --> 00:27:24,220
現在，我宣布另一個變量，
總之，初始化為零。

609
00:27:24,220 --> 00:27:28,140
然後，我有這樣的For循環
迭代，顯然是為了清楚起見，

610
00:27:28,140 --> 00:27:33,810
從i = 1上長達一個= M，這是
不管用戶輸入的，然後我

611
00:27:33,810 --> 00:27:35,690
增加這樣的總和。

612
00:27:35,690 --> 00:27:37,360
然後返回的總和。

613
00:27:37,360 --> 00:27:38,440
>> 於是幾個問題。

614
00:27:38,440 --> 00:27:42,370
一，我要求我的意見，這
避免了一個無限循環的風險。

615
00:27:42,370 --> 00:27:45,620
為什麼會傳遞一個負數
誘發潛在的，無限循環？

616
00:27:45,620 --> 00:27:49,396

617
00:27:49,396 --> 00:27:51,290
>> 聽眾：你永遠也做不到米。

618
00:27:51,290 --> 00:27:52,880
>> 揚聲器1：永遠達不到米。

619
00:27:52,880 --> 00:27:55,880
但米傳入，讓我們
考慮一個簡單的例子。

620
00:27:55,880 --> 00:27:58,510
如果m是由通過在
用戶為負一。

621
00:27:58,510 --> 00:28:00,059
無論主。

622
00:28:00,059 --> 00:28:01,850
主要保護我們免受
這個也一樣，所以我只是

623
00:28:01,850 --> 00:28:04,680
是真的有肛
適馬也確保

624
00:28:04,680 --> 00:28:06,540
該輸入不能為負值。

625
00:28:06,540 --> 00:28:10,130
因此，如果m是否定的，
像負一。

626
00:28:10,130 --> 00:28:11,930
有什麼事情發生？

627
00:28:11,930 --> 00:28:14,390
好吧，我是要
得到初始化為1，

628
00:28:14,390 --> 00:28:19,060
然後我將是
小於或等於m？

629
00:28:19,060 --> 00:28:24,130

630
00:28:24,130 --> 00:28:24,765
>> 支持。

631
00:28:24,765 --> 00:28:26,930

632
00:28:26,930 --> 00:28:29,370
這was--我們不要，
讓尼克斯這個故事。

633
00:28:29,370 --> 00:28:32,780
我沒有問這個問題，因為
，我影射的風險

634
00:28:32,780 --> 00:28:38,360
是不會發生的，因為我是
總是會更大than--確定，

635
00:28:38,360 --> 00:28:39,871
我收起了這個問題。

636
00:28:39,871 --> 00:28:40,370
行。

637
00:28:40,370 --> 00:28:42,030
讓我們只專注於這部分在這裡。

638
00:28:42,030 --> 00:28:44,210

639
00:28:44,210 --> 00:28:48,830
為什麼我的一些聲明
循環之外？

640
00:28:48,830 --> 00:28:52,010
上線49我已經通知
í宣布在循環裡面，

641
00:28:52,010 --> 00:28:54,950
但網上48我已經
宣布一些外部。

642
00:28:54,950 --> 00:28:55,695
是啊。

643
00:28:55,695 --> 00:28:56,611
聽眾：[聽不清]。

644
00:28:56,611 --> 00:28:58,734

645
00:28:58,734 --> 00:28:59,400
揚聲器1：當然。

646
00:28:59,400 --> 00:29:03,360
所以，首先我當然不
要聲明和初始化總和

647
00:29:03,360 --> 00:29:06,130
到的零內
環上的每個迭代中，

648
00:29:06,130 --> 00:29:09,370
因為這顯然打敗
總結數的目的。

649
00:29:09,370 --> 00:29:11,770
我會不斷變化
值回零。

650
00:29:11,770 --> 00:29:17,992
還有，什麼是另一個更神秘的
原因是同樣的設計決定？

651
00:29:17,992 --> 00:29:18,954
是啊。

652
00:29:18,954 --> 00:29:20,279
>> 聽眾：[聽不清]。

653
00:29:20,279 --> 00:29:21,070
揚聲器1：沒錯。

654
00:29:21,070 --> 00:29:24,060
我想外面訪問
中環過上什麼線？

655
00:29:24,060 --> 00:29:25,390

656
00:29:25,390 --> 00:29:26,400
53。

657
00:29:26,400 --> 00:29:29,910
而根據我們的經驗法則
從一對夫婦的講座前，

658
00:29:29,910 --> 00:29:33,680
變量的作用域，說真的，到
大括號，涵蓋他們。

659
00:29:33,680 --> 00:29:38,190
所以，如果我不內聲明的總和
這些外花括號，

660
00:29:38,190 --> 00:29:40,250
在第53行，我不能使用它。

661
00:29:40,250 --> 00:29:43,160
換句話說，如果我宣布
在這裡，或者甚至在總和

662
00:29:43,160 --> 00:29:45,410
For循環，我不能訪問它的53。

663
00:29:45,410 --> 00:29:47,150
該變量將有效地去了。

664
00:29:47,150 --> 00:29:48,579
所以有幾個原因在那裡。

665
00:29:48,579 --> 00:29:50,370
但現在，讓我們回到
看看會發生什麼。

666
00:29:50,370 --> 00:29:51,730
因此適馬被調用。

667
00:29:51,730 --> 00:29:55,640
它增加了1加2或1加2
加3，然後將返回值，

668
00:29:55,640 --> 00:29:59,660
它存儲在回答，這裡的printf
所以我看到在屏幕上。

669
00:29:59,660 --> 00:30:03,079
所以，這就是我們稱之為迭代
方法，即迭代只

670
00:30:03,079 --> 00:30:03,870
意味著使用一個循環。

671
00:30:03,870 --> 00:30:06,900
for循環中，While循環中，DO WHILE
環路，只需再次做某事

672
00:30:06,900 --> 00:30:08,380
一次又一次。

673
00:30:08,380 --> 00:30:13,505
>> 不過，西格瑪是一種整齊的功能
我可以有不同的實現它。

674
00:30:13,505 --> 00:30:14,620

675
00:30:14,620 --> 00:30:19,120
那麼這一點，這
僅僅是種很酷，

676
00:30:19,120 --> 00:30:21,880
讓我真正擺脫
很多分心的

677
00:30:21,880 --> 00:30:24,380
因為這個功能
是很簡單的。

678
00:30:24,380 --> 00:30:27,780
讓我們來消減下來只
其四芯線

679
00:30:27,780 --> 00:30:30,410
和擺脫所有的
意見及大括號。

680
00:30:30,410 --> 00:30:34,334
這是怎樣的一個令人興奮的
另一種實現。

681
00:30:34,334 --> 00:30:37,250
好吧，也許不是令人興奮的，
但它是一種性感，沒事的，

682
00:30:37,250 --> 00:30:39,920
看看這如此多的更簡潔。

683
00:30:39,920 --> 00:30:43,120
只有四行代碼，
我第一次有這種全面的檢查。

684
00:30:43,120 --> 00:30:45,732
如果m小於或等於
為零，標準差是沒有意義的。

685
00:30:45,732 --> 00:30:48,190
它不僅應該在
這種情況下為正數，

686
00:30:48,190 --> 00:30:50,340
所以我只是要
返回零隨意

687
00:30:50,340 --> 00:30:53,210
所以，我們至少有
某些所謂的基本情況。

688
00:30:53,210 --> 00:30:54,430
>> 但這裡的美景。

689
00:30:54,430 --> 00:30:59,930
這種思想的全部，加上
從1數到n，m或在這種情況下，

690
00:30:59,930 --> 00:31:02,630
可以通過一種推卸責任的完成。

691
00:31:02,630 --> 00:31:04,947
那麼，什麼是1到m的總和？

692
00:31:04,947 --> 00:31:05,780
那麼，你知道嗎？

693
00:31:05,780 --> 00:31:11,949
這是相同的m的總和
加1〜m減1的總和。

694
00:31:11,949 --> 00:31:12,740
嗯，你知道嗎？

695
00:31:12,740 --> 00:31:13,940
什麼是m減1西格馬？

696
00:31:13,940 --> 00:31:17,860
好吧，如果你種按照此
在邏輯上，這是一樣的m減1

697
00:31:17,860 --> 00:31:21,415
加上m減2倍標準差。

698
00:31:21,415 --> 00:31:22,480

699
00:31:22,480 --> 00:31:26,012
所以，你可以種只是 - 
這就好比，如果你只是

700
00:31:26,012 --> 00:31:28,220
試圖惹惱朋友
他們問你一個問題，

701
00:31:28,220 --> 00:31:31,344
你種一個問題作出回應，
種你可以保持互相推諉。

702
00:31:31,344 --> 00:31:34,560
但是，什麼是關鍵的是，如果你繼續
使問題越來越小

703
00:31:34,560 --> 00:31:36,910
小，你
不是問什麼是六西格瑪

704
00:31:36,910 --> 00:31:39,116
n的什麼的西格瑪
N，什麼是n個西格瑪？

705
00:31:39,116 --> 00:31:40,990
你問什麼
n個西格瑪，什麼是六西格瑪

706
00:31:40,990 --> 00:31:42,839
正減1，什麼是正減去2倍標準差？

707
00:31:42,839 --> 00:31:44,880
最終，你的問題
將會變成什麼樣？

708
00:31:44,880 --> 00:31:50,250
什麼是一個或西格馬
零，一些非常小的值，

709
00:31:50,250 --> 00:31:52,220
而只要你
得到，你的朋友，

710
00:31:52,220 --> 00:31:54,350
你是不是要問
再次同樣的問題，

711
00:31:54,350 --> 00:31:55,975
你只是會說，哦，這是零。

712
00:31:55,975 --> 00:31:58,490
我們就大功告成了玩這種
愚蠢的循環遊戲。

713
00:31:58,490 --> 00:32:02,950
>> 因此，遞歸是編程的行為
函數調用自身。

714
00:32:02,950 --> 00:32:06,630
這個程序，編譯和運行的時候，是
要表現完全相同的方式，

715
00:32:06,630 --> 00:32:09,620
但什麼是關鍵的是，內
一個名為西格瑪功能，

716
00:32:09,620 --> 00:32:13,150
有一行代碼，其中
我們調用我們自己，

717
00:32:13,150 --> 00:32:14,980
一般來說，這是不好的。

718
00:32:14,980 --> 00:32:21,160
舉例來說，如果我有什麼第一
編撰了這本，所以請sigma--

719
00:32:21,160 --> 00:32:22,710
使西格瑪1 ./sigma-1。

720
00:32:22,710 --> 00:32:25,050

721
00:32:25,050 --> 00:32:27,690
正整數，請50 1275。

722
00:32:27,690 --> 00:32:30,810
那麼，什麼功能似乎
是基於一個試驗中，正確的。

723
00:32:30,810 --> 00:32:34,917
但如果我得到一點點危險
和刪除所謂鹼的情況下，

724
00:32:34,917 --> 00:32:37,750
而只是說，好吧，我只是做
這比它更複雜的。

725
00:32:37,750 --> 00:32:42,450
讓我們只計算西格瑪
通過取米，然後加

726
00:32:42,450 --> 00:32:44,564
在米減一西格瑪？

727
00:32:44,564 --> 00:32:45,980
那麼，什麼會發生在這裡？

728
00:32:45,980 --> 00:32:47,140
讓我們縮小。

729
00:32:47,140 --> 00:32:52,920
讓我們重新編譯程序，
保存，重新編譯程序，

730
00:32:52,920 --> 00:33:00,450
然後準備./sigma-1放大，
進入正整數，請50。

731
00:33:00,450 --> 00:33:02,180

732
00:33:02,180 --> 00:33:04,430
你們有多少人願意
以明說看到嗎？

733
00:33:04,430 --> 00:33:04,950
>> 行。

734
00:33:04,950 --> 00:33:06,690
因此，這可能發生在
由於多種原因，

735
00:33:06,690 --> 00:33:09,148
坦白地說，本週我們
約給你更多的人。

736
00:33:09,148 --> 00:33:11,780
但在這種情況下，嘗試
向後推理

737
00:33:11,780 --> 00:33:14,430
什麼可能在這裡發生了什麼？

738
00:33:14,430 --> 00:33:17,400
分段錯誤，我們所說的最後
時間，是指內存的段。

739
00:33:17,400 --> 00:33:18,690
壞事發生。

740
00:33:18,690 --> 00:33:21,550
但究竟是什麼
機械的偏差去

741
00:33:21,550 --> 00:33:25,000
在這裡，因為我的去除
的即所謂的鹼的情況下，

742
00:33:25,000 --> 00:33:26,870
在我返回一個硬編碼的值？

743
00:33:26,870 --> 00:33:28,970

744
00:33:28,970 --> 00:33:30,460
你覺得哪裡出了問題？

745
00:33:30,460 --> 00:33:31,219
是啊。

746
00:33:31,219 --> 00:33:32,135
>> 聽眾：[聽不清]。

747
00:33:32,135 --> 00:33:36,387

748
00:33:36,387 --> 00:33:36,970
揚聲器1：嗯。

749
00:33:36,970 --> 00:33:37,550
這個問題問得好。

750
00:33:37,550 --> 00:33:39,508
如此數量的大小
我是總結

751
00:33:39,508 --> 00:33:41,920
有這麼大，它超過了
的存儲器空間的大小。

752
00:33:41,920 --> 00:33:44,640
想法很好，但沒有從根本上
會導致崩潰。

753
00:33:44,640 --> 00:33:48,230
這可能會導致整數溢出，
其中位剛剛空翻多

754
00:33:48,230 --> 00:33:51,760
然後我們誤以為一個真正的大
像負數數，

755
00:33:51,760 --> 00:33:53,260
但本身並不會導致崩潰。

756
00:33:53,260 --> 00:33:55,509
因為底了
一天一個int仍然是32位。

757
00:33:55,509 --> 00:33:57,640
你不會
不小心偷了第33位。

758
00:33:57,640 --> 00:33:58,431
但一個好的想法。

759
00:33:58,431 --> 00:33:58,984
是啊。

760
00:33:58,984 --> 00:33:59,900
>> 聽眾：[聽不清]。

761
00:33:59,900 --> 00:34:00,551

762
00:34:00,551 --> 00:34:02,300
揚聲器1：本方法
從來沒有停止運行，

763
00:34:02,300 --> 00:34:06,658
而事實上它再次調用自身
一次又一次又一次

764
00:34:06,658 --> 00:34:08,449
並且再次，與沒有
這些功能不斷

765
00:34:08,449 --> 00:34:13,310
完成，因為他們唯一的行
碼一再呼籲自理

766
00:34:13,310 --> 00:34:14,219
又一遍。

767
00:34:14,219 --> 00:34:16,080
什麼是真正
這裡發生的，現在我們

768
00:34:16,080 --> 00:34:18,100
種可以得出這樣的圖示方式。

769
00:34:18,100 --> 00:34:20,899
讓我去了一個
圖片只是一瞬間。

770
00:34:20,899 --> 00:34:22,940
這是一個圖片，那
最終將充實

771
00:34:22,940 --> 00:34:26,336
在更多的細節，這是怎麼回事
在你的計算機內存。

772
00:34:26,336 --> 00:34:28,460
而事實證明，在
這幅畫的底部

773
00:34:28,460 --> 00:34:29,709
一種叫做堆棧。

774
00:34:29,709 --> 00:34:31,920
這是一大塊
內存的RAM塊，

775
00:34:31,920 --> 00:34:33,920
這只是用於任何時間
一個函數被調用。

776
00:34:33,920 --> 00:34:36,239
任何時候你，程序員，
調用一個函數，

777
00:34:36,239 --> 00:34:38,860
操作系統，如
的Mac OS，Windows或Linux中，

778
00:34:38,860 --> 00:34:41,920
抓起一串字節，也許是
幾KB，也許幾兆

779
00:34:41,920 --> 00:34:44,590
內存，遞上
給你，然後讓

780
00:34:44,590 --> 00:34:47,650
您使用的是運行你的函數
任何變量，你需要的。

781
00:34:47,650 --> 00:34:50,699
如果你再調用另一個
功能與其它功能，

782
00:34:50,699 --> 00:34:53,590
你的內存另一片
和記憶另一片。

783
00:34:53,590 --> 00:34:57,090
>> 事實上，如果這些綠色托盤
從安嫩伯格代表內存，

784
00:34:57,090 --> 00:34:59,870
這裡就是發生在第一
一次調用函數標準差。

785
00:34:59,870 --> 00:35:04,510
這就像把一盤這樣的
什麼是最初一個空棧。

786
00:35:04,510 --> 00:35:07,142
不過，如果該紙盤
自稱，可以這麼說，

787
00:35:07,142 --> 00:35:08,850
調用另一個實例
適馬的，這是

788
00:35:08,850 --> 00:35:11,640
像詢問操作系統，
哦，需要多一點的內存，

789
00:35:11,640 --> 00:35:12,520
給我。

790
00:35:12,520 --> 00:35:14,840
然後它就會在上面堆。

791
00:35:14,840 --> 00:35:18,030
但是，什麼是這裡的關鍵是，
第一盤仍然存在，

792
00:35:18,030 --> 00:35:20,620
因為他援引這第二盤。

793
00:35:20,620 --> 00:35:23,500
現在同時，SIGMA適馬打電話，
這就像要求更多的內存。

794
00:35:23,500 --> 00:35:25,830
被堆在了這裡。

795
00:35:25,830 --> 00:35:29,350
適馬適馬稱，這是另一個
托盤被堆在這裡。

796
00:35:29,350 --> 00:35:32,942
如果你繼續這樣做，
最終，種地圖這種視覺

797
00:35:32,942 --> 00:35:35,525
該排行榜，什麼事情
發生與該堆托盤？

798
00:35:35,525 --> 00:35:37,480

799
00:35:37,480 --> 00:35:41,160
它是將超過的量
內存您的計算機。

800
00:35:41,160 --> 00:35:45,790
而一旦這個綠色托盤
超過水平線

801
00:35:45,790 --> 00:35:49,410
上面的堆棧和上面那個字堆，
我們會回來的，在未來，

802
00:35:49,410 --> 00:35:50,410
這是一件壞事。

803
00:35:50,410 --> 00:35:52,810
堆是不同的
內存部分，

804
00:35:52,810 --> 00:35:55,190
如果你讓這些
盤樁與樁，

805
00:35:55,190 --> 00:35:57,800
你要超越
你自己的部分記憶，

806
00:35:57,800 --> 00:36:00,420
和程序確實要崩潰。

807
00:36:00,420 --> 00:36:02,930
>> 現在，順便說一句，這個想法
遞歸的，因此

808
00:36:02,930 --> 00:36:06,500
可以清楚地導致的問題，但
它不一定是壞事。

809
00:36:06,500 --> 00:36:08,840
由於考慮後，
總之，how--，也許

810
00:36:08,840 --> 00:36:11,700
這需要一些時間來
 - 如何以優雅的或者多​​麼簡單

811
00:36:11,700 --> 00:36:14,890
在實施六西格瑪的了。

812
00:36:14,890 --> 00:36:17,440
而且我們不打算使用
遞歸的CS50所有的東西，

813
00:36:17,440 --> 00:36:20,780
但在CS51，真是任何類
在那裡你操作的數據結構

814
00:36:20,780 --> 00:36:23,640
如樹或家譜，
有一些層級

815
00:36:23,640 --> 00:36:26,000
這是超級，超級有用。

816
00:36:26,000 --> 00:36:29,750
現在，作為一個一旁，讓你
作為有抱負的計算機科學家

817
00:36:29,750 --> 00:36:33,180
熟悉一些谷歌的了
裡面的笑話，如果你去谷歌

818
00:36:33,180 --> 00:36:36,345
你查查是什麼
中，定義說，遞歸，進入。

819
00:36:36,345 --> 00:36:40,208

820
00:36:40,208 --> 00:36:41,110
嗯。

821
00:36:41,110 --> 00:36:42,670
順便說一句，我拉了幾下。

822
00:36:42,670 --> 00:36:45,470
這是像10分鐘
拖沓今天早上。

823
00:36:45,470 --> 00:36:52,890
如果你也是谷歌“歪”的通知
通過傾斜你的頭slightly--

824
00:36:52,890 --> 00:36:55,120
然後這個人是可能
最殘暴的是

825
00:36:55,120 --> 00:36:57,286
既然有人喜歡花
他們一天執行本

826
00:36:57,286 --> 00:36:59,880
幾年ago--來吧。

827
00:36:59,880 --> 00:37:01,140

828
00:37:01,140 --> 00:37:04,540
哦，wait--這是一個錯誤。

829
00:37:04,540 --> 00:37:08,410

830
00:37:08,410 --> 00:37:11,410
>> 因此，對一個運行
世界上最大的網站

831
00:37:11,410 --> 00:37:13,510
這些愚蠢的小彩蛋。

832
00:37:13,510 --> 00:37:16,690
他們可能消耗
代碼的行數平凡

833
00:37:16,690 --> 00:37:19,280
只是讓我們可以有
小樂這樣的事情。

834
00:37:19,280 --> 00:37:22,140
但至少現在你
其中的一些內部笑話。

835
00:37:22,140 --> 00:37:28,330
>> 現在，讓我們來看看一些
善意的謊言，我們一直叫晚，

836
00:37:28,330 --> 00:37:30,707
並開始剝離回
一些技術上層

837
00:37:30,707 --> 00:37:32,790
讓你真正了解
什麼是怎麼回事

838
00:37:32,790 --> 00:37:34,860
你能理解
一些威脅，

839
00:37:34,860 --> 00:37:38,060
像Shellshock，那
現在已經開始成為

840
00:37:38,060 --> 00:37:41,110
在每個人的前列
注意，至少在媒體。

841
00:37:41,110 --> 00:37:45,810
因此，這裡是一個非常簡單的功能
不返回任何內容無效。

842
00:37:45,810 --> 00:37:46,790
它的名字是交換。

843
00:37:46,790 --> 00:37:50,880
它需要在兩個變量
它沒有返回值。

844
00:37:50,880 --> 00:37:52,260
把A和B。

845
00:37:52,260 --> 00:37:53,337
因此，一個快速演示。

846
00:37:53,337 --> 00:37:54,170
我們把這些了。

847
00:37:54,170 --> 00:37:56,100
我們不妨取一點
打破這裡只是一瞬間

848
00:37:56,100 --> 00:37:57,250
並有一個小東西喝。

849
00:37:57,250 --> 00:38:00,120
如果有人不介意加盟
我在這裡只是一瞬間。

850
00:38:00,120 --> 00:38:01,830
你怎麼樣了棗紅色的襯衫？

851
00:38:01,830 --> 00:38:02,335
上來吧。

852
00:38:02,335 --> 00:38:04,060

853
00:38:04,060 --> 00:38:05,260
只是一個今天。

854
00:38:05,260 --> 00:38:06,251
謝謝你，雖然。

855
00:38:06,251 --> 00:38:08,000
好吧，我們有
來了誰在這裡？

856
00:38:08,000 --> 00:38:08,660
你叫什麼名字？

857
00:38:08,660 --> 00:38:09,360
>> 揚聲器4：勞拉。

858
00:38:09,360 --> 00:38:09,740
>> 揚聲器1：勞拉。

859
00:38:09,740 --> 00:38:10,370
上來吧。

860
00:38:10,370 --> 00:38:11,460

861
00:38:11,460 --> 00:38:13,850
所以勞拉，今天很簡單的挑戰。

862
00:38:13,850 --> 00:38:14,704

863
00:38:14,704 --> 00:38:15,370
很高興見到喲。

864
00:38:15,370 --> 00:38:16,410

865
00:38:16,410 --> 00:38:16,910
好吧。

866
00:38:16,910 --> 00:38:21,179
因此，我們有一些牛奶在這裡
我們有一些橙汁在這裡

867
00:38:21,179 --> 00:38:23,345
有的杯子，我們
從安嫩伯格今天借來的。

868
00:38:23,345 --> 00:38:24,178
>> 揚聲器4：借來的。

869
00:38:24,178 --> 00:38:27,240
揚聲器1：而且要繼續前進
給你的這半杯。

870
00:38:27,240 --> 00:38:28,250

871
00:38:28,250 --> 00:38:28,800
好吧。

872
00:38:28,800 --> 00:38:30,750
我們會給你一半
一杯牛奶。

873
00:38:30,750 --> 00:38:31,905

874
00:38:31,905 --> 00:38:35,890
呵呵，只是這樣就可以
還記得這是什麼樣子，

875
00:38:35,890 --> 00:38:38,860
我還記得帶
這和今天。

876
00:38:38,860 --> 00:38:42,030

877
00:38:42,030 --> 00:38:42,530
好。

878
00:38:42,530 --> 00:38:45,470
如果你不介意的話，讓我們來看看，我們
可以把他們交給自己的眼鏡

879
00:38:45,470 --> 00:38:46,560
如果你想。

880
00:38:46,560 --> 00:38:48,710
這將是從勞拉眼中的世界。

881
00:38:48,710 --> 00:38:49,210
好吧。

882
00:38:49,210 --> 00:38:53,820
所以你的目標，考慮到兩杯
液體此處，牛奶和橙汁，

883
00:38:53,820 --> 00:38:58,370
被交換兩個內容，這樣
橙汁進入牛奶杯

884
00:38:58,370 --> 00:39:00,710
和牛奶進入
橙汁一杯。

885
00:39:00,710 --> 00:39:02,359
>> 揚聲器4：我得再來一杯？

886
00:39:02,359 --> 00:39:05,650
揚聲器1：我很高興你問，但
這本來是更好的素材

887
00:39:05,650 --> 00:39:06,710
如果你沒有問。

888
00:39:06,710 --> 00:39:10,620
但是，是的，我們可以為您提供三分之一
杯那是當然的空白。

889
00:39:10,620 --> 00:39:11,120
好吧。

890
00:39:11,120 --> 00:39:12,300
因此，交換的內容在那裡。

891
00:39:12,300 --> 00:39:16,100

892
00:39:16,100 --> 00:39:17,050
很不錯。

893
00:39:17,050 --> 00:39:20,390

894
00:39:20,390 --> 00:39:21,305
挺好。

895
00:39:21,305 --> 00:39:23,121

896
00:39:23,121 --> 00:39:24,745
你這樣做非常仔細。

897
00:39:24,745 --> 00:39:26,970

898
00:39:26,970 --> 00:39:28,655
和第三步。

899
00:39:28,655 --> 00:39:30,390

900
00:39:30,390 --> 00:39:31,350
好吧。

901
00:39:31,350 --> 00:39:31,930
優秀的。

902
00:39:31,930 --> 00:39:33,930
熱烈的掌聲中
將是很好的勞拉。

903
00:39:33,930 --> 00:39:36,500

904
00:39:36,500 --> 00:39:37,000
好吧。

905
00:39:37,000 --> 00:39:40,790
我們有一點點臨別禮物
你，但讓我把這些。

906
00:39:40,790 --> 00:39:42,620
太謝謝你了。

907
00:39:42,620 --> 00:39:46,170
因此，一個簡單的例子，不過，
證明，如果你做

908
00:39:46,170 --> 00:39:48,300
想交換的內容
兩個容器中，

909
00:39:48,300 --> 00:39:52,360
還是讓我們稱他們為變量，
你需要一些臨時存儲

910
00:39:52,360 --> 00:39:56,710
在這樣階段的內容之一。
你實際上可以做交換。

911
00:39:56,710 --> 00:40:01,790
所以事實上，這個源代碼在這裡在
C是代表正是中。

912
00:40:01,790 --> 00:40:06,340
如果橙汁是和牛奶
是B，我們想交換兩個，

913
00:40:06,340 --> 00:40:08,990
你可以嘗試一些創造性的工作
通過傾一方轉換成另一方，

914
00:40:08,990 --> 00:40:11,031
但是這可能不會
結束特別好。

915
00:40:11,031 --> 00:40:15,260
因此，我們採用了第三杯，通話
它TMP，T-M-P按照慣例，

916
00:40:15,260 --> 00:40:19,370
放的內容
辛普森在那，然後換一個杯子，

917
00:40:19,370 --> 00:40:22,610
然後把辛普森進入
原盅，從而

918
00:40:22,610 --> 00:40:25,320
實現，正是因為
勞拉那樣，交換。

919
00:40:25,320 --> 00:40:26,850
>> 因此，讓我們這樣做。

920
00:40:26,850 --> 00:40:30,110
讓我繼續前進，開
了一個例子，是

921
00:40:30,110 --> 00:40:32,720
其實所謂的“無
交換，“因為這不是

922
00:40:32,720 --> 00:40:36,180
因為只是照你的想像。

923
00:40:36,180 --> 00:40:41,190
所以這個計劃，請注意
我使用的是stdio.h中，我們的老朋友。

924
00:40:41,190 --> 00:40:43,130
我有原型
用於交換在那裡，這

925
00:40:43,130 --> 00:40:45,450
指其實施的
可能向下跌破，

926
00:40:45,450 --> 00:40:48,050
讓我們看看這個主
程序會為我做。

927
00:40:48,050 --> 00:40:52,020
我第一次申報詮釋x變
之一，詮釋y得到兩張。

928
00:40:52,020 --> 00:40:54,930
因此，認為那些是辛普森的
和牛奶分別。

929
00:40:54,930 --> 00:40:57,100
然後，我只是有一個
printf的話說，x是該

930
00:40:57,100 --> 00:41:00,120
和y是這樣的，只是讓我可以
直觀地看到發生了什麼事情。

931
00:41:00,120 --> 00:41:03,810
然後，我的printf自稱
那我換了兩下，

932
00:41:03,810 --> 00:41:07,100
然後我打印出
聲稱他們交換，

933
00:41:07,100 --> 00:41:09,300
我再次打印出x和y。

934
00:41:09,300 --> 00:41:13,010
這樣下來在這裡互換是
正是勞拉做了，

935
00:41:13,010 --> 00:41:16,240
我們看到了什麼
剛才的畫面。

936
00:41:16,240 --> 00:41:19,380
>> 因此，讓我們繼續前進，
大失所望。

937
00:41:19,380 --> 00:41:24,690
毫無互換，並運行沒有掉，
在輸出放大在這裡。

938
00:41:24,690 --> 00:41:28,320
輸入x為1，y為2，交換交換。

939
00:41:28,320 --> 00:41:32,700
x是靜止1，且y是靜止2。

940
00:41:32,700 --> 00:41:37,630
因此，即使坦白地說，這看起來
一模一樣，雖然技術上更，

941
00:41:37,630 --> 00:41:40,730
什麼勞拉一樣，似乎並沒有工作。

942
00:41:40,730 --> 00:41:42,130
那麼，為什麼會這樣呢？

943
00:41:42,130 --> 00:41:46,630
嗯，事實證明，當
我們寫這樣的程序

944
00:41:46,630 --> 00:41:51,590
同時具有主，在這裡強調，
然後另外一個功能，如交換，

945
00:41:51,590 --> 00:41:54,230
在這裡強調，這
它調用的世界

946
00:41:54,230 --> 00:41:57,030
看起來有點像
這些托盤剛才。

947
00:41:57,030 --> 00:42:00,440
當主第一次被調用，
這就像問操作系統

948
00:42:00,440 --> 00:42:04,030
在任何地方一點點記憶
如x和y的主要有變量，

949
00:42:04,030 --> 00:42:05,660
他們最終在那裡。

950
00:42:05,660 --> 00:42:10,920
但是，如果主電話交換和主
通過交換兩個參數a和b，

951
00:42:10,920 --> 00:42:16,410
橙汁和牛奶，不喜歡
遞給了橙汁和牛奶

952
00:42:16,410 --> 00:42:17,500
勞拉。

953
00:42:17,500 --> 00:42:21,300
什麼是電腦呢，就是它
經過橙汁的副本

954
00:42:21,300 --> 00:42:27,110
牛奶勞拉和副本，從而使
什麼是最終這盤內

955
00:42:27,110 --> 00:42:32,510
為值1和2，或OJ
以及它們的牛奶，但副本，

956
00:42:32,510 --> 00:42:34,790
所以，在這一點
在故事中，有

957
00:42:34,790 --> 00:42:36,930
是辛普森和牛奶中的每一個托盤。

958
00:42:36,930 --> 00:42:39,260
有一個和兩
在每個這些托盤，

959
00:42:39,260 --> 00:42:41,720
和交換功能確實工作。

960
00:42:41,720 --> 00:42:46,090
它的內部交換他們
第二最上面的托盤的，

961
00:42:46,090 --> 00:42:48,147
但該交換沒有任何影響。

962
00:42:48,147 --> 00:42:49,980
並根據只是一些
我們已經基本原理

963
00:42:49,980 --> 00:42:52,970
談到前，確實
短短的幾個小時前，有什麼

964
00:42:52,970 --> 00:42:58,770
或許可以解釋為什麼改變
A和B交換內

965
00:42:58,770 --> 00:43:05,560
對x和y的任何影響，即使
我通過x和y的調劑功能。

966
00:43:05,560 --> 00:43:08,750
什麼是這裡的關鍵詞
可以簡單地解釋一下嗎？

967
00:43:08,750 --> 00:43:11,250

968
00:43:11,250 --> 00:43:12,627
我想我在這裡聽到了嗎？

969
00:43:12,627 --> 00:43:13,335
聽眾：返回。

970
00:43:13,335 --> 00:43:14,085
揚聲器1：回報？

971
00:43:14,085 --> 00:43:14,590
不歸。

972
00:43:14,590 --> 00:43:15,895
讓我們一起去另一個。

973
00:43:15,895 --> 00:43:16,395
那是什麼？

974
00:43:16,395 --> 00:43:17,080
>> 聽眾：[聽不清]。

975
00:43:17,080 --> 00:43:20,000
>> 揚聲器1：好了，return--我們可以
做復出之作中的故事，

976
00:43:20,000 --> 00:43:21,914
但還有一個更簡單的解釋。

977
00:43:21,914 --> 00:43:22,580
聽眾：適用範圍。

978
00:43:22,580 --> 00:43:23,288
揚聲器1：適用範圍。

979
00:43:23,288 --> 00:43:24,300
我帶的範圍。

980
00:43:24,300 --> 00:43:27,290
所以範圍，記得在哪裡
我們的x和y的聲明。

981
00:43:27,290 --> 00:43:30,840
他們中聲明
的主力右在這裡。

982
00:43:30,840 --> 00:43:33,200
a和b，同時，有
有效申報

983
00:43:33,200 --> 00:43:35,930
掉在裡面，不是很
大括號，但仍

984
00:43:35,930 --> 00:43:37,690
在交換的一般地區。

985
00:43:37,690 --> 00:43:40,560
所以實際上，A和B
僅此托盤中存在

986
00:43:40,560 --> 00:43:44,850
從安嫩伯格，這個
代碼的第二塊。

987
00:43:44,850 --> 00:43:49,500
因此，我們確實改變了副本，但
這不是真的那麼有用。

988
00:43:49,500 --> 00:43:52,190
>> 因此，讓我們一起來看看
這個低一點的水平。

989
00:43:52,190 --> 00:43:55,430
我要回去到
在源目錄，

990
00:43:55,430 --> 00:43:58,330
而我要第一
放大這裡，只是

991
00:43:58,330 --> 00:44:02,290
確認我在這
更大的終端窗口，

992
00:44:02,290 --> 00:44:04,430
該程序的行為仍然這樣。

993
00:44:04,430 --> 00:44:06,840
現在假設這
是不是故意的。

994
00:44:06,840 --> 00:44:10,090
很明顯，我想互換
工作，所以感覺就像一個錯誤。

995
00:44:10,090 --> 00:44:12,780
現在我可以開始添加
很多的printf的我的代碼，

996
00:44:12,780 --> 00:44:16,010
這裡打印出倍過，Y在
在這裡，在這裡，B在這裡。

997
00:44:16,010 --> 00:44:18,220
但坦率地說，這可能是什麼
你已經做了幾個星期的

998
00:44:18,220 --> 00:44:20,190
現在，在辦公時間
而在家裡工作時，

999
00:44:20,190 --> 00:44:22,150
在pset時試圖找到一些錯誤。

1000
00:44:22,150 --> 00:44:25,560
但是你會看到，如果你還沒有，
這個問題設置3為您介紹

1001
00:44:25,560 --> 00:44:31,630
一個叫做GDB命令，
其中GDB，GNU調試器，

1002
00:44:31,630 --> 00:44:34,040
有自己一大堆
的功能，實際上可以

1003
00:44:34,040 --> 00:44:38,160
讓我們了解的情況
像這樣的，但更令人信服，

1004
00:44:38,160 --> 00:44:39,940
解決問題和發現的bug。

1005
00:44:39,940 --> 00:44:40,940
所以，我要做到這一點。

1006
00:44:40,940 --> 00:44:44,770
相反./noswap的，我不是
要運行GDB ./noswap。

1007
00:44:44,770 --> 00:44:47,410

1008
00:44:47,410 --> 00:44:51,200
換句話說，我要執行我的
程序不是在Bash中，我們的新朋友

1009
00:44:51,200 --> 00:44:51,850
今天。

1010
00:44:51,850 --> 00:44:53,970
我要我跑
節目noswap內

1011
00:44:53,970 --> 00:44:56,900
這個所謂的其他程序
廣發行，這是一個調試器，它

1012
00:44:56,900 --> 00:45:01,035
是的，旨在幫助計劃
你們人類找到並刪除錯誤。

1013
00:45:01,035 --> 00:45:03,410
所以，如果我打在這裡運行，有
文字的殘暴量

1014
00:45:03,410 --> 00:45:04,868
你真的從來沒有閱讀。

1015
00:45:04,868 --> 00:45:07,290
它本質上是一種干擾
從提示，

1016
00:45:07,290 --> 00:45:10,030
我會打控制-L
起床，在那裡的頂部。

1017
00:45:10,030 --> 00:45:11,800
這是GDB的提示。

1018
00:45:11,800 --> 00:45:15,550
如果我想現在運行這個程序，
作為今天的這個小小抄

1019
00:45:15,550 --> 00:45:21,860
幻燈片顯示，潤是第一
命令，我們打算引進。

1020
00:45:21,860 --> 00:45:25,150
我只是要輸入
跑起來這裡的GDB內，

1021
00:45:25,150 --> 00:45:26,811
而事實上它跑了我的計劃。

1022
00:45:26,811 --> 00:45:29,310
現在有一些額外的
像這樣的屏幕的輸出

1023
00:45:29,310 --> 00:45:31,910
但是這GDB只是被肛
並告訴我們發生了什麼事情。

1024
00:45:31,910 --> 00:45:34,451
你真的不擔心
這些細節現在。

1025
00:45:34,451 --> 00:45:36,890
但是，什麼是真正酷的
GDB的，如果我這樣做again--

1026
00:45:36,890 --> 00:45:42,100
控制-L清除screen--讓我走
進取，鍵入“破為主，”因此，

1027
00:45:42,100 --> 00:45:45,743
當我按下Enter鍵，設置什麼
所謂的noswap.c一個破發點，

1028
00:45:45,743 --> 00:45:51,270
線16，這是其中GDB
想通了，我的計劃實際上

1029
00:45:51,270 --> 00:45:53,070
是，我的功能實際上是。

1030
00:45:53,070 --> 00:45:55,070
為此，我們將忽略現在
但是這是地址

1031
00:45:55,070 --> 00:45:57,310
在存儲器具體的該功能。

1032
00:45:57,310 --> 00:46:00,240
所以，現在當我鍵入run，
發現什麼是酷在這裡。

1033
00:46:00,240 --> 00:46:05,650
我的程序違反的線I
對廣發行在暫停執行。

1034
00:46:05,650 --> 00:46:09,850
所以，我不必改變現在我的代碼，
加一些printf的年代，重新編譯，重新運行

1035
00:46:09,850 --> 00:46:13,300
它，改變，添加一些的printf的，
保存，重新編譯，運行它。

1036
00:46:13,300 --> 00:46:18,100
我可以走過我的程序
在人類的速度一步一步一個腳印，

1037
00:46:18,100 --> 00:46:20,880
不是在英特爾內部的那種速度。

1038
00:46:20,880 --> 00:46:24,580
>> 所以，現在看到這條線
出現在這裡了，如果我回去

1039
00:46:24,580 --> 00:46:27,800
我在gedit中的程序，
請注意，這實際上是

1040
00:46:27,800 --> 00:46:29,280
的第一行代碼。

1041
00:46:29,280 --> 00:46:31,240
有gedit中第16行。

1042
00:46:31,240 --> 00:46:34,610
有16行GDB中，甚至
雖然這黑白界面

1043
00:46:34,610 --> 00:46:37,760
是不是幾乎一樣的用戶
友好的，這意味著

1044
00:46:37,760 --> 00:46:41,680
該線路16還沒有被執行
然而，但它即將被。

1045
00:46:41,680 --> 00:46:46,220
所以，如果我輸入打印的確
X，不是printf的，只是打印的x，

1046
00:46:46,220 --> 00:46:50,730
我得到了一些零假值出現，
因為X有沒有被初始化。

1047
00:46:50,730 --> 00:46:54,760
所以我打算接下來的輸入，或者，如果你
想成為幻想，只是n轉到下一個。

1048
00:46:54,760 --> 00:46:59,090
但是當我輸入下一個進入，現在
注意到它移動到第17行。

1049
00:46:59,090 --> 00:47:02,840
所以，從邏輯上講，如果我執行
第16行，我現在輸入打印X，

1050
00:47:02,840 --> 00:47:03,640
我應該怎麼看？

1051
00:47:03,640 --> 00:47:04,970

1052
00:47:04,970 --> 00:47:05,520
之一。

1053
00:47:05,520 --> 00:47:07,820
>> 而現在，這是無可否認的混亂。

1054
00:47:07,820 --> 00:47:11,260
2美元是只是一種奇特的方式，如果你
希望以後參考該數值，

1055
00:47:11,260 --> 00:47:12,510
你可以說“美元簽兩個。”

1056
00:47:12,510 --> 00:47:13,480
這就像一個向後引用。

1057
00:47:13,480 --> 00:47:14,570
但是現在，就忽視它。

1058
00:47:14,570 --> 00:47:17,070
有趣的是什麼
等號右邊。

1059
00:47:17,070 --> 00:47:21,000
而現在，如果我明年再次鍵入
和打印Y，我看到2。

1060
00:47:21,000 --> 00:47:23,870
我也可以開始打印
點¯x再次，​​坦白說，

1061
00:47:23,870 --> 00:47:27,130
如果我開始有點困惑，
我在哪裡，我可以輸入清單列表

1062
00:47:27,130 --> 00:47:30,590
，只是看到周圍的一些環境
點我其實在。

1063
00:47:30,590 --> 00:47:35,180
現在我可以鍵入
接下來，有x是1。

1064
00:47:35,180 --> 00:47:36,300
現在我輸入下一個。

1065
00:47:36,300 --> 00:47:37,710
哦，y為2。

1066
00:47:37,710 --> 00:47:40,750
再次，它是混亂的，
因為GDB的輸出

1067
00:47:40,750 --> 00:47:43,044
被混合用我自己的輸出。

1068
00:47:43,044 --> 00:47:45,710
但是，如果你要記住，通過
一眼來回你的代碼

1069
00:47:45,710 --> 00:47:47,740
或者鋪設了一面
並排也許，你會

1070
00:47:47,740 --> 00:47:51,020
看到真的我只是
步進通過我的節目。

1071
00:47:51,020 --> 00:47:54,620
>> 但是請注意，接下來會發生什麼，從字面上。

1072
00:47:54,620 --> 00:47:56,380
這裡是第22行。

1073
00:47:56,380 --> 00:48:01,315
讓我過目一下，從而使上
23，如果我打印點¯x現在，依然之一。

1074
00:48:01,315 --> 00:48:03,890
如果我現在打印Y，依然之一。

1075
00:48:03,890 --> 00:48:05,820
所以，這不是一個有用的練習。

1076
00:48:05,820 --> 00:48:07,450
因此，讓我們重做了。

1077
00:48:07,450 --> 00:48:10,069
讓我回去到
頂部和類型來看一次。

1078
00:48:10,069 --> 00:48:12,110
和它說程序
這是正在調試

1079
00:48:12,110 --> 00:48:14,109
開始已經，
從頭開始。

1080
00:48:14,109 --> 00:48:15,420
是的，讓我們再次做到這一點。

1081
00:48:15,420 --> 00:48:22,000
而這一次，讓我們做下一個，
下一步，下一步，下一步，下一步，

1082
00:48:22,000 --> 00:48:24,180
但現在事情變得有趣。

1083
00:48:24,180 --> 00:48:27,760
現在我想踏入
掉，所以我不鍵入下一個。

1084
00:48:27,760 --> 00:48:34,380
我輸入的步驟，現在發現它
已經躍升我noswap.c線33。

1085
00:48:34,380 --> 00:48:37,240
如果我回去gedit的，什麼是33行？

1086
00:48:37,240 --> 00:48:40,500
這是第一個實際
代碼行互換的內部。

1087
00:48:40,500 --> 00:48:44,150
這是很好的，因為現在我可以
種閒逛，讓好奇的

1088
00:48:44,150 --> 00:48:46,052
至於什麼是真正打算在那裡。

1089
00:48:46,052 --> 00:48:46,760
讓我打印TMP。

1090
00:48:46,760 --> 00:48:47,770

1091
00:48:47,770 --> 00:48:48,800
哇。

1092
00:48:48,800 --> 00:48:51,438
為什麼TMP有一些
瘋了，假的垃圾的價值？

1093
00:48:51,438 --> 00:48:54,579

1094
00:48:54,579 --> 00:48:56,120
聽眾：它沒有被初始化。

1095
00:48:56,120 --> 00:48:57,150
揚聲器1：它沒有被初始化。

1096
00:48:57,150 --> 00:49:00,270
事實上，當你運行一個程序，
你給出一大堆的記憶

1097
00:49:00,270 --> 00:49:03,392
由操作系統，但你
未初始化的任何值，

1098
00:49:03,392 --> 00:49:05,600
所以你什麼位
看到這裡，即使它

1099
00:49:05,600 --> 00:49:07,770
這個瘋狂的大利空
數，只是表示

1100
00:49:07,770 --> 00:49:10,750
這些都是從殘存
一些以前使用的內存，

1101
00:49:10,750 --> 00:49:13,050
即使我有沒有
我需要它。

1102
00:49:13,050 --> 00:49:17,086
所以，現在我要繼續和類型
接下來，如果我現在輸入打印TMP，

1103
00:49:17,086 --> 00:49:17,835
我應該怎麼看？

1104
00:49:17,835 --> 00:49:19,570

1105
00:49:19,570 --> 00:49:23,360
無論a的值，
a是第一個參數，只是

1106
00:49:23,360 --> 00:49:25,550
如x是第一
東西被傳遞，

1107
00:49:25,550 --> 00:49:30,450
所以A和X應該是相同的，
所以打印TMP應打印我一個。

1108
00:49:30,450 --> 00:49:36,360
>> 所以，你會在問題集中看
三是各種各樣的GDB教程，

1109
00:49:36,360 --> 00:49:40,020
但要意識到，這是開始
看一個工具，它將真正

1110
00:49:40,020 --> 00:49:42,774
幫你解決問題
這樣更有效。

1111
00:49:42,774 --> 00:49:44,690
我們最終是什麼
要做到週三

1112
00:49:44,690 --> 00:49:48,180
在開始剝開幾層
並刪除了一些輔助輪。

1113
00:49:48,180 --> 00:49:50,496
這東西叫字符串
我們已經使用了一段時間，

1114
00:49:50,496 --> 00:49:53,370
我們要慢慢的把這種美麗
從你開始談論

1115
00:49:53,370 --> 00:49:55,725
更多的東西esoterically
被稱為字符*，

1116
00:49:55,725 --> 00:49:59,550
但我們要做到這一點不錯，
輕輕地在第一，即使指針

1117
00:49:59,550 --> 00:50:02,730
因為他們是所謂的，可以做一些
如果濫用非常糟糕的事情，

1118
00:50:02,730 --> 00:50:06,040
通過觀察從一個小粘土動畫
我們的朋友尼克Parlante斯坦福

1119
00:50:06,040 --> 00:50:09,670
大學計算機教授
學誰放在一起這個預覽

1120
00:50:09,670 --> 00:50:11,075
對什麼樣的來本週三。

1121
00:50:11,075 --> 00:50:12,196

1122
00:50:12,196 --> 00:50:13,400
>> [視頻回放]

1123
00:50:13,400 --> 00:50:13,900
嘿，賓基。

1124
00:50:13,900 --> 00:50:14,930

1125
00:50:14,930 --> 00:50:15,780
醒來。

1126
00:50:15,780 --> 00:50:17,240
現在是時候為指針樂趣。

1127
00:50:17,240 --> 00:50:18,260

1128
00:50:18,260 --> 00:50:19,350
>>  - 什麼是什麼？

1129
00:50:19,350 --> 00:50:21,150
了解指針？

1130
00:50:21,150 --> 00:50:22,050
噢，好極了！

1131
00:50:22,050 --> 00:50:22,897

1132
00:50:22,897 --> 00:50:23,730
[完視頻回放]

1133
00:50:23,730 --> 00:50:25,396
揚聲器1：那等著你在星期三。

1134
00:50:25,396 --> 00:50:26,440
我們會看到你呢。

1135
00:50:26,440 --> 00:50:27,106
[視頻回放]

1136
00:50:27,106 --> 00:50:30,420
 - 和現在，深層的思考，
通過Daven法納姆。

1137
00:50:30,420 --> 00:50:33,980

1138
00:50:33,980 --> 00:50:35,900
>>  - 為什麼我們要學C？

1139
00:50:35,900 --> 00:50:36,785
為什麼不是A +？

1140
00:50:36,785 --> 00:50:38,550

1141
00:50:38,550 --> 00:50:40,910
>> [笑]

1142
00:50:40,910 --> 00:50:42,160
>> [完視頻回放]