Bonjour et bienvenue à nouveau.
Dans cette conférence, je veux parler de la définition des pointeurs, principalement de la
syntaxe pour déclarer le rapporteur, puis de l'utilisation de l'adresse de l'opérateur pour
attribuer une adresse mémoire à un pointeur.
Donc, jusqu'à ce point, nous devrions nous faire comprendre
qu'un pointeur n'est rien de plus qu'une variable
qui pointe vers une adresse mémoire ou qui contient une adresse mémoire comme valeur.
Donc, déclarer un pointeur n'est pas la même chose que créer un pointeur normal.
Vous ne pouvez donc pas faire quelque chose comme le pointeur de pointeur.
Ce n'est pas la manière de déclarer un pointeur. La syntaxe est légèrement différente.
Vous utilisez un astérisque. Il ne suffit donc pas de dire qu'une variable est un pointeur.
Vous devez également spécifier le type de variable vers lequel pointe le pointeur.
Différents types de variables occupent différentes quantités de stockage.
Certaines opérations de pointeur nécessitent la connaissance de cette taille de stockage.
Ainsi, tout comme une variable régulière lorsque vous spécifiez un type de
données, lorsque vous créez une variable d'un type de données
pointeur, vous devez également spécifier ce type de données.
Vous pouvez déclarer un pointeur vers une variable de type int en faisant
le nombre suivant, int star ou astérisque p.
Cela va vous dire que c'est un indicateur.
L'int est le même, mais après cela, il y a l'astérisque.
L'astérisque signifie qu'un pointeur, puis vous spécifiez le
type du pointeur lui-même. Ceci est un pointeur int.
Le type de la variable avec le nom p nombres int star.
Il peut stocker l'adresse de n'importe quelle variable de type int.
Un pointeur stocke les adresses. Donc, si vous
allez stocker l'adresse d'une autre variable, cette variable
doit être définie comme un type entier.
Donc ici PI pointe vers la
variable int, char
star pc, qui pointe vers une variable de caractère, float
star pf star pg, ce sont des pointeurs vers des variables float.
C'est comme ça que vous les définissez, les types comptent.
L'espace entre l'astérisque et le nom du pointeur est facultatif.
Vous n'êtes pas obligé de mettre un espace là-bas. Vous ne pouvez pas avoir d'espace.
Ce qui finit par arriver,
et nous allons parler de déréférencer une variable, c'est que vous utilisez généralement un espace dans la déclaration,
puis lorsque vous déréférencer vous ne l'utilisez pas.
Donc toutes ces déclarations devraient contenir un espace par convention.
La valeur d'un pointeur est une adresse,
il doit donc être représenté en interne comme une image non signée sur la plupart des systèmes.
Il lui faut donc encore stocker quelque chose. Il se trouve qu'il stocke un nombre hexadécimal.
Et même s'il le stocke comme il ressemble à un entier,
ne le considérez pas comme un type entier.
Les mêmes choses que vous pouvez faire avec des entiers, vous ne pouvez pas nécessairement faire avec des pointeurs et vice versa.
Donc, même si vous essayez de l'imprimer, cela ressemblera à un nombre hexadécimal, cela ne signifie pas
que vous pouvez le traiter comme un entier.
Vous pouvez multiplier un entier par un autre, par exemple,
mais vous ne pouvez pas multiplier un pointeur par un autre.
Un pointeur est vraiment un nouveau type, ce n'est pas un type entier.
Le pourcentage p représente le format spécifié pour les pointeurs.
Je vais passer par l'affichage des différentes données pour un pointeur et nous verrons comment cela est utilisé.
Les déclarations précédentes créent la
variable mais il n'y a pas d'initialisation. Il n'y a pas de mission là-bas.
Vous voulez toujours attribuer une valeur
à un pointeur, c'est très dangereux si vous ne l'initialisez pas.
Vous souhaitez donc initialiser un pointeur lorsque vous le déclarez.
Si vous ne savez pas sur quoi l'initialiser
si ce n'est pas l'adresse d'une autre variable ou
si vous ne lui avez pas alloué de mémoire dynamiquement, vous pouvez utiliser un pointeur nul.
Vous pouvez donc initialiser un pointeur pour qu'il ne pointe vers rien.
Vous faites cela en utilisant null.
Vous dites que le nombre d'instar p est égal à null pour un pointeur vers un entier.
Null est une constante définie par la bibliothèque standard.
C'est l'équivalent d'un zéro pour un pointeur.
Cela signifie que cela ne veut rien dire.
Il est garanti de ne pointer vers aucun emplacement de la mémoire.
Donc c'est bien que vous vouliez faire cela parce que cela signifie que vous n'allez
pas faire d'erreur en faisant accidentellement un débordement de tampon ou en écrivant dans
la mémoire que vous n'êtes pas censé écrire.
En l'initialisant à cela, cela limite en fait certaines erreurs que vous pouvez faire.
Nous avons parlé de null un peu plus tôt. Nous avons parlé du caractère nul.
Ce concept est différent du pointeur nul.
Un pointeur nul signifie qu'il ne pointe vers rien et qu'il doit être initialisé avec cela.
Vous devez ajouter une directive d'inclusion pour la définition standard. h si vous souhaitez utiliser la
définition nulle ici.
L'adresse de l'opérateur. Si vous souhaitez affecter votre
pointeur à l'adresse,
vous pouvez utiliser l'opérateur d'adresse d'une variable existante.
Donc si vous voulez initialiser votre variable avec la variable add ou sub
que vous avez déjà déclarée, vous utilisez l'adresse de l'opérateur, l'esperluette.
Nous avons vu cela lorsque nous avons discuté de la fonction scanf.
Ici, nous attribuons une variable de valeur entière 99.
Nous créons un pointeur de type int et nous lui attribuons l'adresse de nombre.
Nous pouvons le faire car number est un
int et le pointeur que nous avons créé pointe également vers un int.
Donc, tout ce que nous avons à faire après l'opérateur égal est d'utiliser l'esperluette.
Et donc maintenant p numéro va contenir l'adresse du nombre.
La valeur initiale de p nombre est l'adresse du nombre de variable.
La déclaration de nombre doit précéder la déclaration du pointeur qui stocke son
adresse car vous ne
pouvez pas attribuer à un pointeur quelque chose
qui n'a pas de mémoire allouée.
Si vous essayez d'attribuer à ce numéro de pointeur, le numéro n'existe pas à moins que vous ne le fassiez après.
Afin d'attribuer une adresse à un pointeur, cette
adresse doit avoir de la mémoire allouée pour elle.
Sinon, le compilateur va se plaindre.
Attention cependant car il n'y a rien de spécial dans la déclaration d'un pointeur.
Vous pouvez déclarer des variables régulières et des pointeurs dans la même instruction.
Vous pouvez donc dire double valeur, valeur p f num.
Dans cette déclaration ici, c'est la seule deuxième
variable p val est un pointeur, les deux autres ne sont que des doubles.
C'est un peu plus explicite, un peu plus
évident dans cette déclaration. Mais que se passe-t-il si vous dites en star
pq, cela implique qu'ils sont tous les deux des pointeurs et qu'ils ne le sont pas.
Nous n'avons ici qu'un seul pointeur int qui est p, la
variable q est juste de taper int.
C'est une erreur courante de penser que p et q sont des pointeurs.
Soyez donc prudent lorsque vous déclarez un pointeur sur de nombreuses variables sur la même ligne.
C'est aussi une bonne idée d'utiliser les noms commençant par p comme noms de pointeur.
Cela vous dira que cette variable est un pointeur simplement en la regardant.
Donc, généralement, vous faites toutes vos déclarations de variables en haut d'un
programme, généralement à l'intérieur de la fonction principale.
Et lorsque vous voyez ces variables utilisées plus
tard dans le programme, vous pouvez facilement identifier les différents types de données
ou les différents types de pointeurs car ils ont p comme préfixe.
Donc, cette conférence a juste
expliqué comment vous pouvez définir, déclarer un pointeur, puis affecter une
adresse d'une variable existante à un pointeur.
Maintenant, il y a des cas où vous ne voulez pas nécessairement
attribuer à une variable existante une valeur de pointeur, peut-être que vous voulez allouer une nouvelle mémoire.
Nous en parlerons dans la conférence suivante. Mais pour le moment, nous allons garder les choses simples.
Nous allons nous concentrer sur l'utilisation de pointeurs de type
ints et de différents types faciles comme les doubles ou les flottants.
Et nous allons nous concentrer sur
l'affectation des variables existantes, l'adresse de et voir comment cela fonctionne.
Alors allons de l'avant. Merci.