NOM

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

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);

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

       La fonction 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.

       La  fonction realloc() modifie la taille du bloc de mémoire pointé par ptr à la taille de size octets. Le
       contenu de la mémoire entre la zone de départ et la plus petite taille entre la  nouvelle  et  l'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 ptr est non NULL, l'appel est équivalent à
       free(ptr). Si ptr est 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

       Les  fonctions  malloc()  et calloc() renvoient un pointeur vers la mémoire allouée, qui est correctement
       alignée pour n'importe quel type intégré. 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
       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,  qui  est  correctement
       alignée  pour  n'importe  quel  type  intégré,  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

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

       Pour éviter les corruptions d'applications multithreadées,  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ée 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ées, 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.

       Le standard UNIX 98 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  dernières versions de libc Linux (depuis 5.4.23) et de glibc (2.x) contiennent une implémentation de
       malloc() qui est personnalisable à  l'aide  des  variables  d'environnement.  Pour  plus  de  précisions,
       consultez mallopt(3).

VOIR AUSSI

       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)

COLOPHON

       Cette page fait partie de la publication 3.57 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

       Depuis 2010, cette traduction est maintenue à l'aide de l'outil po4a <http://po4a.alioth.debian.org/> par
       l'équipe de traduction francophone au sein du projet perkamon <http://perkamon.alioth.debian.org/>.

       Christophe Blaess <http://www.blaess.fr/christophe/> (1996-2003), Alain Portal
       <http://manpagesfr.free.fr/> (2003-2006). Florentin Duneau et l'équipe francophone de traduction de
       Debian (2006-2009).

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