Maîtriser les pointeurs constants et pointeurs vers 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. Quand on combine pointeurs avec le mot-clé const, on peut 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 variations principales de pointeurs constants −

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

Pointeur constant

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

Voici la syntaxe d'un pointeur constant −

type_donnees *const nom_pointeur = &variable;

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

Exemple de pointeur constant

Dans cet exemple, on déclare un pointeur constant ptr et l'initialise avec l'adresse de la variable x. Ensuite, on change la valeur de x en utilisant ptr et on affiche sa valeur.

#include <stdio.h>
int main() {
    int x = 10;
    int y = 20;
    int *const ptr = &x; // pointeur constant vers int
    printf("Valeur de x: %d\n", *ptr);
    *ptr = 15; // peut changer la valeur à l'adresse
    printf("Valeur modifiée de x: %d\n", *ptr);
    // ptr = &y; // changer l'adresse du pointeur n'est pas autorisé
    return 0;
}

Ci-dessous la sortie du programme ci-dessus, qui montre que le pointeur reste fixé sur x, mais la valeur de x peut être mise à jour.

Valeur de x: 10
Valeur modifiée de x: 15

Exemple d'erreur de pointeur constant

Voici un exemple où on déclare un pointeur constant ptr et l'initialise avec l'adresse de la variable x. Ensuite, on essaie de le faire pointer vers 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 initialisé.

#include <stdio.h>
int main() {
    int x = 10;
    int y = 20;
    int *const ptr = &x; // pointeur constant vers int
    printf("Valeur de x: %d\n", *ptr);
    // Tentative de changer le pointeur pour pointer vers y
    ptr = &y; // ne peut pas changer l'adresse d'un pointeur constant
    return 0;
}

Vous pouvez voir l'erreur ci-dessous, indiquant qu'on ne peut pas changer l'adresse d'un pointeur constant.

error: assignment of read-only variable 'ptr'

Pointeur vers constante

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

Voici la syntaxe pour pointeur vers constante −

const type_donnees *nom_pointeur = &variable;
type_donnees const *pointeur = &variable;

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

Exemple de pointeur vers constante

Dans cet exemple, on déclare un pointeur ptr qui pointe vers une valeur constante et on lui affecte l'adresse de variable a. Ensuite, on fait pointer le pointeur vers une adresse différente de variable b et on affiche sa valeur.

#include <stdio.h>
int main() {
    int a = 5;
    int b = 30;
    const int *ptr = &a; // pointeur vers int constant
    printf("Valeur de a: %d\n", *ptr);
    // *ptr = 10; // on ne peut pas modifier la valeur via le pointeur
    ptr = &b; // changement d'adresse du pointeur
    printf("Pointe maintenant vers b: %d\n", *ptr);
    return 0;
}

Voici la sortie du programme ci-dessus, montrant le même pointeur pointant vers différentes variables.

Valeur de a: 5
Pointe maintenant vers b: 30

Exemple d'erreur de pointeur vers constante

Voici un exemple où on déclare un pointeur vers constante ptr et l'initialise avec l'adresse de la variable a. Ensuite, on essaie de changer la valeur de a à travers le pointeur. Cela donnera une erreur car un pointeur vers constante ne permet pas de modifier la valeur vers laquelle il pointe.

#include <stdio.h>
int main() {
    int a = 5;
    const int *ptr = &a; // pointeur vers int constant
    printf("Valeur de a: %d\n", *ptr);
    // on ne peut pas modifier la valeur via pointeur vers constante
    *ptr = 10;
    return 0;
}

Ci-dessous vous pouvez voir la sortie, qui montre une erreur indiquant qu'on ne peut pas modifier la valeur à travers 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 changée. Les deux actions sont restreintes, donc on peut seulement lire la valeur, rien d'autre.

Voici la syntaxe pour un pointeur constant vers une constante −

const type_donnees *const nom_pointeur = &variable;

Dans cette syntaxe −

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

Exemple de pointeur constant vers constante

Dans cet exemple, on déclare un pointeur constant vers constante ptr et on lui affecte l'adresse mémoire de la variable a. On affiche ensuite la valeur de a en utilisant le pointeur.

#include <stdio.h>
int main() {
    int a = 10;
    const int *const ptr = &a; // pointeur constant vers constante
    printf("Valeur de a: %d\n", *ptr);
    // *ptr = 15; // on ne peut pas modifier la valeur
    // ptr = &b; // on ne peut pas changer l'emplacement du pointeur
    return 0;
}

Voici la sortie du programme ci-dessus −

Valeur de a: 10

Exemple d'erreur de pointeur constant vers constante

Dans cet exemple, on déclare un pointeur constant vers constante ptr et on l'initialise avec une variable a. Ensuite, on essaie de modifier la valeur à travers le pointeur et aussi de faire pointer le pointeur vers une autre variable. Les deux opérations ne sont pas autorisées et résulteront en une erreur de compilation.

#include <stdio.h>
int main() {
    int a = 10;
    int b = 20;
    const int *const ptr = &a; // pointeur constant vers constante
    printf("Valeur de a: %d\n", *ptr);
    // *ptr = 15; // on ne peut pas modifier la valeur
    // ptr = &b; // on ne peut pas changer l'adresse du pointeur
    return 0;
}

Ci-dessous vous pouvez voir la sortie montrant les erreurs −

Valeur de a: 10

Différence entre 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.

int *const p = &x;

const int *p = &x;

const int *const p = &x;

Conclusion

Dans ce chapitre, nous avons couvert les pointeurs constants et pointeurs vers constante en C. Les pointeurs constants fixent l'adresse mais permettent de changer la valeur, les pointeurs vers constante permettent de changer l'adresse mais pas la valeur, et les pointeurs constants vers constante restreignent les deux.