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星級住宿等於為int的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星級住宿等於為int的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