1
00:00:00,000 --> 00:00:02,440
[Powered by Google Translate] [Punteiros]

2
00:00:02,440 --> 00:00:05,000
[Rob Bowden] [Harvard University]

3
00:00:05,000 --> 00:00:07,360
[Esta é CS50] [CS50.TV]

4
00:00:07,360 --> 00:00:08,820
>> Imos falar sobre punteiros.

5
00:00:08,820 --> 00:00:13,710
Ata agora, sempre referida só as cousas na memoria explicitamente polo nome.

6
00:00:13,710 --> 00:00:22,610
Nós dixemos int n = 42, e entón, cando queremos utilizar a variable n,

7
00:00:22,610 --> 00:00:30,640
Nós só chamalo polo nome que damos por escribir algo así como n * 2.

8
00:00:30,640 --> 00:00:34,790
Pero esa variable debe vivir en algún lugar na memoria.

9
00:00:34,790 --> 00:00:37,790
Cando se quere usar o valor que está almacenado dentro de n,

10
00:00:37,790 --> 00:00:40,730
ou actualizar o valor que n está seguro,

11
00:00:40,730 --> 00:00:44,180
o programa precisa saber onde na memoria de ollar para n.

12
00:00:44,180 --> 00:00:48,320
Onde na memoria de vidas variable é chamado de enderezo.

13
00:00:48,320 --> 00:00:49,940
É como un enderezo de casa.

14
00:00:49,940 --> 00:00:53,080
Podo atopar a casa de alguén, sempre que eu saiba o seu enderezo de casa,

15
00:00:53,080 --> 00:00:58,110
e un programa de ordenador pode atopar unha variable, xa que el coñece o seu enderezo de memoria.

16
00:00:58,110 --> 00:01:02,660
What punteiros ofrecen é un xeito de tratar directamente con estes enderezos de memoria.

17
00:01:02,660 --> 00:01:06,860
>> Unha morea de poder en C vén de ser capaz de manipular a memoria como este.

18
00:01:06,860 --> 00:01:09,960
Pero con gran poder vén gran responsabilidade.

19
00:01:09,960 --> 00:01:14,670
Punteiros poden ser usados ​​perigosamente o suficiente para que unha gran cantidade de linguaxes de programación

20
00:01:14,670 --> 00:01:16,460
pointers ocultar completamente.

21
00:01:16,460 --> 00:01:19,440
Entón, por que dar C pointers entón?

22
00:01:19,440 --> 00:01:22,680
Como vostede sabe, argumentos para unha función C

23
00:01:22,680 --> 00:01:25,370
sempre son copiados para os parámetros da función.

24
00:01:25,370 --> 00:01:33,260
Entón, chamando algo troco dalgunhas variables x e y

25
00:01:33,260 --> 00:01:38,840
non pode cambiar os valores de x e y na función de chamada,

26
00:01:38,840 --> 00:01:40,810
a pesar de que pode ser útil.

27
00:01:40,810 --> 00:01:46,430
Como veremos máis tarde intercambio, reescribir a tomar punteiros para os lugares que precisan ser trocados

28
00:01:46,430 --> 00:01:49,690
permite que afectan variables seu chamador.

29
00:01:49,690 --> 00:01:54,150
>> Imos examinar un exemplo relativamente simple que os punteiros poden facer.

30
00:01:54,150 --> 00:02:15,550
Imos dicir que temos int n = 4, e int * pointer_to_n = n.

31
00:02:15,550 --> 00:02:18,990
Guau! Un pouco de nova sintaxe para cubrir.

32
00:02:18,990 --> 00:02:22,600
En primeiro lugar, imos interpretar isto e n.

33
00:02:22,600 --> 00:02:27,260
Lembre que todo na memoria ten algún enderezo.

34
00:02:27,260 --> 00:02:30,800
O comercial chámase "enderezo de" operador.

35
00:02:30,800 --> 00:02:36,470
Entón, e n refírese ao enderezo de memoria onde n é almacenado.

36
00:02:36,470 --> 00:02:41,560
Agora, estamos mantendo ese enderezo nunha nova variable, pointer_to_n.

37
00:02:41,560 --> 00:02:43,870
Cal é o tipo desta nova variable?

38
00:02:43,870 --> 00:02:47,410
O asterisco é unha parte do tipo da variable,

39
00:02:47,410 --> 00:02:49,880
e leremos tipo int *.

40
00:02:49,880 --> 00:02:56,500
* Int significa que pointer_to_n é unha variable que almacena o enderezo de un número enteiro.

41
00:02:56,500 --> 00:03:02,970
Sabemos que & n é un int * sempre que n é un enteiro, e nós estamos levando o enderezo de n.

42
00:03:02,970 --> 00:03:06,660
Int * é un exemplo dun tipo de punteiro.

43
00:03:06,660 --> 00:03:10,150
Así que comezar a ver asteriscos no tipo,

44
00:03:10,150 --> 00:03:11,950
vostede sabe que está lidando con punteiros.

45
00:03:11,950 --> 00:03:16,520
Así como podemos declarar unha variable como int x e y char,

46
00:03:16,520 --> 00:03:20,410
podemos dicir int * Z e char * w.

47
00:03:20,410 --> 00:03:25,190
Int * e * char son só novos tipos de usarmos.

48
00:03:25,190 --> 00:03:29,430
A localización do * pode ir a calquera lugar antes do nome da variable.

49
00:03:29,430 --> 00:03:34,730
Así, tanto int * pointer_to_n - co seguinte * para int, como temos aquí -

50
00:03:34,730 --> 00:03:45,210
e int * pointer_to_n co * xunto pointer_to_n son válidos.

51
00:03:45,210 --> 00:03:56,470
Pero aquí, eu vou poñer o * próximo ao int.

52
00:03:56,470 --> 00:04:00,600
Non importa o que prefire, pode ser coherente.

53
00:04:00,600 --> 00:04:02,810
>> Imos deseñar un diagrama para iso.

54
00:04:02,810 --> 00:04:07,590
Primeiro temos a variable n, que imos deseñar como unha pequena caixa de memoria.

55
00:04:07,590 --> 00:04:15,400
Para este exemplo, imos dicir que esa caixa está situada no enderezo 100.

56
00:04:15,400 --> 00:04:18,820
Dentro desta caixa, que está almacenando o valor 4.

57
00:04:18,820 --> 00:04:23,730
Agora, temos unha nova variable, pointer_to_n.

58
00:04:23,730 --> 00:04:27,030
El ten a súa propia caixa na memoria,

59
00:04:27,030 --> 00:04:32,900
o que imos dicir é o enderezo 200.

60
00:04:32,900 --> 00:04:37,220
Dentro desta caixa, estamos mantendo o enderezo de n,

61
00:04:37,220 --> 00:04:39,890
que xa dixemos antes era 100.

62
00:04:39,890 --> 00:04:44,710
Frecuentemente en diagramas, podes ver esta mostra como unha frecha literal

63
00:04:44,710 --> 00:04:48,730
deixando a caixa pointer_to_n apuntando para a caixa que garda n.

64
00:04:48,730 --> 00:04:54,620
Agora, o que pode realmente facer pointer_to_n?

65
00:04:54,620 --> 00:05:10,400
Ben, se dicimos algo * pointer_to_n = 8, este é un uso diferente para o asterisco

66
00:05:10,400 --> 00:05:14,830
que é totalmente separado do uso do asterisco en declarar unha variable

67
00:05:14,830 --> 00:05:16,790
dun tipo de punteiro.

68
00:05:16,790 --> 00:05:21,130
Aquí, o asterisco chámase operador dereference.

69
00:05:21,130 --> 00:05:26,860
No noso diagrama, o que * pointer_to_n = 8 significa,

70
00:05:26,860 --> 00:05:32,220
ir ao pointer_to_n caixa contendo, siga a frecha,

71
00:05:32,220 --> 00:05:38,160
e despois asignar a caixa na parte final da frecha valor 8.

72
00:05:38,160 --> 00:05:45,960
Isto significa que tras esa liña, se tentar empregar n terá o valor 8.

73
00:05:45,960 --> 00:05:51,600
'Punteiro' A palabra é usada en moitos contextos diferentes.

74
00:05:51,600 --> 00:05:54,380
Aquí, imos tratar de ser coherente.

75
00:05:54,380 --> 00:05:58,330
Un tipo de punteiro é algo así como * int.

76
00:05:58,330 --> 00:06:04,630
Neste vídeo, un punteiro só se usa para referirse a un valor cun tipo de punteiro,

77
00:06:04,630 --> 00:06:08,180
como pointer_to_n que * tipo int.

78
00:06:08,180 --> 00:06:15,140
Calquera lugar que adoitaba dicir n, podemos agora dicir, en vez pointer_to_n *,

79
00:06:15,140 --> 00:06:18,020
e todo vai funcionar tan ben.

80
00:06:18,020 --> 00:06:21,120
>> Imos examinar un exemplo simple.

81
00:06:21,120 --> 00:06:50,390
Imos dicir que temos int n = 14; int * punteiro = &N; n + +, e (* punteiro) + +.

82
00:06:50,390 --> 00:06:59,830
A primeira liña crea unha nova caixa na memoria rotulado n.

83
00:06:59,830 --> 00:07:05,400
Esta vez non imos etiquetar a caixa con un enderezo explícito, pero aínda ten un.

84
00:07:05,400 --> 00:07:11,810
Dentro da caixa, que está almacenando o número 14.

85
00:07:11,810 --> 00:07:22,290
A liña seguinte crea un punteiro segunda caixa rotulada.

86
00:07:22,290 --> 00:07:27,210
E dentro desta caixa, que está almacenando un punteiro para a caixa n.

87
00:07:27,210 --> 00:07:33,170
Entón, imos deseñar a frecha de punteiro para n.

88
00:07:33,170 --> 00:07:37,790
Agora n + + incrementa o valor na caixa rotulada n,

89
00:07:37,790 --> 00:07:45,420
así que imos 14-15.

90
00:07:45,420 --> 00:07:53,330
Finalmente, (* punteiro) + + vai o punteiro caixa rotulada

91
00:07:53,330 --> 00:08:02,660
dereferences o valor na caixa, o que significa que a seguir a frecha que apunta,

92
00:08:02,660 --> 00:08:11,690
e incrementa o valor almacenado alí, entón imos 15-16.

93
00:08:11,690 --> 00:08:13,480
E é iso.

94
00:08:13,480 --> 00:08:18,480
N agora almacena o número 16, despois de ser incrementado dúas veces -

95
00:08:18,480 --> 00:08:25,050
unha vez directamente usando os nomes de variables n, ea outra a través dun pointer_to_n.

96
00:08:25,050 --> 00:08:33,360
>> Test rápido. ¿Que pensas que iso significa que se eu tentar dicir algo así como && n?

97
00:08:33,360 --> 00:08:41,350
Ben, imos reescribir isto como & (& n), que realiza a mesma cousa.

98
00:08:41,350 --> 00:08:47,030
O (+ n) retorna o enderezo da variable n na memoria.

99
00:08:47,030 --> 00:08:53,110
Pero, entón, a continuación, comercial externa intenta volver ao enderezo do enderezo.

100
00:08:53,110 --> 00:08:56,600
Isto é como tentar facer e 2.

101
00:08:56,600 --> 00:09:00,550
Non ten sentido para obter o enderezo de un número un pouco

102
00:09:00,550 --> 00:09:03,260
unha vez que non está sendo almacenado en memoria.

103
00:09:03,260 --> 00:09:07,090
Usando dous e comercial nunha liña non é a idea correcta.

104
00:09:07,090 --> 00:09:28,960
Pero agora, o que significa que eu tentar dicir int ** double_pointer = punteiro?

105
00:09:28,960 --> 00:09:40,750
Agora, eu estou creando unha nova caixa rotulada double_pointer,

106
00:09:40,750 --> 00:09:44,590
e dentro da caixa que eu estou garda o enderezo do punteiro,

107
00:09:44,590 --> 00:09:50,810
que significa que eu debuxe unha frecha da caixa double_pointer á caixa de punteiro.

108
00:09:50,810 --> 00:09:56,640
Teña en conta o tipo de double_pointer, un ** int.

109
00:09:56,640 --> 00:10:03,700
N era un número enteiro de punteiro, almacenado o enderezo de n, e por iso ten * int tipo.

110
00:10:03,700 --> 00:10:10,550
Agora, double_pointer almacena o enderezo do punteiro, por iso ten o tipo int. **

111
00:10:10,550 --> 00:10:15,070
>> Entón, o que nós pensamos que iso significa -

112
00:10:15,070 --> 00:10:24,490
Double_pointer ** = 23?

113
00:10:24,490 --> 00:10:28,630
Repare que eu estou agora dereferencing dúas veces.

114
00:10:28,630 --> 00:10:32,030
Só ten que seguir o diagrama de caixa e-flecha que xa configurada.

115
00:10:32,030 --> 00:10:36,400
En primeiro lugar, imos á caixa double_pointer.

116
00:10:36,400 --> 00:10:40,550
O * primeiro significa seguir a frecha dunha vez.

117
00:10:40,550 --> 00:10:44,110
Agora, estamos no punteiro caixa rotulada.

118
00:10:44,110 --> 00:10:49,940
A segunda estrela di seguir a frecha de novo,

119
00:10:49,940 --> 00:10:58,230
e agora estamos no cadro chamada n, e imos definir o valor desta caixa para 23.

120
00:10:58,230 --> 00:11:05,940
Teña en conta que o "enderezo de" dereference e operadores son inversas unha da outra.

121
00:11:05,940 --> 00:11:16,990
Tanto me permite facer algo como * & * & n = 42.

122
00:11:16,990 --> 00:11:22,550
Mentres tanto funciona, vostede non debe facer algo así na práctica.

123
00:11:22,550 --> 00:11:24,840
O que estamos realmente facendo aquí?

124
00:11:24,840 --> 00:11:28,700
O primeiro e comercial agarra o enderezo da variable n.

125
00:11:28,700 --> 00:11:34,660
Entón, temos un operador dereference, o que significa que estamos indo ao enderezo na memoria,

126
00:11:34,660 --> 00:11:36,910
por iso estamos de volta ao n.

127
00:11:36,910 --> 00:11:40,910
Agora, pegamos o enderezo do n novo e inmediatamente dereference,

128
00:11:40,910 --> 00:11:50,780
por iso estamos de volta ao n e tenda 42.

129
00:11:50,780 --> 00:11:55,490
Así, cada par de * & só cancela.

130
00:11:55,490 --> 00:11:59,980
>> Hai un punteiro especial chamado punteiro nulo.

131
00:11:59,980 --> 00:12:03,140
Este é un punteiro que nunca debemos dereference.

132
00:12:03,140 --> 00:12:07,130
Este punteiro é importante porque nos dá un xeito de distinguir entre

133
00:12:07,130 --> 00:12:10,220
un punteiro que debe e non debe ser dereferenced.

134
00:12:10,220 --> 00:12:13,050
Se tentar eliminar a referencia dun punteiro nulo,

135
00:12:13,050 --> 00:12:17,150
normalmente o seu programa ha fallar con un fallo de segmento,

136
00:12:17,150 --> 00:12:19,210
que pode ter visto antes.

137
00:12:19,210 --> 00:12:30,490
Entón, imos dicir que temos o código int * x = null; * x = 4.

138
00:12:30,490 --> 00:12:36,190
Neste exemplo, pode parecer obvio que estamos facendo algo mal,

139
00:12:36,190 --> 00:12:40,650
pero lembre que nulo podería realmente ser un valor retornado dunha chamada a unha función

140
00:12:40,650 --> 00:12:45,930
como malloc, se malloc non pode reservar memoria solicitada polo usuario.

141
00:12:45,930 --> 00:12:50,200
Por esta razón, en vez diso, estableza o valor de x de unha chamada a malloc,

142
00:12:50,200 --> 00:13:12,050
como int * x = malloc (sizeof (int)), entón debemos sempre comprobar explicitamente

143
00:13:12,050 --> 00:13:15,280
a ver se nulo foi devolto.

144
00:13:15,280 --> 00:13:43,250
If (x == null) / / uhoh! retorno; máis que poidamos seguir e dicir * x = 4.

145
00:13:43,250 --> 00:13:47,780
>> Entón, de novo, por que temos que usar punteiros?

146
00:13:47,780 --> 00:13:51,910
Vexamos un exemplo dun programa que temos de usar punteiros -

147
00:13:51,910 --> 00:13:54,110
unha función de cambio simple.

148
00:13:54,110 --> 00:14:08,270
Imos dicir que eu teño dous enteiros, int x = 4, e int y = 15;

149
00:14:08,270 --> 00:14:21,220
e quero escribir unha función chamada de intercambio que podo usar así: intercambio (x, y).

150
00:14:21,220 --> 00:14:28,270
Tras esta liña, os valores dentro da variable x debe ser de 15,

151
00:14:28,270 --> 00:14:32,360
é o valor de y no interior variable debe ser 4.

152
00:14:32,360 --> 00:14:36,510
Os valores dentro de x e y foron trocados.

153
00:14:36,510 --> 00:14:53,040
Sen punteiros, podemos tentar algo void intercambio (int a, int b);

154
00:14:53,040 --> 00:15:09,750
int tmp = b, b = a, a = tmp.

155
00:15:09,750 --> 00:15:12,960
Pero, entender o problema con iso?

156
00:15:12,960 --> 00:15:19,000
Lembrar que o valor almacenado na variable a é só unha copia do valor de x,

157
00:15:19,000 --> 00:15:22,000
é o valor de b é copiado a partir de y.

158
00:15:22,000 --> 00:15:28,000
Calquera cambio feitas nun b e non será reflectida en x e y.

159
00:15:28,000 --> 00:15:32,050
Así, mentres que os valores de a e b son correctamente trocados,

160
00:15:32,050 --> 00:15:35,810
x e y non cambiou nada.

161
00:15:35,810 --> 00:15:38,480
Agora, imos cambiar a función de intercambio para que os seus argumentos

162
00:15:38,480 --> 00:15:42,180
son punteiros para as variables que debe cambiar, así:

163
00:15:42,180 --> 00:15:56,880
void intercambio (int * a, int * b); int tmp = * b; * b * = a; * a = tmp.

164
00:15:56,880 --> 00:16:00,140
Lembre que os argumentos swaps agora son punteiros,

165
00:16:00,140 --> 00:16:05,670
e por iso temos que pasar o enderezo de X e Y na chamada para intercambiar, así:

166
00:16:05,670 --> 00:16:15,280
intercambio (e x, e y).

167
00:16:15,280 --> 00:16:20,520
Iso agora correctamente swaps os valores de x e y.

168
00:16:20,520 --> 00:16:24,310
>> Imos deseñar un diagrama de caixa e-flecha para ver por que isto funciona.

169
00:16:24,310 --> 00:16:28,520
Comezamos coas dúas caixas na memoria, x e y.

170
00:16:28,520 --> 00:16:35,780
Dentro do cadro de x é o número 4, e no interior da caixa para y temos 15.

171
00:16:35,780 --> 00:16:41,200
Agora, dentro da chamada á función de intercambio, temos dúas caixas

172
00:16:41,200 --> 00:16:45,140
para os argumentos a e b;

173
00:16:45,140 --> 00:16:50,960
a apunta para o cadro para x, e os puntos de B para a caixa para y.

174
00:16:50,960 --> 00:16:58,070
Unha nova caixa é creado para o tmp variable,

175
00:16:58,070 --> 00:17:01,470
e dentro del nós gardados resultado de dereferencing b,

176
00:17:01,470 --> 00:17:04,980
que significa "siga a frecha da caixa rotulada b '.

177
00:17:04,980 --> 00:17:09,880
Entón, nós almacenar 15 dentro tmp.

178
00:17:09,880 --> 00:17:20,560
Entón, siga a frecha en B e almacenar aquí o resultado dunha dereferencing,

179
00:17:20,560 --> 00:17:24,569
que é o valor 4.

180
00:17:24,569 --> 00:17:35,590
Finalmente, segue a frecha nunha tenda e que está actualmente dentro tmp, que é 15.

181
00:17:35,590 --> 00:17:42,440
Nótese que as caixas marcadas x e y teñen valores correctamente trocados.

182
00:17:42,440 --> 00:17:46,290
>> Unha vez que nós aprenden sobre malloc e xestión dinámica de memoria,

183
00:17:46,290 --> 00:17:49,610
imos ver que non temos elección a non ser usar punteiros.

184
00:17:49,610 --> 00:17:52,690
Camiñando polo diagrama de caixa e-flecha para calquera programa

185
00:17:52,690 --> 00:17:55,980
pode axudar a descubrir o que o programa está realmente facendo.

186
00:17:55,980 --> 00:17:59,680
>> O meu nome é Rob Bowden, e este é o CS50.

187
00:18:00,000 --> 00:18:02,500
[CS50.TV]

188
00:18:02,500 --> 00:18:06,070
>> Este é un uso diferente para o asterisco - bleah, eu odio esa palabra.

189
00:18:06,070 --> 00:18:13,960
Calquera lugar que adoitaba dicir n, podemos agora dicir pointer_to_n - non non pode - pointer_to_n *.