Maîtriser les pointeurs constants et les pointeurs vers des constantes en C

En C, un pointeur est une variable qui stocke l'adresse mémoire d'une autre variable et le mot-clé const est utilisé pour définir une variable ou un pointeur dont la valeur ne peut pas être modifiée une fois initialisée. Lorsque nous combinons des pointeurs avec const mot-clé, nous pouvons contrôler deux choses −

• Si l'adresse stockée dans le pointeur peut changer.
• Si la valeur stockée à cette adresse peut changer.

Dans ce chapitre, nous examinerons les trois principales variantes de pointeurs constants −

• Pointeur constant
• Pointeur vers une constante
• Pointeur constant vers une constante

Pointeur constant

Un pointeur constant signifie que le pointeur lui-même est constant. Une fois qu'il est initialisé pour pointer vers un emplacement mémoire, il ne peut pas pointer vers un emplacement différent, mais la valeur stockée à cet emplacement peut toujours être modifiée.

Voici la syntaxe d'un pointeur constant −

data_type *const pointer_name = &variable;

Dans cette syntaxe, data_type est le type de données vers lequel pointe le pointeur, *const rend le pointeur lui-même constant, pointer_name est le nom du pointeur et &variable lui attribue l'adresse mémoire d'une variable.

Exemple de pointeur constant

Dans cet exemple, nous déclarons un pointeur constant ptr et initialisez-le avec l'adresse de la variable x . Ensuite, on change la valeur de x en utilisant ptr et nous imprimons sa valeur.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 20;
 int *const ptr = &x; // constant pointer to int
 printf("Value of x: %d\n", *ptr);
 *ptr = 15; // can change the value at address
 printf("Modified value of x: %d\n", *ptr);
 // ptr = &y; // changing pointer address is not allowed
 return 0;
}

Vous trouverez ci-dessous le résultat du programme ci-dessus, qui montre que le pointeur reste fixé sur x , mais la valeur de x peut être mis à jour.

Value of x: 10
Modified value of x: 15

Exemple d'erreur de pointeur constant

Voici un exemple où nous déclarons un pointeur constant ptr et initialisez-le avec l'adresse de la variable x . Ensuite, on essaie de le faire pointer sur l'adresse de la variable y . Cela donnera une erreur car un pointeur constant ne peut pas pointer vers un autre emplacement mémoire une fois qu'il a été initialisé.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 20;
 int *const ptr = &x; // constant pointer to int
 printf("Value of x: %d\n", *ptr);
 // Attempting to change the pointer to point to y
 ptr = &y; // cannot change the address of a constant pointer
 return 0;
}

Vous pouvez voir l'erreur ci-dessous , indiquant que nous ne pouvons pas changer l'adresse d'un pointeur constant.

error: assignment of read-only variable 'ptr'

Pointeur vers la constante

Un pointeur vers une constante signifie que la valeur vers laquelle il pointe ne peut pas être modifiée, mais le pointeur lui-même peut pointer vers différentes adresses mémoire (ou variables).

Voici la syntaxe du pointeur vers une constante −

const data_type *pointer_name = &variable;
data_type const *pointer = &variable;

Dans cette syntaxe, const data_type ou data_type const signifie que le pointeur pointe vers une valeur constante, pointer_name est le nom du pointeur, et &variable lui attribue l'adresse d'une variable.

Exemple de pointeur vers une constante

Dans cet exemple, nous déclarons un pointeur ptr qui pointe vers une valeur constante et lui attribue l'adresse de la variable a . Ensuite, nous faisons pointer le pointeur vers une adresse différente de la variable b et imprimez sa valeur.

#include <stdio.h>
int main() {
 int a = 5;
 int b = 30;
 const int *ptr = &a; // pointer to constant int
 printf("Value of a: %d\n", *ptr);
 // *ptr = 10; //we cannot modify value through pointer
 ptr = &b; // canging pointer address
 printf("Now pointing to b: %d\n", *ptr);
 return 0;
}

Voici le résultat du programme ci-dessus, affichant le même pointeur pointant vers différentes variables.

Value of a: 5
Now pointing to b: 30

Exemple de pointeur vers une erreur constante

Voici un exemple où nous déclarons un pointeur vers la constante ptr et initialisez-le avec l'adresse de la variablea . Ensuite, nous essayons de changer la valeur de a grâce au pointeur. Cela donnera une erreur car un pointeur sur constante ne permet pas de modifier la valeur sur laquelle il pointe.

#include <stdio.h>
int main() {
 int a = 5;
 const int *ptr = &a; // pointer to constant int
 printf("Value of a: %d\n", *ptr);
 // we cnnot modify value through pointer to constant
 *ptr = 10; 
 return 0;
}

Ci-dessous, vous pouvez voir le résultat , qui affiche une erreur indiquant que nous ne pouvons pas modifier la valeur via un pointeur vers constante.

error: assignment of read-only location '*ptr'

Pointeur constant vers constante

Un pointeur constant vers une constante est un pointeur qui ne peut pas changer son adresse mémoire, et la valeur stockée à cette adresse mémoire ne peut pas non plus être modifiée. Les deux actions sont restreintes, nous ne pouvons donc lire que la valeur, rien d'autre.

Voici la syntaxe d'un pointeur constant vers une constante −

const data_type *const pointer_name = &variable;

Dans cette syntaxe −

• const data_type indique que la valeur à l'emplacement mémoire ne peut pas être modifiée via le pointeur.
• *const nom_pointeur signifie que le pointeur lui-même ne peut pointer vers une autre adresse mémoire après l'initialisation.
• &variable attribue le pointeur sur l'adresse mémoire de la variable.

Exemple de pointeur de constante vers une constante

Dans cet exemple, nous déclarons un pointeur constant vers la constante ptr et attribuez-lui l'adresse mémoire de la variable a . On imprime ensuite la valeur de a en utilisant le pointeur.

#include <stdio.h>
int main() {
 int a = 10;
 const int *const ptr = &a; // constant pointer to constant
 printf("Value of a: %d\n", *ptr);
 // *ptr = 15; // we cannot modify value
 // ptr = &b; // we annot change pointer location
 return 0;
}

Voici le résultat du programme ci-dessus −

Value of a: 10

Exemple de pointeur constant vers une erreur constante

Dans cet exemple, nous déclarons un pointeur constant vers constant ptr et initialisez-le avec une variable a . Ensuite, nous essayons de modifier la valeur via le pointeur et essayons également de faire pointer le pointeur vers une autre variable. Les deux opérations ne sont pas autorisées et entraîneront une erreur du compilateur .

#include <stdio.h>
int main() {
 int a = 10;
 int b = 20;
 const int *const ptr = &a; // constant pointer to constant
 printf("Value of a: %d\n", *ptr);
 // *ptr = 15; // we cnnot modify value
 // ptr = &b; // we cannot change pointer address
 return 0;
}

Ci-dessous, vous pouvez voir le résultat montrant les erreurs −

Value of a: 10

Différence entre les types de pointeurs constants

Le tableau suivant montre les différences entre un pointeur constant, un pointeur vers constante et un pointeur constant vers constante.

Variante Définition Peut-on changer d'adresse ? Peut-il changer la valeur ? Exemple de syntaxe Pointeur constantUn pointeur dont l'adresse est fixe, mais la valeur à cette adresse peut être modifiée.NonOui

int *const p = &x;

Pointeur vers ConstantUn pointeur qui peut pointer vers différentes adresses, mais ne peut pas modifier la valeur à l'emplacement pointé.OuiNon

const int *p = &x;

Constant Pointeur vers ConstantUn pointeur dont l'adresse est fixe et la valeur à cette adresse ne peut pas être modifiée.NoNo

const int *const p = &x;

Conclusion

Dans ce chapitre, nous avons couvert les pointeurs constants et les pointeurs vers une constante en C. Pointeurs constants corrige l'adresse mais autorise la modification de la valeur, pointeurs vers une constante permettre de changer l'adresse mais pas la valeur, et des pointeurs constants vers constants restreindre les deux.