Provided by: manpages-de-dev_2.5-1_all 
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);
void *reallocarray(void *ptr, size_t nmemb, size_t size);
Mit Glibc erforderliche Makros (siehe feature_test_macros(7)):
reallocarray():
_GNU_SOURCE
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.
Die Funktion reallocarray() ändert die Größe des Speicherblocks, auf den ptr zeigt, damit
er groß genug für ein Feld von nmemb Elementen mit jeweils size bytes ist. Sie ist
äquivalent zu dem Aufruf:
realloc(ptr, nmemb * size);
Allerdings schlägt reallocarray(), anders als obiger Aufruf von realloc(), sicher fehl,
wenn die Multiplikation überliefe. Falls solch ein Überlauf auftritt, liefert
reallocarray() NULL, setzt errno auf ENOMEM und lässt den ursprünglichen Speicherblock
unverändert.
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.
Im Erfolgsfall liefert die Funktion reallocarray() einen Zeiger auf den neu belegten
Speicher zurück. Beim Fehlschlag liefert sie NULL und der ursprüngliche Speicherblock
bleibt unverändert.
FEHLER
calloc(), malloc(), realloc() und reallocarray() können mit den folgenden Fehlern
fehlschlagen:
ENOMEM Speicher erschöpft. Möglicherweise erreichte die Anwendung die in getrlimit(2)
beschriebene Grenze RLIMIT_AS oder RLIMIT_DATA.
ATTRIBUTE
Siehe attributes(7) für eine Erläuterung der in diesem Abschnitt verwandten Ausdrücke.
┌─────────────────────┬───────────────────────┬─────────┐
│Schnittstelle │ Attribut │ Wert │
├─────────────────────┼───────────────────────┼─────────┤
│malloc(), free(), │ Multithread-Fähigkeit │ MT-Safe │
│calloc(), realloc() │ │ │
└─────────────────────┴───────────────────────┴─────────┘
KONFORM ZU
malloc(), free(), calloc(), realloc(): POSIX.1-2001, POSIX.1-2008, C89, C99.
reallocarray() ist eine nicht standardisierte Erweiterung, die erstmals in OpenBSD 5.6 und
FreeBSD 11.0 erschien.
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.
Normally, malloc() allocates memory from the heap, and adjusts the size of the heap as
required, using sbrk(2). When allocating blocks of memory larger than MMAP_THRESHOLD
bytes, the glibc malloc() implementation allocates the memory as a private anonymous
mapping using mmap(2). MMAP_THRESHOLD is 128 kB by default, but is adjustable using
mallopt(3). Prior to Linux 4.7 allocations performed using mmap(2) were unaffected by the
RLIMIT_DATA resource limit; since Linux 4.7, this limit is also enforced for allocations
performed using mmap(2).
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
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)
KOLOPHON
Diese Seite ist Teil der Veröffentlichung 4.15 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 https://www.kernel.org/doc/man-pages/.
ÜBERSETZUNG
Die deutsche Übersetzung dieser Handbuchseite wurde von Martin Eberhard Schauer
<Martin.E.Schauer@gmx.de>, Mario Blättermann <mario.blaettermann@gmail.com> und Helge
Kreutzmann <debian@helgefjell.de> 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>.