1
00:00:00,000 --> 00:00:06,030
>> [Música tocando]

2
00:00:06,030 --> 00:00:08,390
>> Doug LLOYD: Punteiros, aquí estamos nós.

3
00:00:08,390 --> 00:00:11,080
Este é probablemente vai
ser o tema máis difícil

4
00:00:11,080 --> 00:00:12,840
que falamos en CS50.

5
00:00:12,840 --> 00:00:15,060
E se leu
nada punteiros

6
00:00:15,060 --> 00:00:19,080
antes de que pode ser un pouco
intimidador entrar nun vídeo.

7
00:00:19,080 --> 00:00:21,260
É certo que os punteiros
non permitir-lle a capacidade

8
00:00:21,260 --> 00:00:23,740
quizais para romper
moi mal cando está

9
00:00:23,740 --> 00:00:27,450
traballar con variables, e os datos,
e facendo que o seu programa trabe.

10
00:00:27,450 --> 00:00:30,490
Pero son realmente moi útil
e nos realmente unha boa forma permitir

11
00:00:30,490 --> 00:00:33,340
para pasar datos de volta e
atrás entre funcións,

12
00:00:33,340 --> 00:00:35,490
que somos doutro xeito incapaz de facer.

13
00:00:35,490 --> 00:00:37,750
>> E así o que realmente
quero facer aquí é tren

14
00:00:37,750 --> 00:00:41,060
que teña unha boa disciplina punteiro, así
que pode usar agullas de forma eficaz

15
00:00:41,060 --> 00:00:43,850
para facer os seus programas que moito mellor.

16
00:00:43,850 --> 00:00:48,220
Como dixen punteiros dar unha diferente
forma de pasar datos entre funcións.

17
00:00:48,220 --> 00:00:50,270
Agora, se lembrar de
un vídeo anterior, cando

18
00:00:50,270 --> 00:00:53,720
que estaban falando sobre
ámbito de variables, eu mencionen

19
00:00:53,720 --> 00:01:00,610
que todos os datos que pasan entre
funcións en C é pasado por valor.

20
00:01:00,610 --> 00:01:03,070
E eu non pode usar que
prazo, o que eu quería dicir alí

21
00:01:03,070 --> 00:01:07,170
foi a de que estamos pasando copias de datos.

22
00:01:07,170 --> 00:01:12,252
Cando pasar unha variable a unha función,
non estamos realmente pasando a variable

23
00:01:12,252 --> 00:01:13,210
para a función, non?

24
00:01:13,210 --> 00:01:17,670
Estamos pasando unha copia do
que os datos para a función.

25
00:01:17,670 --> 00:01:20,760
A función fai o que vai
e calcúlase algún valor,

26
00:01:20,760 --> 00:01:23,180
e quizais usamos ese valor
cando dalo de volta.

27
00:01:23,180 --> 00:01:26,700
>> Houbo unha excepción para
esta regra de pasar por valor,

28
00:01:26,700 --> 00:01:31,210
e nós imos voltar para o que
é un pouco máis tarde, nun vídeo.

29
00:01:31,210 --> 00:01:34,880
Se usarmos punteiros vez
do uso de variables,

30
00:01:34,880 --> 00:01:38,180
ou en vez de utilizar as variables
si ou copias das variables,

31
00:01:38,180 --> 00:01:43,790
agora podemos pasar as variables en torno a
entre as funcións dun xeito diferente.

32
00:01:43,790 --> 00:01:46,550
Isto significa que se facemos
un cambio de unha función,

33
00:01:46,550 --> 00:01:49,827
que o cambio vai realmente tomar
efecto nunha función diferente.

34
00:01:49,827 --> 00:01:52,160
De novo, iso é algo que
non podiamos facer antes,

35
00:01:52,160 --> 00:01:56,979
e se xa intentou cambiar o
valor de dúas variables nunha función,

36
00:01:56,979 --> 00:01:59,270
entender este problema
tipo de rastreando-se, non?

37
00:01:59,270 --> 00:02:04,340
>> Se queremos cambiar X e Y, e nós
paso-las para unha función chamada intercambio,

38
00:02:04,340 --> 00:02:08,680
dentro da función cambiar o
variables facer valores de cambio.

39
00:02:08,680 --> 00:02:12,600
Un pasa a ser dous, dous convértese en
un, pero non, en realidade,

40
00:02:12,600 --> 00:02:16,890
cambiar nada no orixinal
función, o chamador.

41
00:02:16,890 --> 00:02:19,550
Porque non podemos, nós somos só
traballar con copias deles.

42
00:02:19,550 --> 00:02:24,760
Con agullas aínda, podemos
realmente pasar X e Y a unha función.

43
00:02:24,760 --> 00:02:26,960
Esta función pode facer
algo con eles.

44
00:02:26,960 --> 00:02:29,250
E eses valores variables
realmente cambiar.

45
00:02:29,250 --> 00:02:33,710
Entón, iso é un gran cambio en
nosa capacidade de traballar con datos.

46
00:02:33,710 --> 00:02:36,100
>> Antes de mergulharmos
punteiros, creo que paga a pena

47
00:02:36,100 --> 00:02:38,580
Tomar uns minutos para
volver ao básico aquí.

48
00:02:38,580 --> 00:02:41,000
E ter un ollar en como
obras de memoria de ordenador

49
00:02:41,000 --> 00:02:45,340
porque estes dous asuntos van
para realmente ser moi interrelacionados.

50
00:02:45,340 --> 00:02:48,480
Como probablemente sabe,
no seu sistema informático

51
00:02:48,480 --> 00:02:51,310
ten un disco duro ou
quizais unha unidade de estado sólido,

52
00:02:51,310 --> 00:02:54,430
algún tipo de lugar de almacenamento de ficheiros.

53
00:02:54,430 --> 00:02:57,950
É xeralmente en algún lugar no
barrio de 250 gigabytes

54
00:02:57,950 --> 00:02:59,810
para quizais un par de terabytes agora.

55
00:02:59,810 --> 00:03:02,270
E é onde todo o seu
arquivos, finalmente, vivir,

56
00:03:02,270 --> 00:03:04,870
mesmo cando o ordenador está apagado
fóra, pode liga-lo de novo

57
00:03:04,870 --> 00:03:09,190
e vai atopar os seus arquivos están alí
de novo cando reiniciar o sistema.

58
00:03:09,190 --> 00:03:14,820
Pero as unidades de disco, como unha unidade de disco duro,
un disco duro ou unha unidade de estado sólido, un SSD,

59
00:03:14,820 --> 00:03:16,050
son só o espazo de almacenamento.

60
00:03:16,050 --> 00:03:20,400
>> Non podemos realmente facer algo con
Os datos que está no disco duro,

61
00:03:20,400 --> 00:03:22,080
ou nunha unidade de estado sólido.

62
00:03:22,080 --> 00:03:24,950
Co fin de que realmente cambiar
datos ou movelo,

63
00:03:24,950 --> 00:03:28,800
debemos mover para
RAM, memoria de acceso aleatorio.

64
00:03:28,800 --> 00:03:31,170
Agora RAM, ten unha morea
menos no seu ordenador.

65
00:03:31,170 --> 00:03:34,185
Pode que nalgún lugar no
barrio de 512 megabytes

66
00:03:34,185 --> 00:03:38,850
se ten un ordenador máis antigo,
para quizais dous, catro, oito, 16,

67
00:03:38,850 --> 00:03:41,820
posiblemente incluso un pouco
máis gigabytes de memoria RAM.

68
00:03:41,820 --> 00:03:46,390
Entón, iso é moi pequena, pero iso é
onde todos os datos volátiles existe.

69
00:03:46,390 --> 00:03:48,270
É alí onde podemos cambiar as cousas.

70
00:03:48,270 --> 00:03:53,350
Pero cando volvemos nosa ordenador apagado,
todos os datos da memoria RAM é destruído.

71
00:03:53,350 --> 00:03:57,150
>> Entón é por iso que necesitamos ter disco duro
para a localización de máis permanente que,

72
00:03:57,150 --> 00:03:59,720
de xeito que ela sería exists-
ser moi malo se cada vez que

73
00:03:59,720 --> 00:04:03,310
virou noso ordenador apagado, cada
arquivo no noso sistema foi obliterada.

74
00:04:03,310 --> 00:04:05,600
Por iso, traballamos dentro da RAM.

75
00:04:05,600 --> 00:04:09,210
E cada vez que estamos a falar
memoria, practicamente, en CS50,

76
00:04:09,210 --> 00:04:15,080
estamos a falar de RAM, disco duro non.

77
00:04:15,080 --> 00:04:18,657
>> Entón, cando cambiar as cousas na memoria,
leva-se unha certa cantidade de espazo.

78
00:04:18,657 --> 00:04:20,740
Todo tipo de datos que
temos está a traballar con

79
00:04:20,740 --> 00:04:23,480
asumir diferentes
cantidades de espazo na memoria RAM.

80
00:04:23,480 --> 00:04:27,600
Entón, cada vez que se crea un enteiro
variables, catro bytes de memoria

81
00:04:27,600 --> 00:04:30,750
son postos de lado na memoria RAM para que
pode traballar con ese enteiro.

82
00:04:30,750 --> 00:04:34,260
Pode declarar o número enteiro,
mudalo, asocia-la

83
00:04:34,260 --> 00:04:36,700
para un valor de 10 incrementado
por un, así por diante e así por diante.

84
00:04:36,700 --> 00:04:39,440
Todo o que ten que ocorrer en
RAM, e terá catro bytes

85
00:04:39,440 --> 00:04:42,550
traballando con cada
enteiro que crea.

86
00:04:42,550 --> 00:04:45,410
>> Cada personaxe que
crear recibe un byte.

87
00:04:45,410 --> 00:04:48,160
Isto é só a cantidade de espazo
necesarios para almacenar un personaxe.

88
00:04:48,160 --> 00:04:51,310
Cada float, unha verdadeira
número, recibe catro bytes

89
00:04:51,310 --> 00:04:53,390
a non ser que sexa un dobre
Precisión de punto flotante

90
00:04:53,390 --> 00:04:56,510
número, o que lle permite
díxitos ten máis precisas ou máis

91
00:04:56,510 --> 00:04:59,300
despois do punto decimal
sen perder precisión,

92
00:04:59,300 --> 00:05:01,820
que ocupan oito bytes de memoria.

93
00:05:01,820 --> 00:05:06,730
Ansia por moito tempo, realmente grandes números enteiros,
tamén ocupan oito bytes de memoria.

94
00:05:06,730 --> 00:05:09,000
Cantos bytes de memoria
non cordas asumir?

95
00:05:09,000 --> 00:05:12,990
Ben, imos poñer un pino en cuestión que
por agora, pero imos volver a el.

96
00:05:12,990 --> 00:05:17,350
>> Entón, de volta a esta idea de memoria como
unha gran variedade de células de tamaño byte.

97
00:05:17,350 --> 00:05:20,871
Isto é realmente todo o que é, é
só unha enorme variedade de células,

98
00:05:20,871 --> 00:05:23,370
así como calquera outra matriz que
está familiarizado con e ver,

99
00:05:23,370 --> 00:05:26,430
excepto cada elemento é un byte de ancho.

100
00:05:26,430 --> 00:05:30,030
E, así como unha matriz,
cada elemento ten un enderezo.

101
00:05:30,030 --> 00:05:32,120
Cada elemento dun array
ten un índice, e nós

102
00:05:32,120 --> 00:05:36,302
Pode utilizar este índice de facer chamadas
de acceso aleatorio na matriz.

103
00:05:36,302 --> 00:05:38,510
Non hai que comezar a
o inicio da matriz,

104
00:05:38,510 --> 00:05:40,569
iterado a través de cada
único elemento do mesmo,

105
00:05:40,569 --> 00:05:41,860
para atopar o que estamos buscando.

106
00:05:41,860 --> 00:05:45,790
Podemos só dicir, quero chegar ao
15th elemento ou do elemento 100A.

107
00:05:45,790 --> 00:05:49,930
E pode só pasar ese número
e obter o valor que está a procurar.

108
00:05:49,930 --> 00:05:54,460
>> Así mesmo cada lugar
na memoria ten un enderezo.

109
00:05:54,460 --> 00:05:57,320
Polo tanto, a súa memoria pode
algo coma isto.

110
00:05:57,320 --> 00:06:01,420
Aquí está un pequeno anaco de
memoria, esta é de 20 bytes de memoria.

111
00:06:01,420 --> 00:06:04,060
Os primeiros 20 bytes, porque o meu
aborda alí no fondo

112
00:06:04,060 --> 00:06:08,890
son 0, 1, 2, 3, e así
en todo o camiño ata a 19.

113
00:06:08,890 --> 00:06:13,190
E cando eu declarar variables e
cando comezar a traballar con eles,

114
00:06:13,190 --> 00:06:15,470
o sistema vai definir
reservar un espazo para me

115
00:06:15,470 --> 00:06:17,595
nesta memoria para traballar
cos meus variables.

116
00:06:17,595 --> 00:06:21,610
Entón, eu podería dicir, char c é igual a de capital
H. E o que vai pasar?

117
00:06:21,610 --> 00:06:23,880
Ben, o sistema vai
reservado para me un byte.

118
00:06:23,880 --> 00:06:27,870
Neste caso, el escolleu o número de bytes
catro, o byte no enderezo catro,

119
00:06:27,870 --> 00:06:31,310
e está indo para almacenar o
letra H de capital en alí para min.

120
00:06:31,310 --> 00:06:34,350
Se eu, entón, dicir velocidade int
límite é igual a 65, é

121
00:06:34,350 --> 00:06:36,806
vai destinar catro
bytes de memoria para min.

122
00:06:36,806 --> 00:06:39,180
E vai tratar aqueles
catro bytes como unha única unidade

123
00:06:39,180 --> 00:06:41,305
porque o que nós estamos a traballar
é un número enteiro con aquí.

124
00:06:41,305 --> 00:06:44,350
E vai a almacenar 65 en alí.

125
00:06:44,350 --> 00:06:47,000
>> Agora xa estou medio
dicíndolle un pouco de unha mentira,

126
00:06:47,000 --> 00:06:50,150
dereito, porque sabemos que
ordenadores traballar en binario.

127
00:06:50,150 --> 00:06:53,100
Eles non entenden
necesariamente o que é un capital H

128
00:06:53,100 --> 00:06:57,110
ou o que é un 65, eles só
comprender binarios, ceros e uns.

129
00:06:57,110 --> 00:06:59,000
E así, en realidade, o que
estamos almacenando alí

130
00:06:59,000 --> 00:07:03,450
non é a letra H eo número 65,
senón as representacións binarias

131
00:07:03,450 --> 00:07:06,980
destes, que parecen un
pouco algo así.

132
00:07:06,980 --> 00:07:10,360
E, en particular no
contexto da variable número enteiro,

133
00:07:10,360 --> 00:07:13,559
non vai só cuspi-lo,
non está indo para trata-lo como un de catro

134
00:07:13,559 --> 00:07:15,350
byte peza necesariamente,
está realmente a suceder

135
00:07:15,350 --> 00:07:19,570
tratala como un catro anacos de byte,
o que podería ser algo así.

136
00:07:19,570 --> 00:07:22,424
E aínda que non é
enteiramente verdade, quere,

137
00:07:22,424 --> 00:07:24,840
por mor de algo chamado
unha ordenación, que non estamos

138
00:07:24,840 --> 00:07:26,965
vai entrar agora, pero
Se está curioso para saber,

139
00:07:26,965 --> 00:07:29,030
pode ler-se en pouco
e gran endianness.

140
00:07:29,030 --> 00:07:31,640
Pero por mor dese argumento,
por mor deste vídeo,

141
00:07:31,640 --> 00:07:34,860
imos supor que é, en
feito, como o número 65 sería

142
00:07:34,860 --> 00:07:36,970
ser representado en
memoria en cada sistema,

143
00:07:36,970 --> 00:07:38,850
aínda que non é enteiramente verdade.

144
00:07:38,850 --> 00:07:41,700
>> Pero imos realmente só obter
librar de todos binario enteiramente,

145
00:07:41,700 --> 00:07:44,460
e só pensar en como H
e 65, é moito máis fácil

146
00:07:44,460 --> 00:07:47,900
pensar niso como
que, como un ser humano.

147
00:07:47,900 --> 00:07:51,420
Todo ben, entón tamén parece quizais un
pouco aleatorio que I've- meu sistema

148
00:07:51,420 --> 00:07:55,130
non me deu bytes 5, 6, 7,
e 8 para almacenar o número enteiro.

149
00:07:55,130 --> 00:07:58,580
Hai unha razón para iso, tamén, que
Non imos entrar agora, pero só

150
00:07:58,580 --> 00:08:00,496
dicir que o que o
ordenador está facendo aquí

151
00:08:00,496 --> 00:08:02,810
pode ser unha boa xogada da súa parte.

152
00:08:02,810 --> 00:08:06,020
Para non darme a memoria que é
necesariamente ao atrás.

153
00:08:06,020 --> 00:08:10,490
Aínda que vai facelo agora
se eu queira obter outra secuencia,

154
00:08:10,490 --> 00:08:13,080
chamado apelidos, e quero
para poñer Lloyd alí.

155
00:08:13,080 --> 00:08:18,360
Vou ter para caber un
carácter, cada letra do que é

156
00:08:18,360 --> 00:08:21,330
vai esixir un
carácter, un byte de memoria.

157
00:08:21,330 --> 00:08:26,230
Entón, se eu podería poñer Lloyd na miña matriz
así eu son moi bo para ir, non?

158
00:08:26,230 --> 00:08:28,870
O que falta?

159
00:08:28,870 --> 00:08:31,840
>> Lembre que cada corda traballamos
con en C remata con barra invertida cero,

160
00:08:31,840 --> 00:08:33,339
e non podemos omitir que aquí, tamén.

161
00:08:33,339 --> 00:08:36,090
Necesitamos deixar de lado un byte
de memoria para almacenar que así nós

162
00:08:36,090 --> 00:08:39,130
saber cando nosa cadea rematou.

163
00:08:39,130 --> 00:08:41,049
Entón, de novo este arranxo
de como as cousas

164
00:08:41,049 --> 00:08:42,799
aparecen en poder de memoria
ser un pouco ao chou,

165
00:08:42,799 --> 00:08:44,870
pero, en realidade, é como
a maioría dos sistemas están deseñados.

166
00:08:44,870 --> 00:08:48,330
Para aliñar a eles en múltiples
de catro, por razóns de novo

167
00:08:48,330 --> 00:08:50,080
que non precisa
entrar agora.

168
00:08:50,080 --> 00:08:53,060
Pero iso, entón basta dicir que
Despois destas tres liñas de código,

169
00:08:53,060 --> 00:08:54,810
este é o que a memoria pode parecer.

170
00:08:54,810 --> 00:08:58,930
Se eu ter lugares de memoria
4, 8, e 12 para manter os datos,

171
00:08:58,930 --> 00:09:01,100
isto é o que a miña memoria pode parecer.

172
00:09:01,100 --> 00:09:04,062
>> E só ser particularmente
pedante aquí, cando

173
00:09:04,062 --> 00:09:06,020
estamos a falar de memoria
enderezos que adoitamos

174
00:09:06,020 --> 00:09:08,390
facelo utilizando notacións hexadecimais.

175
00:09:08,390 --> 00:09:12,030
Entón, por que non podemos converter todos estes
de decimal a notación hexadecimal

176
00:09:12,030 --> 00:09:15,010
só porque iso é xeralmente
como nos referimos a memoria.

177
00:09:15,010 --> 00:09:17,880
Entón, en vez de ser de 0 a
19, o que temos é cero

178
00:09:17,880 --> 00:09:20,340
x cero a cero, tres x1.

179
00:09:20,340 --> 00:09:23,790
Estes son os 20 bytes de memoria que
ter ou nós estamos mirando nesta imaxe

180
00:09:23,790 --> 00:09:25,540
xusto aquí.

181
00:09:25,540 --> 00:09:29,310
>> Entón, todo o que se dixo, imos
afastarse da memoria para un segundo

182
00:09:29,310 --> 00:09:30,490
e ao punteiros.

183
00:09:30,490 --> 00:09:32,420
Aquí é o máis importante
cousa a lembrar

184
00:09:32,420 --> 00:09:34,070
a medida que comezar a traballar con punteiros.

185
00:09:34,070 --> 00:09:36,314
Un punteiro é nada
máis dun enderezo.

186
00:09:36,314 --> 00:09:38,230
Eu vou dicir de novo porque
é tan importante,

187
00:09:38,230 --> 00:09:42,730
un punteiro non é nada
máis dun enderezo.

188
00:09:42,730 --> 00:09:47,760
Os punteiros son enderezos para lugares
na memoria onde variables vivir.

189
00:09:47,760 --> 00:09:52,590
Sabendo que xa é un esperanza
pouco máis fácil traballar con eles.

190
00:09:52,590 --> 00:09:54,550
Outra cousa que me gusta
que facer é ter sorte

191
00:09:54,550 --> 00:09:58,510
de diagramas visualmente representando o que é
pasando con varias liñas de código.

192
00:09:58,510 --> 00:10:00,660
E nós imos facelo un par
de cando en punteiros,

193
00:10:00,660 --> 00:10:03,354
e cando falamos de dinámica
reserva de memoria tamén.

194
00:10:03,354 --> 00:10:06,020
Porque eu creo que estes diagramas
pode ser especialmente útil.

195
00:10:06,020 --> 00:10:09,540
>> Entón, se eu dicir, por exemplo, int k
no meu código, que está a suceder?

196
00:10:09,540 --> 00:10:12,524
O que está a suceder é basicamente
Estou quedando memoria reservada para min,

197
00:10:12,524 --> 00:10:14,690
pero eu non me gusta nin de
pense nisto como este, eu

198
00:10:14,690 --> 00:10:16,300
gusto de pensar niso como unha caixa.

199
00:10:16,300 --> 00:10:20,090
Eu teño unha caixa e é
de cor verde porque

200
00:10:20,090 --> 00:10:21,750
pode pór enteiros en caixas verdes.

201
00:10:21,750 --> 00:10:23,666
Se fose un personaxe que eu
pode ter unha caixa azul.

202
00:10:23,666 --> 00:10:27,290
Pero sempre digo, se eu estou creando
unha caixa que pode conter enteiros

203
00:10:27,290 --> 00:10:28,950
que a caixa é de cor verde.

204
00:10:28,950 --> 00:10:33,020
E eu tomo un marcador permanente
e eu k escribir sobre o lado do mesmo.

205
00:10:33,020 --> 00:10:37,590
Entón, eu teño unha caixa chamada k,
para que eu poida poñer enteiros.

206
00:10:37,590 --> 00:10:41,070
Polo tanto, cando digo int k, que é
o que pasa na miña cabeza.

207
00:10:41,070 --> 00:10:43,140
Se eu digo que k é igual a cinco, o que estou facendo?

208
00:10:43,140 --> 00:10:45,110
Ben, eu estou poñendo cinco
no cadro, seguro.

209
00:10:45,110 --> 00:10:48,670
Isto é moi sinxelo, se
Digo int k, crear unha caixa chamada k.

210
00:10:48,670 --> 00:10:52,040
Se eu digo que k é igual a 5,
poñer cinco na caixa.

211
00:10:52,040 --> 00:10:53,865
Esperemos que isto non é moi de un salto.

212
00:10:53,865 --> 00:10:55,990
Aquí é onde as cousas van un
pouco interesante aínda.

213
00:10:55,990 --> 00:11:02,590
Se eu digo int * pk, así, aínda que eu non fai
sabe o que é, necesariamente,

214
00:11:02,590 --> 00:11:06,150
é claramente ten algo
que ver con un número enteiro.

215
00:11:06,150 --> 00:11:08,211
Entón eu vou para colorear
esta caixa verde-ISH,

216
00:11:08,211 --> 00:11:10,210
Sei que ten algo
que ver con un número enteiro,

217
00:11:10,210 --> 00:11:13,400
pero non é un número enteiro en si,
porque é unha estrela int.

218
00:11:13,400 --> 00:11:15,390
Hai algo lixeiramente
diferente sobre iso.

219
00:11:15,390 --> 00:11:17,620
Tan implicado un número enteiro,
pero se non, é

220
00:11:17,620 --> 00:11:19,830
non moi diferente do
o que estabamos falando.

221
00:11:19,830 --> 00:11:24,240
É unha caixa, o seu ten unha etiqueta,
ela está a levar posto un pk etiqueta,

222
00:11:24,240 --> 00:11:27,280
e é capaz de explotación
estrelas int, calquera que sexan.

223
00:11:27,280 --> 00:11:29,894
Teñen algo que ver
con números enteiros, de forma clara.

224
00:11:29,894 --> 00:11:31,060
Aquí é a última liña aínda.

225
00:11:31,060 --> 00:11:37,650
Se eu digo pk = k, whoa,
o que pasou, non?

226
00:11:37,650 --> 00:11:41,820
Polo tanto, este número aleatorio, aparentemente aleatoria
número, vai no cadro alí.

227
00:11:41,820 --> 00:11:44,930
Todo o que é, é pk
obtén a dirección de k.

228
00:11:44,930 --> 00:11:52,867
Entón, eu estou unirse onde k vive na memoria,
seu enderezo, a dirección dos seus bytes.

229
00:11:52,867 --> 00:11:55,200
Todo o que eu estou facendo é que eu estou dicindo
este valor é o que eu vou

230
00:11:55,200 --> 00:11:59,430
para poñer dentro da miña caixa chamada pk.

231
00:11:59,430 --> 00:12:02,080
E por isto son
punteiros, e porque procura

232
00:12:02,080 --> 00:12:04,955
nunha cadea como nula x
oito cero ° C sete catro oito

233
00:12:04,955 --> 00:12:07,790
dous cero pode ser
non moi significativa.

234
00:12:07,790 --> 00:12:12,390
Cando xeralmente ver punteiros,
realmente facelo como punteiros.

235
00:12:12,390 --> 00:12:17,000
Pk dános a información
necesitamos atopar k na memoria.

236
00:12:17,000 --> 00:12:19,120
Entón, basicamente pk ten unha frecha nela.

237
00:12:19,120 --> 00:12:21,670
E se andarmos a lonxitude
de que a frecha, imaxine

238
00:12:21,670 --> 00:12:25,280
é algo que pode camiñar sobre, se nós
camiñar ao longo da lonxitude da frecha,

239
00:12:25,280 --> 00:12:29,490
na punta de flecha que, nos
vai atopar o lugar na memoria

240
00:12:29,490 --> 00:12:31,390
onde k vive.

241
00:12:31,390 --> 00:12:34,360
E iso é realmente importante
porque unha vez que sabemos onde k vive,

242
00:12:34,360 --> 00:12:37,870
podemos empezar a traballar cos datos
no interior do referido local de memoria.

243
00:12:37,870 --> 00:12:40,780
Aínda estamos empezando un pequenininho
pouco por diante de nós mesmos para o momento.

244
00:12:40,780 --> 00:12:42,240
>> Entón, o que é un punteiro?

245
00:12:42,240 --> 00:12:45,590
Un punteiro é un elemento de datos cuxo
valor é un enderezo de memoria.

246
00:12:45,590 --> 00:12:49,740
Isto foi o que o cero x oito cousas de cero
pasando, que era un enderezo de memoria.

247
00:12:49,740 --> 00:12:52,060
Esa era unha posición na memoria.

248
00:12:52,060 --> 00:12:55,080
E do tipo de un punteiro
describe o tipo

249
00:12:55,080 --> 00:12:56,930
de datos que vai atopar no
este enderezo de memoria.

250
00:12:56,930 --> 00:12:58,810
Polo tanto, hai a parte dereita int estrela.

251
00:12:58,810 --> 00:13:03,690
Se eu seguir esta flecha, é
me vai levar a un lugar.

252
00:13:03,690 --> 00:13:06,980
E ese lugar, o que eu
vai atopar alí no meu exemplo,

253
00:13:06,980 --> 00:13:08,240
é unha caixa de cor verde.

254
00:13:08,240 --> 00:13:12,650
É un enteiro, que é o que eu
vai atopar se eu ir a ese enderezo.

255
00:13:12,650 --> 00:13:14,830
O tipo de datos a
punteiro describe o que

256
00:13:14,830 --> 00:13:17,936
vai atopar ese enderezo de memoria.

257
00:13:17,936 --> 00:13:19,560
Entón aquí está a cousa moi legal aínda.

258
00:13:19,560 --> 00:13:25,090
Punteiros nos permiten pasar
variables entre funcións.

259
00:13:25,090 --> 00:13:28,520
E, de feito, pasar variables
e non pasar copias deles.

260
00:13:28,520 --> 00:13:32,879
Porque se sabemos exactamente onde
na memoria para atopar unha variable,

261
00:13:32,879 --> 00:13:35,670
non precisamos de facer unha copia de
Lo, podemos só ir a ese lugar

262
00:13:35,670 --> 00:13:37,844
e traballar con esa variable.

263
00:13:37,844 --> 00:13:40,260
Así, en esencia punteiros especie
de facer un ambiente de ordenador

264
00:13:40,260 --> 00:13:42,360
moito máis parecido ao mundo real, correcta.

265
00:13:42,360 --> 00:13:44,640
>> Entón aquí vai unha analoxía.

266
00:13:44,640 --> 00:13:48,080
Imos dicir que eu teño un portátil,
dereito, e está cheo de notas.

267
00:13:48,080 --> 00:13:50,230
E gustaríame que actualiza-lo.

268
00:13:50,230 --> 00:13:53,960
É unha función que
actualizacións notas, certo.

269
00:13:53,960 --> 00:13:56,390
No camiño nós estivemos
funcionando ata agora, o que

270
00:13:56,390 --> 00:14:02,370
pasa é que vai tomar o meu portátil,
ir ata a tenda de copia,

271
00:14:02,370 --> 00:14:06,410
vai facer unha copia de Xerox
todas as páxinas do caderno.

272
00:14:06,410 --> 00:14:09,790
Vai deixar o meu portátil de volta
na miña mesa cando estea listo,

273
00:14:09,790 --> 00:14:14,600
vai pasar e risco cousas na miña
notebook que están desactualizados ou mal,

274
00:14:14,600 --> 00:14:19,280
e entón vai pasar ao
me a pila de páxinas Xerox

275
00:14:19,280 --> 00:14:22,850
que é unha réplica do meu portátil con
os cambios que fixo a ela.

276
00:14:22,850 --> 00:14:27,040
E nese punto, cómpre a min como
a función de chamada, como o interlocutor,

277
00:14:27,040 --> 00:14:30,582
para decidir tomar as súas notas e
integrala los de volta para o meu portátil.

278
00:14:30,582 --> 00:14:32,540
Polo tanto, hai unha serie de pasos
implicado aquí, certo.

279
00:14:32,540 --> 00:14:34,850
Como non sería mellor
se eu só dicir, hey, pode

280
00:14:34,850 --> 00:14:38,370
actualizar o meu portátil para
me, entregar-lle o meu portátil,

281
00:14:38,370 --> 00:14:40,440
e levar as cousas e
literalmente cruza-los fora

282
00:14:40,440 --> 00:14:42,810
e actualizar as miñas notas na miña caderno.

283
00:14:42,810 --> 00:14:45,140
E, a continuación, dar-me o meu portátil de volta.

284
00:14:45,140 --> 00:14:47,320
Ese é o tipo que
punteiros nos permiten facer,

285
00:14:47,320 --> 00:14:51,320
fan este ambiente moi
máis como como operamos na realidade.

286
00:14:51,320 --> 00:14:54,640
>> Todo ben entón iso é o que
un punteiro é, imos falar

287
00:14:54,640 --> 00:14:58,040
punteiros sobre como traballar en C, e
como podemos comezar a traballar con eles.

288
00:14:58,040 --> 00:15:02,550
Polo tanto, hai un punteiro moi sinxelo
en C chamado punteiro nulo.

289
00:15:02,550 --> 00:15:04,830
O punteiro puntos nulos a nada.

290
00:15:04,830 --> 00:15:08,310
Isto probablemente parece que é
en realidade, non é unha cousa moi útil,

291
00:15:08,310 --> 00:15:10,500
pero como nós imos ver unha
pouco despois, o feito

292
00:15:10,500 --> 00:15:15,410
que existe ese punteiro nulo
de feito, realmente pode vir a cadra.

293
00:15:15,410 --> 00:15:19,090
E sempre que crear un punteiro, e
non definir o seu valor imediatamente-

294
00:15:19,090 --> 00:15:21,060
un exemplo de configuración
o seu valor inmediatamente

295
00:15:21,060 --> 00:15:25,401
será un par de láminas de volta
onde eu dixen pk k é igual e,

296
00:15:25,401 --> 00:15:28,740
pk recibe o enderezo k, como
imos ver o que iso significa,

297
00:15:28,740 --> 00:15:32,990
imos ver como codificar que shortly-
se non que o valor a algo

298
00:15:32,990 --> 00:15:35,380
significativa inmediatamente,
ten que sempre

299
00:15:35,380 --> 00:15:37,480
definir o punteiro para apuntar para null.

300
00:15:37,480 --> 00:15:40,260
Ten que configuralo para apuntar para nada.

301
00:15:40,260 --> 00:15:43,614
>> Iso é moi diferente do que
deixando só o valor é tan

302
00:15:43,614 --> 00:15:45,530
e, a continuación, declara unha
punteiro e só supoñendo

303
00:15:45,530 --> 00:15:48,042
é nula porque iso raramente é verdade.

304
00:15:48,042 --> 00:15:50,000
Entón ten que sempre definir
o valor dun punteiro

305
00:15:50,000 --> 00:15:55,690
como nulo se non definir o seu valor
para algo significativo inmediatamente.

306
00:15:55,690 --> 00:15:59,090
Pode comprobar se o valor dun punteiro
é nulo mediante o operador de igualdade

307
00:15:59,090 --> 00:16:05,450
(==), Así como comparar calquera número enteiro
valores ou valores de caracteres a usar (==)

308
00:16:05,450 --> 00:16:06,320
ben.

309
00:16:06,320 --> 00:16:10,994
É un tipo especial de constante
valor que pode usar para probar.

310
00:16:10,994 --> 00:16:13,160
Entón esa foi unha forma moi simple
punteiro, o punteiro nulo.

311
00:16:13,160 --> 00:16:15,320
Outra forma de crear
un enlace é para extraer

312
00:16:15,320 --> 00:16:18,240
a dirección dunha variable
xa creou,

313
00:16:18,240 --> 00:16:22,330
e facelo empregando o &
extracción enderezo operador.

314
00:16:22,330 --> 00:16:26,720
Que xa vimos anteriormente
no primeiro exemplo diagrama eu mostre.

315
00:16:26,720 --> 00:16:31,450
Entón, se x é unha variable que temos
xa creada do tipo enteiro,

316
00:16:31,450 --> 00:16:35,110
logo & x é un punteiro para un enteiro.

317
00:16:35,110 --> 00:16:39,810
& X é- recordo, e vai extraer
a dirección do cousa da dereita.

318
00:16:39,810 --> 00:16:45,350
E unha vez que un punteiro é só un enderezo,
que & x é un punteiro para un enteiro

319
00:16:45,350 --> 00:16:48,560
cuxo valor é, onde na memoria x vidas.

320
00:16:48,560 --> 00:16:50,460
É a dirección de x.

321
00:16:50,460 --> 00:16:53,296
Así & X é a dirección de x.

322
00:16:53,296 --> 00:16:55,670
Imos dar un paso
máis e conectarse a algo

323
00:16:55,670 --> 00:16:58,380
Eu, en alusión a un vídeo anterior.

324
00:16:58,380 --> 00:17:06,730
Se arr é unha matriz de dúos, a continuación,
& Paréntese arr i é un punteiro

325
00:17:06,730 --> 00:17:08,109
para unha parella.

326
00:17:08,109 --> 00:17:08,970
Aceptar.

327
00:17:08,970 --> 00:17:12,160
arr cadrado soporte i si
arr é unha matriz de dúos,

328
00:17:12,160 --> 00:17:19,069
logo arr paréntese i é
o elemento i-th desa matriz,

329
00:17:19,069 --> 00:17:29,270
e & arr paréntese i é onde en
memoria o elemento i-th de arr existe.

330
00:17:29,270 --> 00:17:31,790
>> Entón, cal é a implicación aquí?

331
00:17:31,790 --> 00:17:34,570
Un nome de matrices, a implicación
de todo isto,

332
00:17:34,570 --> 00:17:39,290
é que o nome dunha matriz é
de feito en si un punteiro.

333
00:17:39,290 --> 00:17:41,170
Ten traballado
con punteiros ao longo de toda

334
00:17:41,170 --> 00:17:45,290
cada vez que usou unha matriz.

335
00:17:45,290 --> 00:17:49,090
Teña en conta que do exemplo
ámbito de variables,

336
00:17:49,090 --> 00:17:53,420
preto do fin do vídeo presento
un exemplo no que temos unha función

337
00:17:53,420 --> 00:17:56,890
chamado int set e unha
función chamada matriz set.

338
00:17:56,890 --> 00:18:00,490
E o seu reto para determinar
ou non, ou o que o

339
00:18:00,490 --> 00:18:03,220
valores que imprimir
o final da función,

340
00:18:03,220 --> 00:18:05,960
ao final do programa principal.

341
00:18:05,960 --> 00:18:08,740
>> Se se lembrar de que o exemplo
ou se asistiu o vídeo,

342
00:18:08,740 --> 00:18:13,080
vostede sabe que cando você- a chamada a
conxunto int efectivamente non fai nada.

343
00:18:13,080 --> 00:18:16,390
A súa chamada para definir matriz fai.

344
00:18:16,390 --> 00:18:19,280
E eu medio que encuberto por
que era o caso no seu momento.

345
00:18:19,280 --> 00:18:22,363
Eu só dixen, ben, é un array, é
especial, xa sabe, hai unha razón.

346
00:18:22,363 --> 00:18:25,020
A razón é que unha matriz de
nome é realmente só un punteiro,

347
00:18:25,020 --> 00:18:28,740
e hai esta especial
sintaxe paréntese que

348
00:18:28,740 --> 00:18:30,510
facer as cousas moito máis agradable para traballar.

349
00:18:30,510 --> 00:18:34,410
E eles fan a idea dun
punteiro moito menos intimidante,

350
00:18:34,410 --> 00:18:36,800
e é por iso que son tipo
da presentada desa forma.

351
00:18:36,800 --> 00:18:38,600
Pero realmente matrices son só enlaces.

352
00:18:38,600 --> 00:18:41,580
E é por iso que cando
fixo un cambio para a matriz,

353
00:18:41,580 --> 00:18:44,880
cando pasamos dunha matriz como un parámetro
para unha función ou como un argumento

354
00:18:44,880 --> 00:18:50,110
a unha función, o contido da matriz
realmente cambiaron tanto no receptor

355
00:18:50,110 --> 00:18:51,160
e en que o interlocutor.

356
00:18:51,160 --> 00:18:55,846
Que para calquera outro tipo de
variable que vimos non foi o caso.

357
00:18:55,846 --> 00:18:58,970
Entón, iso é só algo para manter
mente cando se está a traballar con punteiros,

358
00:18:58,970 --> 00:19:01,610
que é o nome dun
matriz, en realidade, un punteiro

359
00:19:01,610 --> 00:19:04,750
para o primeiro elemento do array.

360
00:19:04,750 --> 00:19:08,930
>> OK entón agora temos todos estes
feitos, imos seguir, non.

361
00:19:08,930 --> 00:19:11,370
Por que nos preocupa
onde algo vive.

362
00:19:11,370 --> 00:19:14,120
Ben, como dixen, é moi
útil saber onde algo vive

363
00:19:14,120 --> 00:19:17,240
para que poida ir alí e cambialo.

364
00:19:17,240 --> 00:19:19,390
Traballar con el e realmente
ten a cousa que

365
00:19:19,390 --> 00:19:23,710
quere facer para que entren en vigor a variable,
e non produce efectos nalgúns copia do mesmo.

366
00:19:23,710 --> 00:19:26,150
Iso é chamado de dereferencing.

367
00:19:26,150 --> 00:19:28,690
Nós imos para a referencia e
nós cambiamos o valor alí.

368
00:19:28,690 --> 00:19:32,660
Entón, se temos un punteiro e chámase
PC, e apunta a un personaxe,

369
00:19:32,660 --> 00:19:40,610
entón podemos dicir * * PC e PC é o
nome do que imos atopar, se somos

370
00:19:40,610 --> 00:19:42,910
para o PC enderezo.

371
00:19:42,910 --> 00:19:47,860
O que imos atopar alí é un personaxe e
* PC é como nos referimos aos datos a que

372
00:19:47,860 --> 00:19:48,880
localización.

373
00:19:48,880 --> 00:19:54,150
Así, poderiamos dicir algo así como
* PC = D ou algo parecido,

374
00:19:54,150 --> 00:19:59,280
e iso significa que calquera que sexa
Foi no enderezo de memoria PC,

375
00:19:59,280 --> 00:20:07,040
calquera personaxe que estaba anteriormente
alí, agora D, se dicimos * PC = D.

376
00:20:07,040 --> 00:20:10,090
>> Entón, aquí imos nós de novo con
algunhas cousas C estraño, certo.

377
00:20:10,090 --> 00:20:14,560
Entón vimos anteriormente como *
dalgunha forma parte do tipo de datos,

378
00:20:14,560 --> 00:20:17,160
e agora está a ser usado en
nun contexto lixeiramente diferente

379
00:20:17,160 --> 00:20:19,605
para acceder aos datos nun lugar.

380
00:20:19,605 --> 00:20:22,480
Sei que é un pouco confuso e
que é, en realidade, parte dese todo

381
00:20:22,480 --> 00:20:25,740
como, por punteiros teñen esa mitoloxía
en torno a eles como sendo tan complexo,

382
00:20:25,740 --> 00:20:28,250
é un tipo de problema de sintaxe, honesta.

383
00:20:28,250 --> 00:20:31,810
Pero * se usa en ambos os contextos,
tanto como parte do nome do tipo,

384
00:20:31,810 --> 00:20:34,100
e veremos un pouco
despois outra cousa, tamén.

385
00:20:34,100 --> 00:20:36,490
E agora é o
operador de eliminación de referencia.

386
00:20:36,490 --> 00:20:38,760
Por iso, vai á referencia
el accede os datos

387
00:20:38,760 --> 00:20:43,000
na localización do punteiro, e
permite que manipula-lo a gusto.

388
00:20:43,000 --> 00:20:45,900
>> Agora, este é moi similar ao
visitar o seu veciño, certo.

389
00:20:45,900 --> 00:20:48,710
Se sabe o que o seu
veciño vive, é

390
00:20:48,710 --> 00:20:50,730
non saír co seu veciño.

391
00:20:50,730 --> 00:20:53,510
Vostede sabe que pasar
sabe onde viven,

392
00:20:53,510 --> 00:20:56,870
pero iso non significa que, por
virtude de ter ese coñecemento

393
00:20:56,870 --> 00:20:59,170
está interactuando con eles.

394
00:20:59,170 --> 00:21:01,920
Se quere interactuar con eles,
ten que ir para a súa casa,

395
00:21:01,920 --> 00:21:03,760
ten que ir a onde eles viven.

396
00:21:03,760 --> 00:21:07,440
E unha vez que se fai iso,
a continuación, pode interactuar

397
00:21:07,440 --> 00:21:09,420
con eles só como vai querer.

398
00:21:09,420 --> 00:21:12,730
E do mesmo xeito coas variables,
ten que ir para o seu enderezo

399
00:21:12,730 --> 00:21:15,320
se quere interactuar eles,
non pode só saber a dirección.

400
00:21:15,320 --> 00:21:21,495
E o xeito no que ir ao enderezo é
de usar *, o operador de eliminación de referencia.

401
00:21:21,495 --> 00:21:23,620
¿Que pensas que pasa
se nós intentamos e dereference

402
00:21:23,620 --> 00:21:25,260
un punteiro cuxo valor é nulo?

403
00:21:25,260 --> 00:21:28,470
Lembre que o nulo
punteiro apunta para nada.

404
00:21:28,470 --> 00:21:34,110
Entón, se tentar eliminar referencia
nada ou ir a un enderezo de nada,

405
00:21:34,110 --> 00:21:36,800
o que pensas que pasa?

406
00:21:36,800 --> 00:21:39,630
Segmentación Ben, se adiviñou
falla, estaría ben.

407
00:21:39,630 --> 00:21:41,390
Se tentar e dereference
un punteiro nulo,

408
00:21:41,390 --> 00:21:43,140
padece unha segmentación
fallo. Pero espera,

409
00:21:43,140 --> 00:21:45,820
non vos digo, que
se non está indo

410
00:21:45,820 --> 00:21:49,220
para definir o valor da súa
punteiro para algo significativo,

411
00:21:49,220 --> 00:21:51,000
ten que definir como nulo?

412
00:21:51,000 --> 00:21:55,290
Eu fixen e, de feito, a segmentación
culpa é unha especie de bo comportamento.

413
00:21:55,290 --> 00:21:58,680
>> Algunha vez xa declarou unha variable e
Non concedido o valor inmediatamente?

414
00:21:58,680 --> 00:22:02,680
Entón acaba de dicir int x; non fai
de feito, atribuílo-lo a nada

415
00:22:02,680 --> 00:22:05,340
e despois, máis tarde, no seu código,
imprimir o valor de x,

416
00:22:05,340 --> 00:22:07,650
aínda non
lle atribúe a calquera cousa.

417
00:22:07,650 --> 00:22:10,370
Frecuentemente terá
cero, pero ás veces

418
00:22:10,370 --> 00:22:15,000
pode obter un número aleatorio, e
non ten idea de onde veu.

419
00:22:15,000 --> 00:22:16,750
Así mesmo pode cousas
pasar con punteiros.

420
00:22:16,750 --> 00:22:20,110
Cando declarar un punteiro
int * pk por exemplo,

421
00:22:20,110 --> 00:22:23,490
e non atribuílo la a un valor,
recibe catro bytes para memoria.

422
00:22:23,490 --> 00:22:25,950
Calquera que sexan os catro bytes de
memoria do sistema pode

423
00:22:25,950 --> 00:22:28,970
considerar que ten algún valor significativo.

424
00:22:28,970 --> 00:22:31,760
E non podería ser
algo que xa existe

425
00:22:31,760 --> 00:22:34,190
non se necesita doutra
función, entón só ten

426
00:22:34,190 --> 00:22:35,900
todos os datos que estaba alí.

427
00:22:35,900 --> 00:22:40,570
>> E se intentou facer dereference
algún enderezo que non- había

428
00:22:40,570 --> 00:22:43,410
xa bytes e información
alí, que está agora no seu punteiro.

429
00:22:43,410 --> 00:22:47,470
Se tentar cancelar a referencia dese punteiro,
pode estar mexendo con algunha memoria

430
00:22:47,470 --> 00:22:49,390
que non tiña a intención
para xogar con todo.

431
00:22:49,390 --> 00:22:51,639
E de feito, podería facer
algo realmente devastador,

432
00:22:51,639 --> 00:22:54,880
como romper navegador,
ou romper outra función,

433
00:22:54,880 --> 00:22:58,289
ou facer algo malicioso que
non tiña a intención de facer nada.

434
00:22:58,289 --> 00:23:00,080
E é por iso que é
realmente unha boa idea

435
00:23:00,080 --> 00:23:04,030
para definir os punteiros como nulo se
non configure-los para algo significativo.

436
00:23:04,030 --> 00:23:06,760
É probabelmente mellor no
final do día, para o seu programa

437
00:23:06,760 --> 00:23:09,840
a fallar, a continuación, para que faga
algo que estraga

438
00:23:09,840 --> 00:23:12,400
outro programa ou outra función.

439
00:23:12,400 --> 00:23:15,207
Este comportamento pode ser aínda
menos ideal que deixe de funcionar.

440
00:23:15,207 --> 00:23:17,040
E é por iso que é
realmente un bo hábito

441
00:23:17,040 --> 00:23:20,920
para entrar para definir os punteiros
como nulo se non configure-los

442
00:23:20,920 --> 00:23:24,540
a un valor significativo
inmediatamente, un valor que sabe

443
00:23:24,540 --> 00:23:27,260
e que pode con seguridade a eliminar referencia.

444
00:23:27,260 --> 00:23:32,240
>> Entón, imos voltar agora e bótalle un ollo
na sintaxe global da situación.

445
00:23:32,240 --> 00:23:37,400
Se eu digo int * p;, o que eu acabo de facer?

446
00:23:37,400 --> 00:23:38,530
O que eu teño feito é este.

447
00:23:38,530 --> 00:23:43,290
Sei o valor de p é un enderezo
porque todos os punteiros son só

448
00:23:43,290 --> 00:23:44,660
enderezos.

449
00:23:44,660 --> 00:23:47,750
Podo borrar a referencia p
mediante o operador *.

450
00:23:47,750 --> 00:23:51,250
Neste contexto aquí, no propio
top recordar a * é parte do tipo.

451
00:23:51,250 --> 00:23:53,510
Int * é o tipo de datos.

452
00:23:53,510 --> 00:23:56,150
Pero podo dereference
p usando o operador *,

453
00:23:56,150 --> 00:24:01,897
e se eu fai iso, se eu ir a este enderezo,
o que vou atopar nese enderezo?

454
00:24:01,897 --> 00:24:02,855
Eu vou atopar un enteiro.

455
00:24:02,855 --> 00:24:05,910
Así, int * p é basicamente
dicindo: p é un enderezo.

456
00:24:05,910 --> 00:24:09,500
Podo borrar a referencia p e
Fago, eu vou atopar un número enteiro

457
00:24:09,500 --> 00:24:11,920
en que a localización de memoria.

458
00:24:11,920 --> 00:24:14,260
>> OK, entón eu dixo que non había outra
cousa chat con estrelas

459
00:24:14,260 --> 00:24:17,060
e aquí é onde que
cousa chat con estrelas é.

460
00:24:17,060 --> 00:24:21,640
Algunha vez xa intentou declarar
múltiples variables do mesmo tipo

461
00:24:21,640 --> 00:24:24,409
na mesma liña de código?

462
00:24:24,409 --> 00:24:27,700
Entón, por un segundo, finxir que a liña,
o código En realidade, teño alí en verde

463
00:24:27,700 --> 00:24:29,366
non está alí e el só di int x, y, z;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
Que quere facer é realmente crear
tres variables enteiras para ti,

466
00:24:34,550 --> 00:24:36,930
un chamado x, unha chamada
y, z e un chamado.

467
00:24:36,930 --> 00:24:41,510
É un xeito de facelo sen
ter que dividir en tres liñas.

468
00:24:41,510 --> 00:24:43,890
>> Aquí é onde as estrelas chegar
irritante novo aínda,

469
00:24:43,890 --> 00:24:49,200
porque o * é de feito parte
tanto o nome do tipo e parte

470
00:24:49,200 --> 00:24:50,320
do nome da variable.

471
00:24:50,320 --> 00:24:56,430
E por iso, se digo int * px, py, pz, o que eu
en realidade é un punteiro para un enteiro

472
00:24:56,430 --> 00:25:01,650
chamado px e dous enteiros, e py pz.

473
00:25:01,650 --> 00:25:04,950
E iso probablemente non o que é
queremos, isto non é bo.

474
00:25:04,950 --> 00:25:09,290
>> Entón, se eu queira crear varios punteiros
na mesma liña, do mesmo tipo,

475
00:25:09,290 --> 00:25:12,140
e estrelas, o que realmente precisa
que facer é dicir int * pa, * pb, * PC.

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
Agora, tendo só dixo que
e agora lle dicindo iso,

478
00:25:20,300 --> 00:25:22,170
probablemente non vai facelo.

479
00:25:22,170 --> 00:25:25,170
E pode ser unha cousa boa, honestamente,
porque pode inadvertidamente

480
00:25:25,170 --> 00:25:26,544
omitir unha estrela, algo así.

481
00:25:26,544 --> 00:25:29,290
É probablemente o mellor para declarar quizais
punteiros en liñas individuais,

482
00:25:29,290 --> 00:25:31,373
pero é só un
daqueles sintaxe irritante

483
00:25:31,373 --> 00:25:35,310
cousas que fan estrelas
punteiros tan difícil de traballar.

484
00:25:35,310 --> 00:25:39,480
Porque é só iso sintáctica
desorde que ten que traballar.

485
00:25:39,480 --> 00:25:41,600
Coa práctica que fai
realmente facer unha segunda natureza.

486
00:25:41,600 --> 00:25:45,410
Eu cometer erros con el aínda
despois da programación durante 10 anos,

487
00:25:45,410 --> 00:25:49,630
polo que non sexa chat se algo acontecer
para ti, é moi común honesta.

488
00:25:49,630 --> 00:25:52,850
Realmente tipo de
un fallo da sintaxe.

489
00:25:52,850 --> 00:25:54,900
>> OK entón eu medio que prometeu
que queremos volver

490
00:25:54,900 --> 00:25:59,370
o concepto de quão grande é unha cadea.

491
00:25:59,370 --> 00:26:02,750
Ben, se eu lle dixese que un
corda, temos realmente unha especie de

492
00:26:02,750 --> 00:26:04,140
mentindo para ti todo o tempo.

493
00:26:04,140 --> 00:26:06,181
Non hai ningún tipo de datos chamado
corda, e de feito eu

494
00:26:06,181 --> 00:26:09,730
mencionen iso nun dos nosos
primeiros vídeos sobre tipos de datos,

495
00:26:09,730 --> 00:26:13,820
esa secuencia foi un tipo de datos que
foi creado para ti en CS50.h.

496
00:26:13,820 --> 00:26:17,050
Ten que # include
CS50.h, a fin de usalo.

497
00:26:17,050 --> 00:26:19,250
>> Ben cadea é realmente só
un alias para algo

498
00:26:19,250 --> 00:26:23,600
chamado char *, un
Punteiro para un personaxe.

499
00:26:23,600 --> 00:26:26,010
Ben punteiros, recall,
son só aborda.

500
00:26:26,010 --> 00:26:28,780
Entón, cal é o tamaño
en bytes dunha secuencia?

501
00:26:28,780 --> 00:26:29,796
Ben, é catro ou oito.

502
00:26:29,796 --> 00:26:32,170
E a razón de eu dicir catro ou
oito é porque realmente

503
00:26:32,170 --> 00:26:36,730
depende do sistema, se está a usar
CS50 ide, char * é do tamaño dun char

504
00:26:36,730 --> 00:26:39,340
* É de oito, é un sistema de 64 bits.

505
00:26:39,340 --> 00:26:43,850
Cada enderezo na memoria é de 64 bits de lonxitude.

506
00:26:43,850 --> 00:26:48,270
Se está usando aparello CS50
ou a utilización de máquinas de 32 bits,

507
00:26:48,270 --> 00:26:51,640
e xa escoitou este termo de 32 bits
máquina, o que é unha máquina de 32 bits?

508
00:26:51,640 --> 00:26:56,090
Ben, iso só significa que cada
enderezo na memoria é de 32 bits de lonxitude.

509
00:26:56,090 --> 00:26:59,140
E así 32 bits é de catro bytes.

510
00:26:59,140 --> 00:27:02,710
Así, un char * é de catro ou oito
bytes dependendo do seu sistema.

511
00:27:02,710 --> 00:27:06,100
E, de feito calquera tipo de datos,
e un punteiro para todos os datos

512
00:27:06,100 --> 00:27:12,030
escriba, xa que todos os punteiros son só
enderezos, catro ou oito bytes.

513
00:27:12,030 --> 00:27:14,030
Entón, imos volver a esta
diagramar e imos concluír

514
00:27:14,030 --> 00:27:18,130
este vídeo con un pouco de exercicio aquí.

515
00:27:18,130 --> 00:27:21,600
Entón aquí está o diagrama paramos con
no inicio do vídeo.

516
00:27:21,600 --> 00:27:23,110
Entón o que ocorre agora, se eu digo * pk = 35?

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
Entón, o que quero dicir cando digo, * pk = 35?

519
00:27:30,530 --> 00:27:32,420
Tomé un segundo.

520
00:27:32,420 --> 00:27:34,990
* Pk.

521
00:27:34,990 --> 00:27:39,890
No contexto aquí, é *
operador de eliminación de referencia.

522
00:27:39,890 --> 00:27:42,110
Así, cando o dereference
operador é usado,

523
00:27:42,110 --> 00:27:48,520
imos ao enderezo sinalado
por pk, e nós cambiamos o que atopamos.

524
00:27:48,520 --> 00:27:55,270
Así * pk = 35 eficaz
fai iso coa imaxe.

525
00:27:55,270 --> 00:27:58,110
Entón é basicamente sintaticamente
o mesmo que o de dicir k = 35.

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> Máis un.

528
00:28:01,930 --> 00:28:05,510
Se eu digo int m, creo
unha nova variable chamada m.

529
00:28:05,510 --> 00:28:08,260
Unha caixa, é unha caixa verde porque
que vai realizar un número enteiro,

530
00:28:08,260 --> 00:28:09,840
e é rotulado m.

531
00:28:09,840 --> 00:28:14,960
Se eu digo que m = 4, engada un
enteiro en que a caixa.

532
00:28:14,960 --> 00:28:20,290
Se digamos pk = m, como é
este cambio diagrama?

533
00:28:20,290 --> 00:28:28,760
Pk = m, se lembra o que o
Operador & fai ou se chama?

534
00:28:28,760 --> 00:28:34,430
Lembre que o nome da variable e algúns
é a dirección dun nome de variable.

535
00:28:34,430 --> 00:28:38,740
Entón, o que estamos dicindo é
pk obtén a dirección de m.

536
00:28:38,740 --> 00:28:42,010
E así efectivamente o que ocorre no
diagrama é que xa non pk puntos

537
00:28:42,010 --> 00:28:46,420
para k, pero apunta a m.

538
00:28:46,420 --> 00:28:48,470
>> Novo punteiros son moi
complicado para traballar con

539
00:28:48,470 --> 00:28:50,620
e eles toman unha morea de
práctica, senón porque

540
00:28:50,620 --> 00:28:54,150
da súa capacidade de permitir que
para transmitir datos entre funcións

541
00:28:54,150 --> 00:28:56,945
e realmente ten os
cambios entren en vigor,

542
00:28:56,945 --> 00:28:58,820
recibindo a súa cabeza en torno
é realmente importante.

543
00:28:58,820 --> 00:29:02,590
É probablemente o máis complicado
tema que discutir en CS50,

544
00:29:02,590 --> 00:29:05,910
pero o valor que
comeza de usar punteiros

545
00:29:05,910 --> 00:29:09,200
supera en moito as complicacións
que veñen de aprendela las.

546
00:29:09,200 --> 00:29:12,690
Entón, eu desexo-lle o mellor de
sorte de coñecer punteiros.

547
00:29:12,690 --> 00:29:15,760
Eu son Doug Lloyd, este é CS50.

548
00:29:15,760 --> 00:29:17,447