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
>> [完视频回放]