Provided by: manpages-fr-dev_2.80.1-1_all bug

NOM

       malloc,  calloc, free, realloc - Allocation et libération dynamiques de
       mémoire

SYNOPSIS

       #include <stdlib.h>

       void *calloc(size_t nmemb, size_t size);
       void *malloc(size_t size);
       void free(void *ptr);
       void *realloc(void *ptr, size_t size);

DESCRIPTION

       calloc() alloue la mémoire nécessaire pour un tableau de nmemb éléments
       de  size  octets, et renvoie un pointeur vers la mémoire allouée. Cette
       zone est remplie avec des zéros. Si nmemb ou si size est nulle,  calloc
       renvoie  soit  NULL  ou  un  unique  pointeur  qui  pourra  être  passé
       ultérieurement à free() avec succès.

       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.

       free()  libère  l’espace  mémoire pointé par ptr, qui a été obtenu lors
       d’un appel antérieur à malloc(), calloc() ou realloc(). Si le  pointeur
       ptr  n’a  pas  été  obtenu  par  l’un de ces appels, ou s’il a déjà été
       libéré avec free(ptr), le comportement  est  indéterminé.  Si  ptr  est
       NULL, aucune opération n’est effectuée.

       realloc()  modifie  la  taille  du  bloc de mémoire pointé par ptr pour
       l’amener à une taille de size octets. realloc() conserve le contenu  de
       la  zone  mémoire  minimum  entre  la nouvelle et l’ancienne taille. Le
       contenu  de  la  zone  de  mémoire  nouvellement  allouée   n’est   pas
       initialisé.  Si  ptr  est  NULL,  l’appel de realloc() est équivalent à
       malloc(size), pour toute valeur de size. Si size vaut zéro, l’appel est
       é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 free(ptr) est effectué.

VALEUR RENVOYÉE

       calloc()  et malloc() renvoient un pointeur sur la mémoire allouée, qui
       est correctement alignée pour n’importe quel type de variable. Si elles
       échouent, elles renvoient NULL. NULL peut également être renvoyé par un
       appel réussi à malloc() avec un paramètre size égal à zéro, ou  par  un
       appel réussi de realloc() avec nmemb ou size égal à zéro.

       free() ne renvoie pas de valeur.

       realloc()  renvoie un pointeur sur la mémoire nouvellement allouée, qui
       est correctement alignée pour n’importe quel type de variable,  et  qui
       peut  être différent de ptr, ou NULL si la demande échoue. 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é.

CONFORMITÉ

       C89, C99.

NOTES

       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 bloques 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 un
       projection anonyme privée avec mmap(2). MMAP_THRESHOLD vaut 128 Ko  par
       défaut  et  il est ajustable avec mallopt(3). Les allocations réalisées
       avec mmap(2) ne sont pas  affectées  par  la  limitation  de  ressource
       RLIMIT_DATA (consultez getrlimit(2)).

       Le  standard  Unix98  nécessite  que  malloc(),  calloc()  et realloc()
       positionnent 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 donner
       de raison dans errno.

       Lorsqu’un programme  échoue  durant  un  appel  à  malloc(),  calloc(),
       realloc()   ou  free(),  ceci  est  presque  toujours  le  signe  d’une
       corruption du tas. Ceci 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.

       Les  versions récentes de la bibliothèque libc de Linux (postérieures à
       5.4.23) et de la bibliothèque glibc 2.x incluent une implémentation  de
       malloc()  dont on peut configurer le comportement à l’aide de variables
       d’environnement. Quand la variable MALLOC_CHECK_ existe, les  appels  à
       malloc()  emploient  une  implémentation spéciale (moins efficace) mais
       plus tolérante à l’encontre des bogues simples, comme le double appel à
       free()  avec  le même argument, ou lors d’un débordement de tampon d’un
       seul octet (bogues de surpassement d’une unité, ou oubli d’un caractère
       nul final d’une chaîne). Il n’est toutefois pas possible de se protéger
       contre toutes les erreurs de ce type, et l’on risque de voir des fuites
       de  mémoire se produire. Si la variable MALLOC_CHECK_ vaut zéro, toutes
       les corruptions du tas détectées sont ignorées silencieusement. Si elle
       vaut  1,  un message de diagnostic est affiché sur stderr. Si elle vaut
       2, la fonction abort(3) est appelée immédiatement. Si elle vaut  3,  un
       message de diagnostic est affiché sur stderr et le proramme est arrêté.
       L’utilisation des valeurs non nulle de MALLOC_CHECK_  peut  être  utile
       car  un  crash  pourrait  se produire ultérieurement, et il serait très
       difficile de trouver la cause du problème.

BOGUES

       Par défaut, Linux  suit  une  stratégie  d’allocation  optimiste.  Ceci
       signifie  que  lorsque  malloc()  renvoie une valeur non NULL, il n’y a
       aucune garantie que la mémoire  soit  véritablement  disponible.  C’est
       vraiment  un  bogue  ennuyeux.  Dans  le  cas  où  le système manque de
       mémoire, un ou plusieurs  processus  seront  tués  par  l’infâme  « OOM
       killer »  (gestionnaire  de  mémoire)  .  Si Linux est utilisé dans des
       circonstances où il n’est pas souhaitable de  perdre  soudainement  des
       processus  lancés  aléatoirement, et si de plus la version du noyau est
       suffisamment récente, il est possible  de  désactiver  ce  comportement
       avec une commande comme :

           # echo 2 > /proc/sys/vm/overcommit_memory

       Voir  également  les fichiers vm/overcommit-accounting et sysctl/vm.txt
       dans le répertoire de la documentation du noyau.

VOIR AUSSI

       brk(2), mmap(2), alloca(3), posix_memalign(3)

COLOPHON

       Cette page fait partie de  la  publication  2.80  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      être       trouvées       à       l’adresse
       http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Cette  page  de  manuel  a  été  traduite et mise à jour par Christophe
       Blaess <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis  par
       Alain  Portal  <aportal AT univ-montp2 DOT fr> jusqu’en 2006, et mise à
       disposition sur http://manpagesfr.free.fr/.

       Les mises à jour et corrections de la version présente dans Debian sont
       directement gérées par Florentin Duneau <fduneau@gmail.com> et l’équipe
       francophone de traduction de Debian.

       Veuillez  signaler  toute  erreur   de   traduction   en   écrivant   à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous pouvez toujours avoir accès à la version anglaise de  ce  document
       en utilisant la commande « man -L C <section> <page_de_man> ».