Bonjour et bienvenue à nouveau.
Dans cette conférence, je veux parler de l'accès à la valeur
vers laquelle pointe un
pointeur. Souvenez-vous donc des pointeurs, ils stockent les adresses mémoire.
Cette adresse mémoire contient en fait une valeur de quelque part.
Et donc les pointeurs pointent vers cette adresse mémoire. Je veux connaître la valeur de
ce que cela indique.
Parce que je voudrais simplement imprimer la valeur d'un pointeur qui serait une adresse, mais que je veux obtenir l'adresse, je
veux obtenir la valeur de l'adresse.
Ainsi, vous pouvez accéder à la valeur d'une adresse vers laquelle pointe un
pointeur à l'aide de l'opérateur d'indirection. L'opérateur d'indirection est l'astérisque.
Nous avons donc appris à utiliser l'astérisque pour déclarer un
pointeur, nous allons également utiliser l'astérisque pour trouver la valeur vers laquelle pointe un pointeur.
Il est donc également appelé opérateur de déréférence car
vous l'utilisez pour déréférencer un pointeur.
Ainsi, par exemple, si vous avez un nombre égal à 15, vous déclarez
un pointeur de type int, pointant vers un int et vous lui attribuez l'adresse du nombre à l'aide de l'esperluette.
Maintenant, comment obtenez-vous la valeur sur laquelle pointe le pointeur.
Vous pouvez dé-référencer.
Si vous pouvez en gros la valeur sur laquelle pointe le
pointeur, la valeur est 15 car elle pointe vers l'adresse du nombre qui est 15.
Ainsi, la variable pointeur contient l'adresse du numéro de variable.
Vous pouvez l'utiliser dans une expression pour calculer une nouvelle valeur pour le résultat.
Supposons que nous voulions que le résultat soit égal à la
valeur vers laquelle le pointeur pointe plus cinq. Vous utiliseriez l'astérisque pour
cela avant le nom du pointeur.
Et donc ce que cela ferait, c'est que cela indiquerait essentiellement sur
quoi pointe la variable du pointeur, cela indique 15 ajouter cinq.
C'est l'adresse que
le pointeur indique quelle est la valeur de cette adresse.
Ainsi, l'astérisque de l'opérateur d'indirection que
vous devriez remarquer est également le symbole utilisé pour la multiplication, et il est également utilisé
lorsque vous déclarez des types de pointeurs. Cela peut donc devenir très déroutant.
Comment savez-vous nécessairement ce qui se passe ou comment fonctionne le compilateur.
Eh bien, tout est question de contexte. Cela dépend du moment où vous utilisez cet astérisque et de l'endroit où vous l'utilisez.
Si vous utilisez l'astérisque lorsque vous déclarez un pointeur juste après
le type
du pointeur, alors il utilise évidemment une déclaration.
Si vous utilisez l'astérisque entre deux nombres,
il est utilisé pour la multiplication. Et s'il est utilisé juste
avant le nom du pointeur sur le côté droit, par exemple, ou sur le côté
gauche, il va affecter une valeur ou accéder à une valeur.
C'est donc une question de contexte lorsque vous utilisez cet
opérateur d'indirection.
Et c'est comme ça que ça marche.
C'est ainsi que le compilateur va l'interpréter.
Chaque fois que vous le voyez dans cet exemple, un pointeur
en étoile et que vous n'avez pas de type de données auparavant ou que vous
n'avez pas deux nombres de chaque côté, vous savez que c'est un pointeur d'indirection, le déréférencement.
Alors passons par un exemple. Voici un autre
exemple où nous allons créer un nombre
d'entiers égal à 10. Nous allons également créer un entier de type nommé x une autre variable.
Nous initialisons count à 10, x est initialisé à rien.
Nous créons ensuite un pointeur int. Nous savons que c'est un pointeur
int car nous avons l'astérisque après le type
de données, puis nous l'avons nommé pointeur int.
Nous allons maintenant attribuer à ce pointeur int l'adresse de count.
Parce que rappelez-vous, les pointeurs ne contiennent que des adresses comme valeurs, mais
ils pointent également vers quelque chose.
Nous pouvons donc affecter la variable x quel que soit le pointeur int pointé,
quelle est la valeur de l'adresse contenue dans le pointeur.
Donc, x va afficher 10.
dix. Donc, si nous allons de l'avant et affichons cela
en disant count pour cent d ird x pour cent ird, count est égal à 10, x va être égal à 10.
C'est ainsi que vous pouvez déréférencer un pointeur et obtenir la valeur qui. Il pointe vers si vous
souhaitez afficher les valeurs du pointeur car rappelez-vous qu'un pointeur
a une valeur en mémoire, c'est
juste une adresse. Alors que faire
si vous souhaitez afficher la valeur des pointeurs,
représentée par un entier hexadécimal et une adresse?
Eh bien, vous pouvez utiliser le spécificateur de format percent p. Nous en avons déjà parlé.
Cela produira une valeur de pointeur sous forme d'adresse mémoire sous forme hexadécimale.
Donc, si nous devions faire quelque chose
comme ceci où, nous déclarons notre
nombre, nous déclarons notre pointeur, nous l'initialisons à null parce que c'est une bonne pratique que nous voulons toujours
faire chaque fois que vous n'assignez pas quelque chose dans une déclaration au pointeur, faites assurez-vous de
l'initialiser à null.
Nous attribuons ensuite notre variable numérique 10.
Et puis nous attribuons notre pointeur à l'adresse du numéro.
Ainsi, la valeur du nombre p sera en fait une adresse.
une adresse. Donc, si nous essayions de l'imprimer, nous utiliserions le pourcentage p et ce serait la valeur de l'adresse.
Si nous voulions imprimer ce sur quoi il pointe, nous
devrons le dé-référencer à l'aide de l'opérateur d'indirection.
Mais lorsque vous imprimez l'adresse, elle l'imprime en hexadécimal et
les pointeurs occupent 8 octets en mémoire
et les adresses ont 16
chiffres hexadécimaux. Alors comment ça marche?
Eh bien, cela dépend si votre machine prend en charge les adresses 64 bits ou 32 bits.
Si votre ordinateur dispose d'un système d'exploitation 64 bits,
vous verrez alors 16 chiffres hexadécimaux.
Si votre ordinateur ou votre système d'exploitation n'a
qu'un adressage 32 bits, vous verrez l'hexadécimal représenté par 8 chiffres hexadécimaux.
Et maintenant, que faire si vous souhaitez afficher une adresse.
Vous pouvez dire quelle est la différence car le pointeur a une valeur.
Mais vous pouvez également afficher l'adresse avec l'adresse de l'opérateur.
Donc, dans cet exemple, nous voulons afficher l'adresse du numéro.
Le nombre n'est pas un pointeur. Le nombre n'est qu'un entier.
Si nous voulons obtenir l'adresse de cela, nous utilisons l'esperluette.
Si nous voulons afficher l'adresse de celui-ci, il vous suffit d'utiliser à nouveau le pourcentage p.
Vous appliquez simplement l'esperluette.
Donc, si nous fournissons l'esperluette avec la variable pointeur, nous afficherons
en fait l'adresse de ce pointeur,
pas la valeur du point. N'oubliez pas que l'adresse du pointeur est une adresse en mémoire.
La valeur du pointeur est une adresse vers laquelle il pointe.
Et la valeur vers laquelle il pointe se trouve ailleurs dans la mémoire.
Souvenez-vous donc de cette illustration où
nous avons montré le fonctionnement des pointeurs.
Un pointeur, lorsque vous le déclarez, crée de la mémoire pour ce
pointeur, 8 octets.
La valeur de ce pointeur est une adresse.
Et puis, tout ce que pointe
ce pointeur est une valeur, généralement du type que vous avez fourni.
Mais rappelez-vous qu'il y a vraiment trois parties.
Si vous souhaitez imprimer l'adresse des nombres p, vous utiliserez à nouveau l'esperluette.
Ce serait l'adresse du pointeur réel.
Et vous devrez utiliser l'étoile du vide pour contourner un avertissement.
Alors rappelez-vous, un pointeur lui-même a une adresse, comme toute autre variable, il
est alloué lorsque vous le déclarez.
Vous utilisez le pourcentage p comme spécificateur de conversion pour afficher les adresses.
Vous utilisez l'esperluette et l'adresse de l'opérateur pour référencer l'adresse occupée
par la variable de nombre p.
C'est l'adresse du pointeur. Là encore, le pointeur a
une valeur d'adresse.
Le cast a void est d'empêcher un avertissement du compilateur, en particulier
la spécification de pourcentage p s'attend à ce que la valeur soit une sorte de type de pointeur.
Mais le type de nombre esperluette est un pointeur vers un pointeur de celui-ci.
Et vous devez donc le lancer.
Affichage du nombre d'octets utilisé par un pointeur.
Une autre façon d'obtenir des informations sur un pointeur.
Ici, vous pouvez utiliser l'opérateur sizeof. Nous avons découvert l'opérateur sizeof
pour afficher différents octets de types de données. Vous pouvez faire la même chose avec un pointeur.
Sur une machine que j'exécute, cela occupera 8 octets.
Et l'adresse de la machine a 64 bits car
il s'agit d'un système d'exploitation 64 bits.
Et vous pouvez recevoir un avertissement du compilateur lors de l'utilisation de sizeof de cette façon,
sizet est un type entier défini par l'implémentation.
Pour éviter l'avertissement, vous pouvez convertir l'argument en un type int comme celui-ci.
Donc, ce que vous feriez, c'est de dire p taille du nombre, pour cent d octets.
Et vous diriez int, convertissez-le en un pouce de taille p.
Cela va vous donner la taille du pointeur en mémoire, la taille du pointeur de cette adresse,
qui, encore une fois, est de huit octets sur la plupart des systèmes.
Parce que ça contient juste une adresse.
Un autre exemple ici. Cela va afficher un certain nombre de choses.
Et nous allons exécuter cet exemple pour afficher la sortie.
Mais juste avant de l'exécuter, je veux décrire un peu ce qui se passe ici. Nous avons un nombre qui a été déclaré.
Nous avons un pointeur qui a initialisé la valeur null.
Nous fixons la valeur du nombre à 10.
Et puis ce que nous voulons faire, c'est que
nous voulons imprimer l'adresse du nombre entier, et nous voulons imprimer la valeur du nombre,
très simple, en utilisant l'adresse de l'opérateur et ensuite juste la variable.
Lorsque nous faisons l'adresse de l'opérateur, nous faisons le pourcentage p.
Nous allons ensuite attribuer l'adresse du numéro à notre pointeur.
Nous allons ensuite imprimer des informations de pointeur.
Nous voulons afficher l'adresse du pointeur lui-même.
Nous pouvons simplement utiliser le pourcentage p, le nombre de l'esperluette étoile vide.
Nous voulons voir combien d'octets ce pointeur a en mémoire. On peut dire sizeof.
Nous voulons voir la valeur réelle du pointeur,
qui est une adresse. Nous pouvons simplement dire le nombre p
sans aucune information supplémentaire, puis nous utilisons le pourcentage p.
Si nous voulons voir la valeur vers laquelle
pointe le pointeur, la valeur à l'adresse, alors nous
faisons le nombre étoile p, nous utilisons l'opérateur d'indirection.
Et nous savons que le nombre p pointe vers un in donc nous pouvons dire pour cent d.
Jetons donc un coup d'œil à cet exemple dans des blocs de code pour voir comment il est réellement affiché.
Ce que nous allons voir, ce sont des nombres
hexadécimaux pour les adresses chaque fois que nous affichons des adresses et nous allons voir des valeurs dans d'autres cas.
Cela devrait donc vous paraître familier. Ceci est juste un
programme qui vous montre comment accéder aux différentes parties d'un pointeur.
Encore une fois, nous avons un type de données de nombre régulier int, et
nous avons notre pointeur. Nous l'initialisons à null.
Nous allons d'abord afficher notre numéro, qui est 10. Donc, cela va afficher l'adresse du nombre,
puis il va afficher la valeur du nombre sur les lignes 10 et 11.
Nous allons ensuite attribuer notre pointeur, l'adresse du numéro.
Si nous voulons voir l'adresse réelle de notre pointeur, nous utilisons simplement l'esperluette, l'adresse de
l'opérateur, et nous la convertissons en étoile vide.
Nous utilisons le pourcentage p.
Si nous voulons voir combien d'octets le pointeur est en mémoire, nous faisons percent d sizeof.
Si nous voulons voir l'adresse la valeur de peanut le pointeur, nous faisons pour cent p
et nous disons simplement p nombre, car le nombre p est une adresse.
Si nous voulons voir vers quoi pointe le pointeur avec la valeur
de l'adresse qui est dans la valeur du pointeur, nous disons
simplement le nombre d'astérisque p, nous le déréférencons, l'opérateur d'indirection.
Alors allons-y.
Quand je lance ceci, vous verrez les deux premières choses
qui sont imprimées, l'adresse des nombres qui
est sur la ligne six, et c'est un nombre hexadécimal, 0060ff0c.
Et cela exécute en fait un programme 32 bits, donc vous voyez que ce n'est que
8 bits.
la variable numérique qui est 10.
Nous imprimons ensuite l'adresse du pointeur réel vers la mémoire allouée.
C'est une adresse différente du numéro.
Parce que c'est l'adresse allouée pour le pointeur.
La taille du numéro du pointeur est de 4 octets, ce
qui signifie qu'il s'agit d'un adressage 32 bits.
La valeur du pointeur, qui
est l'adresse du nombre, doit être la même et c'est 0060ff0c.
Et vous voyez que vous pouvez réellement obtenir l'adresse
numérique en utilisant simplement le nom, le pointeur avec le pourcentage p.
Nous avons vu la taille de l'opérateur 4 octets.
Si vous voulez obtenir la valeur vers laquelle pointe le nombre p
qui est 10, vous devez la dé-référencer à l'aide de l'opérateur d'indirection et vous voyez qu'elle est imprimée 10.
Mais vous voyez que vous utilisez le pourcentage p chaque fois
que vous affichez des adresses, utilisez le pourcentage e lorsque vous affichez les valeurs du pointeur
entier ou le nombre d'octets.
Voici donc la syntaxe de base pour accéder aux valeurs de pointeur.
Adresse du pointeur, esperluette, valeur vers
laquelle pointe le point, juste le nom de la
variable et la valeur du pointeur lui-même est juste le nom de la variable,
puis la valeur que le pointeur pointe pour utiliser l'opérateur d'indirection.
Merci. J'espère que cela t'aides. Étudiez ceci, parcourez ceci.