Aller au contenu
Encyclopédie informatique Édition 2026

Pointeurs et gestion de la mémoire

Partie 2 sur 3

Niveau de lecture :

3Passer une donnée à une fonction

Quand on passe une variable à une fonction, celle-ci en reçoit une copie : « en sortie de la fonction, une variable passée en paramètre n’est pas modifiée », parce que la copie a pour portée celle de la fonction (voir les fonctions). C’est le passage par valeur.

3.1Passage par adresse (ou par pointeur)

Une première solution pour qu’une fonction modifie la variable de l’appelant est de la renvoyer : b = ajout2(b);. Mais cela ne convient pas si la fonction doit déjà renvoyer autre chose. La seconde solution est de lui donner l’adresse de la variable. La fonction reçoit un pointeur et peut modifier directement la variable :

void ajout2(int *a)
{
    *a += 2;      /* modifie la variable de l'appelant */
}

int b = 3;
ajout2(&b);       /* b vaut maintenant 5 */

Une erreur à éviter. Une fonction déclarée int Ajout2(int * a) qui ne renvoie aucune valeur est fautive : une fonction qui annonce un résultat entier doit en renvoyer un, sinon le comportement est indéterminé. Quand on ne renvoie rien, on déclare void, comme ci-dessus.

C’est aussi la manière de renvoyer plusieurs résultats : la fonction reçoit les adresses où déposer chacun. Et c’est la raison pour laquelle scanf, qui lit au clavier, demande l’adresse de la variable à remplir : scanf("%d", &age);.

3.2Passage par référence en C++

Le C++ ajoute la référence, « concept novateur » : un second nom pour une variable existante. On l’écrit avec une esperluette entre le type et le nom :

void ajout2(int &a)
{
    a += 2;       /* a est un autre nom pour la variable de l'appelant */
}

int b = 3;
ajout2(b);        /* b vaut 5, sans écrire & ni * */

Les règles à retenir : une référence doit être initialisée dès sa déclaration, elle ne peut pas être redirigée vers une autre variable ensuite, et elle ne peut pas être « nulle ». Il ne faut « en aucun cas » confondre la référence avec l’adresse, même si les deux emploient le signe &. Ce signe a deux sens selon la place : dans une expression, &a est « l’adresse de a » ; dans une déclaration, int &r signifie « r est une référence ». En pratique, on emploie une référence quand la donnée doit exister, et un pointeur quand elle peut manquer (NULL) ou quand on veut changer de cible.

3.3Dans d’autres langages

En Python ou en Java, on ne manipule pas d’adresses, mais le même mécanisme existe en coulisse : une variable contenant un objet contient en réalité une référence vers lui. Passer une liste à une fonction donne donc accès à la même liste, que la fonction peut modifier (voir Python). C’est la source d’une surprise fréquente : modifier le contenu d’une liste reçue en paramètre la change aussi chez l’appelant, alors que réaffecter la variable locale ne change rien. Comprendre les pointeurs aide à comprendre ces comportements, même dans un langage qui les cache.

Pour s’exercer

Exercice 1 : lire un pointeur

Que valent a et b à la fin ? int a = 5, b = 8; int *p = &a; *p = 20; p = &b; *p = *p + 1;

Voir la réponse

*p = 20 écrit 20 dans a. Puis p reçoit l’adresse de b ; *p = *p + 1 met b à 9. Résultat : a vaut 20 et b vaut 9.

Exercice 2 : l’échange

Écrivez une fonction echanger qui échange les valeurs de deux entiers de l’appelant. Pourquoi une version qui reçoit deux int par valeur ne marche-t-elle pas ?

Voir la réponse

void echanger(int *x, int *y) { int tmp = *x; *x = *y; *y = tmp; }, appelée par echanger(&a, &b);. Avec le passage par valeur, la fonction échange ses copies locales, qui disparaissent à la fin : les variables de l’appelant restent inchangées. (En C++, des paramètres int &x, int &y suffisent.)

Exercice 3 : trouver l’erreur

Que reproche-t-on à ce code ? int *f(void) { int x = 7; return &x; }

Voir la réponse

La fonction renvoie l’adresse d’une variable locale, qui est sur la pile. À la fin de f, x n’existe plus : l’adresse renvoyée est un pointeur pendant. L’utiliser donne un comportement imprévisible. Il faut soit renvoyer la valeur, soit allouer sur le tas avec malloc (et laisser l’appelant la libérer), soit recevoir en paramètre un emplacement fourni par l’appelant.

4La pile et le tas

Le pointeur permet d’ajouter des éléments « en cours d’utilisation » : cela suppose de pouvoir demander de la mémoire pendant l’exécution. Pour le comprendre, il faut connaître les deux zones où un programme range ses données, que la figure 2 résume (voir aussi la mémoire du système).

LA PILE ET LE TAS : DEUX FAÇONS D’OBTENIR DE LA MÉMOIRE PILE (stack) main() variables : a, p calcul() variables : n, i affiche() variables : texte variables locales ; libérées toutes seules quand la fonction se termine TAS (heap) bloc 1 bloc 2 bloc 3 libre demandé avec malloc ou new, à rendre soi-même avec free ou delete p Le pointeur p vit sur la pile ; le bloc vers lequel il pointe vit sur le tas. Si p disparaît sans que le bloc soit rendu, le bloc est perdu : c’est une fuite de mémoire.
Figure 2. La pile (variables locales, gestion automatique) et le tas (blocs demandés, gestion manuelle).

4.1La pile

La pile (stack) contient les variables locales des fonctions en cours d’exécution. Chaque appel de fonction y empile un « cadre » ; à la fin de la fonction, le cadre est retiré et ses variables disparaissent d’elles-mêmes. C’est rapide et sans souci de gestion, mais la taille est limitée (quelques mégaoctets) et la durée de vie est courte : une variable locale n’existe plus quand la fonction se termine. Renvoyer l’adresse d’une variable locale est donc une erreur : l’adresse ne vise plus rien de valable.

4.2Le tas

Le tas (heap) est une grande réserve de mémoire où l’on demande des blocs à la volée, de la taille que l’on veut, qui survivent à la fonction qui les a demandés. En C, on les obtient avec malloc (memory allocation, « allocation de mémoire ») et on les rend avec free ; en C++, avec new et delete.

#include <stdlib.h>

int *notes = malloc(100 * sizeof *notes);   /* 100 entiers */
if (notes == NULL) {
    /* plus de mémoire : il faut le gérer */
}
/* ... utilisation ... */
free(notes);        /* on rend le bloc */
notes = NULL;       /* on évite de garder une adresse périmée */

malloc renvoie l’adresse du bloc ou NULL en cas d’échec : d’où le conseil de « tester la valeur renvoyée ». Les variantes calloc (qui met le bloc à zéro) et realloc (qui change la taille d’un bloc, en le déplaçant au besoin) complètent la famille. C’est ainsi que se réalisent les tableaux extensibles et les listes chaînées (voir les structures de données).

La règle fondamentale est simple à énoncer et difficile à tenir : chaque bloc demandé doit être rendu exactement une fois, et plus jamais utilisé après. Tout le reste de la partie 5 en découle.