Nous savons que la variable pointeur peut stocker l'adresse mémoire en langage C et dans cet article, nous apprendrons comment utiliser ce pointeur pour accéder aux données stockées dans l'emplacement mémoire pointé par le pointeur.
Qu'est-ce qu'un pointeur ?
Tout d’abord, nous révisons ce qu’est un pointeur. Un pointeur est une variable qui stocke l'adresse mémoire d'une autre variable. Le pointeur nous aide à manipuler les données dans l'adresse mémoire pointée par le pointeur. De plus, plusieurs pointeurs peuvent pointer vers la même mémoire.
Considérons l'exemple suivant,
opérateur ternaire java
int num = 10; int *ptr; ptr = #>
Nous avons stocké l'adresse du sur une variable dans le ptr pointeur, mais maintenant, comment accéder à la valeur stockée dans la mémoire à l'adresse pointée par ptr ? Ici, le déréférencement entre en jeu.
Pointeur de déréférencement en C
L'accès ou la manipulation du contenu stocké dans l'adresse mémoire pointée par le pointeur à l'aide de l'opérateur de déréférencement ou d'indirection (*) est appelé déréférencement du pointeur.
Pointeur de déréférencement en C
Syntaxe pour déréférencer un pointeur
Nous utilisons l'opérateur d'indirection (*) comme préfixe pour déréférencer un pointeur :
* ( pointer_name )>
Pour modifier les données stockées dans la mémoire, nous utilisons
* ( pointer_name ) = new_value;>
Il est à noter que la new_value doit être du même type que la précédente.
Considérez les exemples ci-dessus où ptr pointe vers si, t Le contenu de l'adresse mémoire est accessible à l'opérateur de déréférencement *. Maintenant, le *ptr récupérera le contenu stocké à l'adresse qui est 10.
L'adresse et les valeurs de la mémoire num et ptr ressembleront à ceci.
| Variable | Adresse mémoire | Valeur |
|---|---|---|
| nombre = 10 | 202020 | dix |
| 202021 | ||
| 202022 | ||
| 202023 | ||
| ptr = &numéro | 202024 – 202032 | 202020 |
Note: Nous avons supposé que l'architecture dans l'exemple ci-dessus est adressable par octet, c'est-à-dire que l'unité minimale qui a une adresse distincte est un octet.
Exemples de déréférencement de pointeur
Exemple 1:
Utiliser un pointeur pour accéder et modifier la valeur d'une variable entière.
C
commande d'installation npm
// C Program to illustrate the dereferencing of pointer> #include> int> main()> {> >// Declare integer variable number> >int> num = 10;> >// Declare pointer to store address of number> >int>* ptr = #> >// Print the value of number> >printf>(>'Value of num = %d
'>, num);> >// Print Address of the number using & operator> >printf>(>'Address of num = %d
'>, &num);> >// Print Address stored in the pointer> >printf>(>'Address stored in the ptr = %p
'>, ptr);> >printf>(>'Dereference content in ptr using *ptr
'>);> >// Access the content using * operator> >printf>(>'Value of *ptr = %d
'>, *ptr);> >printf>(>'Now, *ptr is same as number
'>);> >printf>(>'Modify the value using pointer to 6
'>);> >// Modify the content in the address to 6 using pointer> >*ptr = 6;> >// Print the modified value using pointer> >printf>(>'Value of *ptr = %d
'>, *ptr);> >// Print the modified value using variable> >printf>(>'Value of number = %d
'>, num);> >return> 0;> }> |
>
>
lancer la gestion des exceptions en Java
Sortir
Value of num = 10 Address of num = 0x7ffe47d51b4c Address stored in the ptr = 0x7ffe47d51b4c Dereference content in ptr using *ptr Value of *ptr = 10 Now, *ptr is same as number Modify the value using pointer to 6 Value of *ptr = 6 Value of number = 6>
Exemple 2 : déréférencement d'un double pointeur
Les doubles pointeurs peuvent également être déréférencés en utilisant la même logique mais vous devrez utiliser l'opérateur d'indirection deux fois : une pour se déplacer vers le pointeur vers lequel pointe le double pointeur et l'autre pour accéder à la valeur réelle.
C
// C program to dereference double pointer> #include> int> main()> {> >int> var = 10;> >int>* ptr = &var;> >// double pointer> >int>** dptr = &ptr;> >// dereferencing the double pointer> >printf>(>'Accesing value from double pointer using '> >'**dptr: %d'>,> >**dptr);> >return> 0;> }> |
Madhubala
>
>Sortir
Accesing value from double pointer using **dptr: 10>
Juste comme ça, nous pouvons déréférencer des pointeurs de n’importe quel niveau.
Comment fonctionne le déréférencement ?
Chaque fois que nous demandons au compilateur de déréférencer un pointeur, il fait trois choses :
- Il recherche d'abord l'adresse stockée dans le pointeur.
- Il recherche ensuite le type de pointeur pour en déduire la quantité de mémoire à lire. Par exemple, 4 byes pour int, 1 byte pour char, etc. C'est aussi la principale raison pour laquelle nous devons spécifier le type de pointeur dans la déclaration même si la taille de chaque pointeur d'un système est la même.
- Enfin, il lit la mémoire et renvoie les données stockées.
Note: Du raisonnement ci-dessus, nous pouvons également déduire que nous ne pouvons pas déréférencer le pointeur void car la taille des données vers lesquelles il pointe est inconnue. Nous devons donc transtyper le pointeur void pour le déréférencer.