Namespaces
Variants

calloc

From cppreference.net
C
Dynamic memory management
Definiert in Header <stdlib.h>
void * calloc ( size_t num, size_t size ) ;

Reserviert Speicher für ein Array von num Objekten der Größe size und initialisiert alle Bytes im reservierten Speicher mit Null.

Wenn die Allokation erfolgreich ist, gibt sie einen Zeiger auf das niedrigste (erste) Byte im allokierten Speicherblock zurück, das für jeden Objekttyp mit fundamentaler Ausrichtung geeignet ausgerichtet ist.

Wenn size null ist, ist das Verhalten implementierungsdefiniert (es kann ein Nullzeiger zurückgegeben werden, oder es kann ein Nicht-Null-Zeiger zurückgegeben werden, der möglicherweise nicht zum Zugriff auf Speicher verwendet werden darf).

calloc ist threadsicher: Es verhält sich so, als ob es nur auf die Speicherbereiche zugreift, die durch sein Argument sichtbar sind, und nicht auf statischen Speicher.

Ein vorheriger Aufruf von free , free_sized , und free_aligned_sized (seit C23) oder realloc , der einen Speicherbereich freigibt, synchronisiert mit einem Aufruf von calloc , der denselben oder einen Teil desselben Speicherbereichs allokiert. Diese Synchronisation erfolgt nach jedem Zugriff auf den Speicher durch die freigebende Funktion und vor jedem Zugriff auf den Speicher durch calloc . Es gibt eine einzige Gesamtreihenfolge aller Allokierungs- und Freigabefunktionen, die auf jeden bestimmten Speicherbereich wirken.

(seit C11)

Inhaltsverzeichnis

Parameter

num - Anzahl der Objekte
size - Größe jedes Objekts

Rückgabewert

Bei Erfolg gibt die Funktion einen Zeiger auf den Anfang des neu allokierten Speichers zurück. Um einen Speicherverlust zu vermeiden, muss der zurückgegebene Zeiger mit free() oder realloc() freigegeben werden.

Bei Fehler wird ein Nullzeiger zurückgegeben.

Hinweise

Aufgrund der Ausrichtungsanforderungen entspricht die Anzahl der zugewiesenen Bytes nicht notwendigerweise num * size .

Die Initialisierung auf alle Bits Null garantiert nicht, dass ein Gleitkommawert oder ein Zeiger jeweils auf 0.0 und den Nullzeigerwert initialisiert werden (obwohl dies auf allen gängigen Plattformen zutrifft).

Ursprünglich (in C89) wurde die Unterstützung für Null-Größe hinzugefügt, um Code wie folgenden zu ermöglichen: 

OBJ* p = calloc(0, sizeof(OBJ)); // Platzhalter mit "Null-Länge"
...
while(1)
{
    p = realloc(p, c * sizeof(OBJ)); // Neuzuweisungen bis die Größe sich stabilisiert
    ... // Code, der c ändern oder die Schleife abbrechen kann
}

Beispiel

Diesen Code ausführen 
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    int* p1 = calloc(4, sizeof(int));    // allokiere und nullinitialisiere ein Array von 4 int
    int* p2 = calloc(1, sizeof(int[4])); // dasselbe, mit direktem Typnamen des Arrays
    int* p3 = calloc(4, sizeof *p3);     // dasselbe, ohne Wiederholung des Typnamens
    if (p2)
    {
        for (int n = 0; n < 4; ++n) // gebe das Array aus
            printf("p2[%d] == %d\n", n, p2[n]);
    }
    free(p1);
    free(p2);
    free(p3);
}

Ausgabe: 

p2[0] == 0
p2[1] == 0
p2[2] == 0
p2[3] == 0

Referenzen

  • C23-Standard (ISO/IEC 9899:2024):
  • 7.22.3.2 Die calloc-Funktion (S.: TBD)
  • C17-Standard (ISO/IEC 9899:2018):
  • 7.22.3.2 Die calloc-Funktion (S: 253)
  • C11-Standard (ISO/IEC 9899:2011):
  • 7.22.3.2 Die calloc-Funktion (S: 348)
  • C99-Standard (ISO/IEC 9899:1999):
  • 7.20.3.1 Die calloc-Funktion (S: 313)
  • C89/C90 Standard (ISO/IEC 9899:1990):
  • 4.10.3.1 Die calloc-Funktion

Siehe auch

C++ Dokumentation für calloc