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

2
00:00:00,499 --> 00:00:01,395
[MUSIC nagpe-play]

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

4
00:00:05,590 --> 00:00:07,940
>> DOUG LLOYD: OK kaya ng mungkahi
bago simulan dito.

5
00:00:07,940 --> 00:00:11,660
Kung hindi mo pa napanood ang video sa
mga payo na maaaring gusto mong gawin ito sa unang.

6
00:00:11,660 --> 00:00:15,860
Dahil ang video na ito ay isa pang
paraan ng mga nagtatrabaho sa mga payo.

7
00:00:15,860 --> 00:00:17,574
>> Kaya ito ay pagpunta sa makipag-usap
tungkol sa ilang mga concepts

8
00:00:17,574 --> 00:00:19,490
na sumasaklaw namin sa
Payo ng video, at hindi namin

9
00:00:19,490 --> 00:00:21,948
pagpunta sa pagtakpan ang mga ito ngayon,
sa pag-aakala na ang mga ito na

10
00:00:21,948 --> 00:00:23,090
uri ng naiintindihan.

11
00:00:23,090 --> 00:00:25,440
Kaya ito lamang ang iyong makatarungang babala
na kung nakakakita ka ng video na ito

12
00:00:25,440 --> 00:00:27,814
at hindi mo pa nakita ang
payo video, maaaring ito ang uri ng mga

13
00:00:27,814 --> 00:00:29,610
lumipad sa ibabaw ng iyong ulo ng kaunti.

14
00:00:29,610 --> 00:00:32,080
At kaya ito ay maaaring maging mas mahusay na
upang panoorin ang mga ito sa mga na-order.

15
00:00:32,080 --> 00:00:34,710
>> Kaya namin na nakita ng isa
paraan upang gumana sa mga payo,

16
00:00:34,710 --> 00:00:37,810
na kung saan ay ipinahahayag natin ang isang
variable, at pagkatapos namin

17
00:00:37,810 --> 00:00:42,160
Ipinahahayag ng isa pang variable, isang pointer
variable, na ang mga puntos sa mga ito.

18
00:00:42,160 --> 00:00:44,870
Kaya ginawa namin ang isang
variable sa isang pangalan, na namin

19
00:00:44,870 --> 00:00:48,480
lumikha ng isang ikalawang variable na may pangalan,
at ituro namin na pangalawang variable

20
00:00:48,480 --> 00:00:50,220
sa na unang.

21
00:00:50,220 --> 00:00:52,370
Ang uri ng mga may
problema bagaman, dahil ito

22
00:00:52,370 --> 00:00:54,650
nangangailangan sa amin upang malaman ang eksaktong
kung magkano ang memory hindi namin

23
00:00:54,650 --> 00:00:57,600
pagpunta sa kailangan ang mga sandali
ang aming programa ay pinagsama-sama.

24
00:00:57,600 --> 00:00:58,220
>> Bakit na?

25
00:00:58,220 --> 00:01:03,338
Dahil kailangan namin upang ma-pangalan o
makilala ang lahat ng posibleng mga variable

26
00:01:03,338 --> 00:01:04,129
maaari nating makaharap.

27
00:01:04,129 --> 00:01:07,910
Maaari naming magkaroon ng isang array na maaaring maging
maaaring humawak ng isang pulutong ng mga impormasyon,

28
00:01:07,910 --> 00:01:10,110
pero hindi pa rin
eksakto tumpak na sapat.

29
00:01:10,110 --> 00:01:12,640
Paano kung hindi namin alam,
paano kung wala kaming ideya

30
00:01:12,640 --> 00:01:14,370
kung magkano ang kakailanganin naming sa itala oras?

31
00:01:14,370 --> 00:01:17,020
O kung ano kung ang aming mga programa ay
tumakbo para sa isang tunay na matagal na panahon,

32
00:01:17,020 --> 00:01:19,810
tumatanggap ng iba't-ibang user
data, at hindi namin maaaring tunay

33
00:01:19,810 --> 00:01:23,170
tantiyahin kung hindi namin
pagpunta sa kailangan 1,000 units?

34
00:01:23,170 --> 00:01:26,060
>> Ito ay hindi tulad ng aming makakaya
sabihin sa command line

35
00:01:26,060 --> 00:01:28,040
ipasok gaano karaming mga item
sa tingin mo na kailangan mo.

36
00:01:28,040 --> 00:01:31,100
Well kung ano na ang hula ay mali?

37
00:01:31,100 --> 00:01:34,300
Dynamic na laang-gugulin memory
uri ng nagbibigay-daan sa amin ang daan

38
00:01:34,300 --> 00:01:36,867
upang makakuha ng paligid na ito partikular na problema.

39
00:01:36,867 --> 00:01:38,700
At ang paraan na ito ay ito
ay sa pamamagitan ng paggamit ng mga payo.

40
00:01:38,700 --> 00:01:42,140
>> Maaari naming gamitin ang mga payo upang
makakuha ng access sa mga dynamic na

41
00:01:42,140 --> 00:01:45,710
inilalaan memory, memorya na
ilaan gaya ng iyong programa ay tumatakbo.

42
00:01:45,710 --> 00:01:48,290
Ito ay hindi inilalaan sa itala oras.

43
00:01:48,290 --> 00:01:51,570
Kapag pabago-bago mong maglaan
memory ito ay dumating mula sa isang pool

44
00:01:51,570 --> 00:01:53,795
ng memorya na kilala bilang ang magbunton.

45
00:01:53,795 --> 00:01:56,420
Dati lahat ng memorya na namin
ay nagtatrabaho sa sa kurso

46
00:01:56,420 --> 00:01:59,920
ay nagmumula sa isang pool
ng memorya na kilala bilang ang stack.

47
00:01:59,920 --> 00:02:02,470
Ang isang mahusay na paraan upang pangkalahatan
panatilihin sa mind-- at ang patakaran na ito

48
00:02:02,470 --> 00:02:04,720
ay hindi palaging hold totoo,
ngunit medyo marami ang halos

49
00:02:04,720 --> 00:02:09,940
laging humahawak true-- ay na ang anumang
panahon na kayo ay magbigay ng isang pangalan ng variable na ito

50
00:02:09,940 --> 00:02:12,090
marahil buhay sa stack.

51
00:02:12,090 --> 00:02:14,650
At anumang oras wala ka
magbigay ng isang variable ng isang pangalan,

52
00:02:14,650 --> 00:02:19,160
na maaari mong gawin sa mga dynamic na memory
laang-gugulin, ito ay nabubuhay sa magbunton.

53
00:02:19,160 --> 00:02:22,190
>> Ngayon ako uri ng pagtatanghal na ito bilang
kung may mga dalawang mga lawa ng memory.

54
00:02:22,190 --> 00:02:24,740
Ngunit maaari mo pa nakikita ito
diagram, na kung saan ay karaniwang

55
00:02:24,740 --> 00:02:27,290
isang kinatawan ng
kung ano ang memory kamukha,

56
00:02:27,290 --> 00:02:30,373
at hindi kami ay pagpunta sa pag-aalaga tungkol sa lahat ng
mga bagay-bagay sa itaas at sa ibaba.

57
00:02:30,373 --> 00:02:33,580
Anong pinapahalagahan namin ang tungkol ay ang bahagi na ito sa
gitna dito, magbunton at stack.

58
00:02:33,580 --> 00:02:35,570
Tulad ng iyong nakikita sa pamamagitan ng
naghahanap sa diagram na ito,

59
00:02:35,570 --> 00:02:38,390
mga aktwal na ay hindi dalawang
hiwalay na pool ng memory.

60
00:02:38,390 --> 00:02:42,757
Ito ay isa sa mga shared pool ng memory
kung saan ka magsimula, sa ganitong visual

61
00:02:42,757 --> 00:02:44,590
magsimula ka sa ibaba
at simulan ang pagpuno up

62
00:02:44,590 --> 00:02:48,040
mula sa ilalim ng stack, at ikaw
simulan sa itaas at simulan ang pagpuno up

63
00:02:48,040 --> 00:02:50,072
mula sa tuktok pababa sa magbunton.

64
00:02:50,072 --> 00:02:51,780
Ngunit ito ay tunay na ang
parehong pool, ito lang

65
00:02:51,780 --> 00:02:56,050
iba't-ibang lugar, iba't-ibang mga lokasyon
sa memory na ay inilalaan.

66
00:02:56,050 --> 00:02:59,060
At maaari kang magpatakbo ng mga
memory sa pamamagitan ng alinman sa pagkakaroon

67
00:02:59,060 --> 00:03:01,240
magbunton pumunta sa lahat ng paraan
hanggang sa ibaba, o may

68
00:03:01,240 --> 00:03:05,440
stack pumunta sa lahat ng mga paraan sa itaas,
o pagkakaroon ng magbunton at ang salansan

69
00:03:05,440 --> 00:03:06,740
makipagkita sa isa't isa.

70
00:03:06,740 --> 00:03:09,500
Lahat ng mga maaaring maging mga kondisyon
na naging sanhi ng iyong mga programa

71
00:03:09,500 --> 00:03:11,030
pagka-ubos ng memory.

72
00:03:11,030 --> 00:03:11,952
Kaya panatilihin na sa isip.

73
00:03:11,952 --> 00:03:13,660
Kapag pinag-uusapan natin
magbunton at ang salansan

74
00:03:13,660 --> 00:03:17,880
ang talagang pinag-uusapan natin ang tungkol sa mga
parehong pangkalahatang tipak ng memory, lamang

75
00:03:17,880 --> 00:03:21,930
iba't-ibang mga bahagi ng na memory.

76
00:03:21,930 --> 00:03:24,910
>> Kaya paano namin makuha magilas
inilalaan memory sa unang lugar?

77
00:03:24,910 --> 00:03:27,740
Paano gumagana ang aming programa makakuha ng
memorya bilang tumatakbo ito?

78
00:03:27,740 --> 00:03:32,660
Well C ay nagbibigay ng isang function na tinatawag na
malloc, memory allocator, na

79
00:03:32,660 --> 00:03:36,810
gumawa ka ng isang tawag sa, at pumasa ka sa
kung ilang bytes ng memorya na gusto mo.

80
00:03:36,810 --> 00:03:39,940
Kaya kung ang iyong programa ay tumatakbo
at gusto mo ang isang integer runtime,

81
00:03:39,940 --> 00:03:46,040
baka Mallock apat na bytes ng
memory, malloc panaklong apat.

82
00:03:46,040 --> 00:03:48,540
>> Mallock ay pumunta sa pamamagitan
naghahanap sa pamamagitan ng magbunton,

83
00:03:48,540 --> 00:03:50,750
dahil hindi namin magilas
paglaan ng memorya,

84
00:03:50,750 --> 00:03:53,500
at ito ay babalik sa inyo
isang pointer sa na memory.

85
00:03:53,500 --> 00:03:56,180
Hindi magbibigay sa iyo na na memorya
ito ay hindi na bigyan ito ng isang pangalan,

86
00:03:56,180 --> 00:03:57,950
ito ay nagbibigay sa iyo ng isang pointer dito.

87
00:03:57,950 --> 00:04:00,780
At kaya na ang dahilan kung bakit muli sinabi ko
na ito ay mahalaga sa siguro

88
00:04:00,780 --> 00:04:03,770
pinapanood ang mga payo video
bago namin makuha masyadong malayo sa ito.

89
00:04:03,770 --> 00:04:05,940
Kaya malloc pupuntahan
bigyan kayo ng isang pointer.

90
00:04:05,940 --> 00:04:08,950
>> Kung hindi maaaring magbigay sa iyo Mallock anumang
memory dahil mo na maubusan,

91
00:04:08,950 --> 00:04:10,645
ito ay magbibigay sa iyo ng likod ng isang null pointer.

92
00:04:10,645 --> 00:04:15,282
Huwag mo matandaan kung ano ang mangyayari kung namin
subukan at dereference isang null pointer?

93
00:04:15,282 --> 00:04:17,019
Magtiis kami ng isang seg fault, di ba?

94
00:04:17,019 --> 00:04:18,060
Iyon ay marahil hindi mabuti.

95
00:04:18,060 --> 00:04:21,579
>> Kaya sa bawat oras na gumawa ng isang tawag
malloc ka palagi, palaging

96
00:04:21,579 --> 00:04:25,270
kailangan upang suriin kung o hindi ang
pointer ito ay nagbigay sa iyo ng likod ay null.

97
00:04:25,270 --> 00:04:28,800
Kung ito ay, kailangan mong tapusin ang iyong programa
dahil kung susubukan mo at dereference

98
00:04:28,800 --> 00:04:31,360
ang null pointer ka pagpunta
upang magdusa ng segmentation fault

99
00:04:31,360 --> 00:04:34,380
at ang iyong programa ay
pagpunta sa crash pa rin.

100
00:04:34,380 --> 00:04:37,190
Kaya paano namin statically
makakuha ng isang integer?

101
00:04:37,190 --> 00:04:37,730
>> int x.

102
00:04:37,730 --> 00:04:40,010
Marahil nagawa namin na
isang grupo ng mga beses, tama?

103
00:04:40,010 --> 00:04:43,480
Lumilikha ito ng isang variable na tinatawag na
x na nakatira sa stack.

104
00:04:43,480 --> 00:04:46,190
Paano magilas kami makakuha ng isang integer?

105
00:04:46,190 --> 00:04:50,010
Int star px katumbas malloc 4.

106
00:04:50,010 --> 00:04:53,050
>> O mas angkop
Gusto naming sabihin int star px

107
00:04:53,050 --> 00:04:57,680
ay katumbas ng malloc laki ng int,
upang itapon lamang ang ilang mga mas kaunting

108
00:04:57,680 --> 00:04:59,740
magic numero sa paligid ng aming programa.

109
00:04:59,740 --> 00:05:04,140
Ito ay pagpunta upang makakuha ng para sa amin
apat na bytes ng memorya mula sa magbunton,

110
00:05:04,140 --> 00:05:06,720
at ang pointer na nakukuha namin
bumalik sa mga ito ay tinatawag na px.

111
00:05:06,720 --> 00:05:08,430
At pagkatapos ay tulad na namin
tapos namin dati

112
00:05:08,430 --> 00:05:13,966
Maaari dereference px sa
access na memory.

113
00:05:13,966 --> 00:05:15,590
Paano kami makakuha ng isang integer mula sa user?

114
00:05:15,590 --> 00:05:17,970
Maaari naming sabihin int x ay katumbas makakuha int.

115
00:05:17,970 --> 00:05:19,930
Iyan ay medyo tapat.

116
00:05:19,930 --> 00:05:24,030
Paano kung gusto naming lumikha ng isang array
ng x sa kamay na nakatira sa stack?

117
00:05:24,030 --> 00:05:28,210
lumutang stack_array-- na ang pangalan
ng ating array-- square bracket x.

118
00:05:28,210 --> 00:05:32,419
Iyon ay lumikha para sa atin ng isang array
ng x sa kamay na nakatira sa stack.

119
00:05:32,419 --> 00:05:34,960
Maaari naming lumikha ng isang hanay ng mga kamay
na nakatira sa magbunton, masyadong.

120
00:05:34,960 --> 00:05:37,330
Maaaring tumingin syntax Ang isang
maliit na mas mahirap,

121
00:05:37,330 --> 00:05:41,740
ngunit maaari naming sabihin float
star heap_array katumbas

122
00:05:41,740 --> 00:05:44,360
malloc x beses ang laki ng float.

123
00:05:44,360 --> 00:05:48,160
Kailangan ko ng sapat na silid na humawak
x lumulutang halaga punto.

124
00:05:48,160 --> 00:05:51,560
Kaya sabihin na kailangan ko 100
sa kamay, o 1,000 kamay.

125
00:05:51,560 --> 00:05:54,810
Kaya sa kaso na ito ay magiging
400 bytes para sa 100 sa kamay,

126
00:05:54,810 --> 00:05:59,080
o 4,000 bytes para sa 1,000 mga kamay,
dahil ang bawat float ay tumatagal ng hanggang

127
00:05:59,080 --> 00:06:01,230
apat na bytes ng espasyo.

128
00:06:01,230 --> 00:06:05,110
>> Matapos gawin ito maaari ko bang gamitin ang
square bracket syntax sa heap_array.

129
00:06:05,110 --> 00:06:08,970
Tulad ng gagawin ko sa stack_array, ako
Maaaring i-access elemento nito isa-isa

130
00:06:08,970 --> 00:06:11,590
gamit heap_array zero, heap_array isa.

131
00:06:11,590 --> 00:06:15,800
Ngunit isipin ang mga dahilan maaari naming gawin iyon
ay dahil ang pangalan ng isang array sa C

132
00:06:15,800 --> 00:06:19,990
ay talagang isang pointer sa
unang elemento na array ni.

133
00:06:19,990 --> 00:06:23,480
Kaya ang katotohanan na ay deklarasyon kami ng isang
ang dami ng mga kamay sa stack dito

134
00:06:23,480 --> 00:06:24,810
ay talagang isang bit nakaliligaw.

135
00:06:24,810 --> 00:06:27,600
Kami ay talagang nasa
pangalawang linya ng code doon

136
00:06:27,600 --> 00:06:32,360
paglikha ng isang pointer sa isang tipak ng
memory na pagkatapos ay gawin namin ang ilang mga trabaho sa.

137
00:06:32,360 --> 00:06:35,620
>> Narito ang malaking problema sa
dynamic na inilalaan memory bagaman,

138
00:06:35,620 --> 00:06:38,360
at ito ang dahilan kung bakit ito ay talagang
mahalaga upang bumuo ng ilang mga mahusay na mga gawi

139
00:06:38,360 --> 00:06:39,800
kapag ikaw ay nagtatrabaho sa mga ito.

140
00:06:39,800 --> 00:06:43,060
Hindi tulad ng statically ipinahayag
memorya, ang iyong memory

141
00:06:43,060 --> 00:06:46,790
ay hindi awtomatikong ibabalik sa
sistema kapag ang iyong mga function ay tapos na.

142
00:06:46,790 --> 00:06:49,280
Kaya kung mayroon main namin, at
pangunahing tawag ng isang function

143
00:06:49,280 --> 00:06:53,860
f, kapag f pagda anumang ito ay ginagawa
at nagbabalik ng kontrol ng programa

144
00:06:53,860 --> 00:06:58,810
bumalik sa pangunahing, ang lahat ng memory
na f ginagamit ay ibinigay pabalik.

145
00:06:58,810 --> 00:07:01,250
Ito ay maaaring gamitin muli
sa pamamagitan ng ilang mga iba pang programa,

146
00:07:01,250 --> 00:07:04,250
o ilang iba pang mga function na
makakakuha ng tinatawag na sa susunod sa main.

147
00:07:04,250 --> 00:07:06,970
Maaari itong gamitin ang parehong memory-ulit.

148
00:07:06,970 --> 00:07:09,620
>> Kung ikaw magilas
maglaan ng memorya na

149
00:07:09,620 --> 00:07:14,380
ikaw ay may upang malinaw na sabihin ang
sistema na tapos ka na sa mga ito.

150
00:07:14,380 --> 00:07:18,370
Makikita ito hold papunta ito para sa iyo, na maaaring
humantong sa isang problema ng ka nauubusan

151
00:07:18,370 --> 00:07:19,290
ng memorya.

152
00:07:19,290 --> 00:07:22,179
At sa katunayan minsan naming sumangguni
sa ito bilang isang memory tumagas.

153
00:07:22,179 --> 00:07:24,970
At kung minsan ang mga paglabas ng memorya
aktwal na maaaring maging talagang nagwawasak

154
00:07:24,970 --> 00:07:27,020
para sa sistema ng pagganap.

155
00:07:27,020 --> 00:07:31,120
>> Kung ikaw ay isang madalas na gumagamit ng internet
maaari mong gamitin ang ilang mga web browser,

156
00:07:31,120 --> 00:07:35,630
at hindi ko na pangalan ng mga pangalan dito, ngunit
may ilang mga web browser out doon

157
00:07:35,630 --> 00:07:39,150
na kilalang-kilala sa tunay na pagkakaroon
memory paglabas na hindi makakuha ng maayos.

158
00:07:39,150 --> 00:07:44,570
At kung iwan mo bukas ang iyong browser
para sa isang mahabang tagal ng panahon, araw

159
00:07:44,570 --> 00:07:48,060
at araw, o linggo, ikaw minsan
Maaaring mapansin na ang iyong system

160
00:07:48,060 --> 00:07:49,790
ay tumatakbo tunay, tunay dahan-dahan.

161
00:07:49,790 --> 00:07:54,640
At ang mga dahilan para sa na ay na
ang browser ay inilalaan memory,

162
00:07:54,640 --> 00:07:57,320
ngunit pagkatapos ay hindi sinasabi sa sistema
na ito ay tapos na sa mga ito.

163
00:07:57,320 --> 00:08:01,000
At upang ang mga dahon ng mas mababa memory
magagamit para sa lahat ng iyong iba pang mga programa

164
00:08:01,000 --> 00:08:04,480
sa may upang ibahagi, dahil ikaw ay
leaking-- na web browser

165
00:08:04,480 --> 00:08:06,755
program ay pagtulo memory.

166
00:08:06,755 --> 00:08:08,880
Paano ako magbibigay kami memory back
kapag tapos na kami sa mga ito?

167
00:08:08,880 --> 00:08:10,838
Well sa kabutihang-palad ito ay isang
napakadaling paraan upang gawin ito.

168
00:08:10,838 --> 00:08:11,710
Magbakante lang namin ito.

169
00:08:11,710 --> 00:08:15,020
May isang function na tinatawag na libre,
ito ay tumatanggap ng isang pointer sa memory,

170
00:08:15,020 --> 00:08:16,010
at kami ay handa na upang patakbuhin.

171
00:08:16,010 --> 00:08:18,310
>> Kaya sabihin nating tayo'y nasa
gitna ng aming programa,

172
00:08:18,310 --> 00:08:21,970
gusto naming malloc 50 character.

173
00:08:21,970 --> 00:08:25,710
Gusto naming malloc isang array na maaari
kaya ng mga humahawak ng 50 mga character.

174
00:08:25,710 --> 00:08:29,109
At kapag kami makakuha ng isang pointer pabalik sa
na iyon, pangalan na pointer ay salita.

175
00:08:29,109 --> 00:08:30,900
Ginagawa namin ang anumang hindi namin
pagpunta sa gawin sa mga salita,

176
00:08:30,900 --> 00:08:33,440
at pagkatapos ay kapag hindi namin
tapos magbakante namin ito lamang.

177
00:08:33,440 --> 00:08:37,460
At ngayon ay nagbalik kami sa mga 50
bytes ng memory pabalik sa sistema.

178
00:08:37,460 --> 00:08:40,147
Maaaring gamitin ang mga ito sa ilang ibang mga function.

179
00:08:40,147 --> 00:08:43,480
Hindi namin kailangang mag-alala tungkol sa paghihirap ng isang
memory tumagas dahil nabakante namin salita.

180
00:08:43,480 --> 00:08:46,639
Nagbigay kami ng mga memory back,
kaya tapos na kami nagtatrabaho sa mga ito.

181
00:08:46,639 --> 00:08:48,430
Kaya may tatlong
ginintuang mga patakaran na dapat

182
00:08:48,430 --> 00:08:51,700
manatili sa isip sa tuwing ikaw ay
magilas paglaan memory

183
00:08:51,700 --> 00:08:52,990
may malloc.

184
00:08:52,990 --> 00:08:56,480
Bawat bloke ng memorya na
mong malloc ay dapat na napalaya

185
00:08:56,480 --> 00:08:58,430
bago ang iyong programa pagda tumatakbo.

186
00:08:58,430 --> 00:09:02,029
Ngayon muli, sa appliance o sa
Ang ganitong uri ng mangyayari IDE para sa iyo anyway

187
00:09:02,029 --> 00:09:04,820
kapag you-- ito ay mangyayari pa rin
kapag ang iyong programa ay tinapos,

188
00:09:04,820 --> 00:09:06,880
lahat ng memory ay pinakawalan.

189
00:09:06,880 --> 00:09:10,750
Ngunit ito ay sa pangkalahatan ay mabuti coding
pagsasanay upang lagi, kapag tapos ka na,

190
00:09:10,750 --> 00:09:13,810
magbakante kung ano ang iyong mallocd.

191
00:09:13,810 --> 00:09:16,690
>> Sa gayon, ang mga bagay lamang na
na sa iyo na mallocd dapat na napalaya.

192
00:09:16,690 --> 00:09:19,880
Kung statically mong magpahayag ng isang
integer, int x semi-colon,

193
00:09:19,880 --> 00:09:23,500
na nakatira sa stack, ikaw
hindi pagkatapos ay nais na magbakante x.

194
00:09:23,500 --> 00:09:25,970
Kaya lamang ang mga bagay na na sa iyo
mallocd dapat na napalaya.

195
00:09:25,970 --> 00:09:28,960
>> At bilang wakas, hindi libre ang isang bagay nang dalawang beses.

196
00:09:28,960 --> 00:09:31,170
Iyon ay maaaring humantong sa
isa pang kakaiba sitwasyon.

197
00:09:31,170 --> 00:09:33,530
Kaya lahat ng bagay na na sa iyo
mallocd ay dapat napalaya.

198
00:09:33,530 --> 00:09:36,000
Tanging mga bagay na na sa iyo
dapat na napalaya malloc.

199
00:09:36,000 --> 00:09:38,730
At gawin mo ang hindi libre ang isang bagay nang dalawang beses.

200
00:09:38,730 --> 00:09:43,660
>> Kaya sabihin pumunta sa pamamagitan ng isang halimbawa dito
ng kung ano ang ilang mga dynamic na inilalaan

201
00:09:43,660 --> 00:09:46,122
Maaaring tumingin memory tulad mixed
sa may ilang mga static memory.

202
00:09:46,122 --> 00:09:47,080
Ano ang maaaring mangyari dito?

203
00:09:47,080 --> 00:09:48,913
Tingnan kung maaari mong sundin ang
kasama at hulaan kung ano ang

204
00:09:48,913 --> 00:09:51,720
pagpunta sa mangyayari habang tayo'y
sa pamamagitan ng lahat ng mga linya ng code.

205
00:09:51,720 --> 00:09:53,980
>> Kaya sinasabi namin int m.

206
00:09:53,980 --> 00:09:54,840
Ano ang mangyayari dito?

207
00:09:54,840 --> 00:09:56,339
Well ito ay medyo direkta.

208
00:09:56,339 --> 00:09:59,650
Gumawa ako ng isang variable integer tinatawag m.

209
00:09:59,650 --> 00:10:01,400
Kulayan ko ito green,
dahil iyon ang kulay

210
00:10:01,400 --> 00:10:03,730
na gamit ko kapag ako ng pakikipag-usap
tungkol sa mga variable integer.

211
00:10:03,730 --> 00:10:05,160
Ito ay isang box.

212
00:10:05,160 --> 00:10:08,400
Ito ay tinatawag na m, at maaari mong
Tindahan ng integer sa loob ng mga ito.

213
00:10:08,400 --> 00:10:12,400
>> Paano kung pagkatapos kong sabihin int star ang isang?

214
00:10:12,400 --> 00:10:13,530
Well na medyo katulad.

215
00:10:13,530 --> 00:10:15,780
Lumilikha ako ng isang kahon na tinatawag na a.

216
00:10:15,780 --> 00:10:19,100
Ito ay kaya ng mga humahawak int
bituin, mga payo sa integer.

217
00:10:19,100 --> 00:10:21,570
Kaya ako pangkulay ito green-ish rin.

218
00:10:21,570 --> 00:10:24,140
>> Alam ko na ito ay may isang bagay
ang gagawin sa isang integer,

219
00:10:24,140 --> 00:10:25,852
pero hindi ito mismo ng isang integer.

220
00:10:25,852 --> 00:10:27,310
Ngunit ito ay medyo marami ang parehong ideya.

221
00:10:27,310 --> 00:10:28,101
Lumikha ako ng isang box.

222
00:10:28,101 --> 00:10:30,070
Pareho ng mga karapatan
Live na ngayon sa stack.

223
00:10:30,070 --> 00:10:32,520
Ibinigay ko sa iyo ang mga ito sa parehong mga pangalan.

224
00:10:32,520 --> 00:10:36,750
>> int star b katumbas malloc laki ng int.

225
00:10:36,750 --> 00:10:38,560
Maaaring maging isang maliit na nakakalito Isa na ito.

226
00:10:38,560 --> 00:10:44,110
Kumuha ng isang pangalawang at isipin ang tungkol kung ano ang iyong
ay inaasahan na mangyayari sa diagram na ito.

227
00:10:44,110 --> 00:10:50,210
int star b katumbas malloc laki ng int.

228
00:10:50,210 --> 00:10:51,940
>> Well ito ay hindi lamang lumikha ng isang kahon.

229
00:10:51,940 --> 00:10:53,800
Ito ang tunay na lumilikha ng dalawang mga kahon.

230
00:10:53,800 --> 00:10:58,670
At ito relasyon, ito rin ay nagtatatag
isang punto sa isang relasyon.

231
00:10:58,670 --> 00:11:02,240
Inilalaan namin ang isang bloke
ng memory sa magbunton.

232
00:11:02,240 --> 00:11:05,940
Pansinin na sa itaas na kanang box
doon ay walang isang pangalan.

233
00:11:05,940 --> 00:11:06,760
>> Mallocd namin ito.

234
00:11:06,760 --> 00:11:08,050
Ito ay umiiral sa magbunton.

235
00:11:08,050 --> 00:11:10,090
Ngunit b ay may pangalan.

236
00:11:10,090 --> 00:11:11,950
Ito ay isang variable pointer na tinatawag na b.

237
00:11:11,950 --> 00:11:13,910
Na nakatira sa stack.

238
00:11:13,910 --> 00:11:18,250
>> Kaya ito ay isang piraso ng memory
na puntos sa isa pa.

239
00:11:18,250 --> 00:11:21,840
b ay naglalaman ng mga address
ng na block ng memory.

240
00:11:21,840 --> 00:11:23,757
Hindi nito ay may kabilang banda ng isang pangalan.

241
00:11:23,757 --> 00:11:24,590
Ngunit ang mga puntos sa mga ito.

242
00:11:24,590 --> 00:11:29,760
Kaya kapag sinasabi namin int star b ay katumbas ng
size malloc ng int, na may karapatan,

243
00:11:29,760 --> 00:11:33,490
na arrow na pop up sa
kanang bahagi doon, na buong bagay,

244
00:11:33,490 --> 00:11:36,740
Kukuha ako ng lumabas ito
muli, ay kung ano ang mangyayari.

245
00:11:36,740 --> 00:11:39,341
Lahat ng na mangyayari sa
na iisang linya ng code.

246
00:11:39,341 --> 00:11:41,340
Ngayon kami makakuha ng kaunti pa
prangka muli.

247
00:11:41,340 --> 00:11:43,330
isang katumbas ampersand m.

248
00:11:43,330 --> 00:11:46,280
Natatandaan mo pa ba kung ano ang isang
ay katumbas ng ampersand m ay?

249
00:11:46,280 --> 00:11:48,920
Well iyon ang isang makakakuha address m.

250
00:11:48,920 --> 00:11:54,150
O ilagay ang higit diagrammatically,
isang punto upang m.

251
00:11:54,150 --> 00:11:56,360
>> isang katumbas b.

252
00:11:56,360 --> 00:11:57,560
OK kaya dito ay ang isa pa.

253
00:11:57,560 --> 00:11:59,230
A ay katumbas ng b.

254
00:11:59,230 --> 00:12:02,260
Ano kaya ang mangyari
sa diagram oras na ito?

255
00:12:02,260 --> 00:12:04,330
>> Well pagpapabalik na ang
gawa assignment operator

256
00:12:04,330 --> 00:12:08,960
sa pamamagitan ng pagtatalaga ng mga halaga sa mga
karapatan sa halaga sa kaliwa.

257
00:12:08,960 --> 00:12:14,820
Kaya sa halip ng isang pagturo sa m, isang ngayon
puntos sa parehong lugar na b points.

258
00:12:14,820 --> 00:12:18,900
isang ay hindi point sa b, isang
puntos kung saan b points.

259
00:12:18,900 --> 00:12:25,280
>> Kung ang isang matulis na b na gagawin
ay isang katumbas ng ampersand b.

260
00:12:25,280 --> 00:12:28,150
Ngunit sa halip na isang katumbas b lamang
ay nangangahulugan na at b mga ngayon

261
00:12:28,150 --> 00:12:31,770
na tumuturo sa parehong address, dahil
sa loob ng b ay lamang ng isang address.

262
00:12:31,770 --> 00:12:35,004
At ngayon sa loob ng isang ay ang parehong address.

263
00:12:35,004 --> 00:12:37,170
m ay katumbas ng 10, malamang na ang
pinaka-tapat na bagay

264
00:12:37,170 --> 00:12:38,690
nagawa namin sa isang maliit na bit.

265
00:12:38,690 --> 00:12:40,460
Ilagay ang 10 sa kahon.

266
00:12:40,460 --> 00:12:45,640
Star b katumbas m plus 2, isipin ang mula sa
ang aming mga payo video kung ano ang star b ibig sabihin nito.

267
00:12:45,640 --> 00:12:50,230
Kami ay pagpunta sa dereference b at ilagay
ilang mga halaga sa na lokasyon sa memorya.

268
00:12:50,230 --> 00:12:51,860
Sa kasong ito 12.

269
00:12:51,860 --> 00:12:55,300
>> Kaya kapag kami dereference ng isang punto ng
pagpapabalik paglalakbay lamang namin down arrow.

270
00:12:55,300 --> 00:12:58,205
O ilagay ang isa pang paraan, tayo
pumunta sa na memory address

271
00:12:58,205 --> 00:12:59,580
at manipulahin namin ito sa ilang mga paraan.

272
00:12:59,580 --> 00:13:00,830
Naglaan na kami ng ilang mga halaga sa doon.

273
00:13:00,830 --> 00:13:03,960
Sa ganitong kaso star b
ay katumbas ng m plus 2 lang

274
00:13:03,960 --> 00:13:08,230
pumunta sa variable na nakatutok sa pamamagitan b,
pumunta sa memory nakatutok sa pamamagitan b,

275
00:13:08,230 --> 00:13:11,750
at ilagay m plus 2 sa doon, 12.

276
00:13:11,750 --> 00:13:14,970
>> Ngayon magbakante ko b.

277
00:13:14,970 --> 00:13:16,490
Ano ang mangyayari kapag magbakante ko b?

278
00:13:16,490 --> 00:13:18,800
Tandaan kung ano ang sinabi ko sa libreng paraan.

279
00:13:18,800 --> 00:13:21,920
Ano ako sinasabi kapag magbakante ko b?

280
00:13:21,920 --> 00:13:23,410
>> Tapos na akong nagtatrabaho sa mga ito, right?

281
00:13:23,410 --> 00:13:25,702
Ako ay mahalagang bigyan up ang memorya.

282
00:13:25,702 --> 00:13:26,910
Ako bigyan ito pabalik sa sistema.

283
00:13:26,910 --> 00:13:33,010
Hindi ko kailangan ang mga ito anymore ay
kung ano ang ako sinasabi sa kanila, OK?

284
00:13:33,010 --> 00:13:37,390
>> Ngayon kung sinasabi ko star ang isang
ay katumbas ng 11 maaari mong malamang

285
00:13:37,390 --> 00:13:40,460
na sabihin na ang isang bagay masamang
ang mangyayari dito, tama?

286
00:13:40,460 --> 00:13:44,160
At sa katunayan kung sinubukan ko na ako ay marahil
ay magdanas ng segmentation fault.

287
00:13:44,160 --> 00:13:47,140
Dahil ngayon, bagama't
dati na tipak ng memory

288
00:13:47,140 --> 00:13:50,220
ay isang bagay na ako ay
pag-access sa, sa puntong ito

289
00:13:50,220 --> 00:13:54,590
ngayon ako sa pag-access ng memorya na
ay hindi legal na para sa akin upang i-access.

290
00:13:54,590 --> 00:13:57,330
>> At bilang ay namin marahil
pagpapabalik, kapag na-access namin memory

291
00:13:57,330 --> 00:14:00,000
na hindi namin ay dapat na hawakan,
iyon ang pinaka-karaniwang dahilan

292
00:14:00,000 --> 00:14:01,860
ng isang segmentation
kasalanan. At kaya ang aking programa

293
00:14:01,860 --> 00:14:05,170
ay nagka-crash kung sinubukan kong gawin ito.

294
00:14:05,170 --> 00:14:09,910
Kaya muli ito ay isang magandang ideya upang makakuha ng magandang
pagsasanay at mahusay na mga gawi nakatanim

295
00:14:09,910 --> 00:14:12,920
kapag nagtatrabaho sa malloc at libreng,
sa gayon ay hindi mo magdusa segmentation

296
00:14:12,920 --> 00:14:15,310
pagkakamali, at ginagamit mo
ang iyong dynamic na inilalaan

297
00:14:15,310 --> 00:14:17,370
memory responsable.

298
00:14:17,370 --> 00:14:20,300
>> Ako Doug Lloyd ito ay CS50.

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