1
00:00:00,000 --> 00:00:06,030
>> [Jouer de la musique]

2
00:00:06,030 --> 00:00:08,390
>> DOUG LLOYD: pointeurs, nous sommes ici.

3
00:00:08,390 --> 00:00:11,080
Cela va probablement à
être le sujet le plus difficile

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

5
00:00:12,840 --> 00:00:15,060
Et si vous avez lu
rien pointeurs

6
00:00:15,060 --> 00:00:19,080
avant que vous pourriez être un peu
intimidant d'entrer dans cette vidéo.

7
00:00:19,080 --> 00:00:21,260
Il est vrai que les pointeurs
ne vous permettre de la capacité

8
00:00:21,260 --> 00:00:23,740
peut-être à bousiller
assez mal quand vous êtes

9
00:00:23,740 --> 00:00:27,450
travailler avec des variables et des données,
et la cause de votre programme pour planter.

10
00:00:27,450 --> 00:00:30,490
Mais ils sont en fait très utile
et ils nous ont vraiment un excellent moyen permettent

11
00:00:30,490 --> 00:00:33,340
pour transmettre des données en arrière et
vient entre les fonctions,

12
00:00:33,340 --> 00:00:35,490
que nous sommes dans l'impossibilité de le faire.

13
00:00:35,490 --> 00:00:37,750
>> Et donc ce que nous avons vraiment
veulent faire ici est de train

14
00:00:37,750 --> 00:00:41,060
vous avez une bonne discipline de pointeur, donc
que vous pouvez utiliser des pointeurs efficacement

15
00:00:41,060 --> 00:00:43,850
pour rendre vos programmes que beaucoup mieux.

16
00:00:43,850 --> 00:00:48,220
Comme je le disais pointeurs nous donnent un autre
façon de passer des données entre les fonctions.

17
00:00:48,220 --> 00:00:50,270
Maintenant, si vous vous souvenez de
une vidéo plus tôt, quand

18
00:00:50,270 --> 00:00:53,720
nous parlions
la portée des variables, je l'ai mentionné

19
00:00:53,720 --> 00:01:00,610
que toutes les données que nous passons entre
fonctions dans C est passé par valeur.

20
00:01:00,610 --> 00:01:03,070
Et je ne peux pas avoir utilisé cette
terme, ce que je voulait dire qu'il n'y

21
00:01:03,070 --> 00:01:07,170
était que nous passons des copies de données.

22
00:01:07,170 --> 00:01:12,252
Quand nous passons une variable à une fonction,
nous ne sommes pas réellement passer la variable

23
00:01:12,252 --> 00:01:13,210
à la fonction, non?

24
00:01:13,210 --> 00:01:17,670
Nous passons une copie de
que les données de la fonction.

25
00:01:17,670 --> 00:01:20,760
La fonction fait ce qu'il sera
et il calcule une valeur,

26
00:01:20,760 --> 00:01:23,180
et peut-être que nous utilisons cette valeur
quand il lui rend.

27
00:01:23,180 --> 00:01:26,700
>> Il y avait une exception à
cette règle de passage par valeur,

28
00:01:26,700 --> 00:01:31,210
et nous allons revenir à ce que
est un peu plus tard dans cette vidéo.

29
00:01:31,210 --> 00:01:34,880
Si nous utilisons des pointeurs à la place
de l'utilisation de variables,

30
00:01:34,880 --> 00:01:38,180
ou au lieu d'utiliser les variables
eux-mêmes ou des copies des variables,

31
00:01:38,180 --> 00:01:43,790
nous pouvons maintenant passer les variables autour
entre les fonctions d'une manière différente.

32
00:01:43,790 --> 00:01:46,550
Cela signifie que si nous faisons
un changement dans une fonction,

33
00:01:46,550 --> 00:01:49,827
que le changement se fait prendre
effectuer dans une fonction différente.

34
00:01:49,827 --> 00:01:52,160
Encore une fois, cela est quelque chose qui
nous ne pouvions pas faire auparavant,

35
00:01:52,160 --> 00:01:56,979
et si vous avez déjà essayé d'échanger le
valeur de deux variables dans une fonction,

36
00:01:56,979 --> 00:01:59,270
vous avez remarqué ce problème
genre de rampant, non?

37
00:01:59,270 --> 00:02:04,340
>> Si nous voulons échanger X et Y, et nous
les passer à une fonction appelée swap,

38
00:02:04,340 --> 00:02:08,680
l'intérieur de la fonction échanger les
les variables font valeurs d'échange.

39
00:02:08,680 --> 00:02:12,600
On devient deux, deux devient
, mais nous ne le faisons pas fait

40
00:02:12,600 --> 00:02:16,890
changer quelque chose dans l'original
fonction, en l'appelant.

41
00:02:16,890 --> 00:02:19,550
Parce que nous ne pouvons pas, nous ne sommes que
travailler avec des copies d'eux.

42
00:02:19,550 --> 00:02:24,760
Avec pointeurs cependant, nous pouvons
fait passer X et Y à une fonction.

43
00:02:24,760 --> 00:02:26,960
Cette fonction peut faire
quelque chose avec eux.

44
00:02:26,960 --> 00:02:29,250
Et les valeurs des variables
peut réellement changer.

45
00:02:29,250 --> 00:02:33,710
Voilà donc tout un changement dans
notre capacité à travailler avec des données.

46
00:02:33,710 --> 00:02:36,100
>> Avant de nous plonger dans
pointeurs, je pense que ça vaut la peine

47
00:02:36,100 --> 00:02:38,580
prendre quelques minutes pour
revenir à l'essentiel ici.

48
00:02:38,580 --> 00:02:41,000
Et avoir un regard sur la façon
travaux de mémoire de l'ordinateur

49
00:02:41,000 --> 00:02:45,340
parce que ces deux sujets vont
effectivement être assez liés.

50
00:02:45,340 --> 00:02:48,480
Comme vous le savez sans doute,
sur votre système informatique

51
00:02:48,480 --> 00:02:51,310
vous avez un disque dur ou
peut-être un lecteur à état solide,

52
00:02:51,310 --> 00:02:54,430
une sorte de lieu de stockage de fichiers.

53
00:02:54,430 --> 00:02:57,950
Il est généralement quelque part dans le
quartier de 250 gigaoctets

54
00:02:57,950 --> 00:02:59,810
à peut-être un couple de téraoctets maintenant.

55
00:02:59,810 --> 00:03:02,270
Et il est où tous de votre
fichiers, finalement, vivre,

56
00:03:02,270 --> 00:03:04,870
même lorsque votre ordinateur est éteint
off, vous pouvez rallumer

57
00:03:04,870 --> 00:03:09,190
et vous trouverez vos fichiers sont là
nouveau lorsque vous redémarrez votre système.

58
00:03:09,190 --> 00:03:14,820
Mais les lecteurs de disque, comme un lecteur de disque dur,
un disque dur ou un lecteur à état solide, un SSD,

59
00:03:14,820 --> 00:03:16,050
sont un espace de stockage tout simplement.

60
00:03:16,050 --> 00:03:20,400
>> Nous ne pouvons pas faire grand chose avec
les données qui sont sur le disque dur,

61
00:03:20,400 --> 00:03:22,080
ou dans un lecteur à état solide.

62
00:03:22,080 --> 00:03:24,950
Afin de réellement changer
données ou le déplacer,

63
00:03:24,950 --> 00:03:28,800
nous devons aller à
RAM, une mémoire à accès aléatoire.

64
00:03:28,800 --> 00:03:31,170
Maintenant RAM, vous avez beaucoup
moins dans votre ordinateur.

65
00:03:31,170 --> 00:03:34,185
Vous pouvez avoir quelque part dans le
quartier de 512 mégaoctets

66
00:03:34,185 --> 00:03:38,850
si vous avez un vieil ordinateur,
à peut-être deux, quatre, huit, 16,

67
00:03:38,850 --> 00:03:41,820
peut-être même un peu
De plus, des gigaoctets de RAM.

68
00:03:41,820 --> 00:03:46,390
Voilà donc beaucoup plus petite, mais qui est
où toutes les données volatiles en existe un.

69
00:03:46,390 --> 00:03:48,270
Voilà où nous pouvons changer les choses.

70
00:03:48,270 --> 00:03:53,350
Mais quand nous tournons notre ordinateur hors tension,
toutes les données dans la mémoire vive est détruit.

71
00:03:53,350 --> 00:03:57,150
>> Voilà pourquoi nous avons besoin de disque dur
pour l'emplacement plus permanent de celui-ci,

72
00:03:57,150 --> 00:03:59,720
de sorte qu'il exists- il serait
être vraiment mauvais, si chaque fois que nous

73
00:03:59,720 --> 00:04:03,310
transformé notre ordinateur hors tension, tous les
fichier dans notre système a été effacée.

74
00:04:03,310 --> 00:04:05,600
Nous travaillons donc à l'intérieur de RAM.

75
00:04:05,600 --> 00:04:09,210
Et chaque fois que nous parlons
la mémoire, à peu près, dans CS50,

76
00:04:09,210 --> 00:04:15,080
nous parlons de RAM, disque dur pas.

77
00:04:15,080 --> 00:04:18,657
>> Donc, quand nous nous déplaçons les choses en mémoire,
il prend une certaine quantité d'espace.

78
00:04:18,657 --> 00:04:20,740
Tous les types de données qui
nous avons travaillé avec

79
00:04:20,740 --> 00:04:23,480
prendre différentes
quantités d'espace dans la mémoire RAM.

80
00:04:23,480 --> 00:04:27,600
Ainsi, chaque fois que vous créez un nombre entier
variables, quatre octets de mémoire

81
00:04:27,600 --> 00:04:30,750
sont mis de côté dans la RAM de sorte que vous
peut travailler avec cet entier.

82
00:04:30,750 --> 00:04:34,260
Vous pouvez déclarer l'entier,
changer, lui attribue

83
00:04:34,260 --> 00:04:36,700
à une valeur de 10 incrémenté
par une, ainsi de suite et ainsi de suite.

84
00:04:36,700 --> 00:04:39,440
Tout ce qui doit se passer dans
RAM, et vous obtenez quatre octets

85
00:04:39,440 --> 00:04:42,550
de travailler avec pour chaque
entier que vous créez.

86
00:04:42,550 --> 00:04:45,410
>> Chaque personnage vous
créer obtient un octet.

87
00:04:45,410 --> 00:04:48,160
Voilà à quel point l'espace est
nécessaire pour stocker un caractère.

88
00:04:48,160 --> 00:04:51,310
Chaque flotteur, un vrai
Numéro, obtient quatre octets

89
00:04:51,310 --> 00:04:53,390
sauf si elle est un double
précision en virgule flottante

90
00:04:53,390 --> 00:04:56,510
Numéro, qui vous permet de
avoir des chiffres plus précis ou plus

91
00:04:56,510 --> 00:04:59,300
après la virgule
sans perte de précision,

92
00:04:59,300 --> 00:05:01,820
qui prendre jusqu'à huit octets de mémoire.

93
00:05:01,820 --> 00:05:06,730
Longs longues, très grands entiers,
aussi prendre jusqu'à huit octets de mémoire.

94
00:05:06,730 --> 00:05:09,000
Combien d'octets de mémoire
ne prennent cordes?

95
00:05:09,000 --> 00:05:12,990
Eh bien nous allons mettre une épingle dans cette question
pour l'instant, mais nous allons y revenir.

96
00:05:12,990 --> 00:05:17,350
>> Revenons donc à cette idée de mémoire
un grand réseau de cellules d'octets de taille.

97
00:05:17,350 --> 00:05:20,871
Voilà vraiment tout ce qu'il est, il est
juste un énorme réseau de cellules,

98
00:05:20,871 --> 00:05:23,370
comme tout autre tableau qui
vous êtes familier avec et de voir,

99
00:05:23,370 --> 00:05:26,430
sauf chaque élément est un octet de large.

100
00:05:26,430 --> 00:05:30,030
Et tout comme un tableau,
chaque élément a une adresse.

101
00:05:30,030 --> 00:05:32,120
Chaque élément d'un tableau
a un indice, et nous

102
00:05:32,120 --> 00:05:36,302
peut utiliser cet index pour faire soi-disant
accès aléatoire sur le réseau.

103
00:05:36,302 --> 00:05:38,510
Nous ne devons pas commencer à
le début de la rangée,

104
00:05:38,510 --> 00:05:40,569
itérer sur tous les
seul élément de celle-ci,

105
00:05:40,569 --> 00:05:41,860
pour trouver ce que nous cherchons.

106
00:05:41,860 --> 00:05:45,790
Nous pouvons simplement dire, je veux aller à la
15e élément ou l'élément 100e.

107
00:05:45,790 --> 00:05:49,930
Et vous pouvez juste passer ce nombre
et obtenir la valeur que vous cherchez.

108
00:05:49,930 --> 00:05:54,460
>> De même chaque endroit
dans la mémoire a une adresse.

109
00:05:54,460 --> 00:05:57,320
Donc, votre mémoire peut
ressembler à ceci.

110
00:05:57,320 --> 00:06:01,420
Voici un très petit morceau de
mémoire, cela est 20 octets de mémoire.

111
00:06:01,420 --> 00:06:04,060
Les 20 premiers octets parce que mon
il traite au fond

112
00:06:04,060 --> 00:06:08,890
sont égaux à 0, 1, 2, 3, etc.
sur tout le chemin jusqu'à 19.

113
00:06:08,890 --> 00:06:13,190
Et quand je déclarer des variables et
quand je commence à travailler avec eux,

114
00:06:13,190 --> 00:06:15,470
le système va mettre
côté un peu d'espace pour moi

115
00:06:15,470 --> 00:06:17,595
dans cette mémoire pour travailler
avec mes variables.

116
00:06:17,595 --> 00:06:21,610
Donc je pourrais dire, char c est égal capitale
H. et ce qui va se passer?

117
00:06:21,610 --> 00:06:23,880
Eh bien, le système va
mis de côté pour moi un octet.

118
00:06:23,880 --> 00:06:27,870
Dans ce cas, il a choisi l'octet numéro
quatre, l'octet à l'adresse quatre,

119
00:06:27,870 --> 00:06:31,310
et il va stocker le
capitale lettre H là pour moi.

120
00:06:31,310 --> 00:06:34,350
Si je puis dire int speed
limite est égale à 65, il est

121
00:06:34,350 --> 00:06:36,806
va mettre de côté quatre
octets de mémoire pour moi.

122
00:06:36,806 --> 00:06:39,180
Et il va traiter les personnes
quatre octets comme une seule unité

123
00:06:39,180 --> 00:06:41,305
parce que nous travaillons
avec est un nombre entier ici.

124
00:06:41,305 --> 00:06:44,350
Et il va stocker 65 là-dedans.

125
00:06:44,350 --> 00:06:47,000
>> Maintenant déjà, je suis une sorte de
vous parler un peu d'un mensonge,

126
00:06:47,000 --> 00:06:50,150
droite, parce que nous savons que
les ordinateurs fonctionnent en binaire.

127
00:06:50,150 --> 00:06:53,100
Ils ne comprennent pas
nécessairement ce qui est un grand H

128
00:06:53,100 --> 00:06:57,110
ou ce qui est un 65, ils ne
comprendre binaires, zéros et de uns.

129
00:06:57,110 --> 00:06:59,000
Et donc en fait ce que
nous y stocker

130
00:06:59,000 --> 00:07:03,450
est pas la lettre H et le nombre 65,
mais plutôt les représentations binaires

131
00:07:03,450 --> 00:07:06,980
celui-ci, qui ont l'air d'un
petit quelque chose comme ça.

132
00:07:06,980 --> 00:07:10,360
Et en particulier dans le
contexte de la variable de nombre entier,

133
00:07:10,360 --> 00:07:13,559
ça ne va pas juste cracher dans,
ça ne va pas le traiter comme un quatre

134
00:07:13,559 --> 00:07:15,350
octet morceau nécessairement,
il va réellement

135
00:07:15,350 --> 00:07:19,570
de le traiter comme un quatre morceaux d'octets,
ce qui pourrait ressembler à ceci.

136
00:07:19,570 --> 00:07:22,424
Et même cela ne
tout à fait vrai non plus,

137
00:07:22,424 --> 00:07:24,840
à cause de quelque chose appelé
un boutisme, que nous ne sommes pas

138
00:07:24,840 --> 00:07:26,965
vais pas entrer dans l'entreprise, mais
Si vous êtes curieux de savoir,

139
00:07:26,965 --> 00:07:29,030
vous pouvez lire sur peu
et grande boutisme.

140
00:07:29,030 --> 00:07:31,640
Mais pour les besoins de cet argument,
pour le bien de cette vidéo,

141
00:07:31,640 --> 00:07:34,860
disons simplement supposer que est, dans
fait, la façon dont le nombre serait de 65

142
00:07:34,860 --> 00:07:36,970
être représenté dans
mémoire sur chaque système,

143
00:07:36,970 --> 00:07:38,850
bien que ce soit pas entièrement vrai.

144
00:07:38,850 --> 00:07:41,700
>> Mais nous allons en fait juste obtenir
débarrasser de tous entièrement binaire,

145
00:07:41,700 --> 00:07:44,460
et il suffit de penser que H
et 65, il est beaucoup plus facile

146
00:07:44,460 --> 00:07:47,900
y penser comme
que comme un être humain.

147
00:07:47,900 --> 00:07:51,420
Très bien, alors il semble aussi peut-être un
peu aléatoire qui I've- mon système

148
00:07:51,420 --> 00:07:55,130
ne me donne pas les octets 5, 6, 7,
et 8 pour stocker l'entier.

149
00:07:55,130 --> 00:07:58,580
Il ya une raison pour cela, aussi, qui
nous ne serons pas entrer dans ce moment, mais il suffit

150
00:07:58,580 --> 00:08:00,496
de dire que ce que le
ordinateur est fait ici

151
00:08:00,496 --> 00:08:02,810
est probablement une bonne chose de sa part.

152
00:08:02,810 --> 00:08:06,020
Pour ne pas me donner la mémoire qui est
sauvegarder nécessairement à dos.

153
00:08:06,020 --> 00:08:10,490
Bien que ça va le faire maintenant
si je veux obtenir une autre chaîne,

154
00:08:10,490 --> 00:08:13,080
appelé nom de famille, et je veux
de mettre Lloyd là.

155
00:08:13,080 --> 00:08:18,360
Je vais avoir besoin de correspondre à l'une
caractère, chaque lettre de qui est

156
00:08:18,360 --> 00:08:21,330
va exiger un
caractère, un octet de la mémoire.

157
00:08:21,330 --> 00:08:26,230
Donc, si je pouvais mettre Lloyd dans mon tableau
comme cela, je suis assez bon pour aller, non?

158
00:08:26,230 --> 00:08:28,870
Qu'est-ce qui manque?

159
00:08:28,870 --> 00:08:31,840
>> Rappelez-vous que chaque chaîne que nous travaillons
avec en C termine avec barre oblique inverse zéro,

160
00:08:31,840 --> 00:08:33,339
et nous ne pouvons pas omettre que là, non plus.

161
00:08:33,339 --> 00:08:36,090
Nous avons besoin de mettre de côté un octet
de mémoire pour contenir afin que nous

162
00:08:36,090 --> 00:08:39,130
savoir quand notre chaîne est terminée.

163
00:08:39,130 --> 00:08:41,049
Donc encore une fois cet arrangement
des façon dont les choses

164
00:08:41,049 --> 00:08:42,799
apparaître dans la mémoire puissance
être un peu aléatoire,

165
00:08:42,799 --> 00:08:44,870
mais il est en fait comment
la plupart des systèmes sont conçus.

166
00:08:44,870 --> 00:08:48,330
Pour les aligner sur des multiples
de quatre, pour des raisons encore

167
00:08:48,330 --> 00:08:50,080
que nous ne devons pas
entrer dans ce moment.

168
00:08:50,080 --> 00:08:53,060
Mais cela, donc il suffit de dire que
Après ces trois lignes de code,

169
00:08:53,060 --> 00:08:54,810
voici ce que la mémoire pourrait ressembler.

170
00:08:54,810 --> 00:08:58,930
Si je dois emplacements de mémoire
4, 8, et 12 pour maintenir mes données,

171
00:08:58,930 --> 00:09:01,100
voilà ce que ma mémoire pourrait ressembler.

172
00:09:01,100 --> 00:09:04,062
>> Et tout particulièrement
pédante ici, quand

173
00:09:04,062 --> 00:09:06,020
nous parlons de la mémoire
Nous avons l'habitude adresses

174
00:09:06,020 --> 00:09:08,390
le faire en utilisant les notations hexadécimaux.

175
00:09:08,390 --> 00:09:12,030
Alors, pourquoi ne nous convertissons pas tous ces
du format décimal au format hexadécimal

176
00:09:12,030 --> 00:09:15,010
juste parce que ce général
comment nous nous référons à la mémoire.

177
00:09:15,010 --> 00:09:17,880
Ainsi, au lieu d'être de 0 à
19, ce que nous avons est de zéro

178
00:09:17,880 --> 00:09:20,340
x x1 zéro par zéro à trois.

179
00:09:20,340 --> 00:09:23,790
Ce sont les 20 octets de mémoire que nous
avons ou nous regardant dans cette image

180
00:09:23,790 --> 00:09:25,540
ici.

181
00:09:25,540 --> 00:09:29,310
>> Donc, tout cela étant dit, nous allons
pas loin de la mémoire pour une seconde

182
00:09:29,310 --> 00:09:30,490
et retour à des pointeurs.

183
00:09:30,490 --> 00:09:32,420
Ici est le plus important
chose à retenir

184
00:09:32,420 --> 00:09:34,070
que nous commençons à travailler avec des pointeurs.

185
00:09:34,070 --> 00:09:36,314
Un pointeur est rien
plus d'une adresse.

186
00:09:36,314 --> 00:09:38,230
Je vais le dire encore une fois parce que
il est si important que cela,

187
00:09:38,230 --> 00:09:42,730
un pointeur est rien
plus d'une adresse.

188
00:09:42,730 --> 00:09:47,760
Pointeurs sont des adresses à des endroits
dans la mémoire où les variables vivent.

189
00:09:47,760 --> 00:09:52,590
Sachant qu'il devient espérons une
peu plus facile de travailler avec eux.

190
00:09:52,590 --> 00:09:54,550
Une autre chose que je veux
à faire est d'avoir tri

191
00:09:54,550 --> 00:09:58,510
de diagrammes représentant visuellement ce qui est
passe avec différentes lignes de code.

192
00:09:58,510 --> 00:10:00,660
Et nous le ferons un couple
de temps en pointeurs,

193
00:10:00,660 --> 00:10:03,354
et quand nous parlons de dynamique
allocation de mémoire ainsi.

194
00:10:03,354 --> 00:10:06,020
Parce que je pense que ces diagrammes
peuvent être particulièrement utiles.

195
00:10:06,020 --> 00:10:09,540
>> Donc, si je dis par exemple, int k
dans mon code, ce qui se passe?

196
00:10:09,540 --> 00:10:12,524
Eh bien ce qui se passe est essentiellement
Je suis en train de mémoire réservée pour moi,

197
00:10:12,524 --> 00:10:14,690
mais je ne même pas y
pense comme ça, je

198
00:10:14,690 --> 00:10:16,300
tiens à penser comme une boîte.

199
00:10:16,300 --> 00:10:20,090
Je dois une boîte et il est
de couleur verte parce que je

200
00:10:20,090 --> 00:10:21,750
peut mettre entiers dans des boîtes vertes.

201
00:10:21,750 --> 00:10:23,666
Si elle était un personnage que je
pourrait avoir une boîte bleue.

202
00:10:23,666 --> 00:10:27,290
Mais je dis toujours, si je suis la création
une boîte qui peut contenir des nombres entiers

203
00:10:27,290 --> 00:10:28,950
cette boîte est de couleur verte.

204
00:10:28,950 --> 00:10:33,020
Et je prends un marqueur permanent
et je vous écris k sur le côté de celui-ci.

205
00:10:33,020 --> 00:10:37,590
Je dois donc une boîte appelée k,
dans lequel je peux mettre entiers.

206
00:10:37,590 --> 00:10:41,070
Donc, quand je dis int k, qui est
ce qui se passe dans ma tête.

207
00:10:41,070 --> 00:10:43,140
Si je dis k est égal à cinq, ce que je fais?

208
00:10:43,140 --> 00:10:45,110
Eh bien, je suis en train de cinq
dans la boîte, à droite.

209
00:10:45,110 --> 00:10:48,670
Ceci est assez simple, si
Je dis int k, créer une boîte appelée k.

210
00:10:48,670 --> 00:10:52,040
Si je dis k est égal à 5,
mis cinq dans la boîte.

211
00:10:52,040 --> 00:10:53,865
Espérons que ce pas trop d'un saut.

212
00:10:53,865 --> 00:10:55,990
Voici où les choses vont un
peu intéressant cependant.

213
00:10:55,990 --> 00:11:02,590
Si je dis int * pk, bien, même si je ne fais pas
savoir ce que cela signifie nécessairement,

214
00:11:02,590 --> 00:11:06,150
il est clairement a quelque chose
à voir avec un entier.

215
00:11:06,150 --> 00:11:08,211
Donc, je vais à la couleur
cette boîte verte-ish,

216
00:11:08,211 --> 00:11:10,210
Je sais que cela a quelque chose
à faire avec un nombre entier,

217
00:11:10,210 --> 00:11:13,400
mais il est pas un nombre entier lui-même,
parce qu'il est un int étoiles.

218
00:11:13,400 --> 00:11:15,390
Il ya quelque chose de légèrement
différente à ce sujet.

219
00:11:15,390 --> 00:11:17,620
Donc impliquer de un entier,
mais sinon il est

220
00:11:17,620 --> 00:11:19,830
pas trop différent de
ce que nous parlions.

221
00:11:19,830 --> 00:11:24,240
Il est une boîte, son obtenu un label,
il est vêtu d'un pk étiquette,

222
00:11:24,240 --> 00:11:27,280
et il est capable de tenue
étoiles int, quelles qu'elles sont.

223
00:11:27,280 --> 00:11:29,894
Ils ont quelque chose à faire
avec des nombres entiers, clairement.

224
00:11:29,894 --> 00:11:31,060
Voici la dernière ligne si.

225
00:11:31,060 --> 00:11:37,650
Si je dis pk = & k, whoa,
ce qui vient de se passer, non?

226
00:11:37,650 --> 00:11:41,820
Donc, ce nombre aléatoire, apparemment aléatoire
nombre, est jeté dans la boîte il.

227
00:11:41,820 --> 00:11:44,930
Tout ce qui est, est pk
obtient l'adresse de k.

228
00:11:44,930 --> 00:11:52,867
Donc, je suis coller où k vit dans la mémoire,
son adresse, l'adresse de ses octets.

229
00:11:52,867 --> 00:11:55,200
Tout ce que je fais est que je dis
cette valeur est ce que je vais

230
00:11:55,200 --> 00:11:59,430
à mettre à l'intérieur de ma boîte appelée pk.

231
00:11:59,430 --> 00:12:02,080
Et parce que ces choses sont
pointeurs, et parce que la recherche

232
00:12:02,080 --> 00:12:04,955
à une chaîne comme Zero X
huit zéro sept quatre huit c

233
00:12:04,955 --> 00:12:07,790
deux zéro est probablement
pas très significatif.

234
00:12:07,790 --> 00:12:12,390
Lorsque nous visualisons généralement pointeurs,
nous faisons réellement de manière pointeurs.

235
00:12:12,390 --> 00:12:17,000
Pk nous donne l'information
nous devons trouver k dans la mémoire.

236
00:12:17,000 --> 00:12:19,120
Donc, fondamentalement, pk a une flèche en elle.

237
00:12:19,120 --> 00:12:21,670
Et si nous marchons la longueur
de cette flèche, imaginez

238
00:12:21,670 --> 00:12:25,280
il est quelque chose que vous pouvez marcher sur, si nous
marcher le long de la longueur de la flèche,

239
00:12:25,280 --> 00:12:29,490
à la pointe de cette flèche, nous
trouveront l'emplacement dans la mémoire

240
00:12:29,490 --> 00:12:31,390
où k vit.

241
00:12:31,390 --> 00:12:34,360
Et cela est très important
car une fois que nous savons où k vit,

242
00:12:34,360 --> 00:12:37,870
nous pouvons commencer à travailler avec les données
à l'intérieur de cet emplacement de mémoire.

243
00:12:37,870 --> 00:12:40,780
Bien que nous obtenons un minuscule
peu en avance sur nous pour l'instant.

244
00:12:40,780 --> 00:12:42,240
>> Donc ce qui est un pointeur?

245
00:12:42,240 --> 00:12:45,590
Un pointeur est un élément de données dont la
valeur est une adresse mémoire.

246
00:12:45,590 --> 00:12:49,740
Ce était que le zéro x huit trucs zéro
passe, qui était une adresse mémoire.

247
00:12:49,740 --> 00:12:52,060
Ce fut un emplacement en mémoire.

248
00:12:52,060 --> 00:12:55,080
Et du type d'un pointeur
décrit le genre

249
00:12:55,080 --> 00:12:56,930
des données que vous trouverez à
cette adresse de mémoire.

250
00:12:56,930 --> 00:12:58,810
Donc, il ya la partie int étoiles droite.

251
00:12:58,810 --> 00:13:03,690
Si je suis cette flèche, il est
va me conduire à un emplacement.

252
00:13:03,690 --> 00:13:06,980
Et cet endroit, ce que je
y trouveront dans mon exemple,

253
00:13:06,980 --> 00:13:08,240
est une boîte de couleur verte.

254
00:13:08,240 --> 00:13:12,650
Il est un entier, voilà ce que je
trouveront si je vais à cette adresse.

255
00:13:12,650 --> 00:13:14,830
Le type de données d'un
pointeur décrit ce

256
00:13:14,830 --> 00:13:17,936
vous trouverez à cette adresse mémoire.

257
00:13:17,936 --> 00:13:19,560
Alors, voici la chose vraiment cool si.

258
00:13:19,560 --> 00:13:25,090
Pointeurs nous permettre de passer
variables entre fonctions.

259
00:13:25,090 --> 00:13:28,520
Et effectivement passer des variables
et ne passera pas des copies.

260
00:13:28,520 --> 00:13:32,879
Parce que si nous savons exactement où
dans la mémoire pour trouver une variable,

261
00:13:32,879 --> 00:13:35,670
nous ne devons pas faire une copie de
, on peut simplement aller à cet endroit

262
00:13:35,670 --> 00:13:37,844
et de travailler avec cette variable.

263
00:13:37,844 --> 00:13:40,260
Donc, dans les pointeurs de sorte essence
de faire un environnement informatique

264
00:13:40,260 --> 00:13:42,360
beaucoup plus comme le monde réel, à droite.

265
00:13:42,360 --> 00:13:44,640
>> Alors, voici une analogie.

266
00:13:44,640 --> 00:13:48,080
Disons que je suis un ordinateur portable,
à droite, et il est plein de notes.

267
00:13:48,080 --> 00:13:50,230
Et je voudrais vous mettre à jour.

268
00:13:50,230 --> 00:13:53,960
Vous êtes une fonction qui
Mises à jour des notes, à droite.

269
00:13:53,960 --> 00:13:56,390
Dans la façon dont nous avons été
travailler jusqu'ici, ce qui

270
00:13:56,390 --> 00:14:02,370
qui se passe est que vous prendrez mon carnet,
vous allez au magasin de copie,

271
00:14:02,370 --> 00:14:06,410
vous allez faire une copie de Xerox
chaque page de l'ordinateur portable.

272
00:14:06,410 --> 00:14:09,790
Vous quitterez mon carnet Retour
sur mon bureau lorsque vous avez terminé,

273
00:14:09,790 --> 00:14:14,600
vous irez et traverser des choses dans mon
ordinateur portable qui sont périmés ou mal,

274
00:14:14,600 --> 00:14:19,280
puis vous passerez Retour à
moi la pile de pages Xerox

275
00:14:19,280 --> 00:14:22,850
qui est une réplique de mon ordinateur portable avec
les modifications que vous avez apportées.

276
00:14:22,850 --> 00:14:27,040
Et à ce moment, il est à moi comme
la fonction d'appel, que l'appelant,

277
00:14:27,040 --> 00:14:30,582
de décider de prendre vos notes et
les intégrer dans mon ordinateur portable.

278
00:14:30,582 --> 00:14:32,540
Donc, il ya beaucoup d'étapes
en cause ici, à droite.

279
00:14:32,540 --> 00:14:34,850
Comme ça ne serait pas mieux
si je viens de dire, hey, pouvez-vous

280
00:14:34,850 --> 00:14:38,370
mettre à jour mon ordinateur portable pour
moi, vous remets mon carnet,

281
00:14:38,370 --> 00:14:40,440
et vous prenez les choses et
littéralement traverser les sortir

282
00:14:40,440 --> 00:14:42,810
et mettre à jour mes notes sur mon carnet.

283
00:14:42,810 --> 00:14:45,140
Et puis me donner mon carnet dos.

284
00:14:45,140 --> 00:14:47,320
Voilà le genre de ce
pointeurs nous permettent de faire,

285
00:14:47,320 --> 00:14:51,320
ils font cet environnement beaucoup
plus comme comment nous fonctionnons dans la réalité.

286
00:14:51,320 --> 00:14:54,640
>> Tout droit est donc ce que
un pointeur est, parlons

287
00:14:54,640 --> 00:14:58,040
comment pointeurs travaillent en C, et
comment nous pouvons commencer à travailler avec eux.

288
00:14:58,040 --> 00:15:02,550
Donc, il ya un pointeur très simple
en C appelé le pointeur NULL.

289
00:15:02,550 --> 00:15:04,830
Les points de pointeur nul à rien.

290
00:15:04,830 --> 00:15:08,310
Cela semble sans doute comme il est
pas vraiment une chose très utile,

291
00:15:08,310 --> 00:15:10,500
mais comme nous le verrons un
peu plus tard, le fait

292
00:15:10,500 --> 00:15:15,410
que ce pointeur NULL existe
en fait peut vraiment être utile.

293
00:15:15,410 --> 00:15:19,090
Et chaque fois que vous créez un pointeur, et
vous ne définissez pas son immediately- de valeur

294
00:15:19,090 --> 00:15:21,060
un exemple de configuration
sa valeur immédiatement

295
00:15:21,060 --> 00:15:25,401
aura quelques diapositives de retour
où je dis pk égale & k,

296
00:15:25,401 --> 00:15:28,740
pk obtient l'adresse de k, comme
nous allons voir ce que cela signifie,

297
00:15:28,740 --> 00:15:32,990
nous verrons comment coder que shortly-
si nous ne fixons pas sa valeur à quelque chose

298
00:15:32,990 --> 00:15:35,380
immédiatement significative,
vous devriez toujours

299
00:15:35,380 --> 00:15:37,480
définir votre pointeur pour pointer vers null.

300
00:15:37,480 --> 00:15:40,260
Vous devriez le mettre à point à rien.

301
00:15:40,260 --> 00:15:43,614
>> Cela est très différent de
laissant juste la valeur comme il est

302
00:15:43,614 --> 00:15:45,530
puis déclarant une
pointeur et juste en supposant

303
00:15:45,530 --> 00:15:48,042
il est nul parce qu'il ya rarement vrai.

304
00:15:48,042 --> 00:15:50,000
Donc, vous devez toujours définir
la valeur d'un pointeur

305
00:15:50,000 --> 00:15:55,690
null si vous ne définissez pas sa valeur
à quelque chose de significatif immédiatement.

306
00:15:55,690 --> 00:15:59,090
Vous pouvez vérifier si la valeur d'un pointeur
est nulle en utilisant l'opérateur d'égalité

307
00:15:59,090 --> 00:16:05,450
(==), Tout comme vous comparez tout entier
des valeurs ou des valeurs de caractères à l'aide de (==)

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

309
00:16:06,320 --> 00:16:10,994
Il est une sorte spéciale de la constante
valeur que vous pouvez utiliser pour tester.

310
00:16:10,994 --> 00:16:13,160
Ce qui fut une très simple
pointeur, le pointeur NULL.

311
00:16:13,160 --> 00:16:15,320
Une autre façon de créer
un pointeur est d'extraire

312
00:16:15,320 --> 00:16:18,240
l'adresse d'une variable
vous avez déjà créé,

313
00:16:18,240 --> 00:16:22,330
et vous faites cela en utilisant le &
l'extraction de l'adresse de l'opérateur.

314
00:16:22,330 --> 00:16:26,720
Dont nous avons déjà vu précédemment
dans le premier exemple de diagramme je l'ai montré.

315
00:16:26,720 --> 00:16:31,450
Donc, si x est une variable que nous avons
déjà créé de type entier,

316
00:16:31,450 --> 00:16:35,110
ensuite et x est un pointeur sur un entier.

317
00:16:35,110 --> 00:16:39,810
& x est- rappelez-vous, et va extraire
l'adresse de la chose sur la droite.

318
00:16:39,810 --> 00:16:45,350
Et depuis un pointeur est juste une adresse,
de & x est un pointeur sur un entier

319
00:16:45,350 --> 00:16:48,560
dont la valeur est là dans la mémoire x vies.

320
00:16:48,560 --> 00:16:50,460
Il est l'adresse de x.

321
00:16:50,460 --> 00:16:53,296
So & x est l'adresse de x.

322
00:16:53,296 --> 00:16:55,670
Prenons cette première étape
plus loin et se connecter à quelque chose

323
00:16:55,670 --> 00:16:58,380
J'y ai fait allusion dans une vidéo avant.

324
00:16:58,380 --> 00:17:06,730
Si arr est un tableau de doubles, puis
& crochet arr i est un pointeur

325
00:17:06,730 --> 00:17:08,109
à un double.

326
00:17:08,109 --> 00:17:08,970
D'ACCORD.

327
00:17:08,970 --> 00:17:12,160
arr crochet i, si
arr est un tableau de doubles,

328
00:17:12,160 --> 00:17:19,069
puis arr crochet i est
l'élément de rang i de cette matrice,

329
00:17:19,069 --> 00:17:29,270
et arr & crochet i est où, dans
l'élément de mémoire i-ième arr existe.

330
00:17:29,270 --> 00:17:31,790
>> Alors, quelle est l'implication ici?

331
00:17:31,790 --> 00:17:34,570
Un nom tableaux, l'implication
de toute cette affaire,

332
00:17:34,570 --> 00:17:39,290
est que le nom d'un tableau est
en fait lui-même un pointeur.

333
00:17:39,290 --> 00:17:41,170
Vous avez travaillé
avec des pointeurs tout au long de

334
00:17:41,170 --> 00:17:45,290
chaque fois que vous avez utilisé un tableau.

335
00:17:45,290 --> 00:17:49,090
Rappelez-vous de l'exemple
sur la portée des variables,

336
00:17:49,090 --> 00:17:53,420
vers la fin de la vidéo, je présente
un exemple où nous avons une fonction

337
00:17:53,420 --> 00:17:56,890
appelé ensemble int et un
fonction appelée matrice ensemble.

338
00:17:56,890 --> 00:18:00,490
Et votre défi de déterminer
ou non, ou que la

339
00:18:00,490 --> 00:18:03,220
valeurs que nous imprimé
la fin de la fonction,

340
00:18:03,220 --> 00:18:05,960
à la fin du programme principal.

341
00:18:05,960 --> 00:18:08,740
>> Si vous vous souvenez de cet exemple
ou si vous avez regardé la vidéo,

342
00:18:08,740 --> 00:18:13,080
vous savez que lorsque l'appel à You-
ensemble int fait effectivement rien.

343
00:18:13,080 --> 00:18:16,390
Mais l'appel pour régler tableau fait.

344
00:18:16,390 --> 00:18:19,280
Et je sorte de occultée pourquoi
ce fut le cas à l'époque.

345
00:18:19,280 --> 00:18:22,363
Je viens de dire, et il est un tableau, il est
spéciale, vous le savez, il ya une raison.

346
00:18:22,363 --> 00:18:25,020
La raison en est que de un tableau
nom est vraiment juste un pointeur,

347
00:18:25,020 --> 00:18:28,740
et il ya cette spéciale
syntaxe crochet que

348
00:18:28,740 --> 00:18:30,510
rendre les choses beaucoup plus agréable de travailler avec.

349
00:18:30,510 --> 00:18:34,410
Et ils font l'idée d'un
pointeur beaucoup moins intimidant,

350
00:18:34,410 --> 00:18:36,800
et voilà pourquoi ils sont genre
d'présentée de cette façon.

351
00:18:36,800 --> 00:18:38,600
Mais vraiment tableaux sont des pointeurs juste.

352
00:18:38,600 --> 00:18:41,580
Et voilà pourquoi, lorsque nous
fait un changement à la matrice,

353
00:18:41,580 --> 00:18:44,880
lorsque nous avons adopté un tableau comme un paramètre
ou à une fonction en tant qu'argument

354
00:18:44,880 --> 00:18:50,110
à une fonction, le contenu de la matrice
effectivement changé à la fois dans l'appelé

355
00:18:50,110 --> 00:18:51,160
et en l'appelant.

356
00:18:51,160 --> 00:18:55,846
Qui, pour tout autre type de
variable que nous avons vu était pas le cas.

357
00:18:55,846 --> 00:18:58,970
Voilà donc quelque chose à garder à
l'esprit quand vous travaillez avec des pointeurs,

358
00:18:58,970 --> 00:19:01,610
qui est le nom d'un
tableau fait un pointeur

359
00:19:01,610 --> 00:19:04,750
le premier élément de ce tableau.

360
00:19:04,750 --> 00:19:08,930
>> OK alors maintenant nous avons tous ces
faits, nous allons continuer, à droite.

361
00:19:08,930 --> 00:19:11,370
Pourquoi nous soucions-nous
où quelque chose vit.

362
00:19:11,370 --> 00:19:14,120
Eh bien, comme je l'ai dit, il est assez
utile de savoir où quelque chose vit

363
00:19:14,120 --> 00:19:17,240
de sorte que vous pouvez y aller et de le changer.

364
00:19:17,240 --> 00:19:19,390
Travailler avec elle et fait
avoir la chose que vous

365
00:19:19,390 --> 00:19:23,710
vouloir faire à cet effet de prendre variable
et ne pas prendre effet sur une certaine copie.

366
00:19:23,710 --> 00:19:26,150
Ceci est appelé le déréférencement.

367
00:19:26,150 --> 00:19:28,690
Nous allons à la référence et
nous changeons la valeur il.

368
00:19:28,690 --> 00:19:32,660
Donc, si nous avons un pointeur et il est appelé
pc, et il pointe vers un personnage,

369
00:19:32,660 --> 00:19:40,610
alors nous pouvons dire * et * pc pc est le
nom de ce que nous trouverons si nous allons

370
00:19:40,610 --> 00:19:42,910
à l'adresse pc.

371
00:19:42,910 --> 00:19:47,860
Qu'est-ce que nous y trouvons est un personnage et
* pc est de savoir comment nous nous référons aux données à ce

372
00:19:47,860 --> 00:19:48,880
emplacement.

373
00:19:48,880 --> 00:19:54,150
Donc, nous pourrions dire quelque chose comme
* pc = D ou quelque chose comme ça,

374
00:19:54,150 --> 00:19:59,280
et cela signifie que quel que soit
était à l'adresse mémoire pc,

375
00:19:59,280 --> 00:20:07,040
quel que soit le caractère était auparavant
là, est maintenant D, si nous disons * PC = D.

376
00:20:07,040 --> 00:20:10,090
>> Alors on y va à nouveau avec
C certains trucs bizarres, à droite.

377
00:20:10,090 --> 00:20:14,560
Alors que nous avons vu précédemment comme étant *
en quelque sorte partie du type de données,

378
00:20:14,560 --> 00:20:17,160
et maintenant il est utilisé dans
un contexte légèrement différent

379
00:20:17,160 --> 00:20:19,605
pour accéder aux données à un emplacement.

380
00:20:19,605 --> 00:20:22,480
Je sais qu'il est un peu déroutant et
qui est en fait une partie de cet ensemble

381
00:20:22,480 --> 00:20:25,740
comme, pourquoi pointeurs ont cette mythologie
autour d'eux comme étant si complexe,

382
00:20:25,740 --> 00:20:28,250
est une sorte de problème de syntaxe, honnêtement.

383
00:20:28,250 --> 00:20:31,810
Mais * est utilisé dans les deux contextes,
à la fois dans le cadre du nom de type,

384
00:20:31,810 --> 00:20:34,100
et nous verrons un peu
plus tard, quelque chose d'autre, aussi.

385
00:20:34,100 --> 00:20:36,490
Et en ce moment est la
opérateur de déréférencement.

386
00:20:36,490 --> 00:20:38,760
Donc, il va à la référence,
il accède aux données

387
00:20:38,760 --> 00:20:43,000
à l'emplacement du pointeur, et
vous permet de manipuler à volonté.

388
00:20:43,000 --> 00:20:45,900
>> Maintenant, ce qui est très similaire à
visiter votre voisin, à droite.

389
00:20:45,900 --> 00:20:48,710
Si vous savez ce que votre
voisin vit, vous êtes

390
00:20:48,710 --> 00:20:50,730
pas traîner avec votre voisin.

391
00:20:50,730 --> 00:20:53,510
Vous savez que vous arrivez à
savoir où ils vivent,

392
00:20:53,510 --> 00:20:56,870
mais cela ne signifie pas que par
la vertu d'avoir cette connaissance

393
00:20:56,870 --> 00:20:59,170
vous interagissez avec eux.

394
00:20:59,170 --> 00:21:01,920
Si vous souhaitez interagir avec eux,
vous devez aller à leur maison,

395
00:21:01,920 --> 00:21:03,760
vous devez aller à l'endroit où ils vivent.

396
00:21:03,760 --> 00:21:07,440
Et une fois que vous faites cela,
alors vous pouvez interagir

397
00:21:07,440 --> 00:21:09,420
avec eux tout comme vous voudriez.

398
00:21:09,420 --> 00:21:12,730
Et de même avec des variables,
vous devez aller à leur adresse

399
00:21:12,730 --> 00:21:15,320
si vous voulez les interagir,
vous ne pouvez pas savoir exactement l'adresse.

400
00:21:15,320 --> 00:21:21,495
Et la façon dont vous allez à l'adresse est
* à utiliser, l'opérateur de déréférencement.

401
00:21:21,495 --> 00:21:23,620
Que pensez-vous arrive
si nous essayons de déréférencer

402
00:21:23,620 --> 00:21:25,260
un pointeur dont la valeur est nulle?

403
00:21:25,260 --> 00:21:28,470
Rappelons que le null
pointeur pointe vers rien.

404
00:21:28,470 --> 00:21:34,110
Donc, si vous essayez de déréférencer
rien ou aller à une adresse rien,

405
00:21:34,110 --> 00:21:36,800
que pensez-vous qui se passe?

406
00:21:36,800 --> 00:21:39,630
Eh bien, si la segmentation vous l'aurez deviné
faute, vous avez raison.

407
00:21:39,630 --> 00:21:41,390
Si vous essayez de déréférencer
un pointeur NULL,

408
00:21:41,390 --> 00:21:43,140
vous souffrez d'une segmentation
faute. Mais attendez,

409
00:21:43,140 --> 00:21:45,820
ne vous dis-je, que
si tu ne vas pas

410
00:21:45,820 --> 00:21:49,220
pour définir votre valeur de votre
pointeur vers quelque chose de significatif,

411
00:21:49,220 --> 00:21:51,000
vous devez mettre à null?

412
00:21:51,000 --> 00:21:55,290
Je l'ai fait et effectivement la segmentation
faute est une sorte de bon comportement.

413
00:21:55,290 --> 00:21:58,680
>> Avez-vous déjà déclaré une variable et
pas affecté immédiatement sa valeur?

414
00:21:58,680 --> 00:22:02,680
Donc, vous venez de dire int x; vous ne faites pas
effectivement affecter à quoi que ce soit

415
00:22:02,680 --> 00:22:05,340
puis plus tard dans votre code,
vous imprimez la valeur de x,

416
00:22:05,340 --> 00:22:07,650
ayant toujours pas
il attribué à rien.

417
00:22:07,650 --> 00:22:10,370
Fréquemment, vous obtiendrez
zéro, mais parfois vous

418
00:22:10,370 --> 00:22:15,000
pourrait obtenir un nombre aléatoire, et
vous avez aucune idée d'où il vient.

419
00:22:15,000 --> 00:22:16,750
De même les choses peuvent
arriver avec des pointeurs.

420
00:22:16,750 --> 00:22:20,110
Lorsque vous déclarez un pointeur
int * pk par exemple,

421
00:22:20,110 --> 00:22:23,490
et vous ne l'affectez à une valeur,
vous obtenez quatre octets pour la mémoire.

422
00:22:23,490 --> 00:22:25,950
Quelles que soient les quatre octets de
mémoire le système peut

423
00:22:25,950 --> 00:22:28,970
trouver qui ont une certaine valeur significative.

424
00:22:28,970 --> 00:22:31,760
Et il y aurait eu
quelque chose de déjà là que

425
00:22:31,760 --> 00:22:34,190
est plus nécessaire par un autre
fonction, donc vous avez juste

426
00:22:34,190 --> 00:22:35,900
toutes les données était là.

427
00:22:35,900 --> 00:22:40,570
>> Que faire si vous avez essayé de faire déréférencer
une certaine adresse que vous ne- il y avait

428
00:22:40,570 --> 00:22:43,410
octets déjà et d'information dans
là, qui est maintenant dans votre pointeur.

429
00:22:43,410 --> 00:22:47,470
Si vous essayez de déréférencer ce pointeur,
vous pourriez être jouer avec un peu de mémoire

430
00:22:47,470 --> 00:22:49,390
que vous ne vouliez pas
de jouer avec tout cela.

431
00:22:49,390 --> 00:22:51,639
Et en fait, vous pourriez faire
quelque chose de vraiment dévastatrice,

432
00:22:51,639 --> 00:22:54,880
comme briser un autre programme,
ou défaire une autre fonction,

433
00:22:54,880 --> 00:22:58,289
ou faire quelque chose malveillant qui
vous ne l'avez pas l'intention de le faire du tout.

434
00:22:58,289 --> 00:23:00,080
Et voilà pourquoi il est
effectivement une bonne idée

435
00:23:00,080 --> 00:23:04,030
pour définir vos pointeurs null si vous
ne les mettez pas à quelque chose de significatif.

436
00:23:04,030 --> 00:23:06,760
Il est probablement mieux à la
fin de la journée pour votre programme

437
00:23:06,760 --> 00:23:09,840
à planter alors pour elle de le faire
Quelque chose qui vis en hausse

438
00:23:09,840 --> 00:23:12,400
un autre programme ou une autre fonction.

439
00:23:12,400 --> 00:23:15,207
Ce comportement est probablement encore
moins idéale que de simplement écraser.

440
00:23:15,207 --> 00:23:17,040
Et voilà pourquoi il est
effectivement une bonne habitude

441
00:23:17,040 --> 00:23:20,920
pour entrer dans de définir vos pointeurs
null si vous ne les mettez pas

442
00:23:20,920 --> 00:23:24,540
à une valeur significative
immédiatement, une valeur que vous savez

443
00:23:24,540 --> 00:23:27,260
et que vous pouvez en toute sécurité le déréférencement.

444
00:23:27,260 --> 00:23:32,240
>> Donc, revenons maintenant et jetez un oeil
à la syntaxe de la situation globale.

445
00:23:32,240 --> 00:23:37,400
Si je dis int * p ;, ce que je viens faire?

446
00:23:37,400 --> 00:23:38,530
Qu'est-ce que je l'ai fait est présent.

447
00:23:38,530 --> 00:23:43,290
Je connais la valeur de p est une adresse
parce que tous les pointeurs sont juste

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

449
00:23:44,660 --> 00:23:47,750
Je peux déréférencer p
en utilisant l'opérateur *.

450
00:23:47,750 --> 00:23:51,250
Dans ce contexte, ici, à la très
top rappeler le * fait partie du type.

451
00:23:51,250 --> 00:23:53,510
Int * est le type de données.

452
00:23:53,510 --> 00:23:56,150
Mais je ne peux déréférencer
p en utilisant l'opérateur *,

453
00:23:56,150 --> 00:24:01,897
et si je le fais, si je vais à cette adresse,
que vais-je trouver à cette adresse?

454
00:24:01,897 --> 00:24:02,855
Je vais trouver un entier.

455
00:24:02,855 --> 00:24:05,910
Donc, int * p est fondamentalement
disant, p est une adresse.

456
00:24:05,910 --> 00:24:09,500
Je peux déréférencer p et si
Je le fais, je vais trouver un nombre entier

457
00:24:09,500 --> 00:24:11,920
à cet emplacement de mémoire.

458
00:24:11,920 --> 00:24:14,260
>> OK donc je dit qu'il y avait une autre
ennuyeux avec des étoiles

459
00:24:14,260 --> 00:24:17,060
et voici où cela
ennuyeux avec des étoiles est.

460
00:24:17,060 --> 00:24:21,640
Avez-vous déjà essayé de déclarer
plusieurs variables du même type

461
00:24:21,640 --> 00:24:24,409
sur la même ligne de code?

462
00:24:24,409 --> 00:24:27,700
Donc, pour une seconde, prétendre que la ligne,
le code que je dois réellement là en vert

463
00:24:27,700 --> 00:24:29,366
est pas là et il dit seulement int x, y, z ;.

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

465
00:24:31,634 --> 00:24:34,550
Qu'est-ce que ce serait faire est effectivement de créer
trois variables entières pour vous,

466
00:24:34,550 --> 00:24:36,930
un appelé x, un appelé
Y, et un autre appelé z.

467
00:24:36,930 --> 00:24:41,510
Il est une façon de le faire sans
avoir à diviser sur trois lignes.

468
00:24:41,510 --> 00:24:43,890
>> Voici où se étoiles
ennuyeux à nouveau si,

469
00:24:43,890 --> 00:24:49,200
car le * est en fait partie
à la fois le nom du type et une partie

470
00:24:49,200 --> 00:24:50,320
du nom de variable.

471
00:24:50,320 --> 00:24:56,430
Et si je dis int * px, py, pz, ce que je
obtenir effectivement est un pointeur vers un entier

472
00:24:56,430 --> 00:25:01,650
appelé px et deux entiers, py et pz.

473
00:25:01,650 --> 00:25:04,950
Et cela est probablement pas ce
nous voulons, ce ne est pas bonne.

474
00:25:04,950 --> 00:25:09,290
>> Donc, si je veux créer plusieurs pointeurs
sur la même ligne, de même type,

475
00:25:09,290 --> 00:25:12,140
et les étoiles, ce que je réellement besoin
à faire est de dire int * pa, pb *, * pc.

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

477
00:25:17,330 --> 00:25:20,300
Ayant maintenant juste dit que
et maintenant vous dire cela,

478
00:25:20,300 --> 00:25:22,170
vous aurez probablement jamais le faire.

479
00:25:22,170 --> 00:25:25,170
Et il est probablement une bonne chose honnêtement,
parce que vous pourriez par inadvertance

480
00:25:25,170 --> 00:25:26,544
omettre une étoile, quelque chose comme ça.

481
00:25:26,544 --> 00:25:29,290
Il est probablement préférable de déclarer peut-être
pointeurs sur les différentes lignes,

482
00:25:29,290 --> 00:25:31,373
mais il est juste un autre
de ceux syntaxe gênant

483
00:25:31,373 --> 00:25:35,310
les choses avec des étoiles qui font
pointeurs si difficile de travailler avec.

484
00:25:35,310 --> 00:25:39,480
Parce qu'il est juste ce syntaxique
désordre que vous avez à travailler à travers.

485
00:25:39,480 --> 00:25:41,600
Avec la pratique, il ne
vraiment devenu une seconde nature.

486
00:25:41,600 --> 00:25:45,410
Je fais encore des erreurs avec elle encore
après la programmation depuis 10 ans,

487
00:25:45,410 --> 00:25:49,630
alors ne vous inquiétez pas si quelque chose arrive
pour vous, il est assez fréquent honnêtement.

488
00:25:49,630 --> 00:25:52,850
Il est vraiment une sorte de
un défaut de la syntaxe.

489
00:25:52,850 --> 00:25:54,900
>> OK, donc je sorte de promis
que nous allions revoir

490
00:25:54,900 --> 00:25:59,370
le concept de la taille est une chaîne.

491
00:25:59,370 --> 00:26:02,750
Eh bien, si je vous disais que une
chaîne, nous avons vraiment une sorte de

492
00:26:02,750 --> 00:26:04,140
été de vous mentir tout le temps.

493
00:26:04,140 --> 00:26:06,181
Il n'y a pas de type de données appelé
chaîne, et en fait je

494
00:26:06,181 --> 00:26:09,730
a mentionné dans un de nos
premières vidéos sur les types de données,

495
00:26:09,730 --> 00:26:13,820
cette chaîne est un type de données qui
a été créé pour vous dans CS50.h.

496
00:26:13,820 --> 00:26:17,050
Vous devez #inclure
CS50.h afin de l'utiliser.

497
00:26:17,050 --> 00:26:19,250
>> Bien chaîne est vraiment juste
un alias pour quelque chose

498
00:26:19,250 --> 00:26:23,600
appelé le char *, un
pointeur vers un caractère.

499
00:26:23,600 --> 00:26:26,010
Eh bien pointeurs, rappel,
sont des adresses seulement.

500
00:26:26,010 --> 00:26:28,780
Alors, quelle est la taille
en octets d'une chaîne?

501
00:26:28,780 --> 00:26:29,796
Eh bien, il est quatre ou huit.

502
00:26:29,796 --> 00:26:32,170
Et la raison pour laquelle je dire quatre ou
huit est parce qu'il fait

503
00:26:32,170 --> 00:26:36,730
dépend du système, Si vous utilisez
CS50 ide, char * est la taille d'un caractère

504
00:26:36,730 --> 00:26:39,340
* Est de huit, il est un système 64 bits.

505
00:26:39,340 --> 00:26:43,850
Chaque adresse en mémoire est de 64 bits.

506
00:26:43,850 --> 00:26:48,270
Si vous utilisez l'appareil de CS50
ou en utilisant une machine de 32 bits,

507
00:26:48,270 --> 00:26:51,640
et vous avez entendu ce terme 32 bits
la machine, ce qui est une machine 32 bits?

508
00:26:51,640 --> 00:26:56,090
Eh bien cela signifie juste que tous les
adresse en mémoire est de 32 bits de long.

509
00:26:56,090 --> 00:26:59,140
Et donc 32 bits est de quatre octets.

510
00:26:59,140 --> 00:27:02,710
Ainsi, un char * est quatre ou huit
octets en fonction de votre système.

511
00:27:02,710 --> 00:27:06,100
Et en effet tout type de données,
et un pointeur vers les données

512
00:27:06,100 --> 00:27:12,030
taper, puisque tous les pointeurs sont juste
adresses, quatre ou huit octets.

513
00:27:12,030 --> 00:27:14,030
Donc, nous allons revenir sur cette
diagramme et nous allons conclure

514
00:27:14,030 --> 00:27:18,130
cette vidéo avec un peu d'exercice ici.

515
00:27:18,130 --> 00:27:21,600
Alors, voici le schéma nous nous sommes quittés avec
dès le début de la vidéo.

516
00:27:21,600 --> 00:27:23,110
Donc ce qui arrive maintenant, si je dis * pk = 35?

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

518
00:27:26,370 --> 00:27:30,530
Alors qu'est-ce que cela signifie quand je dis, * pk = 35?

519
00:27:30,530 --> 00:27:32,420
Prenez une seconde.

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

521
00:27:34,990 --> 00:27:39,890
Dans le contexte ici, est *
opérateur de déréférencement.

522
00:27:39,890 --> 00:27:42,110
Ainsi, lorsque le déréférencement
opérateur est utilisé,

523
00:27:42,110 --> 00:27:48,520
nous allons à l'adresse pointée
par pk, et nous changeons ce que nous trouvons.

524
00:27:48,520 --> 00:27:55,270
Donc * pk = 35 efficacement
le fait pour l'image.

525
00:27:55,270 --> 00:27:58,110
Donc, il est fondamentalement syntaxiquement
identique à d'avoir dit k = 35.

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

527
00:28:00,740 --> 00:28:01,930
>> Encore un.

528
00:28:01,930 --> 00:28:05,510
Si je dis int m, je crée
une nouvelle variable appelée m.

529
00:28:05,510 --> 00:28:08,260
Une nouvelle boîte, il est une boîte verte parce
il va tenir un nombre entier,

530
00:28:08,260 --> 00:28:09,840
et il est étiqueté m.

531
00:28:09,840 --> 00:28:14,960
Si je dis m = 4, je mets un
entier dans cette boîte.

532
00:28:14,960 --> 00:28:20,290
Si par exemple pk = & m, comment
ce changement de schéma?

533
00:28:20,290 --> 00:28:28,760
Pk = & m, vous vous souvenez de ce que le
& Opérateur fait ou est appelé?

534
00:28:28,760 --> 00:28:34,430
Rappelez-vous que certains et nom de la variable
est l'adresse d'un nom de variable.

535
00:28:34,430 --> 00:28:38,740
Donc, ce que nous disons est
pk obtient l'adresse du m.

536
00:28:38,740 --> 00:28:42,010
Et si efficacement ce qui se passe le
pk schéma est que les points ne sont plus

537
00:28:42,010 --> 00:28:46,420
à k, mais des points à m.

538
00:28:46,420 --> 00:28:48,470
>> Encore une fois les pointeurs sont très
difficile à travailler avec

539
00:28:48,470 --> 00:28:50,620
et ils prennent beaucoup de
pratique, mais parce que

540
00:28:50,620 --> 00:28:54,150
de leur capacité à vous permettre
pour transmettre des données entre les fonctions

541
00:28:54,150 --> 00:28:56,945
et ont fait ceux
modifications prennent effet,

542
00:28:56,945 --> 00:28:58,820
obtenir autour de votre tête
qui est vraiment important.

543
00:28:58,820 --> 00:29:02,590
Il est probablement le plus compliqué
sujet, nous discutons en CS50,

544
00:29:02,590 --> 00:29:05,910
mais la valeur que vous
obtenir de l'utilisation de pointeurs

545
00:29:05,910 --> 00:29:09,200
dépasse de loin les complications
qui viennent de leur apprentissage.

546
00:29:09,200 --> 00:29:12,690
Donc, je vous souhaite la meilleure des
la chance d'apprendre à propos des pointeurs.

547
00:29:12,690 --> 00:29:15,760
Je suis Doug Lloyd, cela est CS50.

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