Provided by: manpages-de-dev_1.11-1_all bug

BEZEICHNUNG

       malloc, free, calloc, realloc - dynamischen Speicher belegen und freigeben

ÜBERSICHT

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

BESCHREIBUNG

       malloc()  belegt  size Byte und gibt einen Zeiger auf den belegten Speicherbereich zurück.
       Der Speicher wird nicht initialisiert. Falls size  0  ist,  wird  malloc()  entweder  NULL
       zurückgeben  oder einen eindeutigen Zeigerwert, der später erfolgreich an free() übergeben
       werden kann.

       free() gibt den Speicher frei, auf den ptr zeigt, welcher von einem  früheren  Aufruf  von
       malloc(), calloc() oder realloc() belegt worden sein muss. Andernfalls oder wenn free(ptr)
       bereits aufgerufen wurde, ist das Verhalten nicht definiert. Wenn ptr NULL ist, wird keine
       Operation ausgeführt.

       calloc()  belegt Speicher für ein Array von nmemb Elementen von jeweils size Byte und gibt
       einen Zeiger auf den belegten Speicherbereich zurück. Der Speicher wird auf Null  gesetzt.
       Falls  nmemb  oder  size  0 ist, gibt calloc() entweder NULL zurück oder einen eindeutigen
       Zeigerwert, der später erfolgreich an free() übergeben werden kann.

       realloc() ändert die Größe des Speicherblocks, auf den  ptr  zeigt,  auf  size  Byte.  Der
       Inhalt  bleibt  unverändert im Bereich vom Anfang des Speicherbereichs bis zum Minimum von
       alter und neuer Größe. Falls die neue Größe die alte überschreitet, wird  der  zusätzliche
       Speicher  nicht  initialisiert.  Falls  ptr  gleich NULL ist, ist der Aufruf äquivalent zu
       malloc(size); falls die Größe gleich Null ist und ptr ist von NULL  verschieden,  ist  der
       Aufruf äquivalent zu free(ptr). Wenn ptr nicht NULL ist, muss er von einem früheren Aufruf
       von malloc(), calloc() oder realloc() zurückgegeben worden sein. Falls  der  Bereich,  auf
       den verwiesen wurde, verschoben wurde, wird free(ptr) aufgerufen.

RÜCKGABEWERT

       Die  Funktionen  malloc() und calloc() liefern einen Zeiger auf den reservierten Speicher,
       der geeignet für jeden eingebauten Typ ausgerichtet ist. Tritt ein Fehler auf, geben diese
       Funktionen  NULL  zurück. NULL kann auch durch einen erfolgreichen Aufruf von malloc() mit
       einer size von Null oder durch einen erfolgreichen Aufruf von calloc() mit nmemb oder size
       gleich Null zurückgegeben werden.

       Die Funktion free() gibt keinen Wert zurück.

       Die Funktion realloc() gibt einen Zeiger auf den neu belegten Speicher zurück, welcher für
       jeden eingebauten Typ passend ausgerichtet ist und sich von ptr unterscheiden  kann,  oder
       NULL falls die Anforderung scheitert. Falls size gleich 0 war, wird entweder NULL oder ein
       für die Übergabe an free() geeigneter  Zeiger  zurückgegeben.  Wenn  realloc()  scheitert,
       bleibt der ursprüngliche Block unverändert - er wird nicht freigegeben oder verändert.

FEHLER

       calloc(), malloc(), and realloc()  can fail with the following error:

       ENOMEM Out  of  memory.  Possibly,  the application hit the RLIMIT_AS or RLIMIT_DATA limit
              described in getrlimit(2).

ATTRIBUTE

       Siehe attributes(7) für eine Erläuterung der in diesem Abschnitt verwandten Ausdrücke.

       ┌─────────────────────┬───────────────────────┬─────────┐
       │SchnittstelleAttributWert    │
       ├─────────────────────┼───────────────────────┼─────────┤
       │malloc(), free(),    │ Multithread-Fähigkeit │ MT-Safe │
       │calloc(), realloc()  │                       │         │
       └─────────────────────┴───────────────────────┴─────────┘

KONFORM ZU

       POSIX.1-2001, POSIX.1-2008, C89, C99.

ANMERKUNGEN

       Standardmäßig verfolgt Linux eine optimistische Strategie bei der  Speicherzuweisung.  Das
       bedeutet  nicht,  dass der Speicher garantiert verfügbar ist, wenn malloc() einen von NULL
       verschiedenen Zeiger zurück gibt. Falls es sich herausstellt, dass das System über  keinen
       freien  Speicher  verfügt,  werden ein oder mehrere Prozesse vom »OOM Killer« beendet. Für
       weitere  Informationen  siehe  die  Beschreibung  von  /proc/sys/vm/overcommit_memory  und
       /proc/sys/vm/oom_adj      in      proc(5)      sowie      die      Linux-Kernel-Quelldatei
       Documentation/vm/overcommit-accounting.

       Normalerweise stellt malloc() Speicher auf dem Heap bereit und passt je  nach  Bedarf  die
       Größe  des  Heaps  mittels  sbrk(2)  an.  Bei der Zuweisung von Speicherblöcken größer als
       MMAP_THRESHOLD Bytes reserviert die Glibc-Implementierung von malloc()  den  Speicher  als
       eine  private anonyme Zuordnung mithilfe von mmap(2). MMAP_THRESHOLD ist standardmäßig 128
       kB, kann aber mittels mallopt(3) angepasst werden.  Reservierungen  unter  Verwendung  von
       mmap(2)  sind  von  der  Ressourcenbeschränkung  RLIMIT_DATA  (siehe  getrlimit(2))  nicht
       betroffen.

       Um Verfälschungen in Multithread-Anwendungen zu vermeiden, werden intern Mutexe zum Schutz
       der  Speicherverwaltungs-Datenstrukturen  eingesetzt,  die  von  diesen Funktionen genutzt
       werden. In einer Multithread-Anwendung, in denen Threads  gleichzeitig  Speicher  zuweisen
       und freigeben, könnte es Zugangskonflikte für diese Mutexe geben. Um die Speicherzuweisung
       in Multithread-Anwendungen skalierbar zu  bewältigen,  erzeugt  Glibc  zusätzliche  memory
       allocation  arenas,  wenn  Mutex-Konflikte  entdeckt  wird.  Jede  Arena  ist  eine  große
       Speicherregion, die intern vom System (mit brk(2) oder mmap(2)) zugeordnet und mit eigenen
       Mutexen verwaltet wird.

       SUSv2  fordert  von  malloc(),  calloc()  und  realloc() im Fehlerfall errno auf ENOMEM zu
       setzen. Glibc geht davon aus,  dass  das  getan  wurde  (und  die  Glibc-Versionen  dieser
       Routinen  tun  es).  Wenn Sie eine private Implementierung von malloc verwenden, die errno
       nicht setzt, können bestimmte Bibliotheksroutinen ohne einen Grund in errno fehlschlagen.

       Abstürze in malloc(), calloc(), realloc() oder free() haben nahezu immer  einen  Bezug  zu
       einem  beschädigten  Heap,  wie  z.B.  eine  Nutzung von mehr als dem zugeordneten Bereich
       (overflowing) oder die doppelte Freigabe eines Zeigers.

       Die malloc()-Implementierung kann über Umgebungsvariablen eingestellt werden. Für  Details
       siehe mallopt(3).

SIEHE AUCH

       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)

KOLOPHON

       Diese Seite ist Teil der Veröffentlichung 4.04 des Projekts Linux-man-pages. Eine
       Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die
       aktuelle Version dieser Seite finden sich unter http://www.kernel.org/doc/man-pages/.

ÜBERSETZUNG

       Die deutsche Übersetzung dieser Handbuchseite wurde von Martin Eberhard Schauer
       <Martin.E.Schauer@gmx.de> und Mario Blättermann <mario.blaettermann@gmail.com> erstellt.

       Diese Übersetzung ist Freie Dokumentation; lesen Sie die GNU General Public License
       Version 3 oder neuer bezüglich der Copyright-Bedingungen. Es wird KEINE HAFTUNG
       übernommen.

       Wenn Sie Fehler in der Übersetzung dieser Handbuchseite finden, schicken Sie bitte eine E-
       Mail an <debian-l10n-german@lists.debian.org>.