Les pointeurs en C et C++ expliqués simplement

Les pointeurs ont une réputation un peu intimidante. Beaucoup de personnes qui apprennent le C ou le C++ butent dessus, abandonnent, puis y reviennent quelques mois plus tard en se disant que finalement, ce n'était pas si terrible. La vérité tient en une phrase : un pointeur repose sur une seule idée toute simple. Au lieu de manipuler une valeur, on manipule l'endroit où cette valeur est rangée. Tout le reste découle logiquement de ce principe.

Une variable, une case, une adresse

Quand on déclare une variable, l'ordinateur réserve une petite zone dans la mémoire pour y stocker sa valeur. On peut imaginer la mémoire comme une longue rue d'immeubles où chaque case porte un numéro unique : son adresse. La variable, elle, n'est qu'une étiquette posée sur l'une de ces cases, pour qu'on n'ait pas à retenir le numéro.

Un pointeur, c'est simplement une variable qui contient ce numéro plutôt qu'une valeur ordinaire. Là où un entier range le nombre 42, un pointeur range l'adresse de l'endroit où se trouve, par exemple, ce fameux 42. Si vous avez déjà parcouru notre article sur les variables en programmation, vous avez déjà fait la moitié du chemin : un pointeur reste une variable, avec une mission un peu particulière.

Déclarer un pointeur et lire ce qu'il désigne

En C, deux symboles font presque tout le travail. L'étoile * sert à déclarer un pointeur et à accéder à la valeur qu'il désigne ; l'esperluette & sert à récupérer l'adresse d'une variable existante.

int age = 42;
int *p = &age;        // p contient l'adresse de age

printf("%d\n", *p);   // affiche 42, la valeur pointée
*p = 43;              // on modifie age à travers le pointeur
printf("%d\n", age);  // affiche 43

Ici, *p se lit « la valeur rangée à l'adresse contenue dans p ». On appelle cela le déréférencement. Le point à retenir : modifier *p revient à modifier age directement, puisque les deux désignent la même case mémoire. C'est exactement ce qui rend les pointeurs aussi utiles.

À quoi servent vraiment les pointeurs

On pourrait croire à une complication gratuite. En réalité, les pointeurs résolvent des problèmes très concrets. Ils permettent à une fonction de modifier une variable qui lui est passée, au lieu d'en recevoir une simple copie. Ils évitent de recopier de gros blocs de données : on transmet une adresse, quelques octets, plutôt qu'un tableau entier. Ils rendent possibles les structures qui grandissent et rétrécissent pendant l'exécution, comme les listes chaînées ou les arbres. Et si vous débutez tout juste, notre guide pour écrire votre premier programme en C++ pose les bases avant d'attaquer ce sujet.

L'allocation dynamique de la mémoire

Jusqu'ici, nos variables avaient une taille connue d'avance. Mais comment faire quand on ignore, au moment d'écrire le code, combien d'éléments il faudra stocker ? La réponse tient dans l'allocation dynamique : on demande de la mémoire pendant l'exécution, puis on la rend une fois qu'on n'en a plus besoin. En C, on utilise malloc pour réserver et free pour libérer.

int *tableau = malloc(10 * sizeof(int));  // 10 entiers
if (tableau != NULL) {
    tableau[0] = 1;
    // ... utilisation ...
    free(tableau);   // on rend la mémoire
}

En C++, on dispose de new et delete, qui font la même chose en respectant mieux les types.

int *valeur = new int(42);
delete valeur;

La règle d'or se résume en une ligne : à chaque allocation doit correspondre une libération. Oublier le free ou le delete, c'est laisser de la mémoire occupée pour rien.

Les pièges qui font peur, et comment les éviter

La mauvaise réputation des pointeurs vient surtout de trois erreurs classiques. La première est la fuite de mémoire : on alloue sans jamais libérer, et le programme grignote la mémoire jusqu'à l'épuiser. La deuxième est le pointeur pendouillant, qui désigne une zone déjà libérée ; y accéder produit un résultat imprévisible. La troisième est le pointeur nul que l'on déréférence sans le vérifier, ce qui provoque le fameux plantage par segmentation.

La bonne nouvelle, c'est que ces pièges se neutralisent avec des habitudes simples. On initialise toujours un pointeur, quitte à le mettre à NULL. On vérifie qu'il n'est pas nul avant de s'en servir. Et après un free, on remet le pointeur à NULL pour éviter de le réutiliser par mégarde. Ces réflexes deviennent vite une seconde nature.

Ce que le C++ moderne change

Le C++ récent a beaucoup adouci tout cela avec les pointeurs intelligents. Un std::unique_ptr ou un std::shared_ptr se charge de libérer la mémoire automatiquement dès qu'on n'en a plus besoin, ce qui élimine d'un coup une grande partie des fuites.

#include <memory>

std::unique_ptr<int> valeur = std::make_unique<int>(42);
// libération automatique : aucun delete à écrire

Pour autant, comprendre les pointeurs « bruts » reste indispensable : les pointeurs intelligents sont construits par-dessus, et le code existant en regorge. On gagne toujours à connaître les deux. Le même esprit anime des bibliothèques C plus anciennes, comme celle que nous décrivons dans notre article sur conio.h, _kbhit et getch.

Pour aller plus loin

Les pointeurs ne se domptent pas en une seule lecture, mais en pratiquant. Écrivez de petits programmes, dessinez la mémoire sur une feuille, suivez chaque adresse à la main. En quelques jours, ce qui semblait obscur devient un réflexe.

Si vous préférez un support papier pour progresser à votre rythme, un bon livre sur le langage C reste un excellent compagnon d'apprentissage, en complément des tutoriels en ligne.

En tant que Partenaire Amazon, nous réalisons un bénéfice sur les achats remplissant les conditions requises.