Maîtriser les pointeurs en C : Tutoriel pratique guidé par des experts

Maîtriser les pointeurs en C

Explorez les concepts fondamentaux des pointeurs en C, des adresses mémoire aux exemples pratiques et pièges courants. Conçu pour les développeurs souhaitant approfondir leur compréhension avec du code réel.

Les pointeurs sont une pierre angulaire de la programmation C efficace. Avant de plonger dans les pointeurs, révisons le fonctionnement des adresses mémoire en C.

---

Adresses mémoire en C

Si vous avez une variable var, l'expression &var donne l'adresse où var est stockée.

La manipulation d'adresses apparaît fréquemment, par exemple dans scanf() :

scanf("%d", &var);

Cela stocke l'entrée utilisateur directement dans l'emplacement mémoire de var. Une démo rapide :

#include <stdio.h>
int main() {
    int var = 5;
    printf("var : %d\n", var);
    printf("adresse de var : %p", &var);
    return 0;
}

Sortie

var : 5
adresse de var : 0x7fffc1a2b1c8

Note : L'adresse diffère à chaque exécution et selon le système.

---

Qu'est-ce qu'un pointeur ?

Un pointeur est une variable qui contient une adresse mémoire au lieu d'une valeur conventionnelle. En stockant des adresses, les pointeurs permettent un accès indirect aux données, permettant la gestion dynamique de la mémoire, des structures de données efficaces et un contrôle bas niveau du système.

Déclaration des pointeurs

Syntaxe de déclaration typique :

int *p;

Des variantes sont aussi courantes :

int *p1; int *p2;

L'espacement autour de l'astérisque n'affecte pas la déclaration. Cependant, attention aux déclarations séparées par des virgules :

int *p1, p2; /* p1 est un pointeur, p2 est un int */

---

Assignation d'adresses aux pointeurs

Exemple :

int *pc, c;
c = 5;
pc = &c;

Ici, c reçoit la valeur 5, et pc stocke l'adresse de c.

---

Déréférencement des pointeurs

Pour accéder à la valeur stockée à l'adresse référencée par un pointeur, utilisez l'opérateur de déréférencement * :

int *pc, c;
c = 5;
pc = &c;
printf("%d", *pc); /* Affiche 5 */

Rappelez-vous, pc est le pointeur ; *pc récupère la valeur pointée. Tenter d'assigner une adresse à *pc (ex. *pc = &c;) est invalide.

L'opérateur * est appelé opérateur de déréférencement.

---

Modification de valeurs via les pointeurs

Vous pouvez modifier les données sous-jacentes via leur pointeur :

int *pc, c;
c = 5;
pc = &c;
*pc = 1; /* c devient 1 */
printf("%d", c); /* Affiche 1 */

Plusieurs variables peuvent partager le même pointeur après réassignation :

int *pc, c, d;
c = 5;
d = -15;
pc = &c;
printf("%d", *pc); /* 5 */
pc = &d;
printf("%d", *pc); /* -15 */

---

Exemple pratique

Exécutez ce programme complet pour observer comment les valeurs des pointeurs restent constantes tandis que les données qu'ils référencent peuvent changer :

#include <stdio.h>
int main() {
    int *pc, c;
    c = 22;
    printf("Adresse de c : %p\n", &c);
    printf("Valeur de c : %d\n\n", c);
    pc = &c;
    printf("Adresse du pointeur pc : %p\n", pc);
    printf("Contenu du pointeur pc : %d\n\n", *pc);
    c = 11;
    printf("Adresse du pointeur pc : %p\n", pc);
    printf("Contenu du pointeur pc : %d\n\n", *pc);
    *pc = 2;
    printf("Adresse de c : %p\n", &c);
    printf("Valeur de c : %d\n\n", c);
    return 0;
}

Sortie

Adresse de c : 0x7fffc1a2b1c8
Valeur de c : 22
Adresse du pointeur pc : 0x7fffc1a2b1c8
Contenu du pointeur pc : 22
Adresse du pointeur pc : 0x7fffc1a2b1c8
Contenu du pointeur pc : 11
Adresse de c : 0x7fffc1a2b1c8
Valeur de c : 2

---

Explication

1. int *pc, c; – déclare un pointeur pc et un int c.
2. c = 22; – stocke 22 à l'adresse mémoire de c.
3. pc = &c; – pointe pc vers c.
4. c = 11; – met à jour la valeur via un accès direct.
5. *pc = 2; – change la valeur à travers le pointeur.

---

Erreurs courantes avec les pointeurs

Erreurs typiques : confusion entre pointeurs et valeurs :

int c, *pc; // Incorrect – assigne une valeur à un pointeur
pc = c; // Erreur
// Incorrect – tente d'assigner une adresse au pointeur déréférencé
*pc = &c; // Erreur
// Correct – assigner l'adresse au pointeur
pc = &c; // OK
// Correct – assigner une valeur à l'emplacement pointé
*pc = c; // OK

Pour les débutants, la syntaxe int *p = &c; peut être déroutante. Elle est équivalente à :

int *p;
p = &c;

L'écrire comme int* p = &c; réduit l'ambiguïté.

---

Maintenant que vous comprenez les pointeurs, vous serez prêt à explorer leur relation avec les tableaux dans le prochain tutoriel.