1
00:00:00,000 --> 00:00:02,760
[Powered by Google Translate] [周5]

2
00:00:02,760 --> 00:00:04,760
戴维·J·马兰，哈佛大学]

3
00:00:04,760 --> 00:00:11,990
这是CS50。[CS50.TV]

4
00:00:11,990 --> 00:00:17,780
[女人]他在说谎的是什么，我不知道。

5
00:00:17,780 --> 00:00:20,300
[文]因此，我们知道些什么？

6
00:00:20,300 --> 00:00:24,120
[女人] 9时15分，雷Santoya是在ATM。

7
00:00:24,120 --> 00:00:27,420
[文]因此，问题是，什么是他做的9:16？

8
00:00:27,420 --> 00:00:29,980
[女人]拍摄9毫米的东西。

9
00:00:29,980 --> 00:00:31,900
也许他看到了狙击手。

10
00:00:31,900 --> 00:00:34,000
[文]他与他共事。

11
00:00:34,000 --> 00:00:36,330
[女人]等待。回到一个。

12
00:00:36,330 --> 00:00:38,330
[文]你看到了什么？

13
00:00:38,330 --> 00:00:44,520
[♫悬疑音乐♫]

14
00:00:44,520 --> 00:00:48,320
[女人]把他的脸。全屏。

15
00:00:48,320 --> 00:00:51,230
[文]他的眼镜。 >>共有的一种体现。

16
00:00:51,230 --> 00:01:00,810
[♫悬疑音乐♫]

17
00:01:00,810 --> 00:01:03,580
[文]这是在Nuevita的棒球队。这是他们的标志。

18
00:01:03,580 --> 00:01:07,790
[女人]他在说给谁穿的那件夹克。

19
00:01:07,790 --> 00:01:13,730
>> [大卫·马兰]所以，这是CS50 5周，而今天我们为你毁了一个位电视和电影。

20
00:01:13,730 --> 00:01:16,170
所以，每当你看像这样的在这里表演，

21
00:01:16,170 --> 00:01:19,910
警察说：“你能不能清理一下？”或“增强”

22
00:01:19,910 --> 00:01:21,900
有没有提高在现实世界中。

23
00:01:21,900 --> 00:01:25,220
事实上，你真正得到的是这样一个小东西。

24
00:01:25,220 --> 00:01:27,570
我把从页面的员工照片之一。

25
00:01:27,570 --> 00:01:30,980
这是一个被称为Photoshop的。这是1 2 Bowdens

26
00:01:30,980 --> 00:01:36,300
1 3 Bowdens实际上，今天，是因为我们有夫人波顿这里，Rob和保罗。

27
00:01:36,300 --> 00:01:41,950
但这里是抢在屏幕上，如果我们放大上，闪闪发光，他总是有他的眼睛，

28
00:01:41,950 --> 00:01:47,600
你看到的就是你所看到的就是你得到的。

29
00:01:47,600 --> 00:01:51,690
这是“增强”，因此“CSI”有点不对劲。

30
00:01:51,690 --> 00:01:55,190
还有另外一个片段，如果我们可以选择“CSI”只是一点点的时间。

31
00:01:55,190 --> 00:01:58,500
这是一个很好的短语，从今以后，如果你想说出

32
00:01:58,500 --> 00:02:10,280
完善的技术的时候，真的与你的朋友，你是说绝对没有。

33
00:02:10,280 --> 00:02:12,970
>> [文]几个星期以来，我一直在调查的马车夫的杀手谋杀

34
00:02:12,970 --> 00:02:15,360
具有一定的病态的迷恋。

35
00:02:15,360 --> 00:02:17,160
[女人＃1]这是实时的。

36
00:02:17,160 --> 00:02:22,930
[女人]我使用Visual Basic创建一个GUI界面，看看我是否能跟踪一个IP地址。

37
00:02:22,930 --> 00:02:29,570
>> [马兰]音频不同步一旁，创建一个GUI界面，使用Visual Basic

38
00:02:29,570 --> 00:02:31,820
跟踪一个IP地址是完全荒谬的。

39
00:02:31,820 --> 00:02:33,840
这些日子里，你将不能使用Visual Basic，

40
00:02:33,840 --> 00:02:38,920
有没有需要一个图形用户界面，IP地址是一个技术上准确的术语。

41
00:02:38,920 --> 00:02:41,730
因此，保持一个眼睛，对于这些，我的最爱之一：

42
00:02:41,730 --> 00:02:45,070
这其中的多了几分神秘的，因为你需要知道不同的语言。

43
00:02:45,070 --> 00:02:47,860
有一种语言叫Objective-C中，这是一个C的超集

44
00:02:47,860 --> 00:02:51,960
这意味着它的C加上一些额外的功能，其中包括面向对象的编程。

45
00:02:51,960 --> 00:02:55,070
这是语言，苹果已经为iOS编程推广。

46
00:02:55,070 --> 00:02:58,760
因此，这里是一个片段从一个完全不同的节目，从“数字”

47
00:02:58,760 --> 00:03:02,450
其实，如果你仔细看你的TiVo和暂停在适当的时候，

48
00:03:02,450 --> 00:03:07,700
你会看到，他们想要的东西是不太所描述的是什么。

49
00:03:07,700 --> 00:03:11,170
让我尝试不同的音频连接器，看看如果我们不能

50
00:03:11,170 --> 00:03:13,780
保持音频的同步时间。

51
00:03:13,780 --> 00:03:20,530
我给你的“数字”。

52
00:03:20,530 --> 00:03:23,240
>> [文＃1]这是一个32位的IPv4地址。

53
00:03:23,240 --> 00:03:38,930
[文2]的IP地址，这是互联网。 >>专用网络。这是梅艳芳的专用网络。

54
00:03:38,930 --> 00:03:43,810
[马兰]好吧。这是Objective-C，这是一些孩子的着色方案，

55
00:03:43,810 --> 00:03:51,140
你或许可以推断出变量的名称。

56
00:03:51,140 --> 00:03:54,410
这样，那么，“数字”。所以我们今天和本周介绍

57
00:03:54,410 --> 00:03:57,740
取证和背景的问题，因此世界上的一点点。

58
00:03:57,740 --> 00:04:00,590
今天将是一个简短的演讲，因为在这里有一个特殊的事件

59
00:04:00,590 --> 00:04:05,530
之后，我们将采取偷看，和逗学生和家长的一致好评今天

60
00:04:05,530 --> 00:04:07,420
一些的东西，是在地平线上。

61
00:04:07,420 --> 00:04:12,240
其中，截至周一，你将有一些更多的同学。

62
00:04:12,240 --> 00:04:16,050
EDX，哈佛和MITS新的在线主动开放课件

63
00:04:16,050 --> 00:04:19,120
多，正在启动（星期一）在哈佛的校园。

64
00:04:19,120 --> 00:04:21,490
这意味着前来周一，你将有 - 如最近的一次统计，

65
00:04:21,490 --> 00:04:26,210
86,000额外的同学也将会跟随着CS50的演讲

66
00:04:26,210 --> 00:04:29,170
和部分演练和习题集。

67
00:04:29,170 --> 00:04:32,350
作为这项工作的一部分，你会成为会员的首届类

68
00:04:32,350 --> 00:04:35,090
CS50和现在CS50x。

69
00:04:35,090 --> 00:04:39,310
>> 作为其中的一部分，现在，意识到，会有一些不相上下以及。

70
00:04:39,310 --> 00:04:43,790
要为此做好准备，对于数量庞大的学生，

71
00:04:43,790 --> 00:04:47,180
可以肯定地说，即使我们有108个转录因子和CA，

72
00:04:47,180 --> 00:04:50,790
不太最好的学生/教师比例后，我们打80000其他学生。

73
00:04:50,790 --> 00:04:52,850
因此，我们不会被分级这么多的问题，手动设置。

74
00:04:52,850 --> 00:04:55,920
所以，本周推出的习题集将是CS50检查，

75
00:04:55,920 --> 00:04:58,450
这将是一个命令行实用程序在设备

76
00:04:58,450 --> 00:05:01,200
一次，你会得到你以后更新本周末，

77
00:05:01,200 --> 00:05:03,200
，你就可以运行一个命令，检查50

78
00:05:03,200 --> 00:05:06,500
在您自身的pset中，你会得到一些反馈，为您的程序是否

79
00:05:06,500 --> 00:05:11,160
正确的或不正确的，根据我们所提供的各种设计规范。

80
00:05:11,160 --> 00:05:13,580
因此，更多的问题设定的规范和

81
00:05:13,580 --> 00:05:17,240
CS50x同学们将利用这一点。

82
00:05:17,240 --> 00:05:19,230
>> 所以，问题设置4个是所有约取证。

83
00:05:19,230 --> 00:05:21,940
这件作品的灵感来自一些真实的东西，

84
00:05:21,940 --> 00:05:24,620
由此，当我在读研究生，我实习一段时间，

85
00:05:24,620 --> 00:05:28,650
米德尔塞克斯郡的地区检察官办公室从事法医工作

86
00:05:28,650 --> 00:05:31,650
他们的领导取证调查，这为

87
00:05:31,650 --> 00:05:35,260
，我想我提到的几个星期过去，是质量国家警察或其他

88
00:05:35,260 --> 00:05:39,000
会来的，他们会脱落的东西，如硬盘驱动器和光盘和软盘

89
00:05:39,000 --> 00:05:42,340
等，然后取证办公室的目标是，以确定是否

90
00:05:42,340 --> 00:05:44,600
有或没有某种形式的证据。

91
00:05:44,600 --> 00:05:48,010
这是特别调查组，所以它是白领犯罪，

92
00:05:48,010 --> 00:05:52,350
更令人不安的是排序的犯罪，

93
00:05:52,350 --> 00:05:55,990
什么涉及某种数字媒体;原来，没有那么多的人

94
00:05:55,990 --> 00:05:59,370
写一封电子邮件说：“我做到了。”

95
00:05:59,370 --> 00:06:03,290
所以，很多时候，这些取证搜索没有打开所有的东西，水果，

96
00:06:03,290 --> 00:06:05,850
但有时人们会写这样的邮件。

97
00:06:05,850 --> 00:06:08,490
所以有时的努力得到了回报。

98
00:06:08,490 --> 00:06:14,420
>> 但是，得出了这个法医pset中，我们将介绍在pset中4位的图形。

99
00:06:14,420 --> 00:06:18,260
所以，你可能把这些东西是理所当然的，JPEG格式，GIF和像这些天，

100
00:06:18,260 --> 00:06:21,640
但如果你真的仔细想想，图像，就像罗布的脸，

101
00:06:21,640 --> 00:06:24,430
可以建模为一个序列的点，或像素。

102
00:06:24,430 --> 00:06:26,680
现在，在罗布的脸的情况下，有各种颜色，

103
00:06:26,680 --> 00:06:29,940
我们开始看到的各个点，otherwide称为像素，

104
00:06:29,940 --> 00:06:31,610
一旦我们开始放大。

105
00:06:31,610 --> 00:06:35,590
但是，如果我们简化了这个世界变得，只是说，这里是Rob

106
00:06:35,590 --> 00:06:40,560
在黑色和白色，代表黑色和白色，我们可以只使用二进制文件。

107
00:06:40,560 --> 00:06:44,960
如果我们要使用二进制的1或0，我们可以表达这种相同的图像

108
00:06:44,960 --> 00:06:51,970
Rob的笑脸这种模式位：11000011表示

109
00:06:51,970 --> 00:06:55,160
白，白，黑，黑，黑，黑，白白。

110
00:06:55,160 --> 00:06:59,290
因此，这不是一个巨大的飞跃，然后，开始谈论精美图片。

111
00:06:59,290 --> 00:07:01,920
的东西，你会看到在Facebook或用数码相机，

112
00:07:01,920 --> 00:07:04,730
但肯定的是，当涉及到颜色，你需要更多的比特。

113
00:07:04,730 --> 00:07:08,470
在世界上的照片相当普遍的是使用1位颜色，

114
00:07:08,470 --> 00:07:12,730
因为这建议，但24位色，你实际上得到数百万种颜色。

115
00:07:12,730 --> 00:07:15,430
因此，作为的情况下，当我们放大罗布的眼睛上，

116
00:07:15,430 --> 00:07:19,270
这是任何数以百万计的不同颜色的可能性。

117
00:07:19,270 --> 00:07:22,260
>> 因此，我们就为大家介绍这方面的问题集4以及在演练中，

118
00:07:22,260 --> 00:07:27,050
这将是今天下午3:30，而不是平常的下午2时30分，因为上周五的演讲在这里。

119
00:07:27,050 --> 00:07:29,930
但视频是在线的，像往常一样，明天。

120
00:07:29,930 --> 00:07:31,880
我们还将为您介绍另一种文件格式。

121
00:07:31,880 --> 00:07:34,150
因此，这是故意为了看起来吓人，

122
00:07:34,150 --> 00:07:38,980
但是，这仅仅是一些文件的C结构。

123
00:07:38,980 --> 00:07:42,280
事实证明，微软，几年前，捧红了这种格式，

124
00:07:42,280 --> 00:07:46,630
被称为位图文件格式，BMP，这是一个超级简单的，

125
00:07:46,630 --> 00:07:50,390
丰富多彩的图形文件格式，使用相当长的一段时间

126
00:07:50,390 --> 00:07:53,640
有时仍然在桌面上的壁纸。

127
00:07:53,640 --> 00:07:57,410
如果你觉得回到了Windows XP和绵延的群山和蔚蓝的天空，

128
00:07:57,410 --> 00:08:00,660
这是典型的一个BMP位图图像，位图

129
00:08:00,660 --> 00:08:03,340
是我们的乐趣，因为他们有了更多的复杂性。

130
00:08:03,340 --> 00:08:05,640
这不是一件简单的事情，因为这格的0和1的;

131
00:08:05,640 --> 00:08:10,680
代替，你必须像一个头在一个文件的开始的东西。

132
00:08:10,680 --> 00:08:15,520
所以，换句话说，里面的。bmp文件是0和1的一大堆，

133
00:08:15,520 --> 00:08:18,070
但有一些额外的0和1的在那里。

134
00:08:18,070 --> 00:08:21,450
而事实证明，我们可能已经多年理所当然的，

135
00:08:21,450 --> 00:08:27,040
doc或xls或。MP3或MP4的文件格式，如，

136
00:08:27,040 --> 00:08:29,910
任何你熟悉的文件格式。

137
00:08:29,910 --> 00:08:31,900
那么，是什么它甚至意味着是一个文件格式？

138
00:08:31,900 --> 00:08:35,740
因为在一天结束的时候，我们使用所有这些文件都只是0和1的

139
00:08:35,740 --> 00:08:39,950
也许那些0和1的代表，乙，丙，通过ASCII或等，

140
00:08:39,950 --> 00:08:42,030
但通过一天结束的时候，它只是0和1。

141
00:08:42,030 --> 00:08:45,300
>> 因此，人类只是偶尔决定发明一种新的文件格式

142
00:08:45,300 --> 00:08:49,420
他们规范的位模式，实际上的意思。

143
00:08:49,420 --> 00:08:52,790
在这种情况下，这里的人谁设计的位图文件格式

144
00:08:52,790 --> 00:08:58,260
说，在第一个字节中的位图文件，并标示为偏移0，在那里，

145
00:08:58,260 --> 00:09:02,320
将是一些神秘命名的变量称为bfType，

146
00:09:02,320 --> 00:09:06,510
这只是代表了位图文件的类型，这是什么类型的位图文件。

147
00:09:06,510 --> 00:09:10,780
你可以推断出，或许，从第二排，偏移量为2，第2字节数

148
00:09:10,780 --> 00:09:15,980
有图案的0和1组成的，代表什么吗？

149
00:09:15,980 --> 00:09:18,320
事物的大小，它从那里。

150
00:09:18,320 --> 00:09:20,660
因此，问题集4中，你会走过一些事情。

151
00:09:20,660 --> 00:09:24,480
>> 我们不会关心所有的人，但是请注意，它开始变得有趣

152
00:09:24,480 --> 00:09:30,780
周围线或54字节，rgbtBlue，绿色和红色。

153
00:09:30,780 --> 00:09:35,280
如果你听说过的缩写，RGB，红，绿，蓝，这是一个参考。

154
00:09:35,280 --> 00:09:37,840
因为事实证明，你可以画的彩虹的所有颜色

155
00:09:37,840 --> 00:09:41,580
与红色，蓝色和绿色的某种组合。

156
00:09:41,580 --> 00:09:46,560
而且，事实上，在房间里的父母可能还记得最早的投影机。

157
00:09:46,560 --> 00:09:49,360
这些天，你只看到1个明亮的光出来的一个镜头。

158
00:09:49,360 --> 00:09:52,870
但是，早在一天，你有红色的镜片，蓝色镜片，绿色镜片

159
00:09:52,870 --> 00:09:56,620
和他们一起旨在在屏幕上，并形成了丰富多彩的画面。

160
00:09:56,620 --> 00:09:59,590
经常中学和高中有那些镜头

161
00:09:59,590 --> 00:10:02,680
不断稍微歪斜，所以你看到双重或三重影像，

162
00:10:02,680 --> 00:10:07,500
但他的想法。你有红色，绿色和蓝色光画一幅画。

163
00:10:07,500 --> 00:10:09,570
在电脑上使用相同的原则。

164
00:10:09,570 --> 00:10:12,000
>> 因此，当中的挑战，那么，你在问题设置4

165
00:10:12,000 --> 00:10:16,080
将要几件事情，一个是调整图像的大小。

166
00:10:16,080 --> 00:10:18,050
要采取的图案中的0和1，

167
00:10:18,050 --> 00:10:22,840
找出结构中的这样的块0和1的代表，

168
00:10:22,840 --> 00:10:26,800
然后找出如何复制像素的红色，蓝色，果岭

169
00:10:26,800 --> 00:10:32,460
内，这样当最初的图片看起来是这样的，可能是这样的，而不是之后。

170
00:10:32,460 --> 00:10:35,590
在其他的挑战，也将是你会交由

171
00:10:35,590 --> 00:10:38,900
法医的形象，一个实际的文件从数码相机

172
00:10:38,900 --> 00:10:42,410
，相机，曾几何时，一大堆的照片。

173
00:10:42,410 --> 00:10:47,030
问题是，我们不小心删除或有图像损坏，不知何故。

174
00:10:47,030 --> 00:10:51,040
数码相机，不好的事情发生，所以我们很快就复制了所有的0和1的

175
00:10:51,040 --> 00:10:55,410
关闭该卡给你，救了他们一大的文件，然后我们会交给你

176
00:10:55,410 --> 00:11:00,000
在问题设置，让您可以写一个程序在C恢复

177
00:11:00,000 --> 00:11:02,660
所有这些JPEG文件，最好。

178
00:11:02,660 --> 00:11:06,280
而事实证明，JPEG文件，即使它们是有点复杂的文件格式，

179
00:11:06,280 --> 00:11:09,580
他们要复杂得多，这笑脸。

180
00:11:09,580 --> 00:11:14,320
事实证明，每一个JPEG相同的模式0和1的开始。

181
00:11:14,320 --> 00:11:18,820
因此，使用一个while循环或循环或类似的，

182
00:11:18,820 --> 00:11:22,350
你可以遍历所有的0和1这法医图像

183
00:11:22,350 --> 00:11:26,670
每次你看到的问题集的规范中定义的特殊模式，

184
00:11:26,670 --> 00:11:29,770
你可以假设，“哦，这里是具有非常高的概率，

185
00:11:29,770 --> 00:11:33,520
开始的JPEG，只要你找到相同的模式，

186
00:11:33,520 --> 00:11:36,050
一定数目的字节或千字节或兆字节后，

187
00:11:36,050 --> 00:11:40,550
你可以假设，“哦！这是第二个JPEG的照片后，我把第一个。

188
00:11:40,550 --> 00:11:44,720
让我停止阅读，第一个文件，开始写这个新的。“

189
00:11:44,720 --> 00:11:49,980
你的程序的pset 4的输出将是多达50个JPEG文件。

190
00:11:49,980 --> 00:11:52,400
而且，如果它不是50 JPEG文件，你有一点的循环。

191
00:11:52,400 --> 00:11:55,580
如果你有无限多的JPEG文件，你有一个无限循环。

192
00:11:55,580 --> 00:11:58,280
这样一来，也将是一个相当普遍的情况。

193
00:11:58,280 --> 00:12:00,280
这是在地平线上。

194
00:12:00,280 --> 00:12:03,740
>> 测验0，在我们背后。实现的，按我的电子邮件，总是有乡亲

195
00:12:03,740 --> 00:12:06,820
谁是既高兴，排序中性，和伤心周围测验0时。

196
00:12:06,820 --> 00:12:10,160
请你拿出来给我，头转录因子，Zamyla，你自己的TF

197
00:12:10,160 --> 00:12:14,120
的CA，你知道，如果你想讨论如何去。

198
00:12:14,120 --> 00:12:16,460
>> 因此，要在这里留下深刻印象的父母在房间里，

199
00:12:16,460 --> 00:12:23,990
是CS50库？干得好。

200
00:12:23,990 --> 00:12:32,280
的CS50库？是吗？ [学生回答，不知所云]

201
00:12:32,280 --> 00:12:35,730
>>好，好。所以这是一个预先写好的代码集，我们的工作人员，写，

202
00:12:35,730 --> 00:12:38,460
我们提供给你，提供一些常用的功能。

203
00:12:38,460 --> 00:12:42,290
的东西，如给我一个字符串，让我一个int，此处列出的所有的功能。

204
00:12:42,290 --> 00:12:45,260
从现在起，我们开始真正把这些训练车轮。

205
00:12:45,260 --> 00:12:48,230
因此，我们要开始你带走一个“字符串”，

206
00:12:48,230 --> 00:12:52,790
其中，召回，只是一个代名词什么实际的数据类型吗？的char *。

207
00:12:52,790 --> 00:12:57,020
因此，对于家长，这很可能是 - 这是很好的，这样的char *，我们将开始看到

208
00:12:57,020 --> 00:13:00,810
在屏幕上，更因为我们从我们的词汇中删除“字符串”，

209
00:13:00,810 --> 00:13:02,760
至少当涉及到实际编写代码。

210
00:13:02,760 --> 00:13:06,240
同样，我们将停止使用其中的一些功能多，

211
00:13:06,240 --> 00:13:08,390
因为我们的计划是要变得更加复杂

212
00:13:08,390 --> 00:13:11,370
而不是仅仅写一个提示，闪烁坐在那里，

213
00:13:11,370 --> 00:13:13,580
等待用户输入一些东西英寸

214
00:13:13,580 --> 00:13:15,220
你会得到你的输入来自其他地方。

215
00:13:15,220 --> 00:13:18,720
例如，你会得到他们的本地硬盘驱动器上的一系列位。

216
00:13:18,720 --> 00:13:23,340
相反，你会得到他们在未来的网络连接，一些网站的某个地方。

217
00:13:23,340 --> 00:13:27,460
因此，让我们剥开这层第一次，并拉起CS50家电

218
00:13:27,460 --> 00:13:32,300
这称为CS50.h的文件，你已经尖锐包括好几个星期。

219
00:13:32,300 --> 00:13:34,380
>> 但是，让我们看到这里面有什么。

220
00:13:34,380 --> 00:13:38,250
因此，顶蓝色的文件仅仅是一大堆的意见，

221
00:13:38,250 --> 00:13:41,340
保修信息和许可。这是一个共同的范式

222
00:13:41,340 --> 00:13:44,600
软件，因为很多软件，这些天是所谓的“开放源码”

223
00:13:44,600 --> 00:13:46,940
这意味着有人已经写好的代码

224
00:13:46,940 --> 00:13:50,060
和自由，而不是仅仅运行和使用，

225
00:13:50,060 --> 00:13:53,660
但实际上读取和改变，并融入自己的工作。

226
00:13:53,660 --> 00:13:55,790
所以，这就是你一直在使用，开放源代码软件，

227
00:13:55,790 --> 00:13:58,030
尽管在一个非常小的形式。

228
00:13:58,030 --> 00:14:01,860
不过，如果我向下滚动过去的意见，我们将开始看到一些比较熟悉的东西。

229
00:14:01,860 --> 00:14:08,090
因此，注意到这里的顶部，CS50.h文件包括一大堆的头文件。

230
00:14:08,090 --> 00:14:11,160
现在，这些我们都没有见过，但一个是

231
00:14:11,160 --> 00:14:15,640
熟悉的，这些我们看到，尽管是短暂的，迄今？

232
00:14:15,640 --> 00:14:18,720
是的，标准库。 stdlib.h中的malloc，

233
00:14:18,720 --> 00:14:21,590
所以一旦我们开始谈论动态内存分配，

234
00:14:21,590 --> 00:14:24,960
我们会回来下周开始，包括该文件。

235
00:14:24,960 --> 00:14:29,660
事实证明，布尔和真假实际上并不存在，在C，本身，

236
00:14:29,660 --> 00:14:32,460
除非你有这个文件在这里。

237
00:14:32,460 --> 00:14:35,770
因此，我们有好几个星期，得到了包括标准bool.h

238
00:14:35,770 --> 00:14:39,020
这样，您可以使用这个概念的一个布尔值，true或false。

239
00:14:39,020 --> 00:14:41,830
没有这一点，你就必须假的排序，并使用int

240
00:14:41,830 --> 00:14:45,920
只是任意假设0是假的，1是真实的。

241
00:14:45,920 --> 00:14:49,980
>> 现在，如果我们继续向下滚动，在这里我们定义一个字符串。

242
00:14:49,980 --> 00:14:54,820
事实证明，正如我们之前所说的，，*其实并不重要。

243
00:14:54,820 --> 00:14:56,750
你甚至可以有空间的限制。

244
00:14:56,750 --> 00:15:01,550
这学期，我们一直在推动它，因为这明确指出，*与类型。

245
00:15:01,550 --> 00:15:05,370
但要意识到，就像常见的，如果没有一点更常见的，是把它放在那里

246
00:15:05,370 --> 00:15:07,480
但在功能上是一样的东西。

247
00:15:07,480 --> 00:15:11,070
但是现在，如果我们读到进一步下降，让我们来看看在说，调用getInt，

248
00:15:11,070 --> 00:15:15,350
因为我们使用的是，也许，先天下之忧这个学期。

249
00:15:15,350 --> 00:15:19,620
这里是调用getInt。这是什么？

250
00:15:19,620 --> 00:15:24,650
这是原型。所以很多时候，我们已经把原型在我们的顶部。c文件，

251
00:15:24,650 --> 00:15:28,190
但你也可以把原型的头文件，。h文件，

252
00:15:28,190 --> 00:15:32,110
像这样的在这里，所以，当你写的一些功能

253
00:15:32,110 --> 00:15:36,790
你希望其他人能够使用，这是完全相同的情况下，的CS50库，

254
00:15:36,790 --> 00:15:40,900
你不仅实现你的功能的东西像CS50.c，

255
00:15:40,900 --> 00:15:46,720
也把原型而不是在该文件的顶部，但在一个头文件的顶部，

256
00:15:46,720 --> 00:15:50,810
然后，头文件是什么样的朋友和同事，包括，

257
00:15:50,810 --> 00:15:52,800
用锋利的，包括在自己的代码。

258
00:15:52,800 --> 00:15:55,440
因此，所有这时候你已经包括所有这些原型

259
00:15:55,440 --> 00:15:59,870
有效地在文件的开头，但这种尖锐的方式，包括机制

260
00:15:59,870 --> 00:16:03,320
到，从本质上说，这个文件复制和粘贴到您自己的。

261
00:16:03,320 --> 00:16:06,400
现在，这里是一些比较详细的文档。

262
00:16:06,400 --> 00:16:08,880
>> 我们几乎是理所当然的调用getInt得到一个int，

263
00:16:08,880 --> 00:16:10,740
但事实证明，有一些角落的情况下，对不对？

264
00:16:10,740 --> 00:16:14,320
如果用户键入的数字太大了吗？

265
00:16:14,320 --> 00:16:17,350
一个三次方，就不能装进一个int？

266
00:16:17,350 --> 00:16:21,180
什么是预期的行为吗？那么，理想的情况下，这是可预见的。

267
00:16:21,180 --> 00:16:23,460
因此，在这种情况下，如果你真正阅读印刷精美，

268
00:16:23,460 --> 00:16:27,850
你会看到，如果该行不能被读取，则返回INT_MAX。

269
00:16:27,850 --> 00:16:30,800
我们从来没有提到这一点，但其资本额的基础上，

270
00:16:30,800 --> 00:16:33,030
它是什么，可能吗？

271
00:16:33,030 --> 00:16:36,610
这是一个常数，所以它的一些特殊常量，可能宣布

272
00:16:36,610 --> 00:16:39,460
了更高的文件中的这些头文件之一，

273
00:16:39,460 --> 00:16:43,400
INT_MAX可能是类似的东西，大约2亿美元。

274
00:16:43,400 --> 00:16:48,160
的想法是，因为我们需要以某种方式表明的东西出了问题，

275
00:16:48,160 --> 00:16:51,090
是的，我们有我们所掌握的4十亿的数字，

276
00:16:51,090 --> 00:16:53,980
负2亿美元至2亿美元，给予或采取。

277
00:16:53,980 --> 00:16:58,030
那么，什么是常见的编程是你偷这些数字。

278
00:16:58,030 --> 00:17:02,250
也许0，也许2十亿，也许负2亿美元。

279
00:17:02,250 --> 00:17:06,720
所以你用一个可能的值，这样就可以提交到世界

280
00:17:06,720 --> 00:17:10,089
，如果出现错误，我会回到这个超级大的价值。

281
00:17:10,089 --> 00:17:13,329
但你不希望用户输入诸如“2，3，4神秘的东西......”

282
00:17:13,329 --> 00:17:17,079
非常大的数字，在那里你概括，而不是为一个常数。

283
00:17:17,079 --> 00:17:19,380
所以，真的，如果你是肛门过去的几个星期中，

284
00:17:19,380 --> 00:17:23,800
任何时候，你调用调用getInt，你应该已经检查的，如果条件。

285
00:17:23,800 --> 00:17:27,109
做了用户在INT_MAX类型，或者更具体地说，

286
00:17:27,109 --> 00:17:29,900
调用getInt返回INT_MAX？因为如果它这样做，

287
00:17:29,900 --> 00:17:35,140
实际上意味着他们没有输入，在这种情况下，出现了错误。

288
00:17:35,140 --> 00:17:38,970
因此，这是通常被称为一个“哨兵”的价值，这只是意味着什么。

289
00:17:38,970 --> 00:17:41,020
>> 好了，现在让我们来打开的。c文件。

290
00:17:41,020 --> 00:17:44,500
C文件已经存在了一段时间的家电，

291
00:17:44,500 --> 00:17:47,540
，事实上，该设备具有预编译为你

292
00:17:47,540 --> 00:17:49,720
到那个东西我们称之为“目标代码”

293
00:17:49,720 --> 00:17:52,940
但它只是对你重要，那是因为系统知道，

294
00:17:52,940 --> 00:17:54,780
在这种情况下，它的位置，该设备。

295
00:17:54,780 --> 00:18:00,620
但是，让我们现在向下滚动到调用getInt，看看如何调用getInt一直在这么长的时间。

296
00:18:00,620 --> 00:18:02,380
所以，在这里，我们从之前也有类似的评论。

297
00:18:02,380 --> 00:18:04,930
让我放大的代码部分，

298
00:18:04,930 --> 00:18:07,410
我们调用getInt如下。

299
00:18:07,410 --> 00:18:12,770
它没有输入和返回一个int，而（真），所以我们有一个故意的无限循环

300
00:18:12,770 --> 00:18:16,560
但是，据推测，我们将打破这个不知何故，或返回在此。

301
00:18:16,560 --> 00:18:19,890
因此，让我们来看看它是如何工作的。那么，我们似乎可以使用GetString

302
00:18:19,890 --> 00:18:22,550
在这第一行内循环，166。

303
00:18:22,550 --> 00:18:25,320
现在，这是很好的做法，因为在什么样的情况下，

304
00:18:25,320 --> 00:18:30,820
可能的GetString返回这个特殊的关键字，NULL吗？

305
00:18:30,820 --> 00:18:38,460
如果出现错误。什么可能出问题，当你调用类似的GetString？

306
00:18:38,460 --> 00:18:42,550
是吗？ [学生回答，不知所云] >>呀。因此，也许malloc失败。

307
00:18:42,550 --> 00:18:45,310
引擎盖下方的GetString调用malloc，

308
00:18:45,310 --> 00:18:48,210
它分配内存，这使得计算机存储

309
00:18:48,210 --> 00:18:50,950
所有的字符，进入键盘的用户类型。

310
00:18:50,950 --> 00:18:53,270
假设用户有一大堆的空闲时间

311
00:18:53,270 --> 00:18:56,470
和类型化的，例如，超过2十亿字符。

312
00:18:56,470 --> 00:18:59,600
甚至有更多的字符比计算机RAM。

313
00:18:59,600 --> 00:19:02,350
是，GetString能够以表​​示对你，

314
00:19:02,350 --> 00:19:05,650
即使这是一个超级，超级罕见的角落的情况。

315
00:19:05,650 --> 00:19:08,490
它以某种方式来处理这个问题，所以GetString的，

316
00:19:08,490 --> 00:19:11,850
如果我们回过头来阅读其说明文件，不，其实，返回NULL。

317
00:19:11,850 --> 00:19:16,150
现在，如果GetString的失败，返回NULL，调用getInt是要失败的

318
00:19:16,150 --> 00:19:19,370
返回INT_MAX，就像一个哨兵。

319
00:19:19,370 --> 00:19:22,650
这些都只是人的约定。只有这样，你会知道这是

320
00:19:22,650 --> 00:19:24,840
是通过阅读文档。

321
00:19:24,840 --> 00:19:28,200
因此，让我们向下滚动到的诠释其实是GotInt的地方。

322
00:19:28,200 --> 00:19:34,220
>> 所以，如果我向下滚动位，在170行，我们有意见，以上这些线路。

323
00:19:34,220 --> 00:19:38,470
因此，我们宣布，在172，一个int n和一个字符c，那么这个新功能

324
00:19:38,470 --> 00:19:41,870
你们中的一些偶然发现之前，但sscanf的。

325
00:19:41,870 --> 00:19:44,190
这代表字符串扫描f。

326
00:19:44,190 --> 00:19:48,580
换句话说，给我一个字符串，我将扫描件信息感兴趣。

327
00:19:48,580 --> 00:19:53,820
那么，是什么意思呢？好吧，假设我在键盘上输入，从字面上看，1 2 3，

328
00:19:53,820 --> 00:19:59,730
并按下回车键。 1 2 3时，由GetString返回的数据类型是什么？

329
00:19:59,730 --> 00:20:05,010
这显然​​是一个字符串，对不对？我有一个字符串，所以1 2 3是真的“1 2 3”

330
00:20:05,010 --> 00:20:07,260
\ 0在它的结束。这不是一个整数。

331
00:20:07,260 --> 00:20:10,420
这不是一个数字。它看起来像一个数字，但它实际上不是。

332
00:20:10,420 --> 00:20:14,680
那么，是什么调用getInt有什么关系？它具有从左向右扫描该字符串，

333
00:20:14,680 --> 00:20:19,010
1 2 3 \ 0，并以某种方式将其转换为一个实际的整数。

334
00:20:19,010 --> 00:20:21,010
现在，你可以找出如何做到这一点。

335
00:20:21,010 --> 00:20:24,240
如果你觉得回到了pset中2，你大概有一点点舒适

336
00:20:24,240 --> 00:20:26,810
与凯撒的vigenere，这样你就可以遍历字符串，

337
00:20:26,810 --> 00:20:29,800
你可以将字符转换成整数与挑。这是一个大量的工作。

338
00:20:29,800 --> 00:20:32,800
sscanf的，做一个这样的函数，你为什么不叫？

339
00:20:32,800 --> 00:20:37,520
因此，sscanf的预计参数，在这种情况下，所谓的线，这是一个字符串。

340
00:20:37,520 --> 00:20:41,310
然后，您可以指定，在引号中，非常类似于printf，

341
00:20:41,310 --> 00:20:44,960
在此字符串你希望看到什么？

342
00:20:44,960 --> 00:20:52,980
我在这里说的是什么，我希望看到一个十进制数，也许一个字符。

343
00:20:52,980 --> 00:20:54,990
我们会看到为什么是这样的情况下，在短短的时刻。

344
00:20:54,990 --> 00:20:58,440
事实证明，这个符号是回忆的东西

345
00:20:58,440 --> 00:21:00,840
我们开始谈论了一个多星期前。

346
00:21:00,840 --> 00:21:05,430
>> 什么是＆N＆C为我们做吗？ [学生回答，不知所云]

347
00:21:05,430 --> 00:21:07,610
>>呀。它给我的地址n和c的地址。

348
00:21:07,610 --> 00:21:10,440
那么，为什么那么重要吗？嗯，你知道，在C函数

349
00:21:10,440 --> 00:21:13,440
你总是可以返回一个值或没有价值。

350
00:21:13,440 --> 00:21:16,630
您可以返回一个int，一个字符串，一个浮子，一个字符，不管。

351
00:21:16,630 --> 00:21:21,150
或者你也可以返回void，但你只能返回1最大限度。

352
00:21:21,150 --> 00:21:26,100
但在这里我们要sscanf的我，也许返回一个int，一个十进制数，

353
00:21:26,100 --> 00:21:29,240
和一个字符，在某一时刻，我会解释为什么字符。

354
00:21:29,240 --> 00:21:34,250
因此，您可以有效地希望F返回两件事情，这是不可能的C.

355
00:21:34,250 --> 00:21:38,460
所以，你可以解决的，通过在2个地址，

356
00:21:38,460 --> 00:21:43,710
因为只要你交给一个功能，2个地址，该功能可以与他们做吗？

357
00:21:43,710 --> 00:21:49,880
它可以写入到这些地址。您可以使用*操作和“走出去”，每个地址。

358
00:21:49,880 --> 00:21:54,320
这是这个后门的机制，但很常见的改变变量的值

359
00:21:54,320 --> 00:21:58,020
在超过仅有1的地方，在这种情况下，2。

360
00:21:58,020 --> 00:22:04,590
现在，请注意我检查==比1，然后返回n如果这样做，其实，计算结果为true。

361
00:22:04,590 --> 00:22:09,340
所以，这是怎么回事呢？那么，在技术上，我们真的要发生在调用getInt是这样的。

362
00:22:09,340 --> 00:22:12,340
我们要分析，可以这么说，我们要读取的字符串

363
00:22:12,340 --> 00:22:16,210
“1 2 3”，如果它看起来像有一些有，

364
00:22:16,210 --> 00:22:21,360
我们告诉sscanf的做的就是把这个数字，1 2 3，在我这个变量n。

365
00:22:21,360 --> 00:22:26,060
那么，为什么我有这样的好了吗？

366
00:22:26,060 --> 00:22:33,750
也说，sscanf的，你也可能会得到一个字符，在这里的作用是什么。

367
00:22:33,750 --> 00:22:36,890
学生来说，不知所云] >>  - 一个小数点工作。

368
00:22:36,890 --> 00:22:40,650
让我们认为，想了一会儿。还有什么呢？

369
00:22:40,650 --> 00:22:42,570
[学生，不知所云] >>因此，良好的思想，它可能是NULL字符。

370
00:22:42,570 --> 00:22:44,970
它实际上不是，在这种情况下。是吗？ [学生，不知所云]

371
00:22:44,970 --> 00:22:47,100
>> >> ASCII。或者，让我进一步概括。

372
00:22:47,100 --> 00:22:49,670
％c有错误检查。

373
00:22:49,670 --> 00:22:52,510
我们不希望有字符数后，

374
00:22:52,510 --> 00:22:54,980
但让我做的是以下几点：

375
00:22:54,980 --> 00:23:01,270
事实证明，sscanf的，除了存储在n和c的值，在这个例子中在这里，

376
00:23:01,270 --> 00:23:08,170
什么也没有返回的变量值英寸

377
00:23:08,170 --> 00:23:13,330
所以，如果你只输入1 2 3，％d是要匹配

378
00:23:13,330 --> 00:23:18,830
只有n被存储像1 2 3的值，都不会在c;

379
00:23:18,830 --> 00:23:20,870
C保持一个垃圾值，可以这么说。

380
00:23:20,870 --> 00:23:23,550
垃圾，因为它从来没有被初始化为一定的价值。

381
00:23:23,550 --> 00:23:29,390
因此，在这种情况下，sscanf的返回1，因为我填充这些指针之一，

382
00:23:29,390 --> 00:23:33,650
在这种情况下，太棒了。我有一个int，所以我释放线释放内存

383
00:23:33,650 --> 00:23:37,150
其实GetString的分配，然后我返回n。

384
00:23:37,150 --> 00:23:42,210
否则，如果你有没有想过，重试语句，就是这里。

385
00:23:42,210 --> 00:23:45,770
如果相反，I型1 2 3富，

386
00:23:45,770 --> 00:23:48,640
只是一些随机序列的文本，，sscanf的是要看到，

387
00:23:48,640 --> 00:23:51,500
哦，数量，哦，数量，哦，数量，噢 -  F。

388
00:23:51,500 --> 00:23:54,190
它打算把1 2 3在n。

389
00:23:54,190 --> 00:23:59,970
这将放置在f中的c，然后返回2。

390
00:23:59,970 --> 00:24:02,980
因此，我们有，只是用scanf函数的行为的基本定义，

391
00:24:02,980 --> 00:24:06,170
一个非常简单的方法 - 乍一看，复杂的，但在一天结束的时候，

392
00:24:06,170 --> 00:24:11,460
机制相当简单的说，是有一个int，如果有的话，那件事，我发现吗？

393
00:24:11,460 --> 00:24:14,950
这里的空白是故意的。如果你读的文档sscanf的，

394
00:24:14,950 --> 00:24:18,690
它会告诉你，如果你有一块空白的开始或结束，

395
00:24:18,690 --> 00:24:24,990
sscanf的也将允许用户，无论出于何种原因，打空格键1 2 3，，这将是合法的。

396
00:24:24,990 --> 00:24:28,310
只是因为他们打的开头或结尾的空格键，它不会在用户嚷嚷，

397
00:24:28,310 --> 00:24:32,160
这只是一个小更方便用户使用。

398
00:24:32,160 --> 00:24:34,160
>> 有任何疑问的话，就GetInts？是吗？

399
00:24:34,160 --> 00:24:36,820
[学生提问，不知所云]

400
00:24:36,820 --> 00:24:40,740
>>很好的问题。什么，如果你刚才输入的一个字符，如f和命中输入

401
00:24:40,740 --> 00:24:47,830
没有输入1 2 3，你怎么看这行代码的行为，然后呢？

402
00:24:47,830 --> 00:24:50,500
，所以sscanf的覆盖太多，因为在这种情况下，

403
00:24:50,500 --> 00:24:56,280
它不会以填补N或C，这是怎么回事，而不是返回0。

404
00:24:56,280 --> 00:25:01,540
在这种情况下，我也赶上那种情况下，我想是因为预期值1。

405
00:25:01,540 --> 00:25:07,310
我只希望，只有1个东西来填补。这个问题问得好。其他人吗？

406
00:25:07,310 --> 00:25:09,610
>> 好吧，让我们不要去所有的功能在这里，

407
00:25:09,610 --> 00:25:11,820
但，这似乎是，也许，余下权益

408
00:25:11,820 --> 00:25:14,530
GetString的，因为它把GetFloat，调用getInt

409
00:25:14,530 --> 00:25:19,490
GetDouble，GetLongLong所有平底船了很多的功能，GetString的，。

410
00:25:19,490 --> 00:25:22,860
因此，让我们来看看他是如何在这里实现。

411
00:25:22,860 --> 00:25:27,040
这一个看起来有点复杂，但它使用相同的基本原理

412
00:25:27,040 --> 00:25:29,680
我们开始谈论上周。因此，在GetString时，

413
00:25:29,680 --> 00:25:32,670
它没有参数，在这里，每虚空

414
00:25:32,670 --> 00:25:37,110
和它返回一个字符串，所以我声明了一个字符串缓冲。

415
00:25:37,110 --> 00:25:39,670
我真的不知道那是什么要用于还，但我们会看到。

416
00:25:39,670 --> 00:25:42,950
看起来像容量，默认情况下，0不太清楚这是怎么回事。

417
00:25:42,950 --> 00:25:44,920
不知道N的将要用于还。

418
00:25:44,920 --> 00:25:47,860
但现在变得更有趣一些，所以在243，

419
00:25:47,860 --> 00:25:51,760
我们声明了一个int C，这是一个愚蠢的细节。

420
00:25:51,760 --> 00:25:58,080
char是8位，8位可以存储多少不同的值吗？

421
00:25:58,080 --> 00:26:03,310
256。现在的问题是，如果你想有256个不同的ASCII字符，

422
00:26:03,310 --> 00:26:06,210
有，如果你想回来，这是不是记住。

423
00:26:06,210 --> 00:26:09,100
但是，如果你觉得回到了那个大的ASCII图表，我们有几个星期前，

424
00:26:09,100 --> 00:26:13,780
有，在这种情况下，128个或256个ASCII字符。

425
00:26:13,780 --> 00:26:16,220
我们使用的所有模式0和1的。

426
00:26:16,220 --> 00:26:19,410
这是一个问题，如果你想成为能够检测到一个错误。

427
00:26:19,410 --> 00:26:23,290
因为如果你已经使用了256个值，为你的角色，

428
00:26:23,290 --> 00:26:26,390
你真的不提前计划，因为现在你也没有办法说，

429
00:26:26,390 --> 00:26:29,750
“这是不是一个合法的字符，这是一些错误的信息。”

430
00:26:29,750 --> 00:26:32,430
因此，世界的是，他们使用的下一个最大的价值，

431
00:26:32,430 --> 00:26:35,790
像int的东西，让你有一个疯狂的数位，

432
00:26:35,790 --> 00:26:39,610
32 4亿可能的值，这样你可以简单地结束了，

433
00:26:39,610 --> 00:26:44,800
基本上，257，1其中有一些特殊的含义为错误。

434
00:26:44,800 --> 00:26:49,190
>> 因此，让我们来看看它是如何工作的。在246行，我有这样大的while循环

435
00:26:49,190 --> 00:26:54,530
正在调用fgetc函数F含义文件，GETC，然后标准输入。

436
00:26:54,530 --> 00:26:59,030
原来，这只是说：“从键盘读取输入更精确的方法。”

437
00:26:59,030 --> 00:27:02,730
标准输入方式键盘，标准输出屏幕，

438
00:27:02,730 --> 00:27:06,920
和标准错误，我们会看到在pset中，是指在屏幕上，

439
00:27:06,920 --> 00:27:09,670
而是一种特殊的屏幕部分，因此，它不是混为一谈

440
00:27:09,670 --> 00:27:13,760
与实际输出，你打算打印，但更多的是在未来。

441
00:27:13,760 --> 00:27:19,430
因此fgetc函数从键盘读取一个字符，并将其存储在那里？

442
00:27:19,430 --> 00:27:24,000
将它保存在c，然后检查，所以我只是在这里使用一些布尔连词，

443
00:27:24,000 --> 00:27:28,430
检查它不等于\ n，所以用户按下回车键。

444
00:27:28,430 --> 00:27:31,510
我们要停止在这一点上，在循环结束，我们还需要检查

445
00:27:31,510 --> 00:27:36,170
特殊常量，EOF，如果你知道或猜测 - 什么是代表？

446
00:27:36,170 --> 00:27:39,860
文件结尾。因此，这是一种荒谬的，因为如果我在键盘上打字，

447
00:27:39,860 --> 00:27:41,900
真的没有参与这一文件，

448
00:27:41,900 --> 00:27:44,330
但是，这仅仅是排序的通用术语，用来指

449
00:27:44,330 --> 00:27:50,320
，没有别的来自人类的手指。 EOF。文件结尾。

450
00:27:50,320 --> 00:27:52,600
顺便说一句，如果你曾经打你的键盘，控制D

451
00:27:52,600 --> 00:27:54,680
不是说你还没有，你已经打了控制C。

452
00:27:54,680 --> 00:27:57,920
但是，控制D发送这个特殊的常数，称为EOF。

453
00:27:57,920 --> 00:28:03,100
>> 所以，现在我们只是有一些动态内存分配。

454
00:28:03,100 --> 00:28:06,460
因此，如果n + 1>的能力，现在我将解释N。

455
00:28:06,460 --> 00:28:09,380
n是目前究竟有多少字节在缓冲区中，

456
00:28:09,380 --> 00:28:11,970
你目前正在建设的字符串从用户。

457
00:28:11,970 --> 00:28:16,240
如果你有比你有更多的字符在缓冲区中的缓冲能力，

458
00:28:16,240 --> 00:28:20,760
直观地，我们需要做的，然后被分配更多的容量。

459
00:28:20,760 --> 00:28:24,490
我要掠过的算术

460
00:28:24,490 --> 00:28:26,900
只注重这个功能。

461
00:28:26,900 --> 00:28:29,170
你知道的malloc的是，或者至少是一般熟悉。

462
00:28:29,170 --> 00:28:32,380
什么realloc的猜测。 [学生回答，不知所云]

463
00:28:32,380 --> 00:28:35,690
>>呀。 ，它不是很新增记忆体，它重新分配内存，例如：

464
00:28:35,690 --> 00:28:40,530
如果在字符串的结尾还是有空间，该内存以使您更

465
00:28:40,530 --> 00:28:43,370
比原来给你，然后你会得到额外的内存。

466
00:28:43,370 --> 00:28:46,640
所以，你可以把字符串的字符背靠背背靠背。

467
00:28:46,640 --> 00:28:49,290
但如果不是这样的话，因为你等太久

468
00:28:49,290 --> 00:28:51,700
和一些随机得到了一屁股到内存中，但有额外的

469
00:28:51,700 --> 00:28:56,480
记忆到这里，那也没关系。 realloc是要为你做所有的繁重，

470
00:28:56,480 --> 00:28:58,810
移动您已经阅读因而在离这里不远的字符串，

471
00:28:58,810 --> 00:29:02,550
爱不释手，然后给你一些更多的在这一点上跑道。

472
00:29:02,550 --> 00:29:05,610
因此，一挥手，让我说，是做什么的GetString

473
00:29:05,610 --> 00:29:09,540
是它的一个小缓冲区，也许单个字符开始，

474
00:29:09,540 --> 00:29:12,300
如果在2个字符的用户类型，GetString的结束

475
00:29:12,300 --> 00:29:15,210
调用realloc和说：“噢，1个字符是不够的。

476
00:29:15,210 --> 00:29:18,480
给我2个字符。然后，如果你读通过的逻辑循环，

477
00:29:18,480 --> 00:29:21,070
它会说，'噢，用户输入3个字符。

478
00:29:21,070 --> 00:29:25,690
现在给我，而不是2 4个字符，然后给我8，然后给我16位和32位。“

479
00:29:25,690 --> 00:29:28,180
事实上，我的能力增加一倍

480
00:29:28,180 --> 00:29:30,320
意味着，缓冲区不会生长缓慢。

481
00:29:30,320 --> 00:29:35,870
这是怎么回事增长超级快，那可能是什么优势？

482
00:29:35,870 --> 00:29:38,540
为什么我加倍的缓冲区的大小，即使该用户

483
00:29:38,540 --> 00:29:41,450
可能只需要1个额外的字符从键盘吗？

484
00:29:41,450 --> 00:29:44,830
[学生回答，不知所云]。 >>那是什么？

485
00:29:44,830 --> 00:29:46,750
没错。您不必经常增长。

486
00:29:46,750 --> 00:29:48,870
而这仅仅是一个怎样的 - 你们在这里对冲你的赌注。

487
00:29:48,870 --> 00:29:54,150
的想法是，你不希望调用realloc的有很多，因为它往往是缓慢的。

488
00:29:54,150 --> 00:29:56,840
任何时候，你问的操作系统的内存，你很快就会看到

489
00:29:56,840 --> 00:30:00,620
在未来的习题集，它往往需要一定的时间。

490
00:30:00,620 --> 00:30:04,980
因此，最大限度地减少，大量的时间，即使你浪费了一些空间，往往是一件好事。

491
00:30:04,980 --> 00:30:07,250
>> 但是，如果我们在这里读通过的最后部分，GetString的，

492
00:30:07,250 --> 00:30:10,880
再次，了解这里的每一行是不那么重要的今天。

493
00:30:10,880 --> 00:30:14,830
但是请注意，它最终会再次调用malloc，它分配

494
00:30:14,830 --> 00:30:16,980
一样多的字节，因为它需要的字符串

495
00:30:16,980 --> 00:30:21,620
然后扔掉，过大的缓冲区，通过调用free

496
00:30:21,620 --> 00:30:23,510
如果它确实得到了太多的时间翻了一倍。

497
00:30:23,510 --> 00:30:25,970
总之，这是多么的GetString已工作时间。

498
00:30:25,970 --> 00:30:30,100
它的作用是读取一个字符时，一而再，再而三

499
00:30:30,100 --> 00:30:37,930
而每次需要一些额外的内存，它要求它的操作系统通过调用realloc的。

500
00:30:37,930 --> 00:30:41,660
有什么问题吗？好的。

501
00:30:41,660 --> 00:30:45,220
>> 的攻击。现在，我们理解指针，或至少

502
00:30:45,220 --> 00:30:47,560
越来越熟悉的指针，

503
00:30:47,560 --> 00:30:50,020
让我们考虑如何在整个世界开始崩溃

504
00:30:50,020 --> 00:30:53,160
如果你不太捍卫对对抗性用户，

505
00:30:53,160 --> 00:30:55,180
人谁试图攻入你的系统。

506
00:30:55,180 --> 00:31:00,260
谁是试图窃取您的软件绕过一些注册码

507
00:31:00,260 --> 00:31:02,150
否则，他们可能有输入英寸

508
00:31:02,150 --> 00:31:04,860
看一看在这个例子中，这仅仅是C代码

509
00:31:04,860 --> 00:31:07,920
的底部，有一个main函数的调用函数foo，

510
00:31:07,920 --> 00:31:12,100
又是什么呢传递给foo？ [学生]：一个参数。

511
00:31:12,100 --> 00:31:15,660
>>单参数。所以的argv [1]，这意味着用户键入的第一个字

512
00:31:15,660 --> 00:31:19,150
在命令行后a.out或其他程序调用。

513
00:31:19,150 --> 00:31:24,920
所以foo的顶部，需要一个char *，但char *是什么？

514
00:31:24,920 --> 00:31:28,860
字符串。这里没有什么新的，而该字符串是任意被称为酒吧。

515
00:31:28,860 --> 00:31:36,090
在这里，字符c [12]，半技术英语的排序，这条线是在做什么？

516
00:31:36,090 --> 00:31:40,640
阵列 - ？字符。给我一个阵列为12个字符。

517
00:31:40,640 --> 00:31:44,970
因此，我们可以称之为一个缓冲。它在技术上被称为C，但程序中的缓冲区

518
00:31:44,970 --> 00:31:47,890
只是指一些空间，你可以把一些东西英寸

519
00:31:47,890 --> 00:31:49,940
>> 然后最后，memcpy的，我们还没有使用过的。

520
00:31:49,940 --> 00:31:52,380
但是，你可能已经猜到它做什么。它的内存复制。

521
00:31:52,380 --> 00:31:58,790
它有什么作用呢？那么，它显然复制酒吧，它的输入，转换成C，

522
00:31:58,790 --> 00:32:03,420
但只有到酒吧的长度。

523
00:32:03,420 --> 00:32:07,440
但有一个错误在这里。

524
00:32:07,440 --> 00:32:14,500
好了，所以在技术上我们确实应该做的strlen（酒吧）x sizeof（char）的的，这是正确的。

525
00:32:14,500 --> 00:32:17,920
但是，在最坏的情况下，在这里，让我们假设that's  - 所以，没关系。

526
00:32:17,920 --> 00:32:23,760
然后有2个错误。所以sizeof（char）的的，所有的权利，让我们使这一点更广泛。

527
00:32:23,760 --> 00:32:28,860
所以现在仍然是一个错误，这是什么？

528
00:32:28,860 --> 00:32:31,630
[学生回答，不知所云] >>检查是为了什么？好了，我们应该检查

529
00:32:31,630 --> 00:32:35,010
为NULL，因为不好的事情发生时，你的指针为NULL，

530
00:32:35,010 --> 00:32:38,490
因为你可能去那里，你永远不应该为NULL

531
00:32:38,490 --> 00:32:40,890
提领*操作符。

532
00:32:40,890 --> 00:32:45,250
所以这是很好的，我们在做什么？在逻辑上有一个缺陷。

533
00:32:45,250 --> 00:32:47,650
[学生回答，不知所云]

534
00:32:47,650 --> 00:32:51,340
>>因此，检查如果ARGC≥2，？

535
00:32:51,340 --> 00:32:54,130
好了，所以有3这个程序中的错误。

536
00:32:54,130 --> 00:33:00,080
我们不检查，如果用户实际上在什么到argv [1]，良好的输入。

537
00:33:00,080 --> 00:33:02,240
那么什么是第三个错误吗？是吗？

538
00:33:02,240 --> 00:33:04,420
[学生回答，不知所云] >>好。

539
00:33:04,420 --> 00:33:09,590
所以，我们检查了一个情景。隐式检查，请不要复制更多的内存

540
00:33:09,590 --> 00:33:12,800
比超过该长度的酒吧。

541
00:33:12,800 --> 00:33:15,720
因此，如果字符串用户输入的长度为10个字符，

542
00:33:15,720 --> 00:33:18,260
这是说，“仅复制10个字符。

543
00:33:18,260 --> 00:33:21,140
这没关系，但如果用户在提示符下键入一个字

544
00:33:21,140 --> 00:33:29,360
像一个20个字符的字，这是，，说复制20个字符，从酒吧到什么？

545
00:33:29,360 --> 00:33:32,840
C，否则被称为我们的缓冲区，这意味着你只是写数据

546
00:33:32,840 --> 00:33:35,950
8个字节，你没有自己的位置，

547
00:33:35,950 --> 00:33:38,320
你并不拥有它们在这个意义上，你永远不分配。

548
00:33:38,320 --> 00:33:41,190
因此，这是一般被称为缓冲区溢出攻击，

549
00:33:41,190 --> 00:33:46,650
或缓冲区溢出攻击，和它的攻击在这个意义上，如果用户

550
00:33:46,650 --> 00:33:50,650
或调用你的函数的程序是这样做的恶意，

551
00:33:50,650 --> 00:33:53,780
到底发生了什么，未来可能会相当糟糕。

552
00:33:53,780 --> 00:33:55,690
>> 让我们来看看这张图片在这里。

553
00:33:55,690 --> 00:33:59,070
此图片代表你的内存堆栈。

554
00:33:59,070 --> 00:34:01,050
回想一下，每次你调用一个函数，

555
00:34:01,050 --> 00:34:04,520
你这个小帧在堆栈上，然后再然后另一个。

556
00:34:04,520 --> 00:34:07,250
到目前为止，我们已经只是一种抽象为矩形

557
00:34:07,250 --> 00:34:09,380
要么有在黑板上，或在屏幕上这里。

558
00:34:09,380 --> 00:34:12,219
但是，如果我们这些矩形中的一个放大，

559
00:34:12,219 --> 00:34:16,460
当你调用一个函数foo，它的出现，更重要的是在栈上

560
00:34:16,460 --> 00:34:18,739
该框架和该矩形内

561
00:34:18,739 --> 00:34:23,370
比是x和y，a和b，就像我们谈论交换。

562
00:34:23,370 --> 00:34:25,949
事实证明，有一些较低层次的细节，

563
00:34:25,949 --> 00:34:27,780
在他们返回地址。

564
00:34:27,780 --> 00:34:33,020
因此，原来当主调用foo，主要有告知富

565
00:34:33,020 --> 00:34:36,760
主要是在计算机的内存中的地址。

566
00:34:36,760 --> 00:34:40,659
因为如果不这样，尽快为foo执行，在这种情况下，这里，

567
00:34:40,659 --> 00:34:43,790
一旦你达到这种紧密的大括号结束时的foo，

568
00:34:43,790 --> 00:34:48,860
如何赫克富不知道程序的控制，应该去吗？

569
00:34:48,860 --> 00:34:52,460
事实证明，这个问题的答案是在这里，红色的矩形。

570
00:34:52,460 --> 00:34:56,130
这是一个指针，它是电脑存储，暂时的，

571
00:34:56,130 --> 00:35:00,250
所谓的堆叠上的主地址，以便尽快为foo执行完成，

572
00:35:00,250 --> 00:35:04,110
电脑知道在哪里和什么线主要回去。

573
00:35:04,110 --> 00:35:06,900
保存的帧指针与此类似。

574
00:35:06,900 --> 00:35:09,620
CHAR *酒吧代表着什么？

575
00:35:09,620 --> 00:35:14,740
好了，现在这个蓝色的部分是foo的框架，是吧？

576
00:35:14,740 --> 00:35:18,300
好了，所以酒吧是参数的函数foo。

577
00:35:18,300 --> 00:35:20,720
>> 所以现在我们又回到了熟悉的画面。

578
00:35:20,720 --> 00:35:22,960
还有更多的东西，并在屏幕上的干扰

579
00:35:22,960 --> 00:35:27,490
但这种淡蓝色的部分是什么，我们已经画在黑板上的东西一样交换。

580
00:35:27,490 --> 00:35:31,890
这是框架为foo和唯一的，现在是酒吧，

581
00:35:31,890 --> 00:35:34,630
这是此参数。

582
00:35:34,630 --> 00:35:39,840
还有什么应该是在堆栈中，根据此代码在这里？

583
00:35:39,840 --> 00:35:44,280
字符c [12]。因此，我们也应该看到12广场的内存，

584
00:35:44,280 --> 00:35:46,260
分配给一个变​​量名为c。

585
00:35:46,260 --> 00:35:48,340
而事实上，我们也有在屏幕上。

586
00:35:48,340 --> 00:35:51,650
最顶端的是c [0]，然后这张图的作者

587
00:35:51,650 --> 00:35:55,130
没有理会绘制所有的平方，但确实有12有

588
00:35:55,130 --> 00:36:00,120
因为，如果你看一下在右下角，C [11]，如果算上从0开始，是12个这样的字节。

589
00:36:00,120 --> 00:36:06,190
但这里有一个问题：在哪个方向是C成长？

590
00:36:06,190 --> 00:36:10,390
排序的自上而下的，对不对？如果它的顶部开始，并生长至底部，

591
00:36:10,390 --> 00:36:13,480
并不像我们给自己多跑道在这里。

592
00:36:13,480 --> 00:36:15,320
我们画种自己陷入了困境，

593
00:36:15,320 --> 00:36:20,210
C [11]是正确的，对吧，这是对堆栈帧指针，

594
00:36:20,210 --> 00:36:23,800
这是对返回地址，有没有更多的空间。

595
00:36:23,800 --> 00:36:26,100
那么，有什么含义，那么，如果你搞砸了，

596
00:36:26,100 --> 00:36:30,460
您尝试读取20字节到12个字节的缓冲区？

597
00:36:30,460 --> 00:36:33,460
这8个额外的字节哪里去了？

598
00:36:33,460 --> 00:36:36,370
一切里面，其中有一些是超级重要的。

599
00:36:36,370 --> 00:36:40,480
和最重要的事情，可能是那里的红色方块，将返回地址。

600
00:36:40,480 --> 00:36:44,720
因为假设你是个意外或adversarially

601
00:36:44,720 --> 00:36:48,040
覆盖这4个字节，该指针的地址，

602
00:36:48,040 --> 00:36:53,190
不只是用垃圾，但有一些发生在内存中代表一个实际地址？

603
00:36:53,190 --> 00:36:55,930
什么是implicaiton，逻辑吗？

604
00:36:55,930 --> 00:36:59,080
[学生回答，不知所云] >>没错。当foo返回

605
00:36:59,080 --> 00:37:03,560
命中，大括号，程序将继续返回到主，

606
00:37:03,560 --> 00:37:08,320
它会返回的地址是在这红色框。

607
00:37:08,320 --> 00:37:11,560
>> ，规避软件登记的情况下，

608
00:37:11,560 --> 00:37:14,400
返回到的地址是什么是功能

609
00:37:14,400 --> 00:37:18,820
通常被称为后，你支付的软件，输入你的注册码？

610
00:37:18,820 --> 00:37:23,160
你可以到这里不打算的绝招计算机排序，而是，在这里。

611
00:37:23,160 --> 00:37:27,950
或者，如果你真的很聪明，对手实际上可以输入在键盘上，

612
00:37:27,950 --> 00:37:32,500
例如，而不是实际的单词，而不是20个字符，但假设他或她

613
00:37:32,500 --> 00:37:36,200
某些字符表示代码的类型吗？

614
00:37:36,200 --> 00:37:38,860
它不会是C代码，这将是字符

615
00:37:38,860 --> 00:37:42,920
的表示二进制机器代码，0和1的。

616
00:37:42,920 --> 00:37:46,740
但是，假如他们很聪明足以做到这一点，以某种方式粘贴到的GetString提示

617
00:37:46,740 --> 00:37:49,460
的东西，本质上是编译后的代码，

618
00:37:49,460 --> 00:37:56,900
最后4个字节覆盖了返回地址，地址的输​​入做呢？

619
00:37:56,900 --> 00:38:01,860
它存储在这个红色矩形的缓冲区的第一个字节的地址。

620
00:38:01,860 --> 00:38:04,270
所以，你必须是真聪明，这是一个很大的试验和错误

621
00:38:04,270 --> 00:38:08,500
不好的人，但如果你能弄清楚这个缓冲区有多大，

622
00:38:08,500 --> 00:38:12,170
例如，在输入最后几个字节您提供的程序

623
00:38:12,170 --> 00:38:15,970
发生相当于您的缓冲器的起始地址的，

624
00:38:15,970 --> 00:38:22,270
你可以做到这一点。通常情况下，如果我们说，你好，\ 0，也就是在缓冲区。

625
00:38:22,270 --> 00:38:27,860
但是，如果我们更聪明，我们填补了这一缓冲，我们将统称叫什么攻击代码，

626
00:38:27,860 --> 00:38:31,920
A，A，A，A：攻击，攻击，攻击，攻击，这是只是做了一件坏事。

627
00:38:31,920 --> 00:38:35,190
好了，会发生什么，如果你真聪明，你可以这样做：

628
00:38:35,190 --> 00:38:41,740
在这里的红色框是一个数字序列：80，CO，35，08。

629
00:38:41,740 --> 00:38:44,890
请注意，相匹配的数字在这里。

630
00:38:44,890 --> 00:38:47,280
它以相反的顺序，但其他一些时间。

631
00:38:47,280 --> 00:38:51,430
请注意，这个返回地址被故意改变

632
00:38:51,430 --> 00:38:54,970
相同的地址，而不是主要的地址。

633
00:38:54,970 --> 00:39:00,170
因此，如果坏家伙是超级聪明，他或她将要包括在该攻击代码

634
00:39:00,170 --> 00:39:02,890
类似的东西，“删除所有用户的文件”。

635
00:39:02,890 --> 00:39:06,320
或“复制密码”或“创建一个用户帐户，我可以登录到”。

636
00:39:06,320 --> 00:39:10,130
任何东西;这是危险的力量C.

637
00:39:10,130 --> 00:39:12,900
因为你必须通过指针存取记忆体

638
00:39:12,900 --> 00:39:15,950
因此，你可以写任何你想要到一台计算机的内存中。

639
00:39:15,950 --> 00:39:19,290
你可以让一台计算机做任何你想要的简单的

640
00:39:19,290 --> 00:39:22,780
跳在其自己的内存空间。

641
00:39:22,780 --> 00:39:27,230
这样，为了这一天，让许多计划和这么多的网站被攻破

642
00:39:27,230 --> 00:39:29,730
归结到人趁着这个。

643
00:39:29,730 --> 00:39:32,510
这似乎是一个超级复杂的攻击，

644
00:39:32,510 --> 00:39:34,220
但它并不总是这种方式开始。

645
00:39:34,220 --> 00:39:36,770
>> 现实情况是，什么不好的人通常会做的是，

646
00:39:36,770 --> 00:39:41,470
无论它是一个程序，在命令行或GUI程序或网站，

647
00:39:41,470 --> 00:39:43,290
你刚开始提供废话。

648
00:39:43,290 --> 00:39:46,940
您键入一个真正的大词在搜索字段并按下回车键，

649
00:39:46,940 --> 00:39:49,030
你就等着看，如果网站崩溃。

650
00:39:49,030 --> 00:39:53,270
或者，你等着看，如果程序体现了一些错误信息。

651
00:39:53,270 --> 00:39:55,480
因为如果你得到幸运的，因为坏人，

652
00:39:55,480 --> 00:39:59,610
您提供一些疯狂的投入，导致程序崩溃，

653
00:39:59,610 --> 00:40:02,280
这意味着程序员没有预料到你的错误行为

654
00:40:02,280 --> 00:40:05,420
这意味着，有足够的精力，你或许可以

655
00:40:05,420 --> 00:40:09,870
足够的试验和错误，找出如何发动更精确的攻击。

656
00:40:09,870 --> 00:40:15,900
因此，安全的一部分，不只是避免这些攻击完全，但检测

657
00:40:15,900 --> 00:40:20,250
实际上是在寻找日志，看到什么疯狂的输入输入到你的网站的人。

658
00:40:20,250 --> 00:40:26,040
什么样的搜索字词输入到您的网站的人一定的缓冲溢出，希望吗？

659
00:40:26,040 --> 00:40:28,900
而这一切都可以归结为简单的基础知识，什么是一个数组，

660
00:40:28,900 --> 00:40:32,510
和是什么意思分配和使用内存？

661
00:40:32,510 --> 00:40:34,920
相关的，也是这样的。

662
00:40:34,920 --> 00:40:37,520
>> 因此，让我们只是看了一眼里面的硬盘驱动器。

663
00:40:37,520 --> 00:40:40,190
所以，你还记得一两个星期前，当你拖动文件

664
00:40:40,190 --> 00:40:45,470
回收站或垃圾桶，会发生什么呢？

665
00:40:45,470 --> 00:40:47,850
[学生]：没有。 >>是的，绝对没有。最后，如​​果你运行低

666
00:40:47,850 --> 00:40:51,370
Windows或Mac OS的磁盘空间，将开始为您删除的文件。

667
00:40:51,370 --> 00:40:53,670
但是，如果你拖动的东西在那里，然后它不是在所有的安全。

668
00:40:53,670 --> 00:40:56,550
你的室友，朋友或家庭成员的所有需要​​做的是双击，瞧。

669
00:40:56,550 --> 00:40:59,720
所有的粗略的，您尝试删除的文件。

670
00:40:59,720 --> 00:41:02,840
所以我们大多数人至少知道，你必须右击或控制点击

671
00:41:02,840 --> 00:41:05,320
清空垃圾桶，或类似的东西。

672
00:41:05,320 --> 00:41:07,900
但即便如此，这并不完全做到的伎俩。

673
00:41:07,900 --> 00:41:11,340
由于发生了什么，当你有你的硬盘驱动器上的文件

674
00:41:11,340 --> 00:41:14,590
一些word文档或者一些JPEG？

675
00:41:14,590 --> 00:41:18,820
这代表您的硬盘驱动器，让我们说这个条子在这里表示该文件，

676
00:41:18,820 --> 00:41:21,640
它是由0和1的一大堆。

677
00:41:21,640 --> 00:41:25,470
会发生什么事时，你不仅该文件拖动到垃圾桶或回收站，

678
00:41:25,470 --> 00:41:30,390
但也空吗？

679
00:41:30,390 --> 00:41:32,820
排序无关。这不是绝对没有。

680
00:41:32,820 --> 00:41:37,630
现在是什么都没有，因为少了一些发生在此表的形式。

681
00:41:37,630 --> 00:41:41,170
因此，有一些种类的数据库或表内的一台计算机的内存

682
00:41:41,170 --> 00:41:44,470
基本上有1列文件名，

683
00:41:44,470 --> 00:41:50,550
1列文件的位置，这可能是位置123，只是一个随机数。

684
00:41:50,550 --> 00:41:58,270
因此，我们可能有一些像x.jpg和位置123。

685
00:41:58,270 --> 00:42:02,870
然后会发生什么，当你清空你的垃圾箱吗？

686
00:42:02,870 --> 00:42:06,720
这消失。但不会消失的“0”和“1”。

687
00:42:06,720 --> 00:42:09,690
>> 那么是什么，然后，连接到PSET 4？

688
00:42:09,690 --> 00:42:13,460
好了，pset的4，只是因为我们不小心删除

689
00:42:13,460 --> 00:42:15,890
紧凑的闪存卡，所有的这些照片，

690
00:42:15,890 --> 00:42:18,710
或者仅仅因为运气不好它成为损坏，

691
00:42:18,710 --> 00:42:21,170
并不意味着，在0和1的是不是仍然存在。

692
00:42:21,170 --> 00:42:23,920
也许他们几个人都失去了，因为有东西损坏

693
00:42:23,920 --> 00:42:26,530
在这个意义上，一些0成为1和1的成为“0”。

694
00:42:26,530 --> 00:42:30,460
不好的事情都可能发生，因为软件bug或有缺陷的硬件。

695
00:42:30,460 --> 00:42:33,510
但许多这些位，也许甚至达到100％，其中仍然存在，

696
00:42:33,510 --> 00:42:38,330
它只是电脑或相机，不知道去哪里JPEG 1日开始

697
00:42:38,330 --> 00:42:41,660
和JPEG 2开始，但如果你作为程序员，

698
00:42:41,660 --> 00:42:45,800
知道，有点悟性，这些JPEG文件或它们看起来像什么，

699
00:42:45,800 --> 00:42:49,570
你可以分析出0和1的，并说，'哦。 JPEG。哦，JPEG。

700
00:42:49,570 --> 00:42:52,830
您可以编写一个程序基本上只是一个while循环

701
00:42:52,830 --> 00:42:56,100
，恢复这些文件中的每一个。

702
00:42:56,100 --> 00:42:59,360
因此，教训的话，是启动“安全地”删除文件

703
00:42:59,360 --> 00:43:01,720
如果你想完全避免这种情况。是吗？

704
00:43:01,720 --> 00:43:06,940
[学生提问，不知所云]

705
00:43:06,940 --> 00:43:11,150
>>有更多的内存比你以前 - 

706
00:43:11,150 --> 00:43:14,790
哦！这个问题问得好。那么，为什么，然后，清空垃圾桶后，

707
00:43:14,790 --> 00:43:18,300
你的计算机告诉你，你有更多的自由空间比您以前吗？

708
00:43:18,300 --> 00:43:22,450
简单地说，因为它是在撒谎。技术上，你有更多的空间。

709
00:43:22,450 --> 00:43:26,720
因为现在你所说的，你可以把其他的东西，曾经是该文件，

710
00:43:26,720 --> 00:43:28,930
但是，这并不意味着这些位去，

711
00:43:28,930 --> 00:43:33,070
和，这并不意味着位被改变了这一切“0”，例如，为保护您的利益。

712
00:43:33,070 --> 00:43:37,520
与此相反，如果“安全地”擦除文件，或物理破坏的移动设备，

713
00:43:37,520 --> 00:43:40,810
这确实是唯一的办法，有时，解决这一问题。

714
00:43:40,810 --> 00:43:45,300
那么，为什么我们不离开上，半吓人的，我们将看到你在周一。

715
00:43:45,300 --> 00:43:52,810
CS50.TV