1
00:00:00,000 --> 00:00:04,875

2
00:00:04,875 --> 00:00:05,750
ANDI鹏：好的。

3
00:00:05,750 --> 00:00:08,240
欢迎来到第四个星期

4
00:00:08,240 --> 00:00:10,280
这是一个美丽的一天
在这里纽黑文

5
00:00:10,280 --> 00:00:14,370
所以我真的觉得疏
孩子散射的

6
00:00:14,370 --> 00:00:17,530
今天加入了我部分，谢谢。

7
00:00:17,530 --> 00:00:21,517
>> 所以很快，就在我们
开始，今天的议程。

8
00:00:21,517 --> 00:00:23,600
我们将走过去一
几句简短的公告。

9
00:00:23,600 --> 00:00:26,224
我们有一个非常古怪的时间表
即将在接下来的两个星期

10
00:00:26,224 --> 00:00:28,010
左右，所以我们要说明一下。

11
00:00:28,010 --> 00:00:30,410
其次，我知道，
大家最喜欢的topic--

12
00:00:30,410 --> 00:00:33,572
我敢肯定，这融化你的心
讲座过程中，不用担心，

13
00:00:33,572 --> 00:00:34,780
那种我仍然不明白这一点。

14
00:00:34,780 --> 00:00:35,444
没关系。

15
00:00:35,444 --> 00:00:36,110
这是一个笑话。

16
00:00:36,110 --> 00:00:37,450
其实我明白这一点。

17
00:00:37,450 --> 00:00:40,234
但我会确保
你们得到它了。

18
00:00:40,234 --> 00:00:42,400
所以，我们要花费
真的，真的很好量

19
00:00:42,400 --> 00:00:44,020
时间今天谈论的指针。

20
00:00:44,020 --> 00:00:47,012
正如你所看到的，糖果的
今天的谈话是巨大的。

21
00:00:47,012 --> 00:00:49,220
我们真的要保持
that--是啊，这是正确的。

22
00:00:49,220 --> 00:00:49,890
继续服用的糖果。

23
00:00:49,890 --> 00:00:51,556
我打算现在通过他们周围。

24
00:00:51,556 --> 00:00:55,150

25
00:00:55,150 --> 00:00:56,510
别担心。

26
00:00:56,510 --> 00:00:59,570
我们要真正尝试
留人的血糖

27
00:00:59,570 --> 00:01:04,390
，因为大脑会烧
当今一些氧气，因为指针

28
00:01:04,390 --> 00:01:05,652
真的，真的很难。

29
00:01:05,652 --> 00:01:08,360
然后我们要谈
内存管理哪一种是

30
00:01:08,360 --> 00:01:09,487
在相同的领域。

31
00:01:09,487 --> 00:01:11,570
而且我们要动
上重定向和文件

32
00:01:11,570 --> 00:01:15,297
I / O这只是语法，不错
事情我们应该谈谈。

33
00:01:15,297 --> 00:01:17,130
然后最后，我
要再次尝试

34
00:01:17,130 --> 00:01:19,070
离开像10，15分钟pset4。

35
00:01:19,070 --> 00:01:21,820
在几天之内这是因为所以我们
那种将真正给你

36
00:01:21,820 --> 00:01:24,850
如果你一些有用的提示
已经开始了这一点。

37
00:01:24,850 --> 00:01:26,141
酷。

38
00:01:26,141 --> 00:01:26,640
好。

39
00:01:26,640 --> 00:01:30,710
因此，一些公告
对于这个即将到来的一周。

40
00:01:30,710 --> 00:01:31,805
评级。

41
00:01:31,805 --> 00:01:33,930
我真的不知道
这一点你们有多少人

42
00:01:33,930 --> 00:01:37,180
家伙居然在我
section--你行吗？

43
00:01:37,180 --> 00:01:38,020
好。

44
00:01:38,020 --> 00:01:40,150
但是，对于那些你
谁在我的部分，

45
00:01:40,150 --> 00:01:42,180
只是一对夫妇的批语分级。

46
00:01:42,180 --> 00:01:44,899
>> 评论首先，切实抓紧抓好。

47
00:01:44,899 --> 00:01:47,940
你们当中谁不评论，你
知道你是谁，因为你可能

48
00:01:47,940 --> 00:01:50,610
得到这个星期dinged一些造型加分。

49
00:01:50,610 --> 00:01:53,920
只要确保在所有的
程序添加一些评论。

50
00:01:53,920 --> 00:01:56,960
真的，风格是很容易
得到正确的点作为一个范围。

51
00:01:56,960 --> 00:01:58,710
所以对我们来说，只要
确保你是那种

52
00:01:58,710 --> 00:02:03,770
的增加在所有的简要说明
你对你在做什么项目。

53
00:02:03,770 --> 00:02:09,190
>> Secondly--这是一个巨大的问题
很多助教过去week--

54
00:02:09,190 --> 00:02:12,020
所以一定要确保你上传到
正确的文件夹正确

55
00:02:12,020 --> 00:02:13,370
命名方案。

56
00:02:13,370 --> 00:02:16,820
为什么我们要求这样做的原因是
因为我们在分级过程中，

57
00:02:16,820 --> 00:02:20,820
实际上上运行脚本您
自动下载代码

58
00:02:20,820 --> 00:02:24,780
所有的pset中，运行
对所有的人都正确性测试，

59
00:02:24,780 --> 00:02:27,550
然后上传你的分数
直接进入成绩册。

60
00:02:27,550 --> 00:02:32,140
但是，在任何时候，如果
正确命名你的程序，

61
00:02:32,140 --> 00:02:34,510
这螺丝了整个
节目给大家。

62
00:02:34,510 --> 00:02:37,280
>> 因此，合法，
这个美丽的脚本

63
00:02:37,280 --> 00:02:40,260
我们已经写了呢
这一切对我们来说，完全

64
00:02:40,260 --> 00:02:43,070
崩溃，如果您还没有
你的程序正确命名。

65
00:02:43,070 --> 00:02:46,020
因此，只要上传到正确的
文件夹，让他们正确命名，

66
00:02:46,020 --> 00:02:47,372
然后生活是美好的。

67
00:02:47,372 --> 00:02:49,080
我明白你的pset回来
以你们前面

68
00:02:49,080 --> 00:02:51,110
因为我很快得到他们品位。

69
00:02:51,110 --> 00:02:52,461
是啊。

70
00:02:52,461 --> 00:02:52,960
好。

71
00:02:52,960 --> 00:02:57,870
同时，我们要谈
about--耶鲁大学有一个非常，非常

72
00:02:57,870 --> 00:02:59,950
古怪的时间表在今后两个星期。

73
00:02:59,950 --> 00:03:02,460
因此，那些你们的
哈佛，这并不适用。

74
00:03:02,460 --> 00:03:05,585
但对于我们可爱的孩子们在耶鲁大学，我们有
所谓秋季break--抱歉，

75
00:03:05,585 --> 00:03:08,430
Harvard--我们有
5天关闭学校。

76
00:03:08,430 --> 00:03:12,270
虽然这是可爱的，它
那种打乱了我们的节奏PSET

77
00:03:12,270 --> 00:03:14,104
因为pset中是由于周四，周五。

78
00:03:14,104 --> 00:03:16,020
所以，如果我们不在这里
周四，周五，我们

79
00:03:16,020 --> 00:03:18,640
不能为你们工作
由于周四，周五。

80
00:03:18,640 --> 00:03:23,832
>> 所以，我们要做的is--我们做什么
像99％确定这是发生了什么事，

81
00:03:23,832 --> 00:03:25,540
可能有一些
改变，但我认为这是

82
00:03:25,540 --> 00:03:28,460
subtle--是我们要
have--这个星期是正常的。

83
00:03:28,460 --> 00:03:32,130
因此，我们有我们的部分
周二其次是办公时间

84
00:03:32,130 --> 00:03:35,190
整周的其余部分
然后pset4是由于上周五。

85
00:03:35,190 --> 00:03:38,180
然后，你们都知道，作为
上周我提醒你们，

86
00:03:38,180 --> 00:03:41,700
我们有我们的测验0
周三上来。

87
00:03:41,700 --> 00:03:44,400
>> 因此，作为学生自己，
我知道，你们中几乎没有

88
00:03:44,400 --> 00:03:49,110
球员将实际工作
您的测验之前pset5两天。

89
00:03:49,110 --> 00:03:51,110
所以，我们要什么
可能最终做的是，

90
00:03:51,110 --> 00:03:54,840
周一晚上，我们要去
实际上，从5:30到7:00，

91
00:03:54,840 --> 00:03:59,970
有一个简要的回顾
会议议题涵盖。

92
00:03:59,970 --> 00:04:02,040
如果它是一个不明确
审查会议或一个Q＆A。

93
00:04:02,040 --> 00:04:04,650
这将是某种形式的审查
形式，我们将讨论

94
00:04:04,650 --> 00:04:06,640
有关为你们的一些话题。

95
00:04:06,640 --> 00:04:09,886
>> 然后周一和周二晚
这一周，从8:00到11:00，

96
00:04:09,886 --> 00:04:11,260
我们将有办公时间。

97
00:04:11,260 --> 00:04:14,500
这些办公时间将最
有可能是更多刚进来，

98
00:04:14,500 --> 00:04:17,564
问助教你的问题有关
你感到困惑的任何概念，

99
00:04:17,564 --> 00:04:20,480
他们就会种下去了你
和审查概念测验。

100
00:04:20,480 --> 00:04:22,920
测验0，如果你在
周一，周三部分，

101
00:04:22,920 --> 00:04:26,480
将周三的中
在课堂分类 - 周三。

102
00:04:26,480 --> 00:04:29,530
然后，如果你在
周二，周四部分，

103
00:04:29,530 --> 00:04:32,577
也将是周四在课堂上。

104
00:04:32,577 --> 00:04:34,410
你真的无法选择
你去哪一个。

105
00:04:34,410 --> 00:04:35,640
如果你是一个周一，周三，
你必须去到星期三。

106
00:04:35,640 --> 00:04:38,056
如果你在周二，周四
你必须要到周四。

107
00:04:38,056 --> 00:04:42,277
但后来那天晚上，
我们可爱的工作人员，将

108
00:04:42,277 --> 00:04:45,360
有一个巨大的测验中分级方
我们将让你的分数还给你

109
00:04:45,360 --> 00:04:46,190
那晚。

110
00:04:46,190 --> 00:04:46,900
在什么时候？

111
00:04:46,900 --> 00:04:51,190
目前还不清楚，谁知道，但它会
回来给你24小时内

112
00:04:51,190 --> 00:04:53,700
所以，你们希望
有一些反馈，在周五。

113
00:04:53,700 --> 00:04:55,870
>> 然后我们有一个非常古怪的一周。

114
00:04:55,870 --> 00:05:00,330
所以pset5是其一
今年最困难的pset。

115
00:05:00,330 --> 00:05:03,370
所以，对不起你们。

116
00:05:03,370 --> 00:05:06,520
我们要去尝试
做的是我们要拥有

117
00:05:06,520 --> 00:05:08,380
一些实际的支持，那个周末。

118
00:05:08,380 --> 00:05:12,970
因为，正如你们所看到的，
PSET是由于秋天休息前。

119
00:05:12,970 --> 00:05:16,760
我们没有支持
你们在秋天休息

120
00:05:16,760 --> 00:05:18,897
所以我们真的有种
希望这句话的，

121
00:05:18,897 --> 00:05:21,230
让我们在以得到这个，
下面就让我们真的，真的很难

122
00:05:21,230 --> 00:05:25,380
这接下来的两个星期，得到这个测验
并添加这两个pset中有做

123
00:05:25,380 --> 00:05:29,650
然后你们有一个不错的放松
7天不假思索CS。

124
00:05:29,650 --> 00:05:33,750
>> 因此，为了使该至
发生，我们可能

125
00:05:33,750 --> 00:05:36,870
要动我的第
至周日下午。

126
00:05:36,870 --> 00:05:39,070
这将被拍摄下来，所以没有
烦恼，如果你不能来。

127
00:05:39,070 --> 00:05:41,595
但网上拍戏会
在那里，访问

128
00:05:41,595 --> 00:05:47,630
让你们有星期日，
周一，周二，上班pset5。

129
00:05:47,630 --> 00:05:50,205
然后它的秋天
打破，没有CS，然后

130
00:05:50,205 --> 00:05:51,830
我们回来，它在研磨回来。

131
00:05:51,830 --> 00:05:54,926
>> 但是，这将是一个
可爱的周秋季休息

132
00:05:54,926 --> 00:05:58,050
我们真的希望把它作为压力
免费提供给大家尽可能哪些

133
00:05:58,050 --> 00:06:02,620
所以，我们提出的PSET是由于
前秋突破，而不是之后。

134
00:06:02,620 --> 00:06:07,601
因为it's--我的意思是，我有种感觉
喜欢它违背了目的

135
00:06:07,601 --> 00:06:10,850
秋天休息，如果有以后的截止日期
在秋天休息反正不支持。

136
00:06:10,850 --> 00:06:14,670
所以这是rather--我想
我们宁愿专注于现在。

137
00:06:14,670 --> 00:06:16,950
有没有人有问题
有关日程安排？

138
00:06:16,950 --> 00:06:17,830
什么困惑？

139
00:06:17,830 --> 00:06:18,330
是啊。

140
00:06:18,330 --> 00:06:20,944
>> 听众：我们仍然有
在21日的演讲？

141
00:06:20,944 --> 00:06:21,610
ANDI彭：是的。

142
00:06:21,610 --> 00:06:26,421
因此，21号，这里将是
讲座是活的哈佛大学。

143
00:06:26,421 --> 00:06:29,170
我不知道大卫是拍摄
它，如果他实际上讲学，

144
00:06:29,170 --> 00:06:32,430
但它的将是可用
在线为你们访问。

145
00:06:32,430 --> 00:06:35,510
因此，只要确保你能开一个
小时某处在秋天休息

146
00:06:35,510 --> 00:06:39,375
所以你们可以赶上
上的演讲。

147
00:06:39,375 --> 00:06:39,875
是吗？

148
00:06:39,875 --> 00:06:40,300
>> 听众：是的。

149
00:06:40,300 --> 00:06:40,422
抱歉。

150
00:06:40,422 --> 00:06:41,280
我这里couple--

151
00:06:41,280 --> 00:06:41,640
>> ANDI彭：不用担心。

152
00:06:41,640 --> 00:06:42,556
在这里，需要一些糖果。

153
00:06:42,556 --> 00:06:45,350

154
00:06:45,350 --> 00:06:47,800
>> 听众：嘿，我抓住了这一点。

155
00:06:47,800 --> 00:06:53,869
因此，只要回顾一下，不是明天，但
之后周三，我们有一个小测验。

156
00:06:53,869 --> 00:06:54,660
ANDI彭：正确。

157
00:06:54,660 --> 00:06:59,207
听众：而且它会be--
什么是问答的格式？

158
00:06:59,207 --> 00:06:59,790
ANDI彭：哦。

159
00:06:59,790 --> 00:07:03,870
因此，我们将发送一封电子邮件，
涵盖了深入的一切了。

160
00:07:03,870 --> 00:07:06,590
但是，实际上，它只是覆盖
已经涵盖了基本内容

161
00:07:06,590 --> 00:07:09,042
在第一学期的一半。

162
00:07:09,042 --> 00:07:12,250
我们必须审查会议和问题
和答案所以不用担心这一点。

163
00:07:12,250 --> 00:07:14,107
但是，我们会去了这一点。

164
00:07:14,107 --> 00:07:16,940
听众：是否将是，我们
把我们的电脑和代码那里 - 

165
00:07:16,940 --> 00:07:17,140
ANDI彭：没有。

166
00:07:17,140 --> 00:07:20,130
这将是你们写
并回答用手问题。

167
00:07:20,130 --> 00:07:21,160
>> 听众：哦。

168
00:07:21,160 --> 00:07:23,160
>> ANDI彭：所以我们会给
从实践和东西

169
00:07:23,160 --> 00:07:26,420
所以你们可能想也许去
回重写马里奥的手刚

170
00:07:26,420 --> 00:07:28,100
要确保你们有
如何做到这一点的想法。

171
00:07:28,100 --> 00:07:29,933
因为有时当
您手工编写您

172
00:07:29,933 --> 00:07:32,656
忘了分号和东西
那是非常糟糕的。

173
00:07:32,656 --> 00:07:34,156
听众：那不[听不清]？

174
00:07:34,156 --> 00:07:38,290
就像，你要
在your--分号

175
00:07:38,290 --> 00:07:40,270
>> ANDI彭：是的，没有。

176
00:07:40,270 --> 00:07:43,170
我们将讨论更深入
关于如何测验布局

177
00:07:43,170 --> 00:07:44,550
以及我们如何打算档次。

178
00:07:44,550 --> 00:07:47,425
但实际上，只知道
一般格式将是你

179
00:07:47,425 --> 00:07:49,930
人要么解释代码 - 
回答的基本问题。

180
00:07:49,930 --> 00:07:51,370
如果我问你，什么是库？

181
00:07:51,370 --> 00:07:53,450
你们应该知道什么是
图书馆不和写下来。

182
00:07:53,450 --> 00:07:56,283
或者，我可以说，编写一个程序，
打印Hello World到屏幕上。

183
00:07:56,283 --> 00:08:01,140
你们会写，INT主要
无效的printf的Hello World分号。

184
00:08:01,140 --> 00:08:01,908
是啊。

185
00:08:01,908 --> 00:08:04,398
>> 听众：所以它不会
到任何地方[听不清]

186
00:08:04,398 --> 00:08:05,900
问题的难易度来确定？

187
00:08:05,900 --> 00:08:06,170
>> ANDI彭：没有。

188
00:08:06,170 --> 00:08:06,380
第

189
00:08:06,380 --> 00:08:07,046
我们won't--耶。

190
00:08:07,046 --> 00:08:10,030
写的全部
比赛15在20分钟内走了。

191
00:08:10,030 --> 00:08:12,120
没有，它不会是。

192
00:08:12,120 --> 00:08:12,801
第

193
00:08:12,801 --> 00:08:13,342
听众：OK。

194
00:08:13,342 --> 00:08:15,326
所以这是星期三。

195
00:08:15,326 --> 00:08:19,017
在那一周，我们还
已在最困难的问题设置？

196
00:08:19,017 --> 00:08:19,600
ANDI彭：没有。

197
00:08:19,600 --> 00:08:22,970
所以，问题设置到期
秋天休息的前一天。

198
00:08:22,970 --> 00:08:25,690
该schedule--电子邮件
实际上发出

199
00:08:25,690 --> 00:08:27,232
11分钟前就了这一切。

200
00:08:27,232 --> 00:08:28,689
所以，你们只是检查你的电子邮件。

201
00:08:28,689 --> 00:08:29,430
它会在那里。

202
00:08:29,430 --> 00:08:30,060
是啊。

203
00:08:30,060 --> 00:08:31,701
别担心。

204
00:08:31,701 --> 00:08:32,200
酷。

205
00:08:32,200 --> 00:08:34,900

206
00:08:34,900 --> 00:08:38,900
>> 对于任何常规问题
公告显示，分级，测验，

207
00:08:38,900 --> 00:08:41,659
之前，我们深入到
指针这将消耗

208
00:08:41,659 --> 00:08:45,060
我们的大多数时间段今天？

209
00:08:45,060 --> 00:08:47,030
酷。

210
00:08:47,030 --> 00:08:47,530
好吧。

211
00:08:47,530 --> 00:08:50,905
因此，没有你们都看这个lovely--
我不知道他们所说的。

212
00:08:50,905 --> 00:08:53,490
事情那里的粘土动画
自爆本身，因为它

213
00:08:53,490 --> 00:08:54,820
没有正确使用指针。

214
00:08:54,820 --> 00:08:57,629
那么，你的程序将
可能打击本身，如果你

215
00:08:57,629 --> 00:08:59,170
不使用指针正常以及。

216
00:08:59,170 --> 00:09:01,250
因此，我们要作
确保不会发生。

217
00:09:01,250 --> 00:09:04,810
>> 今天我们要
做一些指针乐趣。

218
00:09:04,810 --> 00:09:08,970
我会走过去的事情
那样顺利，因为我认为

219
00:09:08,970 --> 00:09:10,790
有可能在一个小的时间框架。

220
00:09:10,790 --> 00:09:14,592
但是，以支付只是这么多
我真的希望你们，

221
00:09:14,592 --> 00:09:17,300
如果你不明白的东西，
不只是让我继续下去。

222
00:09:17,300 --> 00:09:18,580
因为如果你不这样做
明白了点什么，

223
00:09:18,580 --> 00:09:21,329
你可能不会
弄懂之后，我说。

224
00:09:21,329 --> 00:09:23,310
所以，请阻止我，并问一个问题。

225
00:09:23,310 --> 00:09:25,380
因为它都挺
的雪球在一起。

226
00:09:25,380 --> 00:09:27,800
像，三分球领先进入
内存领先进入其他的事情。

227
00:09:27,800 --> 00:09:31,710
所以，如果你不明白三分球，
阻止我，我们会弄明白

228
00:09:31,710 --> 00:09:35,070
生活也会被罚款。

229
00:09:35,070 --> 00:09:35,680
>> 酷。

230
00:09:35,680 --> 00:09:39,050
那么有多少你们的讲座，
当大卫提到的三分球，

231
00:09:39,050 --> 00:09:42,050
那种你的大脑变成果冻？

232
00:09:42,050 --> 00:09:42,550
是啊。

233
00:09:42,550 --> 00:09:44,190
好。

234
00:09:44,190 --> 00:09:46,900
我们将尝试
脱果冻你的大脑今天。

235
00:09:46,900 --> 00:09:50,300
我们要真正系统
经过究竟一个指针，

236
00:09:50,300 --> 00:09:52,530
它做什么，以及我们如何使用它们。

237
00:09:52,530 --> 00:09:56,620
>> 因此，所有pointers--所以
通常与变量

238
00:09:56,620 --> 00:10:00,920
我们一直在使用的编码，如
变量，如整数或字符串

239
00:10:00,920 --> 00:10:04,790
或浮筒，他们都基本上
分配给它们的值

240
00:10:04,790 --> 00:10:06,870
以及一个地址
指向该值。

241
00:10:06,870 --> 00:10:08,895
所以我现在要得出这样的权利。

242
00:10:08,895 --> 00:10:14,270

243
00:10:14,270 --> 00:10:16,140
我们几乎没有粉笔，但没关系。

244
00:10:16,140 --> 00:10:25,550
>> 因此，例如，通常
我们已经一路

245
00:10:25,550 --> 00:10:30,860
在使用变量是我们创造的
int类型的变量的名字，让我们

246
00:10:30,860 --> 00:10:31,360
说啊。

247
00:10:31,360 --> 00:10:37,360
所以在这里我们有INT x和我们
初始化的int值50。

248
00:10:37,360 --> 00:10:42,390
因此，这里的内存这一块我们
电脑，我们已经存储了号码为50。

249
00:10:42,390 --> 00:10:46,170
那么，三分球开始发挥作用是
您的计算机itself--一样，在这里，

250
00:10:46,170 --> 00:10:48,880
在物理硬盘驱动器
在我的computer--的RAM中

251
00:10:48,880 --> 00:10:51,147
它不仅具有存储有限数量。

252
00:10:51,147 --> 00:10:53,980
你不能只让存储的东西
上面的东西对事物的顶部

253
00:10:53,980 --> 00:10:54,990
并让他们所有。

254
00:10:54,990 --> 00:10:59,570
>> 所以这样我们动态地分配
存储器能够存储我们想要的

255
00:10:59,570 --> 00:11:03,150
并对其进行访问，是由具有指针。

256
00:11:03,150 --> 00:11:06,210
所以，想象一下在你的记忆空间，正确的。

257
00:11:06,210 --> 00:11:10,420
如果是这样的RAM您
计算机，你有这些小位

258
00:11:10,420 --> 00:11:14,540
或嵌段或存储器以字节
which--这些都只是小

259
00:11:14,540 --> 00:11:18,120
已经分配出去的块
硬盘驱动器您的计算机或RAM，

260
00:11:18,120 --> 00:11:21,950
并在每个区块的
你可以存储不同的东西。

261
00:11:21,950 --> 00:11:26,990
因此，例如，1
阵列在本实施例

262
00:11:26,990 --> 00:11:29,984
这里是一个字节是
由8比特组成。

263
00:11:29,984 --> 00:11:32,900
数的变化取决于在
您的计算机的操作系统。

264
00:11:32,900 --> 00:11:35,942
例如，你们有多少人有
听说32位与64位操作系统

265
00:11:35,942 --> 00:11:36,441
系统？

266
00:11:36,441 --> 00:11:37,070
没错。

267
00:11:37,070 --> 00:11:38,860
>> 因此，所有这说
是，memory--

268
00:11:38,860 --> 00:11:42,420
的方式，你的电脑
管理存储器是不同的。

269
00:11:42,420 --> 00:11:45,370
这就是为什么它是真的
重要的是了解

270
00:11:45,370 --> 00:11:49,450
为什么内存本身的功能，而
不是讲究数量。

271
00:11:49,450 --> 00:11:52,400
所以，我们真的不关心
怎么这大阵

272
00:11:52,400 --> 00:11:55,710
是，我们只需要关心
有多大我们需要一个int是，

273
00:11:55,710 --> 00:11:58,350
有多大我们需要一个字符串
是，多大是一个指针？

274
00:11:58,350 --> 00:12:00,630

275
00:12:00,630 --> 00:12:01,130
好。

276
00:12:01,130 --> 00:12:03,690
因此，这将是一个很大
沉重的，密集的信息。

277
00:12:03,690 --> 00:12:07,005
我想给你们一个
夫妇漫画救济的时刻在这里。

278
00:12:07,005 --> 00:12:09,130
你们应该都可以
现在明白这一点。

279
00:12:09,130 --> 00:12:12,550
因为我们知道，
指针地址，

280
00:12:12,550 --> 00:12:14,480
而这些都是由不同的变量。

281
00:12:14,480 --> 00:12:14,980
好。

282
00:12:14,980 --> 00:12:15,610
酷。

283
00:12:15,610 --> 00:12:17,065
CS笑话是最好的，是吗？

284
00:12:17,065 --> 00:12:19,800

285
00:12:19,800 --> 00:12:23,450
>> 所以，我们走的路
有关创建一个指针

286
00:12:23,450 --> 00:12:25,750
语法是一个非常特定的排序。

287
00:12:25,750 --> 00:12:27,870
与创建任何
变量的类型，它的

288
00:12:27,870 --> 00:12:30,240
将是一个特定
语法我们用它来创建它。

289
00:12:30,240 --> 00:12:34,830
因此声明的任何指针时，
指针只是essentially--

290
00:12:34,830 --> 00:12:37,040
我认为重要的
指针的一部分，是

291
00:12:37,040 --> 00:12:41,650
而这一个变量
两者的值和地址，

292
00:12:41,650 --> 00:12:44,100
一个指针是一个地址。

293
00:12:44,100 --> 00:12:45,740
它的值是一个地址。

294
00:12:45,740 --> 00:12:48,120
所以这是存储地址
在不同的地址。

295
00:12:48,120 --> 00:12:49,120
如果让任何意义。

296
00:12:49,120 --> 00:12:52,390
我们一起去了这个更详细，
但是这是一般形式

297
00:12:52,390 --> 00:12:54,370
的如何一个打印机存储why--。

298
00:12:54,370 --> 00:12:58,900
>> 这样就创建一个指针方式
是通过执行数据的任何类型

299
00:12:58,900 --> 00:13:02,840
该指针是要
要引用和then--

300
00:13:02,840 --> 00:13:05,324
与star--，然后
指针的名称。

301
00:13:05,324 --> 00:13:07,240
所以在这里，如果我们想
创建一个指针

302
00:13:07,240 --> 00:13:11,640
指出朝向的整数，且我们
想为x指示器的名称，

303
00:13:11,640 --> 00:13:13,880
我们会做INT明星的X.

304
00:13:13,880 --> 00:13:14,380
是吗？

305
00:13:14,380 --> 00:13:16,680
>> 听众：所以，如果
下面这行你

306
00:13:16,680 --> 00:13:20,045
做INT X，将整型明星x
指示x的位置

307
00:13:20,045 --> 00:13:21,170
你定义之后？

308
00:13:21,170 --> 00:13:22,000
>> ANDI彭：非常好的问题。

309
00:13:22,000 --> 00:13:23,860
我们一起去了这
一对夫妇后滑动。

310
00:13:23,860 --> 00:13:24,920
是啊。

311
00:13:24,920 --> 00:13:27,610
然后同样的事
char和同样的事情浮动。

312
00:13:27,610 --> 00:13:29,950
要知道，在这一点
我们创建了一个指针，

313
00:13:29,950 --> 00:13:32,470
我们还没有实际设置
它又等于什么。

314
00:13:32,470 --> 00:13:34,110
我们还没有实际引用它。

315
00:13:34,110 --> 00:13:36,087
这里的时候，同样的事情
您创建一个变量，

316
00:13:36,087 --> 00:13:39,420
您创建的变量的名称，
你有没有实际设置一个值给它。

317
00:13:39,420 --> 00:13:41,410
这里同样的事情。

318
00:13:41,410 --> 00:13:42,110
>> 好。

319
00:13:42,110 --> 00:13:44,670
那么，我们如何设置值指针？

320
00:13:44,670 --> 00:13:47,190
它是通过引用和间接引用。

321
00:13:47,190 --> 00:13:52,260
这样的方式，我们可以参考
一个varia--的指针，在本质上

322
00:13:52,260 --> 00:13:56,630
我们返回的地址在存储器
其中的变量被存储。

323
00:13:56,630 --> 00:14:02,550
所以，如果我有一个pointer--我就画
这一次，我们到下一个幻灯片，

324
00:14:02,550 --> 00:14:05,760
但只知道，从本质上讲，
在和 - 与号

325
00:14:05,760 --> 00:14:10,240
和变量 - 所有
所做的就是告诉你地址

326
00:14:10,240 --> 00:14:11,780
那里的东西存储。

327
00:14:11,780 --> 00:14:15,730
而且提领则相反
这一点，这仅仅是个明星。

328
00:14:15,730 --> 00:14:18,950
星只是给你的实际
存储在该地址数据。

329
00:14:18,950 --> 00:14:21,090
>> 因此，人们给你的地址
存储在地址，

330
00:14:21,090 --> 00:14:23,945
另外给你的实际
值存储在该地址。

331
00:14:23,945 --> 00:14:25,820
所以他们两个给
你不同的东西。

332
00:14:25,820 --> 00:14:27,755

333
00:14:27,755 --> 00:14:29,880
再次，所述幻灯片
所有在线让您无后顾之忧

334
00:14:29,880 --> 00:14:33,200
如果你们不能复制
下来的时候。

335
00:14:33,200 --> 00:14:36,330
>> 因此，让我们一起来看看
在这里这个例子。

336
00:14:36,330 --> 00:14:40,530
所以，我们已经有了一个巨大的
这里存储阵列，对不对？

337
00:14:40,530 --> 00:14:42,920
我们在那里只是有块
存储器，或字节的内存，

338
00:14:42,920 --> 00:14:45,060
我们可以在其中存储不同的事情。

339
00:14:45,060 --> 00:14:47,310
远的不说，这些都是
地址点在存储器中。

340
00:14:47,310 --> 00:14:51,350
所以，任何时候你有 - 看到0X，
所有这一切都告诉你的是，

341
00:14:51,350 --> 00:14:52,930
这是一个十六进制数字。

342
00:14:52,930 --> 00:14:56,310
正如你们都知道，数字
可以设在不同的基地。

343
00:14:56,310 --> 00:14:58,770
基10是我们一般
解读数字。

344
00:14:58,770 --> 00:15:00,550
还有基体2，它是二进制的。

345
00:15:00,550 --> 00:15:03,366
在这种情况下，
十六进制的基数为16。

346
00:15:03,366 --> 00:15:06,240
它是说只是以不同的方式
从零到10--或零到九

347
00:15:06,240 --> 00:15:10,904
然后又A，B，C，D，E，F。
还引用不同的号码。

348
00:15:10,904 --> 00:15:12,570
大卫就在这个演讲中简要地。

349
00:15:12,570 --> 00:15:14,280
如果你们是
困惑，它只是谷歌。

350
00:15:14,280 --> 00:15:17,370
这里真的很容易的方法来学习
什么是十六进制数字的。

351
00:15:17,370 --> 00:15:19,510
所有这一切真的有关
现在是为你

352
00:15:19,510 --> 00:15:24,170
你们要知道，
十六进制在C中位数

353
00:15:24,170 --> 00:15:27,090
告诉你 - 通常
告诉你，这是一个指针。

354
00:15:27,090 --> 00:15:29,150
或者说是一个地址。

355
00:15:29,150 --> 00:15:33,310
>> 因此，在这里本例中为int x等于5。

356
00:15:33,310 --> 00:15:36,350
我们正在创建一个integer--
类型对不起，可变

357
00:15:36,350 --> 00:15:39,090
整数，我们正在对其进行初始化为5。

358
00:15:39,090 --> 00:15:47,040
所以在这里我们的内存板，我们可以
看到x是在为0x0地址

359
00:15:47,040 --> 00:15:50,550
并且，你已经价值
里面存放的是5。

360
00:15:50,550 --> 00:15:52,370
这应该是有意义
每个人，对不对？

361
00:15:52,370 --> 00:15:53,030
好。

362
00:15:53,030 --> 00:15:56,520
>> 然后我们做了什么
在代码的第二线

363
00:15:56,520 --> 00:16:00,290
是，我们已经创建
int类型的指针。

364
00:16:00,290 --> 00:16:02,750
这就是整型
明星指针在做什么。

365
00:16:02,750 --> 00:16:07,320
而且等于该符号x
是给你的东西的地址。

366
00:16:07,320 --> 00:16:12,120
因此x的在地址
本例中为0x0。

367
00:16:12,120 --> 00:16:15,630
并使得地址正在被
存储在该指针。

368
00:16:15,630 --> 00:16:17,360
这是否有意义给大家？

369
00:16:17,360 --> 00:16:19,965
>> 因此，认为this--的
想pointers--这里

370
00:16:19,965 --> 00:16:24,780
在耶鲁大学，我们有一个邮政信箱系统
其中，每个学生都有一个邮件

371
00:16:24,780 --> 00:16:26,960
地址，你可以去
进入LW地下室

372
00:16:26,960 --> 00:16:30,492
你可以随便去抢
无论你需要从该地址。

373
00:16:30,492 --> 00:16:32,450
同样的事情发生
这里在计算机中。

374
00:16:32,450 --> 00:16:36,770
你有这些内存字节
你可以信息存储到，

375
00:16:36,770 --> 00:16:39,529
但为了要知道哪些
的信息片

376
00:16:39,529 --> 00:16:42,570
你正在试图找到匹配起来
何地，你需要一个指针

377
00:16:42,570 --> 00:16:43,740
告诉你如何去那里。

378
00:16:43,740 --> 00:16:47,270
>> 因此，例如，对我来说，我的宝箱，
我有一个特定的五位数字。

379
00:16:47,270 --> 00:16:48,400
这是我的地址。

380
00:16:48,400 --> 00:16:51,880
所以，我可以实际去记忆，
我可以看这个地址，

381
00:16:51,880 --> 00:16:54,507
我可以去那邮政信箱
并访问内部数据。

382
00:16:54,507 --> 00:16:57,090
这是否有意义给大家
您的计算机基本上是

383
00:16:57,090 --> 00:16:59,000
做同样的事情。

384
00:16:59,000 --> 00:17:02,750
>> 因此，所有的指针做的是，
它只是创建一个存储

385
00:17:02,750 --> 00:17:06,099
和它的内存中的数据实际上是
别的东西的地址。

386
00:17:06,099 --> 00:17:08,210
然后，你可以去发现。

387
00:17:08,210 --> 00:17:09,060
每个人都好？

388
00:17:09,060 --> 00:17:10,720
大家好我这么远吗？

389
00:17:10,720 --> 00:17:11,360
好。

390
00:17:11,360 --> 00:17:11,859
酷。

391
00:17:11,859 --> 00:17:14,311

392
00:17:14,311 --> 00:17:14,810
好吧。

393
00:17:14,810 --> 00:17:19,160
因此，几乎同样的事情和以前一样。

394
00:17:19,160 --> 00:17:23,849
因此，我们有，首先，可变
名为x其中case--

395
00:17:23,849 --> 00:17:27,700
我将这个值更改为5。

396
00:17:27,700 --> 00:17:31,820
远的不说地址
这在内存为0x0。

397
00:17:31,820 --> 00:17:33,070
00。

398
00:17:33,070 --> 00:17:33,570
太好了。

399
00:17:33,570 --> 00:17:35,320
>> 那么，在我们的第二个
代码行，我们

400
00:17:35,320 --> 00:17:41,210
要创建一个指针
所谓PTR指针。

401
00:17:41,210 --> 00:17:45,760
与该地址，让我们
只是说这是在内存中为0x01。

402
00:17:45,760 --> 00:17:48,280
而我们其实想
store--的符号

403
00:17:48,280 --> 00:17:50,620
X允许你一个什么样x为地址。

404
00:17:50,620 --> 00:17:53,990
和x的地址为0×00。

405
00:17:53,990 --> 00:17:57,300
所以这个指针现在
实际上有地址

406
00:17:57,300 --> 00:18:00,210
存储作为什么十获得其值。

407
00:18:00,210 --> 00:18:01,700
每个人都和我这么远吗？

408
00:18:01,700 --> 00:18:02,320
酷。

409
00:18:02,320 --> 00:18:04,670
>> 然后，该方式
我们会复制，

410
00:18:04,670 --> 00:18:09,650
是，如果我们将宣布和初始化
int类型内存的另一个块。

411
00:18:09,650 --> 00:18:10,150
对？

412
00:18:10,150 --> 00:18:11,130
这将是一个int。

413
00:18:11,130 --> 00:18:14,130
它会被称为副本。

414
00:18:14,130 --> 00:18:17,120
而你要get--所以
明星指针给你

415
00:18:17,120 --> 00:18:19,080
从该地址的实际数据。

416
00:18:19,080 --> 00:18:22,490
该符号给你的地址，
明星给你的数据。

417
00:18:22,490 --> 00:18:24,630
所以数据在指针。

418
00:18:24,630 --> 00:18:29,420
这个指针指向5。

419
00:18:29,420 --> 00:18:33,140
因此该功能
这里 - 明星pointer--

420
00:18:33,140 --> 00:18:39,740
云，获得无论是在
该块和在这里的商店。

421
00:18:39,740 --> 00:18:41,730
每个人都清楚如何发生的？

422
00:18:41,730 --> 00:18:45,490
>> 因此，两家运营商的权利那里 - 
连字符和star--

423
00:18:45,490 --> 00:18:48,250
只是做不同的事情
在指针使用时。

424
00:18:48,250 --> 00:18:50,837
一个可以让你的地址一
让你的实际值。

425
00:18:50,837 --> 00:18:53,670
所以一定要确保当你家伙
编码您不要将两者混为一谈

426
00:18:53,670 --> 00:18:55,650
因为他们是完全不同的。

427
00:18:55,650 --> 00:18:58,880
在这里，我们有一个为0x01的一个很好的例子。

428
00:18:58,880 --> 00:19:01,207
这是一个非常好的
少量的记忆。

429
00:19:01,207 --> 00:19:03,040
在您的实际计算机
你将有

430
00:19:03,040 --> 00:19:06,740
一个巨大的屁股数量那是后话
这不是很好的，不愉快的。

431
00:19:06,740 --> 00:19:08,280
这将是一些垃圾的价值。

432
00:19:08,280 --> 00:19:10,920
所以它要真的，
真的会打乱你的计划。

433
00:19:10,920 --> 00:19:12,670
这是非常重要的
现在，我们有

434
00:19:12,670 --> 00:19:16,150
基本面下来why--一样，
什么实际发生时，

435
00:19:16,150 --> 00:19:18,270
你正在运行这些代码块。

436
00:19:18,270 --> 00:19:19,120
Everyone--是吗？

437
00:19:19,120 --> 00:19:21,425
>> 听众：所以INT x等于INT副本？

438
00:19:21,425 --> 00:19:24,650

439
00:19:24,650 --> 00:19:34,970
>> ANDI彭：没有，因为在这种情况下，INT
x-- x--的值等于5，对不对？

440
00:19:34,970 --> 00:19:40,546
然后INT副本等于5。

441
00:19:40,546 --> 00:19:43,420
所以，如果你将它们等同于
对方，因为他们是整数，

442
00:19:43,420 --> 00:19:46,379
是的，他们会评估为true。

443
00:19:46,379 --> 00:19:49,670
但是如果他们在存储器串，像
一个大卫例如在做，

444
00:19:49,670 --> 00:19:51,670
这是不同的，因为
他们引用

445
00:19:51,670 --> 00:19:54,920
在内存场所地址
他们将相当于为false。

446
00:19:54,920 --> 00:20:00,070
>> 所以，在这里，因为你是这将是真实的
直接比较values​​-- integers--

447
00:20:00,070 --> 00:20:02,240
但在其他你
参考点。

448
00:20:02,240 --> 00:20:05,290
因为一个字符串是在一个阵列，并
all--我们将谈论这个later--

449
00:20:05,290 --> 00:20:09,940
但阵列本质上只是一个
指针一堆内存中字符的。

450
00:20:09,940 --> 00:20:11,610
因此，这些都是有点不同。

451
00:20:11,610 --> 00:20:14,642
但在这种情况下，是的，
你能做到这一点。

452
00:20:14,642 --> 00:20:17,354
>> 听众：你能解释一下
副本的地址？

453
00:20:17,354 --> 00:20:18,020
ANDI彭：是的。

454
00:20:18,020 --> 00:20:20,030
所以这是just--我
没有填写值

455
00:20:20,030 --> 00:20:23,022
但它只是一些随机其他
垃圾的价值，我们不关心。

456
00:20:23,022 --> 00:20:25,730
因为一旦你开始计划
你知道，我们实际上并不

457
00:20:25,730 --> 00:20:28,150
真正关心什么
实际地址，

458
00:20:28,150 --> 00:20:30,470
我们只需要知道
什么是在地址。

459
00:20:30,470 --> 00:20:31,608
是啊。

460
00:20:31,608 --> 00:20:36,034
>> 听众：为int的下一个明星
第二条线，那是不同的than--

461
00:20:36,034 --> 00:20:36,700
ANDI彭：是的。

462
00:20:36,700 --> 00:20:39,015
听众：--the取消引用
并引用明星？

463
00:20:39,015 --> 00:20:39,681
ANDI彭：是的。

464
00:20:39,681 --> 00:20:43,180
因此C--的作者谁
决定写的语言C--

465
00:20:43,180 --> 00:20:44,200
是不是很聪明。

466
00:20:44,200 --> 00:20:46,830
他们不是很聪明的尝试
弄清楚为什么我们应该这样做。

467
00:20:46,830 --> 00:20:49,413
如果是我，我肯定会
使用两个不同的字符。

468
00:20:49,413 --> 00:20:52,100
但他们决定使用同一个。

469
00:20:52,100 --> 00:20:56,607
>> 因此，一个int后的明星，
它告诉计算机

470
00:20:56,607 --> 00:20:58,190
你是要创建一个指针。

471
00:20:58,190 --> 00:21:00,820
但是，如果你想提领
something--换句话说，

472
00:21:00,820 --> 00:21:03,780
去的地址和拉
从somewhere--数据

473
00:21:03,780 --> 00:21:05,070
明星用不同。

474
00:21:05,070 --> 00:21:08,750
所以，你俩要小心
没有搞乱的两种用法。

475
00:21:08,750 --> 00:21:09,870
酷。

476
00:21:09,870 --> 00:21:10,605
是吗？

477
00:21:10,605 --> 00:21:14,680
>> 听众：所以只是重复到
确保我following--

478
00:21:14,680 --> 00:21:16,252
>> ANDI彭：完全罚款。

479
00:21:16,252 --> 00:21:20,491
>> 听众：--in的左手侧
该幻灯片，我们这样做，我们知道的事情。

480
00:21:20,491 --> 00:21:23,124
我们宣布一个整数
[听不清]是等于5。

481
00:21:23,124 --> 00:21:23,790
ANDI彭：是的。

482
00:21:23,790 --> 00:21:24,456
听众：对。

483
00:21:24,456 --> 00:21:28,960
然后我们有一个int明星的事情，
上面写着那种，OK，像我们

484
00:21:28,960 --> 00:21:31,235
声明一个整数，现在
我们宣布一个指针。

485
00:21:31,235 --> 00:21:32,110
ANDI彭：正确。

486
00:21:32,110 --> 00:21:32,410
正确的。

487
00:21:32,410 --> 00:21:32,710
>> 听众：是吗？

488
00:21:32,710 --> 00:21:33,870
而我们的指针PTR。

489
00:21:33,870 --> 00:21:34,080
>> ANDI彭：是的。

490
00:21:34,080 --> 00:21:35,460
指针的名称是PTR。

491
00:21:35,460 --> 00:21:35,959
指针。

492
00:21:35,959 --> 00:21:39,000
听众：然后它
等于NX，只是告诉C

493
00:21:39,000 --> 00:21:44,667
它希望访问的值
x--值的整数x整数

494
00:21:44,667 --> 00:21:45,800
被分配。

495
00:21:45,800 --> 00:21:49,050
>> ANDI彭：小心
因为符号实际上x

496
00:21:49,050 --> 00:21:53,120
告诉你 - 电脑，你
想拉什么x是地址。

497
00:21:53,120 --> 00:21:56,350
因此，符号给你
地址，星级为您提供的价值。

498
00:21:56,350 --> 00:21:58,255
>> 听众：所以我们想要的地址。

499
00:21:58,255 --> 00:22:02,075
比方说，x为at--

500
00:22:02,075 --> 00:22:03,950
ANDI鹏：实际上我们
知道什么x是吧？

501
00:22:03,950 --> 00:22:06,790
因为我们知道X was--我
使这件事，但我们只能说，

502
00:22:06,790 --> 00:22:08,760
随意，这是为0x00。

503
00:22:08,760 --> 00:22:09,590
对？

504
00:22:09,590 --> 00:22:14,120
所以我们知道地址为0x00，
所以当我们去和符号X，

505
00:22:14,120 --> 00:22:17,050
我们知道这
应该评估为0x00。

506
00:22:17,050 --> 00:22:20,810
这就是为什么我们存储的
作为我们的指针的值。

507
00:22:20,810 --> 00:22:21,924
那有意义吗？

508
00:22:21,924 --> 00:22:22,832
>> 听众：是的。

509
00:22:22,832 --> 00:22:28,057
而副本去提领ptr--

510
00:22:28,057 --> 00:22:28,765
ANDI彭：对。

511
00:22:28,765 --> 00:22:30,473
听众：可呈现为
我们已经指针

512
00:22:30,473 --> 00:22:35,220
声明告诉我们
整数x的地址。

513
00:22:35,220 --> 00:22:36,160
>> ANDI彭：是的。

514
00:22:36,160 --> 00:22:39,272
>> 听众：而在这
一种情况下，星ptr导

515
00:22:39,272 --> 00:22:41,256
等于x的哪个等于5的值。

516
00:22:41,256 --> 00:22:42,744
>> ANDI彭：正确。

517
00:22:42,744 --> 00:22:44,728
>> 听众：酷。

518
00:22:44,728 --> 00:22:49,382
这是一个简单的方法来获得
即或是唯一方式 - 

519
00:22:49,382 --> 00:22:51,840
ANDI彭：所以现在它
似乎不是很合乎逻辑的我们

520
00:22:51,840 --> 00:22:54,690
花这一切时间做
这个超级复杂的事情时，

521
00:22:54,690 --> 00:22:57,606
我们所做的只是创建两个
与5的值的整数，对不对？

522
00:22:57,606 --> 00:22:58,900
它没有意义。

523
00:22:58,900 --> 00:23:03,060
但是，一旦我们就去了
内存分配还有 - 我们将

524
00:23:03,060 --> 00:23:06,067
走了过来，为什么这可能是
方便和有用以后。

525
00:23:06,067 --> 00:23:09,150
相信我，当我说我们不只是
为您创造这些任意函数

526
00:23:09,150 --> 00:23:11,340
你们学习，因为我们是
想惹你。

527
00:23:11,340 --> 00:23:14,550
有实际使用所有这些
的事情，我们会谈论他们。

528
00:23:14,550 --> 00:23:14,950
>> 听众：真棒。

529
00:23:14,950 --> 00:23:15,350
>> ANDI彭：是的。

530
00:23:15,350 --> 00:23:16,150
>> 听众：[听不清]。

531
00:23:16,150 --> 00:23:16,450
>> ANDI彭：这个问题问得好。

532
00:23:16,450 --> 00:23:17,510
>> 听众：[听不清]。

533
00:23:17,510 --> 00:23:18,000
>> ANDI彭：这不是。

534
00:23:18,000 --> 00:23:18,666
这真的不是。

535
00:23:18,666 --> 00:23:21,050
听众：--two变量
这也等于[听不清]。

536
00:23:21,050 --> 00:23:22,400
好。

537
00:23:22,400 --> 00:23:23,070
>> ANDI彭：是的。

538
00:23:23,070 --> 00:23:23,570
好。

539
00:23:23,570 --> 00:23:25,249
在我继续前进，是每个人都清楚了吗？

540
00:23:25,249 --> 00:23:26,790
我知道泰勒，你有点晚了。

541
00:23:26,790 --> 00:23:27,490
好的。

542
00:23:27,490 --> 00:23:28,100
这是在网上。

543
00:23:28,100 --> 00:23:30,600
你看前20
分钟，你就会被大家看好。

544
00:23:30,600 --> 00:23:31,190
好。

545
00:23:31,190 --> 00:23:31,690
酷。

546
00:23:31,690 --> 00:23:35,597

547
00:23:35,597 --> 00:23:37,140
>> 好吧。

548
00:23:37,140 --> 00:23:41,270
样的，所以这是一个基本上
类似的事情，我们只是做了。

549
00:23:41,270 --> 00:23:43,100
它只是在图形形式。

550
00:23:43,100 --> 00:23:47,070
如果你要跟踪什么
就这样发生了，诠释x等于5，

551
00:23:47,070 --> 00:23:52,159
我们所做的在这一点上是
创建一个名为x int类型的变量。

552
00:23:52,159 --> 00:23:54,200
我们要保存
的这5内在价值。

553
00:23:54,200 --> 00:23:57,366
有没有指针，因为我们还没有
实际上创造了一个指针呢，对吧？

554
00:23:57,366 --> 00:24:00,302
然后在下一
行，诠释明星指针，

555
00:24:00,302 --> 00:24:02,760
这就是我们实际上
实际创建的指针

556
00:24:02,760 --> 00:24:05,010
我们正在制定的
等于，或引用

557
00:24:05,010 --> 00:24:07,250
指针，以符号的X.

558
00:24:07,250 --> 00:24:10,002
这是哪里的地方在
记忆这事是。

559
00:24:10,002 --> 00:24:12,210
我其实并没有理会
组成一个值这个时候。

560
00:24:12,210 --> 00:24:14,900
但在这种情况下，该点
您会等于。

561
00:24:14,900 --> 00:24:18,060
>> 再往下还有，明星
指针反引用。

562
00:24:18,060 --> 00:24:20,310
这就是我们
拉动信息。

563
00:24:20,310 --> 00:24:24,170
所以当x是值实际上是
将是等于35。

564
00:24:24,170 --> 00:24:30,390
所以在这一点上，我们基本上已经
只是重新初始化X要35

565
00:24:30,390 --> 00:24:32,320
没有实际接触的X.

566
00:24:32,320 --> 00:24:34,560
只需通过指针
这是指向X，

567
00:24:34,560 --> 00:24:36,910
我们其实可以改变什么x为。

568
00:24:36,910 --> 00:24:38,420
我要画这一点为好。

569
00:24:38,420 --> 00:24:52,200
>> 所以在这里，我们已经创建
这里是一些随机地址。

570
00:24:52,200 --> 00:24:54,734
远的不说，又为0x00。

571
00:24:54,734 --> 00:24:56,150
让我们只说这是地址。

572
00:24:56,150 --> 00:25:00,830
我们已经创建了一个整数名为x
我已经分配给它的值是5。

573
00:25:00,830 --> 00:25:03,840
在第二行，整数
pointer--所以现在我们已经

574
00:25:03,840 --> 00:25:07,820
得到这个第二件事
这里被称为pointer--

575
00:25:07,820 --> 00:25:14,310
我们打​​算用于：我们只能说
它的一些其他随机的内存地址。

576
00:25:14,310 --> 00:25:18,460
>> 所以，我们要设置这个
等于不管是什么样。

577
00:25:18,460 --> 00:25:21,540

578
00:25:21,540 --> 00:25:25,880
与该指针是要
指向x的值

579
00:25:25,880 --> 00:25:30,090
然后，如果改变
the--如果我们做明星的指针，

580
00:25:30,090 --> 00:25:32,800
这是怎么回事的
我们指针的值。

581
00:25:32,800 --> 00:25:36,979
在这种情况下，它的将跟踪
这支箭过来x的这个值

582
00:25:36,979 --> 00:25:38,395
而这将其更改为35。

583
00:25:38,395 --> 00:25:41,400

584
00:25:41,400 --> 00:25:44,760
实际上，我们只是改变
X =无接触的X.

585
00:25:44,760 --> 00:25:48,970
通过刚才引用指针，
我们可以去改变x的值。

586
00:25:48,970 --> 00:25:50,050
那有意义吗？

587
00:25:50,050 --> 00:25:55,200
>> 因此以这种方式，我们实际上可以重新命名
和重新改变并重新分配值

588
00:25:55,200 --> 00:25:57,750
以我们没有的东西
实际上使我们自己。

589
00:25:57,750 --> 00:26:00,925
这是否有意义给大家？

590
00:26:00,925 --> 00:26:01,425
酷。

591
00:26:01,425 --> 00:26:04,450

592
00:26:04,450 --> 00:26:05,310
好。

593
00:26:05,310 --> 00:26:08,210
因此，复杂的图形在这里。

594
00:26:08,210 --> 00:26:09,360
通过走行线。

595
00:26:09,360 --> 00:26:12,055
从本质上讲，只是做的确切
同样的事情，我只是做了。

596
00:26:12,055 --> 00:26:15,977

597
00:26:15,977 --> 00:26:17,810
在我继续前进，我
真的想只是让

598
00:26:17,810 --> 00:26:19,370
确保每个人都对这个真的清楚。

599
00:26:19,370 --> 00:26:26,260
所以在这里，我们有代码
INT a等于3，B等于4，c等于5。

600
00:26:26,260 --> 00:26:33,130
因此，我们已经创建了一个名为三个整数
a，b和c表示等于3,4和5。

601
00:26:33,130 --> 00:26:38,460
然后，我们创建三个指针
这一点每一个这些变量。

602
00:26:38,460 --> 00:26:41,760
>> 现在我们要去
走在本质

603
00:26:41,760 --> 00:26:44,240
当你对他们的工作会发生什么。

604
00:26:44,240 --> 00:26:45,490
所以画出来。

605
00:26:45,490 --> 00:26:48,156
取paper--我做不成片
知道你们都有纸张，

606
00:26:48,156 --> 00:26:50,930
但那些你们谁不这样做，也许
那些你们谁借钱。

607
00:26:50,930 --> 00:26:53,580
取的纸张
并线走线。

608
00:26:53,580 --> 00:26:59,390
而在你做的每一个操作，
我希望你们真正写出来

609
00:26:59,390 --> 00:27:00,800
什么是，b和c在此点。

610
00:27:00,800 --> 00:27:03,550
什么是地址，什么是
指向a，b和c中的指针

611
00:27:03,550 --> 00:27:04,410
在此刻？

612
00:27:04,410 --> 00:27:07,150
>> 然后希望这
那种会加强你们

613
00:27:07,150 --> 00:27:08,900
通过如何看待指针。

614
00:27:08,900 --> 00:27:10,650
我们不会去
通过所有这些。

615
00:27:10,650 --> 00:27:13,450
也许我给你five--
像，三分钟。

616
00:27:13,450 --> 00:27:14,660
获得第几开始。

617
00:27:14,660 --> 00:28:10,410

618
00:28:10,410 --> 00:28:10,959
呵呵。

619
00:28:10,959 --> 00:28:11,459
哎呀。

620
00:28:11,459 --> 00:28:20,940

621
00:28:20,940 --> 00:28:26,950
>> 听众：在第二行，为什么
是不是明星[听不清]变量？

622
00:28:26,950 --> 00:28:29,410
>> ANDI彭：记得在
运营商，在第一周，

623
00:28:29,410 --> 00:28:31,730
我们谈到了如何
如果你这样做等于加，

624
00:28:31,730 --> 00:28:35,320
这只是意味着一个等于加C。

625
00:28:35,320 --> 00:28:39,370
在此case--所以这是另一
方式在其中星也可以使用。

626
00:28:39,370 --> 00:28:42,040
除了参考
并声明指针，

627
00:28:42,040 --> 00:28:44,440
请记住，这也
意味着乘法。

628
00:28:44,440 --> 00:28:46,575
因此，在这种情况下，刚刚
是等于C时代。

629
00:28:46,575 --> 00:28:48,450
这只是不同
编写方式。

630
00:28:48,450 --> 00:28:49,776
>> 听众：一等于C时代。

631
00:28:49,776 --> 00:28:50,442
ANDI彭：是的。

632
00:28:50,442 --> 00:30:43,488

633
00:30:43,488 --> 00:30:47,130
>> 听众：这是什么意思，如果
它说，一个符号的信？

634
00:30:47,130 --> 00:30:50,900
>> ANDI彭：＆符号的手段
你要that--你

635
00:30:50,900 --> 00:30:54,760
要指针的地方
指向和拉动的地址。

636
00:30:54,760 --> 00:31:01,270
因此，符号给你的地址，
明星给你那里的实际值。

637
00:31:01,270 --> 00:31:03,090
>> 听众：难道我们
通过线建设上线？

638
00:31:03,090 --> 00:31:04,881
>> ANDI彭：你
通过线的基础上线。

639
00:31:04,881 --> 00:31:07,260
所以只是去一行
一时间和then--你

640
00:31:07,260 --> 00:31:08,470
不必担心
完成整个事情。

641
00:31:08,470 --> 00:31:10,428
让我们试着打通
也许二，三线

642
00:31:10,428 --> 00:31:12,445
然后，我们将召集和完成这一点。

643
00:31:12,445 --> 00:31:15,530

644
00:31:15,530 --> 00:31:17,470
>> 这是完全确定的，如果你们都将丢失。

645
00:31:17,470 --> 00:31:19,334
这是一个很艰难的概念。

646
00:31:19,334 --> 00:31:22,500
如果你们是担心类
是这样的像大卫说，

647
00:31:22,500 --> 00:31:23,190
它没有。

648
00:31:23,190 --> 00:31:25,949
我们到达
困难的概念性高峰

649
00:31:25,949 --> 00:31:27,740
然后它会
向下倾斜。

650
00:31:27,740 --> 00:31:29,110
所以你们几乎没有。

651
00:31:29,110 --> 00:31:31,080
我们有很多的糖果来获得
你们通过驼峰。

652
00:31:31,080 --> 00:31:32,940
我认为倒台后几乎
打破我们会渡过了难关

653
00:31:32,940 --> 00:31:34,220
和生活都会好起来。

654
00:31:34,220 --> 00:31:36,580
所以不用担心的。

655
00:31:36,580 --> 00:32:30,732

656
00:32:30,732 --> 00:32:31,232
好吧。

657
00:32:31,232 --> 00:32:33,650
我给你们20
多秒的收官。

658
00:32:33,650 --> 00:33:12,560

659
00:33:12,560 --> 00:33:13,330
好。

660
00:33:13,330 --> 00:33:13,830
好吧。

661
00:33:13,830 --> 00:33:16,370
让我们一捅这个。

662
00:33:16,370 --> 00:33:19,430
正如你们给我的答案，
我只是要他们输入。

663
00:33:19,430 --> 00:33:22,140
并希望we--可以吗？

664
00:33:22,140 --> 00:33:23,317
我其实不能输入。

665
00:33:23,317 --> 00:33:24,400
我就画在黑板上。

666
00:33:24,400 --> 00:33:31,420

667
00:33:31,420 --> 00:33:35,900
>> 因此，这里的这个第一线
我们有一个等于B型星温度。

668
00:33:35,900 --> 00:33:38,060
此外艾略特提出了一个
真的，真的好点。

669
00:33:38,060 --> 00:33:42,500
因为我忘了，除了
两种方法，我们可以使用星号，

670
00:33:42,500 --> 00:33:43,750
这事实上是在第三条道路。

671
00:33:43,750 --> 00:33:44,990
乘法。

672
00:33:44,990 --> 00:33:51,380
所以，只是没有得到困惑，因为
这是利用明星的第一种方式。

673
00:33:51,380 --> 00:33:54,470
它只是告诉电脑
我是要创建一个指针。

674
00:33:54,470 --> 00:34:00,600
>> 通过做第二种方法
Star的指针，

675
00:34:00,600 --> 00:34:04,320
告诉你想要的指针
在该指针来访问该数据。

676
00:34:04,320 --> 00:34:06,710
然后，当然，还有
只是简单的乘法

677
00:34:06,710 --> 00:34:09,564
两个数字之间，告诉你
我想乘两个。

678
00:34:09,564 --> 00:34:11,730
因此，有很多的方法
我们可以使用星号。

679
00:34:11,730 --> 00:34:13,830
不要混淆。

680
00:34:13,830 --> 00:34:16,991
只要确保你们理解
正是他们三个

681
00:34:16,991 --> 00:34:18,630
是做。

682
00:34:18,630 --> 00:34:22,920
>> 因此，在这个第一线，
a等于b乘以℃。

683
00:34:22,920 --> 00:34:26,850
所以，让我们通过什么
是，什么是B，什么是C？

684
00:34:26,850 --> 00:34:32,600
什么是一个指针时，
指针为b，并且指针到c？

685
00:34:32,600 --> 00:34:34,050
那些是什么都等于？

686
00:34:34,050 --> 00:34:34,600
好。

687
00:34:34,600 --> 00:34:38,650
>> 因此，我们开始了与一个等于3，
b等于c 4，和C等于5，对不对？

688
00:34:38,650 --> 00:34:42,230
所以这第一行之后，就可以
有人告诉我，什么是？

689
00:34:42,230 --> 00:34:42,730
是啊。

690
00:34:42,730 --> 00:34:44,229
随意刚喊出答案。

691
00:34:44,229 --> 00:34:44,929
20。

692
00:34:44,929 --> 00:34:45,550
好。

693
00:34:45,550 --> 00:34:46,410
什么是B'

694
00:34:46,410 --> 00:34:47,777
>> 听众：4。

695
00:34:47,777 --> 00:34:48,610
ANDI彭：什么是C吗？

696
00:34:48,610 --> 00:34:49,659
听众：5。

697
00:34:49,659 --> 00:34:50,770
ANDI彭：耶。

698
00:34:50,770 --> 00:34:51,639
好。

699
00:34:51,639 --> 00:34:55,707
什么是PA，PB和PC？

700
00:34:55,707 --> 00:34:58,564
>> 听众：000001和002？

701
00:34:58,564 --> 00:34:59,230
ANDI彭：是的。

702
00:34:59,230 --> 00:35:02,390
这么样的脑筋急转弯
但不是真的，因为在这里我

703
00:35:02,390 --> 00:35:04,760
抽出实际的回忆。

704
00:35:04,760 --> 00:35:08,520
但是，因为对于一个例子，我们不
其实知道这些数字是，

705
00:35:08,520 --> 00:35:10,326
我们只能说符号。

706
00:35:10,326 --> 00:35:12,200
我甚至不知道我是否
可以得出一个符号。

707
00:35:12,200 --> 00:35:18,022
这是like--你怎么办呢？

708
00:35:18,022 --> 00:35:19,790
>> 听众：喜欢画画八。

709
00:35:19,790 --> 00:35:20,870
>> ANDI彭：像八。

710
00:35:20,870 --> 00:35:21,580
像那样。

711
00:35:21,580 --> 00:35:22,080
好。

712
00:35:22,080 --> 00:35:23,446
听众：宾果。

713
00:35:23,446 --> 00:35:25,350
>> ANDI彭：杀死它。

714
00:35:25,350 --> 00:35:28,202
所以AMPERSAND一个，你可以做到这一点。

715
00:35:28,202 --> 00:35:30,410
因为我们实际上并不
关心的是，值

716
00:35:30,410 --> 00:35:32,880
是，这是一些长
屁股价值反正，

717
00:35:32,880 --> 00:35:35,220
我们只用榕
说一个符号。

718
00:35:35,220 --> 00:35:37,024
那么什么是PB？

719
00:35:37,024 --> 00:35:37,940
听众：[听不清]。

720
00:35:37,940 --> 00:35:38,606
ANDI彭：是的。

721
00:35:38,606 --> 00:35:42,490

722
00:35:42,490 --> 00:35:43,500
酷。

723
00:35:43,500 --> 00:35:44,010
好吧。

724
00:35:44,010 --> 00:35:44,770
先易行。

725
00:35:44,770 --> 00:35:45,270
我们得到了这一点。

726
00:35:45,270 --> 00:35:46,330
指针很容易。

727
00:35:46,330 --> 00:35:47,450
好的。

728
00:35:47,450 --> 00:35:48,740
>> 第二道防线。

729
00:35:48,740 --> 00:35:52,400
所以明星等于是一样的
话说一件事等于C时代。

730
00:35:52,400 --> 00:35:54,730
这是写的只是一个更简单的方法。

731
00:35:54,730 --> 00:35:57,170
因此，我们不试图使
一个点或任何东西。

732
00:35:57,170 --> 00:36:00,600
因此，与第一线完成。

733
00:36:00,600 --> 00:36:05,144
什么是在第二行上
以后你做了等于C时代？

734
00:36:05,144 --> 00:36:05,777
>> 听众：100？

735
00:36:05,777 --> 00:36:06,610
ANDI彭：这是100。

736
00:36:06,610 --> 00:36:07,795
好。

737
00:36:07,795 --> 00:36:08,864
如何关于B？

738
00:36:08,864 --> 00:36:10,256
>> 听众：[听不清]。

739
00:36:10,256 --> 00:36:11,335
>> ANDI彭：如何C吗？

740
00:36:11,335 --> 00:36:12,490
>> 听众：[听不清]。

741
00:36:12,490 --> 00:36:14,530
>> ANDI彭：又有怎样的指针？

742
00:36:14,530 --> 00:36:15,800
是否they--一样的，对不对？

743
00:36:15,800 --> 00:36:20,640

744
00:36:20,640 --> 00:36:21,940
好。

745
00:36:21,940 --> 00:36:23,820
现在，第三行。

746
00:36:23,820 --> 00:36:26,400

747
00:36:26,400 --> 00:36:27,350
有点麻烦。

748
00:36:27,350 --> 00:36:29,760
b等于c星PA。

749
00:36:29,760 --> 00:36:34,189
谁能告诉我，第一，
哪些呢星级PA平等吗？

750
00:36:34,189 --> 00:36:36,159
>> 听众：这是值
一个储存在。

751
00:36:36,159 --> 00:36:36,950
ANDI鹏：没错。

752
00:36:36,950 --> 00:36:38,070
什么是价值
一个储存在？

753
00:36:38,070 --> 00:36:38,860
>> 听众：100。

754
00:36:38,860 --> 00:36:39,660
>> ANDI彭：OK。

755
00:36:39,660 --> 00:36:43,462
那么，什么会是一个后
执行该行代码？

756
00:36:43,462 --> 00:36:44,760
>> 听众：[听不清]。

757
00:36:44,760 --> 00:36:45,870
>> ANDI彭：什么关于B？

758
00:36:45,870 --> 00:36:46,780
>> 听众：100。

759
00:36:46,780 --> 00:36:47,620
>> ANDI彭：是的。

760
00:36:47,620 --> 00:36:49,995
然后一切是
几乎不变的，对不对？

761
00:36:49,995 --> 00:36:51,239
因为我们没有触及它。

762
00:36:51,239 --> 00:36:55,370

763
00:36:55,370 --> 00:36:57,010
酷。

764
00:36:57,010 --> 00:36:58,390
第四行。

765
00:36:58,390 --> 00:37:00,390
稍微复杂一些。

766
00:37:00,390 --> 00:37:06,910
所以pc--再次，PC是指针
这指出C--等于年利率。

767
00:37:06,910 --> 00:37:11,520

768
00:37:11,520 --> 00:37:12,360
什么是？

769
00:37:12,360 --> 00:37:14,525
>> 听众：100。

770
00:37:14,525 --> 00:37:15,400
ANDI彭：什么为b？

771
00:37:15,400 --> 00:37:17,920
听众：100。

772
00:37:17,920 --> 00:37:18,862
ANDI彭：什么是C？

773
00:37:18,862 --> 00:37:19,993
听众：5。

774
00:37:19,993 --> 00:37:20,867
ANDI彭：什么是PA？

775
00:37:20,867 --> 00:37:22,775
听众：与符号一个。

776
00:37:22,775 --> 00:37:23,730
ANDI彭：PB？

777
00:37:23,730 --> 00:37:26,010
听众：与号湾

778
00:37:26,010 --> 00:37:27,730
ANDI彭：和棘手的，什么是电脑吗？

779
00:37:27,730 --> 00:37:28,410
听众：与符号一个。

780
00:37:28,410 --> 00:37:29,034
ANDI彭：耶。

781
00:37:29,034 --> 00:37:31,790
宇豪。

782
00:37:31,790 --> 00:37:32,500
你们看到了吗？

783
00:37:32,500 --> 00:37:33,282
这是所有的权利。

784
00:37:33,282 --> 00:37:33,990
这不是太糟糕了。

785
00:37:33,990 --> 00:37:38,730
我们有更多的糖果，如果这还不是全部
正确的，但我认为它的一切权利。

786
00:37:38,730 --> 00:37:41,900
我们打​​算走过去只有一个
之前，我们就越难打的人多。

787
00:37:41,900 --> 00:37:43,710
这些问题的答案我在这里。

788
00:37:43,710 --> 00:37:47,050
>> 从本质上讲，知道这是
就像数学在这一点上。

789
00:37:47,050 --> 00:37:53,240
当你有简单的公式像
再加上B，A C时代，这是很容易做到。

790
00:37:53,240 --> 00:37:56,390
当你开始扩大后，
它，只是为了去操作的。

791
00:37:56,390 --> 00:37:57,830
同样的事情了。

792
00:37:57,830 --> 00:38:00,030
>> 保持跟踪，如果你的
明星是什么了。

793
00:38:00,030 --> 00:38:01,640
这告诉你的价值。

794
00:38:01,640 --> 00:38:04,640
如果你有一个和之前
东西，它会告诉你地址。

795
00:38:04,640 --> 00:38:07,860
你应该分配任
的指针或该值。

796
00:38:07,860 --> 00:38:11,260
所以，让我们在这个
最后一个真正的快。

797
00:38:11,260 --> 00:38:12,520
这不是最后一个，对不起。

798
00:38:12,520 --> 00:38:13,340
其实，你们可以挑选。

799
00:38:13,340 --> 00:38:16,006
哪一个做你们想要去
过出剩余的三个的

800
00:38:16,006 --> 00:38:17,449
我们有吗？

801
00:38:17,449 --> 00:38:20,490
我不认为我们可以做的
因为我们不能只是跳转到该行。

802
00:38:20,490 --> 00:38:21,000
好。

803
00:38:21,000 --> 00:38:25,700
你们没有选择，
这仅仅是三分之一到最后一个。

804
00:38:25,700 --> 00:38:29,228
>> 星PC等于b乘以℃。

805
00:38:29,228 --> 00:38:30,144
>> 听众：星PB？

806
00:38:30,144 --> 00:38:32,117
>> 听众：星PB。

807
00:38:32,117 --> 00:38:32,825
ANDI彭：对不起？

808
00:38:32,825 --> 00:38:33,599
听众：星PB。

809
00:38:33,599 --> 00:38:34,390
ANDI彭：星PB。

810
00:38:34,390 --> 00:38:35,100
哦，我的坏。

811
00:38:35,100 --> 00:38:38,647
星PB等于b乘以℃。

812
00:38:38,647 --> 00:38:40,230
我想给你们10秒。

813
00:38:40,230 --> 00:38:41,140
只是很快的想法。

814
00:38:41,140 --> 00:38:43,450
这是我们有这么
到目前为止，什么后，我们发生

815
00:38:43,450 --> 00:38:46,770
执行该第五行权呢？

816
00:38:46,770 --> 00:38:54,030

817
00:38:54,030 --> 00:38:55,980
好。

818
00:38:55,980 --> 00:38:58,720
什么是？

819
00:38:58,720 --> 00:38:59,560
>> 听众：100。

820
00:38:59,560 --> 00:39:02,470
>> ANDI彭：100。

821
00:39:02,470 --> 00:39:03,610
什么为b呢？

822
00:39:03,610 --> 00:39:04,330
>> 听众：500。

823
00:39:04,330 --> 00:39:05,250
>> ANDI鹏：好的。

824
00:39:05,250 --> 00:39:08,570
是否有人想解释
对我来说这是为什么500？

825
00:39:08,570 --> 00:39:10,540
我不觉得我们
实际上碰过湾

826
00:39:10,540 --> 00:39:13,950
我们是怎么改
的B不接触B值？

827
00:39:13,950 --> 00:39:15,090
是吗？

828
00:39:15,090 --> 00:39:18,239
>> 听众：因为星PB
是指在pb--价值

829
00:39:18,239 --> 00:39:19,030
ANDI鹏：没错。

830
00:39:19,030 --> 00:39:19,790
听众：可呈现为b。

831
00:39:19,790 --> 00:39:20,581
ANDI鹏：没错。

832
00:39:20,581 --> 00:39:26,880
所以在这里我们的图中，我们的指针
PB实际上是指向这一权利

833
00:39:26,880 --> 00:39:28,690
在这里，这是实际的物理湾

834
00:39:28,690 --> 00:39:31,340
所以，如果你去
你做明星PB，这是

835
00:39:31,340 --> 00:39:36,080
下面您将鼠标指针箭头
和物理上改变b的值。

836
00:39:36,080 --> 00:39:39,532
所以这就是为什么我们B改变为
500没有实际接触湾

837
00:39:39,532 --> 00:39:42,490
然后一切依旧
同样的，因为我们没有触及这一点。

838
00:39:42,490 --> 00:39:47,060

839
00:39:47,060 --> 00:39:48,530
这是湾

840
00:39:48,530 --> 00:39:49,420
酷。

841
00:39:49,420 --> 00:39:50,485
接着 - 

842
00:39:50,485 --> 00:39:51,910
>> 观众：我只是有一个问题。

843
00:39:51,910 --> 00:39:52,730
>> ANDI彭：是吗？

844
00:39:52,730 --> 00:39:56,000
>> 听众：因为we've--
不再有符号C，

845
00:39:56,000 --> 00:39:59,620
这是否意味着一个符号
重定向到现在同样的事情？

846
00:39:59,620 --> 00:40:00,520
>> ANDI彭：是的。

847
00:40:00,520 --> 00:40:01,582
So--

848
00:40:01,582 --> 00:40:03,540
听众：所以箭头
那种只是移动和 - 

849
00:40:03,540 --> 00:40:04,030
ANDI彭：所以essentially--

850
00:40:04,030 --> 00:40:05,405
听众：--now我们不能access--

851
00:40:05,405 --> 00:40:08,387
ANDI彭： - 当我们
提领Çon--我伪造。

852
00:40:08,387 --> 00:40:08,970
那是什么？

853
00:40:08,970 --> 00:40:09,560
第三行？

854
00:40:09,560 --> 00:40:10,060
四。

855
00:40:10,060 --> 00:40:11,490
第四行。

856
00:40:11,490 --> 00:40:14,910
所有我们所做的是，从本质上讲，
改变这种箭头

857
00:40:14,910 --> 00:40:16,680
并将它指向了一个来代替。

858
00:40:16,680 --> 00:40:19,480
>> 听众：所以我们不能访问Ç了。

859
00:40:19,480 --> 00:40:22,520
>> ANDI彭：如果你有这个确切
号码，你可以访问它。

860
00:40:22,520 --> 00:40:23,260
但不是。

861
00:40:23,260 --> 00:40:25,680
我们没有一个指针
指向Ç了。

862
00:40:25,680 --> 00:40:27,430
我认为，如果你想
再次访问它，你

863
00:40:27,430 --> 00:40:30,390
将创建另一个
指针重新指向到c

864
00:40:30,390 --> 00:40:32,856
或提领这一点，并指出回来。

865
00:40:32,856 --> 00:40:35,730
所以，不，截至目前，三
三分球，他们没有指向C。

866
00:40:35,730 --> 00:40:38,800

867
00:40:38,800 --> 00:40:40,110
>> 每个人都好？

868
00:40:40,110 --> 00:40:41,440
答案是否在线。

869
00:40:41,440 --> 00:40:45,210
随意，节后，去了
过去两年和测试自己。

870
00:40:45,210 --> 00:40:47,840
同样的概念，只是一个
有点棘手。

871
00:40:47,840 --> 00:40:51,860
通过对逻辑只要按照
为什么事情是不同的东西。

872
00:40:51,860 --> 00:40:54,530
并且暗示，指针
我们爱的话题

873
00:40:54,530 --> 00:40:58,780
对测验覆盖，因为他们
概念上非常具有挑战性。

874
00:40:58,780 --> 00:41:01,360
因此，我建议你
家伙都评论此图

875
00:41:01,360 --> 00:41:05,916
或斜线类似概念
这是你的测验之前下周。

876
00:41:05,916 --> 00:41:06,864
>> 听众：对不起。

877
00:41:06,864 --> 00:41:07,530
>> ANDI彭：是吗？

878
00:41:07,530 --> 00:41:09,708
听众：[听不清]
最后埃德蒙顿[听不清]。

879
00:41:09,708 --> 00:41:12,710

880
00:41:12,710 --> 00:41:15,770
>> ANDI彭：50,000？

881
00:41:15,770 --> 00:41:17,850
我需要遵循它背下来。

882
00:41:17,850 --> 00:41:22,530
但somewhere--我觉得行
之前，你创造巨大的c值。

883
00:41:22,530 --> 00:41:26,250
c等于这个巨大的东西
也就是100倍500。

884
00:41:26,250 --> 00:41:27,006
第

885
00:41:27,006 --> 00:41:28,000
>> 听众：[听不清]。

886
00:41:28,000 --> 00:41:28,625
>> ANDI彭：是的。

887
00:41:28,625 --> 00:41:30,620
100乘以100是10,000。

888
00:41:30,620 --> 00:41:32,020
这是10,000。

889
00:41:32,020 --> 00:41:35,410
所以背下来有你
乘b和c。

890
00:41:35,410 --> 00:41:43,165
使得指向b--指针
这是500--倍的值A--

891
00:41:43,165 --> 00:41:44,480
>> 听众：[听不清]。

892
00:41:44,480 --> 00:41:45,730
ANDI彭：也许这是错误的。

893
00:41:45,730 --> 00:41:49,514
听众：不，不，不是这样的。 [听不清]
指针位于c现在指向A--

894
00:41:49,514 --> 00:41:50,180
ANDI彭：是的。

895
00:41:50,180 --> 00:41:50,840
他是对的。

896
00:41:50,840 --> 00:41:56,477
>> 听众：--IT是其在平等
一个times--这是c的值。

897
00:41:56,477 --> 00:41:59,560
ANDI彭：你能说一点点
位高​​涨所以每个人都可以听到你？

898
00:41:59,560 --> 00:42:04,879
听众：所以指针C现在点
到什么用的一个指针指向

899
00:42:04,879 --> 00:42:09,460
用于：仍然does--，但它们指向
同样的事情，这是一个，对不对？

900
00:42:09,460 --> 00:42:12,925
值的，但是
它被重新定义。

901
00:42:12,925 --> 00:42:17,875
而在那开始你
说一个是以前的100倍

902
00:42:17,875 --> 00:42:21,340
在B的值是500。

903
00:42:21,340 --> 00:42:24,305
所以这就是不过多是。

904
00:42:24,305 --> 00:42:24,805
50,000。

905
00:42:24,805 --> 00:42:32,860
他们你重新分配，要什么
在C内存空间is--指针位于c

906
00:42:32,860 --> 00:42:34,510
指向其是。

907
00:42:34,510 --> 00:42:38,460
所以你重新定义为50,000。

908
00:42:38,460 --> 00:42:40,210
ANDI彭：她能
教节对我来说。

909
00:42:40,210 --> 00:42:41,260
下一次，这一切都属于你。

910
00:42:41,260 --> 00:42:41,440
这里。

911
00:42:41,440 --> 00:42:42,564
下面是更多的糖果。

912
00:42:42,564 --> 00:42:45,790
你应该得到糖果的。

913
00:42:45,790 --> 00:42:47,260
>> 听众：我几乎赶上了。

914
00:42:47,260 --> 00:42:47,660
>> ANDI彭：你几乎赶上了。

915
00:42:47,660 --> 00:42:48,450
没关系。

916
00:42:48,450 --> 00:42:48,950
是啊。

917
00:42:48,950 --> 00:42:50,033
但她是完全正确的。

918
00:42:50,033 --> 00:42:54,469
所以，你必须做的事
是that--我想我们

919
00:42:54,469 --> 00:42:56,510
必须遵循的事实
该指针是现在

920
00:42:56,510 --> 00:42:57,880
指向不同的值。

921
00:42:57,880 --> 00:43:01,785
所以value--很抱歉，
的C指针重新瞄准到。

922
00:43:01,785 --> 00:43:04,390
而且使转向我们所有的数字。

923
00:43:04,390 --> 00:43:08,930
这就是为什么，当你访问
值存放在那里，这是不同的。

924
00:43:08,930 --> 00:43:10,490
那有意义吗？

925
00:43:10,490 --> 00:43:11,380
好。

926
00:43:11,380 --> 00:43:12,820
酷。

927
00:43:12,820 --> 00:43:16,635
大家好，我才继续前进？

928
00:43:16,635 --> 00:43:25,332
>> 听众：请问the--时，你会
向下在左侧列中的行，

929
00:43:25,332 --> 00:43:30,494
并在第一行影响第二次排
然后second--等，它们也all--

930
00:43:30,494 --> 00:43:31,160
ANDI彭：是的。

931
00:43:31,160 --> 00:43:37,610
所以，想象这就是我刚才输入的代码
在一个等于b乘以C，明星等于C。

932
00:43:37,610 --> 00:43:40,290
试想一下，我已经
只是跑这个代码

933
00:43:40,290 --> 00:43:42,710
我没有打印出什么
所有这些事情。

934
00:43:42,710 --> 00:43:46,200
如果我只是打印第一
在上面的东西，它会在这里。

935
00:43:46,200 --> 00:43:48,510
如果以后我跑了所有的
这些代码行，

936
00:43:48,510 --> 00:43:51,160
这些值的应
是在末端是。

937
00:43:51,160 --> 00:43:53,290
>> 所以，其实我已经写了一个程序在这里。

938
00:43:53,290 --> 00:43:55,840
我没有做过的所有的
乘法。

939
00:43:55,840 --> 00:43:58,310
但就可想而知了。

940
00:43:58,310 --> 00:44:00,370
所以在这里我只是有一个
程序调用指针。

941
00:44:00,370 --> 00:44:04,190
我会，如果你guys--确定进行放大。

942
00:44:04,190 --> 00:44:07,580
所以，我创建变量a，b和c。

943
00:44:07,580 --> 00:44:09,640
我已经将它们等于
3，4和5，我已经

944
00:44:09,640 --> 00:44:11,770
创建了相应的指针。

945
00:44:11,770 --> 00:44:14,550
然后，在这里我只是去
打印出那是什么。

946
00:44:14,550 --> 00:44:15,833
因此，让我跑了。

947
00:44:15,833 --> 00:44:21,520

948
00:44:21,520 --> 00:44:24,750
>> 难道你们see--废话。

949
00:44:24,750 --> 00:44:28,150
难道你们看如何，
b和c是那些值

950
00:44:28,150 --> 00:44:33,530
但他们的指针是这个巨人
垃圾的价值，我们不关心？

951
00:44:33,530 --> 00:44:36,690
所以，如果我是真正堵塞
在所有的乘法

952
00:44:36,690 --> 00:44:39,770
然后重新打印所有的
这一点，将执行了

953
00:44:39,770 --> 00:44:44,509
到位于底部什么。

954
00:44:44,509 --> 00:44:47,300
所以，如果你们想要玩
与实际的物理编码，

955
00:44:47,300 --> 00:44:49,000
你们只需插上所有的。

956
00:44:49,000 --> 00:44:52,860
该代码将在网上，然后你
值应打印到这事后。

957
00:44:52,860 --> 00:44:56,170
>> 然后你会看到如何指针
地址实际上重新分配。

958
00:44:56,170 --> 00:44:59,190
所以，你会怎么看
的C地址实际上变成

959
00:44:59,190 --> 00:45:00,920
等于什么的地址了。

960
00:45:00,920 --> 00:45:04,140
他们会匹配任何
这大量的。

961
00:45:04,140 --> 00:45:06,530
好问题。

962
00:45:06,530 --> 00:45:07,550
大家都没事吧？

963
00:45:07,550 --> 00:45:10,300
最后一个电话的问题。

964
00:45:10,300 --> 00:45:11,590
好。

965
00:45:11,590 --> 00:45:12,090
好吧。

966
00:45:12,090 --> 00:45:15,940
所以准备让你的心
吹稍微多一点。

967
00:45:15,940 --> 00:45:18,000
数组实际上只是指针。

968
00:45:18,000 --> 00:45:19,010
这就是它们。

969
00:45:19,010 --> 00:45:20,410
请记住，什么是字符串？

970
00:45:20,410 --> 00:45:21,630
他们还数组。

971
00:45:21,630 --> 00:45:23,110
那么，什么是字符串真的吗？

972
00:45:23,110 --> 00:45:27,100
他们就像指针到
开始更多的字符一个字符的。

973
00:45:27,100 --> 00:45:29,970
>> 所以，这只是概念开始
建立在彼此的顶部。

974
00:45:29,970 --> 00:45:32,030
所以这是why--您
记得在讲座中，大卫，

975
00:45:32,030 --> 00:45:34,990
当他有这样的比较
对INT字符串妈妈

976
00:45:34,990 --> 00:45:37,640
是什么，然后
另一个字符串妈妈和你

977
00:45:37,640 --> 00:45:41,240
尽量等同两人给对方，
他们给你不同的价值观。

978
00:45:41,240 --> 00:45:44,370
这是因为字符串
本身不值。

979
00:45:44,370 --> 00:45:48,860
所有却已是内存地址char--
他们是字符和数组的数组

980
00:45:48,860 --> 00:45:50,050
只是指针。

981
00:45:50,050 --> 00:45:54,022
>> 因此，在本质上，当
大卫comparing--

982
00:45:54,022 --> 00:45:55,355
那是正确的，如果我抹去这一切？

983
00:45:55,355 --> 00:46:02,320

984
00:46:02,320 --> 00:46:09,750
所以在讲课时，大卫·
有妈等于等于妈，

985
00:46:09,750 --> 00:46:11,630
我们这似乎是同一件事。

986
00:46:11,630 --> 00:46:12,317
对？

987
00:46:12,317 --> 00:46:15,150
但是，在下面的计算机
油烟机，实际发生的事情

988
00:46:15,150 --> 00:46:18,380
的是，这串，
所有这些都是是一个数组。

989
00:46:18,380 --> 00:46:21,420

990
00:46:21,420 --> 00:46:25,390
随着ampersand--或者，对不起，
使用空终止底。

991
00:46:25,390 --> 00:46:28,311

992
00:46:28,311 --> 00:46:28,810
对？

993
00:46:28,810 --> 00:46:29,940
反斜杠0。

994
00:46:29,940 --> 00:46:32,900
错误的反斜杠。

995
00:46:32,900 --> 00:46:35,960
>> 因此，所有这些were--所有
这两个字符串were--

996
00:46:35,960 --> 00:46:40,360
是四肢大小的数组
妈妈和妈妈的信。

997
00:46:40,360 --> 00:46:44,780
但阵列真的只是
指针在存储器中的特定位置

998
00:46:44,780 --> 00:46:47,140
告诉你开始你的阵列。

999
00:46:47,140 --> 00:46:52,370
所以在这种情况下，这一切是
只是一些垃圾的价值，

1000
00:46:52,370 --> 00:46:54,230
一些随机指针。

1001
00:46:54,230 --> 00:46:56,330
而这一切都被
其他一些垃圾的价值。

1002
00:46:56,330 --> 00:46:59,830
远的不说为0x200。

1003
00:46:59,830 --> 00:47:02,410
>> 所以，当您尝试平等
它们两彼此

1004
00:47:02,410 --> 00:47:06,130
他们评估为false，因为
在addresses--指针

1005
00:47:06,130 --> 00:47:08,390
它们were--是不同的。

1006
00:47:08,390 --> 00:47:11,400
虽然它是不同的，如果你
试图比较实际的整数。

1007
00:47:11,400 --> 00:47:15,820
就像如果你想compare--
在最后example-- INT a到b，

1008
00:47:15,820 --> 00:47:17,640
他们将评估
要真正为艾略特说

1009
00:47:17,640 --> 00:47:19,431
因为他们是
被存储在该整数

1010
00:47:19,431 --> 00:47:21,320
和你正在评估只值。

1011
00:47:21,320 --> 00:47:25,090
在这里，因为字符串数组
和所有的数组的指针，

1012
00:47:25,090 --> 00:47:28,080
这就是为什么他们不
彼此相等。

1013
00:47:28,080 --> 00:47:31,210
>> 所以，那种混乱的，该图形。

1014
00:47:31,210 --> 00:47:32,450
但是，让我们想像。

1015
00:47:32,450 --> 00:47:38,110
我们已经创建大小的数组
3从0索引到2-- 0，

1016
00:47:38,110 --> 00:47:41,530
1，2为1的值，
2，和3存储在其中。

1017
00:47:41,530 --> 00:47:43,820
所有的阵列真
does--在这里，我们只

1018
00:47:43,820 --> 00:47:46,720
说我创造一个指针
该阵列是

1019
00:47:46,720 --> 00:47:50,810
访问的值
该数组的第一个索引。

1020
00:47:50,810 --> 00:47:52,890
所以在这里这将是0。

1021
00:47:52,890 --> 00:47:53,390
对？

1022
00:47:53,390 --> 00:47:56,820
大家是否明白如何
即第一行评估？

1023
00:47:56,820 --> 00:47:57,420
太好了。

1024
00:47:57,420 --> 00:48:00,800
>> 所以，如果你想进行初始化
在那之后的附加价值，

1025
00:48:00,800 --> 00:48:04,390
所有我们正在做的是重新分配。

1026
00:48:04,390 --> 00:48:08,810
所以0，1，2，1。

1027
00:48:08,810 --> 00:48:12,770
所以这个指针，曾经
指着在这里，我们所做的

1028
00:48:12,770 --> 00:48:15,540
正在向下移动。

1029
00:48:15,540 --> 00:48:16,970
这就是加1在做什么。

1030
00:48:16,970 --> 00:48:18,500
然后我们就可以把2中。

1031
00:48:18,500 --> 00:48:23,250
如果我们希望把3一
之后，我们会删除该指针，

1032
00:48:23,250 --> 00:48:25,170
把3在那里。

1033
00:48:25,170 --> 00:48:26,420
这是否有意义每个人？

1034
00:48:26,420 --> 00:48:26,920
是啊。

1035
00:48:26,920 --> 00:48:28,086
你有问题吗？

1036
00:48:28,086 --> 00:48:30,711
听众：这是[听不清]有
一个问题，我反正说了吧。

1037
00:48:30,711 --> 00:48:35,496
我不认为它实际上是一个
但是 - 在英语的问题，阵列

1038
00:48:35,496 --> 00:48:37,448
等于1是有道理的。

1039
00:48:37,448 --> 00:48:39,888
我们想，好，第一件事情。

1040
00:48:39,888 --> 00:48:44,280
但事情0指数
[听不清]数组等于0

1041
00:48:44,280 --> 00:48:48,024
以指示第一点。

1042
00:48:48,024 --> 00:48:48,690
ANDI彭：是的。

1043
00:48:48,690 --> 00:48:53,740
所以，其实我在做什么在这里
我没有访问的第一个索引。

1044
00:48:53,740 --> 00:48:57,930
所有我doing--所以首先，
告诉我是什么星阵呢？

1045
00:48:57,930 --> 00:48:59,480
什么是一个指针之前，一个明星吗？

1046
00:48:59,480 --> 00:49:00,855
>> 听众：它表示一个指针。

1047
00:49:00,855 --> 00:49:02,910
那你声明的指针。

1048
00:49:02,910 --> 00:49:04,380
它de--

1049
00:49:04,380 --> 00:49:07,520
>> ANDI彭：它解引用此装置
它会与实际获取的价值。

1050
00:49:07,520 --> 00:49:08,020
对？

1051
00:49:08,020 --> 00:49:13,030
所以在这种情况下，要得到
这里，并设置为1的值。

1052
00:49:13,030 --> 00:49:13,800
是吗？

1053
00:49:13,800 --> 00:49:17,050
所以我不actually--我不
真正关心的这个指标，

1054
00:49:17,050 --> 00:49:21,406
我做的仅仅是迭代下降
通过移动指针我向下排列。

1055
00:49:21,406 --> 00:49:23,280
然后最终我
要阻止它，对吗？

1056
00:49:23,280 --> 00:49:26,750
而且我停止方式
是我击球的时候，在案件

1057
00:49:26,750 --> 00:49:28,750
一个字符串，一个空终止的。

1058
00:49:28,750 --> 00:49:32,710
我知道，哦，如果我打一个back--如果我看到
反斜线0，我知道我做过这个

1059
00:49:32,710 --> 00:49:35,270
我知道我可以只
停止迭代通过。

1060
00:49:35,270 --> 00:49:36,200
非常好的问题。

1061
00:49:36,200 --> 00:49:40,210
>> 我们真的会走的更远
在深入这个下周

1062
00:49:40,210 --> 00:49:43,990
因为一块，那将
涉及到很多指针的使用。

1063
00:49:43,990 --> 00:49:48,459
但只知道，现在，
这只是一个不同的缓慢 - 

1064
00:49:48,459 --> 00:49:51,250
这只是一种不同的方式进行
电脑写，从本质上讲，

1065
00:49:51,250 --> 00:49:52,470
我们一直在做的。

1066
00:49:52,470 --> 00:49:54,900
就像大卫说
讲课的样子，我们

1067
00:49:54,900 --> 00:50:01,720
访问数组只是做
阵列0，托架0，如果我们只是

1068
00:50:01,720 --> 00:50:04,050
想访问的第一个值。

1069
00:50:04,050 --> 00:50:10,280
>> 所有计算机的工作正在转向
那成和迭代本身。

1070
00:50:10,280 --> 00:50:13,580
因此，我们把它叫做句法
糖这只是

1071
00:50:13,580 --> 00:50:18,420
的话说用户友好的一个奇特的方式
我们如何知道如何编程。

1072
00:50:18,420 --> 00:50:21,560
但是电脑
下面，它在做什么，

1073
00:50:21,560 --> 00:50:23,997
它实际上只是有
指针多数民众赞成调整。

1074
00:50:23,997 --> 00:50:26,330
但是，我们写的方式，
因为它更容易为我们

1075
00:50:26,330 --> 00:50:30,240
考虑事情的角度
盒和如何移动向下拖曳，

1076
00:50:30,240 --> 00:50:32,190
是由具有括号。

1077
00:50:32,190 --> 00:50:36,394
对不起，这是真的，
真正但是 - 不好呀。

1078
00:50:36,394 --> 00:50:38,310
听众：那么，如何会
你比较两个字符串

1079
00:50:38,310 --> 00:50:40,560
看它们是否彼此相等的？

1080
00:50:40,560 --> 00:50:42,690
>> ANDI彭：大卫写道：
这一计划讲座

1081
00:50:42,690 --> 00:50:45,274
所以我只是要去
在快速并简单。

1082
00:50:45,274 --> 00:50:47,440
你会做这件​​事的方法
是，你实际上会

1083
00:50:47,440 --> 00:50:51,300
需要去比较
addresses--或值

1084
00:50:51,300 --> 00:50:52,810
从指针获得。

1085
00:50:52,810 --> 00:50:55,140
所以请记住，你怎么了
这里获得的价值？

1086
00:50:55,140 --> 00:50:56,825
我不关心地址在这里。

1087
00:50:56,825 --> 00:50:58,950
我如何真正得到的
任何的价值在这里？

1088
00:50:58,950 --> 00:50:59,470
>> 听众：[听不清]。

1089
00:50:59,470 --> 00:51:00,261
>> ANDI鹏：没错。

1090
00:51:00,261 --> 00:51:05,090
所以，你比较的明星
这里与这里的明星。

1091
00:51:05,090 --> 00:51:06,150
那些是相等的。

1092
00:51:06,150 --> 00:51:07,690
然后你去。

1093
00:51:07,690 --> 00:51:09,530
是这里的明星，
明星在这里一样的吗？

1094
00:51:09,530 --> 00:51:10,030
好。

1095
00:51:10,030 --> 00:51:10,283
他们是平等的。

1096
00:51:10,283 --> 00:51:12,866
而你只是保持下去
直到你击中双方的结束。

1097
00:51:12,866 --> 00:51:16,190
如果所有的人都是平等的，那么
你知道你的字符串是相等的。

1098
00:51:16,190 --> 00:51:18,130
与C实际上有一个
功能书面叫

1099
00:51:18,130 --> 00:51:20,713
字符串比较这其实只是
这是否给你，让你不“

1100
00:51:20,713 --> 00:51:22,140
要自己写。

1101
00:51:22,140 --> 00:51:23,274
是吗？

1102
00:51:23,274 --> 00:51:26,970
>> 听众：我想在讲座
当我们做了比较。

1103
00:51:26,970 --> 00:51:29,520
我们并不真正需要一个
如pi柜台，对不对？

1104
00:51:29,520 --> 00:51:34,310
>> ANDI彭：你不
因为我们真的不关心

1105
00:51:34,310 --> 00:51:36,250
我们已经多少盒通过迭代。

1106
00:51:36,250 --> 00:51:39,580
我们所关心的是，我们要
继续下去，直到我知道停下来。

1107
00:51:39,580 --> 00:51:41,990
你知道停止的时候
有某种指示

1108
00:51:41,990 --> 00:51:45,310
你是在一个空终止。

1109
00:51:45,310 --> 00:51:45,930
是啊。

1110
00:51:45,930 --> 00:51:47,154
So--

1111
00:51:47,154 --> 00:51:48,070
听众：[听不清]。

1112
00:51:48,070 --> 00:51:48,736
ANDI彭：是的。

1113
00:51:48,736 --> 00:51:51,950
因此，在比较的情况下
串，我真的不

1114
00:51:51,950 --> 00:51:54,207
关心多少个字母
are--我需要比较

1115
00:51:54,207 --> 00:51:56,540
如果他们是真的还是假的，如果
它们彼此相等。

1116
00:51:56,540 --> 00:51:58,914
我不在乎多少个字母
在他们每个人的，对吧？

1117
00:51:58,914 --> 00:52:01,130
我只关心这个
与此和所述一个匹配

1118
00:52:01,130 --> 00:52:05,311
火柴和之后的一个接
比赛一路上扬，直到结束。

1119
00:52:05,311 --> 00:52:05,810
对？

1120
00:52:05,810 --> 00:52:07,000
那有意义吗？

1121
00:52:07,000 --> 00:52:10,166
>> 所以，我真的不关心有多少信件，
我只关心，所有的字母

1122
00:52:10,166 --> 00:52:11,050
匹配。

1123
00:52:11,050 --> 00:52:12,910
是啊。

1124
00:52:12,910 --> 00:52:13,920
好。

1125
00:52:13,920 --> 00:52:16,840
我可以从这个感动吗？

1126
00:52:16,840 --> 00:52:18,489
太好了。

1127
00:52:18,489 --> 00:52:21,280
我们正在运行有点短上
时间，所以我将只允许你

1128
00:52:21,280 --> 00:52:23,670
球员简要回顾一下这个。

1129
00:52:23,670 --> 00:52:26,430
运行到你的ID，如果
你们是好奇。

1130
00:52:26,430 --> 00:52:30,030
而且你们可以看到什么
这将被打印出。

1131
00:52:30,030 --> 00:52:30,640
好。

1132
00:52:30,640 --> 00:52:34,990
>> 所以的东西，我们也将触及一个
位指针运算的想法。

1133
00:52:34,990 --> 00:52:38,180
其中，所有的都好，就是
而不是调整

1134
00:52:38,180 --> 00:52:42,610
的所存储的值
在您的指针的地址，

1135
00:52:42,610 --> 00:52:45,030
它只是实际改变
地址本身。

1136
00:52:45,030 --> 00:52:49,420
所以，如果你作为人的通缉
手动调整指针，

1137
00:52:49,420 --> 00:52:52,700
你会做到这一点的方法就是
做指针的n倍的大小。

1138
00:52:52,700 --> 00:52:53,240
对？

1139
00:52:53,240 --> 00:52:54,810
>> 因此，一个int。

1140
00:52:54,810 --> 00:52:58,580
一个int--多少字节
在内存中是一个int？

1141
00:52:58,580 --> 00:52:59,640
这是四，对不对？

1142
00:52:59,640 --> 00:53:03,520
所以，如果我知道，我把所有的数组
整数，我希望它指向一个

1143
00:53:03,520 --> 00:53:08,470
后来，我知道，我只是要
移动我的指针下四个字节，对不对？

1144
00:53:08,470 --> 00:53:12,440
因此n次的大小
的指针字节

1145
00:53:12,440 --> 00:53:15,890
然而，多少字节，你只是
要通过移动鼠标指针向下。

1146
00:53:15,890 --> 00:53:20,350
>> 因此，例如，如果我们有一个数组
整数，第一个，我们只能说，

1147
00:53:20,350 --> 00:53:22,280
被存储为0x00。

1148
00:53:22,280 --> 00:53:26,150
你知道下一次将是在
0×04，因为这四个字节后面。

1149
00:53:26,150 --> 00:53:31,030
而在这之后的人会
为0x08等等等等。

1150
00:53:31,030 --> 00:53:33,830
所以，伙计们，一起来看看。

1151
00:53:33,830 --> 00:53:36,640
>> 所有你在这里所做的是
你有一个指针ÿ

1152
00:53:36,640 --> 00:53:43,700
而你还说你
内存，让您可以向下移动

1153
00:53:43,700 --> 00:53:45,559
的存储器块进行分配。

1154
00:53:45,559 --> 00:53:46,850
样的一个更高层次的概念。

1155
00:53:46,850 --> 00:53:48,820
你们将不再需要
要知道，本周，

1156
00:53:48,820 --> 00:53:51,290
但是这一切都在做那里。

1157
00:53:51,290 --> 00:53:55,190

1158
00:53:55,190 --> 00:53:55,900
好。

1159
00:53:55,900 --> 00:53:56,710
>> 另一个笑话时间。

1160
00:53:56,710 --> 00:54:01,360

1161
00:54:01,360 --> 00:54:02,780
两串走进一间酒吧。

1162
00:54:02,780 --> 00:54:05,713
一个人说，我想一个朗姆酒
可乐垃圾值。

1163
00:54:05,713 --> 00:54:08,796
另一个人说，你得原谅
我的朋友，他没有空值终止。

1164
00:54:08,796 --> 00:54:10,390
你们得到它。

1165
00:54:10,390 --> 00:54:10,890
抱歉。

1166
00:54:10,890 --> 00:54:13,490
这就是我如何保持自己
当我预习的节会

1167
00:54:13,490 --> 00:54:15,650
是我插入了几个笑话幻灯片。

1168
00:54:15,650 --> 00:54:16,150
反正。

1169
00:54:16,150 --> 00:54:21,460

1170
00:54:21,460 --> 00:54:21,960
好。

1171
00:54:21,960 --> 00:54:24,290
之前，我谨on--
因此，从本质上讲，我们已经

1172
00:54:24,290 --> 00:54:30,600
涵盖了所有的概念
有关指针的问题。

1173
00:54:30,600 --> 00:54:34,090
然后，我们将talk--移动
更多的，说说为什么这很重要

1174
00:54:34,090 --> 00:54:37,810
以及如何装配到
理念的内存管理。

1175
00:54:37,810 --> 00:54:39,810
但在此之前我继续前进，
有没有人有问题

1176
00:54:39,810 --> 00:54:43,880
关于指针使用，这是怎么回事
当你创建的指针上，

1177
00:54:43,880 --> 00:54:47,540
如何引用各
另外，它们是怎样被提领？

1178
00:54:47,540 --> 00:54:51,760
有关的任何问题
之前，我继续前进？

1179
00:54:51,760 --> 00:54:53,060
好。

1180
00:54:53,060 --> 00:54:54,770
太好了。

1181
00:54:54,770 --> 00:54:58,170
>> 因此，这给我们带来了这个
较大的更高层次的概念

1182
00:54:58,170 --> 00:55:00,310
内存管理的全过程。

1183
00:55:00,310 --> 00:55:02,720
因此，基本上，在
您的计算机，有

1184
00:55:02,720 --> 00:55:06,300
两种基本类型的存储器或
在其中的存储区域被存储。

1185
00:55:06,300 --> 00:55:10,210
您这里有什么所谓
堆和你在这儿

1186
00:55:10,210 --> 00:55:11,550
什么叫做堆栈。

1187
00:55:11,550 --> 00:55:13,966
而且我们要谈谈
栈首先是因为它是

1188
00:55:13,966 --> 00:55:16,910
更finagley一个你
有一种概念

1189
00:55:16,910 --> 00:55:18,570
明白这是怎么回事。

1190
00:55:18,570 --> 00:55:23,930
>> 因此，所有的堆叠is--想到的
它作为存储器中的物理栈

1191
00:55:23,930 --> 00:55:28,880
那就是你有一个内存块
多数民众赞成预留程序

1192
00:55:28,880 --> 00:55:30,180
而它的运行。

1193
00:55:30,180 --> 00:55:34,480
这是在哪里，基本上，所有的
您的局部变量的存储位置。

1194
00:55:34,480 --> 00:55:38,300
所以这只是一个放大
在那一叠照片。

1195
00:55:38,300 --> 00:55:41,060
堆栈那里，我
只是放大了一点。

1196
00:55:41,060 --> 00:55:46,170
>> 因此，基本上，在堆叠有
在你的程序了一堆功能。

1197
00:55:46,170 --> 00:55:48,250
所以，就让我们回去
到本周二的例子

1198
00:55:48,250 --> 00:55:51,450
在这里，我们有我们的主要功能
以及一个立方体功能

1199
00:55:51,450 --> 00:55:56,410
在这里我们试图建立一个函数，
cubed--是把参数作为输入，

1200
00:55:56,410 --> 00:55:59,110
立方他们返回
他们回到主。

1201
00:55:59,110 --> 00:56:02,459
这样的方式，一个储存在存储器
是，你有你的主要功能

1202
00:56:02,459 --> 00:56:03,250
这里在底部。

1203
00:56:03,250 --> 00:56:06,630
然后用每个附加功能
您致电，并添加最重要的是，

1204
00:56:06,630 --> 00:56:07,960
内存只是堆在上面。

1205
00:56:07,960 --> 00:56:10,190
把它看成是一个物理堆叠。

1206
00:56:10,190 --> 00:56:13,570
>> 所以，你有在座的各位主要
你的主要函数的变量，

1207
00:56:13,570 --> 00:56:15,260
一切是怎么回事，存储。

1208
00:56:15,260 --> 00:56:17,440
然后当你打电话
立方体，它会和它

1209
00:56:17,440 --> 00:56:20,810
创建的所有副本
参数和它们存储

1210
00:56:20,810 --> 00:56:23,010
上面在不同的地方。

1211
00:56:23,010 --> 00:56:24,280
所以，我们为什么要在乎？

1212
00:56:24,280 --> 00:56:29,220
我们关心的原因是，我们不能只
使用的参数这里 - 变量

1213
00:56:29,220 --> 00:56:33,080
这里 - 我们改变它们，我们预计
他们还可以在这里改变了，对不对？

1214
00:56:33,080 --> 00:56:35,910
>> 的想法是，他们保存的
在存储器不同的地方

1215
00:56:35,910 --> 00:56:40,540
这样一来，当你访问不同
功能，你的想法正在发生的事情

1216
00:56:40,540 --> 00:56:45,520
实际上并没有发生，因为
存储器位未互连。

1217
00:56:45,520 --> 00:56:50,530
这样一来，问题是真的
重要的是我们那种理解

1218
00:56:50,530 --> 00:56:54,100
是，如果，当我们运行
程序，函数的大小

1219
00:56:54,100 --> 00:56:57,159
堆栈frame--这样的身体，怎么
多少内存？我们给它？

1220
00:56:57,159 --> 00:56:59,950
也许这是一个巨大的功能，所以我们
必须给它那么多的内存。

1221
00:56:59,950 --> 00:57:02,230
但如果是小的，我们会
需要一个小点点。

1222
00:57:02,230 --> 00:57:05,980
>> 这样的想法是，我们正在运行时
一个程序，函数的大小

1223
00:57:05,980 --> 00:57:09,100
取决于多少
变量和变量的类型

1224
00:57:09,100 --> 00:57:10,940
我们想给它。

1225
00:57:10,940 --> 00:57:13,910
但是，如果数量
variables--及其大小，

1226
00:57:13,910 --> 00:57:16,140
多数民众赞成坚决不
通过你的编码器，但

1227
00:57:16,140 --> 00:57:20,580
是由实际确定的
用户程序的。

1228
00:57:20,580 --> 00:57:24,240
所以，如果我想创建一个函数
这把字符串从用户，

1229
00:57:24,240 --> 00:57:27,630
但我真的不知道有多大
这些字符串是，这对我来说很难

1230
00:57:27,630 --> 00:57:30,220
以配发的具体
所需的内存量。

1231
00:57:30,220 --> 00:57:30,920
对？

1232
00:57:30,920 --> 00:57:35,234
>> 因为如果这个function--如果
该用户输入一个巨大的字符串，

1233
00:57:35,234 --> 00:57:37,650
它会创建一个错误
什么叫基本

1234
00:57:37,650 --> 00:57:42,190
堆栈溢出，你超越
你有内存的边界。

1235
00:57:42,190 --> 00:57:44,250
所以，那么我们该怎么办？

1236
00:57:44,250 --> 00:57:47,290
如果我们不能创造这个巨人
堆叠，可以节省一切，

1237
00:57:47,290 --> 00:57:50,260
我们怎么做才能解决这个问题？

1238
00:57:50,260 --> 00:57:54,364
>> 因此，我们要继续前进和谈话
关于此第二类型的存储器

1239
00:57:54,364 --> 00:57:56,780
然后我们可以谈论如何
我们可以使用两者结合起来

1240
00:57:56,780 --> 00:57:58,550
要解决这个问题。

1241
00:57:58,550 --> 00:58:01,024
所以，现在我们要动起来
到的存储器的不同部分

1242
00:58:01,024 --> 00:58:01,690
在我们的电脑。

1243
00:58:01,690 --> 00:58:03,215
这就是所谓的堆。

1244
00:58:03,215 --> 00:58:07,150
因此，所有的堆是一个游泳池
可用内存

1245
00:58:07,150 --> 00:58:08,690
可动态分配。

1246
00:58:08,690 --> 00:58:12,420
这样，可以改变，同时
你的程序正在运行。

1247
00:58:12,420 --> 00:58:15,160
>> 等的区域
未使用的内存，可以

1248
00:58:15,160 --> 00:58:18,200
是allowed--，可以是
分配与功能

1249
00:58:18,200 --> 00:58:20,490
所谓的malloc或内存分配。

1250
00:58:20,490 --> 00:58:23,110
因此，本质上，当
你正在运行的程序，

1251
00:58:23,110 --> 00:58:29,560
你可以动态创建的内存
堆和使用，所有到这里。

1252
00:58:29,560 --> 00:58:34,280
因此然后，所有的功能
在这里可以访问堆。

1253
00:58:34,280 --> 00:58:37,960
>> 所以malloc的，这种想法，大卫·
一种快速，简单地掩盖

1254
00:58:37,960 --> 00:58:41,570
在讲座中，仅仅是一种方式，
你控制你的记忆。

1255
00:58:41,570 --> 00:58:45,470
就像，当你刚刚创建
堆叠功能，当你刚

1256
00:58:45,470 --> 00:58:48,290
让您的主要功能
与您的随机函数，

1257
00:58:48,290 --> 00:58:52,270
你认为他们是孩子，仅仅
逃跑的时候，你已经做完了他们。

1258
00:58:52,270 --> 00:58:53,690
他们真的坏事儿。

1259
00:58:53,690 --> 00:58:55,515
创建它们，你
教给他们的东西，

1260
00:58:55,515 --> 00:58:57,640
然后当你想
再次访问他们，他们是

1261
00:58:57,640 --> 00:58:59,850
不存在，因为你的
内存刚刚跑掉了。

1262
00:58:59,850 --> 00:59:04,140
>> 但malloc或堆，是一种
具有较好的儿童，在那里

1263
00:59:04,140 --> 00:59:07,090
一种可以创建
他们，将它们分配值，

1264
00:59:07,090 --> 00:59:11,080
使用them--听起来真
bad--使用它们不过你想要的，

1265
00:59:11,080 --> 00:59:14,002
但能够控制
他们，然后释放内存

1266
00:59:14,002 --> 00:59:14,960
每当你需要他们。

1267
00:59:14,960 --> 00:59:18,085
那么，当你和你做
功能，孩子们回来找你

1268
00:59:18,085 --> 00:59:20,290
你仍然有数据存在。

1269
00:59:20,290 --> 00:59:25,690
>> 因此，我们的malloc，或创建方式，
内存是由函数void明星

1270
00:59:25,690 --> 00:59:26,790
malloc的大小以字节为单位。

1271
00:59:26,790 --> 00:59:29,730
所以，这只是原型
为什么我们这样做。

1272
00:59:29,730 --> 00:59:35,800
因此，一个例子就是我们创建一个指针
类型int-- INT星级pointer--平等

1273
00:59:35,800 --> 00:59:38,120
整型malloc的大小。

1274
00:59:38,120 --> 00:59:41,734
那么，为什么我们做大小的原因
的，而不是只是一个number--

1275
00:59:41,734 --> 00:59:43,650
因为大家都知道，
一个int四个字节，

1276
00:59:43,650 --> 00:59:48,310
right--而是一个int是只有四
字节在某些操作系统。

1277
00:59:48,310 --> 00:59:50,410
>> 作为这个想法对我们来说
程序员是我们

1278
00:59:50,410 --> 00:59:53,160
要创建代码，可以
运行中的所有计算机，而不仅仅是

1279
00:59:53,160 --> 00:59:54,860
我们简单的电脑。

1280
00:59:54,860 --> 00:59:58,350
所以这就是为什么我们喜欢用
的大小，而不是只数4。

1281
00:59:58,350 --> 00:59:59,970
这是否有意义给大家？

1282
00:59:59,970 --> 01:00:03,930
因此，大小of--所有它是一个C
函数或运算符

1283
01:00:03,930 --> 01:00:09,350
告诉你多少字节的内存呢
某种类型的变量占用。

1284
01:00:09,350 --> 01:00:11,150
所以在这种情况下，一个int的尺寸为四。

1285
01:00:11,150 --> 01:00:12,090
四个字节。

1286
01:00:12,090 --> 01:00:15,490
和malloc是要释放
在你的堆四个字节，

1287
01:00:15,490 --> 01:00:18,790
然后你就可以在你的主要用途
功能，以便能够存储存储器。

1288
01:00:18,790 --> 01:00:22,460

1289
01:00:22,460 --> 01:00:24,860
是每个人都在说清楚这么远吗？

1290
01:00:24,860 --> 01:00:25,918
是吗？

1291
01:00:25,918 --> 01:00:28,122
>> 听众：我很清楚，但
刚刚结束clear--

1292
01:00:28,122 --> 01:00:28,705
ANDI彭：OK。

1293
01:00:28,705 --> 01:00:29,246
完全罚款。

1294
01:00:29,246 --> 01:00:32,176
听众：--size是[听不清]
实际上可以[听不清]

1295
01:00:32,176 --> 01:00:34,384
它会怎么做的
我们希望它的东西。

1296
01:00:34,384 --> 01:00:35,380
这不是一些伪代码。

1297
01:00:35,380 --> 01:00:35,878
>> ANDI彭：没有。

1298
01:00:35,878 --> 01:00:36,874
>> 听众：这就像一个真正件事 - 

1299
01:00:36,874 --> 01:00:37,372
>> ANDI彭：这是真正的代码。

1300
01:00:37,372 --> 01:00:38,455
>> 听众： - 我们可以使用它。

1301
01:00:38,455 --> 01:00:39,862
这是实际的。

1302
01:00:39,862 --> 01:00:40,418
酷。

1303
01:00:40,418 --> 01:00:41,751
ANDI彭：尺寸自带C.

1304
01:00:41,751 --> 01:00:43,475
听众：那让我的生活更幸福。

1305
01:00:43,475 --> 01:00:45,550
ANDI彭：是的。

1306
01:00:45,550 --> 01:00:48,610
所以，如果你是一个懒惰的程序员
有点像我，有时，

1307
01:00:48,610 --> 01:00:50,402
我不喜欢记忆
什么尺寸的一个int

1308
01:00:50,402 --> 01:00:52,734
是的，我不喜欢记忆
有一个浮动的大小。

1309
01:00:52,734 --> 01:00:55,160
只是尺寸告诉你什么
这是，这是一个容易得多。

1310
01:00:55,160 --> 01:00:59,880

1311
01:00:59,880 --> 01:01:00,440
>> 好吧。

1312
01:01:00,440 --> 01:01:02,160
因此，一个重要的事情
那你们都想要

1313
01:01:02,160 --> 01:01:04,620
要记住，当你
使用malloc是您永远

1314
01:01:04,620 --> 01:01:06,400
必须进行检查，看它是否为空。

1315
01:01:06,400 --> 01:01:08,630
所以，就像我说的，回
该照片的堆。

1316
01:01:08,630 --> 01:01:11,390
堆就是这个巨人
内存堆栈，你有。

1317
01:01:11,390 --> 01:01:16,740
而你要能够把块
从它的内存并使用它，对吗？

1318
01:01:16,740 --> 01:01:19,750
>> 但是，如果你没有
在这堆更多的内存？

1319
01:01:19,750 --> 01:01:23,650
如果我已经用什么都
它和我尝试对malloc更多？

1320
01:01:23,650 --> 01:01:24,864
不存在。

1321
01:01:24,864 --> 01:01:26,780
嗯，这就是为什么你
要得到一个错误。

1322
01:01:26,780 --> 01:01:29,220
你会赛格故障。你会
有段错误，你

1323
01:01:29,220 --> 01:01:30,940
尝试访问的东西都是不存在的。

1324
01:01:30,940 --> 01:01:33,180
这样一来，这样我们做
那和方式，我们

1325
01:01:33,180 --> 01:01:36,120
防止的是，我们检查
以查看是否指针的空。

1326
01:01:36,120 --> 01:01:41,650
>> 所以，如果我是对ma​​lloc的东西
我没有更多的内存，

1327
01:01:41,650 --> 01:01:45,501
这将打印，因为一个错误
指针回到你只是空。

1328
01:01:45,501 --> 01:01:47,750
这样一来，这样我们做this--
这下好了设计，

1329
01:01:47,750 --> 01:01:52,140
只是记住this--是任何
一次尝试的malloc什么，

1330
01:01:52,140 --> 01:01:55,300
你将需要
检查，看它是否是空。

1331
01:01:55,300 --> 01:01:58,257
因为每当你尝试
从堆中获取内存，

1332
01:01:58,257 --> 01:02:00,340
你总是要做出
确保您有记忆。

1333
01:02:00,340 --> 01:02:01,350
这就是它。

1334
01:02:01,350 --> 01:02:04,980
>> 因此，相当多这三个
行代码，熟记。

1335
01:02:04,980 --> 01:02:06,830
每次你的malloc，扑通一声他们进来。

1336
01:02:06,830 --> 01:02:08,190
你会需要它们。

1337
01:02:08,190 --> 01:02:10,540
因为我向你保证，我们将
测试你的情况，你的电脑

1338
01:02:10,540 --> 01:02:13,498
会爆炸，因为你
要尝试存取存储器的

1339
01:02:13,498 --> 01:02:16,680
不存在，事情将要
偶们这不会是好的。

1340
01:02:16,680 --> 01:02:19,290
因此，只要钻取到你的大脑。

1341
01:02:19,290 --> 01:02:21,370
malloc的，无效。

1342
01:02:21,370 --> 01:02:22,360
好。

1343
01:02:22,360 --> 01:02:22,860
好吧。

1344
01:02:22,860 --> 01:02:26,280

1345
01:02:26,280 --> 01:02:28,340
>> 那么这生子;
发生了什么问题

1346
01:02:28,340 --> 01:02:30,550
我们正在使用的内存后完成。

1347
01:02:30,550 --> 01:02:32,390
因为整个的想法
具有的malloc是

1348
01:02:32,390 --> 01:02:36,460
我们有这样的堆，我们可以采取
从内存中，然后我们可以使用它。

1349
01:02:36,460 --> 01:02:37,220
对？

1350
01:02:37,220 --> 01:02:40,550
然后，我们要记住
在这之后，我们用它做，

1351
01:02:40,550 --> 01:02:41,900
那么我们就可以释放它。

1352
01:02:41,900 --> 01:02:42,400
让它去吧。

1353
01:02:42,400 --> 01:02:43,979
我们可以让他走了。

1354
01:02:43,979 --> 01:02:47,020
要不然你也将泄漏
内存和更坏的事情会发生。

1355
01:02:47,020 --> 01:02:49,010
>> 从本质上讲，只要
你触摸存储器，

1356
01:02:49,010 --> 01:02:51,800
如果不好的事情会发生
不正确地做事情。

1357
01:02:51,800 --> 01:02:55,150
所以，你必须检查，首先，
如果您有可用的存储空间。

1358
01:02:55,150 --> 01:02:58,700
然后就大功告成了之后，你要
释放它，让你的操作系统

1359
01:02:58,700 --> 01:03:00,690
把它收回。

1360
01:03:00,690 --> 01:03:04,870
所以我们这样做的方式就是这样
功能，无空隙，指针

1361
01:03:04,870 --> 01:03:06,370
以内存堆。

1362
01:03:06,370 --> 01:03:08,680
>> 所以这个例子是自由指针。

1363
01:03:08,680 --> 01:03:11,580
这是很容易，操作简单，
不要忘记它。

1364
01:03:11,580 --> 01:03:14,687
因此，检查，看它是否为null，免费的。

1365
01:03:14,687 --> 01:03:15,270
每个人都好？

1366
01:03:15,270 --> 01:03:22,660

1367
01:03:22,660 --> 01:03:27,325
所以再次，代码，你们
可以种迅速采取了一眼。

1368
01:03:27,325 --> 01:03:34,964

1369
01:03:34,964 --> 01:03:37,880
我知道这是一个很多新的语法和
它的所有权利，如果你喜欢啊，

1370
01:03:37,880 --> 01:03:38,963
这是什么意思了吗？

1371
01:03:38,963 --> 01:03:40,250
别担心。

1372
01:03:40,250 --> 01:03:46,785
所有这一切都意味着要被显示
一个动作，如何将所有这些东西

1373
01:03:46,785 --> 01:03:47,660
可以一起使用。

1374
01:03:47,660 --> 01:03:52,190

1375
01:03:52,190 --> 01:03:54,190
所以这是放在一起
就像一群过去

1376
01:03:54,190 --> 01:03:56,532
幻灯片，我们只是去
通过到一个程序。

1377
01:03:56,532 --> 01:03:58,240
听众：在某种程度上
我们可以actually--

1378
01:03:58,240 --> 01:03:59,570
ANDI彭：在一个方式，
我们实际上可以使用。

1379
01:03:59,570 --> 01:04:02,379
你可以放下了到您的ID，
你可以运行它，它会工作。

1380
01:04:02,379 --> 01:04:02,920
听众：OK。

1381
01:04:02,920 --> 01:04:04,140
所以这是真的吗？

1382
01:04:04,140 --> 01:04:05,580
>> ANDI彭：这是真实的。

1383
01:04:05,580 --> 01:04:06,430
是啊。

1384
01:04:06,430 --> 01:04:08,690
我尽量做到让
字体是不同的，因此

1385
01:04:08,690 --> 01:04:11,770
每当我键入真实的
代码中的字体是字体代码

1386
01:04:11,770 --> 01:04:15,471
而我记的代码是不同的，但
我不知道是否实际工作。

1387
01:04:15,471 --> 01:04:16,012
听众：第

1388
01:04:16,012 --> 01:04:17,190
我觉得 - 

1389
01:04:17,190 --> 01:04:18,213
>> ANDI彭：OK。

1390
01:04:18,213 --> 01:04:20,578
>> 听众：--sometimes
[听不清]和我

1391
01:04:20,578 --> 01:04:23,416
像，这将是真的很可爱
如果它实际上是一个有用的事

1392
01:04:23,416 --> 01:04:24,812
但它不是一个有用的东西。

1393
01:04:24,812 --> 01:04:26,270
我想，这是一个有用的事情。

1394
01:04:26,270 --> 01:04:27,010
>> ANDI彭：OK。

1395
01:04:27,010 --> 01:04:27,510
是啊。

1396
01:04:27,510 --> 01:04:28,430
我会通过沿。

1397
01:04:28,430 --> 01:04:33,266
要像大卫，孩子真的
伤心的时候你写假的代码。

1398
01:04:33,266 --> 01:04:34,240
好吧。

1399
01:04:34,240 --> 01:04:34,740
是吗？

1400
01:04:34,740 --> 01:04:37,686
>> 听众：所以这里的PTR
实际上不是一个指针，

1401
01:04:37,686 --> 01:04:41,130
它的内存块？

1402
01:04:41,130 --> 01:04:45,130
>> ANDI彭：所以你在说什么
第一行或一跌吗？

1403
01:04:45,130 --> 01:04:48,170
你说的是这个吗？

1404
01:04:48,170 --> 01:04:50,910
>> 听众：在PTR是
in--不同的东西

1405
01:04:50,910 --> 01:04:53,230
>> ANDI彭：嗯，所以在这里
我所实际doing--，

1406
01:04:53,230 --> 01:04:54,660
让我们只经过这里。

1407
01:04:54,660 --> 01:04:57,120
这种关系在
所有很好的概念。

1408
01:04:57,120 --> 01:05:01,840
所以在这里，我们有INT明星PTR。

1409
01:05:01,840 --> 01:05:04,160
所以诠释的指针，这就是
我们实际上创建

1410
01:05:04,160 --> 01:05:06,550
一个指针指向一个整数。

1411
01:05:06,550 --> 01:05:08,230
那么，它会指向一个整数。

1412
01:05:08,230 --> 01:05:12,135
而且我们要malloc或
给它，足够的内存分配

1413
01:05:12,135 --> 01:05:13,200
存储的整数。

1414
01:05:13,200 --> 01:05:14,910
在这种情况下，这样的四个字节。

1415
01:05:14,910 --> 01:05:18,024
>> 然后如果这等于null--平等
等于null--我们要打印。

1416
01:05:18,024 --> 01:05:20,440
哦，你因为一个错误
你出的内存，对不对？

1417
01:05:20,440 --> 01:05:22,814
否则，返回之一，
这只是告诉你的程序

1418
01:05:22,814 --> 01:05:24,170
你已经有了一个错误。

1419
01:05:24,170 --> 01:05:26,850
然后，如果你这样做
有记忆，它的

1420
01:05:26,850 --> 01:05:33,230
要存储什么让
INT让你进入的位置

1421
01:05:33,230 --> 01:05:35,460
并将其设置为指针的值。

1422
01:05:35,460 --> 01:05:38,500
因此，它实际上会
从物理上删除该值

1423
01:05:38,500 --> 01:05:41,702
并把一切得到int返回。

1424
01:05:41,702 --> 01:05:43,910
然后，你要
无论他们进入打印。

1425
01:05:43,910 --> 01:05:46,080
>> 听众：这就是
要在堆？

1426
01:05:46,080 --> 01:05:47,060
>> ANDI彭：这是怎么回事
将在堆。

1427
01:05:47,060 --> 01:05:48,768
>> 听众：所以这
将是可访问。

1428
01:05:48,768 --> 01:05:51,220
ANDI鹏：没错。

1429
01:05:51,220 --> 01:05:52,600
美观大方。

1430
01:05:52,600 --> 01:05:53,756
好。

1431
01:05:53,756 --> 01:05:59,289
>> 听众：所以当我们释放PTR在这个
最后一步，我们正在释放指针

1432
01:05:59,289 --> 01:06:00,724
或者我们正在释放块？

1433
01:06:00,724 --> 01:06:01,390
ANDI彭：是的。

1434
01:06:01,390 --> 01:06:05,570
因此，我们正在释放pointer--
好了，释放的内存块。

1435
01:06:05,570 --> 01:06:08,780
所以唯一的办法，我们甚至可以访问
存储器是由具有指针。

1436
01:06:08,780 --> 01:06:10,730
如果你没有指针，你
喜欢的哦，我不知道它在哪里，

1437
01:06:10,730 --> 01:06:11,290
对？

1438
01:06:11,290 --> 01:06:13,956
如果你释放它的话，你基本上
释放了整个街区。

1439
01:06:13,956 --> 01:06:16,500
那么你的计算机知道，哦，
没有什么可用的在这里，

1440
01:06:16,500 --> 01:06:19,396
我可以把垃圾
值回了一遍。

1441
01:06:19,396 --> 01:06:21,590
>> 听众：所以整数确实存在的呢？

1442
01:06:21,590 --> 01:06:23,481
>> ANDI彭：不要整数存在吗？

1443
01:06:23,481 --> 01:06:23,980
抱歉。

1444
01:06:23,980 --> 01:06:25,271
你能否重新表述您的问题吗？

1445
01:06:25,271 --> 01:06:28,330
听众：我的意思是，你释放后，
指针，整数，你得到的，

1446
01:06:28,330 --> 01:06:29,990
将仍然存在？

1447
01:06:29,990 --> 01:06:31,360
>> ANDI彭：不，不会。

1448
01:06:31,360 --> 01:06:34,070

1449
01:06:34,070 --> 01:06:37,550
或者至少它会存在于你
你的电脑做之前，内存

1450
01:06:37,550 --> 01:06:40,231
不管它，但有
没办法让你拿到。

1451
01:06:40,231 --> 01:06:41,480
因为你释放的指针。

1452
01:06:41,480 --> 01:06:43,150
你不知道它在哪里了。

1453
01:06:43,150 --> 01:06:43,650
是啊。

1454
01:06:43,650 --> 01:06:46,500

1455
01:06:46,500 --> 01:06:48,560
>> 我打算在这里移动。

1456
01:06:48,560 --> 01:06:49,060
唷。

1457
01:06:49,060 --> 01:06:53,012
因此，我们通过大量的概念的
内存管理困难

1458
01:06:53,012 --> 01:06:54,720
我们正要
基本上花

1459
01:06:54,720 --> 01:06:57,090
5，十几分钟去
在语法的事情，

1460
01:06:57,090 --> 01:07:03,240
将是可用的，并为你们有用，
但没有太概念了那里。

1461
01:07:03,240 --> 01:07:03,740
好。

1462
01:07:03,740 --> 01:07:06,930
>> 因此，我们这里完全改变齿轮。

1463
01:07:06,930 --> 01:07:09,360
内存管理，很难。
指针，很难。是。

1464
01:07:09,360 --> 01:07:10,530
这是真的，真的很难。

1465
01:07:10,530 --> 01:07:11,270
完全罚款。

1466
01:07:11,270 --> 01:07:13,800
这就是为什么你的作品是
将是真的很难。

1467
01:07:13,800 --> 01:07:17,740
但是，如果你去做
的事情，我们是

1468
01:07:17,740 --> 01:07:19,860
应该做的事情，使
确保一切都为空，

1469
01:07:19,860 --> 01:07:21,830
一定要检查，如果事情是
空，一定要释放内存，

1470
01:07:21,830 --> 01:07:23,910
确保一切都没有
漏水，你会好。

1471
01:07:23,910 --> 01:07:25,761
你将被设置。

1472
01:07:25,761 --> 01:07:26,260
好吧。

1473
01:07:26,260 --> 01:07:30,870
所以，我们要进入这个
重定向的全新的概念。

1474
01:07:30,870 --> 01:07:33,201
而之前那么现在​​，在
我们已经主要途径

1475
01:07:33,201 --> 01:07:35,700
与被交互我们
程序是通过标准输入

1476
01:07:35,700 --> 01:07:36,533
和标准输出。

1477
01:07:36,533 --> 01:07:37,040
对？

1478
01:07:37,040 --> 01:07:39,230
我们为用户输入
东西和计算机

1479
01:07:39,230 --> 01:07:42,090
吐回给我们的终端。

1480
01:07:42,090 --> 01:07:44,770
>> 但也有其他
如何让我们互动

1481
01:07:44,770 --> 01:07:47,810
与计算机与我们的
这不只是我的计划

1482
01:07:47,810 --> 01:07:50,245
物理打字的东西
在我的时候提示我。

1483
01:07:50,245 --> 01:07:52,620
而我们做到这一点的方法是
通过大于胡萝卜

1484
01:07:52,620 --> 01:07:53,453
和管道符号。

1485
01:07:53,453 --> 01:07:55,970

1486
01:07:55,970 --> 01:07:58,630
因此，我们也可以读取和
编写使用的文件。

1487
01:07:58,630 --> 01:08:03,230
>> 所以我们这样做的方式是
大于胡萝卜，所有正在做

1488
01:08:03,230 --> 01:08:07,410
正在写什么你
文件具有到一个单独的文件中。

1489
01:08:07,410 --> 01:08:11,870
因此，举例来说，如果我
想跑的hello world

1490
01:08:11,870 --> 01:08:14,330
我想输出到
保存在另一个文件

1491
01:08:14,330 --> 01:08:17,359
而不是仅仅打印出来给我，我
可以只比胡萝卜做的更大，

1492
01:08:17,359 --> 01:08:18,410
output.txt的。

1493
01:08:18,410 --> 01:08:22,609
因此，所有这一切做的是
我hello.world程序，

1494
01:08:22,609 --> 01:08:26,359
不管其输出是，它的
保存在一个名为output.txt的文件。

1495
01:08:26,359 --> 01:08:29,850
所以，大卫做了的方式
.csv格式与学生的名字，

1496
01:08:29,850 --> 01:08:32,310
它是相同的，你们可以做的。

1497
01:08:32,310 --> 01:08:35,137
>> 这有什么特别
有用这里有更大

1498
01:08:35,137 --> 01:08:38,220
than--两个大于胡萝卜
迹象，您可以追加到一个输出

1499
01:08:38,220 --> 01:08:40,795
文件，这意味着你
只需添加在它之上。

1500
01:08:40,795 --> 01:08:43,420
你可以只是不断增加
每增加一点output.txt的

1501
01:08:43,420 --> 01:08:44,490
你正在做的事情。

1502
01:08:44,490 --> 01:08:48,010
或者，如果你开始进入更多
复杂的程序，两个较大

1503
01:08:48,010 --> 01:08:50,939
比胡萝卜，只是打印
出了错误信息。

1504
01:08:50,939 --> 01:08:53,340
所以说，你有一个巨大的
错误消息量

1505
01:08:53,340 --> 01:08:54,810
和你想读
通过所有这些，你的

1506
01:08:54,810 --> 01:08:56,450
不希望有滚动
通过你的终端，

1507
01:08:56,450 --> 01:08:58,651
可以真正地做到
大于output.txt的

1508
01:08:58,651 --> 01:09:00,359
并且它要保存
所有的错误

1509
01:09:00,359 --> 01:09:02,900
在一个文件名为output.txt的那
你可以通过阅读。

1510
01:09:02,900 --> 01:09:04,622
听众：哪里是文本文件保存？

1511
01:09:04,622 --> 01:09:07,330
ANDI彭：它保存在同一
目录下，你的程序。

1512
01:09:07,330 --> 01:09:09,830
所以，你只要回去看看吧。

1513
01:09:09,830 --> 01:09:11,930
而同样的事情，我们
可以输入做的是

1514
01:09:11,930 --> 01:09:14,300
我们可以采取实际
一些文件的内容

1515
01:09:14,300 --> 01:09:16,380
我们可以输入该到我们的程序。

1516
01:09:16,380 --> 01:09:19,930
因此，而不是做命令
在那里你身体行参数

1517
01:09:19,930 --> 01:09:21,680
必须输入事
每一次，你

1518
01:09:21,680 --> 01:09:27,890
可实际上只是有一个名为
input.txt的，只是把它所有的研究。

1519
01:09:27,890 --> 01:09:31,970
>> 然后通过管道是特别爽，因为
它可以采取一个节目的输出

1520
01:09:31,970 --> 01:09:34,170
并把它作为输入
的另一个程序。

1521
01:09:34,170 --> 01:09:38,430
因此，例如，在你的球员“的Vigenere，
有这行代码，你

1522
01:09:38,430 --> 01:09:42,010
球员正在运行，你也许也许
真的不知道这是什么doing--

1523
01:09:42,010 --> 01:09:46,910
这./generate 1000年管./42。

1524
01:09:46,910 --> 01:09:47,510
对？

1525
01:09:47,510 --> 01:09:51,100
>> 因此，所有的在做，如果我们只是
看看这一步一步，

1526
01:09:51,100 --> 01:09:55,870
该./generate，这意味着我
运行我的程序产生。

1527
01:09:55,870 --> 01:09:58,850
即采取在1000在它的输入端。

1528
01:09:58,850 --> 01:10:03,330
所以我想生成1000随机
数字和我要去管that--

1529
01:10:03,330 --> 01:10:07,790
或者我会用that--输出
输入我的程序调用的发现。

1530
01:10:07,790 --> 01:10:12,110
而且我会尽量找42出
从这些1000生成的数字

1531
01:10:12,110 --> 01:10:13,130
数字。

1532
01:10:13,130 --> 01:10:15,410
这是否行代码，使
有意义的其他人？

1533
01:10:15,410 --> 01:10:17,820
>> 所以在这种方式，我们正在保存
我们一吨的步骤。

1534
01:10:17,820 --> 01:10:21,880
我们没有运行，保存，
该文件，然后把它放进发现。

1535
01:10:21,880 --> 01:10:23,800
我们可以做这一切在同一行。

1536
01:10:23,800 --> 01:10:28,080
所以，无论是生成输出，
坠落它右后卫找到。

1537
01:10:28,080 --> 01:10:28,580
是吗？

1538
01:10:28,580 --> 01:10:32,484
>> 听众：而在指挥方面
行参数，是that--那

1539
01:10:32,484 --> 01:10:33,948
三个命令行参数？

1540
01:10:33,948 --> 01:10:38,340
它的产生，find--没有，four--
产生，1000，查找和42？

1541
01:10:38,340 --> 01:10:39,134
或者是the--

1542
01:10:39,134 --> 01:10:42,050
ANDI彭：这样的管道并没有真正
算作一个命令行参数

1543
01:10:42,050 --> 01:10:44,590
因为编译器或
终端知道该管道，

1544
01:10:44,590 --> 01:10:48,590
哦，我知道我必须看前
管道，因为这是我的输出

1545
01:10:48,590 --> 01:10:51,220
我必须照顾
管，因为这是我的意见。

1546
01:10:51,220 --> 01:10:54,520
所以它知道that--的
./generate和1000，

1547
01:10:54,520 --> 01:10:57,390
这些都是那么两个命令参数
只是为第一程序。

1548
01:10:57,390 --> 01:11:01,760
然后./find 42两个命令
行参数的第二个项目。

1549
01:11:01,760 --> 01:11:02,980
是啊。

1550
01:11:02,980 --> 01:11:06,150
每个人都好就这个？

1551
01:11:06,150 --> 01:11:10,610
>> 因此，只要真正的快，做什么
这三行代码呢？

1552
01:11:10,610 --> 01:11:11,606
很简单。

1553
01:11:11,606 --> 01:11:13,605
任何人想告诉我
什么样的第一行呢？

1554
01:11:13,605 --> 01:11:18,201

1555
01:11:18,201 --> 01:11:19,117
听众：[听不清]。

1556
01:11:19,117 --> 01:11:23,540

1557
01:11:23,540 --> 01:11:26,534
>> ANDI彭：把它看成just--
什么是大于胡萝卜吗？

1558
01:11:26,534 --> 01:11:29,299
>> 听众：它把东西
到下一行。

1559
01:11:29,299 --> 01:11:31,090
ANDI彭：那么，什么是
那相反？

1560
01:11:31,090 --> 01:11:33,514
听众：它把下一个
事成的第一件事情。

1561
01:11:33,514 --> 01:11:34,180
ANDI彭：是的。

1562
01:11:34,180 --> 01:11:37,550
因此，所有这一切做的是你
运行程序.hello--

1563
01:11:37,550 --> 01:11:40,010
您正在运行一个名为你好程序。

1564
01:11:40,010 --> 01:11:42,960
你打算给它
称为输入input.txt的。

1565
01:11:42,960 --> 01:11:43,460
对？

1566
01:11:43,460 --> 01:11:46,250
因为把它看作只是
物理进入打招呼。

1567
01:11:46,250 --> 01:11:50,632
然后，你要保存
在文件输出名为output.txt的。

1568
01:11:50,632 --> 01:11:51,715
如何下联？

1569
01:11:51,715 --> 01:11:54,164
想告诉我什么
第二行呢？

1570
01:11:54,164 --> 01:11:55,080
听众：[听不清]。

1571
01:11:55,080 --> 01:12:00,522

1572
01:12:00,522 --> 01:12:01,230
ANDI彭：对不起。

1573
01:12:01,230 --> 01:12:03,560
再说一次。

1574
01:12:03,560 --> 01:12:04,060
艾略特。

1575
01:12:04,060 --> 01:12:06,560
>> 听众：所以它把​​一个
数字到查找列表。

1576
01:12:06,560 --> 01:12:07,540
>> ANDI彭：是的。

1577
01:12:07,540 --> 01:12:10,790
所以找到，请记住，在
为了运行找到你

1578
01:12:10,790 --> 01:12:13,209
需要知道你正在寻找。

1579
01:12:13,209 --> 01:12:15,500
所以所有的它做
这里要说的是它给你

1580
01:12:15,500 --> 01:12:18,720
预先分配的一组的
数字，然后找到是怎么回事

1581
01:12:18,720 --> 01:12:21,680
以搜索那些为42的数目。

1582
01:12:21,680 --> 01:12:23,620
然后15。

1583
01:12:23,620 --> 01:12:25,870
请记住，你们跑这
当你测试你的代码。

1584
01:12:25,870 --> 01:12:27,590
现在你明白这是什么做？

1585
01:12:27,590 --> 01:12:31,069

1586
01:12:31,069 --> 01:12:33,520
>> 听众：它的投入
该组指令

1587
01:12:33,520 --> 01:12:38,860
通过三通过向[听不清]
三，获得the--赢得比赛。

1588
01:12:38,860 --> 01:12:39,560
>> ANDI彭：是的。

1589
01:12:39,560 --> 01:12:41,480
>> 听众：通过输入那些
指令到程序中。

1590
01:12:41,480 --> 01:12:42,438
>> ANDI彭：差不多。

1591
01:12:42,438 --> 01:12:47,840
所以波浪CS50 / pset3 / 3x3的，所有的
在做的是，我们创建了一个文本

1592
01:12:47,840 --> 01:12:50,700
文件把所有的
游戏准备好你们。

1593
01:12:50,700 --> 01:12:56,020
所以，你的游戏玩，你just--
我们只是把那到你的程序。

1594
01:12:56,020 --> 01:12:58,230
因此，我们已经创造了这个
板，然后我们

1595
01:12:58,230 --> 01:13:02,890
把该板到你的程序
跑，并创造了三个瓷砖

1596
01:13:02,890 --> 01:13:03,390
三。

1597
01:13:03,390 --> 01:13:04,730
这就是它在做什么。

1598
01:13:04,730 --> 01:13:07,331
>> 所以实际上也存在神奇
怎么回事幕后

1599
01:13:07,331 --> 01:13:09,330
那你们没
程序，我们编程。

1600
01:13:09,330 --> 01:13:13,120
但是，现在你们明白为什么
我们这样做，所以这一切都很好。

1601
01:13:13,120 --> 01:13:15,750
好吧。

1602
01:13:15,750 --> 01:13:22,200
>> 因此，尽管重定向是一个非常
有用的，C具有普遍的机制

1603
01:13:22,200 --> 01:13:25,030
用于读取和写入
它自己的文件。

1604
01:13:25,030 --> 01:13:26,780
没有什么概念
困难在这里，所以我

1605
01:13:26,780 --> 01:13:28,330
刚准备要经过
真的，真的很快。

1606
01:13:28,330 --> 01:13:30,621
所有这一些记忆
并确保你们

1607
01:13:30,621 --> 01:13:32,680
语法是正确使用它。

1608
01:13:32,680 --> 01:13:35,640
我们会做到这一点的方法是
创建的参考文件，

1609
01:13:35,640 --> 01:13:38,473
我们会打开这个​​文件，然后我们
会做所有的阅读和写作

1610
01:13:38,473 --> 01:13:39,929
然后关闭该文件。

1611
01:13:39,929 --> 01:13:41,720
当你们的事
要记住的是

1612
01:13:41,720 --> 01:13:47,360
虽然这样做，是因为
我们正在关闭和打开文件，

1613
01:13:47,360 --> 01:13:51,230
所有这些命令包括
在standard--标准I / O

1614
01:13:51,230 --> 01:13:51,730
图书馆。

1615
01:13:51,730 --> 01:13:54,410
所以一定要确保每当你
这样做，你已经included--

1616
01:13:54,410 --> 01:13:59,020
＃included--标准I / O点小时。

1617
01:13:59,020 --> 01:14:01,691
>> 所以，真正的快。

1618
01:14:01,691 --> 01:14:03,940
第一步，你要创建
的引用，该文件。

1619
01:14:03,940 --> 01:14:07,670
而现在，我们所做的指针，你
你们能告诉我这是什么行代码

1620
01:14:07,670 --> 01:14:08,630
是在做。

1621
01:14:08,630 --> 01:14:10,250
对？

1622
01:14:10,250 --> 01:14:15,397
所有这一切它做的是创造一个
指针命名的文件类型的文件。

1623
01:14:15,397 --> 01:14:17,980
因为你知道这是怎么回事
指向一个文件，你

1624
01:14:17,980 --> 01:14:20,460
要打开该文件。

1625
01:14:20,460 --> 01:14:23,320
那么你˚Fopen--所有
它的作用是打开文件。

1626
01:14:23,320 --> 01:14:24,560
>> 这是文件名。

1627
01:14:24,560 --> 01:14:26,060
而且有三件事情可以做。

1628
01:14:26,060 --> 01:14:28,195
你可以读，写或追加。

1629
01:14:28,195 --> 01:14:30,320
最普遍，你们
将读取或写入

1630
01:14:30,320 --> 01:14:33,195
因为你要么将是
输入文件或输出之一。

1631
01:14:33,195 --> 01:14:36,500
所以几乎r和w分别在两个
你会使用最多的事。

1632
01:14:36,500 --> 01:14:41,722
>> 因此，在这种情况下，所有我所做的就是
创建一个指向一个名为文件。

1633
01:14:41,722 --> 01:14:47,900
我打开它，我reading--我
打开此文件名为file.txt的

1634
01:14:47,900 --> 01:14:49,020
而我读它。

1635
01:14:49,020 --> 01:14:51,730
这就是我正在做的这一点。

1636
01:14:51,730 --> 01:14:55,270
然后，这些都只是在功能
你可以看不同的东西

1637
01:14:55,270 --> 01:14:57,750
或写不同的东西
或者跳到不同的地方

1638
01:14:57,750 --> 01:14:59,420
在那里，你想看看。

1639
01:14:59,420 --> 01:15:01,200
所有这些都是在网上。

1640
01:15:01,200 --> 01:15:02,960
所有这些，你可以只是谷歌。

1641
01:15:02,960 --> 01:15:04,280
无需记住它们。

1642
01:15:04,280 --> 01:15:07,160
他们只是在那里，
一次性供您使用

1643
01:15:07,160 --> 01:15:09,360
如果您想为
能够使用它们。

1644
01:15:09,360 --> 01:15:13,210
>> 所以，如果我想刚才读
在一个字符的时间，

1645
01:15:13,210 --> 01:15:15,360
我会做文件龟etc。

1646
01:15:15,360 --> 01:15:18,850
或者，如果我想读取一行
文本的时间，我会做与fgets。

1647
01:15:18,850 --> 01:15:19,840
等等，等等。

1648
01:15:19,840 --> 01:15:23,640
所有这些只是做不同
你们的事情可以使用。

1649
01:15:23,640 --> 01:15:25,920
>> 然后最后，经过我
做读取或写入，

1650
01:15:25,920 --> 01:15:27,770
我只是要FCLOSE该文件。

1651
01:15:27,770 --> 01:15:31,760
请记住，这是其一
那些，记住，请

1652
01:15:31,760 --> 01:15:34,220
这样做，否则您的文件
是行不通的。

1653
01:15:34,220 --> 01:15:36,130
之前，请务必打开一个文件
阅读或阅读，

1654
01:15:36,130 --> 01:15:38,310
你必须始终
关闭它，如果你打开​​它。

1655
01:15:38,310 --> 01:15:40,210
同样的事情与记忆，对不对？

1656
01:15:40,210 --> 01:15:42,390
你必须始终以
内存和释放它。

1657
01:15:42,390 --> 01:15:45,200
在这里，你必须始终打开
试图读取它之前的文件

1658
01:15:45,200 --> 01:15:47,360
而你总是要
关闭你打开它之后。

1659
01:15:47,360 --> 01:15:50,650

1660
01:15:50,650 --> 01:15:52,190
>> 所以，这也是在网上。

1661
01:15:52,190 --> 01:15:55,590
我要你挑战家伙
那种写一个程序，打印

1662
01:15:55,590 --> 01:15:57,080
hello.world到一个文件。

1663
01:15:57,080 --> 01:15:58,280
这真的很简单。

1664
01:15:58,280 --> 01:16:00,854
它本质上只是涉及
的代码的几行

1665
01:16:00,854 --> 01:16:02,270
这只是以前写的。

1666
01:16:02,270 --> 01:16:04,311
你打算把他们
一起写的。

1667
01:16:04,311 --> 01:16:06,630

1668
01:16:06,630 --> 01:16:10,950
>> 因此，一些重要的事情要记住
而你们正试图利用这一点。

1669
01:16:10,950 --> 01:16:14,410
如果这一切都是非常有用的
本周你的PSET，

1670
01:16:14,410 --> 01:16:18,000
是FOPEN创建一个文件指针。

1671
01:16:18,000 --> 01:16:19,500
这不是真正的物理文件。

1672
01:16:19,500 --> 01:16:22,260
所有它指向该
文件要打开。

1673
01:16:22,260 --> 01:16:26,070
而你从本质上讲，只要
您正在使用的任何其他职能

1674
01:16:26,070 --> 01:16:30,130
像FREAD和FWRITE
或龟etc或与fgets，是

1675
01:16:30,130 --> 01:16:33,380
那你只是路过解决此
指针的所有这些功能。

1676
01:16:33,380 --> 01:16:36,510
所以你没有真正采取这一
文件并使用它为你的功能，

1677
01:16:36,510 --> 01:16:39,540
你只是把指针
并把它这些功能

1678
01:16:39,540 --> 01:16:41,620
这样就可以使用。

1679
01:16:41,620 --> 01:16:45,360
>> 如果你忘记关闭
您在使用它后的文件，

1680
01:16:45,360 --> 01:16:47,710
你的程序会出现内存泄漏。

1681
01:16:47,710 --> 01:16:50,700
从本质上讲，所有的手段
是不好的事情会发生

1682
01:16:50,700 --> 01:16:52,960
和你的程序将
无法正常工作。

1683
01:16:52,960 --> 01:16:54,880
等等PSET中
一开始，我觉得

1684
01:16:54,880 --> 01:16:59,180
有一个短的，在那里他explained--
内特explained--什么Valgrind的了。

1685
01:16:59,180 --> 01:17:02,350
所有Valgrind是一个方法可以让你
确保你不会泄漏内存。

1686
01:17:02,350 --> 01:17:04,433
所以，你们要进行
确保你看，短期

1687
01:17:04,433 --> 01:17:08,771
因为这说明它
真的很好会发生什么。

1688
01:17:08,771 --> 01:17:09,270
好。

1689
01:17:09,270 --> 01:17:11,260
于是我通过去真的，
真的很快，因为我真的

1690
01:17:11,260 --> 01:17:13,870
想要去谈论
处理器集之前，你们离开。

1691
01:17:13,870 --> 01:17:16,690
有没有人有问题的概念？

1692
01:17:16,690 --> 01:17:20,060
大多都是这只是语法
你可以用它来读取或写入文件。

1693
01:17:20,060 --> 01:17:25,090

1694
01:17:25,090 --> 01:17:28,140
>> 最后，大家的喜爱。

1695
01:17:28,140 --> 01:17:31,760
我们要谈的pset的现在。

1696
01:17:31,760 --> 01:17:35,990
因此，举手表决，多少
你们看过规范这个星期？

1697
01:17:35,990 --> 01:17:36,660
噢，那是一半。

1698
01:17:36,660 --> 01:17:38,000
那很好。

1699
01:17:38,000 --> 01:17:41,430
因此，这实际上是一个真正的，
真正有趣的PSET的意义

1700
01:17:41,430 --> 01:17:43,889
你觉得自己像一个
侦探，因为你

1701
01:17:43,889 --> 01:17:46,930
做所有这些非常酷的事情
你不知道，你可以做

1702
01:17:46,930 --> 01:17:49,050
但现在它真的很酷
你可以做他们。

1703
01:17:49,050 --> 01:17:52,400
它实际上是一个很大
简单的比你们想象。

1704
01:17:52,400 --> 01:17:56,640
>> 所以基本半部
这个程序是你

1705
01:17:56,640 --> 01:18:00,330
要下载源代码或
发行代码写的我们。

1706
01:18:00,330 --> 01:18:03,540
而你将有一个文件夹
所谓的BMP和其他文件夹

1707
01:18:03,540 --> 01:18:05,550
所谓的JPG。

1708
01:18:05,550 --> 01:18:08,370
在您的BMP，你
将有三个方案。

1709
01:18:08,370 --> 01:18:10,400
其中之一是已经为你写的。

1710
01:18:10,400 --> 01:18:12,477
所以CSV模式中有效是一个程序
我们已经写

1711
01:18:12,477 --> 01:18:14,060
对于你，你要去下载。

1712
01:18:14,060 --> 01:18:19,440
所有这些都需要输入一张图片
并使得它的一个副本输出。

1713
01:18:19,440 --> 01:18:22,150
这是所有的文件在做什么。

1714
01:18:22,150 --> 01:18:25,260
>> 但是，你想要做什么
whodunit--所以你们有多少人

1715
01:18:25,260 --> 01:18:30,450
你们还记得在小学五年级或maybe--
你younger--也许三年级，

1716
01:18:30,450 --> 01:18:33,945
当你们有秘密消息，
你不得不把一张纸了它

1717
01:18:33,945 --> 01:18:35,440
解码消息？

1718
01:18:35,440 --> 01:18:36,000
是吗？

1719
01:18:36,000 --> 01:18:39,580
所以，这就是我们正在做的
但这次的计算机。

1720
01:18:39,580 --> 01:18:41,832
因此，我们已经给你这个可爱的形象。

1721
01:18:41,832 --> 01:18:43,540
看起来不像
什么，但下方

1722
01:18:43,540 --> 01:18:49,660
这是一个线索，会帮助你
与回答这个问题，我们问你。

1723
01:18:49,660 --> 01:18:54,170
>> 从本质上讲，你想要什么
要做的就是输入该文件，

1724
01:18:54,170 --> 01:18:56,610
围绕调整一些东西，
也许调整颜色，

1725
01:18:56,610 --> 01:19:00,730
转移的事情，所以，无论
该消息是能安然度过。

1726
01:19:00,730 --> 01:19:03,740
所以里面有隐藏
像素和信息

1727
01:19:03,740 --> 01:19:07,140
如果你正确地编写代码
是要解码，并告诉你

1728
01:19:07,140 --> 01:19:08,500
这是什么线索。

1729
01:19:08,500 --> 01:19:12,480
所以一些有用的提示如何
你会去接近这一点。

1730
01:19:12,480 --> 01:19:15,180
>> 你真的想了解
自己与文件I / O

1731
01:19:15,180 --> 01:19:18,760
因为我们从阅读
文件和写入文件。

1732
01:19:18,760 --> 01:19:19,260
对？

1733
01:19:19,260 --> 01:19:21,430
所以，每当我们做
即，涉及

1734
01:19:21,430 --> 01:19:25,170
文件I / O。你会
有熟悉

1735
01:19:25,170 --> 01:19:27,450
有，你是怎么打开的图片文件？

1736
01:19:27,450 --> 01:19:29,960
你怎么写入文件的图片？

1737
01:19:29,960 --> 01:19:31,640
你怎么做所有这些事情？

1738
01:19:31,640 --> 01:19:33,660
这将是非常有用的。

1739
01:19:33,660 --> 01:19:36,190
>> 其次，你怎么样
要能够改变

1740
01:19:36,190 --> 01:19:38,140
该清理这幅画的颜色？

1741
01:19:38,140 --> 01:19:43,660
它可能会涉及到
调整你的像素或RGB值

1742
01:19:43,660 --> 01:19:45,390
地方在那里，本质上。

1743
01:19:45,390 --> 01:19:47,800
有没有正确的方式
只要解决这个你

1744
01:19:47,800 --> 01:19:52,560
can--只要你可以种
调整的那些像素，使其

1745
01:19:52,560 --> 01:19:54,640
看起来像你关心的东西。

1746
01:19:54,640 --> 01:19:56,207
这就是我们所关心的为好。

1747
01:19:56,207 --> 01:19:57,540
因此，有很多方法可以做到这一点。

1748
01:19:57,540 --> 01:20:00,039
刚玩它，直到
你会得到一些作品。

1749
01:20:00,039 --> 01:20:02,900
而且你会很
代码惊奇地发现几行

1750
01:20:02,900 --> 01:20:04,510
你需要真正做到这一点。

1751
01:20:04,510 --> 01:20:08,700
我说的是像三
代码总行数

1752
01:20:08,700 --> 01:20:11,310
你需要写
为了做到这一点。

1753
01:20:11,310 --> 01:20:15,470
所以，如果你发现自己
写40，30行代码，

1754
01:20:15,470 --> 01:20:16,960
你可能就错了。

1755
01:20:16,960 --> 01:20:19,390
所有你需要做的是一种
玩的颜色

1756
01:20:19,390 --> 01:20:22,960
看看该怎么做了。

1757
01:20:22,960 --> 01:20:27,040
>> 于是我们进入了一点
到的一个问题更难。

1758
01:20:27,040 --> 01:20:30,190
在这里，我们有调整
我们问你在哪里

1759
01:20:30,190 --> 01:20:34,210
用于：我们给你输入
一张图片，你的大小调整

1760
01:20:34,210 --> 01:20:36,710
这个图片弄成
或大或小一点

1761
01:20:36,710 --> 01:20:38,500
这取决于我们给你的尺寸。

1762
01:20:38,500 --> 01:20:41,260
所以请记住讲座
大卫很快

1763
01:20:41,260 --> 01:20:45,780
瞥了一眼信息如何
通过您的计算机上检测到

1764
01:20:45,780 --> 01:20:47,590
意味着它是一个类型的文件。

1765
01:20:47,590 --> 01:20:50,530
所以一个Word文件中有特殊的
前面那个字符

1766
01:20:50,530 --> 01:20:52,040
告诉你的电脑是一个Word文件。

1767
01:20:52,040 --> 01:20:53,090
同样的事情与JPEG格式。

1768
01:20:53,090 --> 01:20:55,131
在这种情况下，我们将
给你一个JPEG文件。

1769
01:20:55,131 --> 01:20:58,300
我们所知道的是，JPEG
文件是一个图片，对吧？

1770
01:20:58,300 --> 01:21:01,430
但电脑与众不同之
它非常具体的方式。

1771
01:21:01,430 --> 01:21:04,070
因此，在开始时
任何JPEG文件，你

1772
01:21:04,070 --> 01:21:08,210
将有什么所谓的位图
信息报头和位图文件头。

1773
01:21:08,210 --> 01:21:11,080
所有这些都为
不同的数据

1774
01:21:11,080 --> 01:21:14,870
告诉您的计算机，嘿嘿，
听好了，一个JPEG文件上来

1775
01:21:14,870 --> 01:21:17,820
而这些都是尺寸或
该JPEG的特点。

1776
01:21:17,820 --> 01:21:21,280
>> 所以你们真的想知道
哪些信息内部存储

1777
01:21:21,280 --> 01:21:23,560
这些标题和
什么是它们的大小。

1778
01:21:23,560 --> 01:21:25,640
当你运行，因为
通过你们的节目，

1779
01:21:25,640 --> 01:21:27,370
你会想
跳过这一数额。

1780
01:21:27,370 --> 01:21:27,940
对？

1781
01:21:27,940 --> 01:21:29,910
因为你不关心
有关修改标题，

1782
01:21:29,910 --> 01:21:31,493
你关心的修改有什么后。

1783
01:21:31,493 --> 01:21:32,450
对？

1784
01:21:32,450 --> 01:21:36,040
所以一定要确保你们知道
这些东西有多大。

1785
01:21:36,040 --> 01:21:39,065
>> 其次，在开始之前
试图调整你的形象，

1786
01:21:39,065 --> 01:21:41,940
你可能会想
保存原始的尺寸。

1787
01:21:41,940 --> 01:21:42,520
对？

1788
01:21:42,520 --> 01:21:45,550
因为如果我告诉你，这幅画
是100像素乘以100像素，

1789
01:21:45,550 --> 01:21:47,630
我想你做
这四次较大，

1790
01:21:47,630 --> 01:21:50,460
你知道你必须
乘以4的尺寸。

1791
01:21:50,460 --> 01:21:54,960
所以，你想要一个输出文件
400×400像素，例如。

1792
01:21:54,960 --> 01:21:58,300
因此，它是非常有用的，你们要
保存原始的尺寸。

1793
01:21:58,300 --> 01:22:00,780
再后来，经过
你完成了调整，

1794
01:22:00,780 --> 01:22:06,270
你可以写新的报头与
调整后的新维度。

1795
01:22:06,270 --> 01:22:10,750
>> 而方式，你身体
可以创建在大像素

1796
01:22:10,750 --> 01:22:13,380
是，你可以写
新RGB--记得，RGB，

1797
01:22:13,380 --> 01:22:17,784
所有代表的是红，绿，
和blue--像素的输出文件。

1798
01:22:17,784 --> 01:22:20,200
而你会想
有不同量的什么

1799
01:22:20,200 --> 01:22:21,200
我们称之为填充。

1800
01:22:21,200 --> 01:22:24,780
所有的填充是有空间
之前和图片后，

1801
01:22:24,780 --> 01:22:29,265
告诉your--基本上是
告诉你的图片有多大它

1802
01:22:29,265 --> 01:22:30,589
应占用。

1803
01:22:30,589 --> 01:22:33,630
这是很抽象了很多
你，如果你还没有读过pset的规范，

1804
01:22:33,630 --> 01:22:35,410
但它的将是
因为当非常有用

1805
01:22:35,410 --> 01:22:36,460
你实际上读通过它。

1806
01:22:36,460 --> 01:22:38,126
你喜欢的哦，是啊，这是有道理的。

1807
01:22:38,126 --> 01:22:39,310
为什么我要这么做？

1808
01:22:39,310 --> 01:22:41,830
说得通。

1809
01:22:41,830 --> 01:22:46,900
>> 最后，这可能是一个
最令人沮丧的程序

1810
01:22:46,900 --> 01:22:51,160
曾经只是因为你不能
告诉我们，如果它的工作与否。

1811
01:22:51,160 --> 01:22:54,980
所有这些计划，恢复，是
做的是，如果正常运行，

1812
01:22:54,980 --> 01:22:59,290
它应该能突然
回收50％的图像，

1813
01:22:59,290 --> 01:23:01,025
失去了我们的硬盘驱动器上。

1814
01:23:01,025 --> 01:23:03,900
所以，这个程序问题
是，你不能真正测试

1815
01:23:03,900 --> 01:23:06,220
因为无论你恢复
他们或者你没有。

1816
01:23:06,220 --> 01:23:09,122
所以那种你只要
必须发挥与它周围，

1817
01:23:09,122 --> 01:23:11,080
如果你的程序是
正常工作，你会

1818
01:23:11,080 --> 01:23:12,829
突然看到，在
您的目录你已经

1819
01:23:12,829 --> 01:23:17,400
得到了一个巨大的量
照片是现在。

1820
01:23:17,400 --> 01:23:20,490
>> 所以，我怎么会接近
这个问题，我们

1821
01:23:20,490 --> 01:23:22,860
要给你什么
被称为card.raw文件。

1822
01:23:22,860 --> 01:23:25,020
从本质上讲，这是
只是损坏的文件

1823
01:23:25,020 --> 01:23:28,870
与所有的图片存储在该
你将需要从恢复。

1824
01:23:28,870 --> 01:23:32,330
所以，你可能会想
输入您的card.raw，或打开，

1825
01:23:32,330 --> 01:23:35,510
您card.raw文件和你
将要处理

1826
01:23:35,510 --> 01:23:37,840
它能够存储JPEG文件。

1827
01:23:37,840 --> 01:23:42,830
>> 因此，我将通过跟踪和存储启动
每个单独的JPEG，你找到它。

1828
01:23:42,830 --> 01:23:47,180
你不会单独所有
突然只创建50个JPEG文件。

1829
01:23:47,180 --> 01:23:50,190
你会想保留
跟踪你打开多少。

1830
01:23:50,190 --> 01:23:52,015
然后你要
要确保，当你

1831
01:23:52,015 --> 01:23:54,640
写入buffer--你们
会知道我在说什么

1832
01:23:54,640 --> 01:23:57,806
一旦你读了spec--要
请确保您使用的是无符号

1833
01:23:57,806 --> 01:23:59,370
字符缓冲区。

1834
01:23:59,370 --> 01:24:01,790
>> 然后你要问
你自己的问题，

1835
01:24:01,790 --> 01:24:05,797
多少字节是在一个
CF--是在一个卡文件？

1836
01:24:05,797 --> 01:24:08,380
这就是你要多少
想读入您的缓冲区。

1837
01:24:08,380 --> 01:24:11,130
你会希望确保
两个对齐因为你

1838
01:24:11,130 --> 01:24:12,850
不会有随机存储器泄漏。

1839
01:24:12,850 --> 01:24:15,370
你知道到底有多少
字节，你需要多少

1840
01:24:15,370 --> 01:24:18,270
字节，你希望他们有。

1841
01:24:18,270 --> 01:24:21,510
>> 然后最后，你要
使用一种称为函数sprint--

1842
01:24:21,510 --> 01:24:26,160
■打印F--生成自定义文件
名称为每一个新的JPEG，你觉得。

1843
01:24:26,160 --> 01:24:29,129
在创建因此和
发现JPEG文件在你的卡，

1844
01:24:29,129 --> 01:24:31,170
你会想
存储它们并将它们命名。

1845
01:24:31,170 --> 01:24:31,700
对？

1846
01:24:31,700 --> 01:24:33,700
所以，你要
要使用该功能

1847
01:24:33,700 --> 01:24:36,770
创建的名称
可以存储所有的JPEG文件。

1848
01:24:36,770 --> 01:24:41,062
>> 最后，不要忘记关闭
每个JPEG图像后，你就大功告成了。

1849
01:24:41,062 --> 01:24:42,770
因为你在做什么
要做的就是你

1850
01:24:42,770 --> 01:24:44,728
将可能有
某种循环的那

1851
01:24:44,728 --> 01:24:46,470
通过您的所有JPEG文件的迭代。

1852
01:24:46,470 --> 01:24:50,460
你会写一个JPEG
并改名为你找到它。

1853
01:24:50,460 --> 01:24:52,870
但是，就大功告成后，
与每一个JPEG，

1854
01:24:52,870 --> 01:24:56,630
你需要关闭它，你就可以开始
过去，在移动到下一个图像。

1855
01:24:56,630 --> 01:24:58,880
所以东西是
真的很有趣，我们喜欢做的事，

1856
01:24:58,880 --> 01:25:03,430
因为这是这样一个奇怪的问题集
也是一个古怪令人满意问题

1857
01:25:03,430 --> 01:25:08,380
集，就是所有的图片我们
对你，如果你正确恢复，

1858
01:25:08,380 --> 01:25:11,910
所有的图片是图片
你的精彩教学人员，无论是

1859
01:25:11,910 --> 01:25:14,240
哈佛，在这里 - 这里在耶鲁大学。

1860
01:25:14,240 --> 01:25:17,260
如果你碰巧
收回所有这些图片

1861
01:25:17,260 --> 01:25:20,020
并确定人员
在这些会员卡，

1862
01:25:20,020 --> 01:25:23,040
并采取selfies与我们联系，如果
你会发现我们身边的校园，

1863
01:25:23,040 --> 01:25:28,270
对于每一张照片你提交给我们，我们将
给你的Dropbox空间的千兆字节。

1864
01:25:28,270 --> 01:25:30,060
>> 因此，让我们做数学题在这里。

1865
01:25:30,060 --> 01:25:33,010
如果有50张图片和
50教学工作人员，

1866
01:25:33,010 --> 01:25:37,160
如果你碰巧发现所有50
我们，这是50千兆字节的Dropbox的，

1867
01:25:37,160 --> 01:25:39,000
基本上，我们会给予你们。

1868
01:25:39,000 --> 01:25:42,380
因此，一些额外的附加激励
如果你们不只是

1869
01:25:42,380 --> 01:25:44,480
关心恢复丢失的图像。

1870
01:25:44,480 --> 01:25:46,867
还有一些额外的奖励。

1871
01:25:46,867 --> 01:25:47,825
这是一个有趣的问题集。

1872
01:25:47,825 --> 01:25:48,390
这真的是。

1873
01:25:48,390 --> 01:25:51,980
这是一种令人沮丧，但随后
当你意识到变得更有趣，

1874
01:25:51,980 --> 01:25:54,230
哇，它的工作，现在我
具有所有的这些照片

1875
01:25:54,230 --> 01:25:55,604
我刚刚被自己创建的。

1876
01:25:55,604 --> 01:25:58,800

1877
01:25:58,800 --> 01:26:00,075
>> 在PSET有任何疑问？

1878
01:26:00,075 --> 01:26:02,408
对于任何人谁的已经
开始，如果您有任何疑问，

1879
01:26:02,408 --> 01:26:06,510
我会在这里过了几分钟
一节，如果你想和我说话。

1880
01:26:06,510 --> 01:26:07,320
干得好，伙计们。

1881
01:26:07,320 --> 01:26:10,520
我很抱歉，我的信息
倾倒在你们。

1882
01:26:10,520 --> 01:26:13,670
指针是真的，真的
具有挑战性和令人沮丧的。

1883
01:26:13,670 --> 01:26:16,187
>> 而且我真的很高兴，
你们一直伴随着我。

1884
01:26:16,187 --> 01:26:18,020
我们将讨论更深入
关于下周

1885
01:26:18,020 --> 01:26:21,330
当我们开始做哈希表和
更多的功能，让他们参与。

1886
01:26:21,330 --> 01:26:23,821

1887
01:26:23,821 --> 01:26:24,320
是啊。

1888
01:26:24,320 --> 01:26:26,278
因此，如果任何人有任何
的问题，我就在附近。

1889
01:26:26,278 --> 01:26:29,330
感谢您的到来，并采取更多
糖果，因为有更多的糖果。

1890
01:26:29,330 --> 01:26:32,220

1891
01:26:32,220 --> 01:26:33,770
酷。

1892
01:26:33,770 --> 01:26:35,765