Aller au contenu
Encyclopédie informatique Édition 2026

Pointeurs et gestion de la mémoire

Un programme range ses données dans la mémoire de l’ordinateur, et chaque donnée a une adresse, comme une maison a un numéro de rue. Un pointeur est une variable qui contient une telle adresse. C’est un outil puissant : il permet de manipuler de grosses données sans les copier, de construire des structures qui grandissent et de modifier une variable depuis une fonction. C’est aussi, depuis un demi-siècle, la première source de failles de sécurité dans les logiciels : une adresse fausse, un bloc rendu deux fois ou une écriture trop loin suffisent à faire planter un programme ou à en donner le contrôle à un attaquant. Cet article explique ce qu’est un pointeur, comment on s’en sert en C et en C++, comment la mémoire est organisée (pile et tas), quelles sont les erreurs classiques, et comment les langages modernes (C++ moderne, Python, Java, Rust) les évitent.

Rubrique
Développement
Niveau
Intermédiaire à avancé
Lecture
21 min (essentiel)
23 min (complet)
Révision
4 novembre 2026
Niveau de lecture :

En bref

  • Un pointeur est une variable qui contient l’adresse d’une autre donnée ; on lit ou écrit la donnée visée en déréférençant le pointeur, avec le signe *.
  • La mémoire d’un programme comprend la pile (variables locales, libérées toutes seules) et le tas (mémoire demandée avec malloc ou new, à rendre soi-même).
  • Les erreurs classiques sont la fuite, l’utilisation après libération, la double libération, le dépassement de tampon et le pointeur non initialisé ; elles provoquent des plantages et des failles de sécurité.
  • Un pointeur ne doit jamais être utilisé tant qu’il n’est pas initialisé ; on le met à NULL quand il ne pointe sur rien et on le contrôle avant usage.
  • Les langages modernes réduisent le risque : pointeurs intelligents en C++, ramasse-miettes en Python et Java, propriété et emprunt en Rust. Google a ainsi fait passer sous 20 % la part des failles de mémoire dans Android en 2025.

Prérequis conseillés : Variables et types de données · Le langage C · La mémoire vive (RAM)

1Adresses et pointeurs

Un pointeur est « une variable contenant l’adresse d’une autre variable d’un type donné ». La notion « fait souvent peur », parce qu’il s’agit d’une technique « très puissante », qui permet de définir des « structures dynamiques », c’est-à-dire qui évoluent au cours du temps, par opposition aux tableaux, qui sont des structures « statiques » dont la taille est figée (voir les tableaux, listes et structures de données). Cette peur est compréhensible, mais elle disparaît quand on sait ce qu’il y a derrière : une simple histoire de numéros de cases.

1.1La mémoire est une suite de cases numérotées

Quand un programme s’exécute, il est placé en mémoire (voir la mémoire vive) : le code à exécuter, mais aussi toutes les variables, chacune dans une zone réservée dont la taille dépend du type. On décrit la mémoire comme « plein de petites cases de 8 bits (un octet) », chaque case ayant un numéro, son adresse. Une variable occupe une ou plusieurs cases voisines : un char occupe une case, un int en occupe quatre en général.

Une correction utile. On lit parfois qu’une variable de type long occupe « 4 cases consécutives ». Ce n’est plus vrai partout : sur la plupart des systèmes de type Unix en 64 bits (Linux, macOS), un long occupe 8 octets, alors qu’il en occupe 4 sous Windows. La norme du langage ne fixe pas ces tailles. On les demande à l’opérateur sizeof, ou l’on emploie des types à taille garantie comme int32_t ou int64_t.

On peut alors désigner une variable de deux façons : par son nom, ou par l’adresse de sa première case. Un pointeur est une variable conçue pour stocker cette seconde information. Par exemple, un pointeur stocké à l’adresse 24 peut contenir la valeur 253, adresse d’une autre variable. La figure 1 en montre un autre, avec des adresses aux valeurs arbitraires.

UN POINTEUR EST UNE VARIABLE QUI CONTIENT UNE ADRESSE int a 42 adresse 1000 int *p 1000 adresse 2000 p pointe vers a p = &a; p reçoit l’adresse de a (le signe et commercial veut dire : adresse de) *p = 7; on va à l’adresse contenue dans p et on y écrit : a vaut maintenant 7 p = NULL; p ne pointe plus vers rien ; s’en servir ferait planter le programme
Figure 1. Un pointeur est une variable ordinaire dont la valeur est l’adresse d’une autre variable.

1.2Connaître l’adresse d’une variable

On n’écrit jamais une adresse à la main : elle « change à chaque lancement de programme », parce que le système d’exploitation attribue les cases libres du moment. Aujourd’hui c’est encore plus vrai : les systèmes modernes brouillent volontairement les adresses à chaque exécution, une protection appelée ASLR (Address Space Layout Randomization, « répartition aléatoire de l’espace d’adresses »), qui complique la tâche d’un attaquant. Pour obtenir l’adresse d’une variable, on fait précéder son nom du signe & (esperluette, ou « et commercial »), que l’on lit « adresse de » : &a.

1.3À quoi servent les pointeurs ?

Un pointeur a trois usages principaux :

  • Manipuler de grosses données sans les copier. Au lieu de passer à une fonction un élément très grand, on lui donne un pointeur vers cet élément : quelques octets au lieu de copier des mégaoctets.
  • Gérer des tableaux dynamiques. Avec des pointeurs dans les cases d’un tableau, on peut stocker des éléments de taille variable, et même ajouter des éléments en cours d’exécution.
  • Construire des structures chaînées : listes, arbres, où chaque maillon contient l’adresse du suivant.

Un quatrième usage est apparu dans le même temps : modifier une variable depuis une fonction (partie 3), et un cinquième, plus récent, le partage : plusieurs parties d’un programme regardent la même donnée sans la dupliquer.

1.4Le plan de l’article

La partie 2 explique l’emploi d’un pointeur, la partie 3 le passage d’arguments, la partie 4 la pile et le tas (figure 2), la partie 5 les erreurs classiques (figure 3), la partie 6 les parades, la partie 7 l’enjeu de sécurité et la partie 8 propose sept exercices corrigés.

2Utiliser un pointeur

2.1Déclarer un pointeur

Un pointeur se déclare en précisant le type de la donnée visée, suivi d’une étoile :

int  *p1;     /* p1 pointera vers un int */
char *p2;     /* p2 pointera vers un char */

Le type n’est pas décoratif. Grâce à lui, « le compilateur saura combien de blocs suivent le bloc situé à l’adresse pointée » : un pointeur vers int lira quatre cases, un pointeur vers char une seule. Le type permet aussi au compilateur de refuser des mélanges douteux.

Une précision sur les types. On lit, selon le langage, qu’un pointeur « doit préférentiellement être typé » (avec la possibilité de définir un pointeur void *, sans type) ou qu’il doit « obligatoirement » l’être. En réalité, les deux langages admettent le pointeur void *, pointeur « générique » qui ne dit pas ce qu’il vise et qu’il faut convertir (transtyper) avant de s’en servir. Les fonctions comme malloc en renvoient. En C++, la conversion doit être écrite explicitement ; en C, elle se fait toute seule et on évite de l’écrire.

2.2Initialiser : le danger du pointeur sauvage

Après la déclaration, un pointeur contient ce qui se trouvait dans la case avant : « n’importe quel nombre ». Un pointeur non initialisé vise donc une adresse au hasard, et s’en servir est une erreur grave : « un morceau de votre programme ou… de votre système d’exploitation ». Les systèmes modernes protègent les zones qui ne sont pas à vous, si bien que le programme est généralement arrêté brutalement par le système (on parle de défaut de segmentation), mais l’adresse au hasard peut aussi tomber sur une zone qui vous appartient et dont vous détruisez le contenu sans le savoir. C’est le pire cas, car aucune alerte n’est donnée.

On initialise donc un pointeur dès sa déclaration, soit avec l’adresse d’une variable, soit avec la valeur spéciale NULL (en C++ moderne, nullptr), qui signifie « ne pointe vers rien » :

int a = 2;
char b;
int  *p1 = &a;      /* p1 contient l'adresse de a */
char *p2 = &b;      /* p2 contient l'adresse de b */
int  *p3 = NULL;    /* p3 ne pointe sur rien, et c'est voulu */

2.3Accéder à la donnée visée : le déréférencement

Une fois le pointeur initialisé, on lit ou on écrit la donnée visée avec l’opérateur *, placé devant le pointeur : c’est le déréférencement. Voici un exemple :

int a = 2;
int  *p1 = &a;
char b;
char *p2 = &b;
*p1 = 10;      /* a vaut maintenant 10 */
*p2 = 'a';     /* b vaut maintenant 97, le code du caractère a */

Une erreur courante. On conclut parfois que « le contenu des variables p1 et p2 sera respectivement 10 et 97 ». C’est faux : p1 et p2 contiennent toujours des adresses ; ce sont les variables a et b qui valent 10 et 97. Cette confusion entre le pointeur et ce qu’il vise est la plus fréquente chez les débutants : p1 est l’adresse, *p1 est la donnée.

Dans une expression plus complexe, il faut des parenthèses, car l’opérateur ++ s’applique avant * : (*p)++ augmente de 1 la donnée visée, alors que *p++ avance le pointeur de case en case après avoir lu la donnée. Dans les exemples a = (*p)++; et a = (*p) + 2;, par p, comprenez p1.

2.4Pointeurs et tableaux : l’arithmétique de pointeurs

Le nom d’un tableau, dans la plupart des expressions, devient l’adresse de sa première case. Et ajouter 1 à un pointeur ne le fait pas avancer d’un octet, mais d’une donnée : si p pointe vers un int de 4 octets, p + 1 est l’adresse située 4 octets plus loin. C’est ce qu’on appelle l’arithmétique de pointeurs. Elle explique que t[i] et *(t + i) soient équivalents (voir les tableaux), et aussi que sortir d’un tableau en avançant un pointeur trop loin soit aussi dangereux qu’un indice trop grand.

2.5Le pointeur sur pointeur et les pointeurs constants

Un pointeur est une variable : il a lui-même une adresse, qu’on peut mémoriser dans un autre pointeur, noté int **pp (un pointeur vers un pointeur vers un entier). On en rencontre dans les tableaux de chaînes de caractères et les fonctions qui doivent modifier un pointeur. On peut aussi promettre de ne pas modifier la donnée visée avec const : const char *texte signifie « je lis le texte mais je ne l’écris pas », ce qui évite des erreurs et se lit comme une documentation.