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

2
00:00:00,499 --> 00:00:01,395
[MUSIK SPELA]

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

4
00:00:05,590 --> 00:00:07,940
>> DOUG LLOYD: OK så ett förslag
innan här.

5
00:00:07,940 --> 00:00:11,660
Om du inte har sett videon på
pekare som du kanske vill göra det först.

6
00:00:11,660 --> 00:00:15,860
Eftersom den här videon är en annan
sätt att arbeta med pekare.

7
00:00:15,860 --> 00:00:17,574
>> Så det kommer att prata
om vissa begrepp

8
00:00:17,574 --> 00:00:19,490
som vi täcker i
pekare video, och vi är

9
00:00:19,490 --> 00:00:21,948
kommer att släta över dem nu,
förutsatt att de är redan

10
00:00:21,948 --> 00:00:23,090
sorts förstådd.

11
00:00:23,090 --> 00:00:25,440
Så det är bara din skälig varning
att om du ser den här videon

12
00:00:25,440 --> 00:00:27,814
och du har inte sett
pekare video, kanske det slags

13
00:00:27,814 --> 00:00:29,610
flyga över huvudet lite.

14
00:00:29,610 --> 00:00:32,080
Och så det kan vara bättre
att titta på det i den ordningen.

15
00:00:32,080 --> 00:00:34,710
>> Så vi har redan sett en
sätt att arbeta med pekare,

16
00:00:34,710 --> 00:00:37,810
som är deklarerar vi en
variabel och sedan vi

17
00:00:37,810 --> 00:00:42,160
förklara en annan variabel, en pekare
variabel, pekar det till den.

18
00:00:42,160 --> 00:00:44,870
Så vi har skapat en
variabel med ett namn, vi har

19
00:00:44,870 --> 00:00:48,480
skapade en andra variabel med ett namn,
och vi peka att andra variabel

20
00:00:48,480 --> 00:00:50,220
vid den första.

21
00:00:50,220 --> 00:00:52,370
Denna typ av har en
problem men eftersom det

22
00:00:52,370 --> 00:00:54,650
kräver att vi vet exakt
hur mycket minne som vi är

23
00:00:54,650 --> 00:00:57,600
kommer att behöva för tillfället
vårt program kompileras.

24
00:00:57,600 --> 00:00:58,220
>> Varför?

25
00:00:58,220 --> 00:01:03,338
Eftersom vi måste kunna namnge eller
identifiera alla möjliga variabler

26
00:01:03,338 --> 00:01:04,129
vi kan stöta på.

27
00:01:04,129 --> 00:01:07,910
Vi kanske har en matris som kan vara
kunna hålla en hel del information,

28
00:01:07,910 --> 00:01:10,110
men det är fortfarande inte
precis tillräckligt exakt.

29
00:01:10,110 --> 00:01:12,640
Vad händer om vi inte vet,
tänk om vi har ingen aning

30
00:01:12,640 --> 00:01:14,370
hur mycket vi behöver vid kompileringen?

31
00:01:14,370 --> 00:01:17,020
Eller vad händer om vårt program kommer
pågå under en väldigt lång tid,

32
00:01:17,020 --> 00:01:19,810
acceptera olika användare
data och vi kan inte riktigt

33
00:01:19,810 --> 00:01:23,170
bedöma om vi är
kommer att behöva 1.000 enheter?

34
00:01:23,170 --> 00:01:26,060
>> Det är inte som vi kan
säger på kommandoraden

35
00:01:26,060 --> 00:01:28,040
ange hur många objekt
du tror att du behöver.

36
00:01:28,040 --> 00:01:31,100
Och vad om det gissning är fel?

37
00:01:31,100 --> 00:01:34,300
Dynamisk minnesallokering
sorts tillåter oss vägen

38
00:01:34,300 --> 00:01:36,867
att komma runt detta problem.

39
00:01:36,867 --> 00:01:38,700
Och den gör det
är att använda pekare.

40
00:01:38,700 --> 00:01:42,140
>> Vi kan använda pekare till
få tillgång till dynamiskt

41
00:01:42,140 --> 00:01:45,710
allokerat minne, minne som är
fördelas enligt programmet körs.

42
00:01:45,710 --> 00:01:48,290
Det är inte tilldelas vid kompileringen.

43
00:01:48,290 --> 00:01:51,570
När du dynamiskt fördela
minne det kommer från en pool

44
00:01:51,570 --> 00:01:53,795
minne kallas högen.

45
00:01:53,795 --> 00:01:56,420
Tidigare hela minnet vi har
arbetat med under loppet

46
00:01:56,420 --> 00:01:59,920
har kommit från en pool
minne som kallas stapeln.

47
00:01:59,920 --> 00:02:02,470
Ett bra sätt att allmänt
hålla mind-- och denna regel

48
00:02:02,470 --> 00:02:04,720
inte alltid hålla sant,
men ganska mycket nästan

49
00:02:04,720 --> 00:02:09,940
alltid håller true-- är att varje
gång du ger ett variabelnamn det

50
00:02:09,940 --> 00:02:12,090
förmodligen bor på stacken.

51
00:02:12,090 --> 00:02:14,650
Och varje gång du gör inte
ge en variabel ett namn,

52
00:02:14,650 --> 00:02:19,160
som du kan göra med dynamiskt minne
tilldelning, lever den på högen.

53
00:02:19,160 --> 00:02:22,190
>> Nu är jag typ att presentera detta som
om det finns dessa två pooler av minne.

54
00:02:22,190 --> 00:02:24,740
Men du kanske har sett denna
schema, som i allmänhet är

55
00:02:24,740 --> 00:02:27,290
en representation av
hur minne ser ut,

56
00:02:27,290 --> 00:02:30,373
och vi kommer inte att bry sig om alla
grejer på toppen och botten.

57
00:02:30,373 --> 00:02:33,580
Vad vi bryr oss om är denna del i
mitten här, hög och stack.

58
00:02:33,580 --> 00:02:35,570
Som ni kan se av
titta på detta diagram,

59
00:02:35,570 --> 00:02:38,390
dessa faktiskt inte två
separata pooler minne.

60
00:02:38,390 --> 00:02:42,757
Det är en delad pool av minne
där du börjar i denna visuella

61
00:02:42,757 --> 00:02:44,590
du börjar längst ner
och börja fylla upp

62
00:02:44,590 --> 00:02:48,040
från botten med bunten, och ni
börja i toppen och börja fylla upp

63
00:02:48,040 --> 00:02:50,072
uppifrån och ner med högen.

64
00:02:50,072 --> 00:02:51,780
Men det är verkligen
samma pool, det är bara

65
00:02:51,780 --> 00:02:56,050
olika platser, olika platser
i minnet som fördelas.

66
00:02:56,050 --> 00:02:59,060
Och du kan få slut på
minne genom att antingen ha

67
00:02:59,060 --> 00:03:01,240
högen gå hela vägen
till botten, eller har

68
00:03:01,240 --> 00:03:05,440
stacken gå hela vägen till toppen,
eller som har högen och stapeln

69
00:03:05,440 --> 00:03:06,740
möta upp mot varandra.

70
00:03:06,740 --> 00:03:09,500
Alla dessa kan vara villkor
som orsakar ditt program

71
00:03:09,500 --> 00:03:11,030
att få slut på minne.

72
00:03:11,030 --> 00:03:11,952
Så ha det i åtanke.

73
00:03:11,952 --> 00:03:13,660
När vi talar om
högen och stack

74
00:03:13,660 --> 00:03:17,880
vi egentligen talar om
samma allmänna bit av minne,

75
00:03:17,880 --> 00:03:21,930
olika delar av detta minne.

76
00:03:21,930 --> 00:03:24,910
>> Så hur får vi dynamiskt
allokerat minne i första hand?

77
00:03:24,910 --> 00:03:27,740
Hur vårt program får
minne som det körs?

78
00:03:27,740 --> 00:03:32,660
Väl C ger en funktion som kallas
malloc, minnesallokering, som

79
00:03:32,660 --> 00:03:36,810
du ringer ett samtal till och du passerar in
hur många byte minne som du vill.

80
00:03:36,810 --> 00:03:39,940
Så om ditt program körs
och du vill ha en heltal runtime,

81
00:03:39,940 --> 00:03:46,040
du kanske Mallock fyra byte
minne, parenteser malloc fyra.

82
00:03:46,040 --> 00:03:48,540
>> Mallock kommer att gå igenom
tittar genom högen,

83
00:03:48,540 --> 00:03:50,750
eftersom vi är dynamiskt
allokering av minne,

84
00:03:50,750 --> 00:03:53,500
och det kommer tillbaka till dig
en pekare till detta minne.

85
00:03:53,500 --> 00:03:56,180
Det är inte ge dig den memory--
den inte ge den ett namn,

86
00:03:56,180 --> 00:03:57,950
det ger dig en pekare till det.

87
00:03:57,950 --> 00:04:00,780
Och så det är därför återigen sa jag
att det är viktigt att kanske

88
00:04:00,780 --> 00:04:03,770
har sett pekare video
innan vi kommer för långt in i detta.

89
00:04:03,770 --> 00:04:05,940
Så malloc kommer att
ge dig tillbaka en pekare.

90
00:04:05,940 --> 00:04:08,950
>> Om Mallock inte kan ge dig något
minnet eftersom du har slut,

91
00:04:08,950 --> 00:04:10,645
det ska ge dig tillbaka en nollpekare.

92
00:04:10,645 --> 00:04:15,282
Kommer du ihåg vad som händer om vi
försöka dereference en nollpekare?

93
00:04:15,282 --> 00:04:17,019
Vi lider en seg fel, eller hur?

94
00:04:17,019 --> 00:04:18,060
Det är förmodligen inte bra.

95
00:04:18,060 --> 00:04:21,579
>> Så varje gång du ringer ett samtal
att malloc dig alltid, alltid

96
00:04:21,579 --> 00:04:25,270
måste kontrollera om inte
pekaren det gav dig tillbaka är noll.

97
00:04:25,270 --> 00:04:28,800
Om det är, måste du avsluta ditt program
eftersom om du försöker och dereference

98
00:04:28,800 --> 00:04:31,360
noll pekaren du ska
att drabbas av en segmentering fel

99
00:04:31,360 --> 00:04:34,380
och ditt program är
kommer att krascha ändå.

100
00:04:34,380 --> 00:04:37,190
Så hur gör vi statiskt
erhålla ett heltal?

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

102
00:04:37,730 --> 00:04:40,010
Vi har antagligen gjort det
ett gäng gånger, eller hur?

103
00:04:40,010 --> 00:04:43,480
Detta skapar en variabel som heter
x som lever på stacken.

104
00:04:43,480 --> 00:04:46,190
Hur kan vi dynamiskt få ett heltal?

105
00:04:46,190 --> 00:04:50,010
Int stjärna px lika malloc 4.

106
00:04:50,010 --> 00:04:53,050
>> Eller mer korrekt
vi skulle säga int stjärna px

107
00:04:53,050 --> 00:04:57,680
lika malloc storlek int,
bara för att kasta lite färre

108
00:04:57,680 --> 00:04:59,740
Magic Numbers runt vårt program.

109
00:04:59,740 --> 00:05:04,140
Detta kommer att få för oss
fyra byte minne från högen,

110
00:05:04,140 --> 00:05:06,720
och pekaren vi får
tillbaka till det kallas px.

111
00:05:06,720 --> 00:05:08,430
Och sedan bara som vi har
gjort tidigare vi

112
00:05:08,430 --> 00:05:13,966
kan dereference px till
sjunga detta minne.

113
00:05:13,966 --> 00:05:15,590
Hur får vi ett heltal från användaren?

114
00:05:15,590 --> 00:05:17,970
Vi kan säga int x lika få int.

115
00:05:17,970 --> 00:05:19,930
Det är ganska enkelt.

116
00:05:19,930 --> 00:05:24,030
Vad händer om vi vill skapa en array
av x flottar som lever på stacken?

117
00:05:24,030 --> 00:05:28,210
flyta stack_array-- det är namnet
av våra array-- hakparentes x.

118
00:05:28,210 --> 00:05:32,419
Det kommer att skapa för oss en array
av x flottörer som lever på stacken.

119
00:05:32,419 --> 00:05:34,960
Vi kan skapa en matris med flottörer
som lever på högen, alltför.

120
00:05:34,960 --> 00:05:37,330
Syntaxen kan se en
lite mer besvärligt,

121
00:05:37,330 --> 00:05:41,740
men vi kan säga float
stjärn heap_array lika

122
00:05:41,740 --> 00:05:44,360
malloc x gånger större än flottörens.

123
00:05:44,360 --> 00:05:48,160
Jag behöver tillräckligt med utrymme för att hålla
x flyttalsvärden.

124
00:05:48,160 --> 00:05:51,560
Så säger jag behöver 100
flottar, eller 1000 flyter.

125
00:05:51,560 --> 00:05:54,810
Så i så fall skulle det vara
400 byte för 100 flottar,

126
00:05:54,810 --> 00:05:59,080
eller 4000 byte för 1000 flottar,
eftersom varje flottör tar upp

127
00:05:59,080 --> 00:06:01,230
fyra byte av utrymme.

128
00:06:01,230 --> 00:06:05,110
>> Efter detta kan jag använda
klammer syntaxen på heap_array.

129
00:06:05,110 --> 00:06:08,970
Precis som jag gör på stack_array jag
kan få tillgång till sina element individuellt

130
00:06:08,970 --> 00:06:11,590
användning heap_array noll, heap_array en.

131
00:06:11,590 --> 00:06:15,800
Men minns anledningen till att vi kan göra det
beror på att namnet på en matris i C

132
00:06:15,800 --> 00:06:19,990
är verkligen en pekare till
att array första elementet.

133
00:06:19,990 --> 00:06:23,480
Så det faktum att vi förklara en
samling av flöten på stacken här

134
00:06:23,480 --> 00:06:24,810
är faktiskt lite missvisande.

135
00:06:24,810 --> 00:06:27,600
Vi är verkligen i
andra kodrad där

136
00:06:27,600 --> 00:06:32,360
också skapa en pekare till en del av
minne som vi sedan göra en del arbete med.

137
00:06:32,360 --> 00:06:35,620
>> Här är det stora problemet med
allokeras dynamiskt minne men,

138
00:06:35,620 --> 00:06:38,360
och det är därför det är verkligen
viktigt att utveckla några goda vanor

139
00:06:38,360 --> 00:06:39,800
när du arbetar med det.

140
00:06:39,800 --> 00:06:43,060
Till skillnad från statiskt deklarerade
minne, ditt minne

141
00:06:43,060 --> 00:06:46,790
inte automatiskt tillbaka till
systemet när din funktion är klar.

142
00:06:46,790 --> 00:06:49,280
Så om vi har huvud, och
Huvud anropar en funktion

143
00:06:49,280 --> 00:06:53,860
f, när f finish vad det gör
och returnerar styrning av programmet

144
00:06:53,860 --> 00:06:58,810
tillbaka till huvud, allt minne
att f används ges tillbaka.

145
00:06:58,810 --> 00:07:01,250
Den kan användas på nytt
av något annat program,

146
00:07:01,250 --> 00:07:04,250
eller någon annan funktion som
anropas senare i main.

147
00:07:04,250 --> 00:07:06,970
Det kan använda samma minne igen.

148
00:07:06,970 --> 00:07:09,620
>> Om du dynamiskt
allokera minne om

149
00:07:09,620 --> 00:07:14,380
du måste specifikt tala om
system som du är klar med det.

150
00:07:14,380 --> 00:07:18,370
Det kommer att hålla fast vid det för dig, som skulle kunna
leda till ett problem av er att ta slut

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

152
00:07:19,290 --> 00:07:22,179
Och faktum är att vi ibland hänvisar
till detta som en minnesläcka.

153
00:07:22,179 --> 00:07:24,970
Och ibland dessa minnesläckor
kan faktiskt vara riktigt förödande

154
00:07:24,970 --> 00:07:27,020
för systemets prestanda.

155
00:07:27,020 --> 00:07:31,120
>> Om du är en flitig Internetanvändare
du kan använda vissa webbläsare,

156
00:07:31,120 --> 00:07:35,630
och jag kommer inte att nämna namn här, men
det finns vissa webbläsare ute

157
00:07:35,630 --> 00:07:39,150
som är ökända för att faktiskt ha
minnesläckor som inte få fast.

158
00:07:39,150 --> 00:07:44,570
Och om du lämnar din webbläsare öppet
för en mycket lång tidsperiod, dagar

159
00:07:44,570 --> 00:07:48,060
och dagar, eller veckor, du ibland
kanske märker att ditt system

160
00:07:48,060 --> 00:07:49,790
körs riktigt, riktigt långsamt.

161
00:07:49,790 --> 00:07:54,640
Och anledningen till det är att
webbläsaren har tilldelat minne,

162
00:07:54,640 --> 00:07:57,320
men sedan inte veta systemet
att det görs med den.

163
00:07:57,320 --> 00:08:01,000
Och så som lämnar mindre minne
tillgängliga för alla dina andra program

164
00:08:01,000 --> 00:08:04,480
att behöva dela, eftersom du är
leaking-- att webbläsare

165
00:08:04,480 --> 00:08:06,755
Programmet läcker minne.

166
00:08:06,755 --> 00:08:08,880
Hur ger vi minnet tillbaka
När vi är klara med det?

167
00:08:08,880 --> 00:08:10,838
Tja lyckligtvis är det en
mycket enkelt sätt att göra det.

168
00:08:10,838 --> 00:08:11,710
Vi frigör det bara.

169
00:08:11,710 --> 00:08:15,020
Det finns en funktion som kallas fri,
det accepterar en pekare till minne,

170
00:08:15,020 --> 00:08:16,010
och vi är bra att gå.

171
00:08:16,010 --> 00:08:18,310
>> Så låt oss säga att vi är på
mitten av vårt program,

172
00:08:18,310 --> 00:08:21,970
Vi vill malloc 50 tecken.

173
00:08:21,970 --> 00:08:25,710
Vi vill malloc en array som kan
kan hålla 50 tecken.

174
00:08:25,710 --> 00:08:29,109
Och när vi får en pekare till
att att pekaren heter ord.

175
00:08:29,109 --> 00:08:30,900
Vi gör vad vi är
ska göra med ord,

176
00:08:30,900 --> 00:08:33,440
och sedan när vi är
gjort vi bara befria den.

177
00:08:33,440 --> 00:08:37,460
Och nu har vi återvänt dessa 50
byte minne tillbaka till systemet.

178
00:08:37,460 --> 00:08:40,147
Någon annan funktion kan använda dem.

179
00:08:40,147 --> 00:08:43,480
Vi behöver inte oroa dig för att lida en
minnesläcka eftersom vi har befriat ord.

180
00:08:43,480 --> 00:08:46,639
Vi har gett minnet tillbaka,
så vi är klar arbetar med det.

181
00:08:46,639 --> 00:08:48,430
Så det finns tre
gyllene regler som bör

182
00:08:48,430 --> 00:08:51,700
hållas i åtanke när du är
dynamiskt allokera minne

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

184
00:08:52,990 --> 00:08:56,480
Varje block av minne som
du malloc måste befrias

185
00:08:56,480 --> 00:08:58,430
innan ditt program slutar köra.

186
00:08:58,430 --> 00:09:02,029
Nu igen, i apparaten eller i
IDE denna typ av händer för dig ändå

187
00:09:02,029 --> 00:09:04,820
när du-- detta kommer att ske i alla fall
när programmet avslutas,

188
00:09:04,820 --> 00:09:06,880
allt minne kommer att släppas.

189
00:09:06,880 --> 00:09:10,750
Men det är i allmänhet bra kodning
vana att alltid, när du är klar,

190
00:09:10,750 --> 00:09:13,810
befria vad du har mallocd.

191
00:09:13,810 --> 00:09:16,690
>> Som sagt, enda som
du har mallocd ska friges.

192
00:09:16,690 --> 00:09:19,880
Om du statiskt deklarera en
heltal, int x semikolon,

193
00:09:19,880 --> 00:09:23,500
som lever på stacken, du
inte sedan vill frigöra x.

194
00:09:23,500 --> 00:09:25,970
Så bara saker som du har
mallocd bör friges.

195
00:09:25,970 --> 00:09:28,960
>> Och slutligen, inte fri något två gånger.

196
00:09:28,960 --> 00:09:31,170
Det kan leda till
annan konstig situation.

197
00:09:31,170 --> 00:09:33,530
Så allt som du har
mallocd måste friges.

198
00:09:33,530 --> 00:09:36,000
Bara saker som du har
malloc bör friges.

199
00:09:36,000 --> 00:09:38,730
Och gör inte fri något två gånger.

200
00:09:38,730 --> 00:09:43,660
>> Så låt oss gå igenom ett exempel här
av vad vissa dynamiskt allokerad

201
00:09:43,660 --> 00:09:46,122
minne kan se ut blandad
in med vissa statiskt minne.

202
00:09:46,122 --> 00:09:47,080
Vad kan hända här?

203
00:09:47,080 --> 00:09:48,913
Se om du kan följa
tillsammans och gissa vad som är

204
00:09:48,913 --> 00:09:51,720
kommer att hända när vi går
genom alla dessa rader kod.

205
00:09:51,720 --> 00:09:53,980
>> Så vi säger int m.

206
00:09:53,980 --> 00:09:54,840
Vad händer här?

207
00:09:54,840 --> 00:09:56,339
Ja detta är ganska enkelt.

208
00:09:56,339 --> 00:09:59,650
Jag skapar en heltalsvariabel kallad m.

209
00:09:59,650 --> 00:10:01,400
Jag färg det grönt,
eftersom det är färgen

210
00:10:01,400 --> 00:10:03,730
som jag använder när jag talar
om heltalsvariabler.

211
00:10:03,730 --> 00:10:05,160
Det är en låda.

212
00:10:05,160 --> 00:10:08,400
Det kallas m, och du kan
lagra heltal inne i det.

213
00:10:08,400 --> 00:10:12,400
>> Vad händer om jag sedan säga int stjärna a?

214
00:10:12,400 --> 00:10:13,530
Jo det är ganska likartade.

215
00:10:13,530 --> 00:10:15,780
Jag skapar en ruta som kallas en.

216
00:10:15,780 --> 00:10:19,100
Det är kapabel innehav int
stjärnor, pekare till heltal.

217
00:10:19,100 --> 00:10:21,570
Så jag färga det grönt-ish också.

218
00:10:21,570 --> 00:10:24,140
>> Jag vet att det har något
att göra med ett heltal,

219
00:10:24,140 --> 00:10:25,852
men det är inte i sig ett heltal.

220
00:10:25,852 --> 00:10:27,310
Men det är ganska mycket samma idé.

221
00:10:27,310 --> 00:10:28,101
Jag har skapat en låda.

222
00:10:28,101 --> 00:10:30,070
Båda dessa rätt
nu bor på stacken.

223
00:10:30,070 --> 00:10:32,520
Jag har gett dem båda namnen.

224
00:10:32,520 --> 00:10:36,750
>> int stjärna B lika malloc storlek int.

225
00:10:36,750 --> 00:10:38,560
Detta kan vara lite knepigt.

226
00:10:38,560 --> 00:10:44,110
Ta en sekund och fundera på vad du
förväntar sig att hända på det här diagrammet.

227
00:10:44,110 --> 00:10:50,210
int stjärna B lika malloc storlek int.

228
00:10:50,210 --> 00:10:51,940
>> Ja detta inte bara skapa en ruta.

229
00:10:51,940 --> 00:10:53,800
Detta skapar faktiskt två lådor.

230
00:10:53,800 --> 00:10:58,670
Och det binder, det fastställs också
en punkt i ett förhållande.

231
00:10:58,670 --> 00:11:02,240
Vi har tilldelats ett kvarter
minne på högen.

232
00:11:02,240 --> 00:11:05,940
Lägg märke till att den övre högra rutan
det inte har ett namn.

233
00:11:05,940 --> 00:11:06,760
>> Vi mallocd det.

234
00:11:06,760 --> 00:11:08,050
Det finns på högen.

235
00:11:08,050 --> 00:11:10,090
Men B har ett namn.

236
00:11:10,090 --> 00:11:11,950
Det är en pekare variabel som heter b.

237
00:11:11,950 --> 00:11:13,910
Som lever på stacken.

238
00:11:13,910 --> 00:11:18,250
>> Så det är en bit av minne
som pekar på en annan en.

239
00:11:18,250 --> 00:11:21,840
b innehåller adressen
av detta minnesblock.

240
00:11:21,840 --> 00:11:23,757
Det har inte ett namn annars.

241
00:11:23,757 --> 00:11:24,590
Men den pekar på det.

242
00:11:24,590 --> 00:11:29,760
Så när vi säger int stjärna B lika
malloc storlek int, att just där,

243
00:11:29,760 --> 00:11:33,490
att pilen som dök upp på
höger sida där det hela,

244
00:11:33,490 --> 00:11:36,740
I have det verkar
igen, är vad som händer.

245
00:11:36,740 --> 00:11:39,341
Allt detta händer i
som enda rad kod.

246
00:11:39,341 --> 00:11:41,340
Nu ska vi få lite mer
okomplicerad igen.

247
00:11:41,340 --> 00:11:43,330
en lika -tecken m.

248
00:11:43,330 --> 00:11:46,280
Minns ni vad en
lika-tecken m är?

249
00:11:46,280 --> 00:11:48,920
Jo det är en får m adress.

250
00:11:48,920 --> 00:11:54,150
Eller lägga mer schematiskt,
en poäng till m.

251
00:11:54,150 --> 00:11:56,360
>> a är lika med b.

252
00:11:56,360 --> 00:11:57,560
OK så här är en annan.

253
00:11:57,560 --> 00:11:59,230
A är lika med f.

254
00:11:59,230 --> 00:12:02,260
Vad kommer att hända
diagrammet här gången?

255
00:12:02,260 --> 00:12:04,330
>> Väl påminna om att
tilldelningsoperator verk

256
00:12:04,330 --> 00:12:08,960
genom att tilldela värdet på
rätt till värdet till vänster.

257
00:12:08,960 --> 00:12:14,820
Så i stället för en som pekar på m, en nu
pekar på samma ställe som b punkter.

258
00:12:14,820 --> 00:12:18,900
en inte peka på b, en
punkter där b poäng.

259
00:12:18,900 --> 00:12:25,280
>> Om ett spetsigt till b som skulle
har varit en lika -tecken b.

260
00:12:25,280 --> 00:12:28,150
Utan i stället en lika b bara
innebär att och b är nu

261
00:12:28,150 --> 00:12:31,770
pekar på samma adress, eftersom
insidan av b är bara en adress.

262
00:12:31,770 --> 00:12:35,004
Och nu inne i en är samma adress.

263
00:12:35,004 --> 00:12:37,170
m är lika med 10, förmodligen
enklaste sak

264
00:12:37,170 --> 00:12:38,690
vi har gjort i en liten bit.

265
00:12:38,690 --> 00:12:40,460
Placera 10 i rutan.

266
00:12:40,460 --> 00:12:45,640
Star B är lika med m plus 2, minns från
våra pekare video vad stjärn b innebär.

267
00:12:45,640 --> 00:12:50,230
Vi kommer att dereference b och put
ett värde i den minnesplatsen.

268
00:12:50,230 --> 00:12:51,860
I detta fall 12.

269
00:12:51,860 --> 00:12:55,300
>> Så när vi avreferera en punkt
minns vi bara resa ner pilen.

270
00:12:55,300 --> 00:12:58,205
Eller annorlunda uttryckt, vi
gå till den minnesadress

271
00:12:58,205 --> 00:12:59,580
och vi manipulerar det på något sätt.

272
00:12:59,580 --> 00:13:00,830
Vi sätter något värde i det.

273
00:13:00,830 --> 00:13:03,960
I detta fall stjärna B
lika m plus 2 är bara

274
00:13:03,960 --> 00:13:08,230
gå till variabeln som utpekas av b,
gå till minnet som utpekas av b,

275
00:13:08,230 --> 00:13:11,750
och sätta m plus 2 där, 12.

276
00:13:11,750 --> 00:13:14,970
>> Nu befria Ib.

277
00:13:14,970 --> 00:13:16,490
Vad händer när jag fri b?

278
00:13:16,490 --> 00:13:18,800
Kom ihåg vad jag sa fria medel.

279
00:13:18,800 --> 00:13:21,920
Vad säger jag när jag fri b?

280
00:13:21,920 --> 00:13:23,410
>> Jag är gjort arbetar med det, eller hur?

281
00:13:23,410 --> 00:13:25,702
Jag ger i huvudsak upp minnet.

282
00:13:25,702 --> 00:13:26,910
Jag ger det tillbaka till systemet.

283
00:13:26,910 --> 00:13:33,010
Jag behöver inte här längre är
vad jag talar om för dem, OK?

284
00:13:33,010 --> 00:13:37,390
>> Nu om jag säger stjärn en
lika 11 kan du förmodligen

285
00:13:37,390 --> 00:13:40,460
redan nu säga att något dåligt
kommer att hända här, eller hur?

286
00:13:40,460 --> 00:13:44,160
Och faktiskt, om jag försökte att jag förmodligen
skulle drabbas av en segmentering fel.

287
00:13:44,160 --> 00:13:47,140
För nu, även om
tidigare att bit av minne

288
00:13:47,140 --> 00:13:50,220
var något som jag hade
tillgång till, vid denna punkt

289
00:13:50,220 --> 00:13:54,590
nu är jag tillgång till minne som
är inte lagligt för mig att få tillgång till.

290
00:13:54,590 --> 00:13:57,330
>> Och när vi kommer förmodligen
minns när vi tillgång till minne

291
00:13:57,330 --> 00:14:00,000
att vi inte ska röra,
det är den vanligaste orsaken

292
00:14:00,000 --> 00:14:01,860
av en segmente
fel. Och så mitt program

293
00:14:01,860 --> 00:14:05,170
skulle krascha om jag försökte göra detta.

294
00:14:05,170 --> 00:14:09,910
Så återigen är det en bra idé att få bra
praxis och goda vanor ingrodd

295
00:14:09,910 --> 00:14:12,920
när man arbetar med malloc och free,
så att du inte lider segmente

296
00:14:12,920 --> 00:14:15,310
fel, och att du använder
din dynamiskt allokerad

297
00:14:15,310 --> 00:14:17,370
minne ansvarsfullt.

298
00:14:17,370 --> 00:14:20,300
>> Jag är Doug Lloyd detta är CS50.

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