Namespaces
Variants

std:: calloc

From cppreference.net
< cpp ‎ | memory ‎ | c
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
Definiert im Header <cstdlib>
void * calloc ( std:: size_t num, std:: size_t size ) ;

Reserviert Speicher für ein Array von num Objekten der Größe size , initialisiert diesen mit allen Bits auf Null ( implizit erzeugende Objekte im Zielbereich).

Wenn die Allokierung erfolgreich ist, gibt sie einen Zeiger auf das niedrigste (erste) Byte im allokierten Speicherblock zurück, das für jeden Objekttyp 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 für den Zugriff auf Speicher verwendet werden darf).

Die folgenden Funktionen müssen thread-sicher sein:

Aufrufe dieser Funktionen, die eine bestimmte Speichereinheit allozieren oder deallozieren, erfolgen in einer einzigen Gesamtordnung, und jeder solche Deallokationsaufruf happens-before der nächsten Allokation (falls vorhanden) in dieser Ordnung.

(seit C++11)

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 std::free() oder std::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 bzw. den Nullzeigerwert initialisiert wird (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)); // "Null-Längen"-Platzhalter
...
while (1)
{ 
    p = realloc(p, c * sizeof(OBJ)); // Neuzuweisungen bis Größe sich stabilisiert
    ... // Code, der c ändern oder Schleife abbrechen kann
}

Beispiel

Diesen Code ausführen 
#include <cstdlib>
#include <iostream>
int main()
{
    int* p1 = (int*)std::calloc(4, sizeof(int)); // allokiere und setze ein Array von 4 int auf Null
    int* p2 = (int*)std::calloc(1, sizeof(int[4])); // dasselbe, mit direktem Typnamen des Arrays
    int* p3 = (int*)std::calloc(4, sizeof *p3); // dasselbe, ohne Wiederholung des Typnamens
    if (p2)
        for (int n = 0; n < 4; ++n) // gebe das Array aus
            std::cout << "p2[" << n << "] == " << p2[n] << '\n';
    std::free(p1);
    std::free(p2);
    std::free(p3);
}

Ausgabe: 

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

Siehe auch

C-Dokumentation für calloc