Provided by: manpages-fr-dev_4.21.0-2_all bug

NOM

       malloc,  free,  calloc,  realloc,  reallocarray  —  Allocation  et  libération  de mémoire
       dynamique

BIBLIOTHÈQUE

       Bibliothèque C standard (libc, -lc)

SYNOPSIS

       #include <stdlib.h>

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

   Exigences   de   macros   de   test   de   fonctionnalités   pour    la    glibc    (consulter
   feature_test_macros(7)) :

       reallocarray() :
           Depuis la glibc 2.29 :
               _DEFAULT_SOURCE
           glibc 2.28 et précédentes :
               _GNU_SOURCE

DESCRIPTION

   malloc()
       La  fonction  malloc() alloue taille octets et renvoie un pointeur sur la mémoire allouée.
       Le contenu de la zone de mémoire n'est pas initialisé. Si taille est nulle, malloc renvoie
       une  valeur  de pointeur unique qui pourra être passée ultérieurement à free() avec succès
       (consulter « Comportement non portable » pour les problèmes de portabilité).

   free()
       La fonction free() libère l'espace mémoire pointé par ptr qui doit avoir été  obtenu  lors
       d'un appel antérieur à malloc() ou une fonction de la même famille. Autrement, ou si ptr a
       déjà été libéré, le comportement est indéterminé. Si ptr est NULL, aucune opération  n'est
       effectuée.

   calloc()
       La  fonction  calloc()  alloue  de  la mémoire pour un tableau de nmemb éléments de taille
       taille octets chacun et renvoie un pointeur sur la mémoire allouée. La  zone  mémoire  est
       initialisée  à 0. Si nmemb ou taille vaut 0, calloc() renvoie alors une valeur de pointeur
       unique qui pourra être passée ultérieurement à free() avec succès.

       Si la multiplication de nmemb  par  taille  provoque  un  dépassement  d'entier,  calloc()
       renvoie  une  erreur.  Par  contre,  aucun  dépassement d'entier ne serait détecté lors de
       l'appel suivant à malloc(), avec  pour  conséquence  l'allocation  d'un  bloc  de  mémoire
       incorrectement dimensionné :

           malloc(nmemb * taille);

   realloc()
       La fonction realloc() modifie la taille du bloc de mémoire pointé par ptr à taille octets.
       Le contenu de la mémoire entre la zone de départ et le minimum des  ancienne  et  nouvelle
       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 égal à NULL, l'appel est équivalent à malloc(taille) pour toutes les valeurs de
       taille.

       Si  taille  est  égale  à  zéro  et si ptr est différent de NULL, l'appel est équivalent à
       free(ptr) (consulter  cependant  « Comportement  non  portable »  pour  les  problèmes  de
       portabilité).

       Excepté  le cas où ptr est égal à NULL, il doit avoir été renvoyé par un appel précédent à
       malloc ou à une fonction de la même famille. Si la zone pointée a  été  déplacée,  l'appel
       free(ptr) est effectué.

   reallocarray()
       La fonction reallocarray() déplace éventuellement le bloc mémoire pointé par ptr et change
       sa taille pour qu'il soit suffisamment grand pour contenir un tableau  de  nmemb  éléments
       faisant chacun taille octets. Elle équivaut à l'appel

           realloc(ptr, nmemb * taille);

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

VALEUR RENVOYÉE

       Les  fonctions  malloc(), calloc(), realloc() et reallocarray() renvoient un pointeur vers
       la mémoire allouée qui est correctement alignée pour n'importe quel type  dont  la  taille
       correspondra  à la taille demandée ou sera inférieure à cette dernière. Si elles échouent,
       elles renvoient NULL et définissent errno pour indiquer l'erreur. Essayer  d'allouer  plus
       que  PTRDIFF_MAX  octets  est  considéré  comme  une  erreur, car un objet de cette taille
       pourrait provoquer un dépassement lors d'une soustraction de pointeur ultérieure.

       La fonction free() ne renvoie aucune valeur et préserve errno.

       Les fonction realloc() et reallocarray() renvoient NULL si ptr est différent de NULL et si
       la  taille  demandée  est  égale  à  zéro,  ce  qui  n'est  pas considéré comme une erreur
       (consulter « Comportement non portable » pour les problèmes de portabilité). Dans  le  cas
       contraire,  le  pointeur  renvoyé peut être identique à ptr si la zone mémoire n'a pas été
       déplacée (par exemple s'il y a assez de place pour l'étendre à son emplacement),  ou  peut
       être  différent  de  ptr  si la zone mémoire a été déplacée à une nouvelle adresse. Si ces
       fonctions échouent, le bloc mémoire originel reste intact ; il n'est ni libéré ni déplacé.

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() a été ajoutée dans la glibc 2.26.

       Depuis  la  glibc  2.30, malloc() et les fonctions de la même famille refusent les tailles
       supérieures à PTRDIFF_MAX.

       Depuis la glibc 2.33, free() préserve errno.

ATTRIBUTS

       Pour une explication des termes utilisés dans cette section, consulter attributes(7).

       ┌────────────────────────────────────────────────────────┬──────────────────────┬─────────┐
       │InterfaceAttributValeur  │
       ├────────────────────────────────────────────────────────┼──────────────────────┼─────────┤
       │malloc(), free(), calloc(), realloc()                   │ Sécurité des threads │ MT-Safe │
       └────────────────────────────────────────────────────────┴──────────────────────┴─────────┘

STANDARDS

       malloc(), free(), calloc(), realloc() : POSIX.1-2001, POSIX.1-2008, 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 seraient 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.rst 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.

       Si votre programme utilise un allocateur de mémoire privé, il doit le faire en  remplaçant
       malloc(), free(), calloc() et realloc(). Les fonctions de remplacement doivent implémenter
       les comportements de la glibc documentés, y compris la gestion de errno,  les  allocations
       de  taille  nulle  et  la surveillance des dépassements ; si ce n'est pas le cas, d'autres
       routines de la bibliothèque pourront se planter ou fonctionner de manière incorrecte.  Par
       exemple,  si  la  fonction  qui  remplace free() ne préserve pas errno, des routines de la
       bibliothèque apparemment sans rapport pourront échouer sans  indiquer  de  raison  valable
       dans  errno.  Un  allocateur  de  mémoire  privé  devra peut-être aussi remplacer d'autres
       fonctions de la glibc ; consulter « Remplacer malloc » dans le manuel  de  la  glibc  pour
       plus de détails.

       L'échec  d'un allocateur de mémoire est presque toujours le signe d'une corruption du tas,
       à l'instar d'un débordement de bloc mémoire alloué ou  d'une  double  libération  du  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 ces fonctions lorsque la taille demandée est égale à 0 est spécifique à
       la  glibc ;  d'autres  implémentations  peuvent  renvoyer  NULL  sans définir errno et les
       programmes  POSIX  portables  doivent  tenir  compte  de  ces   comportements.   Consultez
       realloc(3p).

       La  norme POSIX exige des allocateurs de mémoire qu'ils renseignent errno en cas d'erreur.
       Ce n'est cependant pas le cas de la  norme C,  et  les  applications  portables  vers  des
       plateformes non-POSIX ne sont donc pas tenues de se plier à cette contrainte.

       Les  programmes portables ne doivent pas utiliser d'allocateurs de mémoire privés, car les
       normes C et POSIX ne permettent  pas  le  remplacement  des  fonctions  malloc(),  free(),
       calloc() et realloc().

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

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>, Grégoire Scano
       <gregoire.scano@malloc.fr> et Lucien Gentis <lucien.gentis@waika9.com>

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