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

2
00:00:00,499 --> 00:00:01,395
[Música tocando]

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

4
00:00:05,590 --> 00:00:07,940
>> Doug LLOYD: OK, entón unha suxestión
antes de iniciar aquí.

5
00:00:07,940 --> 00:00:11,660
Se aínda non asistiu o vídeo en
suxestións que pode querer facelo en primeiro lugar.

6
00:00:11,660 --> 00:00:15,860
Porque este vídeo é outra
forma de traballar con punteiros.

7
00:00:15,860 --> 00:00:17,574
>> Por iso, vai falar
sobre algúns conceptos

8
00:00:17,574 --> 00:00:19,490
que cobren o
Indicadores de vídeo, e estamos

9
00:00:19,490 --> 00:00:21,948
vai pasar por riba deles agora,
supoñendo que xa están

10
00:00:21,948 --> 00:00:23,090
tipo de entendido.

11
00:00:23,090 --> 00:00:25,440
Entón, iso é só o seu aviso xusto
que, se está a ver este vídeo

12
00:00:25,440 --> 00:00:27,814
e aínda non viu o
video punteiros, pode tipo de

13
00:00:27,814 --> 00:00:29,610
voar sobre a súa cabeza un pouco.

14
00:00:29,610 --> 00:00:32,080
E por iso quizais sexa mellor
para velo nesa orde.

15
00:00:32,080 --> 00:00:34,710
>> Entón, nós xa vimos un
forma de traballar con punteiros,

16
00:00:34,710 --> 00:00:37,810
que é declaramos un
variable, e entón nós

17
00:00:37,810 --> 00:00:42,160
declarar outra variable, un punteiro
variable, que apunta a el.

18
00:00:42,160 --> 00:00:44,870
Entón creamos un
variable cun nome, temos

19
00:00:44,870 --> 00:00:48,480
creada unha segunda variable cun nome,
e apuntamos que a segunda variable

20
00:00:48,480 --> 00:00:50,220
en que en primeiro lugar.

21
00:00:50,220 --> 00:00:52,370
Este tipo de ten un
problema, porén, porque

22
00:00:52,370 --> 00:00:54,650
obríganos a saber exactamente
a cantidade de memoria que estamos

23
00:00:54,650 --> 00:00:57,600
vai ter do momento
noso programa está feita.

24
00:00:57,600 --> 00:00:58,220
>> Por que é iso?

25
00:00:58,220 --> 00:01:03,338
Porque temos que ser capaces de nomear ou
identificar as posibles variables

26
00:01:03,338 --> 00:01:04,129
poderiamos atopar.

27
00:01:04,129 --> 00:01:07,910
Podemos ter unha matriz que se pode
capaz de manter unha gran cantidade de información,

28
00:01:07,910 --> 00:01:10,110
pero aínda non é
exactamente suficientemente precisa.

29
00:01:10,110 --> 00:01:12,640
E se nós non sabemos,
E se non temos idea

30
00:01:12,640 --> 00:01:14,370
o que imos ter en tempo de compilación?

31
00:01:14,370 --> 00:01:17,020
Ou que o noso programa
executado por un tempo moi longo,

32
00:01:17,020 --> 00:01:19,810
aceptar varios usuario
datos, e non podemos realmente

33
00:01:19,810 --> 00:01:23,170
estimar si estamos
Vai ter 1.000 unidades?

34
00:01:23,170 --> 00:01:26,060
>> Non é como podemos
dicir na liña de comandos

35
00:01:26,060 --> 00:01:28,040
introducir cantos elementos
pensas que vai ter.

36
00:01:28,040 --> 00:01:31,100
Ben, o que se ese palpite é malo?

37
00:01:31,100 --> 00:01:34,300
Distribución dinámica de memoria
tipo de permítenos a camiño

38
00:01:34,300 --> 00:01:36,867
para evitar este problema particular.

39
00:01:36,867 --> 00:01:38,700
E a forma como el fai iso
é usando punteiros.

40
00:01:38,700 --> 00:01:42,140
>> Podemos usar punteiros para
teña acceso aos dinamicamente

41
00:01:42,140 --> 00:01:45,710
memoria alocada, memoria que está
asignado como o programa está a ser executado.

42
00:01:45,710 --> 00:01:48,290
Non é alocada en tempo de compilación.

43
00:01:48,290 --> 00:01:51,570
Cando reservar dinamicamente
memoria se trata dun pool

44
00:01:51,570 --> 00:01:53,795
de memoria coñecido como o heap.

45
00:01:53,795 --> 00:01:56,420
Anteriormente toda a memoria temos
está a traballar con o curso

46
00:01:56,420 --> 00:01:59,920
foi proveniente dunha piscina
de memoria coñecida como a pila.

47
00:01:59,920 --> 00:02:02,470
Unha boa forma de xeral
manter en regra mente-- e este

48
00:02:02,470 --> 00:02:04,720
non sempre son certas,
pero practicamente case

49
00:02:04,720 --> 00:02:09,940
mantén sempre é que calquera true--
vez que dá un nome de variable que

50
00:02:09,940 --> 00:02:12,090
probablemente vive na pila.

51
00:02:12,090 --> 00:02:14,650
E calquera hora que non facer
dar unha variable dun nome,

52
00:02:14,650 --> 00:02:19,160
que se pode facer con memoria dinámica
distribución, el vive na pila.

53
00:02:19,160 --> 00:02:22,190
>> Agora eu son o tipo de presentar isto como
se hai estas dúas piscinas de memoria.

54
00:02:22,190 --> 00:02:24,740
Pero pode ver este
diagrama, que é xeralmente

55
00:02:24,740 --> 00:02:27,290
unha representación de
o que a memoria parece,

56
00:02:27,290 --> 00:02:30,373
e nós non estamos indo a preocuparse todo
o material da parte superior e na parte inferior.

57
00:02:30,373 --> 00:02:33,580
O que nos interesa é esta parte en
medio aquí, heap e pila.

58
00:02:33,580 --> 00:02:35,570
Como verás por
mirando para este diagrama,

59
00:02:35,570 --> 00:02:38,390
estes non son, en realidade, dous
grupos separados de memoria.

60
00:02:38,390 --> 00:02:42,757
É un conxunto compartido de memoria
onde comeza neste visuais

61
00:02:42,757 --> 00:02:44,590
comeza na parte inferior
e comezar a encher

62
00:02:44,590 --> 00:02:48,040
dende o fondo coa pila, e
comezar na parte superior e comezar a encher

63
00:02:48,040 --> 00:02:50,072
arriba abaixo co heap.

64
00:02:50,072 --> 00:02:51,780
Pero é realmente o
mesmo pool, é só

65
00:02:51,780 --> 00:02:56,050
spots diferentes, diferentes lugares
na memoria que se están destinados.

66
00:02:56,050 --> 00:02:59,060
E pode quedar sen
memoria por un ou outro ter

67
00:02:59,060 --> 00:03:01,240
o heap percorrer todo o camiño
para a parte inferior, ou teñen

68
00:03:01,240 --> 00:03:05,440
a pila de percorrer todo o camiño ata o cumio,
ou que teñan a pila ea pila

69
00:03:05,440 --> 00:03:06,740
atopar-se uns contra os outros.

70
00:03:06,740 --> 00:03:09,500
Todos estes poden ser condicións
que causan o seu programa

71
00:03:09,500 --> 00:03:11,030
para realizar con falta de memoria.

72
00:03:11,030 --> 00:03:11,952
Polo tanto, manter isto presente.

73
00:03:11,952 --> 00:03:13,660
Cando falamos de
a pila ea pila

74
00:03:13,660 --> 00:03:17,880
estamos realmente fala de
mesmo anaco xeral da memoria, só

75
00:03:17,880 --> 00:03:21,930
diferentes porcións de que a memoria.

76
00:03:21,930 --> 00:03:24,910
>> Entón, como é que imos chegar dinamicamente
memoria alocada en primeiro lugar?

77
00:03:24,910 --> 00:03:27,740
Como é que o noso programa comezar
memoria como funciona?

78
00:03:27,740 --> 00:03:32,660
Ben C ofrece unha función chamada
malloc, alocador de memoria, o que

79
00:03:32,660 --> 00:03:36,810
fai unha chamada, e pasar
cantos bytes de memoria que quere.

80
00:03:36,810 --> 00:03:39,940
Polo tanto, se o seu programa está a ser executado
e quere un tempo de execución enteiro,

81
00:03:39,940 --> 00:03:46,040
podes Mallock catro bytes de
memoria, malloc parénteses catro.

82
00:03:46,040 --> 00:03:48,540
>> Mallock vai pasar por
mirando a través do conxunto,

83
00:03:48,540 --> 00:03:50,750
porque estamos dinamicamente
distribución de memoria,

84
00:03:50,750 --> 00:03:53,500
e que vai voltar a vostede
un punteiro para a memoria.

85
00:03:53,500 --> 00:03:56,180
Non lle dá que memory--
non darlle un nome,

86
00:03:56,180 --> 00:03:57,950
dálle un punteiro para el.

87
00:03:57,950 --> 00:04:00,780
E é por iso que eu dixen de novo
que é importante se cadra

88
00:04:00,780 --> 00:04:03,770
asistiron o vídeo punteiros
antes de chegar lonxe de máis para iso.

89
00:04:03,770 --> 00:04:05,940
Entón malloc vai
darlle de volta un punteiro.

90
00:04:05,940 --> 00:04:08,950
>> Se Mallock non podo darlle calquera
memoria porque executar para fóra,

91
00:04:08,950 --> 00:04:10,645
el lle vai dar de volta un punteiro nulo.

92
00:04:10,645 --> 00:04:15,282
Vostede recorda o que pasa se
tentar eliminar a referencia un punteiro nulo?

93
00:04:15,282 --> 00:04:17,019
Sufrimos un fallo seg, non?

94
00:04:17,019 --> 00:04:18,060
Isto probablemente non é bo.

95
00:04:18,060 --> 00:04:21,579
>> Así, cada vez que fai unha chamada
para malloc sempre, sempre

96
00:04:21,579 --> 00:04:25,270
que comprobar se é ou non o
punteiro deulle de volta é nulo.

97
00:04:25,270 --> 00:04:28,800
De ser, ten que rematar o seu programa
porque se tentar e dereference

98
00:04:28,800 --> 00:04:31,360
o punteiro nulo está indo
sufrindo un fallo de segmento

99
00:04:31,360 --> 00:04:34,380
eo seu programa é
vai fallar de calquera maneira.

100
00:04:34,380 --> 00:04:37,190
Así como nós estaticamente
obter un enteiro?

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

102
00:04:37,730 --> 00:04:40,010
Nós probablemente fixen iso
unha morea de veces, non?

103
00:04:40,010 --> 00:04:43,480
Isto xera unha variable chamada
x que vive na pila.

104
00:04:43,480 --> 00:04:46,190
Como podemos obter dinamicamente un enteiro?

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

106
00:04:50,010 --> 00:04:53,050
>> Ou, máis apropiadamente
nós diriamos int estrela px

107
00:04:53,050 --> 00:04:57,680
equivale ao tamaño de malloc de int,
só para xogar un pouco menos

108
00:04:57,680 --> 00:04:59,740
números máxicos sobre o noso programa.

109
00:04:59,740 --> 00:05:04,140
Isto vai obter a nós
catro bytes de memoria do heap,

110
00:05:04,140 --> 00:05:06,720
eo punteiro chegamos
de volta para el chámase px.

111
00:05:06,720 --> 00:05:08,430
E entón, así como temos
feito anteriormente nós

112
00:05:08,430 --> 00:05:13,966
Pode eliminar a referencia para px
acceder a esta memoria.

113
00:05:13,966 --> 00:05:15,590
Como podemos obter un número enteiro do usuario?

114
00:05:15,590 --> 00:05:17,970
Podemos dicir int x é igual a obter int.

115
00:05:17,970 --> 00:05:19,930
Isto é moi sinxelo.

116
00:05:19,930 --> 00:05:24,030
E se queremos crear unha matriz
x de Carrozas que viven na pila?

117
00:05:24,030 --> 00:05:28,210
flotar stack_array-- ese é o nome
dos nosos corchetes array-- x.

118
00:05:28,210 --> 00:05:32,419
Isto vai crear a nós un array
x de Carrozas que viven na pila.

119
00:05:32,419 --> 00:05:34,960
Podemos crear unha matriz de Carrozas
que vive na pila tamén.

120
00:05:34,960 --> 00:05:37,330
A sintaxe pode parecer un
pouco máis complicado,

121
00:05:37,330 --> 00:05:41,740
pero podemos dicir flotador
estrela heap_array igual

122
00:05:41,740 --> 00:05:44,360
malloc x veces o tamaño do flotador.

123
00:05:44,360 --> 00:05:48,160
Necesito espacio suficiente para almacenar
x valores de punto flotante.

124
00:05:48,160 --> 00:05:51,560
Entón digo que teño 100
Carrozas, ou 1.000 coches alegóricos.

125
00:05:51,560 --> 00:05:54,810
Así, nese caso, sería
400 bytes para 100 coches alegóricos,

126
00:05:54,810 --> 00:05:59,080
ou 4.000 bytes para 1.000 coches alegóricos,
porque cada flotador ocupa

127
00:05:59,080 --> 00:06:01,230
catro bytes de espazo.

128
00:06:01,230 --> 00:06:05,110
>> Despois de facelo podo usar o
sintaxe paréntese en heap_array.

129
00:06:05,110 --> 00:06:08,970
Así como eu faría stack_array, I
Pode acceder seus elementos individualmente

130
00:06:08,970 --> 00:06:11,590
usando heap_array cero, un heap_array.

131
00:06:11,590 --> 00:06:15,800
Pero recordar a razón que podemos facelo
porque é o nome dunha matriz en C

132
00:06:15,800 --> 00:06:19,990
é realmente un punteiro para
primeiro elemento deste conxunto.

133
00:06:19,990 --> 00:06:23,480
Así, o feito de que estamos declarando un
matriz de Carrozas na pila aquí

134
00:06:23,480 --> 00:06:24,810
en realidade é un pouco erro.

135
00:06:24,810 --> 00:06:27,600
Nós realmente estamos no
segunda liña de código non

136
00:06:27,600 --> 00:06:32,360
tamén a creación dun punteiro para unha peza de
memoria que, a continuación, facer un traballo con.

137
00:06:32,360 --> 00:06:35,620
>> Aquí está o gran problema con
alocada dinamicamente a memoria, porén,

138
00:06:35,620 --> 00:06:38,360
e é por iso que é realmente
importante desenvolver uns bos hábitos

139
00:06:38,360 --> 00:06:39,800
cando se está a traballar con el.

140
00:06:39,800 --> 00:06:43,060
A diferenza declarada estaticamente
memoria, a memoria

141
00:06:43,060 --> 00:06:46,790
non é automaticamente devolta ao
sistema cando a súa función é feito.

142
00:06:46,790 --> 00:06:49,280
Entón, se temos de inicio, e
principal chama unha función

143
00:06:49,280 --> 00:06:53,860
f, cando f acabados sexa o que está facendo
e devolve o control do programa

144
00:06:53,860 --> 00:06:58,810
de volta á principal, toda a memoria
que f usado é xa de volta.

145
00:06:58,810 --> 00:07:01,250
Pode ser usado de novo
por algún outro programa,

146
00:07:01,250 --> 00:07:04,250
ou algunha outra función que
chámase máis tarde na principal.

147
00:07:04,250 --> 00:07:06,970
Pode utilizar a mesma memoria de novo.

148
00:07:06,970 --> 00:07:09,620
>> Se dinamicamente
reservar memoria aínda

149
00:07:09,620 --> 00:07:14,380
ten que dicir explicitamente o
sistema que está feito con el.

150
00:07:14,380 --> 00:07:18,370
Vai coller-lo para ti, o que podería
levar a un problema de vostedes esgotando

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

152
00:07:19,290 --> 00:07:22,179
E, de feito, ás veces, refírense a
para isto como unha perda de memoria.

153
00:07:22,179 --> 00:07:24,970
E ás veces eses perdas de memoria
realmente pode ser realmente devastador

154
00:07:24,970 --> 00:07:27,020
para o desempeño do sistema.

155
00:07:27,020 --> 00:07:31,120
>> Se vostede é un usuario frecuente internet
pode usar certos navegadores web,

156
00:07:31,120 --> 00:07:35,630
e eu non vou citar nomes aquí, pero
existen algúns navegadores web aí fóra

157
00:07:35,630 --> 00:07:39,150
que son notorias para realmente ter
perdas de memoria que non son fixos.

158
00:07:39,150 --> 00:07:44,570
E se deixa o seu navegador aberto
para un período moi longo de tempo, días

159
00:07:44,570 --> 00:07:48,060
e en días, ou semanas, ás veces
Pode notar que o seu sistema

160
00:07:48,060 --> 00:07:49,790
é correndo moi, moi lentamente.

161
00:07:49,790 --> 00:07:54,640
E a razón para iso é que
o explorador reservar memoria,

162
00:07:54,640 --> 00:07:57,320
pero despois non contou o sistema
que está feito con el.

163
00:07:57,320 --> 00:08:01,000
E así que deixa menos memoria
dispoñible para todos os seus programas

164
00:08:01,000 --> 00:08:04,480
ter que compartir, porque é
leaking-- que o navegador web

165
00:08:04,480 --> 00:08:06,755
programa está vazando memoria.

166
00:08:06,755 --> 00:08:08,880
Como é que imos dar de memoria de volta
cando estamos a facer con el?

167
00:08:08,880 --> 00:08:10,838
Ben, por sorte, é unha
xeito moi doado de facelo.

168
00:08:10,838 --> 00:08:11,710
Nós só libralo.

169
00:08:11,710 --> 00:08:15,020
Hai unha función chamada libre,
que acepta un enlace para a memoria,

170
00:08:15,020 --> 00:08:16,010
e nós somos bos de ir.

171
00:08:16,010 --> 00:08:18,310
>> Entón, imos dicir que estamos no
medio do noso programa,

172
00:08:18,310 --> 00:08:21,970
queremos malloc 50 caracteres.

173
00:08:21,970 --> 00:08:25,710
Queremos malloc unha matriz que pode
capaz de reter 50 caracteres.

174
00:08:25,710 --> 00:08:29,109
E cando temos un punteiro de volta ao
que, o nome do punteiro é a palabra.

175
00:08:29,109 --> 00:08:30,900
Facemos o que somos
vai facer palabra,

176
00:08:30,900 --> 00:08:33,440
e, a continuación, cando estamos
feito que só libralo.

177
00:08:33,440 --> 00:08:37,460
E agora temos devolto os 50
bytes de memoria ao seu sistema.

178
00:08:37,460 --> 00:08:40,147
Algunha outra función pode usalos.

179
00:08:40,147 --> 00:08:43,480
Non temos que preocuparse un sufrimento
escape de memoria porque temos liberado palabra.

180
00:08:43,480 --> 00:08:46,639
Nós demos a memoria de volta,
por iso, termine de traballar con el.

181
00:08:46,639 --> 00:08:48,430
Polo tanto, hai tres
regras de ouro que deben

182
00:08:48,430 --> 00:08:51,700
ser mantido en conta sempre que está
reservar dinamicamente a memoria

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

184
00:08:52,990 --> 00:08:56,480
Cada bloque de memoria que
malloc ten que ser liberado

185
00:08:56,480 --> 00:08:58,430
antes do seu programa remata a execución.

186
00:08:58,430 --> 00:09:02,029
Agora, de novo, no aparello ou no
IDE este tipo de pasa para ti de todos os xeitos

187
00:09:02,029 --> 00:09:04,820
você-- cando iso vai ocorrer de forma
cando o programa é pechado,

188
00:09:04,820 --> 00:09:06,880
toda a memoria será liberado.

189
00:09:06,880 --> 00:09:10,750
Pero é xeralmente boa codificación
práctica para sempre, cando estea listo,

190
00:09:10,750 --> 00:09:13,810
liberar o que mallocd.

191
00:09:13,810 --> 00:09:16,690
>> Dito isto, únicas cousas que
tes mallocd deberían ser liberados.

192
00:09:16,690 --> 00:09:19,880
Se declarar un estaticamente
enteiro, int x e coma,

193
00:09:19,880 --> 00:09:23,500
que vive na pila, vostede
non, entón queremos liberar x.

194
00:09:23,500 --> 00:09:25,970
Entón únicas cousas que
mallocd deberían ser liberados.

195
00:09:25,970 --> 00:09:28,960
>> E, para rematar, non facer algo libre dúas veces.

196
00:09:28,960 --> 00:09:31,170
Isto pode levar a
outra situación estraña.

197
00:09:31,170 --> 00:09:33,530
Entón, todo o que tes
mallocd debe ser liberado.

198
00:09:33,530 --> 00:09:36,000
Únicas cousas que
malloc deberían ser liberados.

199
00:09:36,000 --> 00:09:38,730
E non facer algo libre dúas veces.

200
00:09:38,730 --> 00:09:43,660
>> Entón, imos pasar por un exemplo aquí
que algúns alocada dinamicamente

201
00:09:43,660 --> 00:09:46,122
memoria pode parecer mixto
con algunha memoria estática.

202
00:09:46,122 --> 00:09:47,080
O que pode ocorrer aquí?

203
00:09:47,080 --> 00:09:48,913
Vexa se pode seguir
ao longo e difícil de adiviñar o que está

204
00:09:48,913 --> 00:09:51,720
ocorrerá como nós imos
a través de todas estas liñas de código.

205
00:09:51,720 --> 00:09:53,980
>> Así, dicimos int m.

206
00:09:53,980 --> 00:09:54,840
Que pasa aquí?

207
00:09:54,840 --> 00:09:56,339
Ben, iso é moi sinxelo.

208
00:09:56,339 --> 00:09:59,650
Eu crear unha variable enteira chamada m.

209
00:09:59,650 --> 00:10:01,400
Eu colorase lo verde,
porque esa é a cor

210
00:10:01,400 --> 00:10:03,730
que eu uso cando estou falando
preto de variables enteiras.

211
00:10:03,730 --> 00:10:05,160
É unha caixa.

212
00:10:05,160 --> 00:10:08,400
Chámase m, e pode
almacenar números enteiros dentro del.

213
00:10:08,400 --> 00:10:12,400
>> E se eu, a continuación, dicir int estrela un?

214
00:10:12,400 --> 00:10:13,530
Ben, iso é moi semellante.

215
00:10:13,530 --> 00:10:15,780
Estou creando unha caixa chamada a.

216
00:10:15,780 --> 00:10:19,100
É capaz de explotación int
estrelas, punteiros para enteiros.

217
00:10:19,100 --> 00:10:21,570
Entón, eu estou colorido-verde-ish tamén.

218
00:10:21,570 --> 00:10:24,140
>> Sei que ten algo
que ver con un número enteiro,

219
00:10:24,140 --> 00:10:25,852
pero ela propia non é un número enteiro.

220
00:10:25,852 --> 00:10:27,310
Pero é practicamente a mesma idea.

221
00:10:27,310 --> 00:10:28,101
Eu creei unha caixa.

222
00:10:28,101 --> 00:10:30,070
Ambos dereita
agora viven na pila.

223
00:10:30,070 --> 00:10:32,520
Eu dei-lles ambos nomes.

224
00:10:32,520 --> 00:10:36,750
>> int estrela b equivale ao tamaño de malloc de int.

225
00:10:36,750 --> 00:10:38,560
Este pode ser un pouco complicado.

226
00:10:38,560 --> 00:10:44,110
Leva un segundo e pensar sobre o que
era de esperar que suceda neste diagrama.

227
00:10:44,110 --> 00:10:50,210
int estrela b equivale ao tamaño de malloc de int.

228
00:10:50,210 --> 00:10:51,940
>> Ben, iso non basta crear unha caixa.

229
00:10:51,940 --> 00:10:53,800
Isto realmente crea dúas caixas.

230
00:10:53,800 --> 00:10:58,670
E se liga, tamén establece
un punto nunha relación.

231
00:10:58,670 --> 00:11:02,240
Temos asignado a unha pista
de memoria na pila.

232
00:11:02,240 --> 00:11:05,940
Teña en conta que a caixa superior dereita
alí non ten un nome.

233
00:11:05,940 --> 00:11:06,760
>> Nós mallocd-lo.

234
00:11:06,760 --> 00:11:08,050
Existe na pila.

235
00:11:08,050 --> 00:11:10,090
Pero b ten un nome.

236
00:11:10,090 --> 00:11:11,950
É unha variable punteiro chamado b.

237
00:11:11,950 --> 00:11:13,910
Que vive na pila.

238
00:11:13,910 --> 00:11:18,250
>> Polo tanto, é unha peza de memoria
que apunta a outro.

239
00:11:18,250 --> 00:11:21,840
b contén a dirección
do bloque de memoria.

240
00:11:21,840 --> 00:11:23,757
Non ten un nome de outra forma.

241
00:11:23,757 --> 00:11:24,590
Pero apunta a iso.

242
00:11:24,590 --> 00:11:29,760
Así, cando dicimos int estrela b é igual a
malloc tamaño do int, que alí mesmo,

243
00:11:29,760 --> 00:11:33,490
que a frecha que apareceu na
lado dereito alí, aquela cousa toda,

244
00:11:33,490 --> 00:11:36,740
Vou ter que aparecer
de novo, é o que pasa.

245
00:11:36,740 --> 00:11:39,341
Todo isto acontece
que unha soa liña de código.

246
00:11:39,341 --> 00:11:41,340
Agora imos chegar algo máis
simple de novo.

247
00:11:41,340 --> 00:11:43,330
un é igual e comercial m.

248
00:11:43,330 --> 00:11:46,280
Vostede recorda o que un
é igual e comercial m é?

249
00:11:46,280 --> 00:11:48,920
Ben, iso é un recibe o enderezo de m.

250
00:11:48,920 --> 00:11:54,150
Ou poñer máis esquemáticamente,
algúns puntos para m.

251
00:11:54,150 --> 00:11:56,360
>> b é igual a un.

252
00:11:56,360 --> 00:11:57,560
Aceptar entón aquí está outro.

253
00:11:57,560 --> 00:11:59,230
Un igual ao b.

254
00:11:59,230 --> 00:12:02,260
O que vai ocorrer
o diagrama esta vez?

255
00:12:02,260 --> 00:12:04,330
>> Ben recordar que o
obras operador de asignación

256
00:12:04,330 --> 00:12:08,960
atribuíndo o valor no
dereito do valor do lado esquerdo.

257
00:12:08,960 --> 00:12:14,820
Entón, en vez de un enlace para m, unha empresa
apunta para o mesmo lugar que b puntos.

258
00:12:14,820 --> 00:12:18,900
un non apunta a B, A
puntos onde b puntos.

259
00:12:18,900 --> 00:12:25,280
>> Un agroma para b que faría
ser un igual e comercial b.

260
00:12:25,280 --> 00:12:28,150
Pero, en vez de un é igual ab só
significa que a e b son agora

261
00:12:28,150 --> 00:12:31,770
apuntando para o mesmo enderezo, porque
dentro b é só un enderezo.

262
00:12:31,770 --> 00:12:35,004
E agora dentro dun é o mesmo enderezo.

263
00:12:35,004 --> 00:12:37,170
m é igual a 10, probablemente o
O máis sinxelo

264
00:12:37,170 --> 00:12:38,690
fixemos un pouco.

265
00:12:38,690 --> 00:12:40,460
Pon a 10 no cadro.

266
00:12:40,460 --> 00:12:45,640
Estrela b é igual a m plus 2, marca de
nosa punteiros vídeo que estrela b significa.

267
00:12:45,640 --> 00:12:50,230
Estamos indo para dereference b e put
algún valor en que a localización de memoria.

268
00:12:50,230 --> 00:12:51,860
Neste caso 12.

269
00:12:51,860 --> 00:12:55,300
>> Entón, cando dereference un punto de
recordar que acabamos de viaxar baixo a frecha.

270
00:12:55,300 --> 00:12:58,205
Ou dito doutra forma,
ir a este enderezo de memoria

271
00:12:58,205 --> 00:12:59,580
e manipula-lo de algunha maneira.

272
00:12:59,580 --> 00:13:00,830
Poñemos un valor alí.

273
00:13:00,830 --> 00:13:03,960
Neste caso estrela b
é igual a m máis 2 é só

274
00:13:03,960 --> 00:13:08,230
ir á variable apuntada por b,
ir á memoria apuntada por b,

275
00:13:08,230 --> 00:13:11,750
e poñer máis 2 m de alí, 12.

276
00:13:11,750 --> 00:13:14,970
>> Agora eu liberar b.

277
00:13:14,970 --> 00:13:16,490
Que pasa cando liberar b?

278
00:13:16,490 --> 00:13:18,800
Lembre que eu dixen medios libres.

279
00:13:18,800 --> 00:13:21,920
O que estou dicindo cando liberar b?

280
00:13:21,920 --> 00:13:23,410
>> Estou canso de traballar con el, non?

281
00:13:23,410 --> 00:13:25,702
Eu esencialmente desistir da memoria.

282
00:13:25,702 --> 00:13:26,910
Doulle ao seu sistema.

283
00:13:26,910 --> 00:13:33,010
Eu non teño máis diso é
o que eu estou dicindo a eles, OK?

284
00:13:33,010 --> 00:13:37,390
>> Agora, se eu digo unha estrela
é igual a 11 probablemente pode

285
00:13:37,390 --> 00:13:40,460
xa dicir que algo malo
que vai pasar aquí, non?

286
00:13:40,460 --> 00:13:44,160
E, de feito, se eu tente que eu probablemente
sufriría un fallo de segmento.

287
00:13:44,160 --> 00:13:47,140
Porque agora, aínda
anteriormente que pedazo de memoria

288
00:13:47,140 --> 00:13:50,220
era algo que tiña
acceso, neste punto

289
00:13:50,220 --> 00:13:54,590
Agora eu estou accedendo memoria que
non é legal para min para acceder.

290
00:13:54,590 --> 00:13:57,330
>> E como nós, probablemente,
lembro, cando acceder a memoria

291
00:13:57,330 --> 00:14:00,000
que non se quere tarifas,
esa é a causa máis común

292
00:14:00,000 --> 00:14:01,860
dunha segmentación
fallo. E así o meu programa

293
00:14:01,860 --> 00:14:05,170
deixaría de funcionar se eu intentase facer.

294
00:14:05,170 --> 00:14:09,910
Entón, de novo, é unha boa idea para obter un bo
prácticas e bos hábitos enraizados

295
00:14:09,910 --> 00:14:12,920
cando se traballa con malloc e libre,
de xeito que non sofre de segmentación

296
00:14:12,920 --> 00:14:15,310
fallos, e que utiliza
seu alocada dinamicamente

297
00:14:15,310 --> 00:14:17,370
memoria de forma responsable.

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

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