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

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

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

4
00:00:05,590 --> 00:00:07,940
>> DOUG LLOYD: OK asa ca o sugestie
înainte de a începe aici.

5
00:00:07,940 --> 00:00:11,660
Dacă nu ați vizionat video de pe
indicative ar putea să doriți să faceți acest lucru în primul rând.

6
00:00:11,660 --> 00:00:15,860
Deoarece acest film este un alt
mod de lucru cu pointeri.

7
00:00:15,860 --> 00:00:17,574
>> Deci o să vorbească
despre unele concepte

8
00:00:17,574 --> 00:00:19,490
că capacul în
indicative video, iar noi suntem

9
00:00:19,490 --> 00:00:21,948
O să treacă peste ele acum,
presupunând că acestea sunt deja

10
00:00:21,948 --> 00:00:23,090
un fel de înțeles.

11
00:00:23,090 --> 00:00:25,440
Deci, asta e doar avertisment echitabil
că, dacă vedeți acest videoclip

12
00:00:25,440 --> 00:00:27,814
și nu au văzut
indicii video, s-ar putea fel de

13
00:00:27,814 --> 00:00:29,610
zbura peste cap un pic.

14
00:00:29,610 --> 00:00:32,080
Și așa ar fi mai bine
să-l urmăriți în această ordine.

15
00:00:32,080 --> 00:00:34,710
>> Deci, am văzut deja unul
mod de a lucra cu indicii,

16
00:00:34,710 --> 00:00:37,810
care este declarăm o
variabilă, iar apoi ne-am

17
00:00:37,810 --> 00:00:42,160
declara o altă variabilă, un pointer
variabilă, care indică spre el.

18
00:00:42,160 --> 00:00:44,870
Deci am creat un
variabilă cu un nume, am

19
00:00:44,870 --> 00:00:48,480
a creat un al doilea variabilă cu un nume,
și ne-am îndrepta a doua variabile

20
00:00:48,480 --> 00:00:50,220
la acea primă.

21
00:00:50,220 --> 00:00:52,370
Acest tip de are un
problemă deși, pentru că

22
00:00:52,370 --> 00:00:54,650
ne cere să știm exact
câtă memorie suntem

23
00:00:54,650 --> 00:00:57,600
avea nevoie în momentul
programul nostru este compilat.

24
00:00:57,600 --> 00:00:58,220
>> De ce este asta?

25
00:00:58,220 --> 00:01:03,338
Pentru că trebuie să fie în măsură să numească sau
identifice toate variabilele posibile

26
00:01:03,338 --> 00:01:04,129
am putea întâlni.

27
00:01:04,129 --> 00:01:07,910
Am putea avea o serie care ar putea fi
în măsură să dețină o mulțime de informații,

28
00:01:07,910 --> 00:01:10,110
dar nu este încă
exact suficient de precise.

29
00:01:10,110 --> 00:01:12,640
Ce se întâmplă dacă nu știm,
Ce se întâmplă dacă nu avem nici o idee

30
00:01:12,640 --> 00:01:14,370
cât de mult avem nevoie de la compilare?

31
00:01:14,370 --> 00:01:17,020
Sau dacă programul nostru va
candideze pentru un timp foarte lung,

32
00:01:17,020 --> 00:01:19,810
acceptarea diverse utilizator
date, și nu poate într-adevăr

33
00:01:19,810 --> 00:01:23,170
estima dacă suntem
avea nevoie de 1.000 de unitati?

34
00:01:23,170 --> 00:01:26,060
>> Nu e ca și cum putem
spun la linia de comandă

35
00:01:26,060 --> 00:01:28,040
introduceți câte un produs
credeți că veți avea nevoie de.

36
00:01:28,040 --> 00:01:31,100
Ei bine, ce dacă cred este greșit?

37
00:01:31,100 --> 00:01:34,300
Alocare de memorie dinamică
un fel de ne permite modul

38
00:01:34,300 --> 00:01:36,867
pentru a obține în jurul valorii de această problemă special.

39
00:01:36,867 --> 00:01:38,700
Și modul în care o face
este prin utilizarea indicii.

40
00:01:38,700 --> 00:01:42,140
>> Putem folosi indicii la
avea acces la dinamic

41
00:01:42,140 --> 00:01:45,710
memorie alocată, memorie care este
alocate după cum programul se execută.

42
00:01:45,710 --> 00:01:48,290
Nu este alocat în timpul compilării.

43
00:01:48,290 --> 00:01:51,570
Când aloca dinamic
memorie vine de la un bazin

44
00:01:51,570 --> 00:01:53,795
de memorie cunoscut sub numele de heap.

45
00:01:53,795 --> 00:01:56,420
Anterior tot memoria ne-am
fost de lucru cu în cursul

46
00:01:56,420 --> 00:01:59,920
a fost provenind de la un bazin
de memorie cunoscut ca stiva.

47
00:01:59,920 --> 00:02:02,470
O modalitate buna de a în general
păstra în mind-- și această regulă

48
00:02:02,470 --> 00:02:04,720
nu deține întotdeauna adevărat,
dar destul de mult aproape

49
00:02:04,720 --> 00:02:09,940
deține întotdeauna true-- este că orice
timp vă dau un nume de variabilă se

50
00:02:09,940 --> 00:02:12,090
probabil trăiește pe stiva.

51
00:02:12,090 --> 00:02:14,650
Și de fiecare dată când nu
da o variabilă un nume,

52
00:02:14,650 --> 00:02:19,160
pe care le puteți face cu memorie dinamică
alocare, trăiește pe heap.

53
00:02:19,160 --> 00:02:22,190
>> Acum am un fel de a prezenta acest lucru ca
dacă există aceste două bazine de memorie.

54
00:02:22,190 --> 00:02:24,740
Dar este posibil să fi văzut acest
Diagrama, care este, în general,

55
00:02:24,740 --> 00:02:27,290
o reprezentare a
Ce memorie arata ca,

56
00:02:27,290 --> 00:02:30,373
și nu o să aibă grijă de toate
lucrurile din partea de sus și de jos.

57
00:02:30,373 --> 00:02:33,580
Ceea ce ne interesează este aceasta parte din
mijloc aici, heap și stiva.

58
00:02:33,580 --> 00:02:35,570
După cum puteți vedea prin
se uită la acest diagramă,

59
00:02:35,570 --> 00:02:38,390
acestea de fapt, nu sunt două
bazine separate de memorie.

60
00:02:38,390 --> 00:02:42,757
Este una piscină comună de memorie
în cazul în care începe, în acest vizuală

61
00:02:42,757 --> 00:02:44,590
începe în partea de jos
și începeți să umple

62
00:02:44,590 --> 00:02:48,040
din partea de jos cu stiva, și
încep de la partea de sus și începe completarea

63
00:02:48,040 --> 00:02:50,072
de sus în jos cu grămada.

64
00:02:50,072 --> 00:02:51,780
Dar într-adevăr este
același bazin, e doar

65
00:02:51,780 --> 00:02:56,050
locuri diferite, locatii diferite
în memorie care sunt alocate.

66
00:02:56,050 --> 00:02:59,060
Și puteți alerga afară de
Memoria fie având

67
00:02:59,060 --> 00:03:01,240
heap merge până la capăt
la partea de jos, sau au

68
00:03:01,240 --> 00:03:05,440
stiva merge tot drumul la partea de sus,
sau având heap și stiva

69
00:03:05,440 --> 00:03:06,740
întâlni împotriva celuilalt.

70
00:03:06,740 --> 00:03:09,500
Toate acestea pot fi condiții
care cauzeaza programul

71
00:03:09,500 --> 00:03:11,030
la a alerga afară de memorie.

72
00:03:11,030 --> 00:03:11,952
Astfel încât să păstreze în minte.

73
00:03:11,952 --> 00:03:13,660
Când vorbim despre
heap și stiva

74
00:03:13,660 --> 00:03:17,880
suntem într-adevăr vorba despre
aceeași bucată generală de memorie, doar

75
00:03:17,880 --> 00:03:21,930
diferite porțiuni ale acestei memorie.

76
00:03:21,930 --> 00:03:24,910
>> Deci, cum putem obține dinamic
alocate de memorie în primul rând?

77
00:03:24,910 --> 00:03:27,740
Cum programul nostru obține
Memoria ca se execută?

78
00:03:27,740 --> 00:03:32,660
Ei bine, C oferă o funcție numită
malloc, alocator memorie, care

79
00:03:32,660 --> 00:03:36,810
a efectua un apel la, și treceți în
cât de multe bytes de memorie pe care doriți.

80
00:03:36,810 --> 00:03:39,940
Deci, dacă programul se execută
si doriti un număr întreg de execuție,

81
00:03:39,940 --> 00:03:46,040
s-ar putea Mallock patru octeți
memorie, malloc paranteze patru.

82
00:03:46,040 --> 00:03:48,540
>> Mallock va trece prin
Cautati prin grămada,

83
00:03:48,540 --> 00:03:50,750
pentru că suntem în mod dinamic
alocarea de memorie,

84
00:03:50,750 --> 00:03:53,500
și se va întoarce la tine
un pointer la care memoria.

85
00:03:53,500 --> 00:03:56,180
Nu te da ca memory--
nu oferă un nume,

86
00:03:56,180 --> 00:03:57,950
vă oferă un pointer la el.

87
00:03:57,950 --> 00:04:00,780
Și astfel că de aceea i-am spus din nou
că este important să poate

88
00:04:00,780 --> 00:04:03,770
au vizionat video indicii
înainte de a ajunge prea departe în asta.

89
00:04:03,770 --> 00:04:05,940
Deci malloc va
vă dau înapoi un pointer.

90
00:04:05,940 --> 00:04:08,950
>> Dacă Mallock nu se poate da nici
memorie pentru că v-ați alerga afară,

91
00:04:08,950 --> 00:04:10,645
l voi da înapoi un pointer nul.

92
00:04:10,645 --> 00:04:15,282
Îți amintești ce se întâmplă dacă am
încercați și dereference un pointer nul?

93
00:04:15,282 --> 00:04:17,019
Am suferi o defecțiune SEG, nu?

94
00:04:17,019 --> 00:04:18,060
Asta nu e, probabil, bine.

95
00:04:18,060 --> 00:04:21,579
>> Deci, de fiecare dată când face un apel
pentru a vă malloc mereu, mereu

96
00:04:21,579 --> 00:04:25,270
nevoie pentru a verifica dacă este sau nu
pointer-a dat înapoi este nulă.

97
00:04:25,270 --> 00:04:28,800
Dacă este, aveți nevoie pentru a termina programul
pentru că dacă încerci și dereference

98
00:04:28,800 --> 00:04:31,360
indicatorul nul mergi
să sufere o eroare de segmentare

99
00:04:31,360 --> 00:04:34,380
și programul este
va prăbuși oricum.

100
00:04:34,380 --> 00:04:37,190
Deci, cum putem static
obține un număr întreg?

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

102
00:04:37,730 --> 00:04:40,010
Am făcut, probabil, că
o grămadă de ori, nu?

103
00:04:40,010 --> 00:04:43,480
Acest lucru creează o variabilă numită
x care trăiește pe stiva.

104
00:04:43,480 --> 00:04:46,190
Cum putem obține un număr întreg dinamic?

105
00:04:46,190 --> 00:04:50,010
Int px stele este egal cu malloc 4.

106
00:04:50,010 --> 00:04:53,050
>> Sau mai corect
am spune px stea Int

107
00:04:53,050 --> 00:04:57,680
este egal cu dimensiunea malloc de Int,
doar pentru a arunca unele mai

108
00:04:57,680 --> 00:04:59,740
numere magice în jurul programului nostru.

109
00:04:59,740 --> 00:05:04,140
Acest lucru se întâmplă pentru a obține pentru noi
patru octeți de memorie din heap,

110
00:05:04,140 --> 00:05:06,720
și indicatorul ne
înapoi la este numit px.

111
00:05:06,720 --> 00:05:08,430
Și apoi doar cum am
făcut anterior am

112
00:05:08,430 --> 00:05:13,966
poate dereference px la
accesa că memoria.

113
00:05:13,966 --> 00:05:15,590
Cum putem obține un număr întreg de la utilizator?

114
00:05:15,590 --> 00:05:17,970
Putem spune int x este egal cu a obține Int.

115
00:05:17,970 --> 00:05:19,930
Asta e destul de simplă.

116
00:05:19,930 --> 00:05:24,030
Ce se întâmplă dacă dorim să creăm un tablou
de x flotoare care trăiesc pe stiva?

117
00:05:24,030 --> 00:05:28,210
float stack_array-- că e numele
noastre array-- paranteze pătrate x.

118
00:05:28,210 --> 00:05:32,419
Care va crea pentru noi o serie
de x flotoare care trăiesc pe stiva.

119
00:05:32,419 --> 00:05:34,960
Putem crea o serie de flotoare
care trăiește pe heap, de asemenea.

120
00:05:34,960 --> 00:05:37,330
Sintaxa ar putea arata o
puțin mai mult greoaie,

121
00:05:37,330 --> 00:05:41,740
dar putem spune float
heap_array stele este egal

122
00:05:41,740 --> 00:05:44,360
malloc x ori mai mare a flotorului.

123
00:05:44,360 --> 00:05:48,160
Am nevoie de suficient spațiu pentru a ține
Valorile punctul X plutitoare.

124
00:05:48,160 --> 00:05:51,560
Deci spun că am nevoie de 100
pluteste, sau 1.000 de flotoare.

125
00:05:51,560 --> 00:05:54,810
Deci, în acest caz, ar fi
400 octeți pentru 100 de flotoare,

126
00:05:54,810 --> 00:05:59,080
sau 4.000 bytes pentru 1.000 de flotoare,
deoarece fiecare flotor preia

127
00:05:59,080 --> 00:06:01,230
patru octeți de spațiu.

128
00:06:01,230 --> 00:06:05,110
>> După ce faci acest lucru pot folosi
pătrat sintaxă suport pe heap_array.

129
00:06:05,110 --> 00:06:08,970
Așa cum mi-ar pe stack_array, am
pot accesa elementele sale individual

130
00:06:08,970 --> 00:06:11,590
folosind heap_array zero, unu heap_array.

131
00:06:11,590 --> 00:06:15,800
Dar amintesc motivul pentru care putem face asta
se datorează faptului că numele unui tablou în C

132
00:06:15,800 --> 00:06:19,990
este într-adevăr un pointer la
Primul element care matrice lui.

133
00:06:19,990 --> 00:06:23,480
Deci faptul că suntem o declararea
matrice de flotoare pe stiva aici

134
00:06:23,480 --> 00:06:24,810
este de fapt un pic înșelătoare.

135
00:06:24,810 --> 00:06:27,600
Suntem într-adevăr se află în
a doua linie de cod acolo

136
00:06:27,600 --> 00:06:32,360
crearea, de asemenea, un pointer la o bucată de
memorie care apoi facem ceva de lucru cu.

137
00:06:32,360 --> 00:06:35,620
>> Aici e marea problemă cu
alocate dinamic memorie, deși,

138
00:06:35,620 --> 00:06:38,360
și de aceea este foarte
important să se dezvolte unele obiceiuri bune

139
00:06:38,360 --> 00:06:39,800
când lucrați cu ea.

140
00:06:39,800 --> 00:06:43,060
Spre deosebire de declarat static
memorie, memoria

141
00:06:43,060 --> 00:06:46,790
nu este returnat automat la
sistemul atunci când funcția se face.

142
00:06:46,790 --> 00:06:49,280
Deci, dacă avem principal, și
principal solicită o funcție

143
00:06:49,280 --> 00:06:53,860
f, atunci când f finisaje orice ar face
și returnează control al programului

144
00:06:53,860 --> 00:06:58,810
Înapoi la, toată memoria
care f folosit este dat înapoi.

145
00:06:58,810 --> 00:07:01,250
Acesta poate fi utilizat din nou
de un alt program,

146
00:07:01,250 --> 00:07:04,250
sau o altă funcție care
este chemat mai târziu în principal.

147
00:07:04,250 --> 00:07:06,970
Se poate folosi aceeasi memorie din nou.

148
00:07:06,970 --> 00:07:09,620
>> Dacă ați dinamic
aloca memorie deși

149
00:07:09,620 --> 00:07:14,380
trebuie să-i spuneți în mod explicit
sistem care ai terminat cu ea.

150
00:07:14,380 --> 00:07:18,370
Va ține pe ea pentru tine, care ar putea
duce la o problemă de voi scurge

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

152
00:07:19,290 --> 00:07:22,179
Și, de fapt, uneori, ne referim
în acest sens printr-o scurgere de memorie.

153
00:07:22,179 --> 00:07:24,970
Și, uneori, aceste pierderi de memorie
poate fi de fapt foarte devastator

154
00:07:24,970 --> 00:07:27,020
pentru performanța sistemului.

155
00:07:27,020 --> 00:07:31,120
>> Dacă sunteți un utilizator de internet frecvent
s-ar putea utiliza anumite browsere web,

156
00:07:31,120 --> 00:07:35,630
și nu voi da nume aici, dar
există unele browsere web acolo

157
00:07:35,630 --> 00:07:39,150
că sunt cunoscute pentru a avea de fapt
pierderi de memorie care nu te fixe.

158
00:07:39,150 --> 00:07:44,570
Și dacă vă lăsați browser-ul deschis
pentru o perioadă foarte lungă de timp, zile

159
00:07:44,570 --> 00:07:48,060
și zile, sau săptămâni, vă uneori
s-ar putea observa că sistemul dvs.

160
00:07:48,060 --> 00:07:49,790
este de funcționare într-adevăr, într-adevăr lent.

161
00:07:49,790 --> 00:07:54,640
Și motivul pentru care este faptul că
browser-ul a alocat de memorie,

162
00:07:54,640 --> 00:07:57,320
dar atunci nu a spus sistemul
că se face cu ea.

163
00:07:57,320 --> 00:08:01,000
Și astfel încât lasă mai puțină memorie
disponibil pentru toate celelalte programe

164
00:08:01,000 --> 00:08:04,480
de a avea de a împărtăși, pentru că ești
leaking-- că browser-ul web

165
00:08:04,480 --> 00:08:06,755
Programul se scurge de memorie.

166
00:08:06,755 --> 00:08:08,880
Cum ne da inapoi de memorie
când am terminat cu ea?

167
00:08:08,880 --> 00:08:10,838
Ei bine, din fericire e un
mod foarte ușor de a face acest lucru.

168
00:08:10,838 --> 00:08:11,710
Noi doar l gratuit.

169
00:08:11,710 --> 00:08:15,020
Există o funcție numită gratuit,
acceptă un pointer la memorie,

170
00:08:15,020 --> 00:08:16,010
și suntem bine să plec.

171
00:08:16,010 --> 00:08:18,310
>> Deci, să spunem că suntem în
mijloc de programul nostru,

172
00:08:18,310 --> 00:08:21,970
vrem să malloc 50 de caractere.

173
00:08:21,970 --> 00:08:25,710
Vrem să malloc o matrice care poate
capabil să mențină 50 de caractere.

174
00:08:25,710 --> 00:08:29,109
Și când ne un pointer înapoi la
că, nume care indicatorul este cuvântul.

175
00:08:29,109 --> 00:08:30,900
Facem tot ce suntem
de gând să faci cu cuvânt,

176
00:08:30,900 --> 00:08:33,440
și apoi atunci când suntem
făcut noi doar gratuit.

177
00:08:33,440 --> 00:08:37,460
Și acum ne-am întors pe cei 50
bytes de memorie înapoi în sistem.

178
00:08:37,460 --> 00:08:40,147
Unele alte funcții pot să le utilizeze.

179
00:08:40,147 --> 00:08:43,480
Noi nu trebuie să vă faceți griji cu privire la ce a suferit un
scurgere de memorie pentru că am eliberat cuvânt.

180
00:08:43,480 --> 00:08:46,639
Ne-am dat memoria spate,
așa am terminat de lucru cu ea.

181
00:08:46,639 --> 00:08:48,430
Deci, există trei
reguli de aur care ar trebui

182
00:08:48,430 --> 00:08:51,700
să fie păstrate în minte ori de câte ori ești
alocarea dinamică de memorie

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

184
00:08:52,990 --> 00:08:56,480
Fiecare bloc de memorie care
vă malloc să fie eliberat

185
00:08:56,480 --> 00:08:58,430
înainte de a termina programul de funcționare.

186
00:08:58,430 --> 00:09:02,029
Acum, din nou, în aparatul sau în
IDE acest tip de loc pentru tine, oricum

187
00:09:02,029 --> 00:09:04,820
atunci când acest lucru se va întâmpla Tu-- oricum
atunci când programul se termină,

188
00:09:04,820 --> 00:09:06,880
toate memoria va fi lansat.

189
00:09:06,880 --> 00:09:10,750
Dar e de codificare, în general, bine
practică întotdeauna, atunci când ați terminat,

190
00:09:10,750 --> 00:09:13,810
elibera ceea ce ai mallocd.

191
00:09:13,810 --> 00:09:16,690
>> Asta a spus, doar lucruri pe care
ai mallocd ar trebui să fie eliberat.

192
00:09:16,690 --> 00:09:19,880
Dacă ați declara static un
întreg, int x semi-colon,

193
00:09:19,880 --> 00:09:23,500
care trăiește pe stiva, tu
Nu vreau să elibereze apoi X.

194
00:09:23,500 --> 00:09:25,970
Deci numai lucruri pe care le-ați
mallocd ar trebui să fie eliberat.

195
00:09:25,970 --> 00:09:28,960
>> Și, în fine, nu face ceva gratuit de două ori.

196
00:09:28,960 --> 00:09:31,170
Care pot duce la
o altă situație ciudat.

197
00:09:31,170 --> 00:09:33,530
Deci tot ce ai
mallocd trebuie să fie eliberat.

198
00:09:33,530 --> 00:09:36,000
Numai lucruri pe care le-ați
malloc trebuie eliberat.

199
00:09:36,000 --> 00:09:38,730
Și nu face ceva gratuit de două ori.

200
00:09:38,730 --> 00:09:43,660
>> Așa că hai să printr-un exemplu aici
de ceea ce unii alocate dinamic

201
00:09:43,660 --> 00:09:46,122
memorie ar putea arata ca mixt
în cu unele memorie statică.

202
00:09:46,122 --> 00:09:47,080
Ce s-ar putea întâmpla aici?

203
00:09:47,080 --> 00:09:48,913
Vezi dacă poți urmări
de-a lungul și ghici ce-i

204
00:09:48,913 --> 00:09:51,720
o să se întâmple așa cum vom merge
prin toate aceste linii de cod.

205
00:09:51,720 --> 00:09:53,980
>> Deci, noi spunem Int m.

206
00:09:53,980 --> 00:09:54,840
Ce se întâmplă aici?

207
00:09:54,840 --> 00:09:56,339
Ei bine, acest lucru este destul de simplă.

208
00:09:56,339 --> 00:09:59,650
Am crea o variabila integer numit m.

209
00:09:59,650 --> 00:10:01,400
Am culoare verde,
pentru că asta e culoarea

210
00:10:01,400 --> 00:10:03,730
pe care îl folosesc, atunci când vorbesc
despre variabile intregi.

211
00:10:03,730 --> 00:10:05,160
E o cutie.

212
00:10:05,160 --> 00:10:08,400
Se numește m, și puteți
magazin întregi interior.

213
00:10:08,400 --> 00:10:12,400
>> Ce se întâmplă dacă spun, atunci int stea o?

214
00:10:12,400 --> 00:10:13,530
Ei bine, asta e destul de similare.

215
00:10:13,530 --> 00:10:15,780
Creez o cutie numit.

216
00:10:15,780 --> 00:10:19,100
Este capabil să mențină Int
stele, pointeri la întregi.

217
00:10:19,100 --> 00:10:21,570
Așa că eu sunt o colorat verde-ish, de asemenea.

218
00:10:21,570 --> 00:10:24,140
>> Știu că are ceva
de a face cu un număr întreg,

219
00:10:24,140 --> 00:10:25,852
dar nu se e un număr întreg.

220
00:10:25,852 --> 00:10:27,310
Dar e destul de mult aceeași idee.

221
00:10:27,310 --> 00:10:28,101
Am creat o cutie.

222
00:10:28,101 --> 00:10:30,070
Ambele dreapta
acum live pe stiva.

223
00:10:30,070 --> 00:10:32,520
Le-am dat ambele nume.

224
00:10:32,520 --> 00:10:36,750
>> stele int b este egal cu dimensiunea malloc de Int.

225
00:10:36,750 --> 00:10:38,560
Acesta ar putea fi un pic cam complicat.

226
00:10:38,560 --> 00:10:44,110
Ia-o a doua și cred despre ceea ce
ar aștepta să se întâmple pe acest diagrama.

227
00:10:44,110 --> 00:10:50,210
stele int b este egal cu dimensiunea malloc de Int.

228
00:10:50,210 --> 00:10:51,940
>> Ei bine, acest lucru nu creează doar o cutie.

229
00:10:51,940 --> 00:10:53,800
Acest lucru creează de fapt două cutii.

230
00:10:53,800 --> 00:10:58,670
Și se leagă, de asemenea, stabilește
un punct într-o relație.

231
00:10:58,670 --> 00:11:02,240
Am alocat un bloc
de memorie pe heap.

232
00:11:02,240 --> 00:11:05,940
Observați că caseta din dreapta sus
nu are un nume.

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

234
00:11:06,760 --> 00:11:08,050
Care se află la grămadă.

235
00:11:08,050 --> 00:11:10,090
Dar b are un nume.

236
00:11:10,090 --> 00:11:11,950
Este o variabilă pointer numit b.

237
00:11:11,950 --> 00:11:13,910
Care trăiește pe stiva.

238
00:11:13,910 --> 00:11:18,250
>> Deci, este o bucată de memorie
care indică la altul.

239
00:11:18,250 --> 00:11:21,840
b conține adresa
de care bloc de memorie.

240
00:11:21,840 --> 00:11:23,757
Ea nu are un nume altfel.

241
00:11:23,757 --> 00:11:24,590
Dar arată la ea.

242
00:11:24,590 --> 00:11:29,760
Deci, atunci când spunem stea int b este egal cu
Dimensiunea malloc de Int, că acolo,

243
00:11:29,760 --> 00:11:33,490
că săgeata care a apărut cu privire la
partea dreaptă acolo, că totul,

244
00:11:33,490 --> 00:11:36,740
Voi avea să apară
din nou, este ceea ce se întâmplă.

245
00:11:36,740 --> 00:11:39,341
Toate acestea se întâmplă în
că nicio linie de cod.

246
00:11:39,341 --> 00:11:41,340
Acum vom avea ceva mai mult
simplu din nou.

247
00:11:41,340 --> 00:11:43,330
un egal ampersand m.

248
00:11:43,330 --> 00:11:46,280
Îți amintești ce
este egal cu ampersand m este?

249
00:11:46,280 --> 00:11:48,920
Ei bine, asta-i o primeste adresa m lui.

250
00:11:48,920 --> 00:11:54,150
Sau, mai schematic,
de puncte de m.

251
00:11:54,150 --> 00:11:56,360
>> are o valoare cuprinsă b.

252
00:11:56,360 --> 00:11:57,560
OK Deci, aici este un alt unul.

253
00:11:57,560 --> 00:11:59,230
Un egal cu b.

254
00:11:59,230 --> 00:12:02,260
Ce se va întâmpla
diagrama de data asta?

255
00:12:02,260 --> 00:12:04,330
>> Ei bine, Amintiti-va ca
Lucrari de operatori de atribuire

256
00:12:04,330 --> 00:12:08,960
prin atribuirea valoarea de pe
dreptul la valoarea din stânga.

257
00:12:08,960 --> 00:12:14,820
Deci, în loc de o indicare a m, un acum
subliniază în același loc pe care de puncte b.

258
00:12:14,820 --> 00:12:18,900
o nu indică la B, o
Puncte Puncte unde B.

259
00:12:18,900 --> 00:12:25,280
>> În cazul în care un ascuțit la b care ar
Au fost un egal cu ampersand b.

260
00:12:25,280 --> 00:12:28,150
Dar, în loc un egal b doar
înseamnă că și b sunt acum

261
00:12:28,150 --> 00:12:31,770
arătând spre aceeași adresă, deoarece
interior de b este doar o adresă.

262
00:12:31,770 --> 00:12:35,004
Și acum în interiorul unei este aceeași adresă.

263
00:12:35,004 --> 00:12:37,170
m este egal cu 10, probabil cea
mai simplu lucru

264
00:12:37,170 --> 00:12:38,690
am făcut într-un pic.

265
00:12:38,690 --> 00:12:40,460
Pune 10 în caseta.

266
00:12:40,460 --> 00:12:45,640
Stele b este egal cu m plus 2, amintesc de la
indicii videoclipul nostru ceea ce înseamnă stea b.

267
00:12:45,640 --> 00:12:50,230
Vom dereference b și a pus
o valoare în acea locație de memorie.

268
00:12:50,230 --> 00:12:51,860
În acest caz, 12.

269
00:12:51,860 --> 00:12:55,300
>> Așa că atunci când am dereference un punct de
amintesc ne-am deplasa în jos săgeată.

270
00:12:55,300 --> 00:12:58,205
Sau, altfel spus, am
du-te la acea adresă de memorie

271
00:12:58,205 --> 00:12:59,580
si l-am manipula într-un fel.

272
00:12:59,580 --> 00:13:00,830
Am pus o anumită valoare acolo.

273
00:13:00,830 --> 00:13:03,960
În acest caz, stea b
este egal cu m plus 2 este doar

274
00:13:03,960 --> 00:13:08,230
du-te la variabila indicat de b,
du-te la memorie indicat de b,

275
00:13:08,230 --> 00:13:11,750
și a pus m plus 2 acolo, 12.

276
00:13:11,750 --> 00:13:14,970
>> Acum am liber b.

277
00:13:14,970 --> 00:13:16,490
Ce se întâmplă când liber b?

278
00:13:16,490 --> 00:13:18,800
Amintiți-vă ce am spus mijloace gratuite.

279
00:13:18,800 --> 00:13:21,920
Ce tot spun, atunci când am liber b?

280
00:13:21,920 --> 00:13:23,410
>> Am terminat de lucru cu el, nu?

281
00:13:23,410 --> 00:13:25,702
Dau în principal la memoria.

282
00:13:25,702 --> 00:13:26,910
Am da înapoi în sistem.

283
00:13:26,910 --> 00:13:33,010
Nu am nevoie de acest lucru mai este
ceea ce eu le spun, bine?

284
00:13:33,010 --> 00:13:37,390
>> Acum, dacă spun o stea
este egal cu 11, puteți, probabil,

285
00:13:37,390 --> 00:13:40,460
spune deja că ceva rău
se va întâmpla aici, nu?

286
00:13:40,460 --> 00:13:44,160
Și într-adevăr, dacă am încercat că probabil
ar suferi o eroare de segmentare.

287
00:13:44,160 --> 00:13:47,140
Deoarece acum, deși
anterior ca bucată de memorie

288
00:13:47,140 --> 00:13:50,220
a fost ceva ce am avut
acces la, în acest moment

289
00:13:50,220 --> 00:13:54,590
acum am acces la memorie care
nu este legal pentru mine pentru a accesa.

290
00:13:54,590 --> 00:13:57,330
>> Și, după cum, probabil, vom
amintesc, atunci când am acces la memorie

291
00:13:57,330 --> 00:14:00,000
că nu ar trebui să atingă,
care este cea mai frecventa cauza

292
00:14:00,000 --> 00:14:01,860
de o segmentare
vina. Și așa programul meu

293
00:14:01,860 --> 00:14:05,170
ar prăbuși dacă am încercat să fac acest lucru.

294
00:14:05,170 --> 00:14:09,910
Deci, din nou, este o idee bună pentru a obține bun
practici și obiceiuri bune înrădăcinată

295
00:14:09,910 --> 00:14:12,920
atunci când se lucrează cu malloc și gratuit,
astfel încât să nu suferă de segmentare

296
00:14:12,920 --> 00:14:15,310
defecte, și pe care le utilizați
dumneavoastră alocate dinamic

297
00:14:15,310 --> 00:14:17,370
memorie responsabil.

298
00:14:17,370 --> 00:14:20,300
>> Sunt Doug Lloyd este CS50.

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