1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:11,261
[音乐播放]

3
00:00:11,261 --> 00:00:12,640
>> 戴维·J·马兰：好吧。

4
00:00:12,640 --> 00:00:14,525
这是CS50。

5
00:00:14,525 --> 00:00:16,009
这是5周的开始。

6
00:00:16,009 --> 00:00:18,050
正如你可能已经注意到，
一些材料

7
00:00:18,050 --> 00:00:21,050
越来越多一点
复杂，小更密。

8
00:00:21,050 --> 00:00:24,560
>> 而且它是很容易的，尤其是当
你已经在习惯了一段时间，

9
00:00:24,560 --> 00:00:28,600
是为了要涂下最
什么我们做什么，我们说在课堂上。

10
00:00:28,600 --> 00:00:31,626
但要意识到，这也许不是
理想的教学方法

11
00:00:31,626 --> 00:00:34,250
学习这种物质，
而材料更普遍。

12
00:00:34,250 --> 00:00:37,250
因此，我们很高兴
宣布，CS50自己Gheng

13
00:00:37,250 --> 00:00:39,780
龚已开始准备
一个规范的集合票据

14
00:00:39,780 --> 00:00:42,100
用于操作过程中，希望
其是，一个，这些

15
00:00:42,100 --> 00:00:44,030
不仅作为
参考和资源

16
00:00:44,030 --> 00:00:47,410
审查材料中去
回通过材料可能具有的

17
00:00:47,410 --> 00:00:51,230
逃脱你在第一时间左右，但
也让你的头可以更

18
00:00:51,230 --> 00:00:53,740
向上比下降，当它
谈到时间来讲课，

19
00:00:53,740 --> 00:00:56,960
所以，你可能搞
更周到，为

20
00:00:56,960 --> 00:00:59,170
相对于更杂乱。

21
00:00:59,170 --> 00:01:02,510
>> 虽这么说，你会发现
该网站是这样的文件，因为这。

22
00:01:02,510 --> 00:01:04,660
并请注意，在左上角，有
不仅表的内容，

23
00:01:04,660 --> 00:01:06,920
而且时间码的
会立即跳到你

24
00:01:06,920 --> 00:01:09,077
到相应的部分
在视频网上。

25
00:01:09,077 --> 00:01:11,410
什么常在这里做了
在本质上，记载

26
00:01:11,410 --> 00:01:13,340
发生了什么事在这
特别讲座。

27
00:01:13,340 --> 00:01:16,370
和许多的讲座是
已经在线使用这个网址。

28
00:01:16,370 --> 00:01:20,110
我们将继续张贴其余
那些在本周末结束，

29
00:01:20,110 --> 00:01:22,380
所以不要采取资源优势。

30
00:01:22,380 --> 00:01:25,740
>> 因此，事不宜迟，
我们开始剥离回

31
00:01:25,740 --> 00:01:28,180
已经作为层
串持续一段时间。

32
00:01:28,180 --> 00:01:30,670
并没有说什么一个字符串
上周居然是？

33
00:01:30,670 --> 00:01:31,720

34
00:01:31,720 --> 00:01:32,900
因此，焦炭的明星。

35
00:01:32,900 --> 00:01:34,900
和CHAR星，那么，
这样做究竟意味着什么？

36
00:01:34,900 --> 00:01:37,150
那么，这一切的时候，如果我们已经
被调用的函数，

37
00:01:37,150 --> 00:01:40,450
喜欢的getString和存储
所谓返回

38
00:01:40,450 --> 00:01:42,910
的getString的价值
变量 - 这就是所谓的

39
00:01:42,910 --> 00:01:47,721
S型string--我们已经写
这行代码在那里上面。

40
00:01:47,721 --> 00:01:49,970
而且它是只有当我看到我的
在这里手写放大

41
00:01:49,970 --> 00:01:51,930
我意识到多么恶劣，这是。

42
00:01:51,930 --> 00:01:54,180
>> 但是，让我们假设，
在右手侧

43
00:01:54,180 --> 00:01:57,070
是，但是，合理的
一个什么样的描述

44
00:01:57,070 --> 00:01:58,880
一直在进行这一切
时间的getString。

45
00:01:58,880 --> 00:02:00,380
的getString，当然，得到的字符串。

46
00:02:00,380 --> 00:02:01,691
但是，这究竟意味着什么？

47
00:02:01,691 --> 00:02:04,190
这意味着它得到了一大块
来自操作系统的内存

48
00:02:04,190 --> 00:02:06,040
通过调用一个函数，称为malloc的。

49
00:02:06,040 --> 00:02:07,390
但后来更多。

50
00:02:07,390 --> 00:02:09,139
然后填充
该内存块

51
00:02:09,139 --> 00:02:11,764
以字母的用户具有
当然键入，紧接着，，

52
00:02:11,764 --> 00:02:14,800
一个空字符或反斜杠
零在最后。

53
00:02:14,800 --> 00:02:18,280
>> 同时，在左手侧
这个故事，这一切的时候，

54
00:02:18,280 --> 00:02:20,850
我们已经声明了一个变量，如第

55
00:02:20,850 --> 00:02:24,770
而这个变量就是现在
将开始调用的指针。

56
00:02:24,770 --> 00:02:29,190
这不是这里面一箱
我们把串，Daven，本身

57
00:02:29,190 --> 00:02:32,550
而是我们把在这方
箱体左侧究竟是什么？

58
00:02:32,550 --> 00:02:34,890

59
00:02:34,890 --> 00:02:35,390
是吗？

60
00:02:35,390 --> 00:02:37,118
>> 听众：的地址
它位于内存中。

61
00:02:37,118 --> 00:02:38,118
>> 戴维·J·马兰：没错。

62
00:02:38,118 --> 00:02:40,690
Daven的所在地址
位于存储器。

63
00:02:40,690 --> 00:02:44,650
不，所有Daven的所在，
本身，而是专门的地址

64
00:02:44,650 --> 00:02:45,150
什么？

65
00:02:45,150 --> 00:02:46,311

66
00:02:46,311 --> 00:02:46,810
是吗？

67
00:02:46,810 --> 00:02:47,460
>> 听众：第一个字符。

68
00:02:47,460 --> 00:02:50,209
>> 戴维·J·马兰：第一个字符
在Daven，其中，在这种情况下，

69
00:02:50,209 --> 00:02:53,820
我提出了任意
和不切实际1，OX1，

70
00:02:53,820 --> 00:02:55,910
它的意思是，
1的十六进制数。

71
00:02:55,910 --> 00:02:57,993
但是，它可能会
是一个更大的数字

72
00:02:57,993 --> 00:03:01,260
我们可能会得出
以0X作为前缀，

73
00:03:01,260 --> 00:03:02,806
代表一个十六进制字符。

74
00:03:02,806 --> 00:03:05,930
而且，由于我们并不需要知道在哪里
Daven的字符的其余部分

75
00:03:05,930 --> 00:03:09,860
是因为，有什么简单的设计
决定这是多年前？

76
00:03:09,860 --> 00:03:10,548
是吗？

77
00:03:10,548 --> 00:03:11,651
>> 听众：反斜杠0。

78
00:03:11,651 --> 00:03:12,900
戴维·J·马兰：是的，没错。

79
00:03:12,900 --> 00:03:18,100
反斜线0可以让你，尽管在
线性时间，来遍历字符串

80
00:03:18,100 --> 00:03:20,400
由左到右行走，
用for循环，或同时

81
00:03:20,400 --> 00:03:22,608
环或类似的东西
这一点，决定了哦，这里

82
00:03:22,608 --> 00:03:24,751
是这个特定字符串的结尾。

83
00:03:24,751 --> 00:03:27,000
所以只用在地址
字符串的开始，

84
00:03:27,000 --> 00:03:30,290
我们可以访问的全部
它，因为这一切的同时，

85
00:03:30,290 --> 00:03:32,030
一个字符串，刚刚一个char明星。

86
00:03:32,030 --> 00:03:36,370
>> 因此，这的确精致继续使用
在CS50库，而且这样的抽象，

87
00:03:36,370 --> 00:03:38,440
可以这么说，但我们会
首先，看看到底

88
00:03:38,440 --> 00:03:41,230
什么是怎么回事
下面这整个时间。

89
00:03:41,230 --> 00:03:45,260
所以，你可能还记得这个例子中，
同样，从去年的时候，比较0，

90
00:03:45,260 --> 00:03:47,300
这实际上并没有进行比较。

91
00:03:47,300 --> 00:03:49,070
但是，我们开始解决这个问题。

92
00:03:49,070 --> 00:03:52,020
>> 但是作为也许是复习，
我可能感兴趣的人

93
00:03:52,020 --> 00:03:54,261
粉红色的大象的今天，
还长呢？

94
00:03:54,261 --> 00:03:55,760
怎么样，你在前面？ [听不清]。

95
00:03:55,760 --> 00:03:56,660
上来吧。

96
00:03:56,660 --> 00:03:58,740
>> 并且在此期间，
你上来，让我们

97
00:03:58,740 --> 00:04:01,670
考虑了一会儿就好了什么
这段代码实际上做的事情。

98
00:04:01,670 --> 00:04:04,917
它声明两个变量了
顶，S和T，并调用的getString。

99
00:04:04,917 --> 00:04:08,250
这不是一个非常用户友好的程序，
因为它不会告诉你的事。

100
00:04:08,250 --> 00:04:10,541
但是，让我们姑且我们
重点是多汁的一部分。

101
00:04:10,541 --> 00:04:14,470
然后我们做的，如果s等于
等于T，应该说printf的，

102
00:04:14,470 --> 00:04:16,170
您键入同样的事情。

103
00:04:16,170 --> 00:04:16,670
你好。

104
00:04:16,670 --> 00:04:17,050
你叫什么名字？

105
00:04:17,050 --> 00:04:17,779
>> 詹妮尔：詹妮尔。

106
00:04:17,779 --> 00:04:19,529
戴维·J·马兰：詹妮尔，
很高兴认识你。

107
00:04:19,529 --> 00:04:21,800
所以，你在挑战
手这头大象

108
00:04:21,800 --> 00:04:25,230
是第一个吸引我们的是什么图片
被代表的前两个

109
00:04:25,230 --> 00:04:25,970
线。

110
00:04:25,970 --> 00:04:28,139
因此，S和T可能是
显示在画面上如何？

111
00:04:28,139 --> 00:04:30,680
而且你可以绘制与
将手指放在这个大屏幕上。

112
00:04:30,680 --> 00:04:31,780

113
00:04:31,780 --> 00:04:34,510
>> 因此，有两部分，以
该方程的每一侧。

114
00:04:34,510 --> 00:04:37,760
所以有S上的左侧，并且
然后GetString的右边。

115
00:04:37,760 --> 00:04:40,540
再有就是吨左边，
然后GetString的右边。

116
00:04:40,540 --> 00:04:42,630
那么我们如何开始
绘制的画面，

117
00:04:42,630 --> 00:04:46,340
表示这是怎么回事
这里的记忆，你会说什么？

118
00:04:46,340 --> 00:04:49,150
让我让你解释
你在做什么，当您去。

119
00:04:49,150 --> 00:04:49,820
>> 詹妮尔：好的。

120
00:04:49,820 --> 00:04:58,890
嗯，首先，它会问
你得到输入字符串。

121
00:04:58,890 --> 00:05:00,439
它会store--哦，对不起。

122
00:05:00,439 --> 00:05:01,230
戴维·J·马兰：确定。

123
00:05:01,230 --> 00:05:01,730
好。

124
00:05:01,730 --> 00:05:03,330
而这个叫什么？

125
00:05:03,330 --> 00:05:03,950
哦，好吧。

126
00:05:03,950 --> 00:05:04,450
继续前进。

127
00:05:04,450 --> 00:05:05,575
我不是故意要打断。

128
00:05:05,575 --> 00:05:07,060
詹妮尔：对不起。

129
00:05:07,060 --> 00:05:14,237
因此，将其输入到
地址of--不能确定。

130
00:05:14,237 --> 00:05:17,320
我不记得确切的数字，
但我相信这是从0开始。

131
00:05:17,320 --> 00:05:18,420
>> 戴维·J·马兰：没关系，
因为我做的数字了，

132
00:05:18,420 --> 00:05:19,650
所以没有正确的答案。

133
00:05:19,650 --> 00:05:22,105
>> 詹妮尔：用0起弧。

134
00:05:22,105 --> 00:05:24,000
>> 戴维·J·马兰：好了，元素0。

135
00:05:24,000 --> 00:05:24,765
当然。

136
00:05:24,765 --> 00:05:28,295
>> 詹妮尔：然后如果是
像刚才两个letter--

137
00:05:28,295 --> 00:05:30,496
>> 戴维·J·马兰：好了，还给你。

138
00:05:30,496 --> 00:05:33,629
>> 詹妮尔：所以元素0，
然后元件1或元件2。

139
00:05:33,629 --> 00:05:36,670
戴维·J·马兰：而且这一块
图片是你画的权利吗？

140
00:05:36,670 --> 00:05:37,690
给GetString的调用？

141
00:05:37,690 --> 00:05:38,830
或s的声明？

142
00:05:38,830 --> 00:05:42,890
>> 詹妮尔：报关
的S，我相信。

143
00:05:42,890 --> 00:05:45,980
哦，对的getString，因为它会
被输入到每一个[？区。 ？]

144
00:05:45,980 --> 00:05:46,510
>> 戴维·J·马兰：好。

145
00:05:46,510 --> 00:05:47,051
没错。

146
00:05:47,051 --> 00:05:49,300
尽管这有效地
返回一个数组，调用，

147
00:05:49,300 --> 00:05:53,300
当我们回到一个字符串，我们可以
索引使用01和2的字符串。

148
00:05:53,300 --> 00:05:56,180
从技术上讲，这很可能是
个别地址表示，

149
00:05:56,180 --> 00:05:57,100
但是这很好。

150
00:05:57,100 --> 00:06:00,170
>> 于是想，如果我可以快
转发给我们留下了

151
00:06:00,170 --> 00:06:04,320
最后时刻，如果一个
字符串是克A B E，

152
00:06:04,320 --> 00:06:10,337
反斜杠0，从而表示Gabe的
输入，怎么可能，我们代表就谈到？

153
00:06:10,337 --> 00:06:12,670
如果是这样的存储器那
被送回了的getString？

154
00:06:12,670 --> 00:06:14,415

155
00:06:14,415 --> 00:06:17,610
>> 詹妮尔：这将是
由电弧所表示？

156
00:06:17,610 --> 00:06:18,750
>> 戴维·J·马兰：通过电弧？

157
00:06:18,750 --> 00:06:19,130
哦，不。

158
00:06:19,130 --> 00:06:21,171
远的不说，形象地，
让我继续前进

159
00:06:21,171 --> 00:06:25,710
和建议，如果这是秒，这
是的getString的返回值。

160
00:06:25,710 --> 00:06:29,482
而你画这是0，1，2，其中
是完全合理的，因为我们

161
00:06:29,482 --> 00:06:30,940
可以索引到字符串，作为这样。

162
00:06:30,940 --> 00:06:33,340
但刚需一致
最后一次，让我先走

163
00:06:33,340 --> 00:06:37,310
并随意提出这
是地址1，这是地址2，

164
00:06:37,310 --> 00:06:39,597
这是地址3，依此类推。

165
00:06:39,597 --> 00:06:41,430
因此，刚需超
显然，这是怎么回事

166
00:06:41,430 --> 00:06:44,580
s中去，作为一个结果，
代码的第一行，你会说什么？

167
00:06:44,580 --> 00:06:45,420
>> 詹妮尔：地址1？

168
00:06:45,420 --> 00:06:46,420
>> 戴维·J·马兰：没错。

169
00:06:46,420 --> 00:06:47,190
因此，解决为0x1。

170
00:06:47,190 --> 00:06:48,220

171
00:06:48,220 --> 00:06:51,230
而与此同时，让我继续前进，
重复的很多东西，你做

172
00:06:51,230 --> 00:06:52,740
在这里添加自己吨。

173
00:06:52,740 --> 00:06:56,340
如果我要在加布型
再一次，第二次，

174
00:06:56,340 --> 00:07:01,530
当用的getString提示，其中，
当然，被加布要去？

175
00:07:01,530 --> 00:07:02,280
那么，presumably--

176
00:07:02,280 --> 00:07:04,935

177
00:07:04,935 --> 00:07:05,975
>> 詹妮尔：像在这里？

178
00:07:05,975 --> 00:07:06,850
戴维·J·马兰：是的。

179
00:07:06,850 --> 00:07:08,516
詹妮尔：或者它也是在同一个箱子？

180
00:07:08,516 --> 00:07:11,940
戴维·J·马兰：我建议，是啊，
准确，因此，在这些附加的盒子。

181
00:07:11,940 --> 00:07:15,230
但是，什么是现在的关键是，即使
虽然我画这些八九不离十

182
00:07:15,230 --> 00:07:18,650
together--为0x1，这
被0x2--在现实中，

183
00:07:18,650 --> 00:07:25,750
这个现在可能是地址为0x10，
例如，和为0x11，以及0x12的

184
00:07:25,750 --> 00:07:26,870
等等。

185
00:07:26,870 --> 00:07:29,955
因此，如果是这样的话，
这是怎么回事结束了在这里吨？

186
00:07:29,955 --> 00:07:30,830
>> 詹妮尔：为0x10？

187
00:07:30,830 --> 00:07:31,830
戴维·J·马兰：没错。

188
00:07:31,830 --> 00:07:33,180
因此，为0x10。

189
00:07:33,180 --> 00:07:34,570
所以现在，最后一个问题。

190
00:07:34,570 --> 00:07:37,510
你有，到目前为止，已经工作了
最难的大象迄今。

191
00:07:37,510 --> 00:07:42,650
事到如今，如果我拉起码
再次，当我这样做，在三线，

192
00:07:42,650 --> 00:07:47,630
如果s等于等于T，我算什么实际
相比较，我们在这里画？

193
00:07:47,630 --> 00:07:49,271
>> 詹妮尔：这两个地址？

194
00:07:49,271 --> 00:07:50,270
戴维·J·马兰：没错。

195
00:07:50,270 --> 00:07:53,350
所以，我要说的是S等于等于t？

196
00:07:53,350 --> 00:07:56,210
换句话说，是1等于等于10？

197
00:07:56,210 --> 00:07:59,710
并且，当然，在
答案很明显，现在是，没有。

198
00:07:59,710 --> 00:08:02,920
所以这个方案最终是
要打印的内容，你会说什么？

199
00:08:02,920 --> 00:08:05,770

200
00:08:05,770 --> 00:08:08,405
>> 詹妮尔：它会是这样，
您键入同样的事情？

201
00:08:08,405 --> 00:08:11,446
>> 戴维·J·马兰：所以，如果
s是1和t是10？

202
00:08:11,446 --> 00:08:13,320
>> 詹妮尔：输入不同的事情。

203
00:08:13,320 --> 00:08:13,570
>> 戴维·J·马兰：没错。

204
00:08:13,570 --> 00:08:14,480
你输入不同的事情。

205
00:08:14,480 --> 00:08:14,850
好吧。

206
00:08:14,850 --> 00:08:16,714
所以，掌声雷动，
如果我们能在这里。

207
00:08:16,714 --> 00:08:17,214
[掌声]

208
00:08:17,214 --> 00:08:17,708
这是痛苦的。

209
00:08:17,708 --> 00:08:18,208
我知道。

210
00:08:18,208 --> 00:08:19,684
很好地完成。

211
00:08:19,684 --> 00:08:24,690
所以，现在让我们来看看，如果我们不能
梳理出什么样的修复程序。

212
00:08:24,690 --> 00:08:28,040
当然，当我们固定this--
现在我将代表green--

213
00:08:28,040 --> 00:08:29,690
我们做了几个增强功能在这里。

214
00:08:29,690 --> 00:08:32,409
首先，正如一个理智
检查一下，我先检查

215
00:08:32,409 --> 00:08:35,110
如果s等于null和T等于null。

216
00:08:35,110 --> 00:08:39,440
而只是要清楚，如果可能
s或t为null，在这样的代码？

217
00:08:39,440 --> 00:08:43,140

218
00:08:43,140 --> 00:08:44,490
当可能s或t为null。

219
00:08:44,490 --> 00:08:44,990
是吗？

220
00:08:44,990 --> 00:08:45,990
>> 听众：[听不清]。

221
00:08:45,990 --> 00:08:49,490

222
00:08:49,490 --> 00:08:50,510
>> 戴维·J·马兰：没错。

223
00:08:50,510 --> 00:08:52,840
如果字符串用户
键入的是太长时间

224
00:08:52,840 --> 00:08:56,140
要装入内存，或者一些
奇怪的角落情况下那样，

225
00:08:56,140 --> 00:08:59,010
GetString的，正如我们所看到的，从字面上
今天，它的文档中，

226
00:08:59,010 --> 00:09:02,330
表示将返回null作为
一个特殊的标记值，

227
00:09:02,330 --> 00:09:05,417
或者只是有点特殊符号
这意味着出事了。

228
00:09:05,417 --> 00:09:07,500
因此，我们要检查
是，因为事实证明

229
00:09:07,500 --> 00:09:09,720
那空是一个非常危险的价值。

230
00:09:09,720 --> 00:09:14,250
>> 通常情况下，如果你尝试做一些与
空涉及函数 - 它传递

231
00:09:14,250 --> 00:09:17,470
作为输入，对instance--该功能
很可能会崩溃，并用它，

232
00:09:17,470 --> 00:09:19,090
记下你的整个程序。

233
00:09:19,090 --> 00:09:22,570
因此，这第三条线，现在仅仅是一个理智
检查，检查错误，如果你愿意。

234
00:09:22,570 --> 00:09:25,450
这是一个好习惯，现在的
我们进入任何时候我们

235
00:09:25,450 --> 00:09:28,050
尝试使用一个值，
可能，可能，是空的。

236
00:09:28,050 --> 00:09:32,000
>> 现在，在第四行此处，
“如果STRCMP（S，T），”好了，

237
00:09:32,000 --> 00:09:33,180
那是什么指？

238
00:09:33,180 --> 00:09:36,750
好吧，我们说这是一个非常简洁
命名函数的字符串比较。

239
00:09:36,750 --> 00:09:40,370
及其在生命的目的是比较
其反对的第一个参数第二，

240
00:09:40,370 --> 00:09:44,640
但不是在它们的地址而言，
因为我们没有无意中片刻

241
00:09:44,640 --> 00:09:48,270
以前的红色代码，但
而比较这两个

242
00:09:48,270 --> 00:09:53,210
在力所能及直观的字符串
通过比较这一点，对这种方式，

243
00:09:53,210 --> 00:09:56,690
针对这一点，针对这一点，并
然后停止，如果和当一个

244
00:09:56,690 --> 00:09:59,590
还是我的两个手指
打一个反斜杠0。

245
00:09:59,590 --> 00:10:04,530
因此，有人年前实施的strcmp
实现我们的功能

246
00:10:04,530 --> 00:10:08,890
我们希望我们会得到
仅通过比较两个简单的值。

247
00:10:08,890 --> 00:10:14,929
>> 现在，坦率地说，我把图纸
所有这些不同的数字。

248
00:10:14,929 --> 00:10:17,470
但现实是，我已经
制备这些向上的全部时间。

249
00:10:17,470 --> 00:10:19,580
因此，让我干脆去
而这些乱涂出来

250
00:10:19,580 --> 00:10:23,100
做一个点，在结束
这一天，并向前走，

251
00:10:23,100 --> 00:10:30,160
我们不是真的要关心
有什么解决的事情，其实

252
00:10:30,160 --> 00:10:30,790
在存储器中。

253
00:10:30,790 --> 00:10:34,320
所以，我不会画这些
种数的那么多了，

254
00:10:34,320 --> 00:10:38,970
我只是一个抽象的这个客场
小只箭更友好。

255
00:10:38,970 --> 00:10:42,060
>> 换言之，如果s是一个指针，
好了，让我们只绘制它，从字面上看，

256
00:10:42,060 --> 00:10:45,430
作为一个指针箭头指向
从自身到别的东西，

257
00:10:45,430 --> 00:10:48,280
而不用太担心更多
这些地址的细节

258
00:10:48,280 --> 00:10:49,910
其中，再次，我反正做了。

259
00:10:49,910 --> 00:10:52,680
但是，我们可以看到这些地址，
有时，调试代码的时候。

260
00:10:52,680 --> 00:10:56,450
>> 现在，同时，该计划
当然，在这里的修复，

261
00:10:56,450 --> 00:10:58,720
通过比较该问题
这两个字符串。

262
00:10:58,720 --> 00:11:00,260
但是，我们遇到了另一个问题。

263
00:11:00,260 --> 00:11:03,180
这是从复制
节目最后一次，

264
00:11:03,180 --> 00:11:06,880
因此，我试图利用
在一个字符串仅仅是第一个字符。

265
00:11:06,880 --> 00:11:09,620
但究竟是什么症状
我们看到最后的时候

266
00:11:09,620 --> 00:11:14,150
用户键入一个值，如
加布于小写的S，

267
00:11:14,150 --> 00:11:19,310
那么我们分配s转换T，
如第三行那里，

268
00:11:19,310 --> 00:11:22,900
然后我试图
资本吨支架0？

269
00:11:22,900 --> 00:11:25,950
什么效果
改变吨支架0吗？

270
00:11:25,950 --> 00:11:27,150
>> 听众：它改变了第

271
00:11:27,150 --> 00:11:29,360
>> 戴维·J·马兰：是啊，
我换了S，以及。

272
00:11:29,360 --> 00:11:31,050
因为什么怎么回事？

273
00:11:31,050 --> 00:11:34,130
好吧，让我看看，如果我能清洁
这幅画，如下所示。

274
00:11:34,130 --> 00:11:41,390
>> 如果S是再次，字克，
A，B，E，反斜杠，0和s

275
00:11:41,390 --> 00:11:44,084
我们将继续绘制一个框
在这里，但没有更多的地址。

276
00:11:44,084 --> 00:11:45,250
让我们停止做的事情了。

277
00:11:45,250 --> 00:11:47,510
让我们只画一幅画
简化了世界。

278
00:11:47,510 --> 00:11:52,640
>> 当我宣布吨，串T，
创建的内存块。

279
00:11:52,640 --> 00:11:55,850
方碰巧是32
位在大多数计算机上。

280
00:11:55,850 --> 00:11:59,530
事实上，如果你曾经听说过的
具有32位体系结构的计算机，

281
00:11:59,530 --> 00:12:03,000
真正看中的，说话，只是
意味着它采用32位地址。

282
00:12:03,000 --> 00:12:05,370
而作为一个技术不谈，
如果你曾经想知道

283
00:12:05,370 --> 00:12:09,630
为什么旧的电脑，如果你真的
想喝汤起来，有很多的RAM，

284
00:12:09,630 --> 00:12:12,360
只能有一个最大
四个千兆字节的RAM，

285
00:12:12,360 --> 00:12:14,860
好，这是因为，从字面上看，
您的旧电脑只能

286
00:12:14,860 --> 00:12:17,250
计高达4
十亿，4个十亿字节，

287
00:12:17,250 --> 00:12:20,590
因为它是使用32位
号码的地址。

288
00:12:20,590 --> 00:12:23,260
>> 但在任何情况下，在该
比如，故事中的要简单得多。

289
00:12:23,260 --> 00:12:27,250
t是只是一个指针，或
真是一个char星，又名字符串。

290
00:12:27,250 --> 00:12:30,860
怎么办我想更新这幅画
现在的代码，第二行，

291
00:12:30,860 --> 00:12:31,950
点后，点，点？

292
00:12:31,950 --> 00:12:35,845
当我做串T等于Š分号，
请问这张照片改变？

293
00:12:35,845 --> 00:12:37,500

294
00:12:37,500 --> 00:12:38,000
是吗？

295
00:12:38,000 --> 00:12:38,916
>> 听众：[听不清]。

296
00:12:38,916 --> 00:12:41,087

297
00:12:41,087 --> 00:12:42,020
>> 戴维·J·马兰：是的。

298
00:12:42,020 --> 00:12:42,600
没错。

299
00:12:42,600 --> 00:12:45,620
我只是把一个箭头从
吨方块以相同的地址，

300
00:12:45,620 --> 00:12:47,570
在相同的第一个字母给了。

301
00:12:47,570 --> 00:12:50,850
或在技术上，如果这
男人仍然在为0x1，

302
00:12:50,850 --> 00:12:53,052
这是因为虽然我有
这里为0x1和0x1这里。

303
00:12:53,052 --> 00:12:54,760
但同样，谁在乎
关于地址？

304
00:12:54,760 --> 00:12:56,345
只是，现在最重要的想法。

305
00:12:56,345 --> 00:12:57,720
因此，这是这里发生了什么。

306
00:12:57,720 --> 00:13:02,690
所以，当然，如果你做T支架
0，这是数组符号，

307
00:13:02,690 --> 00:13:05,650
的course--坦率地说，它看起来
像有一个数组在这里，

308
00:13:05,650 --> 00:13:07,340
但现在有这样奇怪的事情。

309
00:13:07,340 --> 00:13:11,160
要知道，编程语言，
C，为您提供此功能，

310
00:13:11,160 --> 00:13:14,650
由此，即使t是
指针，或s是一个指针，

311
00:13:14,650 --> 00:13:18,050
您还可以使用熟悉的，
舒适的括号

312
00:13:18,050 --> 00:13:22,520
符号去的第一要素，
或所述第二元件，或任何元件

313
00:13:22,520 --> 00:13:26,130
在该指针指向
到，因为，据推测，它

314
00:13:26,130 --> 00:13:29,410
是，因为在这种情况下，
指着一些数组。

315
00:13:29,410 --> 00:13:30,340
>> 那么，我们如何解决这个问题？

316
00:13:30,340 --> 00:13:33,660
坦率地说，这是它得到了
有点麻烦第一眼。

317
00:13:33,660 --> 00:13:35,340
但这里是一个新的和改进的版本。

318
00:13:35,340 --> 00:13:37,460
>> 因此，首先，我越来越
摆脱CS50库，

319
00:13:37,460 --> 00:13:41,170
只是揭露S是真的
一个char明星，只是一个代名词。

320
00:13:41,170 --> 00:13:43,540
和T也是一个char明星。

321
00:13:43,540 --> 00:13:48,290
但对到底是怎么回事
该行的右手侧

322
00:13:48,290 --> 00:13:49,970
其中T是赋值？

323
00:13:49,970 --> 00:13:50,790
>> 什么是malloc的？

324
00:13:50,790 --> 00:13:51,630
什么是strlen的？

325
00:13:51,630 --> 00:13:52,547
什么是的sizeof（char）的？

326
00:13:52,547 --> 00:13:54,380
为什么非得这样做
线看起来那么复杂吗？

327
00:13:54,380 --> 00:13:55,713
它是什么做在一个较高的水平？

328
00:13:55,713 --> 00:13:56,482

329
00:13:56,482 --> 00:13:57,440
什么是存储在T？

330
00:13:57,440 --> 00:13:58,646
是吗？

331
00:13:58,646 --> 00:14:01,104
听众：它的分配
一定量的存储空间。

332
00:14:01,104 --> 00:14:03,032
它的存储，我想，
信[听不清]。

333
00:14:03,032 --> 00:14:04,032
>> 戴维·J·马兰：完美。

334
00:14:04,032 --> 00:14:04,540
完美的。

335
00:14:04,540 --> 00:14:06,650
它分配一个特定的
存储空间量

336
00:14:06,650 --> 00:14:08,940
存储，据推测，未来的信件。

337
00:14:08,940 --> 00:14:11,310
并且特别地，malloc的
因此，返回什么？

338
00:14:11,310 --> 00:14:13,114

339
00:14:13,114 --> 00:14:14,851
>> 听众：返回的[听不清]？

340
00:14:14,851 --> 00:14:15,850
戴维·J·马兰：没错。

341
00:14:15,850 --> 00:14:18,850
返回的内存地址，
这只不过是一个奇特的方式，

342
00:14:18,850 --> 00:14:21,640
返回的地址
该内存的第一个字节。

343
00:14:21,640 --> 00:14:25,460
的责任是我记住
实际上有多少内存I

344
00:14:25,460 --> 00:14:27,140
分配或要求的malloc的。

345
00:14:27,140 --> 00:14:28,384
>> 现在是多少呢？

346
00:14:28,384 --> 00:14:30,550
好吧，即使有
很多括号在这里，

347
00:14:30,550 --> 00:14:32,970
malloc的只需要一个参数。

348
00:14:32,970 --> 00:14:37,250
和我指定的字符strlen，所以给
我尽可能多的字节，因为在S，

349
00:14:37,250 --> 00:14:37,800
但新增一个。

350
00:14:37,800 --> 00:14:38,300
为什么呢？

351
00:14:38,300 --> 00:14:39,030

352
00:14:39,030 --> 00:14:39,530
是吗？

353
00:14:39,530 --> 00:14:40,840
>> 听众：反斜杠0。

354
00:14:40,840 --> 00:14:41,840
戴维·J·马兰：没错。

355
00:14:41,840 --> 00:14:43,423
我们必须做一点家务。

356
00:14:43,423 --> 00:14:45,970
所以，因为有一个反斜杠
0，我们最好记住这一点。

357
00:14:45,970 --> 00:14:47,310
否则，我们将
创建一个字符串，

358
00:14:47,310 --> 00:14:49,170
没有特别的终结者。

359
00:14:49,170 --> 00:14:52,640
>> 同时，刚需超
肛门，我的sizeof（char）的，

360
00:14:52,640 --> 00:14:55,730
万一有人跑我
不上CS50设备代码，

361
00:14:55,730 --> 00:14:58,220
但也许在不同的计算机
干脆在那里字符

362
00:14:58,220 --> 00:15:01,470
是一个字节，按照惯例，但有两个
字节或更大的东西不止这些。

363
00:15:01,470 --> 00:15:04,490
这是刚需超，
超级反感的错误。

364
00:15:04,490 --> 00:15:06,940
尽管，在现实中，这是
最有可能将是一个1。

365
00:15:06,940 --> 00:15:11,490
>> 现在，同时，我继续和复制
字符串，T支架i等于吨支架第

366
00:15:11,490 --> 00:15:14,962
我将按照上周的
源代码，看看是怎么回事。

367
00:15:14,962 --> 00:15:17,670
但关键的外卖，以及
我之所以把代码现在绿，

368
00:15:17,670 --> 00:15:22,520
是因为很最后一行
吨支架0等于TOUPPER，

369
00:15:22,520 --> 00:15:25,230
具有的效果
转增股本的字符串？

370
00:15:25,230 --> 00:15:26,960
T和/或S？

371
00:15:26,960 --> 00:15:29,280

372
00:15:29,280 --> 00:15:30,580
最后一行代码。

373
00:15:30,580 --> 00:15:32,930

374
00:15:32,930 --> 00:15:35,560
>> 只是T，是因为什么
最少此时，

375
00:15:35,560 --> 00:15:41,500
如果我稍微撤消最后一步，
什么情况是，当我调用malloc，

376
00:15:41,500 --> 00:15:45,380
í基本上得到一个内存块
这是相同的尺寸，原来，

377
00:15:45,380 --> 00:15:47,020
因为这是算术我做到了。

378
00:15:47,020 --> 00:15:50,920
我存储在T地址
的内存块。

379
00:15:50,920 --> 00:15:53,370
尽管这看起来不错
漂亮，漂亮，一片空白，

380
00:15:53,370 --> 00:15:56,882
实际情况是有，我们会
保持通话，在这里的垃圾值。

381
00:15:56,882 --> 00:15:59,340
该内存块可能很
也有之前被使用，

382
00:15:59,340 --> 00:16:00,940
几秒钟，几分钟前。

383
00:16:00,940 --> 00:16:04,410
因此，有可能完全是数字
或字母那里，只是偶然。

384
00:16:04,410 --> 00:16:08,580
但他们不是有效的，直到我
我自己填充此块内存

385
00:16:08,580 --> 00:16:12,510
与实际的字符，如我
做在for循环出现。

386
00:16:12,510 --> 00:16:13,180
好吧？

387
00:16:13,180 --> 00:16:16,180
>> 所以，现在的高潮
这三个例子

388
00:16:16,180 --> 00:16:20,730
那名看似打破最后一次，
这个互换的例子，这个功能

389
00:16:20,730 --> 00:16:23,670
在这个意义上制作
它交换a和b。

390
00:16:23,670 --> 00:16:25,620
但它并没有什么其他意义的工作？

391
00:16:25,620 --> 00:16:27,616

392
00:16:27,616 --> 00:16:28,614
是吗？

393
00:16:28,614 --> 00:16:29,612
>> 听众：[听不清]。

394
00:16:29,612 --> 00:16:35,600

395
00:16:35,600 --> 00:16:36,700
>> 戴维·J·马兰：没错。

396
00:16:36,700 --> 00:16:39,530
如果我要调用这个函数
从another--例如

397
00:16:39,530 --> 00:16:42,870
从主一样，在功能
我有一个变量，x和y，当我

398
00:16:42,870 --> 00:16:46,160
上星期，同样的代码，
而我通过在X和Y

399
00:16:46,160 --> 00:16:49,860
以交换，然后调用Swap--这一点，
当然是正确的版本

400
00:16:49,860 --> 00:16:52,220
就是我们即将
see--没有奏效。

401
00:16:52,220 --> 00:16:53,770
那么，什么是定位？

402
00:16:53,770 --> 00:16:56,850
>> 好了，所以才要
显然，让我先走

403
00:16:56,850 --> 00:17:05,450
还有 - 给我1秒在这里，看
如果我能告诉你的最后一个，这

404
00:17:05,450 --> 00:17:12,464
将in--让我们来看看，如果我能找到
这种真正的fast--确定，[听不清]。

405
00:17:12,464 --> 00:17:18,440

406
00:17:18,440 --> 00:17:19,240
好了，它就在那里。

407
00:17:19,240 --> 00:17:21,000
所以忽略我只是键入命令。

408
00:17:21,000 --> 00:17:23,780
我希望它在检索
最后一分钟的一例

409
00:17:23,780 --> 00:17:27,960
从去年的时间，这
现在所谓的无交换。

410
00:17:27,960 --> 00:17:30,200
>> 因此，没有交换的地方
我们离开的最后一次，

411
00:17:30,200 --> 00:17:32,930
因此，我初始化
X要1和y 2。

412
00:17:32,930 --> 00:17:35,840
后来我打电话交换，传递1和2。

413
00:17:35,840 --> 00:17:37,930
然后这个函数
在某种意义上工作，

414
00:17:37,930 --> 00:17:40,750
但它没有永久的
在x和y的影响。

415
00:17:40,750 --> 00:17:45,430
因此，目前的问题是，怎么现在
我们其实解决这个问题？

416
00:17:45,430 --> 00:17:47,820
如何解决在眼前？

417
00:17:47,820 --> 00:17:53,150
>> 那么，在swap.c，今天是新的，
看到一对夫妇的差异。

418
00:17:53,150 --> 00:17:54,700
x和y是相同的。

419
00:17:54,700 --> 00:17:57,250
但显然
约25行有什么不同？

420
00:17:57,250 --> 00:17:58,880

421
00:17:58,880 --> 00:18:01,715
最新消息那里，如果你还记得
它看起来像一秒钟前？

422
00:18:01,715 --> 00:18:02,565
>> 听众：[听不清]。

423
00:18:02,565 --> 00:18:03,440
>> 戴维·J·马兰：是的。

424
00:18:03,440 --> 00:18:06,680
所以连字号是一个新的作品
语法不仅这个程序中，

425
00:18:06,680 --> 00:18:08,560
而且更普遍的CS50。

426
00:18:08,560 --> 00:18:10,680
到目前为止，我不认为
我们见过的任何实例

427
00:18:10,680 --> 00:18:14,070
还是真的在任何谈论他们
细节，不是，也许，抢先其他

428
00:18:14,070 --> 00:18:16,467
在节中，像这样的符号。

429
00:18:16,467 --> 00:18:19,300
嗯，原来符号是
最后张新语法

430
00:18:19,300 --> 00:18:20,174
我们要学习的。

431
00:18:20,174 --> 00:18:23,500
它的意思是在
一些变量的地址。

432
00:18:23,500 --> 00:18:25,070
请问您的地址并点¯x住在哪里？

433
00:18:25,070 --> 00:18:26,510
但ÿ住什么地址？

434
00:18:26,510 --> 00:18:28,700
因为如果
之前根本问题

435
00:18:28,700 --> 00:18:32,970
在x和y分别被传递
作为副本，我们真正想做的事

436
00:18:32,970 --> 00:18:38,780
是提供交换与像宝贝一样
地图，导致其中x和y实际上

437
00:18:38,780 --> 00:18:41,910
在RAM中，从而使
交换可以按照该图

438
00:18:41,910 --> 00:18:47,760
和去哪里x或y标志的地方
和改变实际值1和2

439
00:18:47,760 --> 00:18:48,270
那里。

440
00:18:48,270 --> 00:18:50,710
>> 所以交换需要稍微改变了。

441
00:18:50,710 --> 00:18:53,760
乍看之下，这可能
似乎有点类似于字符的明星。

442
00:18:53,760 --> 00:18:54,850
的确是。

443
00:18:54,850 --> 00:18:59,635
所以a是一个指向什么类型的数据，
在此基础上突出部分？

444
00:18:59,635 --> 00:19:00,810

445
00:19:00,810 --> 00:19:01,620
所以这是一个int。

446
00:19:01,620 --> 00:19:04,880
>> 所以不再是一个int，
这是一个int的地址。

447
00:19:04,880 --> 00:19:07,910
同样，B现在准备
是一个int的地址。

448
00:19:07,910 --> 00:19:12,470
所以，当我现在请交换从主，
我不会给交换1和2。

449
00:19:12,470 --> 00:19:15,540
我要去给它像
牛的东西，黄牛的东西，

450
00:19:15,540 --> 00:19:19,820
两个地址，这将导致
交换自己的实际位置

451
00:19:19,820 --> 00:19:21,310
在我的电脑的内存中。

452
00:19:21,310 --> 00:19:25,580
>> 所以，现在，我剩下的落实
需要改变一点点。

453
00:19:25,580 --> 00:19:28,650
有什么明显的不同，现在
在这三行代码？

454
00:19:28,650 --> 00:19:31,350
有这些该死的明星都
过的地方，好吗？

455
00:19:31,350 --> 00:19:33,014
所以，这是怎么回事吗？

456
00:19:33,014 --> 00:19:33,514
是吗？

457
00:19:33,514 --> 00:19:35,055
>> 听众：这是很明显[听不清]。

458
00:19:35,055 --> 00:19:36,832

459
00:19:36,832 --> 00:19:37,990
>> 戴维·J·马兰：没错。

460
00:19:37,990 --> 00:19:41,560
所以在此context--，这是不
最好的设计决定，无可否认，

461
00:19:41,560 --> 00:19:42,530
几年前。

462
00:19:42,530 --> 00:19:45,110
在这种情况下，其中
你只需要一个明星，

463
00:19:45,110 --> 00:19:48,240
而你没有的数据类型，
如int，立即到左边，

464
00:19:48,240 --> 00:19:53,146
而不是你有一个等号，显然，
在这种情况下，当你说星A，

465
00:19:53,146 --> 00:19:56,980
这意味着去
地址是在一个。

466
00:19:56,980 --> 00:19:58,870
按照藏宝图，可以这么说。

467
00:19:58,870 --> 00:20:01,720
>> 并且同时，在第37行，
这意味着同样的事情。

468
00:20:01,720 --> 00:20:05,460
去的地址，并把什么呢？

469
00:20:05,460 --> 00:20:09,520
不管是在
地理位置使得b指定。

470
00:20:09,520 --> 00:20:10,980
换句话说，去到b。

471
00:20:10,980 --> 00:20:12,130
获得该值。

472
00:20:12,130 --> 00:20:15,620
去和每平等
签署，赋值运算符，

473
00:20:15,620 --> 00:20:17,010
把该值存在。

474
00:20:17,010 --> 00:20:19,272
>> 同样，INT温度仅仅是一个int。

475
00:20:19,272 --> 00:20:20,730
没有什么需要改一下温度。

476
00:20:20,730 --> 00:20:24,810
这只是一个备用的玻璃从安嫩伯格
对于一些牛奶或橙汁。

477
00:20:24,810 --> 00:20:27,630
但我需要说的，去到B。

478
00:20:27,630 --> 00:20:31,449
去那个目的地，
放在那里的温度值。

479
00:20:31,449 --> 00:20:32,490
因此，发生了什么呢？

480
00:20:32,490 --> 00:20:36,540
当我真正称之为交换这个时候，如果
这第一盘在这里代表主，

481
00:20:36,540 --> 00:20:42,270
当第二盘代表交换，
我通过符号x和符号ÿ

482
00:20:42,270 --> 00:20:47,150
从主来交换，只是要清楚，
这是什么堆栈帧接收？

483
00:20:47,150 --> 00:20:48,700

484
00:20:48,700 --> 00:20:49,200
是吗？

485
00:20:49,200 --> 00:20:50,180
>> 听众：[听不清]。

486
00:20:50,180 --> 00:20:51,180
戴维·J·马兰：没错。

487
00:20:51,180 --> 00:20:53,129
x的地址和y的地址。

488
00:20:53,129 --> 00:20:55,170
而你能想到的这些
如邮寄地址。

489
00:20:55,170 --> 00:20:58,772
33牛津街和35
牛津街和你

490
00:20:58,772 --> 00:21:01,230
要移动的两栋楼
这是在这些地方。

491
00:21:01,230 --> 00:21:04,680
>> 这有点荒谬的想法，
但是这就是我们所说的地址。

492
00:21:04,680 --> 00:21:07,000
凡在世界上可以
你会发现这两个整数？

493
00:21:07,000 --> 00:21:09,470
凡在世界上你
找到这两个建筑物？

494
00:21:09,470 --> 00:21:15,170
因此，如果最后，毕竟这个时候我
进入今天的源代码和编译

495
00:21:15,170 --> 00:21:22,110
交换和运行./swap，最后，为
第一次，我们确实看到，

496
00:21:22,110 --> 00:21:25,330
我的价值观的确有
已成功交换。

497
00:21:25,330 --> 00:21:30,860
而现在，我们甚至可以把
请注意这一点，比如，广发银行。

498
00:21:30,860 --> 00:21:32,740
>> 所以，让我去到同一个文件中。

499
00:21:32,740 --> 00:21:35,010
让我继续运行./swap的GDB。

500
00:21:35,010 --> 00:21:36,590

501
00:21:36,590 --> 00:21:40,547
而现在，在交换，我会去
未来，并设置一个断点在主。

502
00:21:40,547 --> 00:21:42,630
现在我要去
继续运行该程序。

503
00:21:42,630 --> 00:21:45,810
现在我们看到我的代码
停在该行。

504
00:21:45,810 --> 00:21:48,330
>> 如果我继续和打印
X，我应该在这里看到的？

505
00:21:48,330 --> 00:21:49,314

506
00:21:49,314 --> 00:21:49,980
这是一个问题。

507
00:21:49,980 --> 00:21:51,030

508
00:21:51,030 --> 00:21:51,530
再说一遍？

509
00:21:51,530 --> 00:21:52,295
>> 听众：[听不清]。

510
00:21:52,295 --> 00:21:53,910
>> 戴维·J·马兰：所以
随机数，也许。

511
00:21:53,910 --> 00:21:56,010
也许我很幸运，它的
优雅而简单，如0。

512
00:21:56,010 --> 00:21:57,230
但也许这是一些随机数。

513
00:21:57,230 --> 00:21:58,090
在这种情况下，我真的很幸运。

514
00:21:58,090 --> 00:21:59,030
这恰好是0。

515
00:21:59,030 --> 00:22:00,780
但它确实是运气，
因为直到我

516
00:22:00,780 --> 00:22:06,280
输入下一个，然后打印x的那
代码行，19行，被执行死刑。

517
00:22:06,280 --> 00:22:10,942
>> 同时，如果我输入下一一遍，
现在打印出Y，我要见2。

518
00:22:10,942 --> 00:22:13,900
现在，如果我输入下一个，它要
变得有点混乱，因为现在，

519
00:22:13,900 --> 00:22:17,250
中的printf会出现在
在屏幕上，因为它没有。 x是1。

520
00:22:17,250 --> 00:22:18,606
>> 让我们再次做到这一点。

521
00:22:18,606 --> 00:22:20,480
而现在，这里的地方
事情变得有趣。

522
00:22:20,480 --> 00:22:21,580

523
00:22:21,580 --> 00:22:26,580
在我打电话交换，甚至一步
进去，让我们一点点偷看。

524
00:22:26,580 --> 00:22:28,980
x是，再次，1。

525
00:22:28,980 --> 00:22:33,240
Y是当然，快清醒
检查，2，所以并不难有。

526
00:22:33,240 --> 00:22:35,740
但是，什么是符号X你是否

527
00:22:35,740 --> 00:22:36,760

528
00:22:36,760 --> 00:22:39,350
答案，它是一种时髦好看。

529
00:22:39,350 --> 00:22:43,500
但INT明星在括号只是
对这种说法GDP的方式是一个地址。

530
00:22:43,500 --> 00:22:48,290
它不是一个整数，它是一个指向
int或以其他方式被称为一个地址。

531
00:22:48,290 --> 00:22:49,742
>> 这是什么疯狂的事？

532
00:22:49,742 --> 00:22:51,825
我们从来没有见过的东西
很喜欢之前。

533
00:22:51,825 --> 00:22:53,650

534
00:22:53,650 --> 00:22:58,120
因此，这是在我的电脑的地址
内存，其中x恰好住。

535
00:22:58,120 --> 00:22:59,040
这是黄牛的东西。

536
00:22:59,040 --> 00:23:01,290
这是坦率地说，为什么
我开始画箭头，

537
00:23:01,290 --> 00:23:03,340
不是数字的，
因为谁真正关心

538
00:23:03,340 --> 00:23:06,890
您的int是在一个特定的
地址是那么大。

539
00:23:06,890 --> 00:23:12,160
但bffff0c4，这些都是
的确十六进制数字，

540
00:23:12,160 --> 00:23:13,720
这是0到f。

541
00:23:13,720 --> 00:23:16,590
>> 因此，我们不会过多纠缠
长在什么地方的东西。

542
00:23:16,590 --> 00:23:19,400
但是，如果我打印出Y，
当然，我看到2。

543
00:23:19,400 --> 00:23:22,440
但符号Y，我看这个地址。

544
00:23:22,440 --> 00:23:26,527
并请注意，为好奇，
相距多远是x和y？

545
00:23:26,527 --> 00:23:27,985
您可以忽略大部分的地址。

546
00:23:27,985 --> 00:23:29,330

547
00:23:29,330 --> 00:23:29,920
四个字节。

548
00:23:29,920 --> 00:23:33,510
而这与我们的一致
早前声称有多大是一个int？

549
00:23:33,510 --> 00:23:34,130
四个字节。

550
00:23:34,130 --> 00:23:37,420
所以看起来一切都排队
很好，你可能希望，在内存中。

551
00:23:37,420 --> 00:23:40,010
>> 所以，现在，让我们快进
这个故事的结尾。

552
00:23:40,010 --> 00:23:43,290
让我们继续前进，步型，
潜入交换功能。

553
00:23:43,290 --> 00:23:46,880
现在发现，如果我输入一个，它的
相同，x的地址。

554
00:23:46,880 --> 00:23:52,130
如果我B型是相同的
到y的地址。

555
00:23:52,130 --> 00:23:57,020
所以，我应该怎样，如果我看到
说，进入地址的？

556
00:23:57,020 --> 00:23:58,120
因此，打印星号标示。

557
00:23:58,120 --> 00:24:00,130
所以，明星意味着去那里，在这种情况下。

558
00:24:00,130 --> 00:24:02,730
＆符号意味着什么的地址。

559
00:24:02,730 --> 00:24:05,000
所以，明星的手段1。

560
00:24:05,000 --> 00:24:09,590
并打印星级的住宿给我2。

561
00:24:09,590 --> 00:24:15,750
>> 让我假设，就目前而言，
至少所述代码

562
00:24:15,750 --> 00:24:18,950
现在进入执行即可
通过这种方式的理由。

563
00:24:18,950 --> 00:24:21,150
但我们会在不久重新讨论这个想法。

564
00:24:21,150 --> 00:24:23,850
所以这个版本的互换
现在是正确的，并且允许

565
00:24:23,850 --> 00:24:26,650
我们来交换该特定数据类型。

566
00:24:26,650 --> 00:24:29,120
>> 所以任何疑问然后交换？

567
00:24:29,120 --> 00:24:29,890
在星？

568
00:24:29,890 --> 00:24:30,690
对地址？

569
00:24:30,690 --> 00:24:33,270
你会看到，有
问题集4，排序，

570
00:24:33,270 --> 00:24:37,310
但问题集5，绝对，如何将这些
东西是有用的，并得到更多的

571
00:24:37,310 --> 00:24:39,584
熟悉他们，作为一个结果。

572
00:24:39,584 --> 00:24:40,430
什么呢？

573
00:24:40,430 --> 00:24:40,930
好吧。

574
00:24:40,930 --> 00:24:44,350
所以malloc的是，再次，此功能
刚刚分配内存，内存

575
00:24:44,350 --> 00:24:45,330
分配。

576
00:24:45,330 --> 00:24:47,024
以及为什么是这样有用吗？

577
00:24:47,024 --> 00:24:48,940
那么，这一切的时候，
你一直在使用malloc。

578
00:24:48,940 --> 00:24:52,230
如果你现在怎么考虑的
GetString的作品，据推测，这是

579
00:24:52,230 --> 00:24:56,140
被问的人一大块
记忆，随时在用户键入字符串

580
00:24:56,140 --> 00:24:59,040
在，因为我们肯定
不知道，因为CS50的工作人员，

581
00:24:59,040 --> 00:25:02,710
有多大的字符串，人类
要键入可能。

582
00:25:02,710 --> 00:25:07,910
>> 因此，让我们，第一次，开始
剥开如何CS50库工程，

583
00:25:07,910 --> 00:25:10,990
通过几个实例来
这将导致我们的。

584
00:25:10,990 --> 00:25:15,300
所以，如果我打开gedit的
开拓scanf函数0，

585
00:25:15,300 --> 00:25:17,055
我们将看到下面的代码。

586
00:25:17,055 --> 00:25:18,720

587
00:25:18,720 --> 00:25:23,530
scanf函数0，可以在网站上
今天，有代码相对较少的行

588
00:25:23,530 --> 00:25:25,351
在这里，14至20。

589
00:25:25,351 --> 00:25:26,600
让我们来看看它在做什么。

590
00:25:26,600 --> 00:25:28,920
它声明为int，名为x。

591
00:25:28,920 --> 00:25:30,850
它说像，数请。

592
00:25:30,850 --> 00:25:33,940
而现在它说，scanf函数％I，＆X。

593
00:25:33,940 --> 00:25:35,620
因此，有一堆新的东西出现。

594
00:25:35,620 --> 00:25:38,420
>> 但是scanf函数，你可以种思考
作为printf的相反。

595
00:25:38,420 --> 00:25:40,090
printf的，当然，打印到屏幕上。

596
00:25:40,090 --> 00:25:44,410
scanf的排序从用户的扫描
键盘的东西，他或她已经打出来。

597
00:25:44,410 --> 00:25:46,550
>> ％i是一样的printf。

598
00:25:46,550 --> 00:25:49,410
这意味着预期
用户键入一个int。

599
00:25:49,410 --> 00:25:52,820
而现在，你为什么认为我
可能是通过scanf函数＆X？

600
00:25:52,820 --> 00:25:54,030

601
00:25:54,030 --> 00:25:57,770
如果目的在scanf生活
是得到的东西从用户

602
00:25:57,770 --> 00:26:02,480
是什么意思
通过它，与X，现在呢？

603
00:26:02,480 --> 00:26:02,980
是吗？

604
00:26:02,980 --> 00:26:03,896
>> 听众：[听不清]。

605
00:26:03,896 --> 00:26:05,540

606
00:26:05,540 --> 00:26:06,540
戴维·J·马兰：没错。

607
00:26:06,540 --> 00:26:12,900
无论我，人，请在我的输入
将被保存在该位置。

608
00:26:12,900 --> 00:26:17,660
这是不够的，还记得，刚
通过在X，因为我们已经看到，

609
00:26:17,660 --> 00:26:21,630
任何时候，你只需通过一个原始变量，
就像一个int，一些其他的功能，

610
00:26:21,630 --> 00:26:25,640
当然，它可以改变
可变的，但不会永久。

611
00:26:25,640 --> 00:26:27,360
它不能对主要的效果。

612
00:26:27,360 --> 00:26:29,420
它只能改变自己的本地副本。

613
00:26:29,420 --> 00:26:32,560
但相反，如果你不这样做
给我实际的诠释，

614
00:26:32,560 --> 00:26:36,640
但你给我方向
在INT，我现在，是scanf函数，

615
00:26:36,640 --> 00:26:41,050
当然，我可以按照这
解决并把一些有

616
00:26:41,050 --> 00:26:43,280
所以你可以访问它。

617
00:26:43,280 --> 00:26:45,120
>> 所以，当我运行这个程序，让我们来看看。

618
00:26:45,120 --> 00:26:49,660
使scanf函数0点斜线，scanf函数0。

619
00:26:49,660 --> 00:26:54,030
如果我现在键入数字
像50，感谢50。

620
00:26:54,030 --> 00:26:58,150
如果我现在键入数字一样
负1，为负1。

621
00:26:58,150 --> 00:27:04,200
我现在键入数字如1.5，HM。

622
00:27:04,200 --> 00:27:06,030
为什么我的程序不理我了？

623
00:27:06,030 --> 00:27:07,300

624
00:27:07,300 --> 00:27:09,880
嗯，因为简单地说，我告诉
只期待一个int。

625
00:27:09,880 --> 00:27:10,380
好吧。

626
00:27:10,380 --> 00:27:11,630
所以这是其中的一个版本。

627
00:27:11,630 --> 00:27:16,600
让我们拿东西了一个缺口，
提出，这是不好的。

628
00:27:16,600 --> 00:27:20,530
而就在这里一个很简单的例子，
怎么我们就可以开始编写代码

629
00:27:20,530 --> 00:27:24,450
其他人可以利用或
做不好的事情妥协。

630
00:27:24,450 --> 00:27:28,336
所以第16行，如此相似
在精神之前，

631
00:27:28,336 --> 00:27:29,960
但我不会宣布它诠释这个时候。

632
00:27:29,960 --> 00:27:32,970
我宣布它炭星，又名字符串。

633
00:27:32,970 --> 00:27:35,190
>> 但是，这究竟意味着什么？

634
00:27:35,190 --> 00:27:38,790
所以，如果我不指定address--和
我打电话是随意，缓冲，

635
00:27:38,790 --> 00:27:43,370
但我可以把它称为为s，是simple--
然后我做到这一点，给我解释一下，

636
00:27:43,370 --> 00:27:48,630
如果可以的话，基于先前
逻辑是什么scanf函数在做线18，

637
00:27:48,630 --> 00:27:55,000
如果传％s和缓冲区，
这是一个地址？

638
00:27:55,000 --> 00:27:58,210
什么是scanf函数，如果你申请的
完全相同的逻辑版本0，

639
00:27:58,210 --> 00:28:00,640
当将试图在这里做，
在用户类型的东西吗？

640
00:28:00,640 --> 00:28:02,630

641
00:28:02,630 --> 00:28:03,409
是吗？

642
00:28:03,409 --> 00:28:04,407
>> 听众：[听不清]。

643
00:28:04,407 --> 00:28:07,401

644
00:28:07,401 --> 00:28:08,890
>> 戴维·J·马兰：没错。

645
00:28:08,890 --> 00:28:11,577
scanf函数，通过逻辑较早，
将要采取的串

646
00:28:11,577 --> 00:28:13,410
该人的类型化
in--它现在是一个字符串，

647
00:28:13,410 --> 00:28:15,790
它不是一个数，据推测，
如果他或她cooperates--

648
00:28:15,790 --> 00:28:19,310
并且它会试图把那
字符串在内存中的任何地址

649
00:28:19,310 --> 00:28:20,340
缓冲区指定。

650
00:28:20,340 --> 00:28:23,870
这是伟大的，因为缓冲
的确意味着是一个地址。

651
00:28:23,870 --> 00:28:30,470
>> 但我要求这个节目是越野车的
很严肃的方式，因为价值是什么

652
00:28:30,470 --> 00:28:31,330
默认情况下缓冲区？

653
00:28:31,330 --> 00:28:33,380

654
00:28:33,380 --> 00:28:34,790
我有什么初始化为？

655
00:28:34,790 --> 00:28:35,770
什么的内存块？

656
00:28:35,770 --> 00:28:37,480

657
00:28:37,480 --> 00:28:38,620
我没有，对不对？

658
00:28:38,620 --> 00:28:42,265
>> 所以，即使我已经分配了
焦恒星的不再叫S，

659
00:28:42,265 --> 00:28:48,030
它不是所谓的，buffer--所以
让我们来绘制变量名

660
00:28:48,030 --> 00:28:53,380
现在的buffer--如果我没有
所谓的getString或malloc的位置，

661
00:28:53,380 --> 00:28:56,030
这实际上意味着，
缓冲区只是一些垃圾值。

662
00:28:56,030 --> 00:28:57,030
>> 现在是什么意思？

663
00:28:57,030 --> 00:29:00,220
这意味着，我已经告诉scanf函数
期望从用户的字符串。

664
00:29:00,220 --> 00:29:01,300
而且你知道吗？

665
00:29:01,300 --> 00:29:03,883
不管这件事情是指向
to--和我画问号，

666
00:29:03,883 --> 00:29:07,060
但在现实中，这将是
像OX1，2，3，对不对？

667
00:29:07,060 --> 00:29:10,730
这是一些虚假的价值，仅仅
恰好从之前在那里。

668
00:29:10,730 --> 00:29:13,440
所以，换句话说，它是
仿佛缓冲只是

669
00:29:13,440 --> 00:29:16,180
指着东西在内存中。

670
00:29:16,180 --> 00:29:17,610
我不知道是什么。

671
00:29:17,610 --> 00:29:24,130
>> 所以，如果我输入加布现在，这是怎么回事
尝试把G-A-B-E / 0出现。

672
00:29:24,130 --> 00:29:25,530
但谁知道这是什么吗？

673
00:29:25,530 --> 00:29:27,480
和过去一样，任何
我们试图去触摸时间

674
00:29:27,480 --> 00:29:29,770
不属于存储器
对我们来说，发生了什么事？

675
00:29:29,770 --> 00:29:31,020

676
00:29:31,020 --> 00:29:32,870
或几乎所有的时间。

677
00:29:32,870 --> 00:29:34,310
分段错误，对吧？

678
00:29:34,310 --> 00:29:37,829
>> 这个箭头，我不知道它是
指点。它只是一些随机值。

679
00:29:37,829 --> 00:29:40,370
当然，如果你解释
一个随机值作为地址，

680
00:29:40,370 --> 00:29:42,610
你会去
一些随机的目的地。

681
00:29:42,610 --> 00:29:46,810
所以加布可能确实崩溃
我在这里这种情况下程序。

682
00:29:46,810 --> 00:29:50,600
>> 所以，我们可以做到这一点几乎是坏？

683
00:29:50,600 --> 00:29:52,660
考虑这个第三和
scanf函数的最后一个例子。

684
00:29:52,660 --> 00:29:53,890

685
00:29:53,890 --> 00:29:56,870
这个版本是在何种意义上比较好？

686
00:29:56,870 --> 00:29:57,990

687
00:29:57,990 --> 00:30:01,400
如果你是舒服了
以前的问题，这是更好的。

688
00:30:01,400 --> 00:30:02,250
为什么呢？

689
00:30:02,250 --> 00:30:03,250
>> 听众：[听不清]。

690
00:30:03,250 --> 00:30:06,235

691
00:30:06,235 --> 00:30:07,110
戴维·J·马兰：好。

692
00:30:07,110 --> 00:30:09,970
线16，以便该情况下
较好，在这个意义上

693
00:30:09,970 --> 00:30:12,030
我们是明确的
分配一些内存。

694
00:30:12,030 --> 00:30:14,190
我们不使用malloc，
我们使用了2周

695
00:30:14,190 --> 00:30:16,060
只是声明数组的方法。

696
00:30:16,060 --> 00:30:18,130
而我们在此之前一个字符串说过
是一个字符只是一个数组，

697
00:30:18,130 --> 00:30:19,690
所以这是完全合法的。

698
00:30:19,690 --> 00:30:22,910
但它的，当然，如
您注意，固定的大小，16。

699
00:30:22,910 --> 00:30:25,440
>> 因此，这个计划是
完全安全的，如果我输入

700
00:30:25,440 --> 00:30:29,760
在一个文字串，两个字符的
串，15字符的字符串。

701
00:30:29,760 --> 00:30:34,970
但是当我开始打字16，
17，第18，千字符串，

702
00:30:34,970 --> 00:30:37,390
这里是该字符串将要结束？

703
00:30:37,390 --> 00:30:39,570
这将结束部分在这里。

704
00:30:39,570 --> 00:30:42,820
但谁知道还有什么
超出了界限

705
00:30:42,820 --> 00:30:44,270
这个阵列呢？

706
00:30:44,270 --> 00:30:48,015
>> 这是因为虽然我
在这里宣布16箱。

707
00:30:48,015 --> 00:30:49,300

708
00:30:49,300 --> 00:30:52,690
因此，而不是画出来的所有16中，我们将
只是假装我画16。

709
00:30:52,690 --> 00:30:56,540
但是，如果我再尝试读取字符串
这是更长的时间，如50个字符，

710
00:30:56,540 --> 00:31:01,270
我要开始把
A，B，C，D，X，Y，Z。

711
00:31:01,270 --> 00:31:04,916
这大概是
其它一些内存段

712
00:31:04,916 --> 00:31:06,790
即，再次，可能会导致
我的程序崩溃，

713
00:31:06,790 --> 00:31:10,600
因为我没有要求
事情不止16个字节。

714
00:31:10,600 --> 00:31:12,260
>> 那么，谁在乎呢？

715
00:31:12,260 --> 00:31:13,880
好了，这里的CS50库。

716
00:31:13,880 --> 00:31:17,220
而且大部分这只是
类似的指令往上顶。

717
00:31:17,220 --> 00:31:21,670
该CS50库，这一切的时候，
已经有这一行52行。

718
00:31:21,670 --> 00:31:23,680
我们已经看到的typedef，或
你会看到的typedef

719
00:31:23,680 --> 00:31:27,930
在PSET 4，刚刚创建了一个
同义词其中焦炭明星可以更

720
00:31:27,930 --> 00:31:29,290
简称为字符串。

721
00:31:29,290 --> 00:31:31,540
因此，这是一个
数轮培训

722
00:31:31,540 --> 00:31:34,120
我们已经偷偷使用了引擎盖下方。

723
00:31:34,120 --> 00:31:36,490
>> 同时，这里的函数，getchar函数。

724
00:31:36,490 --> 00:31:38,190
现在很明显，没有身体吧。

725
00:31:38,190 --> 00:31:40,273
而事实上，如果我继续
滚动，我实际上并不

726
00:31:40,273 --> 00:31:42,080
看不到任何的实现
这些功能。

727
00:31:42,080 --> 00:31:43,140

728
00:31:43,140 --> 00:31:45,516
作为一个全面的检查，这是为什么？

729
00:31:45,516 --> 00:31:46,795
>> 听众：[听不清]。

730
00:31:46,795 --> 00:31:47,670
戴维·J·马兰：是的。

731
00:31:47,670 --> 00:31:48,950
因此，这是头文件。

732
00:31:48,950 --> 00:31:52,520
和头文件包含原型，
再加上一些其他的东西，现在看来，

733
00:31:52,520 --> 00:31:53,780
喜欢的类型定义。

734
00:31:53,780 --> 00:31:56,910
但在CS50.c，我们已经
从来没有给你顾左右而言他，

735
00:31:56,910 --> 00:32:02,100
但一直在CS50所有家电
这个时候，内心深处的文件夹，

736
00:32:02,100 --> 00:32:04,990
注意到有一个整体
在这里一堆功能。

737
00:32:04,990 --> 00:32:06,720
>> 事实上，我们向下滚动。

738
00:32:06,720 --> 00:32:08,810
让我们忽略了他们中的大多数现在。

739
00:32:08,810 --> 00:32:12,670
但是，向下滚动到调用getInt
看看调用getInt是如何工作的。

740
00:32:12,670 --> 00:32:13,890
因此，这里是调用getInt。

741
00:32:13,890 --> 00:32:17,727
如果你真的关心如何获得
INT作品，这里是它的文档。

742
00:32:17,727 --> 00:32:19,560
而当中的事
它说的是它告诉你

743
00:32:19,560 --> 00:32:21,340
什么值的范围就可以返回。

744
00:32:21,340 --> 00:32:24,400
它本质上是负面的2十亿
以正面的2十亿，给予或采取。

745
00:32:24,400 --> 00:32:26,420
>> 而事实证明，这一切
时间，即使我们从来没有

746
00:32:26,420 --> 00:32:28,570
有了你检查它，
如果出现错误，

747
00:32:28,570 --> 00:32:30,680
事实证明，所有的
此时，调用getInt有

748
00:32:30,680 --> 00:32:33,600
已返回一个特殊的
常量，不为空，

749
00:32:33,600 --> 00:32:36,760
而是INT_MAX，这是
只是一个程序员的约定。

750
00:32:36,760 --> 00:32:38,846
这意味着这里是一个特殊的值。

751
00:32:38,846 --> 00:32:41,470
请一定要检查这一点，只是
在出错的时候。

752
00:32:41,470 --> 00:32:43,261
但是，我们从来没有困扰
同的是，到目前为止，

753
00:32:43,261 --> 00:32:45,200
因为再次，这
是为了简化。

754
00:32:45,200 --> 00:32:46,950
>> 但如何调用getInt得到实施？

755
00:32:46,950 --> 00:32:48,450
嗯，一，它不带任何参数。

756
00:32:48,450 --> 00:32:49,390
我们知道这一点。

757
00:32:49,390 --> 00:32:50,820
它返回一个int。

758
00:32:50,820 --> 00:32:51,950
我们知道这一点。

759
00:32:51,950 --> 00:32:54,460
那么它是怎样的引擎盖底下工作？

760
00:32:54,460 --> 00:32:58,290
>> 所以这是很明显的无限
环，其中一个至少外观。

761
00:32:58,290 --> 00:33:00,290
请注意，我们使用的getString。

762
00:33:00,290 --> 00:33:04,000
所以这很有趣。调用getInt
调用我们自己的函数，的getString。

763
00:33:04,000 --> 00:33:05,645
现在为什么会变成这样？

764
00:33:05,645 --> 00:33:07,400

765
00:33:07,400 --> 00:33:09,842
为什么我会被防守
在这里行165？

766
00:33:09,842 --> 00:33:11,390

767
00:33:11,390 --> 00:33:15,639
哪些本着可能发生
164，只是要清楚吗？

768
00:33:15,639 --> 00:33:16,930
这是同样的答案和以前一样。

769
00:33:16,930 --> 00:33:18,660

770
00:33:18,660 --> 00:33:20,089
可能仅仅是内存不足。

771
00:33:20,089 --> 00:33:23,130
不顺心的事了的getString，
我们必须能够处理的。

772
00:33:23,130 --> 00:33:27,070
而我之所以不返回null是
即，在技术上，空是一个指针。

773
00:33:27,070 --> 00:33:29,120
调用getInt必须返回一个int。

774
00:33:29,120 --> 00:33:31,060
所以我随意
决定，从本质上讲，

775
00:33:31,060 --> 00:33:34,600
有2十亿，而奋斗，是怎么回事
是一种特殊的价值，我永远不可能

776
00:33:34,600 --> 00:33:35,970
其实获取用户。

777
00:33:35,970 --> 00:33:39,930
这只是一个价值我要去
浪费，代表一个错误代码。

778
00:33:39,930 --> 00:33:41,540
>> 所以，现在，事情变得有点奇特。

779
00:33:41,540 --> 00:33:44,670
它不是完全一样的功能
和以前一样，但它是非常相似的。

780
00:33:44,670 --> 00:33:50,120
所以请注意，我在这里声明，符合
172，无论是一个int n和一个char℃。

781
00:33:50,120 --> 00:33:53,600
然后我用这个时髦的路线，
sscanf的，它原来

782
00:33:53,600 --> 00:33:55,990
不扫描从键盘输入的字符串。

783
00:33:55,990 --> 00:33:59,226
它代表着现有的字符串
用户已经键入英寸

784
00:33:59,226 --> 00:34:02,100
所以，我已经叫的getString，这
意味着我有一个字符串在内存中。

785
00:34:02,100 --> 00:34:05,020
sscanf的是什么，你会
调用解析函数。

786
00:34:05,020 --> 00:34:07,760
它着眼于我有串
键入，字符一个字符，

787
00:34:07,760 --> 00:34:09,250
并做一些有用的东西。

788
00:34:09,250 --> 00:34:10,969
该字符串被存储在一行。

789
00:34:10,969 --> 00:34:13,560
我知道，只有通过去
备份在这里，说，哦，好吧，

790
00:34:13,560 --> 00:34:15,143
我把它叫做不发这个时间，但行。

791
00:34:15,143 --> 00:34:15,989

792
00:34:15,989 --> 00:34:18,080
>> 而现在，这是一个有点不同。

793
00:34:18,080 --> 00:34:22,480
但是这实际上意味着，其原因
我们会有点潮手在今天，

794
00:34:22,480 --> 00:34:26,070
我们正在检查
查看该用户键入

795
00:34:26,070 --> 00:34:29,909
与诠释，也许另一个字符。

796
00:34:29,909 --> 00:34:33,610
如果用户输入了一个int，它的
将要被存储在正，因为我

797
00:34:33,610 --> 00:34:36,739
按地址传递这一点，
今天我们看到的新把戏。

798
00:34:36,739 --> 00:34:41,570
如果用户还输入
像123x，使得x

799
00:34:41,570 --> 00:34:45,060
将要结束了
字母字符c。

800
00:34:45,060 --> 00:34:48,739
>> 现在事实证明，sscanf的
告诉我，智能化，

801
00:34:48,739 --> 00:34:54,750
多少个变量是sscanf的
能够成功地填补。

802
00:34:54,750 --> 00:34:58,770
所以通过这种逻辑，如果该函数
我实施的调用getInt，

803
00:34:58,770 --> 00:35:00,900
但我检查，
潜在地，对于用户

804
00:35:00,900 --> 00:35:04,190
已经输入了一个int
其次是别的东西，

805
00:35:04,190 --> 00:35:08,580
什么才是我想要的sscanf的
返回值真的是？

806
00:35:08,580 --> 00:35:10,950
如果目的是要获得
只是从用户的诠释？

807
00:35:10,950 --> 00:35:13,980

808
00:35:13,980 --> 00:35:19,300
>> 所以，如果sscanf的回报
2，是什么意思呢？

809
00:35:19,300 --> 00:35:21,660
用户键入
是这样，从字面上看，

810
00:35:21,660 --> 00:35:24,770
123x，这只是无稽之谈。

811
00:35:24,770 --> 00:35:27,490
这是一个错误，并
我要检查的。

812
00:35:27,490 --> 00:35:32,960
>> 因此，如果这在用户的类型，由
这个逻辑有哪些呢sscanf的回报，

813
00:35:32,960 --> 00:35:33,740
你会说什么？

814
00:35:33,740 --> 00:35:35,070

815
00:35:35,070 --> 00:35:39,130
所以它会返回2，因为
123是要去这里，

816
00:35:39,130 --> 00:35:41,580
而X是要结束在这里。

817
00:35:41,580 --> 00:35:43,970
但我不想在x得到填补。

818
00:35:43,970 --> 00:35:48,580
我想，sscanf会只成功
灌装头的变量。

819
00:35:48,580 --> 00:35:52,490
所以这就是为什么我
想sscanf会返回1。

820
00:35:52,490 --> 00:35:55,750
>> 如果这是有点在头上
就目前而言，这是完全正常。

821
00:35:55,750 --> 00:36:00,030
意识到虽然，其中一个
调用getInt和GetString值

822
00:36:00,030 --> 00:36:03,630
就是我们正在做的啦！
很多错误检查这样使

823
00:36:03,630 --> 00:36:07,130
是，到今天为止，你几乎可以
在你的键盘输入任何东西，

824
00:36:07,130 --> 00:36:08,490
我们会抓住它。

825
00:36:08,490 --> 00:36:10,592
我们肯定的是，
工作人员，肯定不会

826
00:36:10,592 --> 00:36:13,300
在一个错误的来源你
计划，因为我们的防守

827
00:36:13,300 --> 00:36:16,270
检查所有的愚蠢的
的东西，用户可能会做，

828
00:36:16,270 --> 00:36:18,900
如输入一个字符串，当
你真的想要诠释。

829
00:36:18,900 --> 00:36:21,350
因此，对于now--我们就来
回此之前long--

830
00:36:21,350 --> 00:36:23,710
但是这一切的时候，
的getString和调用getInt有

831
00:36:23,710 --> 00:36:29,950
在使用这种发动机罩下方
内存地址的基本思路。

832
00:36:29,950 --> 00:36:32,580
>> 所以，现在，让我们把事情
对用户来说更加友好。

833
00:36:32,580 --> 00:36:38,740
您可能还记得，从去年宾基
时间 - 如果我的鼠标会cooperate--所以

834
00:36:38,740 --> 00:36:42,560
我们有这个代码，这
坦率地说，是相当荒谬的。

835
00:36:42,560 --> 00:36:45,330
此代码实现了什么
有用的，但它是例子

836
00:36:45,330 --> 00:36:48,330
该教授Parlante
为了表示用于

837
00:36:48,330 --> 00:36:51,840
什么样的是怎么回事
项目涉及内存。

838
00:36:51,840 --> 00:36:54,850
>> 因此，让我们复述这
故事超简要介绍。

839
00:36:54,850 --> 00:36:58,720
这些前两行，在
英语，做什么，会说什么？

840
00:36:58,720 --> 00:37:01,230

841
00:37:01,230 --> 00:37:05,430
就在合理的人，但
稍微专业术语，取刺。

842
00:37:05,430 --> 00:37:06,346
听众：[听不清]。

843
00:37:06,346 --> 00:37:07,705

844
00:37:07,705 --> 00:37:11,080
>> 戴维·J·马兰：好，你确定
地址为你的x和y变量。

845
00:37:11,080 --> 00:37:15,520
不大，因为x和y是未
变量在传统意义上的。

846
00:37:15,520 --> 00:37:18,054
x和y是地址
或者将存储地址。

847
00:37:18,054 --> 00:37:19,220
因此，让我们试试这个一次。

848
00:37:19,220 --> 00:37:21,010
不是一个糟糕的开局，但。

849
00:37:21,010 --> 00:37:21,510
是吗？

850
00:37:21,510 --> 00:37:22,426
>> 听众：[听不清]。

851
00:37:22,426 --> 00:37:23,966

852
00:37:23,966 --> 00:37:24,840
戴维·J·马兰：好。

853
00:37:24,840 --> 00:37:26,173
我认为这是一个小清洁。

854
00:37:26,173 --> 00:37:28,630
声明两个三分球，两个整数。

855
00:37:28,630 --> 00:37:30,150
而我们称他们为x和y。

856
00:37:30,150 --> 00:37:32,790
或者，如果我们画
此为图片，再

857
00:37:32,790 --> 00:37:36,410
记得很简单，所有
我们正在做的与第一线

858
00:37:36,410 --> 00:37:39,690
正在制定一个盒子这样的，
在它的一些垃圾的价值，

859
00:37:39,690 --> 00:37:41,920
并调用它的X，然后
另一个盒子这样的，

860
00:37:41,920 --> 00:37:43,880
与一些垃圾值
它，叫它年。

861
00:37:43,880 --> 00:37:45,810
我们已经声明了两个
三分球，最终

862
00:37:45,810 --> 00:37:47,860
将存储一个int的地址。

863
00:37:47,860 --> 00:37:49,170
所以这一切都在那里。

864
00:37:49,170 --> 00:37:53,290
>> 所以当宾基这样做，则
粘土只是看着这样的。

865
00:37:53,290 --> 00:37:55,350
和尼克刚种
包裹起来的箭，

866
00:37:55,350 --> 00:37:57,590
仿佛他们不是指向任何地方
特别是，因为他们只是

867
00:37:57,590 --> 00:37:58,250
垃圾值。

868
00:37:58,250 --> 00:38:01,670
他们没有明确的初始化
任何地方尤其如此。

869
00:38:01,670 --> 00:38:03,980
>> 现在的下一行
代码，召回，是这样的。

870
00:38:03,980 --> 00:38:07,510
因此，在合理的人性化，
但有些技术英语，

871
00:38:07,510 --> 00:38:09,790
什么是这行代码在做什么？

872
00:38:09,790 --> 00:38:10,391
是吗？

873
00:38:10,391 --> 00:38:11,333
>> 听众：[听不清]。

874
00:38:11,333 --> 00:38:12,746

875
00:38:12,746 --> 00:38:13,950
>> 戴维·J·马兰：完美。

876
00:38:13,950 --> 00:38:17,016
它分配的大块
内存是一个int的大小。

877
00:38:17,016 --> 00:38:18,140
而这一半的答案。

878
00:38:18,140 --> 00:38:20,056
你回答正确
一半的表情。

879
00:38:20,056 --> 00:38:22,473
什么是发生在
等号左边？

880
00:38:22,473 --> 00:38:22,972
是吗？

881
00:38:22,972 --> 00:38:24,814
听众：和受让人
它给变量x？

882
00:38:24,814 --> 00:38:27,690
>> 戴维·J·马兰：和受让人
它给变量x。

883
00:38:27,690 --> 00:38:31,650
总括来说，右侧会分配
足够的内存来存储一个int。

884
00:38:31,650 --> 00:38:34,150
但具体的malloc
返回地址

885
00:38:34,150 --> 00:38:37,270
这大块的内存，您已中
只是建议被存放在X。

886
00:38:37,270 --> 00:38:42,560
>> 那么，尼克做了最后一次带宾基是
他拖着那指针移出，粘土，

887
00:38:42,560 --> 00:38:46,820
现在指向一个内存块白
等于一个int的大小。

888
00:38:46,820 --> 00:38:49,360
事实上，这意味着
来表示四个字节。

889
00:38:49,360 --> 00:38:55,310
>> 现在，代码的下一行
这样做，星x被42。

890
00:38:55,310 --> 00:38:58,530
所以42是简单的
右手侧，生活的含义。

891
00:38:58,530 --> 00:39:00,500
左侧，星x表示什么？

892
00:39:00,500 --> 00:39:01,600

893
00:39:01,600 --> 00:39:03,280
这也可能gone--没关系。

894
00:39:03,280 --> 00:39:04,220
行。

895
00:39:04,220 --> 00:39:06,875
>> 听众：基本上，
进入[听不清]

896
00:39:06,875 --> 00:39:07,750
戴维·J·马兰：好。

897
00:39:07,750 --> 00:39:08,760
听众：[听不清]。

898
00:39:08,760 --> 00:39:09,760
戴维·J·马兰：没错。

899
00:39:09,760 --> 00:39:11,979
左手边是指去为x。

900
00:39:11,979 --> 00:39:12,520
x是地址。

901
00:39:12,520 --> 00:39:15,520
这就像33牛津街，或OX1。

902
00:39:15,520 --> 00:39:18,690
和星x表示去那家
解决和放什么呢？

903
00:39:18,690 --> 00:39:19,520
42。

904
00:39:19,520 --> 00:39:21,290
>> 所以，事实上，这正是尼克做了。

905
00:39:21,290 --> 00:39:23,740
他开始用，
本质上，精神上

906
00:39:23,740 --> 00:39:26,270
用手指指着
的x，下面的箭头

907
00:39:26,270 --> 00:39:30,670
到右侧的白框
侧，并且把数42那里。

908
00:39:30,670 --> 00:39:34,120
但后来事情得到了
有点危险吧？

909
00:39:34,120 --> 00:39:35,860
宾基的即将失去他的头。

910
00:39:35,860 --> 00:39:39,465
>> 星y等于13，运气不好，意味着什么？

911
00:39:39,465 --> 00:39:43,620
所以，明星y表示去的地址y中。

912
00:39:43,620 --> 00:39:45,630
但是，什么是Y中的地址？

913
00:39:45,630 --> 00:39:47,899

914
00:39:47,899 --> 00:39:49,440
好吧，这是垃圾的价值，对不对？

915
00:39:49,440 --> 00:39:50,800
我画它作为一个问号。

916
00:39:50,800 --> 00:39:54,850
尼克画了它作为一个蜷缩箭头。

917
00:39:54,850 --> 00:39:59,600
而且只要你尝试
做明星Y，说去那里，

918
00:39:59,600 --> 00:40:03,872
但没有一个合法的
地址，它的一些虚假的位置，

919
00:40:03,872 --> 00:40:05,080
该计划的要崩溃。

920
00:40:05,080 --> 00:40:08,580
和宾基的头部会
飞了出去，在这里，因为它没有。

921
00:40:08,580 --> 00:40:12,130
>> 所以，最后，这个方案
只是平了破绽。

922
00:40:12,130 --> 00:40:13,540
这是一个错误的程序。

923
00:40:13,540 --> 00:40:14,760
它需要加以固定。

924
00:40:14,760 --> 00:40:18,260
而唯一的办法，真的，要解决它
将是，举例来说，这条线，

925
00:40:18,260 --> 00:40:21,010
我们甚至没有去，因为
程序崩溃得太快。

926
00:40:21,010 --> 00:40:26,170
但是，如果我们要解决这个问题，有什么
效果确实做Ÿ等于x具有？

927
00:40:26,170 --> 00:40:30,010
那么，它基本上是在点ÿ
任何值x指向。

928
00:40:30,010 --> 00:40:32,430
>> 因此，在尼克的故事，
或宾基的故事，无论是

929
00:40:32,430 --> 00:40:34,640
x和y分别为指向
白色块的存储器，

930
00:40:34,640 --> 00:40:38,300
这样一来，最终，当
做明星Ÿ再次等于13，

931
00:40:38,300 --> 00:40:43,080
你最终将在13
适当的位置。

932
00:40:43,080 --> 00:40:47,640
因此，所有这些线路都完美
合法的，除了这一个，

933
00:40:47,640 --> 00:40:51,730
之前，当它发生
实际分配Ÿ一定的价值。

934
00:40:51,730 --> 00:40:54,290
>> 现在值得庆幸的是，你不
要通过推理全部

935
00:40:54,290 --> 00:40:56,560
这些类型的问题你自己。

936
00:40:56,560 --> 00:40:59,310
让我继续前进，开
在这里一个终端窗口

937
00:40:59,310 --> 00:41:03,050
与开拓，就一下，
超级短节目的

938
00:41:03,050 --> 00:41:04,360
也就是那种毫无意义的。

939
00:41:04,360 --> 00:41:05,152
这是丑陋的。

940
00:41:05,152 --> 00:41:06,610
它没有实现任何用处。

941
00:41:06,610 --> 00:41:10,180
但它确实证明问题
记忆，让我们一起来看看。

942
00:41:10,180 --> 00:41:11,830
>> 主要的，超级简单。

943
00:41:11,830 --> 00:41:14,830
这显然​​是调用一个函数，
F，然后返回0。

944
00:41:14,830 --> 00:41:16,310
这是一种很难搞砸。

945
00:41:16,310 --> 00:41:18,540
所以，主要是相当不错的，到目前为止。

946
00:41:18,540 --> 00:41:20,100
>> 所以f是有问题的。

947
00:41:20,100 --> 00:41:22,120
只是没放多少
努力为它命名

948
00:41:22,120 --> 00:41:23,990
在这里，以保持重心的代码。

949
00:41:23,990 --> 00:41:25,740
f有两行。

950
00:41:25,740 --> 00:41:27,610
让我们看看现在怎么回事。

951
00:41:27,610 --> 00:41:29,840
这样一方面
这里 - 并让我

952
00:41:29,840 --> 00:41:32,680
与前此一致
example--一方面，

953
00:41:32,680 --> 00:41:35,830
左手侧是
做什么，用英语？

954
00:41:35,830 --> 00:41:36,493
它is--

955
00:41:36,493 --> 00:41:37,701
听众：创建一个指针。

956
00:41:37,701 --> 00:41:40,830
戴维·J·马兰：创建一个指针
为int，把它x即可。

957
00:41:40,830 --> 00:41:43,789
因此，它的创造者一个箱子
我一直画在触摸屏上。

958
00:41:43,789 --> 00:41:45,913
现在，对右手
当然一面，malloc的，

959
00:41:45,913 --> 00:41:47,420
被分配的内存块。

960
00:41:47,420 --> 00:41:49,989
而只是要清楚，怎么
多少内存是它明显

961
00:41:49,989 --> 00:41:52,030
分配，如果你只是
种做数学题吗？

962
00:41:52,030 --> 00:41:53,200

963
00:41:53,200 --> 00:41:54,040
>> 因此，它是40个字节。

964
00:41:54,040 --> 00:41:57,400
我知道，只是因为我知道的
整数，在CS50器具，至少

965
00:41:57,400 --> 00:41:58,060
是四个字节。

966
00:41:58,060 --> 00:41:59,610
所以，10次4 40。

967
00:41:59,610 --> 00:42:04,924
所以这是存储一个x，地址
第一次出40的整数

968
00:42:04,924 --> 00:42:07,340
已分配的空间回来了，
背，背，背来。

969
00:42:07,340 --> 00:42:08,470
>> 而这正是重点对malloc的。

970
00:42:08,470 --> 00:42:11,261
它并不需要一点点内存
在这里，有一点在这里，在这里一点点。

971
00:42:11,261 --> 00:42:14,220
它为您提供了一个内存块，
连续地，从操作

972
00:42:14,220 --> 00:42:15,240
系统。

973
00:42:15,240 --> 00:42:18,500
>> 现在来谈谈这个，
点¯x支架10等于0？

974
00:42:18,500 --> 00:42:19,470
独断专行的代码。

975
00:42:19,470 --> 00:42:21,100
它没有实现任何用处。

976
00:42:21,100 --> 00:42:26,128
但有意思的是，
因为变量x支架10--？

977
00:42:26,128 --> 00:42:26,628
是吗？

978
00:42:26,628 --> 00:42:27,912
>> 听众：[听不清]？

979
00:42:27,912 --> 00:42:30,500
>> 戴维·J·马兰：X支架
10不必是空的。

980
00:42:30,500 --> 00:42:35,070
空的细节只有进场
用字符串，在字符串的结尾。

981
00:42:35,070 --> 00:42:36,700
但一个好的想法。

982
00:42:36,700 --> 00:42:39,615
>> 有多大这个数组，甚至
虽然我已经分配40个字节？

983
00:42:39,615 --> 00:42:42,560

984
00:42:42,560 --> 00:42:43,690
这是从0到9，对不对？

985
00:42:43,690 --> 00:42:45,120
这10个整数，总。

986
00:42:45,120 --> 00:42:48,790
40个字节，但是10个整数，
索引0到0。

987
00:42:48,790 --> 00:42:50,930
>> 那么，什么是是X支架10？

988
00:42:50,930 --> 00:42:53,090
它实际上是一些
未知的垃圾值。

989
00:42:53,090 --> 00:42:54,780
这是一个不属于我的记忆。

990
00:42:54,780 --> 00:42:59,650
我不应该碰的
字节数41，42，43，44。

991
00:42:59,650 --> 00:43:01,420
我会稍微有点远。

992
00:43:01,420 --> 00:43:04,490
>> 事实上，如果我运行这个
程序时，它很可能会崩溃。

993
00:43:04,490 --> 00:43:05,790
但有时，我们会得到幸运。

994
00:43:05,790 --> 00:43:07,706
所以，只是为了演示
this--坦率地说，

995
00:43:07,706 --> 00:43:11,000
你永远不知道你之前
做它 - 让我们来运行的。

996
00:43:11,000 --> 00:43:12,480
它实际上并没有崩溃。

997
00:43:12,480 --> 00:43:15,032
>> 但是，如果我改变这一状况，为
例如，要像千，

998
00:43:15,032 --> 00:43:16,740
使这真的
故意的，让我们来看看

999
00:43:16,740 --> 00:43:18,710
如果我们可以得到它的崩溃这个时候。

1000
00:43:18,710 --> 00:43:20,070
好吧，它没有崩溃。

1001
00:43:20,070 --> 00:43:22,600
如何约10万？

1002
00:43:22,600 --> 00:43:25,000
让我们来改造它，现在重新运行它。

1003
00:43:25,000 --> 00:43:25,500
行。

1004
00:43:25,500 --> 00:43:25,960
唷。

1005
00:43:25,960 --> 00:43:26,460
好吧。

1006
00:43:26,460 --> 00:43:29,090
因此很明显，同样，这些
内存段，可以这么说，

1007
00:43:29,090 --> 00:43:32,660
是相当大的，所以我们可以
一次又一次得到幸运。

1008
00:43:32,660 --> 00:43:36,510
但最终，一旦你得到可笑
真正炎等在屏幕上，

1009
00:43:36,510 --> 00:43:39,120
你触摸记忆真的，
真的不属于你。

1010
00:43:39,120 --> 00:43:40,870
>> 但坦率地说，这些
种虫子会

1011
00:43:40,870 --> 00:43:43,020
是难当
找出你自己的。

1012
00:43:43,020 --> 00:43:47,880
不过，值得庆幸的是，作为程序员，我们有
工具，使我们能够做到这一点的我们。

1013
00:43:47,880 --> 00:43:50,140
因此，这是，也许是一
最丑的节目，

1014
00:43:50,140 --> 00:43:52,060
比gdb的输出，甚至丑陋。

1015
00:43:52,060 --> 00:43:55,670
但它总有一条线或
2是超级有用。

1016
00:43:55,670 --> 00:44:00,310
>> Valgrind是一个程序，可以帮助
你没有调试一个程序，本身

1017
00:44:00,310 --> 00:44:03,500
但是发现内存相关
的问题，特别是。

1018
00:44:03,500 --> 00:44:07,590
它会自动运行您的代码
你看，至少两件事情。

1019
00:44:07,590 --> 00:44:10,680
一，你做了什么
偶然像触摸记忆

1020
00:44:10,680 --> 00:44:11,980
那不属于你？

1021
00:44:11,980 --> 00:44:13,590
这将帮助你找到这些情况。

1022
00:44:13,590 --> 00:44:15,710
>> 其二，它会帮助
你发现了一种叫做

1023
00:44:15,710 --> 00:44:19,270
内存泄露，我们有
全然不顾，天真，

1024
00:44:19,270 --> 00:44:21,380
一段时间和幸​​福地。

1025
00:44:21,380 --> 00:44:23,140
但事实证明，所有的
此时，每当

1026
00:44:23,140 --> 00:44:26,620
你所谓的getString在
我们这么多的节目，

1027
00:44:26,620 --> 00:44:28,930
你问工作
系统记忆体，

1028
00:44:28,930 --> 00:44:32,070
但你有什么回忆
有史以来给它

1029
00:44:32,070 --> 00:44:36,169
回来了，做unalloc，或
免费的，因为它的调用。

1030
00:44:36,169 --> 00:44:37,960
没有，因为我们从来没有
要求你这样做。

1031
00:44:37,960 --> 00:44:41,250
>> 但所有这一次，程序
你一直在写C语言

1032
00:44:41,250 --> 00:44:43,800
已经泄漏内存，
要求经营

1033
00:44:43,800 --> 00:44:46,190
系统越来越
存储字符串和诸如此类的东西，

1034
00:44:46,190 --> 00:44:47,870
但从来没有递了回去。

1035
00:44:47,870 --> 00:44:50,080
而现在，这是一个有点
à简单化的，

1036
00:44:50,080 --> 00:44:53,550
但如果你曾经运行在Mac或
你的电脑很长一段时间，开

1037
00:44:53,550 --> 00:44:55,790
大量的节目，
也许关闭程序，

1038
00:44:55,790 --> 00:44:57,795
而即使你的
电脑没有死机，

1039
00:44:57,795 --> 00:45:01,690
它变得这么慢得多，
好像真的

1040
00:45:01,690 --> 00:45:04,290
使用大量的内存或
资源，即使，

1041
00:45:04,290 --> 00:45:06,070
如果你不连
触摸键盘，

1042
00:45:06,070 --> 00:45:10,430
可能be--但不always--能
是因为你正在运行的程序

1043
00:45:10,430 --> 00:45:11,920
有自己的内存泄漏。

1044
00:45:11,920 --> 00:45:15,645
他们不断地问操作系统的更多，
更多的内存，但忘记了它，

1045
00:45:15,645 --> 00:45:18,470
实际上并不使用它，但
因此，服用内存离开

1046
00:45:18,470 --> 00:45:20,500
从可能希望它的其他程序。

1047
00:45:20,500 --> 00:45:23,940
所以这是一个常见的​​解释。

1048
00:45:23,940 --> 00:45:25,940
现在，这里的地方Valgrind的公司
输出是完全

1049
00:45:25,940 --> 00:45:29,290
残暴的那些少
更舒适的一致好评。

1050
00:45:29,290 --> 00:45:32,690
但有趣
东西是正确的在这里。

1051
00:45:32,690 --> 00:45:37,060
它告诉我一个无效的写
大小4发生这个程序中，

1052
00:45:37,060 --> 00:45:40,640
特别是，在memory.c的第21行。

1053
00:45:40,640 --> 00:45:45,450
>> 如果我去到第21行，嗯，的确有
是大小为4的无效写。

1054
00:45:45,450 --> 00:45:46,250
为什么大小4？

1055
00:45:46,250 --> 00:45:49,500
那么，这number--它
可能是anything--是一个int。

1056
00:45:49,500 --> 00:45:50,450
因此，这四个字节。

1057
00:45:50,450 --> 00:45:52,550
所以，我把四个字节
他们不属于。

1058
00:45:52,550 --> 00:45:55,080
这就是Valgrind的
实际上是告诉我。

1059
00:45:55,080 --> 00:45:57,600
此外，它也将
告诉我，因为我们将看到，

1060
00:45:57,600 --> 00:46:01,490
当你运行这个在未来的PSET，如果和
当你的内存泄漏，这确实是

1061
00:46:01,490 --> 00:46:05,300
我有，因为我打过电话
malloc的，但我并没有实际

1062
00:46:05,300 --> 00:46:08,010
叫，在这种情况下，自由
我们最终会看到

1063
00:46:08,010 --> 00:46:09,830
是的malloc相反。

1064
00:46:09,830 --> 00:46:10,860

1065
00:46:10,860 --> 00:46:12,930
>> 所以，现在，我认为，最后一个例子。

1066
00:46:12,930 --> 00:46:14,050

1067
00:46:14,050 --> 00:46:16,690
所以这一块是一个有点多
晦涩难懂，但它也许是

1068
00:46:16,690 --> 00:46:19,180
最大的原因
小心内存，

1069
00:46:19,180 --> 00:46:24,490
究其原因，很多节目
和/或Web服务器，甚至到今天，

1070
00:46:24,490 --> 00:46:28,200
被接管坏人的地方
在互联网上谁是莫名其妙

1071
00:46:28,200 --> 00:46:33,390
发送伪造的数据包到服务​​器
试图破坏您的账户，

1072
00:46:33,390 --> 00:46:36,420
或者把你的数据，或只是
一般拿过来一台机器。

1073
00:46:36,420 --> 00:46:38,910
缓冲区溢出，随着
顾名思义，手段

1074
00:46:38,910 --> 00:46:40,740
不溢出为int，而是一个缓冲区。

1075
00:46:40,740 --> 00:46:43,490
和缓冲仅仅是一个奇特的方式
的说这是一串记忆。

1076
00:46:43,490 --> 00:46:46,710
>> 事实上，我叫一个字符串
前缓冲区，而不是S，。

1077
00:46:46,710 --> 00:46:49,234
因为如果它是一个缓冲，
像在YouTube的意义，

1078
00:46:49,234 --> 00:46:52,400
或者您正在观看的视频的任何时间，
你可能已经看到这个词的缓冲，

1079
00:46:52,400 --> 00:46:53,040
点，点，点。

1080
00:46:53,040 --> 00:46:54,240
这是令人难以置信的烦人。

1081
00:46:54,240 --> 00:46:55,990
而这仅仅意味着
您的视频播放器

1082
00:46:55,990 --> 00:46:58,710
试图下载大量
字节，大量的字节

1083
00:46:58,710 --> 00:47:00,170
从网上的视频。

1084
00:47:00,170 --> 00:47:02,920
但它是缓慢的，所以它的尝试
下载了一堆人

1085
00:47:02,920 --> 00:47:06,430
填充缓冲器，一个容器，从而使
你有足够的字节，它可以再

1086
00:47:06,430 --> 00:47:09,174
告诉你的视频，
不停顿不断。

1087
00:47:09,174 --> 00:47:11,340
但事实证明，你可以
有一个缓冲，以这个大。

1088
00:47:11,340 --> 00:47:15,710
但尽量把这么多数据
微博，很糟糕的事情可能发生。

1089
00:47:15,710 --> 00:47:22,780
因此，例如，让我们来看看
一个例子的这个最终预告片。

1090
00:47:22,780 --> 00:47:24,720
这是另一种方案
即，乍一看，

1091
00:47:24,720 --> 00:47:26,540
什么都不做超级有用。

1092
00:47:26,540 --> 00:47:29,590
它有一个主要功能
调用该函数f。

1093
00:47:29,590 --> 00:47:36,640
而且函数f，在这里，有
一个char数组，称为大小12℃，。

1094
00:47:36,640 --> 00:47:39,340
然后它用这个
新的函数调用strncpy（）函数。

1095
00:47:39,340 --> 00:47:40,430

1096
00:47:40,430 --> 00:47:45,190
>> 事实证明，这种简单
代码简单的线条，只是两条线，

1097
00:47:45,190 --> 00:47:49,130
我们已经做了我的整个程序，
因此，我的整个电脑，

1098
00:47:49,130 --> 00:47:54,000
我的用户帐户，我的硬盘
开车可能受到任何人

1099
00:47:54,000 --> 00:47:58,170
谁知道，是不够好，运行
这个节目带有一定的命令行

1100
00:47:58,170 --> 00:47:58,900
的说法。

1101
00:47:58,900 --> 00:48:03,400
换句话说，如果这个坏家伙
通过键入把argvargv [1]内

1102
00:48:03,400 --> 00:48:08,750
在键盘非常特制
字符串，而不是ABC，123，但本质上，

1103
00:48:08,750 --> 00:48:15,180
代表可执行的二进制符号
代码，一个程序，他或她写道：

1104
00:48:15,180 --> 00:48:19,190
用这种简单的方案，这是
代表的数以千计的节目

1105
00:48:19,190 --> 00:48:23,610
这同样是脆弱的，敢说，
他或她可以最终删除所有

1106
00:48:23,610 --> 00:48:26,680
在我的硬盘驱动器中的文件，得到了
闪烁提示，以便他或她可以

1107
00:48:26,680 --> 00:48:30,170
自己输入命令，
电子邮件中的所有文件到自己。

1108
00:48:30,170 --> 00:48:34,660
什么我可以做的，他
或她可以使用此代码做。

1109
00:48:34,660 --> 00:48:36,575
>> 我们不太解决这事。

1110
00:48:36,575 --> 00:48:38,700
而事实上，这将
涉及小图片

1111
00:48:38,700 --> 00:48:41,470
这样，我们将很快到来
理解就更好了。

1112
00:48:41,470 --> 00:48:44,480
但是今天，让我们结束
什么是有希望稍微

1113
00:48:44,480 --> 00:48:48,360
可以理解的XKCD笑话，
直到我们重新开始下一次。

1114
00:48:48,360 --> 00:48:51,100

1115
00:48:51,100 --> 00:48:51,600
好吧。

1116
00:48:51,600 --> 00:48:53,446
星期三见。

1117
00:48:53,446 --> 00:48:54,754
>> [音乐播放]

1118
00:48:54,754 --> 00:48:57,790
>> 演讲嘉宾：现在，深
思想，通过Daven法纳姆。

1119
00:48:57,790 --> 00:49:00,890

1120
00:49:00,890 --> 00:49:04,770
记忆就像是跳进了一堆
金黄的树叶在周日下午。

1121
00:49:04,770 --> 00:49:09,000
风拂过，你折腾
hair--哦，我怀念的日子when--

1122
00:49:09,000 --> 00:49:11,100

1123
00:49:11,100 --> 00:49:12,650
>> [笑]

1124
00:49:12,650 --> 00:49:13,750