Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Informatique

Pointeurs et mémoire dynamique en C

Adresses, pointeurs et déréférencement, passage par référence, arithmétique des pointeurs et tableaux, malloc et free, erreurs classiques, mémoire sur les microcontrôleurs, pointeurs de fonction.

https://www.electronics-engineering.com/fr/pointeurs-memoire-dynamique-c/

Pas encore de vote : soyez le premier à noter cette page.

Les pointeurs sont la fonctionnalité la plus puissante du C et celle qui effraie le plus les débutants. L’idée est pourtant simple : un pointeur est une variable qui contient une adresse mémoire. Avec les pointeurs une fonction peut modifier les variables de l’appelant, on parcourt les tableaux, on alloue de la mémoire à l’exécution et on accède directement aux registres du matériel. Dans cette leçon nous les prenons pas à pas, avec la mémoire dynamique et les erreurs à éviter.

Adresses et pointeurs

Chaque variable occupe une ou plusieurs cellules de mémoire, et l’opérateur & donne son adresse. Un pointeur se déclare avec un astérisque et contient une adresse ; l’opérateur * appliqué au pointeur donne accès à la variable pointée (déréférencement).

int x = 42;
int *p = &x;          /* p holds the address of x: p "points to" x */

printf("%d\n", *p);   /* 42: the value of the variable pointed to */
*p = 7;               /* changes x through the pointer */
printf("%d\n", x);    /* 7 */

Le type du pointeur (int *, double *, char *) dit quel genre de données se trouve à l’adresse, et donc combien d’octets lire. Le pointeur nul NULL ne pointe sur rien : c’est la valeur utilisée pour dire « aucun objet », et le déréférencer fait planter le programme.

Le passage par référence

Pour permettre à une fonction de modifier une variable de l’appelant, on lui passe l’adresse de la variable :

void swap(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

int main(void)
{
    int x = 3, y = 8;
    swap(&x, &y);             /* now x is 8 and y is 3 */
    return 0;
}

De cette façon une fonction peut aussi renvoyer plusieurs résultats, par exemple le module et la phase d’un nombre complexe, et c’est pourquoi scanf veut &x : il doit écrire dans la variable de l’appelant.

Pointeurs et tableaux

Le nom d’un tableau, dans presque toute expression, se convertit en l’adresse de son premier élément. Et on peut faire de l’arithmétique sur les pointeurs : p + 1 n’est pas l’adresse de l’octet suivant, mais celle de l’élément suivant.

Un tableau d'entiers en mémoire avec les adresses et un pointeur vers le troisième élément
Un tableau de cinq entiers de 4 octets qui commence à l’adresse 0x1000. Le pointeur p contient 0x1008, l’adresse de a[2] : donc *p vaut 33, et p + 1 pointe sur l’élément suivant, à l’adresse 0x100C.

Les équivalences a[i] == *(a + i) et &a[i] == a + i sont valables. On peut parcourir un tableau avec un pointeur :

double average(const double *v, int n)
{
    double s = 0.0;
    for (const double *p = v; p < v + n; p++) {
        s += *p;
    }
    return s / n;
}

La mémoire dynamique

Les tableaux ont une taille fixe, décidée à l’écriture du programme. Si la taille n’est connue qu’à l’exécution (combien d’échantillons lire dans un fichier, combien de nœuds a un circuit) on demande de la mémoire au système avec malloc, dans la zone appelée le tas (heap), et on la rend avec free quand elle n’est plus nécessaire.

#include <stdlib.h>

int n = read_sample_count();
double *samples = malloc(n * sizeof *samples);
if (samples == NULL) {                /* malloc can fail: always check */
    fprintf(stderr, "Out of memory\n");
    return 1;
}
/* ... use samples[0] ... samples[n - 1] like an array ... */
free(samples);
samples = NULL;                       /* avoids reusing it by mistake */

Les erreurs classiques

  • Pointeur non initialisé : int *p; *p = 5; écrit à une adresse aléatoire.
  • Déréférencer NULL : par exemple ne pas vérifier le résultat de malloc.
  • Fuite de mémoire : oublier free. Dans un programme qui tourne pendant des mois, comme le micrologiciel d’un routeur, la mémoire s’épuise peu à peu.
  • Utilisation après libération : utiliser la mémoire après l’avoir libérée. Son contenu a pu être réattribué à autre chose.
  • Double libération : libérer deux fois le même bloc corrompt les structures internes de l’allocateur.
  • Pointeur vers une variable locale renvoyé par une fonction : quand la fonction se termine, la variable n’existe plus.

Ces erreurs expliquent une grande part des vulnérabilités des logiciels écrits en C et C++ : c’est pourquoi des langages plus récents comme Rust vérifient l’utilisation de la mémoire à la compilation. Des outils comme valgrind et AddressSanitizer les trouvent pendant les tests.

Sur les microcontrôleurs on évite presque toujours l’allocation dynamique : avec quelques kilo-octets de RAM, des allocations et libérations répétées fragmentent la mémoire jusqu’à ce que malloc échoue après des heures ou des jours de fonctionnement. Les lignes directrices pour les logiciels critiques, comme MISRA C utilisé dans l’automobile, l’interdisent après l’initialisation : on utilise à la place des tableaux statiques dimensionnés pour le pire cas.

Les pointeurs de fonction

Un pointeur peut aussi contenir l’adresse d’une fonction, qui est alors appelée à travers lui. On l’utilise pour choisir un comportement à l’exécution : le qsort de la bibliothèque standard reçoit un pointeur vers la fonction qui compare deux éléments, et les tables de vecteurs d’interruption des microcontrôleurs sont des tableaux de pointeurs vers les fonctions à exécuter quand une interruption arrive.

S’abonner
Notifier de
guest
1 commentaire
Le plus ancien
Plus récent Les plus votés
1
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x