Qu'est-ce qu'un pointeur const en c++?

Le mot «const» i.e., constant, signifie «aucun changement» en toute valeur variable dans les langages de programmation. Le pointeur de la programmation fait référence à une variable qui pointe vers une adresse spécifique, probablement d'une adresse variable. Le pointeur constant sera celui qui pointera toujours dans le sens de la même adresse. Cela signifie que l'adresse d'une variable à laquelle le pointeur pointe ne peut pas être mise à jour jusqu'à présent. Par conséquent, dans cet article, nous verrons ce qu'est un pointeur constant en C ++ et comment il fonctionne. Alors, faisons un bon départ.

Exemple 01: pointeur

Ayons notre premier exemple pour montrer comment fonctionne un pointeur constant dans la coquille de terminal. Commencez par ouvrir l'application de la console Shell dans votre distribution Linux. Vous pouvez utiliser le raccourci «Ctrl + Alt + T» à Ubuntu 20.04 Desktop pour le faire. Juste après avoir ouvert le shell, ayons une création d'un nouveau fichier C ++. Ainsi, la requête «Touch» sera utilisée ici jusqu'à présent. Mentionnez le nom d'un fichier dans l'instruction «Touch» que vous souhaitez créer avec le «.Extension CC ”.

Après avoir créé un fichier, vous pouvez facilement ouvrir votre fichier à partir du dossier domestique de votre système Linux. Pour le modifier et le mettre à jour dans le shell, vous devez utiliser certains modules d'éditeur. Si vous n'en avez pas, essayez d'installer l'éditeur «GNU Nano» ou l'éditeur VIM. Comme indiqué dans l'image ci-dessous, nous avons utilisé l'éditeur «Nano» pour ouvrir le «const« const récemment fait.Commande cc ”dans le shell.

$ Touch const const.CC
$ nano const.CC

Le fichier sera ouvert vide dans l'éditeur GNU Nano. Dans notre premier exemple, nous verrons d'abord le fonctionnement d'une variable de pointeur simple pour comprendre plus de pointeurs constants. Alors, ajoutez les bibliothèques requises, je.e., En-tête de flux standard-sortie et en-tête STDIO, en utilisant le mot-clé «Inclure» avec un signe de hachage au début. Vous devez définir l'espace de noms standard avec le mot «utilisation». Après cela, la méthode principale () sera lancée car nous devons faire tout ce qui s'y trouve. De plus, la compilation et l'exécution commencent à partir d'ici. Initialiser une variable entière «A» avec une valeur entière qui lui est attribuée, je.e., 98.

Le flux «cout» est utilisé pour afficher la valeur de la variable «A». Après cela, un pointeur de type entier «PTR» a été initialisé, pointant vers l'adresse de la variable entière «A». En raison de ce pointeur, nous pouvons modifier la variable «A» car les deux ne sont pas constants pour le moment. Après cela, le pointeur «PTR» a été affiché, je.e., Adresse de la variable «A». Dans la ligne suivante, nous avons utilisé l'opérateur d'incrément pour incrémenter la valeur de la valeur d'adresse du pointeur «PTR» car il pointe vers l'adresse de la variable «A».

Le pointeur «PTR» a de nouveau été affiché à l'aide du flux «cout». Le flux «cout» suivant est utilisé pour afficher à nouveau la valeur «A» variable, je.e., incrémenté. Le code se termine ici. Enregistrez le code nouvellement créé et laissez l'éditeur GNU Nano en utilisant le «Ctrl + S» et «Ctrl + X» du clavier.

Compilons d'abord ce code C ++ nouvellement fabriqué. Utilisez le compilateur «G ++» pour le faire. Si vous n'en avez pas déjà installé dans votre système, essayez de le configurer d'abord. Une fois la compilation avec succès, faites fonctionner votre code en utilisant le «./un.Commande. Vous verrez, lorsque la première instruction «cout» a été exécutée, elle affichera la valeur d'une variable «A» I.e., 98.

Lors de l'exécution d'un deuxième et troisième flux de «cout», il a affiché la même adresse enregistrée dans le pointeur «PTR» qui pointe vers la variable «A». L'incrément a été exécuté sur la valeur d'une variable «A» via le pointeur «PTR». Ainsi, lors de l'exécution d'une 4ème instruction «cout», la valeur d'incrément d'une variable «A» a été affichée sur l'écran terminal.

$ g ++ const.CC
$ ./un.dehors

Exemple 02: pointeur constant vers entier

Il s'agissait du simple pointeur pointant vers une adresse variable. Maintenant, jetons un coup d'œil à l'exemple d'utilisation d'un pointeur de type constant pour pointer vers une variable. Comme nous le savons, le mot constant signifie «pas de changement» lorsqu'il est appliqué à une variable. Nous allons donc l'utiliser comme variable de pointeur pour voir comment un pointeur constant se comportera dans certaines situations. Ainsi, nous avons ouvert le même fichier avec l'éditeur «GNU Nano» et mis à jour son code un peu.

La ligne d'initialisation d'un pointeur a été mise à jour avec le mot «const» avec le signe «*» à son début. Assurez-vous de l'utiliser après le type de données «int» dans l'initialisation d'un pointeur «CPTR». Ensuite, nous avons utilisé l'instruction «cout» pour incrémenter la valeur de la variable «A» car le pointeur «cptr» pointe vers lui. La toute prochaine instruction COUT a été initialisée pour incrémenter le pointeur «CPTR» lui-même. Cela entraînera l'erreur de compilation car le «CPTR» lui-même est constant. Le reste du code est resté inchangé et enregistré en utilisant le «Ctrl + S».

Lorsque nous avons compilé le code du const.Fichier CC, il nous donne l'erreur à la ligne 10. Comme le pointeur était constant, l'erreur indique que le «CPTR» est en lecture seule et ne peut pas être incrémenté comme prévu.

$ g ++ const.CC

Lorsque nous avons compilé le code, la variable «A» a été affichée avec sa valeur d'origine et mise à jour. Alors que l'adresse du pointeur «CPTR» a été la même et non modifiée.

$ ./un.dehors

Exemple 03: pointeur constant vers un entier constant

Dans cet exemple, nous prendrons à la fois le pointeur et l'entier que cela pointe comme constant. Cela signifie que les deux ne peuvent pas être mis à jour. Alors, ouvrez le même fichier pour le rendre à jour. Nous avons initialisé un entier de type constant «B» avec une valeur de 13. Cette variable a été affichée via l'instruction «cout». Ensuite, nous avons initialisé un pointeur de type constant «cptrc» pointant vers la variable constante «b» avec le signe «&». La clause COUT est utilisée pour afficher le pointeur «CPTRC». Après cela, la valeur «B» variable constante sera incrémentée par la variable constante «CPTRC».

Dans la prochaine ligne consécutive, le pointeur «CPTRC» lui-même a été incrémenté. Les deux lignes d'incrément afficheront l'erreur à la compilation. Les deux dernières instructions COUT sont utilisées pour afficher la valeur de la valeur variable constante et du pointeur constant.

Après avoir compilé le code, nous avons une erreur sur les deux lignes d'incrément, je.e., 9 et 10.

$ g ++ const.CC

Ainsi, lors de l'exécution du code à l'aide d'un «./un.instruction out », nous avons obtenu l'ancien résultat du dernier exemple, et le code n'a pas été exécuté.

$ ./un.dehors

Conclusion:

Enfin, nous avons fait le fonctionnement de variables constantes en C++. Nous avons discuté des exemples de pointeurs simples, de pointeurs constants vers les entiers et de pointeurs constants vers des entiers constants pour améliorer le niveau de compréhension des pointeurs. Nous avons utilisé la déclaration «cout», les opérateurs d'incrément et & Opérateurs pour atteindre cet objectif. Nous espérons que cet article sera tout aussi bénéfique pour les utilisateurs nouveaux et déjà expérimentés de C ++ dans l'Ubuntu 20.04 Système.