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/
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.

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.






Benvenuti nella pagina su «Puntatori e memoria dinamica in C». L'ho scritta pensando a chi studia ingegneria elettronica: se un passaggio non vi torna, un esercizio vi dà un risultato diverso o volete altro materiale sull'argomento, chiedete pure nei commenti e vi risponderò. Un voto con le stelle qui sopra mi aiuta a capire quali pagine migliorare.Welcome to the page on “Pointers and dynamic memory in C”. I wrote it for engineering students: if a step does not add up, an exercise gives you a different result or you would like more material on the topic, just ask in the comments and I will reply. A star rating above helps me understand which pages to improve.