Comprendre un pointeur en programmation

Voici le concept réputé le plus redoutable du parcours — celui qui a fait la légende noire du langage C. Bonne nouvelle : sa difficulté est surfaite ; c’est une idée simple, mal introduite d’habitude, et qui éclaire d’un coup des mystères que tu as déjà rencontrés sans explication. Comprendre un pointeur — l’adresse, les opérateurs, et ce que les langages modernes en font en coulisses — se fait très bien avec une enveloppe et un plan de ville : ce guide s’y emploie, dans la lignée de notre guide complet pour apprendre à coder.

Un pointeur, expliqué avec les mains

Depuis le premier concept, une variable est une boîte : un nom, un contenu. Précisons maintenant le décor : ces boîtes sont rangées dans une immense rue — la mémoire — et chaque boîte y possède une adresse, son numéro dans la rue. D’ordinaire, tu ignores ces numéros : tu appelles les boîtes par leur nom, le langage fait le facteur. Le pointeur lève le rideau : c’est une boîte dont le contenu est l’adresse d’une autre boîte — non pas la maison, mais le papier où l’adresse de la maison est notée. La distinction paraît byzantine ? Elle est la clé de tout : avec le papier, tu peux aller à la maison et agir dessus — et tu peux donner le papier à quelqu’un d’autre, qui agira sur la même maison, sans qu’il en existe jamais deux.

D’où les deux services que le pointeur rend, partout, tout le temps. Partager sans dupliquer : confier à une fonction l’adresse d’un tableau d’un million de cases coûte la taille d’un papier — pas celle du tableau ; toutes les grandes structures circulent ainsi. Modifier pour de vrai : une fonction qui reçoit une copie de valeur travaille sur la copie — l’original ne bouge pas ; une fonction qui reçoit l’adresse va modifier l’original sur place. Retiens l’image complète — la rue, les numéros, le papier — elle va maintenant s’écrire en code, dans le langage où le concept vit à ciel ouvert.

À quoi ça ressemble dans le code

Le terrain naturel du pointeur est le langage C, avec deux opérateurs. & — « donne-moi l’adresse » : si age est une boîte contenant 25, alors &age est son numéro dans la rue ; on le range dans un pointeur — int *p = &age; — lis : « p est un pointeur vers un entier, et il contient l’adresse de age ». * — « va à l’adresse » : *p suit le papier jusqu’à la maison — lire *p donne 25 ; écrire *p = 30; change le contenu de age sans jamais la nommer. Tout le concept tient dans ces deux gestes symétriques : & transforme une maison en adresse, * transforme une adresse en maison.

L’exemple canonique — celui de tous les cours de C — est l’échange de deux variables par une fonction : echanger(&a, &b) transmet les adresses, la fonction suit les papiers et permute les contenus sur place — a et b sont réellement échangées, ce qu’aucune copie de valeurs ne permettrait (tu l’as peut-être déjà vécu dans les exercices de C). Et maintenant, le secret d’initié : Python et JavaScript font cela en permanence, sans le dire. Leurs variables ne contiennent pas les grandes structures — elles contiennent des références, des adresses polies et sécurisées. Voilà pourquoi b = a sur une liste ne duplique rien — deux papiers, une seule maison, et modifier « b » modifie « a » : le mystère du guide des tableaux vient de trouver son explication complète. Les langages modernes ont caché les numéros de rue et interdit l’arithmétique dangereuse ; ils n’ont jamais cessé de faire circuler des adresses — et le C++, héritier direct, offre les deux mondes à la fois.

Les pièges classiques (et comment les éviter)

Piège 1 : confondre l’adresse et le contenu. Afficher p montre un numéro de rue (une adresse hexadécimale absconse) ; afficher *p montre la valeur habitant là — mélanger les deux est LA confusion fondatrice. Le remède : verbaliser chaque expression — « p, le papier ; étoile-p, la maison » — jusqu’au réflexe. Piège 2 : le pointeur qui ne pointe nulle part. Suivre un papier vierge (pointeur non initialisé) ou un papier barré (adresse d’une boîte détruite) mène à la maison fantôme — le plantage sec, le fameux « segmentation fault » qui a forgé la réputation du C. Le remède : tout pointeur naît initialisé (vers une vraie adresse, ou vers NULL — le « nulle part » officiel qu’on peut tester), et jamais de * sans être sûr de la destination.

Piège 3 : croire que b = a copie. En C comme dans les coulisses de Python et JavaScript, affecter une structure copie souvent le papier, pas la maison — les modifications se « téléportent » d’une variable à l’autre, au grand étonnement du débutant. Le remède : connaître le geste de vraie copie de son langage (list(a) en Python, […a] en JavaScript, la copie explicite en C) et se demander, à chaque affectation de structure : « papier ou maison ? ». Piège 4 : l’arithmétique aventureuse. En C, on peut faire p + 1 pour avancer de case en case — puissant sur un tableau, catastrophique un pas trop loin : la sortie de route mémoire. Le remède du débutant : réserver l’arithmétique de pointeurs au parcours de tableaux, bornes vérifiées. Le rideau est levé : la rue, les numéros, les papiers — tu sais désormais ce que la mémoire fait vraiment, et pourquoi les langages modernes t’en protègent sans jamais s’en passer. C’est le savoir des mots du métier qui impressionne à juste titre : peu de concepts éclairent autant de mystères d’un coup.

Questions fréquentes

C’est quoi un pointeur, en une phrase ?

Une variable qui contient l’adresse d’une autre variable en mémoire — le papier où est notée l’adresse de la maison, plutôt que la maison elle-même. Avec cette adresse, on peut lire et modifier la donnée originale sur place, et la partager sans jamais la dupliquer.

Que font les opérateurs & et * en C ?

& donne l’adresse d’une variable (« où habites-tu ? ») : &age est le numéro de la boîte age dans la mémoire. * suit une adresse (« va à cette maison ») : *p lit ou modifie la valeur qui habite à l’adresse contenue dans p. Les deux gestes sont symétriques : & fabrique l’adresse, * la déréférence.

Y a-t-il des pointeurs en Python ou en JavaScript ?

Pas sous ce nom, mais dans les coulisses, oui : leurs variables contiennent des références — des adresses sécurisées — vers les objets et les listes. C’est pourquoi b = a ne duplique pas une liste : deux noms désignent la même structure, et la modifier via l’un se voit via l’autre. La vraie copie demande un geste explicite.

C’est quoi une erreur « segmentation fault » ?

Le plantage typique d’un programme C qui suit un pointeur invalide : non initialisé, mis à NULL sans test, ou visant une zone mémoire détruite ou interdite — la maison fantôme. La prévention : initialiser tout pointeur à sa naissance, tester NULL avant de déréférencer, et surveiller les bornes des tableaux.

Sources

• cppreference — la référence du langage C et de ses opérateurs
• freeCodeCamp — cours et explications pédagogiques sur les pointeurs

Cet article a une vocation informative et pédagogique. Les plateformes, outils et formations éventuellement cités le sont à titre d’exemple ; compare plusieurs options avant de t’engager ou de payer.