Pointeurs en langage C : Guide Complet pour Bien les Utiliser

C’est quoi exactement un pointeur ? Le passeport de tes données 🛂

Imagine que la mémoire de ton ordinateur est une immense ville. Chaque variable (un entier, un caractère…) habite à une adresse précise, comme « 0x7ffee3b4156c ». Un pointeur, c’est un papier sur lequel tu écris cette adresse. Tu ne manipules pas directement l’habitant (la valeur), mais son adresse postale.

Pourquoi c’est utile ? Deux raisons majeures :

• Économie de ressources : Passer l’adresse d’une grosse structure à une fonction est bien plus rapide que d’en faire une copie complète.
• Flexibilité : Tu peux créer à la volée de la mémoire (avec malloc), construire des listes chaînées, des arbres… bref, tout ce qui est dynamique.

Syntaxe & Opérateurs : Ton kit de démarrage

Pour déclarer un pointeur, tu utilises l’astérisque * après le type de la variable pointée.

int *mon_pointeur; // Prêt à stocker l'adresse d'un entier
char *ptr_char;    // Prêt à stocker l'adresse d'un caractère

Deux opérateurs sont INDISPENSABLES :

Un exemple complet pour fixer les idées :

#include <stdio.h>

int main() {
    int mon_argent = 150; // Une variable normale
    int *porte_monnaie = &mon_argent; // Le pointeur stocke l'adresse de 'mon_argent'

    printf("Valeur : %dn", mon_argent); // Affiche 150
    printf("Adresse en mémoire : %pn", (void*)porte_monnaie); // Affiche l'adresse (ex: 0x7ffd...)
    printf("Valeur via le pointeur : %dn", *porte_monnaie); // Affiche 150 (déréférencement)

    // Je modifie la valeur EN PASSANT PAR LE POINTEUR
    *porte_monnaie = 200;
    printf("Nouvelle valeur de 'mon_argent' : %dn", mon_argent); // Affiche 200 !

    return 0;
}

Pointeurs et Tableaux : Deux concepts inséparables 🧑‍🤝‍🧑

En C, le nom d’un tableau est pratiquement synonyme de pointeur sur son premier élément. C’est une connexion vitale à comprendre.

int villes_visitees[3] = {73, 45, 12}; // Mon tableau
int *p = villes_visitees; // Équivalent à int *p = &villes_visitees[0]

printf("Premier voyage : %dn", *p); // 73
printf("Deuxième voyage : %dn", *(p + 1)); // 45
p++; // Je fais avancer le pointeur d'UN ÉLÉMENT (un int)
printf("Deuxième voyage (après p++) : %dn", *p); // 45

⚠️ Attention à l’arithmétique : p++ n’avance pas d’un octet, mais de la taille du type pointé (ex: 4 octets pour un `int`). L’ordinateur calcule ça pour toi.

Allocation Dynamique : Ta carte bancaire mémoire 💳

Parfois, tu ne sais pas à l’avance de combien de mémoire tu as besoin (ex: une liste de contacts). C’est là que malloc et free entrent en jeu. Ils te permettent de demander et de rendre de la mémoire au système.

#include <stdlib.h>
#include <stdio.h>

int main() {
    // Je demande de la place pour 5 entiers (comme un tableau de taille variable)
    int *mes_notes = (int*)malloc(5 * sizeof(int));

    if (mes_notes == NULL) {
        printf("Erreur : la mémoire n'a pas pu être allouée.n");
        return 1; // On quitte en cas de problème
    }

    // J'utilise cette mémoire comme un tableau
    for(int i = 0; i < 5; i++) {
        mes_notes[i] = i * 10;
    }

    // TRÈS IMPORTANT : Je rends la mémoire quand je n'en ai plus besoin
    free(mes_notes);
    // Bonne pratique : après free, mettre le pointeur à NULL
    mes_notes = NULL;

    return 0;
}

👉 calloc(n, taille) est une alternative qui alloue ET initialise tout à zéro, souvent plus sûre.

Aller plus loin : Pointeurs de fonctions et structures

Quand tu seras à l’aise, tu découvriras des utilisations puissantes :

• Pointeurs vers fonctions : Permettent de choisir quelle fonction exécuter à l’exécution (très utile pour les callbacks).
• Pointeurs vers des structures : Le fondement des listes chaînées et des arbres. On utilise l’opérateur -> pour accéder aux membres : ma_struct->valeur.

FAQ : Les questions qui reviennent tout le temps