1
00:00:00,000 --> 00:00:06,030
>> [音乐播放]

2
00:00:06,030 --> 00:00:08,390
>> DOUG LLOYD：指针，我们在这里。

3
00:00:08,390 --> 00:00:11,080
这可能会
是最困难的话题

4
00:00:11,080 --> 00:00:12,840
我们在这里讨论的CS50。

5
00:00:12,840 --> 00:00:15,060
如果你读过
关于指针什么

6
00:00:15,060 --> 00:00:19,080
之前，你可能会有点
恐吓进入这部影片。

7
00:00:19,080 --> 00:00:21,260
这是真的指针
不要让你的能力

8
00:00:21,260 --> 00:00:23,740
到也许搞砸了
当你很厉害

9
00:00:23,740 --> 00:00:27,450
与变量和数据的工作，
并导致程序崩溃。

10
00:00:27,450 --> 00:00:30,490
但他们实际上是非常有用的
他们让我们一个真正伟大的方式

11
00:00:30,490 --> 00:00:33,340
通过数据备份和
第四功能之间，

12
00:00:33,340 --> 00:00:35,490
我们是否则无法做到。

13
00:00:35,490 --> 00:00:37,750
>> 还等什么，我们真的
想在这里做的是火车

14
00:00:37,750 --> 00:00:41,060
你有很好的指针纪律，所以
你可以有效地使用指针

15
00:00:41,060 --> 00:00:43,850
让你的程序要好得多。

16
00:00:43,850 --> 00:00:48,220
正如我所说的三分球给我们一个不同的
办法函数之间传递数据。

17
00:00:48,220 --> 00:00:50,270
现在，如果你还记得
较早的视频，当

18
00:00:50,270 --> 00:00:53,720
我们谈论
变量的作用域，我提到

19
00:00:53,720 --> 00:01:00,610
所有我们传递的数据
在C函数是按值传递。

20
00:01:00,610 --> 00:01:03,070
我可能没有使用的
看，我的意思有

21
00:01:03,070 --> 00:01:07,170
是我们传递数据的副本。

22
00:01:07,170 --> 00:01:12,252
当我们通过一个变量的函数，
我们没有真正传递变量

23
00:01:12,252 --> 00:01:13,210
的功能，对不对？

24
00:01:13,210 --> 00:01:17,670
我们传递的一个副本
该数据的功能。

25
00:01:17,670 --> 00:01:20,760
该函数做的事情会
并计算出一定的价值，

26
00:01:20,760 --> 00:01:23,180
也许大家使用该值
当它给它回来。

27
00:01:23,180 --> 00:01:26,700
>> 有一个例外
这条规则按值传递的，

28
00:01:26,700 --> 00:01:31,210
我们会回来的是什么
有一点后来在这部影片。

29
00:01:31,210 --> 00:01:34,880
如果我们用指针来代替
使用变量的，

30
00:01:34,880 --> 00:01:38,180
或者使用替代的变量
本身或变量的副本，

31
00:01:38,180 --> 00:01:43,790
我们现在可以通过周围的变量
之间以不同的方式的功能。

32
00:01:43,790 --> 00:01:46,550
这意味着，如果我们使
在一种功能的变化，

33
00:01:46,550 --> 00:01:49,827
这一变化实际上会
在不同的功能的影响。

34
00:01:49,827 --> 00:01:52,160
再次，这是一件
我们以前无法做到，

35
00:01:52,160 --> 00:01:56,979
如果你曾经尝试交换
在函数两个变量的值，

36
00:01:56,979 --> 00:01:59,270
你已经注意到了这个问题
排序攀升，对不对？

37
00:01:59,270 --> 00:02:04,340
>> 如果我们想交换的X和Y，和我们
他们通过一个叫交换功能，

38
00:02:04,340 --> 00:02:08,680
该函数内部交换
变量做交换价值。

39
00:02:08,680 --> 00:02:12,600
一变二，二变
，但我们实际上并不

40
00:02:12,600 --> 00:02:16,890
在原有的任何改变
功能，在呼叫者。

41
00:02:16,890 --> 00:02:19,550
因为我们不能，我们只
与他们一起工作的副本。

42
00:02:19,550 --> 00:02:24,760
随着指针虽然，我们可以
实际上通过X和Y的一个函数。

43
00:02:24,760 --> 00:02:26,960
这个函数可以做
一些与他们。

44
00:02:26,960 --> 00:02:29,250
而那些变量的值
其实可以改变。

45
00:02:29,250 --> 00:02:33,710
所以这是在相当长的变化
我们处理数据的能力。

46
00:02:33,710 --> 00:02:36,100
>> 在我们深入
三分球，我认为这是值得

47
00:02:36,100 --> 00:02:38,580
花几分钟到
回到基础在这里。

48
00:02:38,580 --> 00:02:41,000
同时你也可以看看如何
计算机存储作品

49
00:02:41,000 --> 00:02:45,340
因为这两个科目会
实际上是非常相关的。

50
00:02:45,340 --> 00:02:48,480
正如你可能知道，
您的计算机系统

51
00:02:48,480 --> 00:02:51,310
你有一个硬盘驱动器或
也许是固态硬盘，

52
00:02:51,310 --> 00:02:54,430
某种形式的文件存储位置。

53
00:02:54,430 --> 00:02:57,950
它通常某处
250千兆字节附近

54
00:02:57,950 --> 00:02:59,810
也许到了几个TB的现在。

55
00:02:59,810 --> 00:03:02,270
而这也正是所有的
文件最终活，

56
00:03:02,270 --> 00:03:04,870
即使您的计算机关闭
关闭，你可以将其重新打开

57
00:03:04,870 --> 00:03:09,190
你会发现你的文件存在
再次当您重新启动您的系统。

58
00:03:09,190 --> 00:03:14,820
但是磁盘驱动器，像一个硬盘驱动器，
一个硬盘驱动器或固态硬盘，固态硬盘，

59
00:03:14,820 --> 00:03:16,050
只是存储空间。

60
00:03:16,050 --> 00:03:20,400
>> 我们实际上不能做任何与
该数据是在硬盘，

61
00:03:20,400 --> 00:03:22,080
或固态驱动器。

62
00:03:22,080 --> 00:03:24,950
为了真正改变
数据或移动它，

63
00:03:24,950 --> 00:03:28,800
我们必须把它移到
RAM的随机存取存储器。

64
00:03:28,800 --> 00:03:31,170
现在RAM，你有很多
少在您的计算机。

65
00:03:31,170 --> 00:03:34,185
您可能有某处
512兆附近

66
00:03:34,185 --> 00:03:38,850
如果你有一个旧的电脑，
到也许两个，四个，八个，十六

67
00:03:38,850 --> 00:03:41,820
甚至可能是一点点
此外，4GB的内存。

68
00:03:41,820 --> 00:03:46,390
所以这是非常小，但是这
其中所有的易失性数据的存在。

69
00:03:46,390 --> 00:03:48,270
这就是我们可以改变的事情。

70
00:03:48,270 --> 00:03:53,350
但是，当我们把自己的电脑关闭，
所有在RAM中的数据被破坏。

71
00:03:53,350 --> 00:03:57,150
>> 所以这就是为什么我们需要硬盘
对于它的更稳定的位置，

72
00:03:57,150 --> 00:03:59,720
这样它exists-它会
是真的不好，如果我们每次都

73
00:03:59,720 --> 00:04:03,310
把我们的电脑关闭，每
在我们的系统文件被抹杀。

74
00:04:03,310 --> 00:04:05,600
因此，我们的RAM里面工作。

75
00:04:05,600 --> 00:04:09,210
而每一次，我们正在谈论的
内存，相当多，在CS50，

76
00:04:09,210 --> 00:04:15,080
我们谈论的RAM，而不是硬盘。

77
00:04:15,080 --> 00:04:18,657
>> 所以，当我们搬东西到内存中，
它占用一定的空间。

78
00:04:18,657 --> 00:04:20,740
所有的数据类型的
我们一直在与

79
00:04:20,740 --> 00:04:23,480
采取了不同的
量的RAM空间。

80
00:04:23,480 --> 00:04:27,600
所以，每次创建一个整数
可变的，四个字节的存储器

81
00:04:27,600 --> 00:04:30,750
被搁置在RAM中，所以你
可以与整数工作。

82
00:04:30,750 --> 00:04:34,260
可以声明整数，
改变它，为它分配

83
00:04:34,260 --> 00:04:36,700
一个值10增加
由一个，等等等等。

84
00:04:36,700 --> 00:04:39,440
所有需要发生在
RAM，你会得到四个字节

85
00:04:39,440 --> 00:04:42,550
一起工作的每一个
整数创建的。

86
00:04:42,550 --> 00:04:45,410
>> 每个字符您
创建得到一个字节。

87
00:04:45,410 --> 00:04:48,160
这就是空间到底有多少是
存储一个字符需要的。

88
00:04:48,160 --> 00:04:51,310
每个浮动，一个真正的
数，得到四个字节

89
00:04:51,310 --> 00:04:53,390
除非它是一个双
精度浮点

90
00:04:53,390 --> 00:04:56,510
号，它可以让你
有更精确或多个数字

91
00:04:56,510 --> 00:04:59,300
小数点后
又不失精确，

92
00:04:59,300 --> 00:05:01,820
它占用八个字节的内存。

93
00:05:01,820 --> 00:05:06,730
长期多头，真正的大整数，
还占用八个字节的内存。

94
00:05:06,730 --> 00:05:09,000
有多少字节的内存
做字符串占用？

95
00:05:09,000 --> 00:05:12,990
好吧，让我们把一根钢钉这个问题
现在，但我们会回来的。

96
00:05:12,990 --> 00:05:17,350
>> 所以回到这一想法的内存
字节大小的单元的大数组。

97
00:05:17,350 --> 00:05:20,871
这真的是这样，它的
只是一个巨大的数组细胞，

98
00:05:20,871 --> 00:05:23,370
就像任何其他的阵列
你熟悉和观望，

99
00:05:23,370 --> 00:05:26,430
除了每一个元素是一个字节宽。

100
00:05:26,430 --> 00:05:30,030
就如同一个数组，
每个单元都有一个地址。

101
00:05:30,030 --> 00:05:32,120
数组中的每个元素
有索引，并且我们

102
00:05:32,120 --> 00:05:36,302
可以使用该索引做所谓的
阵列上随机接入。

103
00:05:36,302 --> 00:05:38,510
我们没有开始在
数组的开始，

104
00:05:38,510 --> 00:05:40,569
遍历每个
其单个元件

105
00:05:40,569 --> 00:05:41,860
找到我们所要寻找的。

106
00:05:41,860 --> 00:05:45,790
我们只能说，我想要得到的
第十五元件或100元件。

107
00:05:45,790 --> 00:05:49,930
而且你可以通过该号码
并得到你要寻找的价值。

108
00:05:49,930 --> 00:05:54,460
>> 同样每一个位置
在存储器都有一个地址。

109
00:05:54,460 --> 00:05:57,320
所以，你的记忆可能
是这个样子。

110
00:05:57,320 --> 00:06:01,420
这里是一个非常小的大块
存储器，这是20个字节的存储器。

111
00:06:01,420 --> 00:06:04,060
前20个字节，因为我
地址有在底部

112
00:06:04,060 --> 00:06:08,890
是0，1，2，3，依此
在一路攀升至19。

113
00:06:08,890 --> 00:06:13,190
而当我宣布变量，
当我开始与他们合作，

114
00:06:13,190 --> 00:06:15,470
该系统将要设置
我预留一些空间

115
00:06:15,470 --> 00:06:17,595
在该存储器中的工作
我的变量。

116
00:06:17,595 --> 00:06:21,610
所以我可以说，炭c等于资本
H.什么事情发生？

117
00:06:21,610 --> 00:06:23,880
那么该系统会
抛开对我来说一个字节。

118
00:06:23,880 --> 00:06:27,870
在这种情况下，它选择字节数目
四，在涉及到四个字节，

119
00:06:27,870 --> 00:06:31,310
并且它要保存
在信中有大写的H我。

120
00:06:31,310 --> 00:06:34,350
如果我那么说INT速度
极限等于65，这是

121
00:06:34,350 --> 00:06:36,806
要预留4
记忆对我来说字节。

122
00:06:36,806 --> 00:06:39,180
它是怎么回事治疗那些
四个字节作为一个单位

123
00:06:39,180 --> 00:06:41,305
因为我们正在努力
用在这里是一个整数。

124
00:06:41,305 --> 00:06:44,350
而且它要存储65在里面。

125
00:06:44,350 --> 00:06:47,000
>> 现在已经我有点
告诉你有点骗人的，

126
00:06:47,000 --> 00:06:50,150
对的，因为我们知道，
计算机二进制工作。

127
00:06:50,150 --> 00:06:53,100
他们不明白
一定就是一个大写的H是

128
00:06:53,100 --> 00:06:57,110
或者什么是65，他们只
懂二进制，零和的。

129
00:06:57,110 --> 00:06:59,000
所以实际上是什么
我们要存储在那里

130
00:06:59,000 --> 00:07:03,450
是不是字母H和65号，
而是二进制表示法

131
00:07:03,450 --> 00:07:06,980
物，它看起来
有点这样的事情。

132
00:07:06,980 --> 00:07:10,360
并且特别是在
整型变量的情况下，

133
00:07:10,360 --> 00:07:13,559
它不会只是吐了进去，
它不会把它当作四位一体

134
00:07:13,559 --> 00:07:15,350
字节块必然，
它实际上是

135
00:07:15,350 --> 00:07:19,570
把它当作四分之一的字节块，
这可能会是这个样子。

136
00:07:19,570 --> 00:07:22,424
即使这不是
完全正确要么，

137
00:07:22,424 --> 00:07:24,840
因为一种叫
字节排列顺序，这我们不

138
00:07:24,840 --> 00:07:26,965
要进入了，但
如果你好奇，

139
00:07:26,965 --> 00:07:29,030
你可以少读了
与大字节序。

140
00:07:29,030 --> 00:07:31,640
但为了这个说法，
为了这个视频，

141
00:07:31,640 --> 00:07:34,860
让我们姑且认为，在
事实上，如何在65号会

142
00:07:34,860 --> 00:07:36,970
在代表
每个内存的系统上，

143
00:07:36,970 --> 00:07:38,850
尽管这不是完全正确的。

144
00:07:38,850 --> 00:07:41,700
>> 但是，让我们实际上只是获得
去掉所有的二进制完全，

145
00:07:41,700 --> 00:07:44,460
而只是想想为：H
65，这是一个容易得多

146
00:07:44,460 --> 00:07:47,900
想想它像
，作为一个人。

147
00:07:47,900 --> 00:07:51,420
好吧，所以它似乎也可能是
有点乱了I've-我的系统

148
00:07:51,420 --> 00:07:55,130
没给我个字节5，6，7，
和图8来存储整数。

149
00:07:55,130 --> 00:07:58,580
还有一个理由，同样，这
我们不会进入的权利，但足够了

150
00:07:58,580 --> 00:08:00,496
我要说的是什么
计算机在这里做什么

151
00:08:00,496 --> 00:08:02,810
可能是它的一部分，一个很好的举措。

152
00:08:02,810 --> 00:08:06,020
给不给我的内存是
一定背靠背。

153
00:08:06,020 --> 00:08:10,490
虽然它现在打算怎么办呢
如果我想获得另一个字符串，

154
00:08:10,490 --> 00:08:13,080
所谓的姓，我想
把劳合社在那里。

155
00:08:13,080 --> 00:08:18,360
我将需要添加1
性格，那每个字母的

156
00:08:18,360 --> 00:08:21,330
将需要一个
字符，存储器的一个字节。

157
00:08:21,330 --> 00:08:26,230
所以，如果我可以把劳合社进入我的数组
这样的我很不好走，对不对？

158
00:08:26,230 --> 00:08:28,870
缺少了什么？

159
00:08:28,870 --> 00:08:31,840
>> 请记住，每一个字符串我们的工作
用C语言结尾反斜杠零，

160
00:08:31,840 --> 00:08:33,339
我们不能忽略，在这里，无论是。

161
00:08:33,339 --> 00:08:36,090
我们需要预留一个字节
内存来保存，所以我们

162
00:08:36,090 --> 00:08:39,130
知道什么时候我们的字符串已经结束。

163
00:08:39,130 --> 00:08:41,049
所以，再一次这样的安排
事物的方式

164
00:08:41,049 --> 00:08:42,799
出现在内存中的威力
有点乱，

165
00:08:42,799 --> 00:08:44,870
但它实际上是多么的
大多数系统的设计。

166
00:08:44,870 --> 00:08:48,330
要它们对齐的倍数
四，原因再次

167
00:08:48,330 --> 00:08:50,080
我们并不需要
进入现在。

168
00:08:50,080 --> 00:08:53,060
不过这一点，所以我只想说的
这三行代码后，

169
00:08:53,060 --> 00:08:54,810
这是记忆是什么样子。

170
00:08:54,810 --> 00:08:58,930
如果我需要的存储位置
4，8，和12来保存我的数据，

171
00:08:58,930 --> 00:09:01,100
这是我的记忆是什么样子。

172
00:09:01,100 --> 00:09:04,062
>> 而就特别
迂腐这里，当

173
00:09:04,062 --> 00:09:06,020
我们谈论的记忆
地址我们通常

174
00:09:06,020 --> 00:09:08,390
这样做使用十六进制符号。

175
00:09:08,390 --> 00:09:12,030
那么，我们为什么不把所有这些
从十进制转换为十六进制

176
00:09:12,030 --> 00:09:15,010
只是因为这是一般
我们如何参考存储器。

177
00:09:15,010 --> 00:09:17,880
因此，而不是为0〜
19，我们有什么是零

178
00:09:17,880 --> 00:09:20,340
x零到零X1三种。

179
00:09:20,340 --> 00:09:23,790
这些是20个字节的内存，我们
也或者我们正在寻找在这个图片

180
00:09:23,790 --> 00:09:25,540
就在这儿。

181
00:09:25,540 --> 00:09:29,310
>> 因此，所有的他这样说，让我们
从内存一步之遥了第二

182
00:09:29,310 --> 00:09:30,490
和背部的指针。

183
00:09:30,490 --> 00:09:32,420
这里最重要的
事情要记住

184
00:09:32,420 --> 00:09:34,070
当我们开始与指针的工作。

185
00:09:34,070 --> 00:09:36,314
指针是什么
不是一个地址了。

186
00:09:36,314 --> 00:09:38,230
我会再次因为说出来
它是那么重要，

187
00:09:38,230 --> 00:09:42,730
一个指针是什么
不是一个地址了。

188
00:09:42,730 --> 00:09:47,760
指针是地址位置
在内存中的变量住。

189
00:09:47,760 --> 00:09:52,590
知道它有望成为一个
稍微容易一些与他们合作。

190
00:09:52,590 --> 00:09:54,550
另一件事我喜欢
这样做是有排序

191
00:09:54,550 --> 00:09:58,510
的图表直观代表什么
发生与各行的代码。

192
00:09:58,510 --> 00:10:00,660
我们会做这样的夫妻
在指针的时候，

193
00:10:00,660 --> 00:10:03,354
当我们谈论动态
内存分配也是如此。

194
00:10:03,354 --> 00:10:06,020
因为我认为，这些图
可以是特别有帮助。

195
00:10:06,020 --> 00:10:09,540
>> 所以，如果我说，例如，时int k
在我的代码，发生了什么事？

196
00:10:09,540 --> 00:10:12,524
那么什么是主要发生在
我得到的内存预留给了我，

197
00:10:12,524 --> 00:10:14,690
但我甚至不喜欢
想想这样的，我

198
00:10:14,690 --> 00:10:16,300
喜欢去想它像一个盒子。

199
00:10:16,300 --> 00:10:20,090
我有一个盒子，它的
颜色为绿色，因为我

200
00:10:20,090 --> 00:10:21,750
可以把整数绿框。

201
00:10:21,750 --> 00:10:23,666
如果这是一个角色，我
可能有一个蓝色的盒子。

202
00:10:23,666 --> 00:10:27,290
但是，我总是说，如果我创建
一箱，可容纳整数

203
00:10:27,290 --> 00:10:28,950
该框为绿色。

204
00:10:28,950 --> 00:10:33,020
我拿一个永久性标记
而我写钾对的这一边。

205
00:10:33,020 --> 00:10:37,590
所以，我有一个盒子叫做K，
到了我可以把整数。

206
00:10:37,590 --> 00:10:41,070
所以当我说INT K，这是
在我的脑海会发生什么。

207
00:10:41,070 --> 00:10:43,140
如果我说k等于五，我在做什么？

208
00:10:43,140 --> 00:10:45,110
好吧，我把5
在框中，正确的。

209
00:10:45,110 --> 00:10:48,670
这是非常简单的，如果
我说INT K，创建一个盒子叫做K。

210
00:10:48,670 --> 00:10:52,040
如果我说k等于5，
投入五成箱。

211
00:10:52,040 --> 00:10:53,865
我希望这不是一个太大的飞跃。

212
00:10:53,865 --> 00:10:55,990
这就是事情走
有趣的一点，虽然。

213
00:10:55,990 --> 00:11:02,590
如果我说INT * PK，以及即使我不
知道这必然意味着，

214
00:11:02,590 --> 00:11:06,150
这显然​​是得到的东西
做的整数。

215
00:11:06,150 --> 00:11:08,211
所以，我要色
这个盒子的绿色十岁上下，

216
00:11:08,211 --> 00:11:10,210
我知道它有什么
做的整数，

217
00:11:10,210 --> 00:11:13,400
但它不是一个整数本身，
因为它是一个int明星。

218
00:11:13,400 --> 00:11:15,390
有一些稍微
不同吧。

219
00:11:15,390 --> 00:11:17,620
因此，一个整数的参与，
但除此之外，它的

220
00:11:17,620 --> 00:11:19,830
从没有太多不同
我们都在谈论。

221
00:11:19,830 --> 00:11:24,240
这是一个盒子，它有一个标签，
它穿着标签PK，

222
00:11:24,240 --> 00:11:27,280
而且它能够容纳
INT明星，不管那些。

223
00:11:27,280 --> 00:11:29,894
他们有事可做
与整数，清晰。

224
00:11:29,894 --> 00:11:31,060
这里的最后一行，虽然。

225
00:11:31,060 --> 00:11:37,650
如果我说PK =​​＆K，哇，
刚刚发生了什么，对不对？

226
00:11:37,650 --> 00:11:41,820
所以这个随机数，看似随意
数，被扔进了箱子那里。

227
00:11:41,820 --> 00:11:44,930
所有也就是说，是峰
得到k的地址。

228
00:11:44,930 --> 00:11:52,867
所以我会继续其中k内存里，
其地址，其字节的地址。

229
00:11:52,867 --> 00:11:55,200
我做的是我的话
该值就是我要去

230
00:11:55,200 --> 00:11:59,430
把我的箱子叫做PK的内部。

231
00:11:59,430 --> 00:12:02,080
而且，由于这些东西都是
指针，因为找

232
00:12:02,080 --> 00:12:04,955
在像无×字符串
八零Ç7四八

233
00:12:04,955 --> 00:12:07,790
两个零可能
意义不大。

234
00:12:07,790 --> 00:12:12,390
当我们通常想象的指针，
我们实际上这样做的指针。

235
00:12:12,390 --> 00:12:17,000
PK给我们的信息
我们需要找到K的内存。

236
00:12:17,000 --> 00:12:19,120
因此，基本上峰中有一个箭头。

237
00:12:19,120 --> 00:12:21,670
如果我们走的长度
那个箭头，想象

238
00:12:21,670 --> 00:12:25,280
这件事情，你可以走，如果我们
沿箭头的长度行走，

239
00:12:25,280 --> 00:12:29,490
在该箭头的最前端，我们
会发现在存储器中的位置

240
00:12:29,490 --> 00:12:31,390
其中k生活。

241
00:12:31,390 --> 00:12:34,360
这真的很重要
因为一旦我们知道其中k生活，

242
00:12:34,360 --> 00:12:37,870
我们可以开始与数据进行工作
里面的内存位置。

243
00:12:37,870 --> 00:12:40,780
虽然我们得到的蝇头
有点超前了现在。

244
00:12:40,780 --> 00:12:42,240
>> 那么，什么是指针？

245
00:12:42,240 --> 00:12:45,590
指针是它的一个数据项
值是一个存储器地址。

246
00:12:45,590 --> 00:12:49,740
这是零个八零的东西
怎么回事，这是一个内存地址。

247
00:12:49,740 --> 00:12:52,060
那是在存储器中的位置。

248
00:12:52,060 --> 00:12:55,080
和指针的类型
描述的那种

249
00:12:55,080 --> 00:12:56,930
数据，你会发现在
该存储器地址。

250
00:12:56,930 --> 00:12:58,810
因此，有整型明星的部分权利。

251
00:12:58,810 --> 00:13:03,690
如果我按照箭头，它的
要带领我的位置。

252
00:13:03,690 --> 00:13:06,980
而那个位置，我
会发现有在我的例子，

253
00:13:06,980 --> 00:13:08,240
是一个绿色的盒子。

254
00:13:08,240 --> 00:13:12,650
这是一个整数，这就是我
会发现如果我去这个地址。

255
00:13:12,650 --> 00:13:14,830
的数据类型
指针描述了

256
00:13:14,830 --> 00:13:17,936
你会发现在这个内存地址。

257
00:13:17,936 --> 00:13:19,560
因此，这里的很酷的事情虽然。

258
00:13:19,560 --> 00:13:25,090
指针允许我们传递
功能之间的变量。

259
00:13:25,090 --> 00:13:28,520
而实际上传递变量
而不是通过他们的副本。

260
00:13:28,520 --> 00:13:32,879
因为如果我们确切地知道在哪里
在存储器找到的变量，

261
00:13:32,879 --> 00:13:35,670
我们并不需要作出的副本
它，我们可以去到那个位置

262
00:13:35,670 --> 00:13:37,844
和与该可变工作。

263
00:13:37,844 --> 00:13:40,260
因此，在本质指针排序
做出一个计算机环境

264
00:13:40,260 --> 00:13:42,360
很多更像是真正的世界吧。

265
00:13:42,360 --> 00:13:44,640
>> 因此，这里是一个比喻。

266
00:13:44,640 --> 00:13:48,080
比方说，我有一个笔记本，
对了，这是充满了笔记。

267
00:13:48,080 --> 00:13:50,230
我希望你能更新。

268
00:13:50,230 --> 00:13:53,960
你是一个函数，
更新注意事项，正确的。

269
00:13:53,960 --> 00:13:56,390
在路上，我们一直
到目前为止的工​​作，有什么

270
00:13:56,390 --> 00:14:02,370
偏偏是你将采取我的笔记本，
你会去到复印店，

271
00:14:02,370 --> 00:14:06,410
你会做的影印件
笔记本的每一页。

272
00:14:06,410 --> 00:14:09,790
你会离开我的笔记本背
我的办公桌上时，你就大功告成了，

273
00:14:09,790 --> 00:14:14,600
你会去交掉的东西在我的
笔记本电脑，过时或错误的，

274
00:14:14,600 --> 00:14:19,280
然后你就会传回
我施乐页堆叠

275
00:14:19,280 --> 00:14:22,850
这是我的笔记本电脑与副本
你做了它的变化。

276
00:14:22,850 --> 00:14:27,040
在这一点上，它给我，
调用函数，作为呼叫者，

277
00:14:27,040 --> 00:14:30,582
决定把你的笔记和
它们整合回我的笔记本电脑。

278
00:14:30,582 --> 00:14:32,540
因此，有很多步骤
这里涉及到了吧。

279
00:14:32,540 --> 00:14:34,850
就像那岂不是更好
如果我只是说，哎，你

280
00:14:34,850 --> 00:14:38,370
更新我的笔记本
我，交给你我的笔记本，

281
00:14:38,370 --> 00:14:40,440
你拿的东西，
从字面上跨出来

282
00:14:40,440 --> 00:14:42,810
并更新我的笔记在我的笔记本。

283
00:14:42,810 --> 00:14:45,140
然后给我我的笔记本电脑了。

284
00:14:45,140 --> 00:14:47,320
这是什么样的
指针允许我们这样做，

285
00:14:47,320 --> 00:14:51,320
他们做出这样的环境中有很多
更像是我们如何运作的现实。

286
00:14:51,320 --> 00:14:54,640
>> 所有这样的权利是什么
一个指针，让我们来谈谈

287
00:14:54,640 --> 00:14:58,040
关于指针在C中是如何工作的，并
我们如何开始与他们合作。

288
00:14:58,040 --> 00:15:02,550
所以这是一个非常简单的指针
称为C中的空指针。

289
00:15:02,550 --> 00:15:04,830
空指针指向什么。

290
00:15:04,830 --> 00:15:08,310
这可能看起来像它的
其实不是一个非常有用的东西，

291
00:15:08,310 --> 00:15:10,500
但正如我们将看到一个
过了一会儿上，其实

292
00:15:10,500 --> 00:15:15,410
这个空指针存在
居然真的能派上用场。

293
00:15:15,410 --> 00:15:19,090
每当你创建一个指针，
你不将其值设置立即─

294
00:15:19,090 --> 00:15:21,060
设置的一个例子
其价值立即

295
00:15:21,060 --> 00:15:25,401
将一对夫妇滑回
在这里我说的PK等于＆K，

296
00:15:25,401 --> 00:15:28,740
PK获得K公司的地址，
我们将看到这意味着什么，

297
00:15:28,740 --> 00:15:32,990
我们将看到如何编码的shortly-
如果我们不将其值设置为某事

298
00:15:32,990 --> 00:15:35,380
马上有意义的，
你应该总是

299
00:15:35,380 --> 00:15:37,480
设置你的指针指向空。

300
00:15:37,480 --> 00:15:40,260
你应该把它设置为指向什么。

301
00:15:40,260 --> 00:15:43,614
>> 这比很大的不同
正要离开的价值，因为它是

302
00:15:43,614 --> 00:15:45,530
然后声明
指针，只是假设

303
00:15:45,530 --> 00:15:48,042
这是零，因为那是很少如此。

304
00:15:48,042 --> 00:15:50,000
所以，你应该总是设置
一个指针的值

305
00:15:50,000 --> 00:15:55,690
为空，如果你不将其值设置
立即有意义的事。

306
00:15:55,690 --> 00:15:59,090
您可以检查是否指针的值
为null使用等于运算符

307
00:15:59,090 --> 00:16:05,450
（==），就像你比较任意整数
值或使用字符值（= =）

308
00:16:05,450 --> 00:16:06,320
为好。

309
00:16:06,320 --> 00:16:10,994
这是一种特殊的恒
值，你可以用它来测试。

310
00:16:10,994 --> 00:16:13,160
所以这是一个非常简单的
指针，空指针。

311
00:16:13,160 --> 00:16:15,320
另一种方式来创建
一个指针是提取

312
00:16:15,320 --> 00:16:18,240
一个变量的地址
你已经创建，

313
00:16:18,240 --> 00:16:22,330
而你做到这一点使用的＆
运营商地址提取。

314
00:16:22,330 --> 00:16:26,720
对此我们已经先前看到的
在第一个图的例子我发现。

315
00:16:26,720 --> 00:16:31,450
因此，如果x是，我们的变量
已创建的整数类型，

316
00:16:31,450 --> 00:16:35,110
然后＆x是一个指向一个整数。

317
00:16:35,110 --> 00:16:39,810
＆X是 - 记住，和将要提取
的右边的事情的地址。

318
00:16:39,810 --> 00:16:45,350
并且由于一个指针只是一个地址，
比＆x是一个指向整数

319
00:16:45,350 --> 00:16:48,560
它的值就是在存储器X的生活。

320
00:16:48,560 --> 00:16:50,460
这是X的地址。

321
00:16:50,460 --> 00:16:53,296
所以与x是x的地址。

322
00:16:53,296 --> 00:16:55,670
让我们这一步
进一步连接到一些东西

323
00:16:55,670 --> 00:16:58,380
我暗示在一先前视频。

324
00:16:58,380 --> 00:17:06,730
如果ARR是double数组，然后
与改编括号我是一个指针

325
00:17:06,730 --> 00:17:08,109
一个双。

326
00:17:08,109 --> 00:17:08,970
好。

327
00:17:08,970 --> 00:17:12,160
常用3方括号我，如果
ARR是双打的阵列，

328
00:17:12,160 --> 00:17:19,069
那么常用3括号我是
该数组的第i个元素，

329
00:17:19,069 --> 00:17:29,270
并与常用3方括号我就是在
存储器改编的第i个元素的存在。

330
00:17:29,270 --> 00:17:31,790
>> 那么，有什么含义吗？

331
00:17:31,790 --> 00:17:34,570
一个数组名，寓意
这整个事情，

332
00:17:34,570 --> 00:17:39,290
是，阵列的名称是
其实本身就是一个指针。

333
00:17:39,290 --> 00:17:41,170
你一直工作
与所有的指针沿着

334
00:17:41,170 --> 00:17:45,290
每次你使用一个数组的时间。

335
00:17:45,290 --> 00:17:49,090
还记得本例
可变范围，

336
00:17:49,090 --> 00:17:53,420
不久我目前的视频结束
一个例子，我们有一个函数

337
00:17:53,420 --> 00:17:56,890
所谓集合int和一个
函数调用集阵列。

338
00:17:56,890 --> 00:18:00,490
而你的挑战，以确定
无论是否，或什么

339
00:18:00,490 --> 00:18:03,220
我们打​​印出值
该函数结束，

340
00:18:03,220 --> 00:18:05,960
在主程序的末尾。

341
00:18:05,960 --> 00:18:08,740
>> 如果从这个例子召回
或者，如果你看过视频，

342
00:18:08,740 --> 00:18:13,080
你知道你 - 在调用的时候
集INT有效地不执行任何操作。

343
00:18:13,080 --> 00:18:16,390
但调用设置阵列一样。

344
00:18:16,390 --> 00:18:19,280
我几分掩饰为什么
这是在该时间的情况下。

345
00:18:19,280 --> 00:18:22,363
我刚才说了，那么它的一个数组，它的
特别的，你知道，有一个原因。

346
00:18:22,363 --> 00:18:25,020
其原因是，阵列的
名字其实只是一个指针，

347
00:18:25,020 --> 00:18:28,740
这里面的这个特殊的
方括号语法

348
00:18:28,740 --> 00:18:30,510
使事情很多更好的工作。

349
00:18:30,510 --> 00:18:34,410
并且他们做的想法
指针少了很多恐吓，

350
00:18:34,410 --> 00:18:36,800
这就是为什么他们排序
呈现的那样。

351
00:18:36,800 --> 00:18:38,600
但实际上数组只是指针。

352
00:18:38,600 --> 00:18:41,580
这就是为什么当我们
做出了改变到阵列，

353
00:18:41,580 --> 00:18:44,880
当我们传递了一个数组作为参数
到函数或作为参数

354
00:18:44,880 --> 00:18:50,110
阵列的一个功能时，内容
在这两个被叫方实际改变

355
00:18:50,110 --> 00:18:51,160
并且在调用者。

356
00:18:51,160 --> 00:18:55,846
这对于所有其他类型的
我们看到变量，情况并非如此。

357
00:18:55,846 --> 00:18:58,970
所以，这只是要保持
当你使用指针介意，

358
00:18:58,970 --> 00:19:01,610
是，一个名
数组实际上是一个指针

359
00:19:01,610 --> 00:19:04,750
该阵列的第一个元素。

360
00:19:04,750 --> 00:19:08,930
>> OK，现在我们有所有这些
事实，让我们继续前进吧。

361
00:19:08,930 --> 00:19:11,370
我们为什么要关心
其中，一些住。

362
00:19:11,370 --> 00:19:14,120
那么就像我说的，这是相当
要知道一些有用的生活

363
00:19:14,120 --> 00:19:17,240
所以你可以去那里并改变它。

364
00:19:17,240 --> 00:19:19,390
使用它，实际上
有件事，你

365
00:19:19,390 --> 00:19:23,710
要做到这个变量生效，
而不是采取一些它的复印效果。

366
00:19:23,710 --> 00:19:26,150
这被称为间接引用。

367
00:19:26,150 --> 00:19:28,690
我们去参考和
我们改变价值在那里。

368
00:19:28,690 --> 00:19:32,660
因此，如果我们有一个指针，它被称为
电脑，它指向一个字符，

369
00:19:32,660 --> 00:19:40,610
那么我们可以说，* PC和* PC是
什么，我们会发现，如果我们去的名字

370
00:19:40,610 --> 00:19:42,910
到的地址的PC。

371
00:19:42,910 --> 00:19:47,860
我们会发现有一个字符，
* PC是我们参考的数据，在该

372
00:19:47,860 --> 00:19:48,880
位置。

373
00:19:48,880 --> 00:19:54,150
因此，我们可以这样说：
* PC = D或类似的东西，

374
00:19:54,150 --> 00:19:59,280
这意味着，无论
在内存地址的电脑，

375
00:19:59,280 --> 00:20:07,040
无论角色是以前
在那里，现在是研发，如果说* PC = D。

376
00:20:07,040 --> 00:20:10,090
>> 所以在这里，我们又来了与
一些怪异的Ç的东西，对吧。

377
00:20:10,090 --> 00:20:14,560
因此，我们已经看到了*以前作为
莫名其妙的数据类型的一部分​​，

378
00:20:14,560 --> 00:20:17,160
而现在它在被使用
一个稍微不同的上下文

379
00:20:17,160 --> 00:20:19,605
在一个位置，以访问数据。

380
00:20:19,605 --> 00:20:22,480
我知道这是一个有点混乱，
这实际上是这个整体的一部分

381
00:20:22,480 --> 00:20:25,740
喜欢，为什么指针有这个神话
他们周围的是如此复杂，

382
00:20:25,740 --> 00:20:28,250
是那种语法问题，说实话。

383
00:20:28,250 --> 00:20:31,810
但*用在这两种情况下，
既作为类型名称的一部分，

384
00:20:31,810 --> 00:20:34,100
我们会看到一个小
后来别的东西。

385
00:20:34,100 --> 00:20:36,490
而现在是
引用操作。

386
00:20:36,490 --> 00:20:38,760
如此这般到参考，
它访问数据

387
00:20:38,760 --> 00:20:43,000
在指针的位置，并
可以让你随意操纵它。

388
00:20:43,000 --> 00:20:45,900
>> 现在，这是非常相似的
访问你的邻居吧。

389
00:20:45,900 --> 00:20:48,710
如果你知道你的
邻居的生活，你

390
00:20:48,710 --> 00:20:50,730
未挂出与你的邻居。

391
00:20:50,730 --> 00:20:53,510
你知道你恰巧
知道他们住在哪里，

392
00:20:53,510 --> 00:20:56,870
但是，这并不意味着，通过
凭借具有知识

393
00:20:56,870 --> 00:20:59,170
你与他们的互动。

394
00:20:59,170 --> 00:21:01,920
如果你想与他们进行互动，
你必须去他们家，

395
00:21:01,920 --> 00:21:03,760
你必须去他们住的地方。

396
00:21:03,760 --> 00:21:07,440
一旦你做到这一点，
那么你可以互动

397
00:21:07,440 --> 00:21:09,420
他们就像你想要。

398
00:21:09,420 --> 00:21:12,730
而同样有变数，
你需要去他们的地址

399
00:21:12,730 --> 00:21:15,320
如果你想交互他们，
你不能只知道地址。

400
00:21:15,320 --> 00:21:21,495
而你去这个地址的方法是
使用*，则引用操作。

401
00:21:21,495 --> 00:21:23,620
你觉得会发生
如果我们试图和反引用

402
00:21:23,620 --> 00:21:25,260
一个指针，它的值是空？

403
00:21:25,260 --> 00:21:28,470
回想一下，空
指针指向什么。

404
00:21:28,470 --> 00:21:34,110
所以，如果你尝试取消引用
没事还是去到一个地址什么都没有，

405
00:21:34,110 --> 00:21:36,800
你觉得会发生什么？

406
00:21:36,800 --> 00:21:39,630
那么，如果你猜分割
故障，你是对的。

407
00:21:39,630 --> 00:21:41,390
如果您尝试取消引用
一个空指针，

408
00:21:41,390 --> 00:21:43,140
你受苦分割
故障。可是等等，

409
00:21:43,140 --> 00:21:45,820
我没有告诉你，
如果你不打算

410
00:21:45,820 --> 00:21:49,220
设置你的价值你
指针到一些有意义的事情，

411
00:21:49,220 --> 00:21:51,000
你应该设置为null？

412
00:21:51,000 --> 00:21:55,290
我没有和实际的分割
故障是怎么样的一个很好的行为。

413
00:21:55,290 --> 00:21:58,680
>> 你有没有声明的变量和
没有立即指派它的价值？

414
00:21:58,680 --> 00:22:02,680
所以，你刚才说INT X;你不
实际上它分配给什么

415
00:22:02,680 --> 00:22:05,340
再后来就在你的代码，
你打印出x的值，

416
00:22:05,340 --> 00:22:07,650
有还是没有
其分配到任何东西。

417
00:22:07,650 --> 00:22:10,370
你经常会得到
零，但有时你

418
00:22:10,370 --> 00:22:15,000
可能会得到一些随机数，并
你不知道它是从哪里来的。

419
00:22:15,000 --> 00:22:16,750
同样的事情可以
发生在三分球。

420
00:22:16,750 --> 00:22:20,110
在声明指针
INT * PK为例，

421
00:22:20,110 --> 00:22:23,490
你不将它分配一个值，
你得到四个字节的内存。

422
00:22:23,490 --> 00:22:25,950
任何四个字节的
存储器系统可以

423
00:22:25,950 --> 00:22:28,970
发现有一些有意义的价值。

424
00:22:28,970 --> 00:22:31,760
还有可能是
已经存在的东西了

425
00:22:31,760 --> 00:22:34,190
不再需要由另一
功能，所以你只要有

426
00:22:34,190 --> 00:22:35,900
不管数据在那里。

427
00:22:35,900 --> 00:22:40,570
>> 如果你试图做提领
你没有 - 也有一些地址

428
00:22:40,570 --> 00:22:43,410
已经字节和信息
在那里，这是现在在你的指针。

429
00:22:43,410 --> 00:22:47,470
如果您尝试取消引用该指针，
你可能会和一些内存来搞乱

430
00:22:47,470 --> 00:22:49,390
你不打算
惹这一切。

431
00:22:49,390 --> 00:22:51,639
而事实上，你可以做
一些真正毁灭性的，

432
00:22:51,639 --> 00:22:54,880
像打破另一个程序，
或打破另一项功能，

433
00:22:54,880 --> 00:22:58,289
或者做一些恶意的
你不打算做的。

434
00:22:58,289 --> 00:23:00,080
所以这就是为什么它是
实际上是一个好主意

435
00:23:00,080 --> 00:23:04,030
设置你的指针，如果你为null
不要将它们设置为有意义的事。

436
00:23:04,030 --> 00:23:06,760
它可能会更好的
当天的程序结束

437
00:23:06,760 --> 00:23:09,840
崩溃，然后为它做
一些螺丝了

438
00:23:09,840 --> 00:23:12,400
另一个程序或其他功能。

439
00:23:12,400 --> 00:23:15,207
这种行为很可能是连
不仅仅是崩溃不太理想。

440
00:23:15,207 --> 00:23:17,040
所以这就是为什么它是
实际上是一个好习惯

441
00:23:17,040 --> 00:23:20,920
进入设置你的指针
为空，如果你不将它们

442
00:23:20,920 --> 00:23:24,540
一个有意义的值
马上，你知道的值

443
00:23:24,540 --> 00:23:27,260
并且您可以安全地取消引用。

444
00:23:27,260 --> 00:23:32,240
>> 现在让我们再来看一看
在整体局势的语法。

445
00:23:32,240 --> 00:23:37,400
如果我说INT * P;，你有什么我刚才做了什么？

446
00:23:37,400 --> 00:23:38,530
我所做的就是这一点。

447
00:23:38,530 --> 00:23:43,290
我知道p的值是一个地址
因为所有指针都只是

448
00:23:43,290 --> 00:23:44,660
地址。

449
00:23:44,660 --> 00:23:47,750
我可以提领p
使用*运算符。

450
00:23:47,750 --> 00:23:51,250
在这方面这里，在最
顶部召回*是类型的一部分​​。

451
00:23:51,250 --> 00:23:53,510
为int *是数据类型。

452
00:23:53,510 --> 00:23:56,150
但我可以提领
p使用*运营商，

453
00:23:56,150 --> 00:24:01,897
如果我这样做，如果我去这个地址，
什么都会，我觉得在这个地址？

454
00:24:01,897 --> 00:24:02,855
我会找到一个整数。

455
00:24:02,855 --> 00:24:05,910
因此，为int * p是基本
话说，p是一个地址。

456
00:24:05,910 --> 00:24:09,500
我可以取消引用p和当
我这样做，我会找到一个整数

457
00:24:09,500 --> 00:24:11,920
在该存储器位置。

458
00:24:11,920 --> 00:24:14,260
>> 行，所以我说还有一个
恼人的事情与明星

459
00:24:14,260 --> 00:24:17,060
而这里的地方了
可气的星星是。

460
00:24:17,060 --> 00:24:21,640
你有没有试过声明
相同类型的多个变量

461
00:24:21,640 --> 00:24:24,409
在相同的代码行？

462
00:24:24,409 --> 00:24:27,700
因此，对于第二，假装线，
我的代码实际上有绿色

463
00:24:27,700 --> 00:24:29,366
是不存在的，它只是说：INT X，Y，Z ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
什么，会做实际创建是
为你三个整数变量，

466
00:24:34,550 --> 00:24:36,930
一个叫X，一个叫
y和一个叫ž。

467
00:24:36,930 --> 00:24:41,510
这是一个办法做到这一点不
不必分割成三行。

468
00:24:41,510 --> 00:24:43,890
>> 这里就是星星得
再烦人不过，

469
00:24:43,890 --> 00:24:49,200
因为*实际上是部分
两者的类型名称和部分

470
00:24:49,200 --> 00:24:50,320
变量名。

471
00:24:50,320 --> 00:24:56,430
所以，如果我说INT * PX，PY，PZ，我
实际上得到的是一个指向整数

472
00:24:56,430 --> 00:25:01,650
所谓PX和两个整数，PY和PZ。

473
00:25:01,650 --> 00:25:04,950
而这可能不是什么
我们希望，这并不好。

474
00:25:04,950 --> 00:25:09,290
>> 所以，如果我想创建多个指针
相同类型的在同一行上，

475
00:25:09,290 --> 00:25:12,140
和星星，我真的需要
做的是说INT * PA，* PB，* PC。

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
现在刚刚说，
现在告诉你这个，

478
00:25:20,300 --> 00:25:22,170
你可能永远不会做到这一点。

479
00:25:22,170 --> 00:25:25,170
它可能是一个好东西说实话，
因为您可能会在不经意间

480
00:25:25,170 --> 00:25:26,544
省略明星，类似的东西。

481
00:25:26,544 --> 00:25:29,290
这可能是最好的，也许声明
个别行的指针，

482
00:25:29,290 --> 00:25:31,373
但它只是一个又一个
那些烦人的语法

483
00:25:31,373 --> 00:25:35,310
星星东西，使
三分球这么难的工作。

484
00:25:35,310 --> 00:25:39,480
因为它只是这个语法
惹你有工作，通过。

485
00:25:39,480 --> 00:25:41,600
通过练习它
真正成为第二天性。

486
00:25:41,600 --> 00:25:45,410
我仍然犯错误它仍然
编程后10年，

487
00:25:45,410 --> 00:25:49,630
所以不要生气，如果有事
给你，这是很常见的诚实。

488
00:25:49,630 --> 00:25:52,850
这是一种真正的
语法的缺陷。

489
00:25:52,850 --> 00:25:54,900
>> 样的行，所以我答应
我们会重新审视

490
00:25:54,900 --> 00:25:59,370
如何大的概念，是一个字符串。

491
00:25:59,370 --> 00:26:02,750
那么，如果我告诉你，一个
字符串，我们真的有种

492
00:26:02,750 --> 00:26:04,140
在骗你的全部时间。

493
00:26:04,140 --> 00:26:06,181
有没有所谓的数据类型
字符串，而事实上我

494
00:26:06,181 --> 00:26:09,730
在一提到这个我们
最早的视频数据类型，

495
00:26:09,730 --> 00:26:13,820
该字符串是一个数据类型
在CS50.h.为您创建

496
00:26:13,820 --> 00:26:17,050
你必须＃包括
CS50.h以便使用它。

497
00:26:17,050 --> 00:26:19,250
>> 那么字符串真的只是
别名的东西

498
00:26:19,250 --> 00:26:23,600
所谓的字符*，一
指针指向字符。

499
00:26:23,600 --> 00:26:26,010
好了三分球，召回，
只是解决了。

500
00:26:26,010 --> 00:26:28,780
那么，什么是大小
在一个字符串的字节？

501
00:26:28,780 --> 00:26:29,796
那么它的四个或​​八个。

502
00:26:29,796 --> 00:26:32,170
而我之所以这么说四
八成是因为实际上它

503
00:26:32,170 --> 00:26:36,730
取决于系统，如果你使用
CS50 IDE，字符*是一个字符的大小

504
00:26:36,730 --> 00:26:39,340
*是8，它是一个64位的系统。

505
00:26:39,340 --> 00:26:43,850
在内存中的每个地址是64位长。

506
00:26:43,850 --> 00:26:48,270
如果您使用的是CS50家电
或使用任何32位机，

507
00:26:48,270 --> 00:26:51,640
你听说过这个词32位
机，什么是32位机？

508
00:26:51,640 --> 00:26:56,090
那么它只是意味着每
在存储器地址是32位长。

509
00:26:56,090 --> 00:26:59,140
因此32位是四个字节。

510
00:26:59,140 --> 00:27:02,710
所以，一个char *为四个或八个
根据你的系统字节。

511
00:27:02,710 --> 00:27:06,100
实际上，任何数据类型，
的指针和指向的任何数据

512
00:27:06,100 --> 00:27:12,030
类型，因为所有指针都只是
地址，是四个或八个字节。

513
00:27:12,030 --> 00:27:14,030
因此，让我们重新审视这个
图，让我们得出结论：

514
00:27:14,030 --> 00:27:18,130
该视频在这里一点点的锻炼。

515
00:27:18,130 --> 00:27:21,600
因此，这里是我们离开了与图
在视频的开始。

516
00:27:21,600 --> 00:27:23,110
那么现在会发生什么，如果我说* PK = 35？

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
所以，这是什么意思，当我说，* PK = 35？

519
00:27:30,530 --> 00:27:32,420
拿第二。

520
00:27:32,420 --> 00:27:34,990
*峰。

521
00:27:34,990 --> 00:27:39,890
在这里背景下，*是
引用操作。

522
00:27:39,890 --> 00:27:42,110
因此，当提领
操作者的情况下，

523
00:27:42,110 --> 00:27:48,520
我们去的地址指向
通过PK，我们改变我们发现。

524
00:27:48,520 --> 00:27:55,270
因此，* PK = 35有效
这样做是为了在照片。

525
00:27:55,270 --> 00:27:58,110
因此，它基本上是语法
相同的具有所述k = 35。

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> 多一个。

528
00:28:01,930 --> 00:28:05,510
如果我说INT男，创建
一个称为M的新变量。

529
00:28:05,510 --> 00:28:08,260
一个新的盒子，这是因为一个绿色的盒子
它会举行一个整数，

530
00:28:08,260 --> 00:28:09,840
和它的标记微米。

531
00:28:09,840 --> 00:28:14,960
如果我说M = 4，我把
整装进盒子。

532
00:28:14,960 --> 00:28:20,290
如果说PK =​​＆M，怎么做
此图的变化？

533
00:28:20,290 --> 00:28:28,760
PK =＆M，你还记得什么
与操作者或者叫什么名字？

534
00:28:28,760 --> 00:28:34,430
请记住，与一些变量名
是变量名的地址。

535
00:28:34,430 --> 00:28:38,740
所以，我们在说什么是
PK得到m的地址。

536
00:28:38,740 --> 00:28:42,010
所以，有效地会发生什么
图是pk的不再指向

537
00:28:42,010 --> 00:28:46,420
以K，但点到m。

538
00:28:46,420 --> 00:28:48,470
>> 此外指针是非常
棘手一起工作

539
00:28:48,470 --> 00:28:50,620
他们采取了很多
实践中，但因为

540
00:28:50,620 --> 00:28:54,150
他们的能力，让您
传递函数之间的数据

541
00:28:54,150 --> 00:28:56,945
居然有那些
更改生效，

542
00:28:56,945 --> 00:28:58,820
围绕让你的头
是非常重要的。

543
00:28:58,820 --> 00:29:02,590
这可能是最复杂
主题中，我们在CS50讨论，

544
00:29:02,590 --> 00:29:05,910
但值你
使用指针获得

545
00:29:05,910 --> 00:29:09,200
远远超过了并发症
这来自于学习他们。

546
00:29:09,200 --> 00:29:12,690
所以，我希望你最好的
运气了解指针。

547
00:29:12,690 --> 00:29:15,760
我是道格·劳埃德，这是CS50。

548
00:29:15,760 --> 00:29:17,447