Malloc
![Page d’aide sur l’homonymie](http://upload.wikimedia.org/wikipedia/commons/thumb/4/44/Logo_disambig-homophone.svg/20px-Logo_disambig-homophone.svg.png)
Pour l’article ayant un titre homophone, voir Mallock.
![](http://upload.wikimedia.org/wikipedia/commons/thumb/5/51/Malloc.svg/220px-Malloc.svg.png)
malloc(4)
alloue 4 octets dans le tas mémoire et renvoie l'adresse du premier octet (sur l'image 0x42
).![Si ce bandeau n'est plus pertinent, retirez-le. Cliquez ici pour en savoir plus.](http://upload.wikimedia.org/wikipedia/commons/thumb/3/38/Info_Simple.svg/12px-Info_Simple.svg.png)
![](http://upload.wikimedia.org/wikipedia/commons/thumb/a/a1/2017-fr.wp-orange-source.svg/45px-2017-fr.wp-orange-source.svg.png)
Cet article ne cite pas suffisamment ses sources ().
Si vous disposez d'ouvrages ou d'articles de référence ou si vous connaissez des sites web de qualité traitant du thème abordé ici, merci de compléter l'article en donnant les références utiles à sa vérifiabilité et en les liant à la section « Notes et références ».
En pratique : Quelles sources sont attendues ? Comment ajouter mes sources ?
En informatique, dans la bibliothèque standard du langage C, la fonction malloc
(pour memory allocation en anglais) permet d'allouer dynamiquement de la mémoire. La libération de la mémoire ainsi réservée s'effectue avec la fonction free
.
Cette fonction est déclarée dans l'en-tête <stdlib.h>
. Dans les systèmes GNU/Linux, elle fait partie du paquet GNU C Library.
Motivation
Il existe trois types d'allocation de mémoire pour une variable dans un programme C : l'allocation statique, automatique, et dynamique. La fonction malloc
concerne l'allocation dynamique.
L'allocation statique a lieu au cours de la compilation par la déclaration de variables statiques. Ces variables là persistent durant toute l'exécution du programme. Cela concerne les variables globales et les variables locales déclarées en utilisant le mot-clé static
. L'allocation statique oblige le développeur à connaître à l'avance la quantité de mémoire qui sera utilisée par le programme. C'est ainsi qu'un « gaspillage » de la mémoire peut survenir si l'on réserve trop de mémoire par rapport à ce dont le programme a véritablement besoin pour réaliser la tâche qui lui incombe.
L'allocation automatique a lieu pendant l'exécution du programme sur la pile d'exécution. Il s'agit des variables locales déclarées dans un bloc d'instructions. La libération de la mémoire n'est réalisée qu'à la fin du bloc d'instructions dans lequel est déclarée la variable. Cela peut également être un facteur de gaspillage lorsque de la mémoire est allouée, mais n'est plus utilisée.
C'est ici que l'allocation dynamique de mémoire entre en jeu. La réservation de la mémoire se fait au cours de l'exécution du programme, mais la libération de cette mémoire n'est plus gérée par le compilateur, mais par le programmeur. L'allocation dynamique a lieu à la demande sur le tas. Pour cela, on utilise des fonctions d'allocation de la mémoire comme malloc
. Cela augmente la complexité du programme, mais la gestion de la mémoire est plus fine. Si un programme alloue de la mémoire par malloc
sans la libérer ensuite par free
, on parle de fuite de mémoire. Pour éviter ce type de bug et faciliter l'écriture des programmes, certains langages disposent d'un mécanisme de ramasse-miettes, mais ce n'est pas le cas du langage C.
Utilisation
La fonction malloc
permet de réserver une zone de la mémoire. Son prototype est le suivant :
void *malloc(size_t nbOctets);
Le seul paramètre à passer à malloc
est le nombre d'octets à allouer. La valeur renvoyée est l'adresse du premier octet de la zone mémoire allouée. Si l'allocation n'a pu se réaliser (par manque de mémoire libre), la valeur de retour est la constante NULL.
La libération de la mémoire précédemment allouée via malloc
est assurée par la fonction free
dont la déclaration est la suivante :
void free(void *ptr);
Le seul paramètre à passer est l'adresse du premier octet de la zone allouée et aucune valeur n'est retournée une fois cette opération réalisée.
Voici du code réservant 20 octets et le libérant immédiatement après si l'allocation a été effectuée.
#include <stdlib.h> char * pointeur = malloc(20 * sizeof(char)); //Allocation de 20 octets (Un char est égal à 1 octet) if(pointeur == NULL) { printf("L'allocation n'a pu être réalisée\n"); } else { printf("L'allocation a été un succès\n"); free(pointeur); //Libération des 20 octets précédemment alloués pointeur = NULL; // Invalidation du pointeur }
Fonctions analogues
calloc
La zone mémoire allouée par malloc
n'est pas initialisée automatiquement. Cette initialisation peut être réalisée à l'aide de la fonction memset
ou bien par le parcours de toute la zone mémoire. Avec la fonction calloc
, cette phase d'initialisation n'est plus nécessaire, car la zone mémoire allouée est initialisée avec des 0.
La déclaration de calloc
est la suivante :
void *calloc(size_t nmemb, size_t size);
Le paramètre nmemb
est le nombre d'éléments que l'on désire réserver et size
correspond à la taille en octets d'un élément. La valeur retournée est la même que pour malloc
.
realloc
La fonction realloc
permet de modifier la taille de la mémoire allouée préalablement avec malloc
. S'il est nécessaire de déplacer la zone mémoire, car il n'y a pas assez de mémoire contiguë, la libération de l'ancienne zone mémoire est réalisée par realloc
via free
.
La déclaration de realloc
est la suivante :
void *realloc(void *ptr, size_t size);
Le paramètre ptr
désigne le début de la zone mémoire dont on désire modifier la taille. Le second paramètre, size
, est la nouvelle taille en octet de la zone mémoire.
Si la fonction réussit, la valeur retournée est le début de la zone mémoire allouée. Attention : la valeur du pointeur ptr
n'est plus valide car la nouvelle zone peut débuter à un autre endroit de la mémoire si un déplacement a été nécessaire.
Si la fonction échoue, elle retourne la valeur NULL
. Des précautions doivent être prises pour éviter une fuite de mémoire. Il convient de veiller à ce que l'adresse de l'ancien bloc ne soit pas écrasée avant de s'assurer que la réallocation a bien réussi. Dans le code suivant, le test sur la valeur de tampon
n'est pas suffisant. Si realloc
échoue, l'adresse de la zone mémoire est perdue :
tampon = realloc(tampon, nouvelle_taille); if (tampon == NULL) rapporterErreur();
Pour remédier à ce problème, on introduit une nouvelle variable tmp
qui stocke le résultat de realloc
sans écraser la valeur de tampon
:
tmp = realloc(tampon, nouvelle_taille); if (tmp == NULL) { free(tampon); rapporterErreur(); } else tampon = tmp;
Débogage
Débogage sous Windows
Des utilitaires graphiques permettent de vérifier que la mémoire utilisée est bien libérée lorsqu'elle n'est plus utilisée, comme c'est le cas avec MFC Debugging support qui est dédié à l'API MFC de Microsoft[1].
Débogage sous GNU/Linux
- mtrace, commande servant de débogueur de mémoire et distribuée avec le paquet GNU C Library ; elle permet de tracer les appels à malloc ;
- TotalView, Valgrind et mpatrol : débogueurs permettant de détecter les fuites de mémoire et les écritures hors de la zone allouée par malloc ;
- La bibliothèque logicielle DUMA aide à détecter indirectement les malloc ayant une taille trop petite ou trop grande ;
Notes et références
Portail de la programmation informatique