1
00:00:00,000 --> 00:00:03,395
>> [音乐播放]

2
00:00:03,395 --> 00:00:11,031

3
00:00:11,031 --> 00:00:13,280
DAVID J.马兰：这就像
一个新生研讨会今天。

4
00:00:13,280 --> 00:00:14,060
行。

5
00:00:14,060 --> 00:00:15,024
因此大雨了。

6
00:00:15,024 --> 00:00:17,690
这往往发生在星期三，
但所有的更多机会

7
00:00:17,690 --> 00:00:18,700
对于今天的问题。

8
00:00:18,700 --> 00:00:22,210
因此，让我们开始实际
有一会儿就好了这部电影。

9
00:00:22,210 --> 00:00:24,560
但是，我们将隆重启动一如既往。

10
00:00:24,560 --> 00:00:28,000
>> 这是CS50，这
是4周结束。

11
00:00:28,000 --> 00:00:30,820
所以，如果你曾经看过
电视或电影，其中

12
00:00:30,820 --> 00:00:34,690
有一些计算机专家，
警察，或者FBI，或者一些机构

13
00:00:34,690 --> 00:00:36,930
试图捕捉一些
对手，嗯，你已经

14
00:00:36,930 --> 00:00:40,850
大概听过这句话“提升”
因此该技术人员不知何故

15
00:00:40,850 --> 00:00:44,750
神奇地放大无限
远远的看到歹徒

16
00:00:44,750 --> 00:00:48,640
身份或车牌号
在镜子连微光

17
00:00:48,640 --> 00:00:50,390
或某人的眼睛闪闪发光。

18
00:00:50,390 --> 00:00:55,196
因此，我们确实，让我们一起来看看
一些这样的场景从好莱坞。

19
00:00:55,196 --> 00:00:55,862
[视频回放]

20
00:00:55,862 --> 00:00:59,243
 - 确定了，现在让我们好好看看你。

21
00:00:59,243 --> 00:01:06,488

22
00:01:06,488 --> 00:01:07,415
>> -拿住。

23
00:01:07,415 --> 00:01:08,267
运行该回来了。

24
00:01:08,267 --> 00:01:09,121
>> -等待一分钟。

25
00:01:09,121 --> 00:01:11,300
向右走。

26
00:01:11,300 --> 00:01:12,209
>> -there，冻结。

27
00:01:12,209 --> 00:01:12,750
-全屏。

28
00:01:12,750 --> 00:01:13,558
 - 确定，冻结。

29
00:01:13,558 --> 00:01:14,820
向上拧得过紧上，你会？

30
00:01:14,820 --> 00:01:16,530
 - 矢量在上
小伙的后轮。

31
00:01:16,530 --> 00:01:19,400
-zoom在这里在这一点上。

32
00:01:19,400 --> 00:01:22,846
 - 随着合适的设备，图像
可以扩大和激化。

33
00:01:22,846 --> 00:01:24,065
-那是什么？

34
00:01:24,065 --> 00:01:25,600
 - 它是一个提升计划。

35
00:01:25,600 --> 00:01:26,860
 - 你能清楚地表明了没有？

36
00:01:26,860 --> 00:01:27,890
-我不知道。

37
00:01:27,890 --> 00:01:29,050
让我们增强了。

38
00:01:29,050 --> 00:01:31,575
>>  - 增强部分A6。

39
00:01:31,575 --> 00:01:33,642
>> -I增强了细节，
而且 - 我认为有

40
00:01:33,642 --> 00:01:35,433
足以提升，
它释放到我的屏幕。

41
00:01:35,433 --> 00:01:37,080
-I增强了她的眼睛反射。

42
00:01:37,080 --> 00:01:38,830
>>  - 让我们通过运行此
视频增强。

43
00:01:38,830 --> 00:01:40,100
-Edgar，你可以加强这方面的？

44
00:01:40,100 --> 00:01:41,875
>> -不挂断。

45
00:01:41,875 --> 00:01:44,010
>> -I've这方面的工作思考。

46
00:01:44,010 --> 00:01:44,995
>> -Someone的反思。

47
00:01:44,995 --> 00:01:45,495
 - 反射。

48
00:01:45,495 --> 00:01:47,399
 - 存在就是男人的脸的反映。

49
00:01:47,399 --> 00:01:48,065
-The反映。

50
00:01:48,065 --> 00:01:48,981
 - 存在的一种反映。

51
00:01:48,981 --> 00:01:50,600
 - 放大上镜。

52
00:01:50,600 --> 00:01:52,712
 - 你可以看到一个反映。

53
00:01:52,712 --> 00:01:54,350
 - 你能在这里提升形象？

54
00:01:54,350 --> 00:01:55,370
 - 你能提高他在这里？

55
00:01:55,370 --> 00:01:56,210
 - 你能提升呢？

56
00:01:56,210 --> 00:01:56,900
你能提升呢？

57
00:01:56,900 --> 00:01:57,870
>>  - 能，我们加强这方面的？

58
00:01:57,870 --> 00:01:58,717
>>  - 你能提升呢？

59
00:01:58,717 --> 00:02:00,050
-hold在第二，我会提高。

60
00:02:00,050 --> 00:02:00,924
 - 放大在门上。

61
00:02:00,924 --> 00:02:01,700
-Times 10。

62
00:02:01,700 --> 00:02:02,586
-zoom。

63
00:02:02,586 --> 00:02:03,490
-move研究。

64
00:02:03,490 --> 00:02:03,990
-更多。

65
00:02:03,990 --> 00:02:04,690
-Wait，停止。

66
00:02:04,690 --> 00:02:05,190
-停止。

67
00:02:05,190 --> 00:02:05,970
-pause它。

68
00:02:05,970 --> 00:02:09,460
-rotate我们75度
绕垂直，请。

69
00:02:09,460 --> 00:02:10,962
-停止。

70
00:02:10,962 --> 00:02:14,040
返回到部分
关于门，再一次。

71
00:02:14,040 --> 00:02:15,860
>> -Got图像增强器，可以位图？

72
00:02:15,860 --> 00:02:18,776
>>  - 嘿，也许我们可以使用普拉迪普
森方法来查看到窗口。

73
00:02:18,776 --> 00:02:20,372
 - 此软件是最先进的。

74
00:02:20,372 --> 00:02:21,845
>> -The特征值是关闭的。

75
00:02:21,845 --> 00:02:24,300
>>  - 随着权
算法 - 组合

76
00:02:24,300 --> 00:02:26,755
>>  - 他的采取淘汰
算法，以一个新的水平，

77
00:02:26,755 --> 00:02:28,730
我可以用它们来
加强这方面的照片。

78
00:02:28,730 --> 00:02:31,286
>> -lock上和放大z轴。

79
00:02:31,286 --> 00:02:32,560
>>  - 增强。

80
00:02:32,560 --> 00:02:33,100
>>  - 增强。

81
00:02:33,100 --> 00:02:33,600
>>  - 增强。

82
00:02:33,600 --> 00:02:34,960
-freeze和提高。

83
00:02:34,960 --> 00:02:37,180
>> [结束播放]

84
00:02:37,180 --> 00:02:41,160
>> DAVID J.马兰：所有的权利，所以
所有这些实际上都是字。

85
00:02:41,160 --> 00:02:44,450
他们只是串联系在一起，
的方式，实际上不是明智的。

86
00:02:44,450 --> 00:02:48,400
而且，事实上，CS50和课程喜欢它
往往会毁了很多电视和电影

87
00:02:48,400 --> 00:02:48,900
为了你。

88
00:02:48,900 --> 00:02:52,330
因为当这些电脑专家
在剑拔弩张关条款，并说

89
00:02:52,330 --> 00:02:56,860
喜欢花哨的东西
特征向量，和z轴，

90
00:02:56,860 --> 00:02:59,572
和任何数量的其它的
其实更多的技术术语，

91
00:02:59,572 --> 00:03:02,030
他们真的只是串起
字联太频繁。

92
00:03:02,030 --> 00:03:05,020
那是我们的希望之一是，
作为疗程服用的副作用

93
00:03:05,020 --> 00:03:08,245
像这样，将更多的人在
世界上居然能权衡

94
00:03:08,245 --> 00:03:12,040
而只是非常轻微影响
质量和这些膜的准确性？

95
00:03:12,040 --> 00:03:14,350
>> 事实上，让我们来看看现实。

96
00:03:14,350 --> 00:03:18,070
因此，这里的工作人员合影
玛利亚，我们的教学研究员之一。

97
00:03:18,070 --> 00:03:20,050
而假设她是
怀疑的东西。

98
00:03:20,050 --> 00:03:23,730
然而，还有一丝
一些的证据在她的眼睛，

99
00:03:23,730 --> 00:03:25,480
还是在她的眼镜的反映。

100
00:03:25,480 --> 00:03:30,760
那么，如果我们这样做完全一样的电影
建议，其中，我们缩放和“提升”，

101
00:03:30,760 --> 00:03:34,080
这是多少信息
在玛丽的脸上

102
00:03:34,080 --> 00:03:36,795
当你拍摄图像
与原始分辨率。

103
00:03:36,795 --> 00:03:39,120
>> 而且，事实上，你可以看到这些点。

104
00:03:39,120 --> 00:03:41,900
这些都是什么
称为像素，P-I-X-E-L-S，

105
00:03:41,900 --> 00:03:45,740
这仅仅是一个典型的方
这是一个圆点组成的图像。

106
00:03:45,740 --> 00:03:49,200
而早在一天，居然连
今天与当今一些LED电视

107
00:03:49,200 --> 00:03:51,950
或液晶电视，如果你有
一个在你的房间或在家里，

108
00:03:51,950 --> 00:03:55,100
如果你去了超级靠近它，
尤其是如果它是一个有些旧的电视，

109
00:03:55,100 --> 00:03:58,760
你甚至可能看到这些点
而这正是构成的图像。

110
00:03:58,760 --> 00:04:00,980
>> 并且没有更多的
信息莫过于此。

111
00:04:00,980 --> 00:04:05,400
我们可以“提高”，在感
平滑的事情了排序和

112
00:04:05,400 --> 00:04:09,040
推断那种类型的，什么
颜色应该是旁边的Mary的眼睛

113
00:04:09,040 --> 00:04:10,910
因此，它实际上不是这样的像素化。

114
00:04:10,910 --> 00:04:14,510
但是，如果我继续放大，有
是个坏家伙在她的眼睛。

115
00:04:14,510 --> 00:04:16,600
就像是所有的
我们掌握的。

116
00:04:16,600 --> 00:04:18,920
您不能创建
信息无中生有。

117
00:04:18,920 --> 00:04:20,790
这里只有一个有限
位存在的数目。

118
00:04:20,790 --> 00:04:22,873
>> 因此，在习题集4，其中
你有一个机会

119
00:04:22,873 --> 00:04:24,580
用这种世界玩。

120
00:04:24,580 --> 00:04:27,610
在习题4，你会探索
图形和取证的世界，

121
00:04:27,610 --> 00:04:30,870
实际上编写代码
即恢复丢失的图像。

122
00:04:30,870 --> 00:04:33,510
你会写代码，
操纵现有图像

123
00:04:33,510 --> 00:04:36,120
最终明白什么是
怎么回事引擎盖下。

124
00:04:36,120 --> 00:04:38,540
>> 而且，事实证明，它实际上
不是所有的那么复杂。

125
00:04:38,540 --> 00:04:41,320
举例来说，如果我们想
代表笑脸的地方

126
00:04:41,320 --> 00:04:44,160
这些黑色像素，
或者这些黑点，

127
00:04:44,160 --> 00:04:47,230
好了，我们可以简单地表示
他们作为一个真正的位图。

128
00:04:47,230 --> 00:04:50,040
如果你曾经听说过
表达位图，也许

129
00:04:50,040 --> 00:04:52,330
现在开始做一个
一点更有意义的今天。

130
00:04:52,330 --> 00:04:53,580
>> 我们已经知道什么是位。

131
00:04:53,580 --> 00:04:54,160
它是0或1。

132
00:04:54,160 --> 00:04:56,201
而地图只是一些
像一张纸

133
00:04:56,201 --> 00:04:59,180
，让你的方向，并具有
也许x和y坐标的网格。

134
00:04:59,180 --> 00:05:00,540
因此，这里是一个位图。

135
00:05:00,540 --> 00:05:03,680
它是比特的地图
由此1是显然

136
00:05:03,680 --> 00:05:07,857
要代表白色像素和
0是要表示黑像素。

137
00:05:07,857 --> 00:05:09,440
但是，我们当然可以翻转它周围。

138
00:05:09,440 --> 00:05:11,648
它并不真正的问题等等
只要我们是一致的。

139
00:05:11,648 --> 00:05:15,570
这里是怎么回事，在binary--内
计算机的存储器中，或甚至内部

140
00:05:15,570 --> 00:05:18,160
在您的硬盘的文件
drive--你能存储

141
00:05:18,160 --> 00:05:20,240
的笑脸图像的简单。

142
00:05:20,240 --> 00:05:23,990
但当然，我们是什么，
缺乏这一形象？

143
00:05:23,990 --> 00:05:24,610
颜色，对不对？

144
00:05:24,610 --> 00:05:28,220
这是一个明显的下一个步骤或
增强的色彩改善这一点。

145
00:05:28,220 --> 00:05:32,230
所以，不幸的是，只是一个单一
位，0或1，我们可以表示的颜色。

146
00:05:32,230 --> 00:05:36,100
这可能是红色或蓝色，或
黑或白，或绿，或粉红色，

147
00:05:36,100 --> 00:05:37,420
或对颜色。

148
00:05:37,420 --> 00:05:40,860
但是，为了简单起见，我们将
姑且黑色和白色。

149
00:05:40,860 --> 00:05:45,930
>> 那么在逻辑上我们需要，如果我们
要实现彩色图像中的？

150
00:05:45,930 --> 00:05:49,080
什么是我们必须做的？

151
00:05:49,080 --> 00:05:51,900
就像如果这里的限制因素
是与一位你只能

152
00:05:51,900 --> 00:05:55,977
表示两个状态，0或1，白
或黑色的，你有什么想干什么？

153
00:05:55,977 --> 00:05:56,810
听众：更多的数据。

154
00:05:56,810 --> 00:05:58,813
DAVID J.马兰：更多位，
耶更多的数据，更多的比特。

155
00:05:58,813 --> 00:06:01,440
而且，事实上，这也正是如何
彩色图像表示。

156
00:06:01,440 --> 00:06:05,120
而不是使用单个比特，一
0或1对于每个像素，每个点，

157
00:06:05,120 --> 00:06:06,170
你只需要使用多个。

158
00:06:06,170 --> 00:06:09,660
也许使用8，也许，更常见
使用24，而事实上，在习题集

159
00:06:09,660 --> 00:06:13,300
4，将你的文件播放
使用24位典型的格式。

160
00:06:13,300 --> 00:06:15,430
>> 但大多数你可能
熟悉的JPEG文件。

161
00:06:15,430 --> 00:06:17,460
如果你曾经拍摄
照片在手机上，

162
00:06:17,460 --> 00:06:20,360
或者上载或看到的东西
Facebook或Flickr的，任何数量

163
00:06:20,360 --> 00:06:24,882
照片为基础的网站，你
之前可能看到一个JPEG图像。

164
00:06:24,882 --> 00:06:27,840
而事实证明，这是文件
格式我们会在PSET 4使用，

165
00:06:27,840 --> 00:06:30,340
因此你要
要恢复图像

166
00:06:30,340 --> 00:06:35,160
我不小心从已删除
在摄像机损坏的存储卡，

167
00:06:35,160 --> 00:06:35,800
如果你愿意。

168
00:06:35,800 --> 00:06:38,490
>> 而事实证明，即使
JPEG是相当sophisticated--

169
00:06:38,490 --> 00:06:40,906
它的更复杂
比黑和白点

170
00:06:40,906 --> 00:06:44,480
我们看到刚才，因为有
实际上看中的算法，

171
00:06:44,480 --> 00:06:47,410
被用于压缩为JPEG，所以
你可以有一个非常好的，

172
00:06:47,410 --> 00:06:49,832
高质量的图像，但使用
相当少的比特。

173
00:06:49,832 --> 00:06:51,790
我们再回过头来
不久压缩。

174
00:06:51,790 --> 00:06:56,280
事实证明，在第一
在一个JPEG image--三个字节

175
00:06:56,280 --> 00:07:02,750
无论你所拍摄的照片
of--是值255，216，255。

176
00:07:02,750 --> 00:07:05,990
>> 换句话说，如果你只是
看到位的模式，

177
00:07:05,990 --> 00:07:09,180
这里为三
字节或24比特合计，

178
00:07:09,180 --> 00:07:13,810
高概率，你可以推断，
你看它这前三

179
00:07:13,810 --> 00:07:15,230
一个JPEG字节。

180
00:07:15,230 --> 00:07:18,040
这是什么是已知的
为JPEG的签名。

181
00:07:18,040 --> 00:07:20,540
大量的文件格式
在那里往往开始

182
00:07:20,540 --> 00:07:23,735
用0和1的某些模式，
因此，Windows和Mac OS，和iOS，

183
00:07:23,735 --> 00:07:28,272
和Android知道什么样的文件，他们
是，除了所谓的文件

184
00:07:28,272 --> 00:07:29,730
扩展了很多文件都有。

185
00:07:29,730 --> 00:07:32,590
如果您的.jpg，这是
另一线索到计算机。

186
00:07:32,590 --> 00:07:35,310
>> 现在让我们看看这个
多一点技术。

187
00:07:35,310 --> 00:07:37,390
我们知道小数
系统是0到9。

188
00:07:37,390 --> 00:07:38,740
我们知道二进制是0和1。

189
00:07:38,740 --> 00:07:41,842
如果你觉得回到PSET
0，我们有你角力，

190
00:07:41,842 --> 00:07:43,800
一点点，东西
所谓的十六进制，

191
00:07:43,800 --> 00:07:47,320
在这里你有16位数字，
而不是10或代替2-。

192
00:07:47,320 --> 00:07:50,405
而这些数字，按照惯例，
为0至9，然后一个

193
00:07:50,405 --> 00:07:55,040
通过f，其中f代表什么
十进制数，只是作为一个快速神智

194
00:07:55,040 --> 00:07:56,640
检查？

195
00:07:56,640 --> 00:07:57,610
这样，15。

196
00:07:57,610 --> 00:08:01,390
而一个必须代表10，只凭
我已经给订货的性质。

197
00:08:01,390 --> 00:08:04,350
这只是一个任意的约定，
但是它是相当标准。

198
00:08:04,350 --> 00:08:06,870
>> 因此，如果我们看一下这个模式
三bytes--我们

199
00:08:06,870 --> 00:08:09,620
刚开始看它
用怎样的方式

200
00:08:09,620 --> 00:08:12,450
计算机科学家一般
看待和思考的文件。

201
00:08:12,450 --> 00:08:15,580
你当然可以考虑一下
在0文件，和1，和小数，

202
00:08:15,580 --> 00:08:19,340
但在现实中，我们往往会使用二进制
或更典型地hexadecimal--

203
00:08:19,340 --> 00:08:20,760
回程从PSET 0。

204
00:08:20,760 --> 00:08:25,857
因此，让我提出，255，216，255
是0和1的只是这些模式。

205
00:08:25,857 --> 00:08:28,440
你可以，如果检查这个你
想从第0周做数学题。

206
00:08:28,440 --> 00:08:30,810
不过，就目前来看，只是假设
这确实是正确的。

207
00:08:30,810 --> 00:08:33,850
我刚刚改写三个小数
数字作为3的二进制值。

208
00:08:33,850 --> 00:08:36,100
现在我所要做的就是
只需添加一些白色的空间，

209
00:08:36,100 --> 00:08:37,266
只是可读性的缘故。

210
00:08:37,266 --> 00:08:39,940
而通知，我只是去
搬东西分开。

211
00:08:39,940 --> 00:08:43,090
所以前，后，前，后。

212
00:08:43,090 --> 00:08:46,180
我在做什么有趣其他
不仅仅是传播的东西出这么

213
00:08:46,180 --> 00:08:50,380
该通知每组八
位现在是两组四比特。

214
00:08:50,380 --> 00:08:54,920
这是因为，十六进制有用
特别时尚

215
00:08:54,920 --> 00:09:00,930
因为每一个十六进制数字0〜
f或者更具体地为0到15，

216
00:09:00,930 --> 00:09:03,430
可以表示
恰好有四位。

217
00:09:03,430 --> 00:09:07,960
换句话说，在十六进制如果
想表示一个0，它只是0000，

218
00:09:07,960 --> 00:09:08,780
四个零。

219
00:09:08,780 --> 00:09:13,997
如果你要代表15，
它是1111，这是4位。

220
00:09:13,997 --> 00:09:16,080
如果你做数学题，
如果这是个位，

221
00:09:16,080 --> 00:09:18,210
这是16S的地方，
那将会给你 - 

222
00:09:18,210 --> 00:09:19,960
而这回事
用于：对不起，二进制，

223
00:09:19,960 --> 00:09:23,660
那将会给你15，个位，
三三两两的地方，四肢和八分的地方。

224
00:09:23,660 --> 00:09:26,821
因此，让我提议说
在左侧设置四个比特的

225
00:09:26,821 --> 00:09:28,070
就是我们要调用F。

226
00:09:28,070 --> 00:09:30,110
这是最大的号码，你
可以用四位表示。

227
00:09:30,110 --> 00:09:33,300
我们已经从十六进制知道，
f是十六进制的最大数字。

228
00:09:33,300 --> 00:09:36,020
我们已经有了另一个F那里，
两个在那边。

229
00:09:36,020 --> 00:09:38,980
而现在，只需要信仰
我已经做了数学向右

230
00:09:38,980 --> 00:09:41,890
并且左半
那些位，1101，

231
00:09:41,890 --> 00:09:43,980
是同样的事情为d十六进制。

232
00:09:43,980 --> 00:09:46,490
而右手，1000年，仅有8。

233
00:09:46,490 --> 00:09:48,140
>> 而一个人的易见，对吧？

234
00:09:48,140 --> 00:09:51,670
8 represents--是正确的
下面的八分地方。

235
00:09:51,670 --> 00:09:56,040
所以我们有一个在八分列
并没有在四肢着地，三三两两或1。

236
00:09:56,040 --> 00:09:59,830
所以现在更多的传统，人们往往
写十六进制这样的数字，

237
00:09:59,830 --> 00:10:03,000
你刚才压碎在一起，
然后以0x前缀他们。

238
00:10:03,000 --> 00:10:05,920
这意味着什么比其他
视觉线索一human--

239
00:10:05,920 --> 00:10:10,350
又来了一个十六进制value--因为
它可能没有另外明显。

240
00:10:10,350 --> 00:10:13,629
>> 这就是说，最终，
零和一的图案，

241
00:10:13,629 --> 00:10:16,170
或十六进制的模式
数字等价的你

242
00:10:16,170 --> 00:10:18,990
要开始寻找
在习题集4 this--

243
00:10:18,990 --> 00:10:22,120
和习题集4规范将走
您通过本更detail--

244
00:10:22,120 --> 00:10:25,344
但作为实现某种神秘的作为
这可能看起来乍一看，

245
00:10:25,344 --> 00:10:27,010
你将开始看到这个有很多。

246
00:10:27,010 --> 00:10:30,320
而事实上，即使是在GDB中，
调试器，我们推出了周一

247
00:10:30,320 --> 00:10:35,440
和丹介绍了PSET 3，是怎么回事
经常告诉你的十六进制值

248
00:10:35,440 --> 00:10:39,910
只是因为他们往往​​更
传统不是十进制或二进制

249
00:10:39,910 --> 00:10:41,157
在计算机的世界。

250
00:10:41,157 --> 00:10:42,490
现在，让我们把这个的来龙去脉。

251
00:10:42,490 --> 00:10:48,040
你们中许多人可能还记得这个
图片浏览，它来自什么？

252
00:10:48,040 --> 00:10:51,240
Vista的，所以还要早
认为，Windows XP这样做首次亮相。

253
00:10:51,240 --> 00:10:52,620
因此，这是一道亮丽的风景。

254
00:10:52,620 --> 00:10:55,940
而事实上，如果你闲逛online--
我认为这是一个维基百科的文章，

255
00:10:55,940 --> 00:11:00,110
其中有人很令人惊讶出去
发现这个位置在世界上成立

256
00:11:00,110 --> 00:11:02,240
他或她的在相机
恰到好处的place--

257
00:11:02,240 --> 00:11:06,510
这看起来今天like--但
它是完全一样的设置。

258
00:11:06,510 --> 00:11:10,060
这个图象，不过，是在一个文件中
格式称为位图，B-M-页。

259
00:11:10,060 --> 00:11:12,910
而且我们要采取超
快速浏览一下这是什么意思。

260
00:11:12,910 --> 00:11:17,770
>> 但是，位图是只是用不同的方式
代表图像仍然采用像素

261
00:11:17,770 --> 00:11:19,580
在0和1，最终。

262
00:11:19,580 --> 00:11:23,282
但在快速浏览，它有
一个更有趣的签名

263
00:11:23,282 --> 00:11:24,490
在文件的开头。

264
00:11:24,490 --> 00:11:26,670
这不是短短三年
字节，而还有

265
00:11:26,670 --> 00:11:30,770
一大堆的字节模式
已经预定义。

266
00:11:30,770 --> 00:11:34,490
例如，某处
位图图像的前几个字节

267
00:11:34,490 --> 00:11:37,440
将是的大小
图像时，图像的宽度，

268
00:11:37,440 --> 00:11:40,390
图像的高度，因此
有用的元数据，如果你愿意。

269
00:11:40,390 --> 00:11:43,940
有用信息的Photoshop
或任何图形您正在使用编程

270
00:11:43,940 --> 00:11:45,180
也许真的在乎。

271
00:11:45,180 --> 00:11:47,170
>> 因此，更多的关于这方面
问题集4中，但此

272
00:11:47,170 --> 00:11:49,220
只说
在一天结束时

273
00:11:49,220 --> 00:11:52,390
你一直在使用的文件格式
对于years-- Microsoft Word文件，

274
00:11:52,390 --> 00:11:55,820
数字文件，Excel文件，
任意数量的文件格式

275
00:11:55,820 --> 00:11:57,770
可能有一些
已知文件扩展名

276
00:11:57,770 --> 00:12:00,130
只是0和1的引擎盖下。

277
00:12:00,130 --> 00:12:02,970
而人类已经决定
什么样的约定，

278
00:12:02,970 --> 00:12:08,340
什么样的0和1的模式代表
一个Word文件与一个Excel文件，

279
00:12:08,340 --> 00:12:10,322
与任意数量的其他文件格式。

280
00:12:10,322 --> 00:12:12,780
因此，在PSET 4，你就会有一个
机遇与发挥。

281
00:12:12,780 --> 00:12:14,405
>> 但是，什么意思有一个结构。

282
00:12:14,405 --> 00:12:18,012
这实际上是一个很好的SEGUE现在
成C，它只有一对夫妇

283
00:12:18,012 --> 00:12:20,220
附加功能
我们还没看呢。

284
00:12:20,220 --> 00:12:24,230
这是一个非常小的语言之一
关于C的不错的功能，是一个结构。

285
00:12:24,230 --> 00:12:27,300
例如，如果你
想represent--我们

286
00:12:27,300 --> 00:12:33,690
说你想有一个变量
代表一个学生的一些计划。

287
00:12:33,690 --> 00:12:37,330
也许你正在写一门课程
注册程序，或核心购物

288
00:12:37,330 --> 00:12:38,870
工具，或者类似的东西。

289
00:12:38,870 --> 00:12:42,922
什么是数据块相关
一个学生浮现在脑海？

290
00:12:42,922 --> 00:12:44,880
就像一个学生
代表有什么样的价值观？

291
00:12:44,880 --> 00:12:45,732
是吗？

292
00:12:45,732 --> 00:12:46,940
你有一个名字作为一个学生。

293
00:12:46,940 --> 00:12:48,900
还有什么不典型的学生有哪些？

294
00:12:48,900 --> 00:12:49,320
>> 听众：[听不清]

295
00:12:49,320 --> 00:12:50,200
>> DAVID J.马兰：所以，对不起。

296
00:12:50,200 --> 00:12:50,660
>> 听众：年龄。

297
00:12:50,660 --> 00:12:52,980
>> DAVID J.马兰：一个时代或
生日等效，是的。

298
00:12:52,980 --> 00:12:53,557
还有什么？

299
00:12:53,557 --> 00:12:54,390
听众：身份证号码？

300
00:12:54,390 --> 00:12:57,460
DAVID J.马兰：所以一个ID号，也许
一个电话号码，也许是一个宿舍，或房子，

301
00:12:57,460 --> 00:12:58,670
或学院，或类似的东西。

302
00:12:58,670 --> 00:13:01,820
任何数目的数据段是
你可能在你的联系人列表

303
00:13:01,820 --> 00:13:03,890
是可以定义一个学生。

304
00:13:03,890 --> 00:13:08,490
因此，如果我们要做到这一点，在代码中，
我们可以做一些简单的像这样。

305
00:13:08,490 --> 00:13:15,670
我们可能有一个程序，
有让我们说，诠释主要（无效）。

306
00:13:15,670 --> 00:13:18,920
如果我想代表
学生，我可能有，比如，

307
00:13:18,920 --> 00:13:24,330
一个名为名字的学生字符串，
一个名为宿舍为学生串，

308
00:13:24,330 --> 00:13:26,900
也许一个int称为ID为学生。

309
00:13:26,900 --> 00:13:30,840
而且因为我使用的字符串，我
需要回去并提出了CS50.h.

310
00:13:30,840 --> 00:13:33,300
也许我会需要stdio.h中。

311
00:13:33,300 --> 00:13:38,190
因此，让我抢先做那些和我
要调用这个student.c现在

312
00:13:38,190 --> 00:13:40,080
并保存。

313
00:13:40,080 --> 00:13:44,206
>> 现在我能做些什么
这些变量。

314
00:13:44,206 --> 00:13:46,830
而我们只是写
随着伪代码中的注释，

315
00:13:46,830 --> 00:13:48,829
因为它不是有趣
我们做什么现在。

316
00:13:48,829 --> 00:13:51,242
好了，这是一个程序，
不知何故存储的学生。

317
00:13:51,242 --> 00:13:53,450
什么是我想要做的，如果我
要存储两位学生？

318
00:13:53,450 --> 00:13:55,991
所以，我的第一反应是怎么回事
就可以了吧，等一下，

319
00:13:55,991 --> 00:14:01,920
如果我有一个学生，为什么不要我
只是做字符串名称2，串宿舍2，

320
00:14:01,920 --> 00:14:04,190
INT ID2。

321
00:14:04,190 --> 00:14:06,540
而我们所做的走了
下来之前，这条道路

322
00:14:06,540 --> 00:14:10,890
什么是我们的解决方案似乎什么
是怎样的一个hackish的复制粘贴的

323
00:14:10,890 --> 00:14:11,555
在这里工作？

324
00:14:11,555 --> 00:14:12,346
听众：数组。

325
00:14:12,346 --> 00:14:13,830
DAVID J.马兰：是啊，
我们可以使用的阵列。

326
00:14:13,830 --> 00:14:15,620
右键这个速度非常快
就不明智了。

327
00:14:15,620 --> 00:14:18,453
你要排序的任意
开始命名所有这些变量。

328
00:14:18,453 --> 00:14:22,190
而你，人类，必须保持
跟踪该行名2对应

329
00:14:22,190 --> 00:14:25,060
与dorm2对应ID2。

330
00:14:25,060 --> 00:14:26,200
它只是变得一团糟。

331
00:14:26,200 --> 00:14:29,350
所以这是一个容易得多，
从几个星期前还记得，

332
00:14:29,350 --> 00:14:34,300
只是不得不叫字符串名称
也许给我们其中的三个。

333
00:14:34,300 --> 00:14:36,940
然后，也许我们有
串宿舍和有

334
00:14:36,940 --> 00:14:41,900
三个，或具有恒定，
诠释ID和有三个那些。

335
00:14:41,900 --> 00:14:45,250
但即便是现在这样的感觉
一个有点草率了吧。

336
00:14:45,250 --> 00:14:49,440
我们谈论的是学生，但
我真的沉湎于低水平

337
00:14:49,440 --> 00:14:50,470
实施细则。

338
00:14:50,470 --> 00:14:52,790
学生是一个名称，一个宿舍和ID。

339
00:14:52,790 --> 00:14:59,814
>> 为什么我不能只是声明一个变量
所谓的学生，称之为秒。

340
00:14:59,814 --> 00:15:02,230
如果我想另一名学生，
为什么不让我只是把它吨。

341
00:15:02,230 --> 00:15:05,260
或者，如果我想要一大堆
学生，为什么不让我

342
00:15:05,260 --> 00:15:09,740
说我有一整类
同学们，这是他们三个。

343
00:15:09,740 --> 00:15:12,470
换句话说，为什么不能我来了
与我自己的数据类型，称为

344
00:15:12,470 --> 00:15:15,641
学生，其内部是
一个名字，是一个ID，是一个宿舍，

345
00:15:15,641 --> 00:15:16,890
任何数量等领域。

346
00:15:16,890 --> 00:15:19,030
而事实证明，你
可正是这样做的。

347
00:15:19,030 --> 00:15:21,850
>> 所以C有这个功能叫做结构。

348
00:15:21,850 --> 00:15:24,700
这是一个语言功能，
让我们做的正是这一点。

349
00:15:24,700 --> 00:15:28,370
我要继续前进
并开辟structs.h

350
00:15:28,370 --> 00:15:32,299
在这里，我们将看到的
以下是学生的定义。

351
00:15:32,299 --> 00:15:35,215
事实证明 - 而这其中甚至
比一个涉及ID简单

352
00:15:35,215 --> 00:15:36,080
刚才。

353
00:15:36,080 --> 00:15:39,120
如果你要来了
自制的数据类型，

354
00:15:39,120 --> 00:15:42,750
而除了int和char和
浮起并所有这些其他人的存在，

355
00:15:42,750 --> 00:15:45,810
你可以从字面上这样做
写typedef结构，

356
00:15:45,810 --> 00:15:47,880
然后一些大括号，
这里面你

357
00:15:47,880 --> 00:15:51,460
列出你想要的变量
这一新的自定义数据相关联

358
00:15:51,460 --> 00:15:55,670
像键入一个名称和宿舍，
再经过大括号

359
00:15:55,670 --> 00:15:57,860
你给一个名称为新的数据类型。

360
00:15:57,860 --> 00:15:59,220
因此，例如，学生。

361
00:15:59,220 --> 00:16:03,247
>> 什么是好的关于这个现在是，
如果我们看一下相应的代码，

362
00:16:03,247 --> 00:16:05,080
该公约，第一
所有的人，是把这个

363
00:16:05,080 --> 00:16:08,230
在一个名为什么点H，
一个头文件，我们有没有

364
00:16:08,230 --> 00:16:09,780
开始使用自己太多。

365
00:16:09,780 --> 00:16:12,120
但是，我们要开始
使用相当多的现在。

366
00:16:12,120 --> 00:16:18,650
而且我们可以用这个做的，
最终，在这几行代码

367
00:16:18,650 --> 00:16:22,130
正是如此声明
数据类型，一个学生。

368
00:16:22,130 --> 00:16:23,230
现在，让我们使用它。

369
00:16:23,230 --> 00:16:27,274
>> 我要现在进入
一个名为structs1.c。

370
00:16:27,274 --> 00:16:29,440
让我们来看看一个
几个特点在这里。

371
00:16:29,440 --> 00:16:32,250
所以的东西在这里是
大多是熟悉的，我们会

372
00:16:32,250 --> 00:16:35,040
回过头来究竟是不是
熟悉一会儿就好了。

373
00:16:35,040 --> 00:16:39,880
当然，这是包括我自己
头文件，它是新的，以及，

374
00:16:39,880 --> 00:16:42,580
除了PSET 3，其中，
回想一下，我们有helpers.h。

375
00:16:42,580 --> 00:16:45,150
所以，你可能还记得的#include helpers.h。

376
00:16:45,150 --> 00:16:49,381
>> 但为什么我使用引号
而不是尖括号？

377
00:16:49,381 --> 00:16:50,630
我什么时候他们之间做出选择？

378
00:16:50,630 --> 00:16:52,310
几乎总是我似乎
使用尖括号。

379
00:16:52,310 --> 00:16:55,040
然后，突然之间就
六号线我使用双引号。

380
00:16:55,040 --> 00:16:55,860
为什么会这样呢？

381
00:16:55,860 --> 00:16:56,700
是吗？

382
00:16:56,700 --> 00:16:57,725
>> 听众：[听不清]

383
00:16:57,725 --> 00:16:59,350
DAVID J.马兰：这是一个实际的，是什么？

384
00:16:59,350 --> 00:17:00,559
听众：这是在你的IDE。

385
00:17:00,559 --> 00:17:02,475
DAVID J.马兰：是啊，
这是在我的实际IDE。

386
00:17:02,475 --> 00:17:05,690
而且我们不要对IDE纠缠，因为
这只是我使用的工具。

387
00:17:05,690 --> 00:17:08,119
那是在我目前
目录，明确。

388
00:17:08,119 --> 00:17:11,647
所以structs.h是我自己的文件
没有安装IDE，

389
00:17:11,647 --> 00:17:14,480
在操作系统本身，
而它在我的当前目录。

390
00:17:14,480 --> 00:17:16,910
所以，如果你想要的约定
包括您自己的头文件，

391
00:17:16,910 --> 00:17:18,200
你只需要使用双引号。

392
00:17:18,200 --> 00:17:23,290
>> 什么是我们所说的这个东西
8号线，一般来讲？

393
00:17:23,290 --> 00:17:25,200
这是什么？

394
00:17:25,200 --> 00:17:28,220
＃定义的东西。

395
00:17:28,220 --> 00:17:31,040
这代表常数，对不对？

396
00:17:31,040 --> 00:17:33,140
如果你想有一个
在你的程序价值

397
00:17:33,140 --> 00:17:35,110
您使用一个整体
一堆的时候，它的

398
00:17:35,110 --> 00:17:39,330
良好的约定因素出来，
声明它，用井号

399
00:17:39,330 --> 00:17:43,340
定义的话，按照惯例，在所有
大写word--尽管它不是

400
00:17:43,340 --> 00:17:45,320
绝对必要的，但
这是人类的约定

401
00:17:45,320 --> 00:17:47,210
充分利用常数
使他们跳出

402
00:17:47,210 --> 00:17:50,380
你visually--空间
那么你想要的值是

403
00:17:50,380 --> 00:17:52,250
相当于恒定的名字。

404
00:17:52,250 --> 00:17:56,110
别无分号，但是你根本
按照该模式存在。

405
00:17:56,110 --> 00:17:57,770
>> 那么，我在此实际代码执行。

406
00:17:57,770 --> 00:18:00,660
因此，让我们一起来看看
这里的主要程序。

407
00:18:00,660 --> 00:18:04,080
在第12行，因为我
已包括structs.h，

408
00:18:04,080 --> 00:18:06,492
我现在已经奇迹般地在我
处置一个新的数据类型。

409
00:18:06,492 --> 00:18:09,200
我不只是有机会获得INT，
和炭，和float和字符串，

410
00:18:09,200 --> 00:18:10,060
和蓝色等。

411
00:18:10,060 --> 00:18:12,470
我现在有机会获得
一个学生的数据类型。

412
00:18:12,470 --> 00:18:17,740
因此，在第12行，我将两个
ideas--一项所述的自定义数据类型和两个，

413
00:18:17,740 --> 00:18:18,940
使用阵列。

414
00:18:18,940 --> 00:18:21,700
所以，在这个项目中，如果
我想实际支持

415
00:18:21,700 --> 00:18:24,320
三个不同的学生
在我的计划，我

416
00:18:24,320 --> 00:18:30,480
可以简单地说，给我一个变量
称为学生，其每一个

417
00:18:30,480 --> 00:18:32,970
是类型的学生，哪个
是我的自定义数据类型。

418
00:18:32,970 --> 00:18:35,890
而且，具体而言，给我
其中三个在我的阵列。

419
00:18:35,890 --> 00:18:37,750
>> 所以，现在我们做这个节目在哪？

420
00:18:37,750 --> 00:18:40,670
这里只是一个for循环迭代
从0到3，因为这是

421
00:18:40,670 --> 00:18:42,110
什么样的学生的价值。

422
00:18:42,110 --> 00:18:44,420
我只是提示用户
给我的学生的名字。

423
00:18:44,420 --> 00:18:48,090
然后在第17行，我们
有大多熟悉线路。

424
00:18:48,090 --> 00:18:50,370
我们有我们的老朋友
GetString的右侧。

425
00:18:50,370 --> 00:18:52,345
什么一块语法
显然是新的，

426
00:18:52,345 --> 00:18:55,130
如果你以前从来没有编入C，
并且从未使用过的结构？

427
00:18:55,130 --> 00:18:55,510
是吗？

428
00:18:55,510 --> 00:18:56,417
>> 听众：本。名称。

429
00:18:56,417 --> 00:18:57,500
DAVID J.马兰：本。名称。

430
00:18:57,500 --> 00:19:01,220
但是，这不是一个太大的飞跃，
因为现在的学生括号我

431
00:19:01,220 --> 00:19:02,590
为您提供了第i个学生。

432
00:19:02,590 --> 00:19:04,730
如果你想潜水
该结构的内部，

433
00:19:04,730 --> 00:19:09,490
你只需要使用一个周期，
那么变量内的名称，

434
00:19:09,490 --> 00:19:11,900
或内部的财产
你想获得访问。

435
00:19:11,900 --> 00:19:14,816
同样的话，如果我再提示
用户，给我的学生的宿舍，

436
00:19:14,816 --> 00:19:18,390
你同样可以存储
字符串里面的宿舍变量

437
00:19:18,390 --> 00:19:19,940
那学生结构。

438
00:19:19,940 --> 00:19:21,410
>> 现在事情变得有点奇特。

439
00:19:21,410 --> 00:19:24,420
这是要去看看
在或许很多太快了。

440
00:19:24,420 --> 00:19:27,970
但是你会看到这么远更PSET
4，所以我们只在它一眼吧。

441
00:19:27,970 --> 00:19:33,364
事实证明，在第23行至
38，你觉得什么我可能做什么？

442
00:19:33,364 --> 00:19:35,530
我已经删除了评论
今天，但版本

443
00:19:35,530 --> 00:19:38,660
网上的代码的
参考已全部评论。

444
00:19:38,660 --> 00:19:40,171
我似乎在做？

445
00:19:40,171 --> 00:19:42,530
>> 听众：保存所有文件
该用户输入的信息。

446
00:19:42,530 --> 00:19:44,530
>> DAVID J.马兰：是啊，
准确地说，这是一种新的方式

447
00:19:44,530 --> 00:19:46,370
我们现在看到的二，
的C另一个特征，

448
00:19:46,370 --> 00:19:48,700
因此我可以创建自己的文件。

449
00:19:48,700 --> 00:19:51,580
到目前为止，几乎每一个程序
你写的是无状态的。

450
00:19:51,580 --> 00:19:53,334
一旦它完成运行，仅此而已。

451
00:19:53,334 --> 00:19:55,000
有没有记忆或它的回忆。

452
00:19:55,000 --> 00:19:56,110
有没有保存的文件。

453
00:19:56,110 --> 00:19:58,120
但是，如果你想
节约投入，有

454
00:19:58,120 --> 00:20:02,100
事情发生了，就像在游戏或程序
这样，事实证明我们可以做到这一点。

455
00:20:02,100 --> 00:20:04,360
你会看到这更
在PSET 4节。

456
00:20:04,360 --> 00:20:08,661
但是，这条线23实质上
创建一个名为students.csv文件。

457
00:20:08,661 --> 00:20:10,160
你可能已经看到过这一点。

458
00:20:10,160 --> 00:20:14,250
即使你以前从来没有学CS，
CSV是逗号分隔的变量。

459
00:20:14,250 --> 00:20:19,000
这就像一个非常贫穷的人的
版本的Excel文件，

460
00:20:19,000 --> 00:20:22,270
这意味着它可以打开
在Excel和苹果的数字，

461
00:20:22,270 --> 00:20:23,830
它具有的行和列。

462
00:20:23,830 --> 00:20:26,485
但它不是一个专有
格式如微软或苹果。

463
00:20:26,485 --> 00:20:29,840
它只是逗号分隔
价值观，我们将看到一个时刻。

464
00:20:29,840 --> 00:20:31,010
>> 而只是采取一种猜测。

465
00:20:31,010 --> 00:20:33,480
在第23行，在最
最后，我的第二个参数

466
00:20:33,480 --> 00:20:37,700
这个所谓的新功能
F打开文件打开是瓦特

467
00:20:37,700 --> 00:20:39,430
什么可能W¯¯表示？

468
00:20:39,430 --> 00:20:40,022
是吗？

469
00:20:40,022 --> 00:20:41,260
>> 听众：它可以让​​你写文件？

470
00:20:41,260 --> 00:20:42,630
>> DAVID J.马兰：它可以让
你写入文件。

471
00:20:42,630 --> 00:20:44,810
因此，有几个变种
我们可以在这里插上研究。

472
00:20:44,810 --> 00:20:47,184
但如果你只是想读
该文件，也就是看它

473
00:20:47,184 --> 00:20:50,010
并读入内存，
只需使用报价引文结束“R”。

474
00:20:50,010 --> 00:20:53,110
如果你想要写的
文件，可以使用报价引文结束“W”。

475
00:20:53,110 --> 00:20:55,190
还有追加和
几个其他的事情

476
00:20:55,190 --> 00:20:57,356
如果要修改现有的文件。

477
00:20:57,356 --> 00:21:00,480
现在，我们将继续看到这
的东西，那么我们会回来到线24。

478
00:21:00,480 --> 00:21:02,640
NULL，它的出现，是
一个特殊值，

479
00:21:02,640 --> 00:21:06,070
可以通过某些功能被返回
如果事情已经wrong--

480
00:21:06,070 --> 00:21:08,490
如果该文件不存在，
如果你耗尽内存，

481
00:21:08,490 --> 00:21:09,620
或一堆其他错误。

482
00:21:09,620 --> 00:21:13,470
但现在，让我们姑且认为这
仅仅是传统的错误检查。

483
00:21:13,470 --> 00:21:17,090
在这里，在第26行，我遍历
从0到3在所有我的学生。

484
00:21:17,090 --> 00:21:20,470
这是一种排序
一个新的功能，fprintf中，

485
00:21:20,470 --> 00:21:21,460
而只是采取一种猜测。

486
00:21:21,460 --> 00:21:24,370
如果printf的只是打印
一个格式化字符串，

487
00:21:24,370 --> 00:21:26,507
是什么fprintf中大概是什么意思？

488
00:21:26,507 --> 00:21:27,590
听众：打印到文件中。

489
00:21:27,590 --> 00:21:29,290
DAVID J.马兰：打印
格式化字符串到一个文件中。

490
00:21:29,290 --> 00:21:31,180
这就是另外的
F表示是文件。

491
00:21:31,180 --> 00:21:36,420
而新的第一个参数必须是
这表示您的文件中的变量。

492
00:21:36,420 --> 00:21:38,866
然后，我们只是有一个格式
就像printf的字符串。

493
00:21:38,866 --> 00:21:40,740
即使这
语法是新的，这只是

494
00:21:40,740 --> 00:21:44,610
是指插在学生的姓名，
插件在学生宿舍，然后

495
00:21:44,610 --> 00:21:47,160
用fclose函数，关闭文件。

496
00:21:47,160 --> 00:21:49,730
然后lastly--这是新的
我们会回来的这

497
00:21:49,730 --> 00:21:53,240
long--我释放前
学生的原因

498
00:21:53,240 --> 00:21:54,860
发生了上面有。

499
00:21:54,860 --> 00:21:56,820
但是，我们会回来的
该前long--

500
00:21:56,820 --> 00:21:59,820
这是因为GetString的是如何
实际工作引擎盖下。

501
00:21:59,820 --> 00:22:01,280
>> 因此，让我们快速浏览一下这里。

502
00:22:01,280 --> 00:22:04,380
如果我在目录中输入ls，
请注意，我不

503
00:22:04,380 --> 00:22:09,360
有一个名为students.csv文件，
只是不存在，不存在。

504
00:22:09,360 --> 00:22:14,965
所以，如果我现在编译这个程序，
使结构-1。 /结构-1，

505
00:22:14,965 --> 00:22:20,570
而且我要继续前进，键入
岸堤，谁住在伯克利，耶鲁。

506
00:22:20,570 --> 00:22:26,350
我们将不得不抢谁
住在塞耶这些天。

507
00:22:26,350 --> 00:22:33,760
而且，我们拿出其中，
是的，我想，玛丽亚是在马瑟

508
00:22:33,760 --> 00:22:35,100
如果我没记错。

509
00:22:35,100 --> 00:22:36,460
>> 所以好像没有什么改变。

510
00:22:36,460 --> 00:22:40,680
但是，如果我现在输入ls，
有students.csv。

511
00:22:40,680 --> 00:22:43,080
让我们继续和开放的students.csv。

512
00:22:43,080 --> 00:22:46,050
这又是一个非常
轻巧的文件格式。

513
00:22:46,050 --> 00:22:49,570
但我只是通过了一项约定
我有两行和列在这里。

514
00:22:49,570 --> 00:22:52,020
第一列是
人的名字。

515
00:22:52,020 --> 00:22:55,740
第二列是学生的
宿舍，或学院，或房子，或诸如此类的东西。

516
00:22:55,740 --> 00:22:57,900
而现在我已经保存在此
永久在文件中。

517
00:22:57,900 --> 00:22:59,280
>> 因此，它不是那么有趣。

518
00:22:59,280 --> 00:23:02,980
但是，这只是一个敲门砖，现在
要能坚持信息

519
00:23:02,980 --> 00:23:04,040
久治不愈。

520
00:23:04,040 --> 00:23:08,340
所以，让我们来看看现在还有什么我们可以
如何处理这些和其它特征。

521
00:23:08,340 --> 00:23:10,729
但首先，什么问题吗？

522
00:23:10,729 --> 00:23:12,145
这是一个很多，而且非常快。

523
00:23:12,145 --> 00:23:16,131
但是，你会看到很多
更PSET 4，也是如此。

524
00:23:16,131 --> 00:23:16,630
是吗？

525
00:23:16,630 --> 00:23:19,360
>> 听众：有没有一种方法来
继续添加名称到该文件？

526
00:23:19,360 --> 00:23:19,880
>> DAVID J.马兰：好问题。

527
00:23:19,880 --> 00:23:21,800
有没有办法继续
将名称添加到该文件？

528
00:23:21,800 --> 00:23:22,340
是。

529
00:23:22,340 --> 00:23:24,630
而且，事实上，如果你最终
最多再打开文件，

530
00:23:24,630 --> 00:23:26,780
你会使用报价
引文结束“一”进行追加，

531
00:23:26,780 --> 00:23:31,090
这只会增加一个新的线，
新的生产线连连，完全吻合。

532
00:23:31,090 --> 00:23:32,010
好问题。

533
00:23:32,010 --> 00:23:32,950
其他的问题吗？

534
00:23:32,950 --> 00:23:33,450
是吗？

535
00:23:33,450 --> 00:23:35,580
听众：如果您运行了
再次程序现在，

536
00:23:35,580 --> 00:23:38,000
它会不断增加名字的
文件或将它打开了一个新的文件？

537
00:23:38,000 --> 00:23:38,740
>> DAVID J.马兰：啊，好问题。

538
00:23:38,740 --> 00:23:41,448
如果再次正确运行程序
现在，也许在输入新的名称，

539
00:23:41,448 --> 00:23:44,820
将其添加到文件
或覆盖文件？

540
00:23:44,820 --> 00:23:47,420
后者，因为我
不使用追加模式。

541
00:23:47,420 --> 00:23:49,930
而且因为我只是一味地
打开该文件进行写入，

542
00:23:49,930 --> 00:23:51,310
它只是将覆盖该文件。

543
00:23:51,310 --> 00:23:54,570
所以，我的确需要做的是追加，
如果我想确实有一个长期的

544
00:23:54,570 --> 00:23:55,350
数据库。

545
00:23:55,350 --> 00:23:58,220
>> 现在，CSV是有用的，坦率地说，即使
像如果你writing--

546
00:23:58,220 --> 00:24:00,100
我们最终会看到这个
后来在学期时，

547
00:24:00,100 --> 00:24:01,455
我们使用的CSV用于其他目的。

548
00:24:01,455 --> 00:24:04,920
如果你想存储所有的人
谁已经注册了一些事件，

549
00:24:04,920 --> 00:24:07,420
或者注册了您的学生
组，或者类似的东西，

550
00:24:07,420 --> 00:24:10,330
将数据存储在这种
格式是超级方便。

551
00:24:10,330 --> 00:24:12,580
因为从字面上看，如果我
要下载此文件。

552
00:24:12,580 --> 00:24:14,540
我可以double--和
让我们真正尝试这

553
00:24:14,540 --> 00:24:16,720
如果我有Excel或数字放在这里。

554
00:24:16,720 --> 00:24:19,130
>> 我要右击
或控制单击我的档案。

555
00:24:19,130 --> 00:24:20,020
哎呦。

556
00:24:20,020 --> 00:24:21,830
用鼠标右键单击或控制单击我的档案。

557
00:24:21,830 --> 00:24:24,960
来吧，我的鼠标是不是合作。

558
00:24:24,960 --> 00:24:32,694
Download--我要去
下载的所有文件，在这里，所以

559
00:24:32,694 --> 00:24:33,860
只是这样我就可以抓住这一个。

560
00:24:33,860 --> 00:24:37,850
而让我们看看，如果这个工程
students.csv--第一次

561
00:24:37,850 --> 00:24:39,310
我已激活。

562
00:24:39,310 --> 00:24:41,360
现在，他们希望看到我的联系人。

563
00:24:41,360 --> 00:24:44,310
现在，我需要注册。

564
00:24:44,310 --> 00:24:47,620
看到它是多么容易使用的CSV？

565
00:24:47,620 --> 00:24:50,840
是的，保持最新。

566
00:24:50,840 --> 00:24:52,375
好了，现在我们已经准备好上课。

567
00:24:52,375 --> 00:24:58,750

568
00:24:58,750 --> 00:25:00,370
OK，哦，有什么新的？

569
00:25:00,370 --> 00:25:02,920
OK，关闭。

570
00:25:02,920 --> 00:25:04,750
这是不可思议的。

571
00:25:04,750 --> 00:25:07,280
好了，现在我们必须更新。

572
00:25:07,280 --> 00:25:10,890
而现在，它忘记了什么
文件我原来开了，

573
00:25:10,890 --> 00:25:13,090
但什么A--我们走吧。

574
00:25:13,090 --> 00:25:16,341
好了，现在我们有一个Excel文件。

575
00:25:16,341 --> 00:25:18,290
谢谢。

576
00:25:18,290 --> 00:25:20,764
>> 好了，我做的是一件容易的事。

577
00:25:20,764 --> 00:25:23,930
当然，我可以预装
Excel或数字，或其他程序。

578
00:25:23,930 --> 00:25:25,846
但是，这是很好的，因为
现在我可以操纵

579
00:25:25,846 --> 00:25:28,090
在标准格式中的数据。

580
00:25:28,090 --> 00:25:30,294
>> 所以，现在我们的上下文
切换到我们离开

581
00:25:30,294 --> 00:25:32,710
最后的时间，这是开始
起飞训练车轮。

582
00:25:32,710 --> 00:25:34,543
但首先，你没有
看到这个前面的午餐

583
00:25:34,543 --> 00:25:38,150
再次发生在这里的消防和
冰在剑桥，西塔在纽黑文。

584
00:25:38,150 --> 00:25:43,150
注册在CS50s网站尽快
加入CS50的学生和工作人员。

585
00:25:43,150 --> 00:25:46,090
>> 因此，我们采取了辅助轮
关闭周一follows--

586
00:25:46,090 --> 00:25:49,120
串已被宣布
CS50s库一段时间。

587
00:25:49,120 --> 00:25:52,650
而且这是不错的，因为它允许
我们谈论的变量作为

588
00:25:52,650 --> 00:25:54,660
完整的单词和句子等。

589
00:25:54,660 --> 00:25:56,710
但事实证明字符串不存在。

590
00:25:56,710 --> 00:26:00,200
这仅仅是同义词，或别名，
我们已经对一些创建

591
00:26:00,200 --> 00:26:03,780
其实是多一点
技术称为一个char *。

592
00:26:03,780 --> 00:26:07,900
>> 事实上，我们看到了一个例子
周一计划

593
00:26:07,900 --> 00:26:11,200
这并没有表现得如我们预期。

594
00:26:11,200 --> 00:26:13,630
这是文件，比较-0。

595
00:26:13,630 --> 00:26:17,910
而记得比较-0，如果
我重新编译周一的节目

596
00:26:17,910 --> 00:26:22,670
并运行比较-0与2型糖尿病的妈妈
小写，妈妈用小写了。

597
00:26:22,670 --> 00:26:25,320
该方案坚持我
输入不同的东西，

598
00:26:25,320 --> 00:26:29,210
即使妈妈，都在
小写的，是一样的视觉。

599
00:26:29,210 --> 00:26:31,990
那么，什么是简单的答案
为什么电脑认为

600
00:26:31,990 --> 00:26:34,500
这两个字符串是不同的？

601
00:26:34,500 --> 00:26:35,250
是吗？

602
00:26:35,250 --> 00:26:36,534
>> 听众：[听不清]

603
00:26:36,534 --> 00:26:37,450
DAVID J.马兰：没错。

604
00:26:37,450 --> 00:26:39,600
所以，妈妈，第一次
我在键入它，正在

605
00:26:39,600 --> 00:26:42,710
地方保存在我的电脑
存储器但在不同的位置

606
00:26:42,710 --> 00:26:44,690
比我第二次输入的妈妈。

607
00:26:44,690 --> 00:26:46,580
现在，它肯定可以优化。

608
00:26:46,580 --> 00:26:49,205
计算机可以是聪明，
实现这两个字符串，哎，

609
00:26:49,205 --> 00:26:49,954
他们是相同的。

610
00:26:49,954 --> 00:26:51,520
让我没有冗余存储。

611
00:26:51,520 --> 00:26:54,229
但是，计算机不这样做
优化，除非你告诉他们。

612
00:26:54,229 --> 00:26:56,061
因此，在默认情况下，他们是
只是要结束了

613
00:26:56,061 --> 00:26:57,670
在内存中的两个不同的地方。

614
00:26:57,670 --> 00:27:01,570
所以更清晰，当
我们比较两个字符串，

615
00:27:01,570 --> 00:27:03,950
第一个被称为S，
第二个被称为

616
00:27:03,950 --> 00:27:08,530
T，具体什么是我
这里比较第13行？

617
00:27:08,530 --> 00:27:09,494
是啊。

618
00:27:09,494 --> 00:27:12,390
>> 听众：这是在内存中的位置
该变量将指向。

619
00:27:12,390 --> 00:27:14,900
>> DAVID J.马兰：没错，我是
比较在存储器中的位置

620
00:27:14,900 --> 00:27:16,300
这些变量指向。

621
00:27:16,300 --> 00:27:20,560
因此，特别是，如果妈妈是在
字节号1，和2和3，

622
00:27:20,560 --> 00:27:24,020
和4--因为记住的反斜杠
0需要是一路在末端。

623
00:27:24,020 --> 00:27:29,420
和妈妈，M-O-M的另一个实例，
是在地址10，11，12，和13。

624
00:27:29,420 --> 00:27:33,100
我是比较1，该地址，
在存储器中的位置，

625
00:27:33,100 --> 00:27:35,160
对10，这是
明显不一样。

626
00:27:35,160 --> 00:27:36,260
1不是10。

627
00:27:36,260 --> 00:27:39,620
>> 因此，这是很好的在
这是非常简单的。

628
00:27:39,620 --> 00:27:42,870
但它是有问题的，只要
我们似乎无法比较字符串。

629
00:27:42,870 --> 00:27:44,930
所以fundamentally--
并且在该低的水平，

630
00:27:44,930 --> 00:27:47,300
如果你想实现
方案比较

631
00:27:47,300 --> 00:27:50,270
两个独立的词了
用户键入的质量，

632
00:27:50,270 --> 00:27:53,944
做自己排队字符为
炭，只是条件一般，

633
00:27:53,944 --> 00:27:55,360
我们需要什么做的，显然是？

634
00:27:55,360 --> 00:27:57,940
这是不够的只是
看看这两个地址。

635
00:27:57,940 --> 00:27:58,860
什么是我们需要做什么？

636
00:27:58,860 --> 00:27:59,360
是吗？

637
00:27:59,360 --> 00:28:01,120
>> 听众：遍历
字符串[听不清]。

638
00:28:01,120 --> 00:28:02,600
>> DAVID J.马兰：是啊，让我们
遍历字符串。

639
00:28:02,600 --> 00:28:05,808
让我们用一个for循环，while循环，或
无论你是最舒服的。

640
00:28:05,808 --> 00:28:08,840
如果我们有两个字符串的地方
在内存中，让我们来看看各的

641
00:28:08,840 --> 00:28:11,770
第一个字符，那么每个第二
字符，则第三和第四，

642
00:28:11,770 --> 00:28:15,206
第五，直到我们打
有什么特殊的标记值？

643
00:28:15,206 --> 00:28:16,080
听众：[听不清]

644
00:28:16,080 --> 00:28:18,800
DAVID J.马兰：是啊，反斜线
零，在该点在任一字符串

645
00:28:18,800 --> 00:28:20,100
我们可以决定就是这样。

646
00:28:20,100 --> 00:28:21,970
我们有没有匹配的每一个人物？

647
00:28:21,970 --> 00:28:22,990
如果不是，返回false。

648
00:28:22,990 --> 00:28:24,770
如果是的话，返回true。

649
00:28:24,770 --> 00:28:28,800
所以这正是这个版本
该方案的比较-1.C一样。

650
00:28:28,800 --> 00:28:31,677
它等同于我们
看着除了星期一，我已经

651
00:28:31,677 --> 00:28:34,760
摆脱了字string--的，虽然
有没有功能impact--所有

652
00:28:34,760 --> 00:28:37,450
我现在做的是消除
一些视觉辅助轮，

653
00:28:37,450 --> 00:28:40,880
但要清醒地看到，
s和t地址。

654
00:28:40,880 --> 00:28:43,020
这就是明星，
星号代表

655
00:28:43,020 --> 00:28:46,690
是一个地址，或称为
更多技术上的一个指针。

656
00:28:46,690 --> 00:28:49,880
>> 所以，当我在申报小号
第9行，说的char * S，

657
00:28:49,880 --> 00:28:52,160
这并不意味着给我一个字符串。

658
00:28:52,160 --> 00:28:56,360
这意味着给我一个变量，其
生活目的是存储一个地址。

659
00:28:56,360 --> 00:29:00,400
因为我即将把
字符串转换成它的地址。

660
00:29:00,400 --> 00:29:03,500
事实上，GetString的，是
清晰，不返回一个字符串。

661
00:29:03,500 --> 00:29:06,110
它不返回的妈妈
反斜杠零，本身。

662
00:29:06,110 --> 00:29:10,005
什么是GetString的具体
而恰恰回来吗？

663
00:29:10,005 --> 00:29:10,880
听众：[听不清]

664
00:29:10,880 --> 00:29:14,080
DAVID J.马兰：一个地址，
第一个字符的地址

665
00:29:14,080 --> 00:29:16,070
在一些字符串就已经得到了。

666
00:29:16,070 --> 00:29:19,250
所以现在我们所看到的
一个特殊的关键字了。

667
00:29:19,250 --> 00:29:20,640
而且，我提到这点。

668
00:29:20,640 --> 00:29:23,620
这将是好习惯
我们会一次又一次地看到了。

669
00:29:23,620 --> 00:29:27,540
我检查，以确保
s是不为空，t为不为空。

670
00:29:27,540 --> 00:29:30,100
因为根据我真的
快速提早些时候，

671
00:29:30,100 --> 00:29:35,510
什么可能意味着，如果GetString的返回不
一个地址，但N-二U-L-L，这是再一次，

672
00:29:35,510 --> 00:29:36,990
一些特殊的价值？

673
00:29:36,990 --> 00:29:37,890
>> 听众：错误。

674
00:29:37,890 --> 00:29:38,600
>> DAVID J.马兰：这是一个错误。

675
00:29:38,600 --> 00:29:39,550
出了些问题。

676
00:29:39,550 --> 00:29:41,341
什么一般
可能发生的事情，尤其是

677
00:29:41,341 --> 00:29:45,162
与strings--可能
未知长度advance--的

678
00:29:45,162 --> 00:29:46,870
也许是电脑“
内存不足，可能

679
00:29:46,870 --> 00:29:49,280
你在这种类型的
长字或句子

680
00:29:49,280 --> 00:29:51,880
或粘贴这样一个庞大的作文
那里只是没有足够的内存。

681
00:29:51,880 --> 00:29:55,340
所以GetString的不能返回
整个事情的地址，

682
00:29:55,340 --> 00:29:56,620
所以它只是没有返回值。

683
00:29:56,620 --> 00:30:00,580
它说，一个错误已经发生
通过返回特殊的NULL值。

684
00:30:00,580 --> 00:30:02,890
这是零地址，可以这么说。

685
00:30:02,890 --> 00:30:06,157
>> 现在事实证明，C提供一
函数，它的迭代。

686
00:30:06,157 --> 00:30:09,240
我们没有一起实现这个
一个for循环或while循环自己。

687
00:30:09,240 --> 00:30:11,150
我们可以用一个函数，
所谓的简洁，

688
00:30:11,150 --> 00:30:15,400
搅拌补偿，或字符串比较，其
人生目标是做这一点。

689
00:30:15,400 --> 00:30:19,990
你给它两个指针，两个地址，
它会去到这些地址

690
00:30:19,990 --> 00:30:23,130
然后比较信
信信的质量，

691
00:30:23,130 --> 00:30:26,610
停止，只有当什么是真的吗？

692
00:30:26,610 --> 00:30:31,540
当直觉上应该挑起补偿
停止迭代，只是要清楚吗？

693
00:30:31,540 --> 00:30:35,400
当它击中一个反斜杠0在任
串，在这一点上，它可以决定

694
00:30:35,400 --> 00:30:38,910
拥有一切匹配，或
以前有差异？

695
00:30:38,910 --> 00:30:42,740
>> 所以，如果我们运行这个现在尝试
我们的小市值的比赛，

696
00:30:42,740 --> 00:30:49,260
因此要比较-1，./compare-1和
键入小写字母妈妈两次。

697
00:30:49,260 --> 00:30:50,560
现在，同样的事情。

698
00:30:50,560 --> 00:30:54,080
如果我再这样做有
小写再大写的可能。

699
00:30:54,080 --> 00:30:56,720
现在，它的确与众不同
之间大写和小写。

700
00:30:56,720 --> 00:31:00,440
所以，不是所有的硬或
神奇，但它现在解释

701
00:31:00,440 --> 00:31:03,140
这是怎么回事引擎盖下。

702
00:31:03,140 --> 00:31:07,640
>> 那么，我们还能提取
从这种教训？

703
00:31:07,640 --> 00:31:08,980
因此，让我们来看看这个。

704
00:31:08,980 --> 00:31:15,380
我要继续前进，写一个
快速程序这里所说的复制0。

705
00:31:15,380 --> 00:31:21,594
现在让我们继续前进，实际上
让我们做this--复制 -  0，

706
00:31:21,594 --> 00:31:23,010
看看我在这里得到了什么。

707
00:31:23,010 --> 00:31:24,712
我首先告诉用户，说些什么。

708
00:31:24,712 --> 00:31:26,420
然后，我得到一个字符串
我将其存储在s中。

709
00:31:26,420 --> 00:31:29,810
然后我检查如果s等于
等于NULL，只返回1。

710
00:31:29,810 --> 00:31:31,590
因此，这仅仅是标准的错误检查。

711
00:31:31,590 --> 00:31:33,112
没有什么有趣的事情发生了。

712
00:31:33,112 --> 00:31:36,320
而事实上，如果我们摆脱错误
检查，这看起来像本周1码

713
00:31:36,320 --> 00:31:36,985
眼下。

714
00:31:36,985 --> 00:31:39,110
但是我已经开始获得
稍微好有关。

715
00:31:39,110 --> 00:31:43,340
>> 现在，在第16行，一个星期前，也许
甚至几天或分钟前，

716
00:31:43,340 --> 00:31:46,720
你可能会说行16
创建一个变量称为T

717
00:31:46,720 --> 00:31:48,219
和复制s转换它。

718
00:31:48,219 --> 00:31:50,010
这是一个完美的
合理的外卖。

719
00:31:50,010 --> 00:31:51,560
但更准确了。

720
00:31:51,560 --> 00:31:54,190
什么是发生在第16行？

721
00:31:54,190 --> 00:31:56,170
什么是得到复制
从右到左？

722
00:31:56,170 --> 00:31:56,669
是吗？

723
00:31:56,669 --> 00:31:58,490
听众：为T获得第一个地址？

724
00:31:58,490 --> 00:32:01,220
>> DAVID J.马兰：没错，T
越来越s的地址。

725
00:32:01,220 --> 00:32:05,170
所以，现在要清楚，如果我去
回到那个前面的例子

726
00:32:05,170 --> 00:32:08,520
我抽出我已经输入了的事情。

727
00:32:08,520 --> 00:32:11,640
而我所键入的
in--这里的s和这里

728
00:32:11,640 --> 00:32:15,830
是我所键入的某处
内存，妈妈再一个反斜杠

729
00:32:15,830 --> 00:32:17,840
0了加我。

730
00:32:17,840 --> 00:32:23,060
我存放在这里，回想一下，
这是在位置1，2，3，4，

731
00:32:23,060 --> 00:32:24,655
这是何等的当前秒。

732
00:32:24,655 --> 00:32:29,220
因此，如果第16行，我说给我
另一个变量称为T和存储

733
00:32:29,220 --> 00:32:33,590
在s的值，什么
在这里获取存储不会妈

734
00:32:33,590 --> 00:32:35,480
而是仅仅数字1。

735
00:32:35,480 --> 00:32:38,520
>> 因此，如果我们向前看这个程序中
现在，有什么事情发生？

736
00:32:38,520 --> 00:32:40,690
所以发现有
这个功能你可能

737
00:32:40,690 --> 00:32:44,410
已经前段时间用这个凯撒，
或的Vigenere，或者根本没有。

738
00:32:44,410 --> 00:32:48,170
我要求我的printf，我
要利用复制吨。

739
00:32:48,170 --> 00:32:51,616
首先在第19行，快速神智
检查，T的strlen的检查长度。

740
00:32:51,616 --> 00:32:53,740
因为我不希望
尽量利用的东西

741
00:32:53,740 --> 00:32:55,104
如果没有串存在。

742
00:32:55,104 --> 00:32:57,520
如果用户只需要敲击回车，
没有什么把握。

743
00:32:57,520 --> 00:33:01,100
所以，我不想做线21。

744
00:33:01,100 --> 00:33:05,758
因此，第21行正在利用
这封信，显然，在T？

745
00:33:05,758 --> 00:33:06,514
>> 听众：M？

746
00:33:06,514 --> 00:33:08,722
DAVID J.马兰：它看起来
喜欢它的拷贝哪一个？

747
00:33:08,722 --> 00:33:09,486
听众：M。

748
00:33:09,486 --> 00:33:10,450
DAVID J.马兰：嗯，男。

749
00:33:10,450 --> 00:33:12,685
好了，第一个男，
因为通知说我

750
00:33:12,685 --> 00:33:14,935
传递给TOUPPER，这
如果你从来没有见过它的

751
00:33:14,935 --> 00:33:16,980
只是一个函数来
利用作为其输入。

752
00:33:16,980 --> 00:33:20,240
Ť支架零意味着放弃
我T的零字符。

753
00:33:20,240 --> 00:33:22,550
所以，如何做到这一点
画面切换，要清楚吗？

754
00:33:22,550 --> 00:33:25,490

755
00:33:25,490 --> 00:33:29,160
需要得到什么重写或者改变
相对于s和t和妈妈

756
00:33:29,160 --> 00:33:30,097
反斜线零。

757
00:33:30,097 --> 00:33:31,470
>> 听众：[听不清]

758
00:33:31,470 --> 00:33:34,030
>> DAVID J.马兰：是啊，
所以这一块在这里简单地

759
00:33:34,030 --> 00:33:40,860
需要得到改变用于：修复this--
需要得到改为大写M。

760
00:33:40,860 --> 00:33:44,330
但现在，在后来的看
程序，如果我打印出来

761
00:33:44,330 --> 00:33:49,800
S和T为我打扫这里，看什么
事情发生打印出s和t。

762
00:33:49,800 --> 00:33:54,310
因此，请复制0，./copy-0。

763
00:33:54,310 --> 00:33:57,140
让我继续前进，键入
在妈妈的全部小写。

764
00:33:57,140 --> 00:34:00,140
注意原始和
该副本已资本化。

765
00:34:00,140 --> 00:34:00,850
为什么呢？

766
00:34:00,850 --> 00:34:04,431
那么，S和T都指向，
如果你愿意，相同的内存块。

767
00:34:04,431 --> 00:34:06,930
坦率地说，这是越来越
真正uninteresting--事实

768
00:34:06,930 --> 00:34:09,150
我们使用零地址在这里。

769
00:34:09,150 --> 00:34:11,719
我的意思是，我真的不关心
那里的东西是在内存中。

770
00:34:11,719 --> 00:34:13,550
对不起，我抹去一点也不为过。

771
00:34:13,550 --> 00:34:15,674
但我真的不关心
那里的东西都在内存中。

772
00:34:15,674 --> 00:34:18,510
所以，确实是
程序员倾向于考虑

773
00:34:18,510 --> 00:34:21,080
就是当你谈论
一个地址，或者一个指针，

774
00:34:21,080 --> 00:34:22,679
谁在乎它是在内存中。

775
00:34:22,679 --> 00:34:24,989
我不关心，如果它在
字节一或一十亿。

776
00:34:24,989 --> 00:34:27,920
我只关心这个
变量是有效的

777
00:34:27,920 --> 00:34:29,620
指向的内存块。

778
00:34:29,620 --> 00:34:33,350
所以，从今以后，而不是狡辩
在任意的内存地址，让我们

779
00:34:33,350 --> 00:34:36,710
刚开始绘制指针
作为指针，为箭头。

780
00:34:36,710 --> 00:34:39,340
那么，S和T真的，
根据这一计划，

781
00:34:39,340 --> 00:34:42,130
因为我是如何创建的T，
这只是两个独立的变量

782
00:34:42,130 --> 00:34:43,840
指向相同的内存块。

783
00:34:43,840 --> 00:34:45,215
我们不关心他们在哪里。

784
00:34:45,215 --> 00:34:47,130
所以我们可以抽象掉的细节。

785
00:34:47,130 --> 00:34:48,780
>> 那么，如何解决这一问题？

786
00:34:48,780 --> 00:34:54,120
如果我想编写一个版本的副本
项目实际的字符串复制

787
00:34:54,120 --> 00:34:56,840
只有大写
副本，只是凭直觉，

788
00:34:56,840 --> 00:34:59,766
真实得到了什么是一个
成份，我们的解决方案？

789
00:34:59,766 --> 00:35:00,640
听众：[听不清]

790
00:35:00,640 --> 00:35:01,420
DAVID J.马兰：我们需要什么？

791
00:35:01,420 --> 00:35:01,820
听众：内存块。

792
00:35:01,820 --> 00:35:03,280
DAVID J.马兰：我们需要
内存另一块，对不对？

793
00:35:03,280 --> 00:35:05,360
我们不知道如何
做到这一点的是，不一定。

794
00:35:05,360 --> 00:35:11,330
但我有种需要做到这一点，以便
在小写原妈

795
00:35:11,330 --> 00:35:14,170
在额外的内存块结束。

796
00:35:14,170 --> 00:35:19,770
然后当我改变的副本，我
不想在这里改变此副本。

797
00:35:19,770 --> 00:35:26,020
我不是想改变仅此
副本使原来的不变。

798
00:35:26,020 --> 00:35:27,980
>> 那么，让我们看看我们如何做到这一点。

799
00:35:27,980 --> 00:35:31,800
在copy-1，它已经
被剥夺了评论，

800
00:35:31,800 --> 00:35:33,250
但网上评论道。

801
00:35:33,250 --> 00:35:36,710
我们不是做following--这些
线是相同的，给我一个字符串

802
00:35:36,710 --> 00:35:38,340
并称之为秒。

803
00:35:38,340 --> 00:35:43,500
但是，现在让我们来看看我们的最多一个
复杂的，但在过去的复杂性

804
00:35:43,500 --> 00:35:47,340
一段时间，第16行正是这一点。

805
00:35:47,340 --> 00:35:49,400
因此，如果与您的舒适
图片我们只是drew--

806
00:35:49,400 --> 00:35:51,790
给我一个新的内存块，
所有内容复制到它，

807
00:35:51,790 --> 00:35:53,730
让我们看看如何把这种代码。

808
00:35:53,730 --> 00:35:59,400
>> 因此线16，在左手侧，
字符* T给我这个盒子在这里。

809
00:35:59,400 --> 00:36:00,230
这就是它。

810
00:36:00,230 --> 00:36:03,240
在右手侧，
米ALLOC，或malloc的，

811
00:36:03,240 --> 00:36:06,480
是内存分配，超花哨，
只是说，一个神秘的方式

812
00:36:06,480 --> 00:36:07,640
给我一个内存块。

813
00:36:07,640 --> 00:36:09,290
多少内存，我们需要什么？

814
00:36:09,290 --> 00:36:10,910
那么，是怎样的一个大的表现。

815
00:36:10,910 --> 00:36:12,570
但是让我们看看它说在这里。

816
00:36:12,570 --> 00:36:15,940
因此，这当然是给
我s的字符串长度。

817
00:36:15,940 --> 00:36:19,094
因此，母亲应该是什么呢？

818
00:36:19,094 --> 00:36:21,010
所以只有三个，对吗？
妈妈是三个大字。

819
00:36:21,010 --> 00:36:22,830
你不要指望了
反斜杠零，当你

820
00:36:22,830 --> 00:36:25,960
谈论一个字符串它的长度
其实人类可见的字母。

821
00:36:25,960 --> 00:36:28,020
所以妈妈，所以这给了我3。

822
00:36:28,020 --> 00:36:31,170
但是且慢，我现在加1。

823
00:36:31,170 --> 00:36:34,861
为什么我真的想
分配4个字节，而不仅仅是3？

824
00:36:34,861 --> 00:36:35,360
是吗？

825
00:36:35,360 --> 00:36:36,910
>> 顾客：定点价值？

826
00:36:36,910 --> 00:36:38,951
>> DAVID J.马兰：没错，
该标记值。

827
00:36:38,951 --> 00:36:40,840
对于反斜杠零，
我需要总共4个字节。

828
00:36:40,840 --> 00:36:42,870
所以，我需要的长度
字符串加1。

829
00:36:42,870 --> 00:36:45,400
然后就是好measure--
即使在这个系统上，

830
00:36:45,400 --> 00:36:49,390
它总是将是1--我说
通过一个char的大小乘这一点。

831
00:36:49,390 --> 00:36:51,552
原来的si​​zeof是
C中的运算符

832
00:36:51,552 --> 00:36:53,260
只是告诉你的
字节数这

833
00:36:53,260 --> 00:36:54,700
所需的一定的数据类型。

834
00:36:54,700 --> 00:36:57,740
它不会对数组工作，
典型地，有时它。

835
00:36:57,740 --> 00:36:59,210
但在一般情况下，没有。

836
00:36:59,210 --> 00:37:02,330
但是，它会告诉我有多少字节
char是，这原来是始终为1。

837
00:37:02,330 --> 00:37:04,080
所以，这就像乘以1。

838
00:37:04,080 --> 00:37:05,900
>> 因此，超级神秘的期待一行代码。

839
00:37:05,900 --> 00:37:09,320
但它是所有给出
我的内存块。

840
00:37:09,320 --> 00:37:13,590
但它似乎是复制
任何东西到了内存？

841
00:37:13,590 --> 00:37:14,560
还没。

842
00:37:14,560 --> 00:37:22,040
所以，我该怎么上线22和
23，24，25，好了，我只是做到这一点。

843
00:37:22,040 --> 00:37:23,760
这是排序
老同学现在的东西。

844
00:37:23,760 --> 00:37:26,010
这就好比PSET 2，其中
你只是搬东西

845
00:37:26,010 --> 00:37:28,620
各地在内存中，或者说在字符串中。

846
00:37:28,620 --> 00:37:31,920
>> 所以，我从0迭代到
的串s的长度。

847
00:37:31,920 --> 00:37:37,820
而我复制第i个字符
以s成吨的第i个字符。

848
00:37:37,820 --> 00:37:41,820
而且因为我，程序员，做
一定要准确地分配尽可能多的字节

849
00:37:41,820 --> 00:37:44,600
因为我需要，这是完美的
一对一的关系。

850
00:37:44,600 --> 00:37:47,060
我复制的妈妈在
小写的新的。

851
00:37:47,060 --> 00:37:50,170
然后，最后，我做这行。

852
00:37:50,170 --> 00:37:54,637
等的效果只有
在这里利用这件T。

853
00:37:54,637 --> 00:37:56,470
因此，大量吸纳，但
如果你只是考虑

854
00:37:56,470 --> 00:37:58,220
到底发生了什么
在发动机罩下方

855
00:37:58,220 --> 00:38:00,880
只是将这些
字节左右，所有的

856
00:38:00,880 --> 00:38:06,617
是需要解决这个问题是
只给我们这一块内存。

857
00:38:06,617 --> 00:38:08,450
现在的风险
铺天盖地，让我告诉

858
00:38:08,450 --> 00:38:13,200
另外一个例子，几乎
相同的，除了这一个

859
00:38:13,200 --> 00:38:14,350
一行代码。

860
00:38:14,350 --> 00:38:18,870
因此，这是黑客版
这个方案的，如果你愿意。

861
00:38:18,870 --> 00:38:21,050
但是，我们只是提取
它变成了什么事情。

862
00:38:21,050 --> 00:38:28,920
24号线使用的是这件T
支架我得到小号支架我。

863
00:38:28,920 --> 00:38:33,370
现在，我改变了这
在更神秘的星牛逼

864
00:38:33,370 --> 00:38:36,280
加1等于歌星般加1。

865
00:38:36,280 --> 00:38:38,702
>> 所以发生了什么以及为什么
我们有一个明星人物？

866
00:38:38,702 --> 00:38:41,410
我们已经看到的明星面前，
它被用于不同的位置。

867
00:38:41,410 --> 00:38:45,490
我们之前看到的字符*，现在我看到
阿星在一开始，这就是确定。

868
00:38:45,490 --> 00:38:48,190
因为事实证明我们
可以种推断只是

869
00:38:48,190 --> 00:38:50,280
从这些第一
原则是怎么回事。

870
00:38:50,280 --> 00:38:53,860
所以，仅仅是明确的，什么是S'

871
00:38:53,860 --> 00:38:55,052
上周，它是一个字符串。

872
00:38:55,052 --> 00:38:56,260
这并不足够了。

873
00:38:56,260 --> 00:38:57,690
什么是S，具体一点吗？

874
00:38:57,690 --> 00:38:58,590
>> 听众：[听不清]

875
00:38:58,590 --> 00:38:59,881
>> DAVID J.马兰：这是一个指针。

876
00:38:59,881 --> 00:39:02,610
它的地址
第一个字符我们输入研究。

877
00:39:02,610 --> 00:39:04,780
OK，什么为t？

878
00:39:04,780 --> 00:39:05,660
>> 听众：[听不清]

879
00:39:05,660 --> 00:39:07,950
>> DAVID J.马兰：本
的第一个字节的地址

880
00:39:07,950 --> 00:39:10,490
在T，该内存块重新分配。

881
00:39:10,490 --> 00:39:14,720
所以，事实证明，当我们
从0迭代，一直到字符串

882
00:39:14,720 --> 00:39:17,424
length--首先，我
从0开始关闭，因为

883
00:39:17,424 --> 00:39:18,840
这个老同学for循环的事情。

884
00:39:18,840 --> 00:39:22,400
因此，只是为了简单起见，我们
假设的代码，所述第一线

885
00:39:22,400 --> 00:39:23,760
真的只是这样，对吧。

886
00:39:23,760 --> 00:39:26,080
如果i为零，加零
的东西想必

887
00:39:26,080 --> 00:39:27,540
是不会有效果。

888
00:39:27,540 --> 00:39:28,560
>> 那么，这是什么意思吗？

889
00:39:28,560 --> 00:39:31,600
事实证明，明星
操作者在这样的背景下

890
00:39:31,600 --> 00:39:33,700
是取消引用
操作者，这仅仅是

891
00:39:33,700 --> 00:39:37,530
说法去一个奇特的方式
到以下地址。

892
00:39:37,530 --> 00:39:42,080
因此，如果s是第一的地址
字符在这个组块的存储器，

893
00:39:42,080 --> 00:39:43,630
* S表示去那里。

894
00:39:43,630 --> 00:39:45,630
因为我们已经开
图像以这种方式，

895
00:39:45,630 --> 00:39:47,430
您可以采用
下面的心智模式。

896
00:39:47,430 --> 00:39:51,030
如果这是S，和你说* S，* S
有点像槽和梯子，

897
00:39:51,030 --> 00:39:54,540
如果你从童年记忆的比赛中，
就像按照箭头，去

898
00:39:54,540 --> 00:39:55,570
到的地址。

899
00:39:55,570 --> 00:39:57,080
>> * t是同样的事情。

900
00:39:57,080 --> 00:39:59,855
所以从这里开始，去它的块。

901
00:39:59,855 --> 00:40:03,350
我不能只是借鉴
该屏幕的方式。

902
00:40:03,350 --> 00:40:05,560
* T手段去这里。

903
00:40:05,560 --> 00:40:08,830
然后，for循环仅仅是
这里说动这个角色，

904
00:40:08,830 --> 00:40:11,330
这里将这个人物，
搬到这里来这个角色。

905
00:40:11,330 --> 00:40:12,890
但我怎么做增量？

906
00:40:12,890 --> 00:40:15,430
我要撤销我刚刚删除。

907
00:40:15,430 --> 00:40:18,140
这是什么一般称为
指针运算，这

908
00:40:18,140 --> 00:40:20,040
意味着数学与地址。

909
00:40:20,040 --> 00:40:22,460
>> 如果在此for循环，
我不断递增我，

910
00:40:22,460 --> 00:40:26,880
且s是一个地址，而t是一个
地址，如果我只是不断增加1，

911
00:40:26,880 --> 00:40:31,406
这只是意味着不断前进，
转发和转发在内存中。

912
00:40:31,406 --> 00:40:34,030
这就像牛津大街，
街道，政务司司长建设上。

913
00:40:34,030 --> 00:40:36,490
在CS建筑物是在33牛津街。

914
00:40:36,490 --> 00:40:39,870
所以，如果你是做33
牛津街加1，

915
00:40:39,870 --> 00:40:42,870
，带你到34牛津
街道，35个牛津街，

916
00:40:42,870 --> 00:40:46,380
那么牛津街36，不管这些
建筑居然是 - 如果它们存在。

917
00:40:46,380 --> 00:40:50,540
所以，这就是我们正在做的
这里有指针运算。

918
00:40:50,540 --> 00:40:53,820
>> 所以这是一个非常神秘的方式
的表达自己。

919
00:40:53,820 --> 00:40:56,160
但是，所有发生的事情
引擎盖下

920
00:40:56,160 --> 00:40:59,330
只是下面的这些地址，
就像下面的地图，如果你愿意，

921
00:40:59,330 --> 00:41:02,692
或以下似箭
我们已经在屏幕上绘制。

922
00:41:02,692 --> 00:41:04,910
OK，很多消化。

923
00:41:04,910 --> 00:41:10,410
对语法有任何问题，概念，
指针，malloc或类似物。

924
00:41:10,410 --> 00:41:11,480
是啊，在这里第一次。

925
00:41:11,480 --> 00:41:13,755
>> 听众：那么，这
说* T等于TOUPPER * T，

926
00:41:13,755 --> 00:41:15,575
就是要利用
所有的字母或just--

927
00:41:15,575 --> 00:41:17,283
>> DAVID J.马兰：啊，
非常好的问题。

928
00:41:17,283 --> 00:41:19,805
因此，在这条线在这里，31，
这是怎么回事充分利用

929
00:41:19,805 --> 00:41:21,430
第一个字母或所有字母。

930
00:41:21,430 --> 00:41:23,460
因此，让我们回答这个问题通过去
回到第一个原则。

931
00:41:23,460 --> 00:41:26,168
在这里，第一个原则，我的意思是
刚去的基本定义

932
00:41:26,168 --> 00:41:27,000
一个什么样的参与。

933
00:41:27,000 --> 00:41:29,770
所以TOUPPER是一个功能
这一个大写字符。

934
00:41:29,770 --> 00:41:30,530
就这样。

935
00:41:30,530 --> 00:41:36,740
* t表示进入first--
去T中的地址。

936
00:41:36,740 --> 00:41:40,350
所以，在图像，如果这是块
内存我们使用malloc分配，

937
00:41:40,350 --> 00:41:43,310
这是T，* T手段去这里。

938
00:41:43,310 --> 00:41:46,710
>> 同时，你传递
该值，小写字母m

939
00:41:46,710 --> 00:41:50,040
到TOUPPER，你要回
外资并购，你在哪里把它？

940
00:41:50,040 --> 00:41:52,410
你把它在同一位置。

941
00:41:52,410 --> 00:41:55,540
所以那些对这种逻辑
基本的定义，这只是

942
00:41:55,540 --> 00:41:58,792
大写的第一个字母
除非你用迭代我或

943
00:41:58,792 --> 00:42:02,000
for循环或while循环，它不会
做任何事情比你问吧。

944
00:42:02,000 --> 00:42:02,583
好问题。

945
00:42:02,583 --> 00:42:03,237
是吗？

946
00:42:03,237 --> 00:42:05,369
>> 听众：你为什么使用
取消引用的方法，而不是

947
00:42:05,369 --> 00:42:05,979
数组？

948
00:42:05,979 --> 00:42:07,395
>> DAVID J.马兰：啊，好问题。

949
00:42:07,395 --> 00:42:10,672
为什么你会使用反引用
方法，而不是在阵列的方法？

950
00:42:10,672 --> 00:42:12,130
没有特别的原因，是诚实的。

951
00:42:12,130 --> 00:42:15,290
而且，事实上，对于这种
样的例子吧，

952
00:42:15,290 --> 00:42:17,556
我只是争论使得
程序比较复杂，

953
00:42:17,556 --> 00:42:19,680
更多的目光都呆滞，
人们退房

954
00:42:19,680 --> 00:42:22,830
因为这看起来超级神秘，但是
即使它在做同样的事情。

955
00:42:22,830 --> 00:42:26,695
所以，坦率地说，这是一个
不必要的视觉复杂的解决方案

956
00:42:26,695 --> 00:42:27,320
到的问题。

957
00:42:27,320 --> 00:42:29,580
>> 它仍然是良好的设计，
五个五的设计，

958
00:42:29,580 --> 00:42:33,140
无论是在支架
符号或指针符号。

959
00:42:33,140 --> 00:42:36,299
但是 - 特别是当我们得到
在以后的过程中PSET 5

960
00:42:36,299 --> 00:42:39,340
当我们执行该字典，
我已经提到了几个times--的

961
00:42:39,340 --> 00:42:42,300
我们真正关心的
低级别的内存地址

962
00:42:42,300 --> 00:42:44,140
我们真正理解
这是怎么回事。

963
00:42:44,140 --> 00:42:48,300
>> 不过，就目前而言，事实证明，这
的代码在这里方括号线

964
00:42:48,300 --> 00:42:49,900
真的不存在。

965
00:42:49,900 --> 00:42:52,230
他们就是被称为
语法糖，这

966
00:42:52,230 --> 00:42:58,390
仅仅是一个古怪爽说的方式
编译器会将方括号是

967
00:42:58,390 --> 00:43:00,420
该数学表达式。

968
00:43:00,420 --> 00:43:02,660
所以这是一个人的约定
要能只写

969
00:43:02,660 --> 00:43:04,220
这些非常人性化的支架。

970
00:43:04,220 --> 00:43:06,850
但是，编译器，铛，
真的做任何时间

971
00:43:06,850 --> 00:43:10,970
你写什么在网上突出
24，引擎盖下它真的

972
00:43:10,970 --> 00:43:12,330
将其转换为此。

973
00:43:12,330 --> 00:43:16,200
这只是作为一个人更愉快
读取和写入的代码如线路24。

974
00:43:16,200 --> 00:43:18,530
但最终这些
培训轮子太脱落

975
00:43:18,530 --> 00:43:21,780
当一个人的自己的舒适性变得更强。

976
00:43:21,780 --> 00:43:27,240
>> 好吧，所以记得那么这
是最大的问题的排序

977
00:43:27,240 --> 00:43:27,807
我们碰上了。

978
00:43:27,807 --> 00:43:30,640
而这正是引发这整个
关于指针该死的谈话，

979
00:43:30,640 --> 00:43:32,340
和地址，以及复制的东西。

980
00:43:32,340 --> 00:43:35,410
这是因为我们绊倒
这个愚蠢的，愚蠢的问题，即

981
00:43:35,410 --> 00:43:38,830
我实现logically--与劳伦
在这里的演示和橙汁

982
00:43:38,830 --> 00:43:43,770
在milk--完美
算法正确的函数

983
00:43:43,770 --> 00:43:47,010
用于交换两个变量“
值，但该死的东西

984
00:43:47,010 --> 00:43:50,550
没有任何持续性，或
永久的，对我的代码。

985
00:43:50,550 --> 00:43:51,820
>> 为什么是？

986
00:43:51,820 --> 00:43:54,650
简而言之，这是为什么
实施互换

987
00:43:54,650 --> 00:43:58,740
逻辑上是正确的，但没有任何影响
在传递给它的变量，

988
00:43:58,740 --> 00:44:01,119
像X和Y的主？

989
00:44:01,119 --> 00:44:02,410
什么是问题的要点？

990
00:44:02,410 --> 00:44:02,909
是吗？

991
00:44:02,909 --> 00:44:05,532
听众：因为变量进行的
变量中通副本

992
00:44:05,532 --> 00:44:06,240
通过功能。

993
00:44:06,240 --> 00:44:09,060
>> DAVID J.马兰：没错，当你通过
变量成一个函数，或参数

994
00:44:09,060 --> 00:44:11,030
到一个函数，它们是
通过复制，通过这

995
00:44:11,030 --> 00:44:14,770
意味着你得到一个相同的期待
位x和y的模式，

996
00:44:14,770 --> 00:44:15,955
这里所谓的a和b。

997
00:44:15,955 --> 00:44:18,080
你可以做任何事情
你想与这些副本，

998
00:44:18,080 --> 00:44:20,657
但他们将不得不无
在呼叫功能的影响。

999
00:44:20,657 --> 00:44:22,990
而且，事实上，我们制定了
画面在屏幕上，召回

1000
00:44:22,990 --> 00:44:25,520
最后一次，如果你由此
真正思考什么

1001
00:44:25,520 --> 00:44:28,570
怎么回事下方的hood--如果
这是你的计算机的内存，

1002
00:44:28,570 --> 00:44:31,650
而这儿是块
被用于主存储器，

1003
00:44:31,650 --> 00:44:34,020
这是对组块
被用于交换内存，

1004
00:44:34,020 --> 00:44:37,090
所以即使主要有
两个变量，x和y，

1005
00:44:37,090 --> 00:44:41,840
掉期可能具有相同的期待
值，这两者都是1和2，

1006
00:44:41,840 --> 00:44:44,520
但他们完全
不同的块的存储器。

1007
00:44:44,520 --> 00:44:46,130
>> 因此，我们需要一个解决这个。

1008
00:44:46,130 --> 00:44:51,580
坦率地说，似乎我们现在
有一个解决这个问题吧。

1009
00:44:51,580 --> 00:44:55,760
如果我们现在有能力
通过地址的方式处理事情

1010
00:44:55,760 --> 00:44:59,310
排序和，滑道和梯子
样式，请按照这些箭头

1011
00:44:59,310 --> 00:45:02,820
而且去任何地方，我们希望
在内存中，难道我们

1012
00:45:02,820 --> 00:45:06,220
解决这个问题由
从主要通过交换

1013
00:45:06,220 --> 00:45:09,650
不是值，我们要
交换，而只是凭直觉

1014
00:45:09,650 --> 00:45:11,630
什么可能我们通过交换呢？

1015
00:45:11,630 --> 00:45:12,620
>> [插入VOICES]

1016
00:45:12,620 --> 00:45:15,244
>> DAVID J.马兰：为什么我们不只是
通过它的地址，对吧？

1017
00:45:15,244 --> 00:45:17,470
我们为什么不给换一个
藏宝图，如果你愿意，

1018
00:45:17,470 --> 00:45:20,950
导致它的
实际值x和y。

1019
00:45:20,950 --> 00:45:24,340
让我们交换，真正改变
这些原始比特，而不是

1020
00:45:24,340 --> 00:45:26,797
刚好路过的位份。

1021
00:45:26,797 --> 00:45:29,130
因此，事实上，这是什么
将是该溶液中。

1022
00:45:29,130 --> 00:45:31,899
这里这个版本
显然不好，有缺陷的。

1023
00:45:31,899 --> 00:45:35,190
而现在，乍一看，它只是看起来
就像我们增加了一堆明星随机

1024
00:45:35,190 --> 00:45:37,106
并越过我们的手指
它将编译。

1025
00:45:37,106 --> 00:45:38,460
但是，它现在将汇编。

1026
00:45:38,460 --> 00:45:40,090
>> 但是，让我们看看这些东西的意思。

1027
00:45:40,090 --> 00:45:43,990
和，遗憾的是，作者
把C选择另一个符号

1028
00:45:43,990 --> 00:45:46,380
使这一点
更清晰，但星运营商

1029
00:45:46,380 --> 00:45:48,610
有不同的含义
两个不同的上下文。

1030
00:45:48,610 --> 00:45:50,890
我们已经看到了两个，
但让我们分辨。

1031
00:45:50,890 --> 00:45:55,310
>> 所以向上在那里的顶部，
当我已经改变a和b

1032
00:45:55,310 --> 00:46:00,470
被廉政局在恶劣
版本为int明星，a和b，

1033
00:46:00,470 --> 00:46:01,740
以前，都是整数。

1034
00:46:01,740 --> 00:46:05,752
什么是a和b现在在
好，绿色版？

1035
00:46:05,752 --> 00:46:06,900
他们的地址。

1036
00:46:06,900 --> 00:46:09,610
什么的，地址是明确的？

1037
00:46:09,610 --> 00:46:10,770
整数地址。

1038
00:46:10,770 --> 00:46:12,520
因此，事实上，我
他说INT星级手段

1039
00:46:12,520 --> 00:46:15,440
这是的地址
的整数，具体而言。

1040
00:46:15,440 --> 00:46:19,120
>> 所以，现在的代码行通知，
别的东西也发生了变化。

1041
00:46:19,120 --> 00:46:22,770
tmp中保持不变，因为
这只是暂时的整数，

1042
00:46:22,770 --> 00:46:24,110
没有记忆的魔法存在。

1043
00:46:24,110 --> 00:46:26,370
但现在需要一个明星。

1044
00:46:26,370 --> 00:46:28,560
而且，事实上，每一个
其他提及的a和b，

1045
00:46:28,560 --> 00:46:31,780
请注意，所有的
由红色变为绿色

1046
00:46:31,780 --> 00:46:34,209
是，我的前缀
这些变量的星星。

1047
00:46:34,209 --> 00:46:35,750
因为我不想要复制a和b。

1048
00:46:35,750 --> 00:46:40,350
因为如果我只是复制a和b和交换
A和B，那我其实交换？

1049
00:46:40,350 --> 00:46:43,760
只是地址，我想交换
什么是这些地址。

1050
00:46:43,760 --> 00:46:44,860
我想去那边。

1051
00:46:44,860 --> 00:46:48,000
这样一来，星运营商
我的函数中，

1052
00:46:48,000 --> 00:46:51,700
不参数列表内，
意味着你去到这些地址

1053
00:46:51,700 --> 00:46:54,490
而真正改变这些值。

1054
00:46:54,490 --> 00:46:56,500
>> 那么，是什么图片
现在的样子吧。

1055
00:46:56,500 --> 00:47:03,250
好吧，如果不是我传递
在A和B不1和2--

1056
00:47:03,250 --> 00:47:05,790
其实，我需要添加
这里另外一个定义。

1057
00:47:05,790 --> 00:47:09,030
因此，假设这个块
内存是在位置10。

1058
00:47:09,030 --> 00:47:12,960
>> 这是在位置11，但是这
是有点简化，

1059
00:47:12,960 --> 00:47:18,900
我现在有两个选择做我传递X
和Y或者我通过他们的地址？

1060
00:47:18,900 --> 00:47:22,500
如果我通过他们的地址
就是这样，我只是

1061
00:47:22,500 --> 00:47:25,390
现在需要实施
每绿色代码交换

1062
00:47:25,390 --> 00:47:29,080
因此，它认为当一个，当它
看到B，它不只是复制a和b

1063
00:47:29,080 --> 00:47:30,540
并移动牛奶和橙汁。

1064
00:47:30,540 --> 00:47:32,664
牛奶和橙汁
比喻现在坏了，

1065
00:47:32,664 --> 00:47:35,060
因为那些都是杯具
的液体，而不是地图。

1066
00:47:35,060 --> 00:47:37,750
我们反而需要去
解决10，我们

1067
00:47:37,750 --> 00:47:42,420
需要去解决11，和
然后执行交换逻辑。

1068
00:47:42,420 --> 00:47:45,580
>> 所以逻辑是相同的，但
我们需要一个稍微不同的方式

1069
00:47:45,580 --> 00:47:47,160
对访问这些变量。

1070
00:47:47,160 --> 00:47:52,400
所以在最后，是什么
程序有样子是这样的。

1071
00:47:52,400 --> 00:47:56,610
在swap.c逐字复制
并粘贴绿色版。

1072
00:47:56,610 --> 00:47:58,450
但我需要做一个改变。

1073
00:47:58,450 --> 00:48:00,180
这是不够的只是改变掉。

1074
00:48:00,180 --> 00:48:03,830
什么其他代码行
我是否需要改变？

1075
00:48:03,830 --> 00:48:04,330
是吗？

1076
00:48:04,330 --> 00:48:05,770
>> 听众：当它需要的参数。

1077
00:48:05,770 --> 00:48:07,603
>> DAVID J.马兰：在哪里
它需要它的参数。

1078
00:48:07,603 --> 00:48:09,985
所以，如果我向上滚动到主，我
不能仅仅通过在x和y，

1079
00:48:09,985 --> 00:48:12,820
而且，我答应，最后
一块新的语法今天。

1080
00:48:12,820 --> 00:48:17,200
我需要传递的不是X和
年，但x和y的地址。

1081
00:48:17,200 --> 00:48:20,400
而事实证明，符号
即C的作者选择

1082
00:48:20,400 --> 00:48:23,860
是，如果你在这里使用的符号，不
可与按位符号相混淆，

1083
00:48:23,860 --> 00:48:27,130
如果您使用的符号
这里和这里的符号，

1084
00:48:27,130 --> 00:48:29,570
这个数字为你，
什么是x的地址，

1085
00:48:29,570 --> 00:48:31,740
也许是10，有什么
Y的地址，也许是

1086
00:48:31,740 --> 00:48:35,400
11，并传递的那些代替。

1087
00:48:35,400 --> 00:48:37,210
>> 因此，大量吸纳的一次。

1088
00:48:37,210 --> 00:48:40,190
但是，让我们现在快速的看到
我们剩下的4分钟

1089
00:48:40,190 --> 00:48:42,150
那里的东西可能会出现偏差。

1090
00:48:42,150 --> 00:48:45,120
而作为一个不谈，实际上
我拍下了这张照片，

1091
00:48:45,120 --> 00:48:46,920
TF一年或两年前拍下了这张照片。

1092
00:48:46,920 --> 00:48:49,190
因此，这是后面的角落
艾略特食堂。

1093
00:48:49,190 --> 00:48:52,310
指针也许是最难
话题，我们将在CS50。

1094
00:48:52,310 --> 00:48:54,810
所以，如果你担心的那种
坡就像是也许是

1095
00:48:54,810 --> 00:48:56,770
更多的是曲棍球棒
这样，实现了

1096
00:48:56,770 --> 00:49:00,160
样的，我们正在接近一个高峰
术语的概念复杂性。

1097
00:49:00,160 --> 00:49:02,300
>> 我提出这个
照片，因为我发誓

1098
00:49:02,300 --> 00:49:05,920
上帝，在1996年秋季，当我把
CS50与我的助教，

1099
00:49:05,920 --> 00:49:09,620
尼沙特梅塔，他在让我坐下
角落艾略特D.厅在午餐时，

1100
00:49:09,620 --> 00:49:12,330
或晚餐，或一些尝试
帮助我理解指针。

1101
00:49:12,330 --> 00:49:16,520
而这正是我在几个星期后，
它在演讲时介绍

1102
00:49:16,520 --> 00:49:18,170
我终于明白了三分球。

1103
00:49:18,170 --> 00:49:20,590
而且我希望这
点击将远远早于你。

1104
00:49:20,590 --> 00:49:23,540
但是，认识到这一点绝对间
在更复杂的主题

1105
00:49:23,540 --> 00:49:24,420
我们已经看了。

1106
00:49:24,420 --> 00:49:25,819
但是，这其中最强大的。

1107
00:49:25,819 --> 00:49:28,860
而当你得到它，这就是全部
刚准备终于走到了一起。

1108
00:49:28,860 --> 00:49:31,460
所以放心它不会
需要在今天所有的水槽。

1109
00:49:31,460 --> 00:49:32,980
>> 因此，这里的最后一个程序
我们要去看看。

1110
00:49:32,980 --> 00:49:35,605
而我们将结束与
快速3分钟粘土动画的

1111
00:49:35,605 --> 00:49:37,030
我们的朋友，尼克Parlante进行。

1112
00:49:37,030 --> 00:49:41,440
这里有一个程序，即在前两名
行声明变量x和y。

1113
00:49:41,440 --> 00:49:44,780
这两者都是地址
整数，AKA指针。

1114
00:49:44,780 --> 00:49:48,125
然后我们分配足够的
内存来存储一个int

1115
00:49:48,125 --> 00:49:51,344
并存储地址
以x那个存储器。

1116
00:49:51,344 --> 00:49:53,260
所以，这是更简单
比以前的例子中

1117
00:49:53,260 --> 00:49:56,100
给我4个字节的内存，
这是一个int的大小，

1118
00:49:56,100 --> 00:49:58,000
并把该地址x中。

1119
00:49:58,000 --> 00:50:01,070
这条线在这里的意思
去x中的地址

1120
00:50:01,070 --> 00:50:05,270
并把意义
生活中，数字42那里。

1121
00:50:05,270 --> 00:50:07,710
不过，此行让我担心。

1122
00:50:07,710 --> 00:50:12,620
星y表示去的地址Y，
并把不吉利的数字13出现。

1123
00:50:12,620 --> 00:50:15,780
为什么是危险的，在这一点上
在story--虽然迅速告知

1124
00:50:15,780 --> 00:50:17,980
在我们的减弱分钟
这里 - 为什么是坏

1125
00:50:17,980 --> 00:50:19,660
我说，去y中的地址？

1126
00:50:19,660 --> 00:50:21,077
>> 听众：你有没有[听不清]。

1127
00:50:21,077 --> 00:50:22,910
DAVID J.马兰：我没有
放任何东西在年。

1128
00:50:22,910 --> 00:50:25,520
那么，什么是y的值，
在这一点上的故事？

1129
00:50:25,520 --> 00:50:26,570
我们不知道。

1130
00:50:26,570 --> 00:50:29,190
这是一些垃圾值
并且也不宾基知道。

1131
00:50:29,190 --> 00:50:32,532
如果我们能够结束这一点。

1132
00:50:32,532 --> 00:50:34,832
>> [视频回放]

1133
00:50:34,832 --> 00:50:36,500
>>  - 嘿，宾基，醒了。

1134
00:50:36,500 --> 00:50:39,140
现在是时候为指针乐趣。

1135
00:50:39,140 --> 00:50:40,210
>> -那是什么？

1136
00:50:40,210 --> 00:50:41,690
了解指针？

1137
00:50:41,690 --> 00:50:43,570
哦，好极了。

1138
00:50:43,570 --> 00:50:46,600
>>  - 嗯，上手的，我想我们
将需要一对夫妇指针。

1139
00:50:46,600 --> 00:50:47,380
>> -行。

1140
00:50:47,380 --> 00:50:51,120
此代码分配两个指针
它可以指向整数。

1141
00:50:51,120 --> 00:50:53,557
>>  - 确定，以及我见
两个指针，但他们

1142
00:50:53,557 --> 00:50:55,140
似乎并没有指向任何东西。

1143
00:50:55,140 --> 00:50:55,970
>> -这是正确的。

1144
00:50:55,970 --> 00:50:58,100
最初，指针
不指向任何东西。

1145
00:50:58,100 --> 00:51:00,950
他们指出，事情
被称为指针对象并设置为

1146
00:51:00,950 --> 00:51:02,330
是一个独立的步骤。

1147
00:51:02,330 --> 00:51:03,210
>> 哦，对，对。

1148
00:51:03,210 --> 00:51:03,940
我知道。

1149
00:51:03,940 --> 00:51:05,730
所述指针对象是分开的。

1150
00:51:05,730 --> 00:51:08,310
那么，你如何分配一个指针对象？

1151
00:51:08,310 --> 00:51:11,960
>>  - 确定，以及这段代码中分配
一个新的整数指针对象，

1152
00:51:11,960 --> 00:51:15,050
而这部分设置x为指向它。

1153
00:51:15,050 --> 00:51:16,240
>>  - 嘿，这看起来更好。

1154
00:51:16,240 --> 00:51:17,743
所以让它做一些事情。

1155
00:51:17,743 --> 00:51:23,580
>>  - 确定，我会取消引用指针x可
数字42存入及其指针。

1156
00:51:23,580 --> 00:51:27,130
对于这一招，我需要我的
提领魔杖。

1157
00:51:27,130 --> 00:51:30,200
>> 提领的 - 你的魔杖？

1158
00:51:30,200 --> 00:51:32,310
呃，那个，这是伟大的。

1159
00:51:32,310 --> 00:51:34,270
>>  - 这是什么样的代码如下所示。

1160
00:51:34,270 --> 00:51:35,970
我会刚刚成立的数量还有 - 

1161
00:51:35,970 --> 00:51:37,070
>> [POP音]

1162
00:51:37,070 --> 00:51:39,140
>>  - 嘿，看那里去。

1163
00:51:39,140 --> 00:51:43,980
所以，做一个解引用在X如下
箭头访问及其指针。

1164
00:51:43,980 --> 00:51:46,150
在这种情况下，为了存储42在那里。

1165
00:51:46,150 --> 00:51:50,700
嘿，尝试用它来存储号码
13通过另一个指针，Y。

1166
00:51:50,700 --> 00:51:51,840
>> -行。

1167
00:51:51,840 --> 00:51:56,270
我只是去在这里为y，
并获得了13号的设置。

1168
00:51:56,270 --> 00:52:00,380
再取的魔杖
提领和just--

1169
00:52:00,380 --> 00:52:01,646
>> [蜂鸣声]

1170
00:52:01,646 --> 00:52:04,080
>> 哦，嘿嘿，没有工作。

1171
00:52:04,080 --> 00:52:06,470
再说了，呃，宾基，我不
想提领

1172
00:52:06,470 --> 00:52:10,850
y是一个好主意，因为设置
向上指针对象是一个独立的步骤。

1173
00:52:10,850 --> 00:52:12,480
而且我不认为我们曾经做到了。

1174
00:52:12,480 --> 00:52:14,620
>> -Hmm，好点。

1175
00:52:14,620 --> 00:52:19,810
>> 是啊，我们分配的指针，Y，但
我们从来没有将其设置为指向一个指针对象。

1176
00:52:19,810 --> 00:52:21,590
>> -Hmm，非常细心。

1177
00:52:21,590 --> 00:52:23,215
 - 嘿，你在寻找好的有，宾基。

1178
00:52:23,215 --> 00:52:26,390
你能解决这个问题，从而y点
到相同的指针对象为x。

1179
00:52:26,390 --> 00:52:29,290
>> -sure，我用我的魔杖
的指针赋值。

1180
00:52:29,290 --> 00:52:31,970
>> -is这将是一个
问题，像以前一样？

1181
00:52:31,970 --> 00:52:33,790
>> 不，这不碰指针对象。

1182
00:52:33,790 --> 00:52:35,840
它只是变化为一指针
向指向同一件事 - 

1183
00:52:35,840 --> 00:52:36,465
>> [爆裂声]

1184
00:52:36,465 --> 00:52:37,450
--as另一回事。

1185
00:52:37,450 --> 00:52:38,440
>> -原来如此。

1186
00:52:38,440 --> 00:52:41,200
现在Ÿ指向同一个地方为x。

1187
00:52:41,200 --> 00:52:42,950
因此，等待，现在y的固定。

1188
00:52:42,950 --> 00:52:44,110
它有一个指针对象。

1189
00:52:44,110 --> 00:52:47,779
所以，你可以尝试的魔杖
再次提领送13以上。

1190
00:52:47,779 --> 00:52:51,110
>> 哦，好了，在这里不用。

1191
00:52:51,110 --> 00:52:52,330
>>  - 嘿，看那个。

1192
00:52:52,330 --> 00:52:53,570
现在提领Y上的作品。

1193
00:52:53,570 --> 00:52:57,900
而由于指针共享
一个指针对象，他们都看到了13。

1194
00:52:57,900 --> 00:52:59,952
>>  - 是的，共享的，呃，等等。

1195
00:52:59,952 --> 00:53:01,535
所以，我们要现在进行切换的地方？

1196
00:53:01,535 --> 00:53:03,730
>> 哦，看我们没时间了。

1197
00:53:03,730 --> 00:53:04,660
>> -But--

1198
00:53:04,660 --> 00:53:06,520
>>  - 仅仅记住三个指针规则。

1199
00:53:06,520 --> 00:53:09,550
号1，基本结构
是你有一个指针，

1200
00:53:09,550 --> 00:53:11,630
它指向了一个指针对象。

1201
00:53:11,630 --> 00:53:13,740
但指针和
指针对象是分开的。

1202
00:53:13,740 --> 00:53:15,620
与常见的错误
是建立一个指针

1203
00:53:15,620 --> 00:53:18,000
但忘了给它一个指针对象。

1204
00:53:18,000 --> 00:53:21,170
>> 2号，指针废弃
开始于指针

1205
00:53:21,170 --> 00:53:24,020
并遵循其箭头以上
访问及其指针。

1206
00:53:24,020 --> 00:53:27,815
大家都知道，这只是如果有工作
为指针对象，哪一种回来

1207
00:53:27,815 --> 00:53:29,260
排除1号。

1208
00:53:29,260 --> 00:53:31,990
>> 3号，指针
任务需要一个指针

1209
00:53:31,990 --> 00:53:35,330
并将其更改为指向
相同的指针对象为另一个指针。

1210
00:53:35,330 --> 00:53:37,150
因此，在转让之后，
两个指针

1211
00:53:37,150 --> 00:53:40,927
将指向相同的指针对象，
有时这就是所谓的共享。

1212
00:53:40,927 --> 00:53:42,510
而这一切就是这么简单，真的。

1213
00:53:42,510 --> 00:53:43,130
再见了。

1214
00:53:43,130 --> 00:53:43,475
>> [结束播放]

1215
00:53:43,475 --> 00:53:44,830
>> DAVID J.马兰：这就是它的CS50。

1216
00:53:44,830 --> 00:53:46,246
由于尼克Parlante教授。

1217
00:53:46,246 --> 00:53:47,730
我们会看到你下周。

1218
00:53:47,730 --> 00:53:51,706

1219
00:53:51,706 --> 00:53:56,435
>> [电子音乐播放]

1220
00:53:56,435 --> 00:57:22,775