Namensräume
Varianten
Aktionen

std::calloc

Von cppreference.com
< cpp‎ | memory‎ | c
 
C++
 
Speicherverwaltungsbibliothek
(nur Exposition*)
Algorithmen für uninitialisierten Speicher
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
Beschränkte uninitialisierte
Speicher-Algorithmen
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20) 
(C++20)
C-Bibliothek
calloc

Allocatoren
(C++11)
(C++23)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20) 
(C++11)
(C++17)
Speicherressourcen
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Unterstützung für Garbage Collection
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
Uninitialisierter Speicher
(bis C++20*)
(bis C++20*)
(bis C++20*)
Explizites Lebenszeitmanagement
(C++23)(C++23)
 
Definiert in Header <cstdlib>
void* calloc( std::size_t num, std::size_t size );

Allokiert Speicher für ein Array von num Objekten der Größe size und initialisiert ihn mit allen Bits null (implizites Erstellen von Objekten im Zielbereich).

Wenn die Allokation erfolgreich ist, wird ein Zeiger auf das niedrigste (erste) Byte des allokierten Speicherblocks zurückgegeben, das für jeden Objekttyp geeignet ausgerichtet ist.

Wenn size null ist, ist das Verhalten implementierungsdefiniert (ein Nullzeiger kann zurückgegeben werden, oder ein Zeiger, der nicht zur Speicheradressierung verwendet werden kann).

Die folgenden Funktionen sind Thread-sicher erforderlich

Aufrufe dieser Funktionen, die eine bestimmte Speichereinheit zuweisen oder freigeben, erfolgen in einer einzigen Gesamtordnung, und jeder solche Freigabeaufruf happens-before die nächste Zuweisung (falls vorhanden) in dieser Ordnung.

 (seit C++11)

Inhalt

[edit] Parameter

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

[edit] Rückgabewert

Bei Erfolg wird der Zeiger auf den Anfang des neu allokierten Speichers zurückgegeben. Um einen Speicherleck zu vermeiden, muss der zurückgegebene Zeiger mit std::free() oder std::realloc() freigegeben werden.

Bei einem Fehler wird ein Nullzeiger zurückgegeben.

[edit] Hinweise

Aufgrund der Ausrichtungsanforderungen ist die Anzahl der allokierten Bytes nicht notwendigerweise gleich num * size.

Die Initialisierung aller Bits auf null garantiert nicht, dass Gleitkommazahlen oder Zeiger mit 0,0 bzw. dem Nullzeigerwert initialisiert werden (obwohl dies auf allen gängigen Plattformen der Fall ist).

Ursprünglich (in C89) wurde die Unterstützung für null Größe hinzugefügt, um Code wie z.B. zu ermöglichen

OBJ *p = calloc(0, sizeof(OBJ)); // "zero-length" placeholder
...
while (1)
{ 
    p = realloc(p, c * sizeof(OBJ)); // reallocations until size settles
    ... // code that may change c or break out of loop
}

[edit] Beispiel

Führen Sie diesen Code aus
#include <cstdlib>
#include <iostream>
 
int main()
{
    int* p1 = (int*)std::calloc(4, sizeof(int)); // allocate and zero out an array of 4 int
    int* p2 = (int*)std::calloc(1, sizeof(int[4])); // same, naming the array type directly
    int* p3 = (int*)std::calloc(4, sizeof *p3); // same, without repeating the type name
 
    if (p2)
        for (int n = 0; n < 4; ++n) // print the array
            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

[edit] Siehe auch

C-Dokumentation für calloc
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/c/calloc&oldid=179181"