Provided by: manpages-fr-dev_4.15.0-9_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
taille 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(), calloc(), realloc() │ Sécurité des threads │ MT-Safe │
└────────────────────────────────────────────────────────┴──────────────────────┴─────────┘
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).
Comportement non portable
Le comportement de realloc() lorsque size est égal à 0 et ptr n'est pas NULL est
spécifique à la glibc ; d'autres implémentations peuvent retourner NULL et fixer errno.
Les programmes POSIX portables doivent l'éviter. Consultez realloc(3p).
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.13 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 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ 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⟩.