Unterschied zwischen Malloc und Calloc?

Was ist der Unterschied zwischen:

ptr = (char **) malloc (MAXELEMS * sizeof(char *));

oder:

ptr = (char **) calloc (MAXELEMS, sizeof(char*));

Wann ist es eine gute Idee, Calloc über Malloc zu verwenden oder umgekehrt?

calloc() gibt Ihnen einen Null-initialisierten Puffer, während malloc() der Speicher nicht initialisiert wird.

Bei großen Zuweisungen erhalten die meisten callocImplementierungen unter Mainstream-Betriebssystemen Seiten mit bekannten Nullen vom Betriebssystem (z. B. über POSIX mmap(MAP_ANONYMOUS)oder Windows VirtualAlloc), sodass sie nicht im Benutzerbereich geschrieben werden müssen. Auf diese Weise mallocerhält normal auch mehr Seiten vom Betriebssystem. callocnutzt nur die Garantie des Betriebssystems.

Dies bedeutet, dass der callocSpeicher weiterhin "sauber" und träge zugewiesen werden kann und das Kopieren beim Schreiben einer systemweit gemeinsam genutzten physischen Seite mit Nullen zugeordnet werden kann. (Angenommen, ein System mit virtuellem Speicher.)

Einige Compiler können sogar malloc + memset (0) für Sie in calloc optimieren. Sie sollten calloc jedoch explizit verwenden, wenn der Speicher als gelesen werden soll 0 .

Wenn Sie vor dem Schreiben nie Speicher lesen werden, verwenden mallocSie ihn, damit Sie (möglicherweise) schmutzigen Speicher aus der internen freien Liste erhalten, anstatt neue Seiten vom Betriebssystem abzurufen. (Oder anstatt einen Speicherblock auf der freien Liste für eine kleine Zuordnung auf Null zu setzen).

Eingebettete Implementierungen von callockönnen es auf sich callocselbst belassen, wenn kein Betriebssystem vorhanden ist, oder es ist kein ausgefallenes Mehrbenutzer-Betriebssystem, das Seiten auf Null setzt, um Informationslecks zwischen Prozessen zu stoppen.

Unter eingebettetem Linux könnte malloc mmap(MAP_UNINITIALIZED|MAP_ANONYMOUS), das nur für einige eingebettete Kernel aktiviert ist, da es auf einem Mehrbenutzersystem unsicher ist.

Ein weniger bekannter Unterschied besteht darin, dass in Betriebssystemen mit optimistischer Speicherzuweisung wie Linux der von zurückgegebene Zeiger mallocnicht durch echten Speicher gesichert wird, bis das Programm ihn tatsächlich berührt.

callocBerührt tatsächlich den Speicher (es schreibt Nullen darauf) und Sie werden sicher sein, dass das Betriebssystem die Zuordnung mit tatsächlichem RAM (oder Swap) unterstützt. Dies ist auch der Grund, warum es langsamer als malloc ist (es muss nicht nur auf Null gesetzt werden, das Betriebssystem muss auch einen geeigneten Speicherbereich finden, indem es möglicherweise andere Prozesse austauscht).

Siehe zum Beispiel diese SO-Frage für weitere Diskussionen über das Verhalten von Malloc

Ein häufig übersehener Vorteil callocist, dass (konforme Implementierungen von) Sie vor Sicherheitslücken durch ganzzahligen Überlauf schützen. Vergleichen Sie:

size_t count = get_int32(file);
struct foo *bar = malloc(count * sizeof *bar);

vs.

size_t count = get_int32(file);
struct foo *bar = calloc(count, sizeof *bar);

Ersteres kann zu einer winzigen Zuordnung und nachfolgenden Pufferüberläufen führen, wenn countes größer als ist SIZE_MAX/sizeof *bar. Letzteres schlägt in diesem Fall automatisch fehl, da ein so großes Objekt nicht erstellt werden kann.

Natürlich müssen Sie möglicherweise nach nicht konformen Implementierungen Ausschau halten, bei denen die Möglichkeit eines Überlaufs einfach ignoriert wird. Wenn dies auf Plattformen, auf die Sie abzielen, ein Problem darstellt, müssen Sie ohnehin einen manuellen Test auf Überlauf durchführen.

Die Dokumentation lässt das Calloc wie ein Malloc aussehen, das den Speicher nur auf Null initialisiert. Das ist nicht der Hauptunterschied! Die Idee von Calloc besteht darin, auf die Copy-on-Write-Semantik für die Speicherzuweisung zu verzichten. Wenn Sie mit calloc Speicher zuweisen, werden alle derselben physischen Seite zugeordnet, die auf Null initialisiert wird. Wenn eine der Seiten des zugewiesenen Speichers in eine physische Seite geschrieben wird, wird sie zugewiesen. Dies wird häufig verwendet, um RIESIGE Hash-Tabellen zu erstellen, da beispielsweise die leeren Hash-Teile nicht durch zusätzlichen Speicher (Seiten) gesichert werden. Sie verweisen glücklich auf die einzelne Seite mit der Nullinitialisierung, die sogar von Prozessen gemeinsam genutzt werden kann.

Jedes Schreiben in eine virtuelle Adresse wird einer Seite zugeordnet. Wenn diese Seite die Nullseite ist, wird eine andere physische Seite zugewiesen, die Nullseite wird dort kopiert und der Steuerungsfluss wird an den Clientprozess zurückgegeben. Dies funktioniert genauso wie Speicherzuordnungsdateien, virtueller Speicher usw. Es wird Paging verwendet.

Hier ist eine Optimierungsgeschichte zum Thema: http://blogs.fau.de/hager/2007/05/08/benchmarking-fun-with-calloc-and-zero-pages/

Es gibt keinen Unterschied in der Größe des zugewiesenen Speicherblocks. callocFüllt einfach den Speicherblock mit einem physischen All-Null-Bit-Muster. In der Praxis wird häufig angenommen, dass die Objekte in dem mit zugewiesenen Speicherblock calloceinen Anfangswert haben, als ob sie mit einem Literal initialisiert worden wären 0, dh Ganzzahlen sollten den Wert von 0Gleitkommavariablen - Wert von 0.0Zeigern - den entsprechenden Nullzeigerwert haben , und so weiter.

Aus pedantischer Sicht wird jedoch calloc(wie auch memset(..., 0, ...)) nur garantiert, dass Objekte vom Typ (mit Nullen) ordnungsgemäß initialisiert werden unsigned char. Es wird nicht garantiert, dass alles andere ordnungsgemäß initialisiert wird, und es kann eine sogenannte Trap-Darstellung enthalten , die zu undefiniertem Verhalten führt. Mit anderen Worten, für jeden anderen Typ als unsigned chardas oben erwähnte All-Null-Bit-Muster könnte ein unzulässiger Wert eine Trap-Darstellung darstellen.

Später wurde in einer der technischen Berichtigungen zum C99-Standard das Verhalten für alle Ganzzahltypen definiert (was sinnvoll ist). Das heißt, formal können Sie in der aktuellen C-Sprache nur ganzzahlige Typen mit calloc(und memset(..., 0, ...)) initialisieren . Die Verwendung zum Initialisieren von anderen Elementen im allgemeinen Fall führt aus Sicht der C-Sprache zu undefiniertem Verhalten.

In der Praxis callocfunktioniert, wie wir alle wissen :), aber ob Sie es verwenden möchten (unter Berücksichtigung der oben genannten), liegt bei Ihnen. Ich persönlich bevorzuge es, es vollständig zu vermeiden, mallocstattdessen zu verwenden und meine eigene Initialisierung durchzuführen.

Schließlich ist ein weiteres wichtiges Detail callocerforderlich, um die endgültige Blockgröße intern zu berechnen , indem die Elementgröße mit der Anzahl der Elemente multipliziert wird. Achten Sie dabei callocauf einen möglichen arithmetischen Überlauf. Dies führt zu einer nicht erfolgreichen Zuordnung (Nullzeiger), wenn die angeforderte Blockgröße nicht korrekt berechnet werden kann. In der Zwischenzeit mallocunternimmt Ihre Version keinen Versuch, auf Überlauf zu achten. Für den Fall eines Überlaufs wird eine "unvorhersehbare" Speichermenge zugewiesen.

aus einem Artikel Benchmarking-Spaß mit calloc () und null Seiten in Georg Hagers Blog

Bei der Zuweisung von Speicher mit calloc () wird die angeforderte Speichermenge nicht sofort zugewiesen. Stattdessen werden alle Seiten, die zum Speicherblock gehören, durch eine MMU-Magie mit einer einzelnen Seite verbunden, die alle Nullen enthält (Links unten). Wenn solche Seiten nur gelesen werden (was in der Originalversion des Benchmarks für die Arrays b, c und d zutraf), werden die Daten von der einzelnen Nullseite bereitgestellt, die natürlich in den Cache passt. Soviel zu speichergebundenen Loop-Kerneln. Wenn eine Seite beschrieben wird (egal wie), tritt ein Fehler auf, die "echte" Seite wird zugeordnet und die Nullseite wird in den Speicher kopiert. Dies wird als Copy-on-Write bezeichnet, ein bekannter Optimierungsansatz (den ich in meinen C ++ - Vorlesungen sogar mehrmals unterrichtet habe). Nachdem,

callocist in der Regel malloc+memsetzu 0

Es ist im Allgemeinen etwas besser, malloc+memsetexplizit zu verwenden , insbesondere wenn Sie etwas tun wie:

ptr=malloc(sizeof(Item));
memset(ptr, 0, sizeof(Item));

Das ist besser, weil sizeof(Item)es dem Compiler zur Kompilierungszeit bekannt ist und der Compiler es in den meisten Fällen durch die bestmöglichen Anweisungen auf Null Speicher ersetzt. Auf der anderen Seite wird, wenn dies memsetgeschieht calloc, die Parametergröße der Zuordnung nicht im callocCode kompiliert , und es memsetwird häufig real aufgerufen, das normalerweise Code enthält, um Byte für Byte bis zur langen Grenze aufzufüllen, als Zyklus zum Füllen Speicherplatz insizeof(long) Blöcken auffüllen und schließlich byteweise den verbleibenden Speicherplatz ausfüllen. Selbst wenn der Allokator intelligent genug ist, um einige aufzurufen, handelt aligned_memsetes sich immer noch um eine generische Schleife.

Eine bemerkenswerte Ausnahme wäre, wenn Sie malloc / calloc eines sehr großen Speicherblocks (einige Potenzen von zwei Kilobyte) ausführen. In diesem Fall kann die Zuweisung direkt vom Kernel aus erfolgen. Da Betriebssystem-Kernel normalerweise den gesamten Speicher, den sie aus Sicherheitsgründen freigeben, auf Null setzen, gibt Calloc ihn möglicherweise ohne zusätzliche Nullung zurück. Nochmals: Wenn Sie nur etwas zuweisen, von dem Sie wissen, dass es klein ist, sind Sie mit malloc + memset in Bezug auf die Leistung möglicherweise besser dran.

Unterschied 1:

malloc() Ordnet normalerweise den Speicherblock zu und es wird ein Speichersegment initialisiert.

calloc() ordnet den Speicherblock zu und initialisiert den gesamten Speicherblock auf 0.

Unterschied 2:

Wenn Sie die malloc()Syntax berücksichtigen , wird nur 1 Argument benötigt. Betrachten Sie das folgende Beispiel:

data_type ptr = (cast_type *)malloc( sizeof(data_type)*no_of_blocks );

Beispiel: Wenn Sie 10 Speicherblöcke für den Typ int zuweisen möchten,

int *ptr = (int *) malloc(sizeof(int) * 10 );

Wenn Sie die calloc()Syntax berücksichtigen , werden 2 Argumente benötigt. Betrachten Sie das folgende Beispiel:

data_type ptr = (cast_type *)calloc(no_of_blocks, (sizeof(data_type)));

Beispiel: Wenn Sie 10 Speicherblöcke für den Typ int zuweisen und all das auf NULL initialisieren möchten,

int *ptr = (int *) calloc(10, (sizeof(int)));

Ähnlichkeit:

Beide malloc()und calloc()geben standardmäßig void * zurück, wenn sie nicht typisiert sind.!

Es gibt zwei Unterschiede.
Erstens ist in der Anzahl der Argumente. malloc()Nimmt ein einzelnes Argument (Speicher in Bytes erforderlich), während calloc()zwei Argumente benötigt werden.
Zweitens wird der zugewiesene Speicher malloc()nicht initialisiert, während calloc()der zugewiesene Speicher auf NULL initialisiert wird.

• calloc()Wenn ein Speicherbereich zugewiesen wird, ist die Länge das Produkt seiner Parameter. callocfüllt den Speicher mit NULL und gibt einen Zeiger auf das erste Byte zurück. Wenn nicht genügend Speicherplatz gefunden wird, wird ein NULLZeiger zurückgegeben.

Syntax: ptr_var=(cast_type *)calloc(no_of_blocks , size_of_each_block); dhptr_var=(type *)calloc(n,s);

• malloc()ordnet einen einzelnen Speicherblock mit der Größe REQUSTED SIZE zu und gibt einen Zeiger auf das erste Byte zurück. Wenn die erforderliche Speichermenge nicht gefunden werden kann, wird ein Nullzeiger zurückgegeben.

Syntax: ptr_var=(cast_type *)malloc(Size_in_bytes); Die malloc()Funktion verwendet ein Argument, dh die Anzahl der zuzuordnenden Bytes, während die calloc()Funktion zwei Argumente verwendet, eines die Anzahl der Elemente und das andere die Anzahl der zuzuordnenden Bytes für jedes dieser Elemente. Außerdem calloc()initialisiert den zugewiesenen Speicherplatz auf Nullen, während malloc()dies nicht tut.

Die calloc()im <stdlib.h>Header deklarierte Funktion bietet gegenüber der malloc()Funktion einige Vorteile .

1. Es ordnet Speicher als eine Anzahl von Elementen einer bestimmten Größe zu, und
2. Es initialisiert den zugewiesenen Speicher so, dass alle Bits Null sind.

malloc()und calloc()sind Funktionen aus der C-Standardbibliothek, die eine dynamische Speicherzuweisung ermöglichen, was bedeutet, dass beide die Speicherzuweisung zur Laufzeit ermöglichen.

Ihre Prototypen sind wie folgt:

void *malloc( size_t n);
void *calloc( size_t n, size_t t)

Es gibt hauptsächlich zwei Unterschiede zwischen den beiden:

• Verhalten: malloc()Weist einen Speicherblock zu, ohne ihn zu initialisieren, und das Lesen des Inhalts dieses Blocks führt zu Müllwerten. calloc()ordnet andererseits einen Speicherblock zu und initialisiert ihn mit Nullen, und das Lesen des Inhalts dieses Blocks führt offensichtlich zu Nullen.

• Syntax: malloc()Nimmt 1 Argument (die zuzuweisende Größe) und calloc()zwei Argumente (Anzahl der zuzuordnenden Blöcke und Größe jedes Blocks).

Der Rückgabewert von beiden ist bei Erfolg ein Zeiger auf den zugewiesenen Speicherblock. Andernfalls wird NULL zurückgegeben, um den Speicherzuordnungsfehler anzuzeigen.

Beispiel:

int *arr;

// allocate memory for 10 integers with garbage values
arr = (int *)malloc(10 * sizeof(int)); 

// allocate memory for 10 integers and sets all of them to 0
arr = (int *)calloc(10, sizeof(int));

Die gleiche Funktionalität wie calloc()mit malloc()und erreicht werden kann memset():

// allocate memory for 10 integers with garbage values   
arr= (int *)malloc(10 * sizeof(int));
// set all of them to 0
memset(arr, 0, 10 * sizeof(int)); 

Beachten Sie, dass dies malloc()vorzugsweise verwendet wird, calloc()da es schneller ist. Wenn die Werte auf Null initialisiert werden sollen, verwenden Sie calloc()stattdessen.

Ein noch nicht erwähnter Unterschied: Größenbeschränkung

void *malloc(size_t size)kann nur bis zuordnen SIZE_MAX.

void *calloc(size_t nmemb, size_t size);kann etwa zuordnen SIZE_MAX*SIZE_MAX.

Diese Fähigkeit wird auf vielen Plattformen mit linearer Adressierung nicht häufig verwendet. Solche Systeme begrenzen calloc()mitnmemb * size <= SIZE_MAX .

Stellen Sie sich einen Typ von 512 Bytes vor, der aufgerufen wird, disk_sectorund Code möchte viele Sektoren verwenden. Hier kann Code nur bis zu SIZE_MAX/sizeof disk_sectorSektoren verwenden.

size_t count = SIZE_MAX/sizeof disk_sector;
disk_sector *p = malloc(count * sizeof *p);

Beachten Sie Folgendes, was eine noch größere Zuordnung ermöglicht.

size_t count = something_in_the_range(SIZE_MAX/sizeof disk_sector + 1, SIZE_MAX)
disk_sector *p = calloc(count, sizeof *p);

Ob ein solches System eine so große Zuordnung liefern kann, ist eine andere Sache. Die meisten heute werden nicht. Es ist jedoch seit vielen Jahren aufgetreten, als SIZE_MAXes 65535 war. Angesichts des Gesetzes von Moore besteht der Verdacht, dass dies um 2030 bei bestimmten Speichermodellen mit SIZE_MAX == 4294967295und Speicherpools in 100 GByte auftreten wird.

Anzahl der Blöcke:
malloc () weist einen einzelnen Block des angeforderten Speichers zu,
calloc () weist mehrere Blöcke des angeforderten Speichers zu

Initialisierung:
malloc () - löscht und initialisiert den zugewiesenen Speicher nicht.
calloc () - initialisiert den zugewiesenen Speicher mit Null.

Geschwindigkeit:
malloc () ist schnell.
calloc () ist langsamer als malloc ().

Argumente & Syntax:
malloc () akzeptiert 1 Argument:

1. Bytes

   • Die Anzahl der zuzuweisenden Bytes

calloc () akzeptiert 2 Argumente:

1. Länge

   • die Anzahl der zuzuweisenden Speicherblöcke
2. Bytes
   • die Anzahl der Bytes, die in jedem Speicherblock zugewiesen werden sollen

void *malloc(size_t bytes);         
void *calloc(size_t length, size_t bytes);      

Art der Speicherzuordnung:
Die Malloc-Funktion weist dem verfügbaren Heap Speicher der gewünschten 'Größe' zu.
Die Calloc-Funktion weist einen Speicher zu, der der Größe von 'num * size' entspricht.

Bedeutung auf Name:
Der Name Malloc bedeutet "Speicherzuordnung".
Der Name calloc bedeutet "zusammenhängende Zuordnung".