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

2
00:00:00,499 --> 00:00:01,395
[音乐播放]

3
00:00:01,395 --> 00:00:05,590

4
00:00:05,590 --> 00:00:07,940
>> 道格·劳埃德：可以这么建议
之前，从这里开始。

5
00:00:07,940 --> 00:00:11,660
如果你还没有看过上的视频
指针，你可能想这样做第一。

6
00:00:11,660 --> 00:00:15,860
因为这段视频是另一种
与指针的工作方式。

7
00:00:15,860 --> 00:00:17,574
>> 因此，它会说话
一些概念

8
00:00:17,574 --> 00:00:19,490
我们覆盖的
指针视频和我们

9
00:00:19,490 --> 00:00:21,948
现在要粉饰他们，
假设他们已经

10
00:00:21,948 --> 00:00:23,090
样的了解。

11
00:00:23,090 --> 00:00:25,440
所以，这只是你公平的警告
如果你看到这个视频

12
00:00:25,440 --> 00:00:27,814
你没见过
指针视频，它可能排序

13
00:00:27,814 --> 00:00:29,610
在你的头上飞一点点。

14
00:00:29,610 --> 00:00:32,080
因此，这可能会更好
看它的顺序。

15
00:00:32,080 --> 00:00:34,710
>> 因此，我们已经见过
方式与指针的工作，

16
00:00:34,710 --> 00:00:37,810
这是我们申报
变量，然后我们

17
00:00:37,810 --> 00:00:42,160
声明另一个变量，指针
变量，指向它。

18
00:00:42,160 --> 00:00:44,870
因此，我们已经创建了一个
使用一个名称的变量，我们

19
00:00:44,870 --> 00:00:48,480
有一个名字创建了第二个变量，
我们点了第二个变量

20
00:00:48,480 --> 00:00:50,220
在第一次。

21
00:00:50,220 --> 00:00:52,370
这种具有
问题虽然，因为它

22
00:00:52,370 --> 00:00:54,650
要求我们确切地知道
多少内存我们

23
00:00:54,650 --> 00:00:57,600
将需要的时刻
我们的编译程序。

24
00:00:57,600 --> 00:00:58,220
>> 这是为什么？

25
00:00:58,220 --> 00:01:03,338
因为我们需要能够以命名或
找出所有可能的变量

26
00:01:03,338 --> 00:01:04,129
我们可能会遇到的问题。

27
00:01:04,129 --> 00:01:07,910
我们可能有可能是一个数组
能够容纳大量的信息，

28
00:01:07,910 --> 00:01:10,110
但它仍然不是
完全足够精确。

29
00:01:10,110 --> 00:01:12,640
如果我们不知道叫什么，
如果我们不知道

30
00:01:12,640 --> 00:01:14,370
多少钱，我们需要在编译的时候？

31
00:01:14,370 --> 00:01:17,020
或者，如果我们的节目会
跑了很长一段时间，

32
00:01:17,020 --> 00:01:19,810
接受各种用户
数据，我们不能真正

33
00:01:19,810 --> 00:01:23,170
估计无论我们是
将需要1000台？

34
00:01:23,170 --> 00:01:26,060
>> 它不喜欢，我们可以
说，在命令行

35
00:01:26,060 --> 00:01:28,040
输入多少个项目
你认为你所需要的。

36
00:01:28,040 --> 00:01:31,100
好吧，如果这猜测是错误的？

37
00:01:31,100 --> 00:01:34,300
动态内存分配
排序可以让我们的方式

38
00:01:34,300 --> 00:01:36,867
要解决这方面的问题。

39
00:01:36,867 --> 00:01:38,700
而它的方式做它
是通过使用指针。

40
00:01:38,700 --> 00:01:42,140
>> 我们可以用指针
可以访问动态

41
00:01:42,140 --> 00:01:45,710
分配的内存，内存，
分配为您的程序正在运行。

42
00:01:45,710 --> 00:01:48,290
这不是分配在编译时。

43
00:01:48,290 --> 00:01:51,570
当你动态分配
内存它来自游泳池

44
00:01:51,570 --> 00:01:53,795
内存被称为堆。

45
00:01:53,795 --> 00:01:56,420
以前，所有的我们已经记忆
一直与在使用过程中

46
00:01:56,420 --> 00:01:59,920
一直在下从池中
的存储器称为栈。

47
00:01:59,920 --> 00:02:02,470
一个好方法一般
保持mind--这条规则

48
00:02:02,470 --> 00:02:04,720
并不总是保持为真，
但几乎差不多

49
00:02:04,720 --> 00:02:09,940
一贯主张true--是任何
时间你给一个变量命名

50
00:02:09,940 --> 00:02:12,090
大概住在堆栈上。

51
00:02:12,090 --> 00:02:14,650
而任何时候你不这样做
给一个变量的名称，

52
00:02:14,650 --> 00:02:19,160
您可以使用动态内存？
分配，它生活在堆上。

53
00:02:19,160 --> 00:02:22,190
>> 那种现在我介绍这是
如果有内存这两个池。

54
00:02:22,190 --> 00:02:24,740
但是你可能已经看到了这
图，这是一般

55
00:02:24,740 --> 00:02:27,290
的表示
看起来是什么样的内存，

56
00:02:27,290 --> 00:02:30,373
而我们不会关心所有
的东西在顶部和底部。

57
00:02:30,373 --> 00:02:33,580
我们关心的是这部分
在此中间，堆和栈。

58
00:02:33,580 --> 00:02:35,570
正如你可以看到
在看这个图，

59
00:02:35,570 --> 00:02:38,390
这其实不是两个
内存单独的池。

60
00:02:38,390 --> 00:02:42,757
这是一个内存共享池
你从哪里开始，在这个视觉

61
00:02:42,757 --> 00:02:44,590
你在底部开始
并开始填补

62
00:02:44,590 --> 00:02:48,040
从与栈的底部，和你
从顶部开始，并开始填充

63
00:02:48,040 --> 00:02:50,072
从上而下的堆。

64
00:02:50,072 --> 00:02:51,780
但它确实是
同一池中，它只是

65
00:02:51,780 --> 00:02:56,050
不同点，不同的地点
在存储器中被分配。

66
00:02:56,050 --> 00:02:59,060
你可以用尽
内存是含

67
00:02:59,060 --> 00:03:01,240
堆一路走
的底部，或具有

68
00:03:01,240 --> 00:03:05,440
栈一路顶端，
或具有堆和栈

69
00:03:05,440 --> 00:03:06,740
见面互相反对。

70
00:03:06,740 --> 00:03:09,500
所有这些可以是条件
导致你的程序

71
00:03:09,500 --> 00:03:11,030
运行内存不足。

72
00:03:11,030 --> 00:03:11,952
所以记住这一点。

73
00:03:11,952 --> 00:03:13,660
当我们谈论
堆和栈

74
00:03:13,660 --> 00:03:17,880
我们真的是在谈论
内存相同的通用块，只

75
00:03:17,880 --> 00:03:21,930
该存储器的不同部分。

76
00:03:21,930 --> 00:03:24,910
>> 那么，我们如何动态地得到
首先分配的内存？

77
00:03:24,910 --> 00:03:27,740
如何我们的计划获得
内存作为它的运行？

78
00:03:27,740 --> 00:03:32,660
C井提供了一个调用的函数
malloc的，内存分配器，这

79
00:03:32,660 --> 00:03:36,810
您拨打一个电话来了，你传递
有多少你想要的内存字节。

80
00:03:36,810 --> 00:03:39,940
所以，如果你的程序正在运行
你想要一个整数的运行时，

81
00:03:39,940 --> 00:03:46,040
你可能会马洛克四个字节
内存，malloc的括号四人。

82
00:03:46,040 --> 00:03:48,540
>> 马洛克将通过
翻翻堆，

83
00:03:48,540 --> 00:03:50,750
因为我们是动态
分配内存，

84
00:03:50,750 --> 00:03:53,500
它会回报给你
一个指针，指向存储器。

85
00:03:53,500 --> 00:03:56,180
它不会给你的memory--
它不给它一个名字，

86
00:03:56,180 --> 00:03:57,950
它给你一个指针。

87
00:03:57,950 --> 00:04:00,780
所以这就是为什么我再次说
这是很重要的，也许

88
00:04:00,780 --> 00:04:03,770
看完球视频
之前，我们得过了头到这一点。

89
00:04:03,770 --> 00:04:05,940
所以malloc的是怎么回事，以
还给你一个指针。

90
00:04:05,940 --> 00:04:08,950
>> 如果马洛克不能给你任何
内存，因为你已经用完了，

91
00:04:08,950 --> 00:04:10,645
它会给你回一个空指针。

92
00:04:10,645 --> 00:04:15,282
你还记得，如果我们发生了什么
尝试取消引用一个空指针？

93
00:04:15,282 --> 00:04:17,019
我们遭受赛格故障，对不对？

94
00:04:17,019 --> 00:04:18,060
这可能不是很好。

95
00:04:18,060 --> 00:04:21,579
>> 所以每次拨打电话
永远的malloc你，总是

96
00:04:21,579 --> 00:04:25,270
需要检查是否
指针它给你回空。

97
00:04:25,270 --> 00:04:28,800
如果是，你需要结束程序
因为如果你尝试取消引用

98
00:04:28,800 --> 00:04:31,360
你要去的空指针
挨段错误

99
00:04:31,360 --> 00:04:34,380
和你的程序是
不管怎样都是崩溃。

100
00:04:34,380 --> 00:04:37,190
那么我们如何做静态
得到的整数。

101
00:04:37,190 --> 00:04:37,730
>> INT的X.

102
00:04:37,730 --> 00:04:40,010
我们可能已经这样做了
一群倍，对不对？

103
00:04:40,010 --> 00:04:43,480
这将创建一个名为变量
X中住在堆栈中。

104
00:04:43,480 --> 00:04:46,190
我们如何动态地获得一个整数？

105
00:04:46,190 --> 00:04:50,010
诠释星PX等于malloc的4。

106
00:04:50,010 --> 00:04:53,050
>> 或者更准确
我们会说INT星级PX

107
00:04:53,050 --> 00:04:57,680
等于为int的malloc的大小，
只是抛出一些较少

108
00:04:57,680 --> 00:04:59,740
围绕我们的计划幻数。

109
00:04:59,740 --> 00:05:04,140
这将获得对我们
从堆四个字节的存储器，

110
00:05:04,140 --> 00:05:06,720
和指针我们得到
回到它被称为像素。

111
00:05:06,720 --> 00:05:08,430
然后，就像我们已经
以前做的我们

112
00:05:08,430 --> 00:05:13,966
可以提领像素到
访问内存。

113
00:05:13,966 --> 00:05:15,590
我们如何从用户那里得到的整数？

114
00:05:15,590 --> 00:05:17,970
我们可以说INT x等于拿到INT。

115
00:05:17,970 --> 00:05:19,930
这是非常简单的。

116
00:05:19,930 --> 00:05:24,030
如果我们想创建一个数组什么
第X住在堆栈上的花车？

117
00:05:24,030 --> 00:05:28,210
浮stack_array--这就是名字
我们array--方括号中的X.

118
00:05:28,210 --> 00:05:32,419
这为我们创建一个数组
第X住在堆栈上浮动。

119
00:05:32,419 --> 00:05:34,960
我们可以创建float数组
家住堆了。

120
00:05:34,960 --> 00:05:37,330
语法看起来可能
多一点麻烦，

121
00:05:37,330 --> 00:05:41,740
但我们可以说浮法
明星heap_array等于

122
00:05:41,740 --> 00:05:44,360
malloc的x次浮子的尺寸。

123
00:05:44,360 --> 00:05:48,160
我需要足够的空间来容纳
x浮点点值。

124
00:05:48,160 --> 00:05:51,560
所以说，我需要100
花车，或1000彩车。

125
00:05:51,560 --> 00:05:54,810
因此，在这种情况下，这将是
400字节100辆彩车，

126
00:05:54,810 --> 00:05:59,080
或4000个字节为1000辆彩车，
因为每个浮点占用

127
00:05:59,080 --> 00:06:01,230
4个字节的空间。

128
00:06:01,230 --> 00:06:05,110
>> 这样做后，我可以使用
在heap_array方括号语法。

129
00:06:05,110 --> 00:06:08,970
正如我会在stack_array，我
可以单独访问它的元素

130
00:06:08,970 --> 00:06:11,590
使用heap_array零，heap_array之一。

131
00:06:11,590 --> 00:06:15,800
回想起我们可以做到这一点的原因
是因为在C数组的名字

132
00:06:15,800 --> 00:06:19,990
确实是一个指针
该数组的第一个元素。

133
00:06:19,990 --> 00:06:23,480
所以，我们正在宣告一个事实
彩车的堆栈这里阵列

134
00:06:23,480 --> 00:06:24,810
其实是有点误导。

135
00:06:24,810 --> 00:06:27,600
我们真的是在
代码第二行有

136
00:06:27,600 --> 00:06:32,360
还创建一个指向一大块
内存我们那么做了一些工作。

137
00:06:32,360 --> 00:06:35,620
>> 这里的大问题
虽然动态分配内存，

138
00:06:35,620 --> 00:06:38,360
这就是为什么它是真的
重要的是要养成一些好习惯

139
00:06:38,360 --> 00:06:39,800
当你使用它。

140
00:06:39,800 --> 00:06:43,060
不同于静态声明
记忆，你的记忆

141
00:06:43,060 --> 00:06:46,790
不会自动返回到
当你的函数完成系统。

142
00:06:46,790 --> 00:06:49,280
因此，如果我们有主，和
主调用一个函数

143
00:06:49,280 --> 00:06:53,860
女，当f完成不管它做
并返回程序的控制

144
00:06:53,860 --> 00:06:58,810
回存储器的主，所有
使用F是给出回复。

145
00:06:58,810 --> 00:07:01,250
它可以再次使用
通过一些其它方案，

146
00:07:01,250 --> 00:07:04,250
或一些其它功能
被调用后来在主。

147
00:07:04,250 --> 00:07:06,970
它可以再次使用同样的内存了。

148
00:07:06,970 --> 00:07:09,620
>> 如果动态
虽然分配内存

149
00:07:09,620 --> 00:07:14,380
你必须明确地告诉
系统，你就大功告成了。

150
00:07:14,380 --> 00:07:18,370
它会抓住它适合你，这可能
导致一个问题，你跑出来

151
00:07:18,370 --> 00:07:19,290
的存储器。

152
00:07:19,290 --> 00:07:22,179
而事实上，我们有时
这是一个内存泄漏。

153
00:07:22,179 --> 00:07:24,970
有时这些内存泄漏
其实是可以真正毁灭性的

154
00:07:24,970 --> 00:07:27,020
为系统的性能。

155
00:07:27,020 --> 00:07:31,120
>> 如果你是一个经常上网的用户
您可以使用特定的Web浏览器，

156
00:07:31,120 --> 00:07:35,630
我不会指名道姓这里，但
有一些网页浏览器在那里

157
00:07:35,630 --> 00:07:39,150
这是臭名昭著的实际上有
内存泄漏没有得到修复。

158
00:07:39,150 --> 00:07:44,570
如果你离开你的浏览器中打开
在很长的一段时间里，天

159
00:07:44,570 --> 00:07:48,060
和天或数周，你有时
可能会注意到，您的系统

160
00:07:48,060 --> 00:07:49,790
是运行非常，非常缓慢。

161
00:07:49,790 --> 00:07:54,640
和其中的原因是，
浏览器已经分配的内存，

162
00:07:54,640 --> 00:07:57,320
但当时没有告诉系统
它的完成它。

163
00:07:57,320 --> 00:08:01,000
所以留下更少的内存
适用于所有的其他程序

164
00:08:01,000 --> 00:08:04,480
有分享，因为你
leaking--的Web浏览器

165
00:08:04,480 --> 00:08:06,755
程序正在泄漏内存。

166
00:08:06,755 --> 00:08:08,880
我们如何给记忆回来
当我们用它做？

167
00:08:08,880 --> 00:08:10,838
那么幸运的是这是一个
很简单的方法来做到这一点。

168
00:08:10,838 --> 00:08:11,710
我们只是释放它。

169
00:08:11,710 --> 00:08:15,020
有一个所谓的自由功能，
它接受一个指向存储器，

170
00:08:15,020 --> 00:08:16,010
我们是好去。

171
00:08:16,010 --> 00:08:18,310
>> 所以我们可以说我们是在
我们的节目中间，

172
00:08:18,310 --> 00:08:21,970
我们想对malloc 50个字符。

173
00:08:21,970 --> 00:08:25,710
我们想的malloc数组，可以
可容纳50个字符。

174
00:08:25,710 --> 00:08:29,109
而当我们得到的指针回
即，该指针的名字是词。

175
00:08:29,109 --> 00:08:30,900
我们做任何我们
打算做的话，

176
00:08:30,900 --> 00:08:33,440
然后，当我们
我们做的只是释放它。

177
00:08:33,440 --> 00:08:37,460
而现在我们又回到那些50
字节的内存回系统。

178
00:08:37,460 --> 00:08:40,147
其他一些功能可以使用它们。

179
00:08:40,147 --> 00:08:43,480
我们不必担心遭受
内存泄漏，因为我们已经释放了字。

180
00:08:43,480 --> 00:08:46,639
我们已经给记忆回来了，
所以我们做的工作吧。

181
00:08:46,639 --> 00:08:48,430
所以有三个
黄金法则，应该

182
00:08:48,430 --> 00:08:51,700
牢记每当你
动态分配内存

183
00:08:51,700 --> 00:08:52,990
使用malloc。

184
00:08:52,990 --> 00:08:56,480
每个内存块
你的malloc必须释放

185
00:08:56,480 --> 00:08:58,430
你的程序之前完成运行。

186
00:08:58,430 --> 00:09:02,029
现在再次，在家电，或在
这种IDE发生反正你

187
00:09:02,029 --> 00:09:04,820
你 - 当这无论如何都会发生
当你的程序被终止，

188
00:09:04,820 --> 00:09:06,880
所有的内存将被释放。

189
00:09:06,880 --> 00:09:10,750
但它总体上是好的编码
实践总是，当你完成，

190
00:09:10,750 --> 00:09:13,810
释放你所mallocd。

191
00:09:13,810 --> 00:09:16,690
>> 这就是说，只有东西
你已经mallocd应该被释放。

192
00:09:16,690 --> 00:09:19,880
如果静态声明
整数，INT×半结肠，

193
00:09:19,880 --> 00:09:23,500
家住在栈中，你
不那么想免费的​​X。

194
00:09:23,500 --> 00:09:25,970
因此，只有你所事
mallocd应该被释放。

195
00:09:25,970 --> 00:09:28,960
>> 最后，不要随意的东西的两倍。

196
00:09:28,960 --> 00:09:31,170
可导致
另一种奇怪的局面。

197
00:09:31,170 --> 00:09:33,530
所以，你已经一切
mallocd必须被释放。

198
00:09:33,530 --> 00:09:36,000
只有你已经事
的malloc应该被释放。

199
00:09:36,000 --> 00:09:38,730
而且不要随意一些的两倍。

200
00:09:38,730 --> 00:09:43,660
>> 所以，让我们通过一个例子在这里
什么样的一些动态分配

201
00:09:43,660 --> 00:09:46,122
内存可能看起来像混合
在一些静态存储器。

202
00:09:46,122 --> 00:09:47,080
什么可能发生在这里？

203
00:09:47,080 --> 00:09:48,913
看看你是否可以按照
同时，你猜是什么

204
00:09:48,913 --> 00:09:51,720
会发生什么，我们去
通过对代码的所有这些行。

205
00:09:51,720 --> 00:09:53,980
>> 所以我们说INT微米。

206
00:09:53,980 --> 00:09:54,840
这里会发生什么？

207
00:09:54,840 --> 00:09:56,339
嗯，这是非常简单的。

208
00:09:56,339 --> 00:09:59,650
我创建一个名为米的整型变量。

209
00:09:59,650 --> 00:10:01,400
我颜色是绿色，
因为这是颜色

210
00:10:01,400 --> 00:10:03,730
我用我说话的时候
关于整型变量。

211
00:10:03,730 --> 00:10:05,160
这是一个盒子。

212
00:10:05,160 --> 00:10:08,400
这就是所谓的米，你可以
它里面存储的整数。

213
00:10:08,400 --> 00:10:12,400
>> 如果我那么说了什么INT明星？

214
00:10:12,400 --> 00:10:13,530
那么这是非常相似的。

215
00:10:13,530 --> 00:10:15,780
我创建一个盒子叫。

216
00:10:15,780 --> 00:10:19,100
这是能够保持为int
明星，指针为整数。

217
00:10:19,100 --> 00:10:21,570
所以我着色它的绿色十岁上下也是如此。

218
00:10:21,570 --> 00:10:24,140
>> 我知道它有什么
做的整数，

219
00:10:24,140 --> 00:10:25,852
但它本身并不是一个整数。

220
00:10:25,852 --> 00:10:27,310
但是，这几乎是同样的想法。

221
00:10:27,310 --> 00:10:28,101
我创建了一个箱子。

222
00:10:28,101 --> 00:10:30,070
这两个权
现在住在堆栈上。

223
00:10:30,070 --> 00:10:32,520
我已经给了他们俩的名字。

224
00:10:32,520 --> 00:10:36,750
>> INT星级住宿等于为i​​nt的malloc的大小。

225
00:10:36,750 --> 00:10:38,560
这其中可能有点棘手。

226
00:10:38,560 --> 00:10:44,110
花一秒钟想想你
希望发生这个图上。

227
00:10:44,110 --> 00:10:50,210
INT星级住宿等于为i​​nt的malloc的大小。

228
00:10:50,210 --> 00:10:51,940
>> 嗯，这并不仅仅创建一个框。

229
00:10:51,940 --> 00:10:53,800
这实际上造成了两箱。

230
00:10:53,800 --> 00:10:58,670
它的联系，这也确立
在的关系的点。

231
00:10:58,670 --> 00:11:02,240
我们分配了一个块
内存堆。

232
00:11:02,240 --> 00:11:05,940
请注意右上角方框
那里没有一个名称。

233
00:11:05,940 --> 00:11:06,760
>> 我们mallocd它。

234
00:11:06,760 --> 00:11:08,050
它存在于堆。

235
00:11:08,050 --> 00:11:10,090
但B有一个名字。

236
00:11:10,090 --> 00:11:11,950
这就是所谓的B A指针变量。

237
00:11:11,950 --> 00:11:13,910
那住在堆栈上。

238
00:11:13,910 --> 00:11:18,250
>> 所以这是一块内存
指向另一个。

239
00:11:18,250 --> 00:11:21,840
B包含地址
该内存块。

240
00:11:21,840 --> 00:11:23,757
它不具有一个名字，否则。

241
00:11:23,757 --> 00:11:24,590
但它指向它。

242
00:11:24,590 --> 00:11:29,760
所以，当我们说INT星级住宿等于
整型malloc的大小，即在那里，

243
00:11:29,760 --> 00:11:33,490
该箭头突然出现在
右侧有，那整个事情，

244
00:11:33,490 --> 00:11:36,740
我会让它出现
再次，是什么情况。

245
00:11:36,740 --> 00:11:39,341
所有这一切都发生在
该一行代码。

246
00:11:39,341 --> 00:11:41,340
现在，我们会得到更多一点
简单的一次。

247
00:11:41,340 --> 00:11:43,330
一个等于符号微米。

248
00:11:43,330 --> 00:11:46,280
你还记得什么
等于符号m是？

249
00:11:46,280 --> 00:11:48,920
嗯，这是一个获得M的地址。

250
00:11:48,920 --> 00:11:54,150
还是把更多的示意，
一个点为m。

251
00:11:54,150 --> 00:11:56,360
>> 一个等于湾

252
00:11:56,360 --> 00:11:57,560
行，所以这里的另一个之一。

253
00:11:57,560 --> 00:11:59,230
A等于湾

254
00:11:59,230 --> 00:12:02,260
这是怎么回事发生
到图中这个时间呢？

255
00:12:02,260 --> 00:12:04,330
>> 那么记得，
赋值运算符的作品

256
00:12:04,330 --> 00:12:08,960
通过分配的价值
从右到左侧的值。

257
00:12:08,960 --> 00:12:14,820
因此，而不是一个指向米，现在
指向同一个地方，乙组分。

258
00:12:14,820 --> 00:12:18,900
一个没有指向B，A
指出其中B点。

259
00:12:18,900 --> 00:12:25,280
>> 如果尖到b那会
是一个等于符号湾

260
00:12:25,280 --> 00:12:28,150
而是一个等于b刚
意味着和b是现在

261
00:12:28,150 --> 00:12:31,770
指向相同的地址，因为
的B内仅有一个地址。

262
00:12:31,770 --> 00:12:35,004
现在的一个内是相同的地址。

263
00:12:35,004 --> 00:12:37,170
m等于10，可能的
最简单的事情

264
00:12:37,170 --> 00:12:38,690
我们在一点点实现。

265
00:12:38,690 --> 00:12:40,460
把10箱。

266
00:12:40,460 --> 00:12:45,640
星级住宿等于M PLUS 2，从召回
我们的三分球视频什么明星B表示。

267
00:12:45,640 --> 00:12:50,230
我们将取消引用b和认沽
在该存储单元的一些值。

268
00:12:50,230 --> 00:12:51,860
在这种情况下，12。

269
00:12:51,860 --> 00:12:55,300
>> 因此，当我们取消引用点
记得我们刚出差向下的箭头。

270
00:12:55,300 --> 00:12:58,205
或者换一种说法，我们
去那个内存地址

271
00:12:58,205 --> 00:12:59,580
和我们操纵它以某种方式。

272
00:12:59,580 --> 00:13:00,830
我们把一些价值在里面。

273
00:13:00,830 --> 00:13:03,960
在这种情况下，星级住宿
等于M PLUS 2只

274
00:13:03,960 --> 00:13:08,230
去变量指向B，
到内存指向B，

275
00:13:08,230 --> 00:13:11,750
并把M PLUS 2在那里，12。

276
00:13:11,750 --> 00:13:14,970
>> 现在，我游离B。

277
00:13:14,970 --> 00:13:16,490
当我游离B，会发生什么？

278
00:13:16,490 --> 00:13:18,800
还记得我说的自由的手段。

279
00:13:18,800 --> 00:13:21,920
我说什么时候我游离B？

280
00:13:21,920 --> 00:13:23,410
>> 我做的工作呢，对吧？

281
00:13:23,410 --> 00:13:25,702
我基本上放弃了记忆。

282
00:13:25,702 --> 00:13:26,910
我给它回系统。

283
00:13:26,910 --> 00:13:33,010
我不需要这个了是
就是我要告诉他们，好不好？

284
00:13:33,010 --> 00:13:37,390
>> 现在，如果我说明星
等于11，你大概可以

285
00:13:37,390 --> 00:13:40,460
已经告诉坏事
将要发生在这里，对不对？

286
00:13:40,460 --> 00:13:44,160
事实上，如果我想，我大概
将遭受分割故障。

287
00:13:44,160 --> 00:13:47,140
因为现在，虽然
内存以前是块

288
00:13:47,140 --> 00:13:50,220
是的东西，我有
访问，在这一点

289
00:13:50,220 --> 00:13:54,590
现在我访问内存
是不合法的，我来访问。

290
00:13:54,590 --> 00:13:57,330
>> 当我们大概会
还记得，当我们访问内存

291
00:13:57,330 --> 00:14:00,000
我们不该碰，
这是最常见的原因

292
00:14:00,000 --> 00:14:01,860
一个分割
故障。所以我的计划

293
00:14:01,860 --> 00:14:05,170
会崩溃，如果我试图做到这一点。

294
00:14:05,170 --> 00:14:09,910
所以，这又是一个好主意，以获得良好的
实践和良好的生活习惯根深蒂固

295
00:14:09,910 --> 00:14:12,920
用malloc和free工作时，
这样你就不会遭受分割

296
00:14:12,920 --> 00:14:15,310
，而您使用的故障
您的动态分配

297
00:14:15,310 --> 00:14:17,370
内存负责任。

298
00:14:17,370 --> 00:14:20,300
>> 我是道格·劳埃德这是CS50。

299
00:14:20,300 --> 00:14:21,947