Les pointeurs constituent le cœur battant, la puissance suprême et la spécificité la plus emblématique du langage C. C'est grâce aux pointeurs que le C permet de manipuler directement la mémoire physique de l'ordinateur, d'écrire des systèmes d'exploitation ultra-rapides, de concevoir des structures de données dynamiques (listes chaînées, arbres, graphes) et d'optimiser les performances en évitant des copies de données massives.

Si les pointeurs effraient souvent les débutants, leur concept est en réalité d'une simplicité limpide dès lors que l'on comprend comment la mémoire d'un ordinateur est organisée.

---

1. La mémoire vive (RAM) : Une suite d'octets numérotés

Imaginez la mémoire RAM de votre ordinateur comme une immense rue bordée de millions de boîtes aux lettres alignées. Chaque boîte postale possède : 1. Une adresse physique unique : un numéro séquentiel (exprimé en hexadécimal, ex: 0x7ffee4b589ac). 2. Un contenu : la valeur qui y est déposée (un nombre, un caractère, des bits).

flowchart LR
    subgraph RAM [Mémoire RAM Physique]
        B1["Case 0x1000\nContenu : 42\n(Variable 'age')"]
        B2["Case 0x1004\nContenu : 0x1000\n(Pointeur 'ptr')"]
    end
    B2 -->|Pointe vers l'adresse 0x1000| B1

Une variable ordinaire (comme int age = 42;) associe un nom facile à retenir (age) à une adresse mémoire précise (par exemple 0x1000).

---

2. Qu'est-ce qu'un pointeur ?

[!NOTE] Un pointeur est tout simplement une variable dont la valeur est l'adresse mémoire d'une autre variable.

Pour manipuler les pointeurs, vous ne devez maîtriser que deux opérateurs essentiels :

1. & (Opérateur d'adresse) : Placé devant une variable, il extrait son adresse mémoire (« Où te trouves-tu dans la RAM ? »).
2. * (Opérateur de déréférencement / indirection) : Placé devant un pointeur, il accède à la valeur stockée à l'adresse pointée (« Quel est le contenu de la case mémoire dont tu as l'adresse ? »).

---

3. Déclaration, Initialisation et Utilisation

Pour déclarer un pointeur, on place une astérisque * entre le type de la cible et le nom du pointeur :

manipulation_pointeur.c

#include <stdio.h>

int main(void)
{
    int note = 15;        // Une variable entière classique
    int *ptrNote = NULL;  // Déclaration d'un pointeur vers un entier, initialisé à NULL

    // 1. Affectation : on stocke l'adresse de 'note' dans 'ptrNote'
    ptrNote = &note;

    printf("Valeur de 'note'               : %d\n", note);
    printf("Adresse memoire de 'note' (&note): %p\n", (void*)&note);
    printf("Valeur stockee dans 'ptrNote'   : %p\n", (void*)ptrNote);
    printf("Valeur pointee par '*ptrNote'   : %d\n", *ptrNote);

    // 2. Modification par indirection : on modifie 'note' via le pointeur !
    *ptrNote = 19;

    printf("\nApres l'instruction *ptrNote = 19 :\n");
    printf("Nouvelle valeur de 'note'       : %d\n", note); // Vaut maintenant 19 !

    return 0;
}

Sortie console

Valeur de 'note'               : 15
Adresse memoire de 'note' (&note): 0x7ffd5e2a44cc
Valeur stockee dans 'ptrNote'   : 0x7ffd5e2a44cc
Valeur pointee par '*ptrNote'   : 15

Apres l'instruction *ptrNote = 19 :
Nouvelle valeur de 'note'       : 19

[!WARNING] Initialisez TOUJOURS vos pointeurs à NULL si vous ne leur affectez pas immédiatement une adresse valide. Tenter de lire ou d'écrire à travers un pointeur non initialisé (dangling pointer / pointeur sauvage) provoque immédiatement un crash système (Segmentation Fault).

---

4. Le passage par adresse (Pass by Reference)

Dans la Partie 2, nous avions constaté qu'une fonction ne pouvait pas modifier une variable de l'appelant car les paramètres étaient transmis par copie (Pass by Value). Grâce aux pointeurs, nous pouvons enfin transmettre l'adresse de nos variables pour permettre à la fonction de modifier directement leur contenu !

L'échange de deux variables enfin résolu

echanger_pointeurs.c

#include <stdio.h>

// La fonction reçoit les ADRESSES de deux entiers
void Echanger(int *ptrA, int *ptrB)
{
    int temporaire = *ptrA; // Sauvegarde la valeur située à l'adresse ptrA
    *ptrA = *ptrB;          // Écrit la valeur de B à l'adresse de A
    *ptrB = temporaire;     // Écrit la valeur temporaire à l'adresse de B
}

int main(void)
{
    int x = 10, y = 20;

    printf("Avant echange : x = %d, y = %d\n", x, y);

    // On passe les adresses de x et y avec l'opérateur &
    Echanger(&x, &y);

    printf("Apres echange : x = %d, y = %d\n", x, y); // x vaut 20 et y vaut 10 !
    return 0;
}

C'est exactement la raison pour laquelle vous avez toujours écrit scanf("%d", &age); : scanf est une fonction qui prend un pointeur vers votre variable pour y écrire la saisie du clavier !

---

Sommaire de la Partie 4

1. Pointeurs et Tableaux (Arithmétique des pointeurs)
2. L'allocation dynamique de mémoire (malloc, calloc, realloc, free)
3. Applications pratiques et manipulation de mémoire

---

Vous comprenez à présent le fonctionnement des adresses et des pointeurs. Découvrons dans le chapitre suivant le lien intime qui unit les pointeurs et les tableaux en C.

Partagez sur les réseaux sociaux

Commentaires