Provided by: manpages-fr-dev_4.13-4_all 
NOM
malloc, free, calloc, realloc, reallocarray - Allocation et libération de mémoire dynamique
SYNOPSIS
#include <stdlib.h>
void *malloc(size_t size);
void free(void *ptr);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);
void *reallocarray(void *ptr, size_t nmemb, size_t size);
Exigences de macros de test de fonctionnalités pour la glibc (consulter feature_test_macros(7)) :
reallocarray() :
Depuis la glibc 2.29 :
_DEFAULT_SOURCE
Pour la glibc 2.28 et antérieure :
_GNU_SOURCE
DESCRIPTION
La fonction malloc() alloue size octets et renvoie un pointeur sur la mémoire allouée. Le contenu de la
zone de mémoire n'est pas initialisé. Si size est nulle, malloc renvoie soit NULL ou un unique pointeur
qui pourra être passé ultérieurement à free() avec succès.
La fonction free() libère l'espace mémoire pointé par ptr qui doit avoir été obtenu lors d'un appel
antérieur à malloc(), calloc() ou realloc(). Autrement, ou si free(ptr) a déjà été appelé précédemment,
le comportement est indéterminé. Si ptr est NULL, aucune opération n'est effectuée.
La fonction calloc() alloue la mémoire nécessaire pour un tableau de nmemb éléments de size octets chacun
et renvoie un pointeur vers la mémoire allouée. Cette zone mémoire est remplie avec des zéros. Si nmemb
ou si size est nulle, calloc renvoie alors NULL ou un unique pointeur qui pourra être passé
ultérieurement à free() avec succès. Si la multiplication de nmemb et size résulte en un dépassement
d'entier, calloc() renverra alors une erreur. En revanche, un dépassement d'entier ne serait pas détecté
dans l'appel suivant à malloc(), mais aurait pour conséquence l'allocation d'un bloc mémoire de taille
incorrecte :
malloc(nmemb * size);
La fonction realloc() modifie la taille du bloc de mémoire pointé par ptr à size octets. Le contenu de la
mémoire entre la zone de départ et le minimum des nouvelle et ancienne tailles n'est pas modifié. Si la
nouvelle taille est plus grande que l'ancienne taille, le contenu de la zone de mémoire nouvellement
allouée n'est pas initialisé. Si ptr est NULL, l'appel est équivalent à malloc(size), pour toute valeur
de size ; si size vaut zéro et que ptr est non NULL, l'appel est alors équivalent à free(ptr). Si ptr
n'est pas NULL, il doit avoir été obtenu par un appel antérieur à malloc(), calloc() ou realloc(). Si la
zone pointée était déplacée, un appel à free(ptr) est effectué.
La fonction reallocarray() change la taille du bloc mémoire pointé par ptr pour qu'il soit suffisamment
grand pour contenir un tableau de nmemb éléments faisant chacun size octets. C'est équivalent à l'appel
realloc(ptr, nmemb * size);
Cependant, contrairement à cet appel de realloc(), reallocarray() échoue sans danger dans le cas où la
multiplication entraînerait un dépassement. Si un tel dépassement se produit, reallocarray() renvoie
NULL, fixe errno à ENOMEM et laisse le bloc mémoire originel inchangé.
VALEUR RENVOYÉE
Les fonctions malloc() et calloc() renvoient un pointeur vers la mémoire allouée qui est correctement
alignée pour n'importe quel type interne. Si elles échouent, elles renvoient NULL. NULL peut également
être renvoyé par un appel réussi à malloc() avec un argument size égal à zéro ou par un appel réussi de
calloc() avec nmemb ou size égal à zéro.
La fonction free() ne renvoie pas de valeur.
La fonction realloc() renvoie un pointeur sur la mémoire nouvellement allouée et qui est correctement
alignée pour n'importe quel type interne, ou NULL si la requête échoue. Le pointeur renvoyé peut être
identique à ptr si la zone mémoire n'est pas déplacée (par exemple s'il y a de la place pour l'étendre à
son emplacement) ou peut être différent de ptr si la zone mémoire est déplacée à une nouvelle adresse. Si
size vaut zéro, realloc() renvoie NULL ou un pointeur acceptable pour free(). Si realloc() échoue, le
bloc mémoire original reste intact ; il n'est ni libéré ni déplacé.
En cas de succès, la fonction reallocarray() renvoie un pointeur sur la mémoire nouvellement allouée. En
cas d'échec, NULL est renvoyé et le bloc mémoire originel n'est pas modifié.
ERREURS
calloc(), malloc(), realloc() et reallocarray() peuvent échouer avec l'erreur suivante :
ENOMEM Plus de mémoire. Il est possible que l'application ait atteint les limites RLIMIT_AS ou
RLIMIT_DATA décrites dans getrlimit(2).
VERSIONS
reallocarray() est apparue pour la première fois dans la version 2.26 de la glibc.
ATTRIBUTS
Pour une explication des termes utilisés dans cette section, consulter attributes(7).
┌──────────────────────┬──────────────────────┬─────────┐
│ Interface │ Attribut │ Valeur │
├──────────────────────┼──────────────────────┼─────────┤
│ malloc(), free(), │ Sécurité des threads │ MT-Safe │
│ calloc(), realloc() │ │ │
└──────────────────────┴──────────────────────┴─────────┘
CONFORMITÉ
malloc(), free(), calloc(), realloc() : POSIX.1-2001, POSIX.1-2008, C89, C99.
reallocarray() est une extension non standard apparue pour la première fois dans OpenBSD 5.6 et
FreeBSD 11.0.
NOTES
Par défaut, Linux suit une stratégie d'allocation optimiste. Cela signifie que lorsque malloc() ne
renvoie pas NULL, il n'y a aucune garantie que la mémoire soit véritablement disponible. S'il devait
s'avérer que le système manque de mémoire, un ou plusieurs processus seront tués par l'infâme « OOM
killer » (gestionnaire de mémoire). Pour plus d'informations, consultez la description de
/proc/sys/vm/overcommit_memory et /proc/sys/vm/oom_adj dans proc(5), ainsi que le fichier
Documentation/vm/overcommit-accounting des sources du noyau Linux.
En général, malloc() alloue la mémoire depuis le tas, et ajuste la taille du tas en conséquence avec
sbrk(2). Lorsque les blocs de mémoire alloués sont plus larges que MMAP_THRESHOLD octets,
l'implémentation de la glibc de malloc alloue la mémoire selon une projection anonyme privée avec
mmap(2). MMAP_THRESHOLD vaut 128 ko par défaut et il est ajustable avec mallopt(3). Avant Linux 4.7, les
allocations réalisées avec mmap(2) n’étaient pas affectées par la limitation de ressource RLIMIT_DATA ;
depuis Linux 4.7, cette limite est aussi prise en compte pour les allocations faites avec mmap(2).
Pour éviter les corruptions d'applications multithread, les mutex sont utilisés en interne pour protéger
les structures de données de gestion de mémoire utilisées dans ces fonctions. Dans une application
multithread où les threads allouent et libèrent la mémoire en même temps, ces mutex risquent d'entrer en
conflit. Pour gérer l'allocation de mémoire de façon évolutive dans les applications multithread, la
glibc crée des domaines d'allocation mémoire si un conflit de mutex est détecté. Chaque domaine est un
grand espace de mémoire qui est alloué en interne par le système (en utilisant brk(2) ou mmap(2)) et géré
avec ses propres mutex.
SUSv2 contraint malloc(), calloc() et realloc() à positionner errno à ENOMEM en cas d'échec. La glibc
suppose qu'il en est ainsi (et les versions glibc de ces routines le font) ; si vous utilisez une
implémentation personnelle de malloc() qui ne positionne pas errno, certaines routines de bibliothèques
peuvent échouer sans indiquer de raison dans errno.
Lorsqu'un programme échoue durant un appel à malloc(), calloc(), realloc() ou free(), cela est presque
toujours le signe d'une corruption du tas. Cela survient généralement en cas de débordement d'un bloc
mémoire alloué ou en libérant deux fois le même pointeur.
L'implémentation de malloc() est personnalisable à l'aide des variables d'environnement. Pour plus de
précisions, consultez mallopt(3).
VOIR AUSSI
valgrind(1), brk(2), mmap(2), alloca(3), malloc_get_state(3), malloc_info(3), malloc_trim(3),
malloc_usable_size(3), mallopt(3), mcheck(3), mtrace(3), posix_memalign(3)
Pour des détails sur l'implémentation de la bibliothèque GNU C, consulter
https://sourceware.org/glibc/wiki/MallocInternals.
COLOPHON
Cette page fait partie de la publication 5.10 du projet man-pages Linux. Une description du projet et des
instructions pour signaler des anomalies et la dernière version de cette page peuvent être trouvées à
l'adresse https://www.kernel.org/doc/man-pages/.
TRADUCTION
La traduction française de cette page de manuel a été créée par Christophe Blaess
<https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry Vignaud
<tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>, Jean-Philippe Guérard
<fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-luc.coulon@wanadoo.fr>, Julien Cristau
<jcristau@debian.org>, Thomas Huriaux <thomas.huriaux@gmail.com>, Nicolas François
<nicolas.francois@centraliens.net>, Florentin Duneau <fduneau@gmail.com>, Simon Paillard
<simon.paillard@resel.enst-bretagne.fr>, Denis Barbier <barbier@debian.org>, David Prévot
<david@tilapin.org> et Grégoire Scano <gregoire.scano@malloc.fr>
Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License
version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à
debian-l10n-french@lists.debian.org.
GNU 9 juin 2020 MALLOC(3)