realloc

MALLOC(3)                   Linux-Programmierhandbuch                  MALLOC(3)



BEZEICHNUNG
       malloc, free, calloc, realloc, reallocarray - 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():
           Seit glibc 2.29:
               _DEFAULT_SOURCE
           Glibc 2.28 und älter:
               _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. Falls die
       Multiplikation von nmemb und size zu einem Ganzzahlüberlauf führen würde,
       dann liefert calloc() einen Fehler zurück. Im Gegensatz dazu würde ein
       Ganzzahlüberlauf in dem nachfolgenden Aufruf von malloc() nicht erkannt
       werden, was zu einer Zuweisung eines Speicherblocks mit falscher Größe
       führen würde:

           malloc(nmemb * size);

       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 oder
       NULL, falls die Anfrage fehlschlug. Der zurückgelieferte Zeiger kann zu
       ptr identisch sein, falls die Belegung nicht verschoben wurde (z.B. weil
       genug Platz vorhanden war, um die Belegung am Ort selbst zu vergrößern)
       oder sich von ptr unterscheiden, falls die Belegung an eine neue Adresse
       verschoben wurde. 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.

VERSIONEN
       reallocarray() kam erstmals in Glibc 2.26 vor.

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

       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() mithilfe von mmap(2) den Speicher als
       ein privates anonymes Mapping. MMAP_THRESHOLD ist standardmäßig 128 kB,
       kann aber mittels mallopt(3) angepasst werden. Vor Linux 4.7 waren
       Reservierungen unter Verwendung von mmap(2) von der
       Ressourcenbeschränkung RLIMIT_DATA nicht betroffen; seit Linux 4.7 wird
       diese Beschränkung auch bei Reservierungen mittels mmap(2) durchgesetzt.

       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)

       Für Details über die GNU-C-Bibliotheksimplementierung, siehe
       ⟨https://sourceware.org/glibc/wiki/MallocInternals⟩.

KOLOPHON
       Diese Seite ist Teil der Veröffentlichung 5.08 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>.



GNU                               9. Juni 2020                         MALLOC(3)