1
00:00:00,000 --> 00:00:11,320

2
00:00:11,320 --> 00:00:13,260
>> DAVID马兰：你好，
欢迎回到CS50。

3
00:00:13,260 --> 00:00:14,860
因此，这是本周四结束。

4
00:00:14,860 --> 00:00:16,680
刚一公布第一。

5
00:00:16,680 --> 00:00:19,600
因此，所谓的第五个星期一是
上来今年下星期一。

6
00:00:19,600 --> 00:00:22,800
这是改变的机会
SAT / UNSAT一个字母等级，还是从

7
00:00:22,800 --> 00:00:24,130
字母等级SAT / UNSAT。

8
00:00:24,130 --> 00:00:27,130
烦人，这个过程确实需要一个
签名，因为你必须填写

9
00:00:27,130 --> 00:00:28,770
出那些粉红色的分/插形式之一。

10
00:00:28,770 --> 00:00:31,680
>> 因为从技术上说，SAT / UNSAT
版本和信级版本

11
00:00:31,680 --> 00:00:33,320
有不同的目录编号。

12
00:00:33,320 --> 00:00:34,240
但没什么大不了的。

13
00:00:34,240 --> 00:00:36,620
只是过来跟我抢
或在任何点的劳伦。

14
00:00:36,620 --> 00:00:39,550
或给我们发电子邮件，如果你没有那种
你需要的文书工作的今天，我们

15
00:00:39,550 --> 00:00:43,410
一定会帮助您
周一前的护理。

16
00:00:43,410 --> 00:00:45,780
>> 所有权利，所以今天 - 

17
00:00:45,780 --> 00:00:47,630
其实，有一点回音。

18
00:00:47,630 --> 00:00:51,070
我们能否音我倒有几分？

19
00:00:51,070 --> 00:00:51,730
确定。

20
00:00:51,730 --> 00:00:54,850
因此，我们今天介绍一个主题
被称为指针。

21
00:00:54,850 --> 00:00:57,770
我承认，这是一个
更复杂的主题，我们倾向于

22
00:00:57,770 --> 00:01:00,960
在这个类中覆盖，或任何真正的
入门课程使用C.

23
00:01:00,960 --> 00:01:05,510
>> 但我的话，特别是
如果你的头脑感觉有点弯曲

24
00:01:05,510 --> 00:01:07,100
今天，在今后几个星期。

25
00:01:07,100 --> 00:01:10,340
这不是你得到的代表
任何在这个糟糕的，那只是意味着

26
00:01:10,340 --> 00:01:13,360
这是一个特别复杂的话题
我答应，几个星期

27
00:01:13,360 --> 00:01:17,610
因此，会显得太惊人
回想起来简单。

28
00:01:17,610 --> 00:01:18,720
>> 我还记得这一天。

29
00:01:18,720 --> 00:01:22,190
我坐在食堂埃利奥特，
坐在旁边我的TF尼沙特梅塔，

30
00:01:22,190 --> 00:01:24,070
谁是居民埃利奥特房子。

31
00:01:24,070 --> 00:01:26,340
出于某种原因，这
只要点击主题。

32
00:01:26,340 --> 00:01:29,430
这是说，我也挣扎
与一定量的时间，但我

33
00:01:29,430 --> 00:01:33,610
会尽我所能来帮助避免任何此类
一个话题，最终的斗争

34
00:01:33,610 --> 00:01:34,580
是相当强大的。

35
00:01:34,580 --> 00:01:37,350
>> 事实上，我们将讨论的话题之一
在未来几周内，

36
00:01:37,350 --> 00:01:41,130
的安全性，以及如何才能真正
利用机器的方式

37
00:01:41,130 --> 00:01:42,320
并不打算。

38
00:01:42,320 --> 00:01:45,850
而那些剥削通常
错误，错误的结果，我们

39
00:01:45,850 --> 00:01:49,740
人们不理解一些使
底层的实现

40
00:01:49,740 --> 00:01:52,250
通过哪些程序。

41
00:01:52,250 --> 00:01:55,410
>> 现在这个问题似乎更多的用户
友好的，我想我会打10

42
00:01:55,410 --> 00:01:59,680
一个小的黏土动画的第二个预览
数字命名宾基被带到

43
00:01:59,680 --> 00:02:03,020
在斯坦福大学生活，我们的一个朋友，
教授尼克Parlante。

44
00:02:03,020 --> 00:02:06,753
所以，请允许我把这个给你
这里传情宾基。

45
00:02:06,753 --> 00:02:09,520
>> [视频回放]

46
00:02:09,520 --> 00:02:10,380
>> 嘿，宾基。

47
00:02:10,380 --> 00:02:11,050
醒来。

48
00:02:11,050 --> 00:02:13,610
它的时间的指针乐趣。

49
00:02:13,610 --> 00:02:14,741
>>  - 那是什么？

50
00:02:14,741 --> 00:02:16,440
了解指针？

51
00:02:16,440 --> 00:02:17,928
哦，满载而归。

52
00:02:17,928 --> 00:02:18,920
>> [END视频播放]

53
00:02:18,920 --> 00:02:20,670
>> 国宝马兰：这是斯坦福
计算机科学。

54
00:02:20,670 --> 00:02:23,194
所以来。

55
00:02:23,194 --> 00:02:24,930
>> [掌声]

56
00:02:24,930 --> 00:02:26,660
>> 国宝MALAN：对不起，尼克。

57
00:02:26,660 --> 00:02:30,680
>> 因此，记得我们最后一次止
这真是令人兴奋的吊人胃口

58
00:02:30,680 --> 00:02:32,960
据此，此功能
只是没有工作。

59
00:02:32,960 --> 00:02:34,960
至少凭直觉，感觉
像它应该工作。

60
00:02:34,960 --> 00:02:37,600
简单地交换值
为两个整数。

61
00:02:37,600 --> 00:02:40,915
但记得，当我们打印出
在主，一个原始值

62
00:02:40,915 --> 00:02:44,210
二，他们仍然是一个和
两个，而不是2个和1个。

63
00:02:44,210 --> 00:02:46,070
>> 因此，让我真正切换
超过家电。

64
00:02:46,070 --> 00:02:50,180
我写了一个骨架代码位
推进在这里，我要求使得x

65
00:02:50,180 --> 00:02:52,500
1，y将是2。

66
00:02:52,500 --> 00:02:54,810
然后，我打印出他们的两个
值打印为f。

67
00:02:54,810 --> 00:02:57,540
>> 然后，我要求在这里，
我们要交换他们。

68
00:02:57,540 --> 00:03:00,800
我们这里给我留下了空白点
填写今天在短短的时刻。

69
00:03:00,800 --> 00:03:03,380
然后，我会要求
已交换两个变量。

70
00:03:03,380 --> 00:03:04,770
然后，我要打印
他们出来了。

71
00:03:04,770 --> 00:03:07,090
所以我希望，我应该看到1，2。

72
00:03:07,090 --> 00:03:07,380
2，1。

73
00:03:07,380 --> 00:03:09,830
这是超级简单
现在目标。

74
00:03:09,830 --> 00:03:12,430
>> 那么，我们如何去交换
两个变量？

75
00:03:12,430 --> 00:03:17,220
恩，如果我在这里提出，这些杯子
可能代表一台计算机的存储器中。

76
00:03:17,220 --> 00:03:19,070
这是了几口，这
是另几叮咬。

77
00:03:19,070 --> 00:03:23,260
我们有一个志愿者和
混合一些饮料，如果熟悉吗？

78
00:03:23,260 --> 00:03:23,920
上来吧。

79
00:03:23,920 --> 00:03:24,815
你叫什么名字？

80
00:03:24,815 --> 00:03:25,260
>> JESS：杰西。

81
00:03:25,260 --> 00:03:25,690
>> 国宝MALAN：杰斯？

82
00:03:25,690 --> 00:03:26,540
上来吧，杰西。

83
00:03:26,540 --> 00:03:29,180
如果你不介意的话，我们必须把
谷歌的玻璃上，所以我们可以

84
00:03:29,180 --> 00:03:30,430
不朽。

85
00:03:30,430 --> 00:03:32,800

86
00:03:32,800 --> 00:03:34,670
OK，玻璃。

87
00:03:34,670 --> 00:03:37,250
录制视频。

88
00:03:37,250 --> 00:03:43,103
OK，我们是很好的
这里去与杰斯。

89
00:03:43,103 --> 00:03:43,810
好的。

90
00:03:43,810 --> 00:03:45,120
认识你很高兴。

91
00:03:45,120 --> 00:03:47,720
>> 所以，我想什么你在这里做 - 
如果你能，相当迅速 - 

92
00:03:47,720 --> 00:03:51,040
只是我们倒一杯橙汁一半
果汁和一杯牛奶的一半，

93
00:03:51,040 --> 00:03:55,710
较有效的数字1
1杯和2个其他杯中。

94
00:03:55,710 --> 00:04:01,380

95
00:04:01,380 --> 00:04:02,630
>> 这将是很好的素材。

96
00:04:02,630 --> 00:04:04,910

97
00:04:04,910 --> 00:04:05,860
>> JESS：对不起。

98
00:04:05,860 --> 00:04:06,330
>> 国宝马兰：没有，没有。

99
00:04:06,330 --> 00:04:08,703
这是确定的。

100
00:04:08,703 --> 00:04:10,120
尼斯。

101
00:04:10,120 --> 00:04:12,950
所有的权利，所以我们有四个字节
值得橙汁。

102
00:04:12,950 --> 00:04:14,460
我们将它称为值1。

103
00:04:14,460 --> 00:04:16,579
现在另外四个字节价值的牛奶。

104
00:04:16,579 --> 00:04:18,519
将调用它的价值2。

105
00:04:18,519 --> 00:04:20,440
因此，x和y分别。

106
00:04:20,440 --> 00:04:23,450
>> 所有权利，所以现在如果手头的任务 - 
你，杰西，眼前的一切

107
00:04:23,450 --> 00:04:24,270
你的同学 - 

108
00:04:24,270 --> 00:04:28,510
是交换的值的x和y这样的
我们希望在橙汁

109
00:04:28,510 --> 00:04:32,070
其他杯和这杯牛奶，如何
你可能会 - 之前，你居然做

110
00:04:32,070 --> 00:04:34,020
 - 去这样做呢？

111
00:04:34,020 --> 00:04:35,220
>> OK，明智的决定。

112
00:04:35,220 --> 00:04:36,340
所以，你需要多一点的内存。

113
00:04:36,340 --> 00:04:38,190
因此，让我们分配一个临时的
杯，如果你愿意。

114
00:04:38,190 --> 00:04:40,540
现在进行交换x和y。

115
00:04:40,540 --> 00:04:52,950

116
00:04:52,950 --> 00:04:53,530
>> 优秀的。

117
00:04:53,530 --> 00:04:54,420
所以做得非常​​好。

118
00:04:54,420 --> 00:04:55,670
谢谢你这么多，杰西。

119
00:04:55,670 --> 00:04:59,520

120
00:04:59,520 --> 00:05:00,020
给你。

121
00:05:00,020 --> 00:05:01,950
一个小纪念品。

122
00:05:01,950 --> 00:05:04,350
>> OK，所以很明显，超简单的想法。

123
00:05:04,350 --> 00:05:07,500
完全直观，我们需要一点点
更多的存储空间 - 在这种形式中，

124
00:05:07,500 --> 00:05:09,750
一杯 - 如果我们真的要
交换这两个变量。

125
00:05:09,750 --> 00:05:11,110
因此，让我们做。

126
00:05:11,110 --> 00:05:14,330
在这里，我要求我之间上升
我会做一些交换，

127
00:05:14,330 --> 00:05:15,720
走并宣布温度。

128
00:05:15,720 --> 00:05:17,980
我会设置它等于说，X。

129
00:05:17,980 --> 00:05:21,110
>> 然后，我要改变的价值
x刚刚像杰斯这里

130
00:05:21,110 --> 00:05:23,200
牛奶和橙汁
等于y。

131
00:05:23,200 --> 00:05:27,460
我要改变将y等于
而不是x，因为现在我们将

132
00:05:27,460 --> 00:05:29,530
停留在一个圆圈，而是温度。

133
00:05:29,530 --> 00:05:33,170
我暂时 - 杰斯
暂时把橙汁

134
00:05:33,170 --> 00:05:35,460
前重挫，
一杯牛奶。

135
00:05:35,460 --> 00:05:37,250
>> 所以，让我继续前进，使这个。

136
00:05:37,250 --> 00:05:39,210
它称为noswap.c。

137
00:05:39,210 --> 00:05:41,190
现在让我们我运行没有交换。

138
00:05:41,190 --> 00:05:43,910
事实上，我看到的，如果我扩大
窗口一点点，

139
00:05:43,910 --> 00:05:45,160
x为1时，y是2。

140
00:05:45,160 --> 00:05:47,230
然后，x是2，y是1。

141
00:05:47,230 --> 00:05:51,910
>> 但记得，上周一，我们做的事情
一点点不同，让我

142
00:05:51,910 --> 00:05:56,760
而不是实现一个辅助函数，
如果你愿意，这实际上是无效的。

143
00:05:56,760 --> 00:05:58,010
我把它叫做交换。

144
00:05:58,010 --> 00:06:01,600
我给它两个参数，我叫
他们，我叫他们b。

145
00:06:01,600 --> 00:06:04,380
>> 坦白说，我可以给他们打电话x和y。

146
00:06:04,380 --> 00:06:06,040
有什么能够阻止
我这样做。

147
00:06:06,040 --> 00:06:08,140
不过，我会认为它是那么
有点暧昧。

148
00:06:08,140 --> 00:06:11,910
因为周一召回我们
权利，这些参数是

149
00:06:11,910 --> 00:06:13,650
值的副本传入

150
00:06:13,650 --> 00:06:15,640
因此，它只是弄乱你
记住，我觉得，如果你使用

151
00:06:15,640 --> 00:06:17,370
完全相同的变量。

152
00:06:17,370 --> 00:06:20,150
>> 所以，我会打电话给他们，而不是一个
B，仅仅是为了清楚。

153
00:06:20,150 --> 00:06:21,840
但是，我们可以给他们打电话最
我们想要的东西。

154
00:06:21,840 --> 00:06:26,280
我要去复制和粘贴
有有效代码

155
00:06:26,280 --> 00:06:27,170
下来到这里。

156
00:06:27,170 --> 00:06:29,110
因为我刚看到它​​的工作原理。

157
00:06:29,110 --> 00:06:30,790
所以这是相当不错的形状。

158
00:06:30,790 --> 00:06:37,390
我会改变我，我的x x到
，我的Y b和我的Y到b。

159
00:06:37,390 --> 00:06:39,130
>> 所以换句话说，相同的逻辑。

160
00:06:39,130 --> 00:06:40,850
确切的同样的事情，杰斯做。

161
00:06:40,850 --> 00:06:44,350
然后我必须做的一件事
这里，当然，现在调用当前

162
00:06:44,350 --> 00:06:45,990
函数或调用这个函数。

163
00:06:45,990 --> 00:06:50,430
因此，我会调用这个函数有两个
输入，X和Y，并点击保存。

164
00:06:50,430 --> 00:06:52,300
>> 所有权利，所以从根本上
同样的事情。

165
00:06:52,300 --> 00:06:55,570
事实上，我可能已经作出计划
不必要的复杂

166
00:06:55,570 --> 00:07:00,820
写一个函数，这只是服用
约6行代码，而我

167
00:07:00,820 --> 00:07:02,970
此前实施
这个只有三岁。

168
00:07:02,970 --> 00:07:06,230
>> 因此，让我先走，现在改造
这一点，没有掉。

169
00:07:06,230 --> 00:07:07,920
好吧，我搞砸了这里。

170
00:07:07,920 --> 00:07:11,290
这应该是一个错误，你可能
看到越来越普遍作为

171
00:07:11,290 --> 00:07:12,380
程序变得更加复杂。

172
00:07:12,380 --> 00:07:13,470
但有一个简单的办法。

173
00:07:13,470 --> 00:07:15,650
让我向后滚动在这里。

174
00:07:15,650 --> 00:07:18,190
>> 什么是我看到的第一个错误？

175
00:07:18,190 --> 00:07:19,520
隐式声明。

176
00:07:19,520 --> 00:07:21,466
通常什么指示？

177
00:07:21,466 --> 00:07:22,830
哦，我忘了原型。

178
00:07:22,830 --> 00:07:26,900
我忘了教的编译器，交换
会存在，即使他

179
00:07:26,900 --> 00:07:28,920
在开始时不存在
的方案。

180
00:07:28,920 --> 00:07:35,780
所以，我只是说无效，交换，
INT，一个int B，分号。

181
00:07:35,780 --> 00:07:37,280
>> 所以我不打算重新实现它。

182
00:07:37,280 --> 00:07:39,140
但现在它匹配这里。

183
00:07:39,140 --> 00:07:42,530
和通知，没有一个分号
这里，这是没有必要的时候

184
00:07:42,530 --> 00:07:43,200
实施。

185
00:07:43,200 --> 00:07:46,010
>> 因此，让我重拍，没有掉。

186
00:07:46,010 --> 00:07:46,910
好得多。

187
00:07:46,910 --> 00:07:48,130
运行没有交换。

188
00:07:48,130 --> 00:07:48,740
该死的。

189
00:07:48,740 --> 00:07:51,650
现在我们回到我们上周一，
那里的东西也不会掉。

190
00:07:51,650 --> 00:07:55,410
>> 有什么直观的解释
为什么是这种情况呢？

191
00:07:55,410 --> 00:07:56,380
是吗？

192
00:07:56,380 --> 00:07:57,630
>> 学生：[听不清]。

193
00:07:57,630 --> 00:08:04,140

194
00:08:04,140 --> 00:08:05,230
>> DAVID马兰：没错。

195
00:08:05,230 --> 00:08:07,330
因此，a和b是x和y的副本。

196
00:08:07,330 --> 00:08:10,680
而事实上，任何时候，你已经
迄今为止，调用一个函数

197
00:08:10,680 --> 00:08:12,540
通过像整数变量 - 

198
00:08:12,540 --> 00:08:14,470
只是作为交换期待 - 

199
00:08:14,470 --> 00:08:16,270
你们已经通过副本。

200
00:08:16,270 --> 00:08:19,150
>> 现在，这意味着它需要一点点
的时间内，第二次分裂，

201
00:08:19,150 --> 00:08:23,270
计算机从一个复制位
变到另一个位。

202
00:08:23,270 --> 00:08:24,610
但是，这不是什么大不了的。

203
00:08:24,610 --> 00:08:25,920
但是，他们却一个副本。

204
00:08:25,920 --> 00:08:30,020
>> 所以现在，在交换的背景下，
事实上，我在成功

205
00:08:30,020 --> 00:08:31,180
改变a和b。

206
00:08:31,180 --> 00:08:33,000
事实上，让我们做一个快速
完整性检查。

207
00:08:33,000 --> 00:08:36,830
打印F A％，新生产线。

208
00:08:36,830 --> 00:08:38,770
让我们插上了。

209
00:08:38,770 --> 00:08:41,830
现在让我们做同样的事情，用b。

210
00:08:41,830 --> 00:08:43,640
让我们在这里做同样的事情。

211
00:08:43,640 --> 00:08:47,260
>> 现在，让我复制这些相同的行
再次在底部的功能

212
00:08:47,260 --> 00:08:51,250
后，我的三个有趣的线
可以执行，

213
00:08:51,250 --> 00:08:53,270
再次打印a和b。

214
00:08:53,270 --> 00:08:56,030
所以，现在让我们做，没有掉。

215
00:08:56,030 --> 00:08:58,430
让我一个终端窗口
高一点，这样我们就可以看到

216
00:08:58,430 --> 00:08:59,520
它一次。

217
00:08:59,520 --> 00:09:00,860
>> 和运行没有交换。

218
00:09:00,860 --> 00:09:04,000
x为1时，y是2。 a是1，b是2。

219
00:09:04,000 --> 00:09:06,070
然后，a为2，b是1。

220
00:09:06,070 --> 00:09:09,390
因此，它是工作，就像杰西
在这里做过内部的交换。

221
00:09:09,390 --> 00:09:13,090
不过，当然，它不具有效果
主要变量。

222
00:09:13,090 --> 00:09:15,360
>> 于是，我们看到了一招，让我们
可以解决这个问题，对不对？

223
00:09:15,360 --> 00:09:19,560
当你面对这个范围
的问题，你可能只是平底船，使X

224
00:09:19,560 --> 00:09:22,400
和y变量，而不是什么样的呢？

225
00:09:22,400 --> 00:09:23,390
>> 你可以让他们在全球范围。

226
00:09:23,390 --> 00:09:27,560
把他们在最高层的文件
我们这样做，甚至在比赛中15。

227
00:09:27,560 --> 00:09:28,890
我们使用一个全局变量。

228
00:09:28,890 --> 00:09:32,420
但是在游戏15的上下文中，
有一个全球性的，这是合理的

229
00:09:32,420 --> 00:09:37,170
变量，代表董事会，因为
15.C全部是所有

230
00:09:37,170 --> 00:09:38,650
关于实施的那场比赛。

231
00:09:38,650 --> 00:09:41,470
这就是该文件存在。

232
00:09:41,470 --> 00:09:44,170
>> 但是，在这种情况下，在这里，我
调用函数swap。

233
00:09:44,170 --> 00:09:45,380
我想交换两个变量。

234
00:09:45,380 --> 00:09:48,950
它应该开始觉得只是马虎
如果我们所有的解决方案

235
00:09:48,950 --> 00:09:51,300
当我们碰上范围的问题
问题是使其全球。

236
00:09:51,300 --> 00:09:54,730
因为速度非常快，我们的计划是
要成为相当混乱。

237
00:09:54,730 --> 00:09:57,760
我们这样做绝少
作为一个结果15.c.

238
00:09:57,760 --> 00:10:00,470
>> 但事实证明，有一个
完全有更好的办法。

239
00:10:00,470 --> 00:10:05,600
实际上，让我回去，并删除
打印F的，只是为了简化代码。

240
00:10:05,600 --> 00:10:09,160
让我提出，
这确实是坏的。

241
00:10:09,160 --> 00:10:15,990
但是，如果我不是在一些星号
和星星，我反而可以把这个

242
00:10:15,990 --> 00:10:18,670
成一个功能
实际运作。

243
00:10:18,670 --> 00:10:25,020
>> 因此，让我回到这里，并承认说
星号总是很困难，

244
00:10:25,020 --> 00:10:26,170
所以我会说星星。

245
00:10:26,170 --> 00:10:27,660
我就明说那个。

246
00:10:27,660 --> 00:10:28,190
好的。

247
00:10:28,190 --> 00:10:30,190
而现在，我该怎么
做什么呢？

248
00:10:30,190 --> 00:10:34,130
>> 所以首先，我要指定
，而不是通过一个int

249
00:10:34,130 --> 00:10:37,980
交换功能，而不是我
去，说INT星级。

250
00:10:37,980 --> 00:10:39,170
现在的明星，什么指示？

251
00:10:39,170 --> 00:10:41,970
这是一个指针，该概念
宾基，黏土动画人物，

252
00:10:41,970 --> 00:10:43,465
指一时年前。

253
00:10:43,465 --> 00:10:47,610
>> 所以，如果我们说诠释明星的意思
现在，不打算要

254
00:10:47,610 --> 00:10:49,110
通过在其价值。

255
00:10:49,110 --> 00:10:50,350
它不会被复制英寸

256
00:10:50,350 --> 00:10:54,700
的地址的情况相反，是
将要传递的。

257
00:10:54,700 --> 00:10:57,840
>> 因此，记得您的计算机内
一大堆的内存，否则

258
00:10:57,840 --> 00:10:58,760
被称为RAM。

259
00:10:58,760 --> 00:11:00,520
而且，RAM仅仅是一个
一大堆字节。

260
00:11:00,520 --> 00:11:03,320
所以，如果你的Mac或PC
两个千兆字节，你有2个

261
00:11:03,320 --> 00:11:05,760
十亿字节的内存。

262
00:11:05,760 --> 00:11:08,440
>> 现在，让我们假设只是为了
保持美好的东西，有序的，我们

263
00:11:08,440 --> 00:11:09,450
分配一个IP地址 - 

264
00:11:09,450 --> 00:11:10,170
一个数字 - 

265
00:11:10,170 --> 00:11:12,270
在您的计算机上的每一个字节的RAM。

266
00:11:12,270 --> 00:11:15,410
那些2的第一个字节
亿元是由多少个零。

267
00:11:15,410 --> 00:11:18,572
下一个是字节数一数
二，所有的方式起来，点点

268
00:11:18,572 --> 00:11:20,530
点，约2亿元。

269
00:11:20,530 --> 00:11:23,640
>> 所以，你可以的字节数
在您的计算机的内存。

270
00:11:23,640 --> 00:11:26,460
因此，让我们假设，这是什么
我们所说的地址。

271
00:11:26,460 --> 00:11:31,360
所以，当我看到INT星级一个，这是怎么回事
要通过期现掉换是

272
00:11:31,360 --> 00:11:32,830
地址。

273
00:11:32,830 --> 00:11:37,150
不是它的价值，但不论其邮政
地址，可以这么说 - 

274
00:11:37,150 --> 00:11:38,810
它的位置在RAM中。

275
00:11:38,810 --> 00:11:41,250
>> 同样为b，我要去
说同样的事情。

276
00:11:41,250 --> 00:11:42,720
诠释，星级，B。

277
00:11:42,720 --> 00:11:46,350
顺便说一句，技术上的明星
在其他地方可以去。

278
00:11:46,350 --> 00:11:50,140
但是，我们将标准化星级
旁边的数据类型。

279
00:11:50,140 --> 00:11:54,080
>> 因此，交换签名意味着现在，给我
一个int的地址和呼叫

280
00:11:54,080 --> 00:11:55,400
地址一个。

281
00:11:55,400 --> 00:11:58,690
并给我的另一个地址
INT和调用该地址b。

282
00:11:58,690 --> 00:12:01,120
>> 但现在这里有我的代码改变。

283
00:12:01,120 --> 00:12:03,470
因为如果我声明INT温度 - 

284
00:12:03,470 --> 00:12:05,580
这仍然是int类型的 - 

285
00:12:05,580 --> 00:12:08,700
但我存储在它，
什么样的价值？

286
00:12:08,700 --> 00:12:12,870
要清楚，我把一个一个
现在写的代码？

287
00:12:12,870 --> 00:12:14,360
>> 我将在一个位置。

288
00:12:14,360 --> 00:12:16,500
但我不关心
现在的位置，对不对？

289
00:12:16,500 --> 00:12:21,940
温度存在只是杰斯第三杯
存在，目的是什么？

290
00:12:21,940 --> 00:12:23,090
要存储一个值。

291
00:12:23,090 --> 00:12:24,830
牛奶或橙汁。

292
00:12:24,830 --> 00:12:28,520
不实际存储的地址
那些东西，感觉

293
00:12:28,520 --> 00:12:31,200
在这个现实有点无厘头
全球上下文反正。

294
00:12:31,200 --> 00:12:34,990
>> 所以真的，我希望把温度
的地址的情况，但

295
00:12:34,990 --> 00:12:36,180
内容。

296
00:12:36,180 --> 00:12:41,930
因此，如果a是一个数（如123），这是
123字节的内存，一个公正的

297
00:12:41,930 --> 00:12:45,090
恰好是占领，该值
在一个恰好是占领。

298
00:12:45,090 --> 00:12:49,040
>> 如果我想去到该地址，
我需要说一个明星。

299
00:12:49,040 --> 00:12:52,610
同样，如果我要改变什么
地址，我改变

300
00:12:52,610 --> 00:12:53,570
这开始。

301
00:12:53,570 --> 00:12:58,185
如果我要存储在什么
什么位置的位置

302
00:12:58,185 --> 00:13:02,180
B，明星B星。

303
00:13:02,180 --> 00:13:05,340
>> 因此，在短，即使这是不太
下沉还没有 - 我不希望

304
00:13:05,340 --> 00:13:06,560
它会如此之快 - 

305
00:13:06,560 --> 00:13:11,100
意识到，我做的是前缀
这些星星我的变量，

306
00:13:11,100 --> 00:13:13,350
说不要抢值。

307
00:13:13,350 --> 00:13:14,520
不要改变值。

308
00:13:14,520 --> 00:13:17,600
而是去到这些地址
和得到的价值。

309
00:13:17,600 --> 00:13:21,430
转到该地址和变化
存在的价值。

310
00:13:21,430 --> 00:13:25,500
>> 所以，现在让我回滚动到顶部，
只是为了解决这条线，在这里，

311
00:13:25,500 --> 00:13:27,690
改变相匹配的原型。

312
00:13:27,690 --> 00:13:30,280
但我现在需要做的另一件事情。

313
00:13:30,280 --> 00:13:35,500
直观地说，如果我已经改变了类型
论点交换期待，

314
00:13:35,500 --> 00:13:37,245
我需要做什么
在我的代码改变？

315
00:13:37,245 --> 00:13:39,750

316
00:13:39,750 --> 00:13:40,840
>> 当我打电话掉。

317
00:13:40,840 --> 00:13:43,340
因为现在，我是什么
我仍然通过交换吗？

318
00:13:43,340 --> 00:13:47,450
x的值和y的值，或
牛奶和橙汁。

319
00:13:47,450 --> 00:13:48,510
但我不想这样做。

320
00:13:48,510 --> 00:13:51,060
我不是要传递什么？

321
00:13:51,060 --> 00:13:53,050
的位置x和
y的位置。

322
00:13:53,050 --> 00:13:55,300
什么是他们的邮政地址，
可以这么说。

323
00:13:55,300 --> 00:13:57,600
>> 因此，要做到这一点，有一个符号。

324
00:13:57,600 --> 00:13:59,260
与符号那种听起来地址。

325
00:13:59,260 --> 00:14:03,240
因此n＆符号，地址
为x，y的地址。

326
00:14:03,240 --> 00:14:06,790
因此，它是故意的，我们使用
＆符号调用函数时，

327
00:14:06,790 --> 00:14:10,230
和恒星时，声明和当
执行的功能。

328
00:14:10,230 --> 00:14:14,220
>> 符号，只是觉得作为
地址运算符，明星的

329
00:14:14,220 --> 00:14:15,490
去那里运营商 - 

330
00:14:15,490 --> 00:14:18,640
，或更确切地说，
引用操作

331
00:14:18,640 --> 00:14:23,480
所以这是一个整体的很多话只是
说，现在希望，交换是怎么回事

332
00:14:23,480 --> 00:14:24,440
是正确的。

333
00:14:24,440 --> 00:14:26,550
>> 让我继续前进，使 - 

334
00:14:26,550 --> 00:14:30,940
其实，让我们重命名文件，以免
这个程序仍然可以称为无交换。

335
00:14:30,940 --> 00:14:33,240
我要求我们叫它swap.c的现在。

336
00:14:33,240 --> 00:14:35,670
所以，交换。

337
00:14:35,670 --> 00:14:37,520
点，斜线，交换。

338
00:14:37,520 --> 00:14:40,210
>> 现在确实，x为1时，y是2。

339
00:14:40,210 --> 00:14:44,040
然后，x是2，y是1。

340
00:14:44,040 --> 00:14:46,500
好吧，让我们来看看，如果我们不能做到这
有点什么不同

341
00:14:46,500 --> 00:14:47,180
怎么回事。

342
00:14:47,180 --> 00:14:51,250
首先，让我放大我们
这里绘制屏幕。

343
00:14:51,250 --> 00:14:54,160
让我提出了一会儿 - 
每当我在这里画将被镜像

344
00:14:54,160 --> 00:14:58,660
那里现在 - 让我提出，
这里有一大堆的内存，或

345
00:14:58,660 --> 00:15:00,540
RAM，在我的电脑里面。

346
00:15:00,540 --> 00:15:04,140
>> 这将是咬号码，
比方说，1。

347
00:15:04,140 --> 00:15:05,720
这将是字节数2。

348
00:15:05,720 --> 00:15:08,220
，我会尽一大堆，
然后一堆点点点

349
00:15:08,220 --> 00:15:10,880
表明有是2亿美元
这些东西。

350
00:15:10,880 --> 00:15:13,520
4，5，等等。

351
00:15:13,520 --> 00:15:17,055
>> 因此，有前5个字节
我的计算机的内存。

352
00:15:17,055 --> 00:15:17,560
没事吧？

353
00:15:17,560 --> 00:15:19,060
很少有人出2亿美元。

354
00:15:19,060 --> 00:15:21,120
但现在我要建议
以下。

355
00:15:21,120 --> 00:15:27,490
我要建议，x是要
存储数字1，和y会

356
00:15:27,490 --> 00:15:29,690
来存储数字2。

357
00:15:29,690 --> 00:15:35,000
让我去现在领先，并代表
这些值如下所示。

358
00:15:35,000 --> 00:15:41,510
>> 让我们做如下。

359
00:15:41,510 --> 00:15:42,870
给我一秒。

360
00:15:42,870 --> 00:15:44,150
一秒钟。

361
00:15:44,150 --> 00:15:45,680
确定。

362
00:15:45,680 --> 00:15:47,560
我想这一点 - 

363
00:15:47,560 --> 00:15:50,440
让我们再次做到这一点。

364
00:15:50,440 --> 00:15:53,250
否则我要使用
相同的号码，无意中，

365
00:15:53,250 --> 00:15:54,230
多次。

366
00:15:54,230 --> 00:15:57,320
>> 所以只是让我们有不同的电话号码，
说说，让这个字节

367
00:15:57,320 --> 00:16:03,391
123，124，125，126，
点点点。

368
00:16:03,391 --> 00:16:08,400
让我要求现在我要去
把值1，值2

369
00:16:08,400 --> 00:16:11,990
这里，否则称为x和y。

370
00:16:11,990 --> 00:16:15,300
因此，它只是恰巧
这是X，这是Y。

371
00:16:15,300 --> 00:16:18,180
>> 只是一些随机的机会，
计算机，操作系统，

372
00:16:18,180 --> 00:16:21,890
碰巧把x的位置
123号。

373
00:16:21,890 --> 00:16:25,590
和Y位置124  - 

374
00:16:25,590 --> 00:16:26,330
该死的。

375
00:16:26,330 --> 00:16:28,700
我应该已经解决了这个问题。

376
00:16:28,700 --> 00:16:34,040
哦，男人，我真的想这样做吗？

377
00:16:34,040 --> 00:16:37,340
是的，我想解决这个问题和
b今天这个约是恰当的。

378
00:16:37,340 --> 00:16:39,950
很抱歉，在这个新的。

379
00:16:39,950 --> 00:16:45,020
>> 127，131，我不希望是这样的
复杂，但为什么我改变

380
00:16:45,020 --> 00:16:46,340
有数字吗？

381
00:16:46,340 --> 00:16:48,360
因为我想的整数
实际上是四个字节。

382
00:16:48,360 --> 00:16:49,810
因此，让的这超肛门。

383
00:16:49,810 --> 00:16:53,800
这样，如果发生要处理的
123 2将是在地址

384
00:16:53,800 --> 00:16:55,730
127，因为它是距离酒店仅有4轮空。

385
00:16:55,730 --> 00:16:56,210
这就是全部。

386
00:16:56,210 --> 00:16:58,640
我们会忘记所有
在世界的其他地址。

387
00:16:58,640 --> 00:17:03,320
>> 所以x是在123的位置，
y是在位置127。

388
00:17:03,320 --> 00:17:05,770
而现在，其实我做什么
想干什么？

389
00:17:05,770 --> 00:17:10,099
当我打电话期现掉换，有什么
实际上是怎么回事呢？

390
00:17:10,099 --> 00:17:14,920
好吧，我调用swap时，我传递
的地址x和y的地址。

391
00:17:14,920 --> 00:17:18,540
因此，例如，如果这两个条
现在的纸张代表两个

392
00:17:18,540 --> 00:17:23,510
参数A和B交换，我是什么
打算写第一，

393
00:17:23,510 --> 00:17:27,720
我要打电话给作为？

394
00:17:27,720 --> 00:17:30,610
>> 没错，123。

395
00:17:30,610 --> 00:17:31,905
因此，我要求的是一个。

396
00:17:31,905 --> 00:17:32,955
这是参数a。

397
00:17:32,955 --> 00:17:35,856
我把x的地址在那里。

398
00:17:35,856 --> 00:17:38,152
>> 那是什么？

399
00:17:38,152 --> 00:17:40,890
>> 那是什么？

400
00:17:40,890 --> 00:17:41,190
>> 没有，没有。

401
00:17:41,190 --> 00:17:41,720
这是确定的。

402
00:17:41,720 --> 00:17:42,570
还是不错的，还是不错的。

403
00:17:42,570 --> 00:17:43,530
所以这是一个。

404
00:17:43,530 --> 00:17:46,240
现在，在第二张纸，
这将是B，我是什么

405
00:17:46,240 --> 00:17:49,010
要编写上
一张纸吗？

406
00:17:49,010 --> 00:17:50,080
127。

407
00:17:50,080 --> 00:17:53,720
>> 因此，唯一的改变，因为
这个故事我们以前有说服力的是，

408
00:17:53,720 --> 00:17:58,590
而不是字面上的1和2，我
要通过123和127。

409
00:17:58,590 --> 00:18:02,130
我现在打算把这些内部
这个盒子，所有的权利？

410
00:18:02,130 --> 00:18:04,640
所以，现在黑盒子代表
交换功能。

411
00:18:04,640 --> 00:18:07,230
>> 同时，让我们现在有一个人
实现交换功能。

412
00:18:07,230 --> 00:18:09,090
会有人在这里
喜欢做义工？

413
00:18:09,090 --> 00:18:09,560
上来吧。

414
00:18:09,560 --> 00:18:11,080
你叫什么名字？

415
00:18:11,080 --> 00:18:11,460
查理。

416
00:18:11,460 --> 00:18:12,080
好吧，查理。

417
00:18:12,080 --> 00:18:14,810
上来吧。

418
00:18:14,810 --> 00:18:17,310
>> 因此，查理是要发挥
我们黑匣子的作用。

419
00:18:17,310 --> 00:18:21,460
查理，我想请你做什么
现在以这样的方式实现交换

420
00:18:21,460 --> 00:18:25,320
的是，由于这两个地址，
你实际上会

421
00:18:25,320 --> 00:18:26,330
改变值。

422
00:18:26,330 --> 00:18:28,290
我会在你耳边低语
如何运行这里的电视。

423
00:18:28,290 --> 00:18:29,930
>> 所以先走了，你的黑盒子。

424
00:18:29,930 --> 00:18:30,920
到达那里。

425
00:18:30,920 --> 00:18:34,054
你看到什么样的价值观，
为B你看什么样的价值观？

426
00:18:34,054 --> 00:18:36,740
>> 查理：一个是123，b是127。

427
00:18:36,740 --> 00:18:37,530
>> 国宝马兰：OK，正好。

428
00:18:37,530 --> 00:18:38,940
现在停在那里只是一瞬间。

429
00:18:38,940 --> 00:18:41,680
第一件事，你现在打算怎么办，
根据代码 - 

430
00:18:41,680 --> 00:18:43,220
现在我会拉在屏幕上 - 

431
00:18:43,220 --> 00:18:46,750
将是分配一点
位的内存称为温度。

432
00:18:46,750 --> 00:18:48,850
所以，我要继续前进，
给你的记忆。

433
00:18:48,850 --> 00:18:52,210
>> 因此，这将是第三个变量
你有访问

434
00:18:52,210 --> 00:18:54,080
你名为温度。

435
00:18:54,080 --> 00:18:57,120
你有什么打算写
上临时纸上？

436
00:18:57,120 --> 00:19:02,524

437
00:19:02,524 --> 00:19:03,470
>> 查理：指针，对不对？

438
00:19:03,470 --> 00:19:04,790
>> 国宝MALAN：“确定”，远的不
一定指针。

439
00:19:04,790 --> 00:19:07,230
所以我的代码行
上突出显示在右手边，

440
00:19:07,230 --> 00:19:07,900
我们从这里开始。

441
00:19:07,900 --> 00:19:08,890
一个明星说。

442
00:19:08,890 --> 00:19:11,670
所以目前保存
数字123。

443
00:19:11,670 --> 00:19:16,660
只是直觉，什么
星级123是什么意思？

444
00:19:16,660 --> 00:19:21,630
>> 但是，具体地，如果a是
123，一个明星意味着什么？

445
00:19:21,630 --> 00:19:22,560
a的值。

446
00:19:22,560 --> 00:19:24,580
或者更随意，去那里。

447
00:19:24,580 --> 00:19:28,620
因此，我建议，持有中
你的手，继续和治疗

448
00:19:28,620 --> 00:19:29,430
就好像它是一个地图。

449
00:19:29,430 --> 00:19:32,940
走自己电脑的
内存，并找到我们的是什么

450
00:19:32,940 --> 00:19:36,520
在123的位置。

451
00:19:36,520 --> 00:19:37,720
没错。

452
00:19:37,720 --> 00:19:41,100
>> 所以我们看到在位置123
是什么，很明显吗？

453
00:19:41,100 --> 00:19:44,240
OK，所以什么样的价值现在是你
去付诸温度？

454
00:19:44,240 --> 00:19:44,750
没错。

455
00:19:44,750 --> 00:19:45,600
因此，继续前进，并做到这一点。

456
00:19:45,600 --> 00:19:51,280
写数字1片
纸的温度题为。

457
00:19:51,280 --> 00:19:53,540
>> 而现在的下一个步骤即
你要实现

458
00:19:53,540 --> 00:19:54,310
会是什么。

459
00:19:54,310 --> 00:19:57,820
以及，在右手侧的
下一行代码是星级住宿。 ，，

460
00:19:57,820 --> 00:19:59,260
当然，存储一个地址。

461
00:19:59,260 --> 00:20:02,270
地址127。

462
00:20:02,270 --> 00:20:06,620
星b表示什么，随便说吗？

463
00:20:06,620 --> 00:20:08,700
>> 进入到该位置。

464
00:20:08,700 --> 00:20:14,988
因此，继续前进，并找到我们什么
在127的位置。

465
00:20:14,988 --> 00:20:15,480
确定。

466
00:20:15,480 --> 00:20:19,170
当然，在位置127，
仍然是值2。

467
00:20:19,170 --> 00:20:24,060
那么你现在店
无论是在上面的位置？

468
00:20:24,060 --> 00:20:26,860
所以明星的手段去的位置。

469
00:20:26,860 --> 00:20:29,770
是什么位置？

470
00:20:29,770 --> 00:20:30,430
>> 没错。

471
00:20:30,430 --> 00:20:34,190
所以，现在，如果你想改变
什么是在那个位置 - 

472
00:20:34,190 --> 00:20:36,470
我会继续运行
橡皮擦都在这里。

473
00:20:36,470 --> 00:20:37,760
现在把它刷上。

474
00:20:37,760 --> 00:20:42,190
你打算写什么号码
在该空白框现在呢？

475
00:20:42,190 --> 00:20:42,850
>> 没错。

476
00:20:42,850 --> 00:20:46,470
所以这行代码，要明确 - 让
我暂停了查理的做

477
00:20:46,470 --> 00:20:51,730
这里指出，他刚刚做了什么
写入那个盒子位置123

478
00:20:51,730 --> 00:20:55,150
以前在b的值。

479
00:20:55,150 --> 00:20:59,140
所以我们现在确实实施
这第二行代码。

480
00:20:59,140 --> 00:21:01,920
>> 不幸的是，现在有
还有一个剩余行。

481
00:21:01,920 --> 00:21:04,900
现在是什么温度，从字面上看？

482
00:21:04,900 --> 00:21:06,200
这显然​​是头号。

483
00:21:06,200 --> 00:21:07,020
这不是一个地址。

484
00:21:07,020 --> 00:21:09,380
这只是一个号码，排序
从本周一的变量。

485
00:21:09,380 --> 00:21:13,520
>> 而现在，当你说星级B，这意味着
去的地址b，这对

486
00:21:13,520 --> 00:21:15,090
当然在这里。

487
00:21:15,090 --> 00:21:16,020
所以，一旦你到达那里 - 

488
00:21:16,020 --> 00:21:18,320
我会继续前进，抹去了实际上
 - 你是什么

489
00:21:18,320 --> 00:21:20,820
去现在写地点127？

490
00:21:20,820 --> 00:21:22,010
>> 查理：温度，这是一种。

491
00:21:22,010 --> 00:21:23,430
>> DAVID马兰：温度，是其中一个。

492
00:21:23,430 --> 00:21:25,670
和温度到底发生了什么？

493
00:21:25,670 --> 00:21:26,600
好了，我们真的不知道。

494
00:21:26,600 --> 00:21:27,420
我们不在乎。

495
00:21:27,420 --> 00:21:31,090
任何时候，我们已经实现了一个功能
到目前为止，你有任何局部变量

496
00:21:31,090 --> 00:21:31,890
确实是本地的。

497
00:21:31,890 --> 00:21:33,060
他们只是消失。

498
00:21:33,060 --> 00:21:35,040
他们回收经营
最终系统。

499
00:21:35,040 --> 00:21:39,800
>> 因此，温度的事实，仍然有
数值1是一种从根本上

500
00:21:39,800 --> 00:21:41,150
无趣我们。

501
00:21:41,150 --> 00:21:43,100
好吧，让掌声雷动
如果我们能为查理。

502
00:21:43,100 --> 00:21:46,400
非常出色。

503
00:21:46,400 --> 00:21:51,520
>> 好，那么还有什么不
这意味着我们可以做的吗？

504
00:21:51,520 --> 00:21:54,400
所以，事实证明，我们已经
告诉一些善意的谎言

505
00:21:54,400 --> 00:21:55,540
相当长的一段时间。

506
00:21:55,540 --> 00:21:59,990
事实上，它变成了一个字符串，
这段时间，是不是真的

507
00:21:59,990 --> 00:22:02,190
本身的字符序列。

508
00:22:02,190 --> 00:22:03,980
样的，直观的。

509
00:22:03,980 --> 00:22:08,270
>> 但是从技术上来说，字符串是一个
数据类型，我们内部声明

510
00:22:08,270 --> 00:22:12,170
CS50库简化了世界
类的头几个星期。

511
00:22:12,170 --> 00:22:20,130
字符串真的是地址是
一个字符在RAM中的某个地方。

512
00:22:20,130 --> 00:22:25,530
一个字符串，是一个真正的号码，如123
或127，出现这种情况划定

513
00:22:25,530 --> 00:22:28,420
字符串开始
您的计算机的内存。

514
00:22:28,420 --> 00:22:31,870
>> 不过，这并不代表
字符串，每se，本身。

515
00:22:31,870 --> 00:22:33,460
我们可以看到如下。

516
00:22:33,460 --> 00:22:35,980
让我去进取，不断开拓
一些代码之间

517
00:22:35,980 --> 00:22:38,340
今天的源代码示例。

518
00:22:38,340 --> 00:22:42,225
而且我要继续前进，并打开
，让我们说，比较0.C。

519
00:22:42,225 --> 00:22:44,830

520
00:22:44,830 --> 00:22:48,790
这是一个错误的程序会
以如下方式实现。

521
00:22:48,790 --> 00:22:49,040
>> 第一。

522
00:22:49,040 --> 00:22:50,420
我要说什么。

523
00:22:50,420 --> 00:22:52,660
然后，我要继续前进，
从用户得到一个字符串

524
00:22:52,660 --> 00:22:53,750
在该下一行。

525
00:22:53,750 --> 00:22:55,370
然后，我要再说一遍。

526
00:22:55,370 --> 00:22:57,540
然后我会得到另一个
来自用户的字符串。

527
00:22:57,540 --> 00:23:00,390
>> 通知，我展示之一
字符串中的变量称为S，

528
00:23:00,390 --> 00:23:03,040
另一个这些字符串
在一个变量名为t。

529
00:23:03,040 --> 00:23:07,480
现在，我要索赔，非常
合理，如果s等于等于T，

530
00:23:07,480 --> 00:23:08,940
字符串是相同的。

531
00:23:08,940 --> 00:23:09,970
你键入同样的事情。

532
00:23:09,970 --> 00:23:11,830
否则，琴弦
不一样的东西。

533
00:23:11,830 --> 00:23:15,440
>> 毕竟，如果我们输入两个整数，两
字符，两个浮筒，两个双打，任何

534
00:23:15,440 --> 00:23:18,400
我们谈过的数据类型
迄今为止对它们进行比较 - 

535
00:23:18,400 --> 00:23:22,070
记得我们前一阵子很清楚
你不这样做，因为一个

536
00:23:22,070 --> 00:23:25,840
当然是一个等号
赋值运算符。

537
00:23:25,840 --> 00:23:26,820
因此，这将是一个错误。

538
00:23:26,820 --> 00:23:29,260
>> 我们用平等等号，
这确实比较

539
00:23:29,260 --> 00:23:31,050
事情真正的平等。

540
00:23:31,050 --> 00:23:32,275
不过，我要求这是越野车。

541
00:23:32,275 --> 00:23:37,400
如果我继续前进，使比较零，
然后做点斜线比较为零。

542
00:23:37,400 --> 00:23:39,700
我输入，让我们说，你好。

543
00:23:39,700 --> 00:23:41,590
然后让我们再次问好。

544
00:23:41,590 --> 00:23:46,040
从字面上看同样的事情，电脑
索赔我打不同的事情。

545
00:23:46,040 --> 00:23:47,640
>> 现在，也许我只是打错了。

546
00:23:47,640 --> 00:23:49,910
这个时候，我会输入我的名字。

547
00:23:49,910 --> 00:23:52,580
我的意思是，你好。

548
00:23:52,580 --> 00:23:54,770
你好。

549
00:23:54,770 --> 00:23:57,360
这是不同的，每一次。

550
00:23:57,360 --> 00:23:58,430
>> 那么，这是为什么？

551
00:23:58,430 --> 00:24:00,140
到底发生了什么
引擎盖下？

552
00:24:00,140 --> 00:24:03,270
那么，什么是真正回事下方
引擎盖然后是字符串

553
00:24:03,270 --> 00:24:07,410
我输入的，例如首次
这个词打招呼，当然。

554
00:24:07,410 --> 00:24:11,660
但是，如果我们代表这底下
引擎盖，回想一下，

555
00:24:11,660 --> 00:24:13,470
字符串是在一个数组中。

556
00:24:13,470 --> 00:24:15,040
我们已经说了这么多了过去。

557
00:24:15,040 --> 00:24:20,200
>> 所以，如果我画这样的数组，我
要代表的东西相当

558
00:24:20,200 --> 00:24:23,030
类似刚才我们所做的事情。

559
00:24:23,030 --> 00:24:25,390
并有实际的东西
特别在这里，太。

560
00:24:25,390 --> 00:24:28,090
我们什么确定
每一个字符串的结尾？

561
00:24:28,090 --> 00:24:30,760
是啊，这反斜杠零，这是
只是表示方式，

562
00:24:30,760 --> 00:24:33,610
从字面上看，00000000。

563
00:24:33,610 --> 00:24:35,680
八0位成一排。

564
00:24:35,680 --> 00:24:37,610
>> 我不知道，坦白说，
什么是在这之后。

565
00:24:37,610 --> 00:24:40,090
那只是一堆更多的RAM
我的电脑里面。

566
00:24:40,090 --> 00:24:40,970
但是，这是一个数组。

567
00:24:40,970 --> 00:24:42,260
我们谈到阵列。

568
00:24:42,260 --> 00:24:45,010
我们通常谈论数组
作为零的位置，

569
00:24:45,010 --> 00:24:46,580
再一个，然后两个。

570
00:24:46,580 --> 00:24:47,950
但是，这只是为了方便。

571
00:24:47,950 --> 00:24:49,380
而这完全是相对的。

572
00:24:49,380 --> 00:24:53,010
>> 当你实际上得到内存
电脑，当然，任何

573
00:24:53,010 --> 00:24:55,450
2十亿一些奇怪的字节，有可能。

574
00:24:55,450 --> 00:24:59,100
所以，真正的引擎盖下方，
这一切的时候，是的。

575
00:24:59,100 --> 00:25:01,670
这很可能是支架为零。

576
00:25:01,670 --> 00:25:04,780
但是，如果你挖更深下方
油烟机，这是真的

577
00:25:04,780 --> 00:25:07,000
解决123号。

578
00:25:07,000 --> 00:25:09,150
这是地址124。

579
00:25:09,150 --> 00:25:11,040
这是地址125。

580
00:25:11,040 --> 00:25:12,540
>> 而且我没有搞砸这个时候。

581
00:25:12,540 --> 00:25:15,840
这些都是现在一个字节
除了由于什么原因？

582
00:25:15,840 --> 00:25:17,930
一个char有多大？

583
00:25:17,930 --> 00:25:19,170
一个char是只是一个字节。

584
00:25:19,170 --> 00:25:20,570
一个int通常是四个字节。

585
00:25:20,570 --> 00:25:24,850
所以这就是为什么我做了它123，
127，131，等等。

586
00:25:24,850 --> 00:25:27,560
现在，我可以保持简单的数学
只是做加1。

587
00:25:27,560 --> 00:25:30,510
这是现在到底发生了什么
引擎盖下。

588
00:25:30,510 --> 00:25:37,760
>> 所以，当你宣布这样的事情，
字符串s，这其实是 - 

589
00:25:37,760 --> 00:25:39,170
原来 - 

590
00:25:39,170 --> 00:25:41,190
字符的明星。

591
00:25:41,190 --> 00:25:44,640
明星，当然，这意味着
地址，又名指针。

592
00:25:44,640 --> 00:25:46,200
因此，它的东西的地址。

593
00:25:46,200 --> 00:25:47,510
这是什么地址？

594
00:25:47,510 --> 00:25:47,760
>> 那么 - 

595
00:25:47,760 --> 00:25:51,680
我是唯一一个谁可以看到非常
重要的一点，我在做，还是觉得

596
00:25:51,680 --> 00:25:52,560
我做。

597
00:25:52,560 --> 00:25:55,270
所以字符串 - 

598
00:25:55,270 --> 00:25:57,180
可悲的是，我有一个监视器
那里我

599
00:25:57,180 --> 00:25:58,100
能看到的是。

600
00:25:58,100 --> 00:26:00,990
>> 所有的权利，所以字符串s是什么
我先前声明。

601
00:26:00,990 --> 00:26:04,600
但事实证明，由于一个小
神奇的的CS50库中，这一切都

602
00:26:04,600 --> 00:26:08,780
从字面上有时间字符串
一直字符星级。

603
00:26:08,780 --> 00:26:11,310
明星再次表示
指针或地址。

604
00:26:11,310 --> 00:26:14,180
事实上，它的侧翼
字字符意味着它的

605
00:26:14,180 --> 00:26:15,970
一个字符的地址。

606
00:26:15,970 --> 00:26:23,100
>> 所以，如果字符串被调用，然后我输入
在H-E-L-L-Ø，现在建议已得到

607
00:26:23,100 --> 00:26:27,330
字串返回
这个时候，即使我们已经相当

608
00:26:27,330 --> 00:26:29,980
过于简单化的世界吗？

609
00:26:29,980 --> 00:26:33,310
没有得到什么实际字符串
作为它的返回值返回？

610
00:26:33,310 --> 00:26:35,830

611
00:26:35,830 --> 00:26:38,720
>> 123在这种情况下，例如。

612
00:26:38,720 --> 00:26:42,630
我们以前说过，得到的字符串
只是返回一个字符串，一个序列

613
00:26:42,630 --> 00:26:43,300
字符。

614
00:26:43,300 --> 00:26:44,790
但是，这是一个有点白色的谎言。

615
00:26:44,790 --> 00:26:48,010
的方式得到真正起作用的字符串
引擎盖下是它得到

616
00:26:48,010 --> 00:26:48,930
来自用户的字符串。

617
00:26:48,930 --> 00:26:51,530
它扑通一声的字符
他或她在内存中。

618
00:26:51,530 --> 00:26:54,680
它把一个反斜杠零结尾
这些字符序列。

619
00:26:54,680 --> 00:26:57,310
>> 但后来没有得到什么字符串
从字面上返回？

620
00:26:57,310 --> 00:27:02,710
它的字面返回的地址
的第一个字节在RAM中的

621
00:27:02,710 --> 00:27:04,130
它用于这种力量。

622
00:27:04,130 --> 00:27:07,500
而事实证明，仅仅通过返回
一个单一的地址的

623
00:27:07,500 --> 00:27:12,120
第一个字符串中的字符，那就是
足以查找的全部

624
00:27:12,120 --> 00:27:12,630
的字符串。

625
00:27:12,630 --> 00:27:16,930
>> 换言之，得到的字符串没有
返回123，124和125。

626
00:27:16,930 --> 00:27:19,950
它没有给我一个长
列表中所有的字节

627
00:27:19,950 --> 00:27:20,740
我的字符串使用。

628
00:27:20,740 --> 00:27:22,670
因为，他们都是背靠背。

629
00:27:22,670 --> 00:27:28,160
和两个，是根据第一个地址，我
可以计算出字符串结束。

630
00:27:28,160 --> 00:27:29,910
怎么样？

631
00:27:29,910 --> 00:27:33,490
>> 特殊的空字符，
结束，反斜线零。

632
00:27:33,490 --> 00:27:35,430
因此，换句话说，如果
你传递 - 

633
00:27:35,430 --> 00:27:36,530
内部变量 - 

634
00:27:36,530 --> 00:27:41,300
一个字符的地址，并承担
，任何字符串结束时，任何

635
00:27:41,300 --> 00:27:45,040
作为我们人类的字符序列
想到的字符串，如果你假设

636
00:27:45,040 --> 00:27:48,600
在有任何这样的字符串的末尾
一个反斜杠零，你的黄金。

637
00:27:48,600 --> 00:27:52,430
因为你总是可以找到
字符串的结尾。

638
00:27:52,430 --> 00:27:54,870
>> 现在，什么是真正然后去
在这个程序？

639
00:27:54,870 --> 00:27:59,990
为什么是这样的程序，
比较0.C，越野车？

640
00:27:59,990 --> 00:28:01,690
什么是真正被比较？

641
00:28:01,690 --> 00:28:02,420
是吗？

642
00:28:02,420 --> 00:28:05,000
>> 学生：[听不清]。

643
00:28:05,000 --> 00:28:05,730
>> DAVID马兰：没错。

644
00:28:05,730 --> 00:28:08,350
它的位置比较
的字符串。

645
00:28:08,350 --> 00:28:12,420
因此，如果用户已键入招呼一次，
像我一样，内存可能会结束

646
00:28:12,420 --> 00:28:13,430
这样看。

647
00:28:13,430 --> 00:28:18,210
然后，如果用户类型招呼再次
但再次调用get字符串，c是

648
00:28:18,210 --> 00:28:21,800
不特别聪明，除非你教
它是巧妙地编写代码。

649
00:28:21,800 --> 00:28:22,430
>> C  - 

650
00:28:22,430 --> 00:28:23,860
和计算机更普遍 - 

651
00:28:23,860 --> 00:28:27,370
如果你输入单词再打招呼，
你知道你要得到什么。

652
00:28:27,370 --> 00:28:31,480
你只是会得到第二个数组
内存，是的，发生

653
00:28:31,480 --> 00:28:35,510
存储H-E-L-L-O和等等。

654
00:28:35,510 --> 00:28:38,240
>> 看起来是一样的，这是怎么回事
我们人类，但这个地址

655
00:28:38,240 --> 00:28:39,460
可能不是123。

656
00:28:39,460 --> 00:28:42,470
所以它可能只是发生
操作系统具有一些可用的

657
00:28:42,470 --> 00:28:45,430
空间实例在位置 - 

658
00:28:45,430 --> 00:28:49,820
比方说，任意东西，
像这样的位置200。

659
00:28:49,820 --> 00:28:51,620
这是201的位置。

660
00:28:51,620 --> 00:28:53,060
这是位置202。

661
00:28:53,060 --> 00:28:55,730
我们不知道这
要存在于内存中。

662
00:28:55,730 --> 00:28:59,110
>> 但是，这是什么意思是，什么是
将最终被存储在s？

663
00:28:59,110 --> 00:29:00,750
123。

664
00:29:00,750 --> 00:29:04,860
这是怎么回事存储在T，
在这种武断的例子吗？

665
00:29:04,860 --> 00:29:06,300
200号。

666
00:29:06,300 --> 00:29:11,410
那么这意味着是显而易见的，
123不等于200。

667
00:29:11,410 --> 00:29:14,940
所以如果条件不
计算结果为true。

668
00:29:14,940 --> 00:29:18,430
由于获取字符串使用不同
每次的内存块。

669
00:29:18,430 --> 00:29:20,360
>> 现在，我们可以再次看到这个
在另一个实例中。

670
00:29:20,360 --> 00:29:23,764
让我去进取，不断开拓复制0.C的。

671
00:29:23,764 --> 00:29:28,770
我要求这个例子是要
尝试 - 失败 - 复制两个字符串

672
00:29:28,770 --> 00:29:29,910
如下所示。

673
00:29:29,910 --> 00:29:31,730
>> 我要说点什么
给用户。

674
00:29:31,730 --> 00:29:34,490
然后，我会得到一个
串并调用它s。

675
00:29:34,490 --> 00:29:36,400
而现在，我做这个检查。

676
00:29:36,400 --> 00:29:37,990
我们提到这一段时间回来。

677
00:29:37,990 --> 00:29:42,490
但是，当可能会返回空字符串，
另一个特殊字符，或特殊

678
00:29:42,490 --> 00:29:45,050
符号让说。

679
00:29:45,050 --> 00:29:45,900
如果它的内存。

680
00:29:45,900 --> 00:29:48,970
>> 例如，如果用户是真的
难以和一个穷凶极恶的类型

681
00:29:48,970 --> 00:29:51,220
上面的的字符数
键盘和点击输入。

682
00:29:51,220 --> 00:29:54,580
如果这个数字的字符就不能
适合在RAM中，不管是任何疯狂

683
00:29:54,580 --> 00:29:57,820
原因，以及字符串可能
很好返回null。

684
00:29:57,820 --> 00:30:01,080
>> 或者，如果你的程序本身是做了很多
其他的事情，而且也只是

685
00:30:01,080 --> 00:30:03,790
没有足够的内存来获取字符串
要取得成功，它可能结束

686
00:30:03,790 --> 00:30:05,240
向上返回null。

687
00:30:05,240 --> 00:30:07,160
但是，让我们更精确
这是什么。

688
00:30:07,160 --> 00:30:10,280
s的数据类型，什么是真的吗？

689
00:30:10,280 --> 00:30:11,610
字符明星。

690
00:30:11,610 --> 00:30:14,560
>> 因此，原来现在我们可以剥离
回空层。

691
00:30:14,560 --> 00:30:17,500
原来，null是 - 是的，很明显
一个特殊的符号。

692
00:30:17,500 --> 00:30:19,190
但什么是真的？

693
00:30:19,190 --> 00:30:25,220
真的，空，我们只是一个符号
人类使用的代表零。

694
00:30:25,220 --> 00:30:29,010
>> 因此，作者的C，电脑
更一般地，决定年前

695
00:30:29,010 --> 00:30:30,010
这一点，你知道是什么。

696
00:30:30,010 --> 00:30:34,850
为什么我们不确保没有用户
数据是永远，永远，永远

697
00:30:34,850 --> 00:30:36,730
存储再见零？

698
00:30:36,730 --> 00:30:39,610
事实上，即使是在我任意的例子
之前，我并没有开始编号

699
00:30:39,610 --> 00:30:40,390
在零字节。

700
00:30:40,390 --> 00:30:41,540
我开始在一个。

701
00:30:41,540 --> 00:30:44,950
因为我知道，人在世界上
已决定预定的零

702
00:30:44,950 --> 00:30:47,970
在任何人的RAM作为字节
一些特别的东西。

703
00:30:47,970 --> 00:30:52,020
>> 原因是，任何时候你想
信号出了毛病

704
00:30:52,020 --> 00:30:55,960
地址中，返回
空 - 否则被称为零 - 

705
00:30:55,960 --> 00:30:59,410
因为你知道，有没有
合法的数据地址零，显然

706
00:30:59,410 --> 00:31:00,400
这意味着一个错误。

707
00:31:00,400 --> 00:31:04,080
这就是为什么，按照惯例，我们检查
空和返回的东西

708
00:31:04,080 --> 00:31:06,260
就像一个在这些情况下。

709
00:31:06,260 --> 00:31:09,300
>> 因此，如果我们现在向下滚动，这只是
然后一些错误检查，以防万一

710
00:31:09,300 --> 00:31:10,610
[出事了？保释？]

711
00:31:10,610 --> 00:31:13,470
完全退出程序
通过提前回国。

712
00:31:13,470 --> 00:31:19,030
现在这条线可以改写
因为这，这意味着什么呢？

713
00:31:19,030 --> 00:31:23,155
在左侧，再给我一次
指针指向一个字符，并调用它吨。

714
00:31:23,155 --> 00:31:26,935
我是什么存储里面的t，根据
这一行代码？

715
00:31:26,935 --> 00:31:30,950

716
00:31:30,950 --> 00:31:32,170
>> 我存储的位置。

717
00:31:32,170 --> 00:31:34,742
具体来说，位置
这是在s。

718
00:31:34,742 --> 00:31:39,000
因此，如果用户已键入招呼，
你好，第一恰好结束

719
00:31:39,000 --> 00:31:42,567
在这里，然后数123
要回来得到

720
00:31:42,567 --> 00:31:43,810
串并储存 - 

721
00:31:43,810 --> 00:31:44,780
正如我们前面所说 - 

722
00:31:44,780 --> 00:31:45,440
在s。

723
00:31:45,440 --> 00:31:50,560
>> 当我现在宣布另一个指针
一个char并调用它的T，什么号码

724
00:31:50,560 --> 00:31:53,940
从字面上去结束在
吨的故事？

725
00:31:53,940 --> 00:31:55,420
所以123。

726
00:31:55,420 --> 00:32:00,310
>> 所以现在技术上s和
T是指向的确切

727
00:32:00,310 --> 00:32:02,410
相同的内存块。

728
00:32:02,410 --> 00:32:06,140
所以通知我要现在做什么
证明，此计划是马车。

729
00:32:06,140 --> 00:32:08,820
>> 首先，我稍后会要求，
打印F，资本化

730
00:32:08,820 --> 00:32:10,080
拷贝的字符串。

731
00:32:10,080 --> 00:32:11,660
然后我会做一个小小的
错误检查。

732
00:32:11,660 --> 00:32:12,160
我要确保。

733
00:32:12,160 --> 00:32:16,710
让我们确保该字符串t是
至少大于零的长度，

734
00:32:16,710 --> 00:32:19,190
所以有一些字符
实际利用。

735
00:32:19,190 --> 00:32:22,840
>> 然后你可能还记得这个
从前面的例子。

736
00:32:22,840 --> 00:32:25,630
2上 - 这是在
ctype.h的文件。

737
00:32:25,630 --> 00:32:30,800
Ť支架零给我零
字符的字符串t。

738
00:32:30,800 --> 00:32:34,360
和2上相同的值，
当然，将其转换为大写。

739
00:32:34,360 --> 00:32:38,230
>> 所以凭直觉，这突出显示的行
代码是资本化的第一

740
00:32:38,230 --> 00:32:40,250
在T字母。

741
00:32:40,250 --> 00:32:44,485
但它不直观，转增股本，
在s的第一个字母。

742
00:32:44,485 --> 00:32:48,130
但是，如果你超前的思维，我是什么
看当我运行这个程序

743
00:32:48,130 --> 00:32:54,220
并打印出原来，
s，而所谓的副本，T？

744
00:32:54,220 --> 00:32:55,350
>> 他们实际上是相同的。

745
00:32:55,350 --> 00:32:56,600
他们为什么会是一样的吗？

746
00:32:56,600 --> 00:32:58,970

747
00:32:58,970 --> 00:33:01,020
他们都指向
完全一样的东西。

748
00:33:01,020 --> 00:33:01,610
因此，让我们做到这一点。

749
00:33:01,610 --> 00:33:03,160
>> 使副本为零。

750
00:33:03,160 --> 00:33:04,070
编译OK。

751
00:33:04,070 --> 00:33:06,500
让我跑副本为零。

752
00:33:06,500 --> 00:33:10,110
让我键入类似您好
全部小写，然后按Enter键。

753
00:33:10,110 --> 00:33:16,520
它声称原来的S
副本的确是相同的。

754
00:33:16,520 --> 00:33:17,920
>> 所以，这里到底发生了什么？

755
00:33:17,920 --> 00:33:20,100
让我重绘此图片
在讲故事

756
00:33:20,100 --> 00:33:21,340
稍微不同的方式。

757
00:33:21,340 --> 00:33:26,060
到底发生了什么下方
当我声明类似罩

758
00:33:26,060 --> 00:33:30,410
字符开始，或字符串s
我得到一个指针 - 

759
00:33:30,410 --> 00:33:33,090
这恰好是四个字节
的CS50器具中

760
00:33:33,090 --> 00:33:34,410
和很多计算机。

761
00:33:34,410 --> 00:33:36,008
我要调用这个S。

762
00:33:36,008 --> 00:33:39,810
而这目前有
一些未知的值。

763
00:33:39,810 --> 00:33:43,900
>> 当你声明一个变量，除非你
自己把一个价值在那里，谁

764
00:33:43,900 --> 00:33:44,570
知道那里有什么。

765
00:33:44,570 --> 00:33:48,110
这可能是一些随机序列的
位从以前的执行。

766
00:33:48,110 --> 00:33:52,490
所以，当我在我行的代码做
字符串，然后存储返回

767
00:33:52,490 --> 00:33:54,800
价值得到字符串s中不知何故 - 

768
00:33:54,800 --> 00:33:58,520
我们最终会剥离怎么弄
字符串的作品，以某种方式分配

769
00:33:58,520 --> 00:34:00,480
可能看起来的阵列
这有点像。

770
00:34:00,480 --> 00:34:05,390
H-E-L-L-O，反斜杠零。

771
00:34:05,390 --> 00:34:09,510
>> 让我们假设这是地址
123只是第一次一致性。

772
00:34:09,510 --> 00:34:13,000
因此，获得字符串返回，在
有突出显示的行，它返回

773
00:34:13,000 --> 00:34:15,000
我们说的号码，123。

774
00:34:15,000 --> 00:34:17,420
那么什么真正走进这里的s？

775
00:34:17,420 --> 00:34:26,590
>> 嗯，真的什么
里面的s是123。

776
00:34:26,590 --> 00:34:29,250
但坦率地说，我开始有点
所有这些地址混淆，

777
00:34:29,250 --> 00:34:30,320
所有这些任意数字。

778
00:34:30,320 --> 00:34:32,290
123，124，127。

779
00:34:32,290 --> 00:34:34,570
因此，让我们简化
世界一点点。

780
00:34:34,570 --> 00:34:38,800
>> 当我们谈论指针，坦率地说，
我们人类，他们到底在乎

781
00:34:38,800 --> 00:34:39,870
事情是在内存中？

782
00:34:39,870 --> 00:34:41,080
这完全是任意的。

783
00:34:41,080 --> 00:34:43,370
这将取决于如何
多少内存的用户。

784
00:34:43,370 --> 00:34:46,590
这将依赖于在白天的时候
你运行的程序，也许和

785
00:34:46,590 --> 00:34:48,250
输入用户给你。

786
00:34:48,250 --> 00:34:50,060
我们居住不重要的细节上。

787
00:34:50,060 --> 00:34:54,230
>> 因此，让我们抽象掉，并说，
当你运行一个像这样的代码行，

788
00:34:54,230 --> 00:34:57,320
字符明星就会越来越回报
获取字符串值。

789
00:34:57,320 --> 00:35:02,720
为什么我们不而是画什么，我们
保持通话就好像它是一个指针

790
00:35:02,720 --> 00:35:04,140
指着东西？

791
00:35:04,140 --> 00:35:07,000
因此，我要求现在到了
有一个指针指向 - 

792
00:35:07,000 --> 00:35:08,480
引擎盖下，它是一个地址。

793
00:35:08,480 --> 00:35:11,330
但它只是指向
第一个字节

794
00:35:11,330 --> 00:35:12,780
字符串，被退回。

795
00:35:12,780 --> 00:35:16,710
>> 如果我现在回到这里的代码，
在这条线是怎么回事？

796
00:35:16,710 --> 00:35:20,020
那么，在现在这个突出的线路，
我声明显然是另一个

797
00:35:20,020 --> 00:35:21,070
变量名为t。

798
00:35:21,070 --> 00:35:25,700
但它也是一个指针，所以我要去
画，从理论上讲，确切的

799
00:35:25,700 --> 00:35:26,710
同样大小的方块。

800
00:35:26,710 --> 00:35:28,160
我要调用它吨。

801
00:35:28,160 --> 00:35:33,500
>> 现在，如果我们去回到代码，
当我存储里面的T，

802
00:35:33,500 --> 00:35:36,920
技术上我是什么
把里面的t？

803
00:35:36,920 --> 00:35:39,350
那么从​​技术上说，这
是数字123。

804
00:35:39,350 --> 00:35:42,270
所以，我真的应该写
有数字123。

805
00:35:42,270 --> 00:35:43,900
但是，让我们把它更高的水平。

806
00:35:43,900 --> 00:35:48,090
T，如果它仅仅是一个指针，
直观的，就是这样。

807
00:35:48,090 --> 00:35:49,800
这是所有被
存储在那里。

808
00:35:49,800 --> 00:35:54,970
>> 所以，现在在最后一个有趣的线
代码，当我真正去了解

809
00:35:54,970 --> 00:36:00,680
资本化零字符
T，是怎么回事？

810
00:36:00,680 --> 00:36:06,310
那么，T支架零现在指向
什么样的性格，想必？

811
00:36:06,310 --> 00:36:07,460
>> 它指向到h。

812
00:36:07,460 --> 00:36:08,870
因为T支架零 - 

813
00:36:08,870 --> 00:36:12,490
记得，这是旧的语法。吨支架
只是意味着，如果t是一个字符串，T零

814
00:36:12,490 --> 00:36:15,590
支架零意味着零
在这种力量的人物。

815
00:36:15,590 --> 00:36:18,650
所以，真正意味着什么
到这个数组 - 

816
00:36:18,650 --> 00:36:21,520
是的，这可能是123，
这可能是124。

817
00:36:21,520 --> 00:36:22,790
但它是相对的，记不清了。

818
00:36:22,790 --> 00:36:25,640
每当谈论一个数组，我们有
谈论的优势

819
00:36:25,640 --> 00:36:27,000
相对指标。

820
00:36:27,000 --> 00:36:31,120
>> 所以现在我们可以假设
那件T支架零小时。

821
00:36:31,120 --> 00:36:35,090
所以，如果我叫2上就可以了，那是什么
真正做的是资本

822
00:36:35,090 --> 00:36:38,290
大写小写h H.
不过，当然，什么是S？

823
00:36:38,290 --> 00:36:41,010
它指向相同织补字符串。

824
00:36:41,010 --> 00:36:44,200
>> 因此，这是已经发生
在这段代码中至今。

825
00:36:44,200 --> 00:36:45,960
那么什么寓意？

826
00:36:45,960 --> 00:36:48,300
我们如何解决这两个问题呢？

827
00:36:48,300 --> 00:36:50,870
我们如何比较实际的字符串？

828
00:36:50,870 --> 00:36:53,720
>> 直观地好了，怎么会
你去比较两个

829
00:36:53,720 --> 00:36:55,090
真正的平等的字符串？

830
00:36:55,090 --> 00:36:58,920

831
00:36:58,920 --> 00:37:00,750
>> 是什么意思，如果两个
字符串相等？

832
00:37:00,750 --> 00:37:04,330
显然不是，他们的地址是
等于在内存中，因为这是一个低

833
00:37:04,330 --> 00:37:06,590
一级执行细节。

834
00:37:06,590 --> 00:37:08,360
所有的字符是相同的。

835
00:37:08,360 --> 00:37:12,810
所以我建议，让我介绍一下
在一个compare.c版本

836
00:37:12,810 --> 00:37:14,970
在这里，所以比较1.C。

837
00:37:14,970 --> 00:37:19,590
>> 最后，我提议，我们仍然获得了
指针，和存储在它

838
00:37:19,590 --> 00:37:20,610
获取字符串返回值。

839
00:37:20,610 --> 00:37:21,750
让我们做同样的事情与t。

840
00:37:21,750 --> 00:37:23,230
因此，没有代码是不同的。

841
00:37:23,230 --> 00:37:25,420
我要加少许
更多错误检查现在。

842
00:37:25,420 --> 00:37:29,390
所以，现在我们有点脱皮
这层CS50什么字符串

843
00:37:29,390 --> 00:37:33,520
实际上，我们需要更肛门
关于如何确保我们不要滥用

844
00:37:33,520 --> 00:37:35,330
无效的值，如空。

845
00:37:35,330 --> 00:37:36,440
>> 所以我只是去检查。

846
00:37:36,440 --> 00:37:41,490
如果s不等于空，T不
等于空，这意味着我们确定。

847
00:37:41,490 --> 00:37:44,460
获取字符串没有搞砸得到
无论是这些字符串。

848
00:37:44,460 --> 00:37:51,270
你也许可以猜到现在，
STR CMP也许可以做到吗？

849
00:37:51,270 --> 00:37:52,000
字符串比较。

850
00:37:52,000 --> 00:37:55,470
>> 所以，如果你已经在Java程序之前，
这是像equals方法

851
00:37:55,470 --> 00:37:56,490
string类。

852
00:37:56,490 --> 00:37:57,890
但是，对于那些你们谁没有
编程之前，

853
00:37:57,890 --> 00:37:59,320
这仅仅是一个C函数。

854
00:37:59,320 --> 00:38:02,180
它发生在
文件名为​​string.h中。

855
00:38:02,180 --> 00:38:03,830
这就是它的声明。

856
00:38:03,830 --> 00:38:05,110
>> 和字符串比较 - 

857
00:38:05,110 --> 00:38:07,530
我居然忘记了它的用法，
但从来没有介意。

858
00:38:07,530 --> 00:38:10,470
回想一下，我们可以做
人，搅匀比较。

859
00:38:10,470 --> 00:38:12,590
这是怎么回事，弹出
Linux程序员手册。

860
00:38:12,590 --> 00:38:14,060
和它的，坦率地说，有点神秘。

861
00:38:14,060 --> 00:38:15,270
但我可以在这里看到，没错。

862
00:38:15,270 --> 00:38:17,570
我必须包括string.h中。

863
00:38:17,570 --> 00:38:20,590
>> 这里说下描述，“
字符串比较功能比较

864
00:38:20,590 --> 00:38:24,560
两个字符串S1和S2。而S1
和S2是显然是两个

865
00:38:24,560 --> 00:38:26,120
参数传入​​。

866
00:38:26,120 --> 00:38:28,650
我真的不记得什么
const是，但现在发现 - 

867
00:38:28,650 --> 00:38:31,480
你可能已经看到了这一点时，已经
你使用的手册页，如果你

868
00:38:31,480 --> 00:38:32,390
拥有这一切 - 

869
00:38:32,390 --> 00:38:36,220
字符星级只是代名词
字符串。

870
00:38:36,220 --> 00:38:40,440
>> 因此，比较这两个字符串S1和
S2，并返回一个整数减

871
00:38:40,440 --> 00:38:44,930
于或等于或大于零的
如果发现S1，分别是

872
00:38:44,930 --> 00:38:47,450
小于或匹配，或者
大于S2。

873
00:38:47,450 --> 00:38:51,220
这只是一个非常复杂的方式说
字符串比较回报

874
00:38:51,220 --> 00:38:55,760
零，如果两个字符串，可以直观地
相同的字符

875
00:38:55,760 --> 00:38:57,120
对于字符。

876
00:38:57,120 --> 00:38:59,970
>> 它返回一个负数，如果
，按字母顺序排列，应该是

877
00:38:59,970 --> 00:39:01,010
来之前吨。

878
00:39:01,010 --> 00:39:05,300
或者返回一个正数，如果
s是应该来后t

879
00:39:05,300 --> 00:39:06,170
按字母顺序排列。

880
00:39:06,170 --> 00:39:08,360
因此，这个简单的函数，可以
例如，排序

881
00:39:08,360 --> 00:39:09,770
一大堆的话吗？

882
00:39:09,770 --> 00:39:13,984
>> 因此，在这个新版本中，我要去
继续前进，做比较。

883
00:39:13,984 --> 00:39:15,750
点斜线比较。

884
00:39:15,750 --> 00:39:18,030
我会全部小写键入打招呼。

885
00:39:18,030 --> 00:39:20,300
我要键入你好的
再在全部小写。

886
00:39:20,300 --> 00:39:23,340
幸好现在实现
我输入了同样的事情。

887
00:39:23,340 --> 00:39:27,520
>> 同时，如果我输入打招呼较低
情况和Hello大写

888
00:39:27,520 --> 00:39:29,710
对它们进行比较，我打
不同的事情。

889
00:39:29,710 --> 00:39:32,530
不仅是因​​为地址
不同的，但我们比较

890
00:39:32,530 --> 00:39:35,350
不同的字符一遍又一遍。

891
00:39:35,350 --> 00:39:37,320
>> 那么让我们去修复一个
现在其他问题。

892
00:39:37,320 --> 00:39:41,590
让我打开一个版本
复制，现在解决

893
00:39:41,590 --> 00:39:42,900
这个问题如下。

894
00:39:42,900 --> 00:39:45,650
而这个人会看
更复杂一点。

895
00:39:45,650 --> 00:39:49,320
但是，如果你想想什么问题，我们
需要解决，希望这将是

896
00:39:49,320 --> 00:39:51,870
现在只是一瞬间清除。

897
00:39:51,870 --> 00:39:57,280
>> 因此，这第一线，烧焦启动T，在
通俗地说可能有人提出

898
00:39:57,280 --> 00:39:59,450
这条线在这里是指什么？

899
00:39:59,450 --> 00:40:01,050
字符明星T，这样做是什么？

900
00:40:01,050 --> 00:40:06,660

901
00:40:06,660 --> 00:40:07,210
>> 好。

902
00:40:07,210 --> 00:40:09,500
创建一个指针，指向某些
现货在内存中。

903
00:40:09,500 --> 00:40:10,930
让我提炼它一点点。

904
00:40:10,930 --> 00:40:17,180
声明一个变量将存储
一些字符在内存中的地址，只是

905
00:40:17,180 --> 00:40:18,480
要适当多一点。

906
00:40:18,480 --> 00:40:21,210
>> 好了，现在在右手侧，我
从来没有见过这些功能之一

907
00:40:21,210 --> 00:40:22,660
之前，malloc的。

908
00:40:22,660 --> 00:40:26,980
但是，什么意思呢？

909
00:40:26,980 --> 00:40:28,050
分配的内存。

910
00:40:28,050 --> 00:40:29,410
内存分配。

911
00:40:29,410 --> 00:40:33,050
>> 因此，原来，到现在为止，我们
还没有真正有强大的方式

912
00:40:33,050 --> 00:40:36,210
要求的操作系统，
给我一些内存。

913
00:40:36,210 --> 00:40:39,980
相反，我们现在有一个函数调用
malloc的正是这么做的。

914
00:40:39,980 --> 00:40:42,960
尽管这是一个有点
现在分心，注意到，在

915
00:40:42,960 --> 00:40:46,200
两个括号之间是
只是要一个数字。

916
00:40:46,200 --> 00:40:48,510
我输入问题
商标可以是一个数字。

917
00:40:48,510 --> 00:40:51,020
>> 而且这个数字意味着，
给我10个字节。

918
00:40:51,020 --> 00:40:52,320
给我20个字节。

919
00:40:52,320 --> 00:40:53,820
给我100个字节。

920
00:40:53,820 --> 00:40:56,500
和malloc将尽最大努力
要求操作系统 - 

921
00:40:56,500 --> 00:40:57,630
Linux中，在这种情况下 - 

922
00:40:57,630 --> 00:40:59,630
哎，他们的100个字节
可用的RAM？

923
00:40:59,630 --> 00:41:04,320
如果是这样，我返回这些字节
返回的地址中的哪一种

924
00:41:04,320 --> 00:41:06,610
这些字节，也许？

925
00:41:06,610 --> 00:41:07,610
第一个。

926
00:41:07,610 --> 00:41:10,460
>> 因此，这里太 - 这是占主导地位
在C中，任何时候你

927
00:41:10,460 --> 00:41:11,680
处理地址？

928
00:41:11,680 --> 00:41:15,830
你几乎总是处理
第一个这样的地址，不管有多大

929
00:41:15,830 --> 00:41:19,490
你被一块内存
传回，可以这么说。

930
00:41:19,490 --> 00:41:20,880
>> 因此，让我们在这里潜水。

931
00:41:20,880 --> 00:41:23,940
我想怎么分配
多少个字节，到底是什么？

932
00:41:23,940 --> 00:41:24,080
嘛。

933
00:41:24,080 --> 00:41:26,090
字符串的长度为S  - 让
做一个具体的例子。

934
00:41:26,090 --> 00:41:30,700
如果你好s是，H-E-L-L-O，什么是
字符串的长度，显然？

935
00:41:30,700 --> 00:41:32,010
因此，它是五。

936
00:41:32,010 --> 00:41:34,590
但我在做加1，为什么呢？

937
00:41:34,590 --> 00:41:37,700
为什么我要六个字节
而不是五个？

938
00:41:37,700 --> 00:41:38,790
空字符。

939
00:41:38,790 --> 00:41:41,210
>> 我不想离开这
特殊的空字符。

940
00:41:41,210 --> 00:41:45,160
因为如果我做一个副本您好
只是做H-E-L-L-O，但我不把

941
00:41:45,160 --> 00:41:50,160
特别字符，电脑
可能没有，一次偶然的机会，一个反斜杠

942
00:41:50,160 --> 00:41:51,730
零对我有。

943
00:41:51,730 --> 00:41:55,570
所以，如果我试图找出
副本的长度，我可能会认为

944
00:41:55,570 --> 00:41:59,360
这是20个字符长，或者一百万
如果我只是从来没有发生字符

945
00:41:59,360 --> 00:42:01,050
打反斜线零。

946
00:42:01,050 --> 00:42:05,780
>> 因此，我们需要6个字节来存储
H-E-L-L-O，反斜杠零。

947
00:42:05,780 --> 00:42:07,870
然后，这仅仅是
是超肛门。

948
00:42:07,870 --> 00:42:10,700
假设，我忘了什么
一个char的大小。

949
00:42:10,700 --> 00:42:12,020
我们一直说这是一个字节。

950
00:42:12,020 --> 00:42:12,860
它通常是。

951
00:42:12,860 --> 00:42:15,425
从理论上讲，它可能是一些
不同，在不同的Mac或

952
00:42:15,425 --> 00:42:16,250
不同的PC。

953
00:42:16,250 --> 00:42:19,650
>> 因此，原来有这个操作符
叫的sizeof，如果你传递给它

954
00:42:19,650 --> 00:42:22,680
名称的数据类型 - 像
char或int或浮 - 

955
00:42:22,680 --> 00:42:26,930
它会告诉你，动态的，有多少
字节一个字符占用

956
00:42:26,930 --> 00:42:28,090
特定的计算机。

957
00:42:28,090 --> 00:42:31,360
>> 因此，这是有效的只是
好像是说次1或

958
00:42:31,360 --> 00:42:32,440
时间什么都没有。

959
00:42:32,440 --> 00:42:36,340
但我这样做只是为了超级肛门，
，一个char以防万一不同

960
00:42:36,340 --> 00:42:40,610
在您的计算机与矿山，这样一来
数学总是要退房。

961
00:42:40,610 --> 00:42:43,720
>> 最后，这里我检查null
这始终是很好的做法 - 再

962
00:42:43,720 --> 00:42:44,920
任何时候，我们正在处理的指针。

963
00:42:44,920 --> 00:42:47,520
如果malloc是不是能够给
我6轮空 - 这是

964
00:42:47,520 --> 00:42:49,210
可能性不大，但以防万一 - 

965
00:42:49,210 --> 00:42:50,730
马上返回一个。

966
00:42:50,730 --> 00:42:53,290
而现在，接着复制
的字符串，如下所示。

967
00:42:53,290 --> 00:42:57,240
这是熟悉的语法，
尽管在不同的角色。

968
00:42:57,240 --> 00:43:01,210
>> 我要继续前进，让字符串
s的长度，并将其存储在n。

969
00:43:01,210 --> 00:43:06,620
然后，我要循环从i等于
零和包括正，

970
00:43:06,620 --> 00:43:08,410
大于或等于。

971
00:43:08,410 --> 00:43:13,540
因此，在每次迭代中，我把
在第i个字符的第i个

972
00:43:13,540 --> 00:43:15,380
字符的t。

973
00:43:15,380 --> 00:43:18,190
>> 所以，到底发生了什么，上下方
这里的引擎盖？

974
00:43:18,190 --> 00:43:22,140
好吧，如果这样，例如，S  - 

975
00:43:22,140 --> 00:43:26,400
我已经输入字H-E-L-L-O
并有一个反斜杠零。

976
00:43:26,400 --> 00:43:29,020
再次强调，这是这里的指点。

977
00:43:29,020 --> 00:43:30,830
这里现在是t。

978
00:43:30,830 --> 00:43:34,860
>> 这是现在指向
副本内存，对不对？

979
00:43:34,860 --> 00:43:37,340
malloc函数有给我一个完整
的内存块。

980
00:43:37,340 --> 00:43:41,440
我不知道最初是什么
在所有这些位置。

981
00:43:41,440 --> 00:43:44,340
所以我打算把它们看作
一大堆问号。

982
00:43:44,340 --> 00:43:50,190
>> 但只要我一开始从零循环
向上穿过的长度，吨

983
00:43:50,190 --> 00:43:52,790
支架零和t支架1  - 

984
00:43:52,790 --> 00:43:55,080
我会立即把这个
上的开销 - 

985
00:43:55,080 --> 00:44:04,190
零吨支架和s支架零的意思
我要复制

986
00:44:04,190 --> 00:44:09,875
迭代ħ在这里，E-L-L-O。
另外，因为我做的加

987
00:44:09,875 --> 00:44:12,370
，反斜线零。

988
00:44:12,370 --> 00:44:19,060
>> 所以现在比较1.C的情况下，
在年底，如果我打印出来的

989
00:44:19,060 --> 00:44:24,760
资本的t，我们应该
看到，s是不变的。

990
00:44:24,760 --> 00:44:26,090
让我现在继续做这个。

991
00:44:26,090 --> 00:44:28,630
所以COPY1。

992
00:44:28,630 --> 00:44:30,860
点斜线副本1。

993
00:44:30,860 --> 00:44:33,670
我打招呼，输入要输入。

994
00:44:33,670 --> 00:44:37,430
现在注意到，只有副本
已被资本化。

995
00:44:37,430 --> 00:44:40,890
因为我确实有两个
内存块。

996
00:44:40,890 --> 00:44:44,390
>> 不幸的是，你可以做一些漂亮的
这里坏，相当危险的事情。

997
00:44:44,390 --> 00:44:49,290
让我拉起一个例子现在在这里，
为我们提供了一个例子，几个

998
00:44:49,290 --> 00:44:51,540
不同的线路。

999
00:44:51,540 --> 00:44:56,040
所以只是凭直觉在这里，第一行
码，诠释星级的x，正在申报

1000
00:44:56,040 --> 00:44:57,340
一个变量x。

1001
00:44:57,340 --> 00:44:58,810
，什么是数据类型
该变量？

1002
00:44:58,810 --> 00:45:01,820

1003
00:45:01,820 --> 00:45:04,290
该变量的数据类型是什么？

1004
00:45:04,290 --> 00:45:06,980
这不是吊人胃口。

1005
00:45:06,980 --> 00:45:08,350
>> 的数据类型为int的明星。

1006
00:45:08,350 --> 00:45:12,600
那么，到底是什么意思呢？ X的
一个int存储地址。

1007
00:45:12,600 --> 00:45:13,520
就这么简单。

1008
00:45:13,520 --> 00:45:16,220
Y为要存储
一个int地址。

1009
00:45:16,220 --> 00:45:18,390
第三行是什么
代码做什么呢？

1010
00:45:18,390 --> 00:45:21,850
它的分配多少
字节，最有可能？

1011
00:45:21,850 --> 00:45:22,350
四。

1012
00:45:22,350 --> 00:45:25,460
由于一个int的大小是
一般四，四的malloc给

1013
00:45:25,460 --> 00:45:29,950
我回了一大块地址
内存的字节的第一个是

1014
00:45:29,950 --> 00:45:32,110
现在存储在x。

1015
00:45:32,110 --> 00:45:34,410
>> 现在，我们正在一点点迅速。

1016
00:45:34,410 --> 00:45:35,760
星x表示什么？

1017
00:45:35,760 --> 00:45:38,480

1018
00:45:38,480 --> 00:45:42,590
这意味着进入该地址
并提出有什么号码？

1019
00:45:42,590 --> 00:45:43,870
将有数字42。

1020
00:45:43,870 --> 00:45:47,590
星y表示在y
把有13号。

1021
00:45:47,590 --> 00:45:48,600
>> 但是且慢。

1022
00:45:48,600 --> 00:45:51,640
y中的那一刻是什么？

1023
00:45:51,640 --> 00:45:54,950
什么地址为y存储？

1024
00:45:54,950 --> 00:45:55,770
我们不知道，对不对？

1025
00:45:55,770 --> 00:45:59,230
我们从来没有一次使用赋值
运营商涉及Ÿ。

1026
00:45:59,230 --> 00:46:03,370
所以y在第二行的声明
代码只是一些垃圾值，大

1027
00:46:03,370 --> 00:46:04,760
问号可以这么说。

1028
00:46:04,760 --> 00:46:07,230
它可以指向随机
在内存中的任何事情，这

1029
00:46:07,230 --> 00:46:08,340
普遍不好。

1030
00:46:08,340 --> 00:46:13,540
>> 所以只要我们在那里打线，
星级y等于13，坏的东西，

1031
00:46:13,540 --> 00:46:17,220
太差的东西大约是
发生宾基。

1032
00:46:17,220 --> 00:46:25,810
因此，让我们看看会发生什么结束
发生在这一分钟宾基

1033
00:46:25,810 --> 00:46:26,200
左右的样子。

1034
00:46:26,200 --> 00:46:26,490
>> [视频回放]

1035
00:46:26,490 --> 00:46:26,745
>> 嘿，宾基。

1036
00:46:26,745 --> 00:46:27,000
醒来。

1037
00:46:27,000 --> 00:46:29,296
它的时间的指针乐趣。

1038
00:46:29,296 --> 00:46:30,680
>>  - 那是什么？

1039
00:46:30,680 --> 00:46:31,980
了解指针？

1040
00:46:31,980 --> 00:46:34,010
哦，满载而归。

1041
00:46:34,010 --> 00:46:37,220
>> 好吧，上手，我想我们
将需要一对夫妇的指针。

1042
00:46:37,220 --> 00:46:37,930
>>  - 确定。

1043
00:46:37,930 --> 00:46:41,650
该代码分配两个指针
它可以指向整数。

1044
00:46:41,650 --> 00:46:43,760
>> OK，好了，我看到两个指针。

1045
00:46:43,760 --> 00:46:45,850
但他们似乎没有要
指向任何东西。

1046
00:46:45,850 --> 00:46:46,490
>> 这是正确的。

1047
00:46:46,490 --> 00:46:48,630
最初，指针不
指向任何东西。

1048
00:46:48,630 --> 00:46:51,700
它们指向的东西被称为
指针对象，设置起来是一个

1049
00:46:51,700 --> 00:46:52,850
单独的步骤。

1050
00:46:52,850 --> 00:46:53,740
>> 哦，对，没错。

1051
00:46:53,740 --> 00:46:54,500
我知道。

1052
00:46:54,500 --> 00:46:56,270
指针对象是分开的。

1053
00:46:56,270 --> 00:46:58,553
那么你是怎么分配一个pointee的？

1054
00:46:58,553 --> 00:46:59,480
>>  - 确定。

1055
00:46:59,480 --> 00:47:03,707
那么，这个代码分配一个新的整数
指针对象，而这部分集合X

1056
00:47:03,707 --> 00:47:05,520
指向它。

1057
00:47:05,520 --> 00:47:06,760
>> 嘿，这看起来更好。

1058
00:47:06,760 --> 00:47:08,520
所以，让它做点事。

1059
00:47:08,520 --> 00:47:09,530
>>  - 确定。

1060
00:47:09,530 --> 00:47:14,110
我会取消引用指针x到存储
42号及其指针。

1061
00:47:14,110 --> 00:47:17,660
对于这一招，我需要我的魔法
魔杖提领。

1062
00:47:17,660 --> 00:47:20,695
>> 你的魔杖提领？

1063
00:47:20,695 --> 00:47:22,632
呃，这是伟大的。

1064
00:47:22,632 --> 00:47:24,620
>> 这是什么样的代码看起来像。

1065
00:47:24,620 --> 00:47:27,526
我刚刚设立的数量，以及 - 

1066
00:47:27,526 --> 00:47:28,250
>> 嘿，看。

1067
00:47:28,250 --> 00:47:29,680
就这样吧。

1068
00:47:29,680 --> 00:47:34,520
这样算下来，反引用X服从
箭头访问及其指针。

1069
00:47:34,520 --> 00:47:36,690
在这种情况下，在那里存储42。

1070
00:47:36,690 --> 00:47:40,890
嘿，尝试用它来存储数字
13通过其他指针，Y。

1071
00:47:40,890 --> 00:47:42,125
>>  - 确定。

1072
00:47:42,125 --> 00:47:46,810
我就在这里为y，并且
13号成立。

1073
00:47:46,810 --> 00:47:50,890
然后拿魔杖
提领，只是 - 

1074
00:47:50,890 --> 00:47:52,430
哇！

1075
00:47:52,430 --> 00:47:53,030
>> 哦，嘿嘿。

1076
00:47:53,030 --> 00:47:54,610
这没有奏效。

1077
00:47:54,610 --> 00:47:58,200
宾基说，我不认为
提领y是一个不错的主意，

1078
00:47:58,200 --> 00:48:01,370
因为设立的pointee，
是一个独立的步骤。

1079
00:48:01,370 --> 00:48:03,460
我不认为我们曾经做到了。

1080
00:48:03,460 --> 00:48:03,810
>> 嗯。

1081
00:48:03,810 --> 00:48:05,160
好点。

1082
00:48:05,160 --> 00:48:07,410
>> 是的，我们分配的指针y。

1083
00:48:07,410 --> 00:48:10,045
但是，我们从来没有将其设置为
指向的pointee。

1084
00:48:10,045 --> 00:48:10,490
>> 嗯。

1085
00:48:10,490 --> 00:48:12,170
非常细心。

1086
00:48:12,170 --> 00:48:13,790
>> 嘿，你看
好，宾基。

1087
00:48:13,790 --> 00:48:16,920
你可以解决它，使y点
到相同的指针对象为x？

1088
00:48:16,920 --> 00:48:17,810
>>  - 当然。

1089
00:48:17,810 --> 00:48:20,300
我会用我的魔杖
指针赋值。

1090
00:48:20,300 --> 00:48:22,240
>> -IS将是一个
像以前一样的问题？

1091
00:48:22,240 --> 00:48:22,665
>> 没有。

1092
00:48:22,665 --> 00:48:24,300
这不触摸指针对象。

1093
00:48:24,300 --> 00:48:27,880
它只是改变了一个指针指向
作为另一个同样的事情。

1094
00:48:27,880 --> 00:48:28,970
>> 哦，我明白了。

1095
00:48:28,970 --> 00:48:31,730
y点为x到同一个地方。

1096
00:48:31,730 --> 00:48:32,450
所以等待。

1097
00:48:32,450 --> 00:48:33,490
现在y的固定。

1098
00:48:33,490 --> 00:48:34,630
它有一个指针对象。

1099
00:48:34,630 --> 00:48:36,520
所以，你可以尝试魔杖
再次提领

1100
00:48:36,520 --> 00:48:39,200
送13以上。

1101
00:48:39,200 --> 00:48:39,840
>>  - 确定。

1102
00:48:39,840 --> 00:48:41,570
这里去。

1103
00:48:41,570 --> 00:48:42,870
>> 嘿，看看那。

1104
00:48:42,870 --> 00:48:44,320
现在提领工程对y。

1105
00:48:44,320 --> 00:48:47,020
而且，由于指针共享
那一个指针对象，他们

1106
00:48:47,020 --> 00:48:48,585
看到13。

1107
00:48:48,585 --> 00:48:49,040
>> 呀。

1108
00:48:49,040 --> 00:48:49,670
共享。

1109
00:48:49,670 --> 00:48:50,380
不管。

1110
00:48:50,380 --> 00:48:52,290
所以我们现在去开关的地方吗？

1111
00:48:52,290 --> 00:48:52,970
>> 哦，看。

1112
00:48:52,970 --> 00:48:54,150
我们没时间了。

1113
00:48:54,150 --> 00:48:55,200
>> 但是 - 

1114
00:48:55,200 --> 00:48:57,060
>> 只要记住三个
指针规则。

1115
00:48:57,060 --> 00:49:00,100
数一，基本结构
就是你有一个指针。

1116
00:49:00,100 --> 00:49:02,170
它指向指针对象。

1117
00:49:02,170 --> 00:49:04,160
但是，指针和指针对象
是分开的。

1118
00:49:04,160 --> 00:49:06,460
常见的错误是
设立一个指针，但到

1119
00:49:06,460 --> 00:49:08,540
忘了给定的指针对象。

1120
00:49:08,540 --> 00:49:12,460
>> 两个指针引用开始
上面的指针和如下

1121
00:49:12,460 --> 00:49:14,570
箭头的访问及其指针。

1122
00:49:14,570 --> 00:49:18,640
正如我们都知道，这只是工作，如果有
指针对象，回来

1123
00:49:18,640 --> 00:49:19,790
排除头号。

1124
00:49:19,790 --> 00:49:23,670
>> 三，需要指针赋值
一个指针，它指向的变化

1125
00:49:23,670 --> 00:49:25,850
作为另一个指针的指针对象。

1126
00:49:25,850 --> 00:49:27,840
因此，在转让之后，
两个指针

1127
00:49:27,840 --> 00:49:29,430
指向相同的pointee。

1128
00:49:29,430 --> 00:49:31,600
有时候，这就是所谓的共享。

1129
00:49:31,600 --> 00:49:33,430
而这一切就是这么简单，真的。

1130
00:49:33,430 --> 00:49:33,840
再见了。

1131
00:49:33,840 --> 00:49:34,300
>> [END视频播放]

1132
00:49:34,300 --> 00:49:36,940
>> 国宝马兰：因此，更多的三分球，
更下周宾基上。

1133
00:49:36,940 --> 00:49:38,190
我们会看到你在星期一。

1134
00:49:38,190 --> 00:49:42,187