Comment déréférence un pointeur C++?

La déréférence est une technique pour obtenir des données à partir d'une adresse mémoire pointée par un pointeur mutable et en les manipulant. Un mutable qui détient l'adresse d'un autre mutable est connu comme un pointeur. Le panneau (*) sera utilisé comme opérateur de déréférence. La déréférence d'un pointeur se produit chaque fois que l'opérateur (*) est en cours de rejet dans le pointeur mutable. Chaque fois qu'un pointeur est déréférencé, la valeur du mutable représentée par le pointeur est retournée. Par conséquent, nous discuterons du concept de déréférence d'un pointeur en C ++ tout en utilisant l'Ubuntu 20.04 Système. Prenons un nouveau départ par la création d'un fichier dans Ubuntu en utilisant la commande de terminal «Touch». Le fichier sera créé dans le répertoire «Accueil» racine de votre machine. Il peut être ouvert dans l'un des éditeurs que vous avez dans votre système. Nous préférons que l'éditeur «Nano» ouvre le fichier vide dans la console terminale.

$ touchez la déréférence.CC
$ Nano Dereference.CC

Exemple 01:

Nous devons commencer par inclure une bibliothèque «iostream» pour l'utilisation du flux d'entrée-sortie en C++. Le mot-clé #include est utilisé pour le faire. Ensuite, un espace de noms standard «STD» est venu pour nous permettre d'utiliser les déclarations standard de COUT et CIN. Tous les travaux ont été effectués dans la méthode principale (). Nous avons initialisé une variable entière «n» avec la valeur 1. Un pointeur de type entier «P» est utilisé pour référence à l'adresse variable «n» via l'opérateur «&». La première instruction COUT est utilisée pour afficher la valeur de la variable «n» sur le shell via le pointeur «P."La prochaine instruction COUT est utilisée pour afficher la valeur d'une variable" n "sur le shell.

#inclure
Utilisation de Namespace Std;
int main();
int n = 1;
int * p = & n;
couter<<"Address of n: "<couter<<"Value of n: "<<*p<

Vous devez compiler le nouveau code avec le compilateur G ++ nouvellement installé d'Ubuntu pour la langue C ++. À partir de maintenant, aucune erreur n'a été reconnue. Après cela, nous avons exécuté le code avec le «./un.Commande out »et obtenez l'adresse et la valeur de la variable« n »en utilisant la déréférence du pointeur.

$ g ++ déréférence.CC
$ ./un.dehors

Exemple 02:

Ayons un autre exemple un peu différent de l'exemple ci-dessus. Ainsi, l'exemple a été démarré avec le même en-tête de bibliothèque de flux d'entrée-sortie et l'espace de noms standard «STD» avec le mot-clé «Utilisation». Maintenant, la fonction Main () est démarrée avec la déclaration et l'initialisation d'une variable de chaîne «V» avec la valeur de chaîne «Linux."Après cela, nous avons déclaré un pointeur de type String pour effectuer la déréférence et le relier à la variable" V "via l'opérateur" & ". La déréférence est utilisée ici pour récupérer la valeur d'une variable via le pointeur. Le seul changement est la valeur d'une variable, je.e., chaîne au lieu d'un entier. La première clause COUT est utilisée pour afficher l'adresse d'une variable «V», et l'autre instruction COUT est utilisée pour afficher la valeur de la variable «V."Enregistrons le script et exécutons notre code.

#inclure
Utilisation de Namespace Std;
int main();
String v = "Linux";
String * p = & v;
couter<<"Address of v: "<couter<<"Value of v: "<<*p<

Le code a été compilé. Après cela, nous avons exécuté le code simple et obtenu l'adresse et la valeur d'une variable «V» lors de l'utilisation de la méthode de déréférence via le pointeur.

$ g ++ déréférence.CC
$ ./un.dehors

Exemple 03:

Ayons notre dernier mais non le moindre que le code a commencé avec l'en-tête de la bibliothèque, je.e., Iostream, et l'espace de noms standard «STD» une fois de plus. Nous avons déclaré deux variables entières dans la fonction principale (), v1 et v2. Tandis que V1 est initialisé avec la valeur «5». Les deux premières instructions COUT affichent les valeurs actuelles de V1 et V2 sur le shell, et le troisième affiche l'adresse du pointeur «P». La prochaine instruction COUT nous indique que nous allons faire de la déréférence maintenant. Ainsi, nous avons utilisé l'instruction «P = & V1» pour attribuer l'adresse d'une variable V1 au pointeur P. C'est ce qu'on appelle la déréférence. Le pointeur «P» est utilisé pour montrer l'adresse et la valeur de la variable v1 sur la coque via les clauses cout. Maintenant, nous attribuons la valeur du pointeur «p» (qui est v1) à la variable v2. L'instruction COUT affichera la valeur de V2, et le pointeur «P» est attribué avec une nouvelle valeur de 10. Les 4 dernières déclarations montrent les valeurs nouvelles ou actuelles de v1, v2 et pointeur «P."

#inclure
Utilisation de Namespace Std;
int main();
int v1 = 5, v2;
couter<<"Value of v1: "<couter<<"Value of v2: "<int * p;
couter<<"Value of pointer p: "<couter<<"************* After using p=&v1 ************** "<p =&v1;
couter<<"Address of v1: "<couter<<"Value of v1: "<<*p<v2 = * p;
couter<<"************* After using v2=*p ************** "<couter<<"Address of v2: "<* p = 10;
couter<<"************* After using *p=10 ************** "<couter<<"Address of p: "<couter<<"Value of p: "<<*p<couter<<"Value of v1: "<couter<<"Value of v2: "<

Les valeurs de début de v1 et v2 ont été affichées avec l'adresse du pointeur. Après «P = & V1», l'adresse de «P» est remplacée par celle de V1. Après «v2 = * p», une valeur de référence «p» est attribuée à v2. En utilisant «* p = 10», la valeur du pointeur «p» devient 10, et en raison de la déréférence, V1 devient également 10. Tandis que v2 et l'adresse du pointeur sont les mêmes.

$ g ++ déréférence.CC
$ ./un.dehors

Conclusion:

Donc, il s'agissait de savoir comment déréférence un pointeur en c++. Nous avons utilisé ce concept pour récupérer les valeurs d'une variable et changer ou mettre à jour la valeur. Nous espérons que nous vous fournirons avec succès un contenu simple et facile à comprendre.