Dynamische Speicherzuweisung in C: malloc(), calloc() Funktionen

Bevor Sie die dynamische Speicherzuweisung in C lernen, sollten Sie diese verstehen:

Wie funktioniert die Speicherverwaltung in C?

Wenn Sie eine Variable mit einem Basisdatentyp deklarieren, weist der C-Compiler automatisch Speicherplatz für die Variable in einem Speicherpool zu, der Stack genannt wird.

Eine Float-Variable zum Beispiel belegt bei ihrer Deklaration typischerweise 4 Byte (je nach Plattform). Wir können diese Information mit dem sizeof-Operator überprüfen, wie im folgenden Beispiel gezeigt wird

#include <stdio.h>int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}

Die Ausgabe wird sein:

 The size of float is 4 bytes 

Auch ein Array mit einer bestimmten Größe wird in zusammenhängenden Speicherblöcken alloziert, wobei jeder Block die Größe für ein Element hat:

#include <stdio.h>int main() { float arr;printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;} 

Das Ergebnis ist:

 The size of the float array with 10 element is 40

Wie bisher gelernt, wird bei der Deklaration eines Basisdatentyps oder eines Arrays der Speicher automatisch verwaltet. Es gibt jedoch ein Verfahren zur Speicherallokation in C, das es Ihnen erlaubt, ein Programm zu implementieren, bei dem die Größe des Arrays bis zur Ausführung Ihres Programms (Laufzeit) unbestimmt ist. Dieses Verfahren wird „Dynamische Speicherzuweisung“ genannt.

In diesem Lernprogramm lernen Sie-

• Wie funktioniert die Speicherverwaltung in C?
• Dynamische Speicherzuweisung in C
• Die Funktion malloc()
• Die Funktion free()
• Die Funktion calloc()
• calloc() vs. malloc(): Die wichtigsten Unterschiede
• Die C realloc()-Funktion
• Dynamische Arrays

Nun können Sie ein Array von Elementen zur Laufzeit problemlos dynamisch erzeugen und zerstören. Zusammenfassend lässt sich sagen, dass die automatische Speicherverwaltung den Stack und die dynamische Speicherzuweisung in C den Heap verwendet.

Die <stdlib.h> Bibliothek hat Funktionen, die für die dynamische Speicherverwaltung zuständig sind.

Funktion	Zweck
malloc()	Allokiert den Speicher der angeforderten Größe und gibt den Zeiger auf das erste Byte des zugewiesenen Platzes zurück.
calloc()	Belegt den Platz für Elemente eines Arrays. Initialisiert die Elemente auf Null und gibt einen Zeiger auf den Speicher zurück.
realloc()	Sie wird verwendet, um die Größe des zuvor zugewiesenen Speicherplatzes zu ändern.
Free()	Freigeben oder Leeren des zuvor zugewiesenen Speicherplatzes.

Lassen Sie uns die obigen Funktionen mit ihrer Anwendung besprechen

Syntax der malloc()-Funktion:

ptr = (cast_type *) malloc (byte_size);

Hier,

• ptr ist ein Zeiger vom Typ cast_type.
• Die C-Funktion malloc() gibt einen Zeiger auf den allokierten Speicher der Größe byte zurück.

Beispiel für malloc():

Example: ptr = (int *) malloc (50)

Wenn diese Anweisung erfolgreich ausgeführt wird, wird ein Speicherplatz von 50 Byte reserviert. Die Adresse des ersten Bytes des reservierten Speicherplatzes wird dem Zeiger ptr vom Typ int zugewiesen.

Betrachten Sie ein weiteres Beispiel:

#include <stdlib.h>int main(){int *ptr;ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */ if (ptr != NULL) { *(ptr + 5) = 480; /* assign 480 to sixth integer */ printf("Value of the 6th integer is %d",*(ptr + 5)); }}

Ausgabe:

Value of the 6th integer is 480

1. Beachten Sie, dass sizeof(*ptr) anstelle von sizeof(int) verwendet wurde, um den Code robuster zu machen, wenn die *ptr-Deklaration später auf einen anderen Datentyp typisiert wird.
2. Die Zuweisung kann fehlschlagen, wenn der Speicher nicht ausreicht. In diesem Fall gibt sie einen NULL-Zeiger zurück. Sie sollten also Code einfügen, um auf einen NULL-Zeiger zu prüfen.
3. Beachten Sie, dass der zugewiesene Speicher zusammenhängend ist und als Array behandelt werden kann. Wir können Zeigerarithmetik verwenden, um auf die Arrayelemente zuzugreifen, anstatt Klammern zu verwenden. Wir empfehlen die Verwendung von +, um auf Array-Elemente zu verweisen, da die Verwendung der Inkrementierung ++ oder += die vom Zeiger gespeicherte Adresse ändert.

Die Funktion Malloc() kann auch mit dem Datentyp Zeichen sowie mit komplexen Datentypen wie Strukturen verwendet werden.

Ein Beispiel:

#include <stdio.h>int main() {int* ptr = malloc(10 * sizeof(*ptr));if (ptr != NULL){ *(ptr + 2) = 50; printf("Value of the 2nd integer is %d",*(ptr + 2));}free(ptr);}

Ausgabe/p>

 Value of the 2nd integer is 50

Syntax der calloc()-Funktion:

ptr = (cast_type *) calloc (n, size);

• Die obige Anweisung wird verwendet, um n Speicherblöcke der gleichen Größe zu allozieren.
• Nach der Allokation des Speicherplatzes werden alle Bytes auf Null initialisiert.
• Der Zeiger, der sich aktuell auf dem ersten Byte des allokierten Speicherplatzes befindet, wird zurückgegeben.

Wenn es einen Fehler bei der Allokation von Speicherplatz gibt, wie z. B. Speichermangel, dann wird ein Null-Zeiger zurückgegeben.

Beispiel für calloc():

Das folgende Programm berechnet die Summe einer arithmetischen Folge.

#include <stdio.h> int main() { int i, * ptr, sum = 0; ptr = calloc(10, sizeof(int)); if (ptr == NULL) { printf("Error! memory not allocated."); exit(0); } printf("Building and calculating the sequence sum of the first 10 terms \ n "); for (i = 0; i < 10; ++i) { * (ptr + i) = i; sum += * (ptr + i); } printf("Sum = %d", sum); free(ptr); return 0; }

Ergebnis:

 Building and calculating the sequence sum of the first 10 termsSum = 45

calloc() vs. malloc(): Die wichtigsten Unterschiede

Nachfolgend finden Sie die wichtigsten Unterschiede zwischen malloc() vs calloc() in C:

Die calloc()-Funktion ist im Allgemeinen besser geeignet und effizienter als die malloc()-Funktion. Während beide Funktionen zur Zuweisung von Speicherplatz verwendet werden, kann calloc() mehrere Blöcke auf einmal zuweisen. Es muss nicht jedes Mal ein Speicherblock angefordert werden. Die Funktion calloc() wird in komplexen Datenstrukturen verwendet, die einen größeren Speicherplatz benötigen.

Der durch ein calloc() allozierte Speicherblock wird in C immer auf Null initialisiert, während er bei der Funktion malloc() in C immer einen Garbage-Wert enthält.

Syntax der realloc()-Funktion:

ptr = realloc (ptr,newsize);

Die obige Anweisung allokiert einen neuen Speicherplatz mit einer bestimmten Größe in der Variablen newsize. Nach dem Ausführen der Funktion wird der Zeiger auf das erste Byte des Speicherblocks zurückgegeben. Die neue Größe kann größer oder kleiner als der bisherige Speicher sein. Wir können nicht sicher sein, ob der neu zugewiesene Block auf die gleiche Stelle zeigt wie der vorherige Speicherblock. Diese Funktion kopiert alle vorherigen Daten in den neuen Bereich. Dadurch wird sichergestellt, dass die Daten sicher bleiben.

Beispiel für realloc():

#include <stdio.h>int main () { char *ptr; ptr = (char *) malloc(10); strcpy(ptr, "Programming"); printf(" %s, Address = %u\n", ptr, ptr); ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new size strcat(ptr, " In 'C'"); printf(" %s, Address = %u\n", ptr, ptr); free(ptr); return 0;} 

Wenn realloc() in C zu einer erfolglosen Operation führt, gibt es einen Null-Zeiger zurück, und die vorherigen Daten werden ebenfalls freigegeben.

#include <stdio.h> int main() { int * arr_dynamic = NULL; int elements = 2, i; arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocks for (i = 0; i < elements; i++) arr_dynamic = i; for (i = 0; i < elements; i++) printf("arr_dynamic=%d\n", i, arr_dynamic); elements = 4; arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); //reallocate 4 elements printf("After realloc\n"); for (i = 2; i < elements; i++) arr_dynamic = i; for (i = 0; i < elements; i++) printf("arr_dynamic=%d\n", i, arr_dynamic); free(arr_dynamic); } 

Ergebnis des Programms Dynamisches Array in C am Bildschirm:

 arr_dynamic=0arr_dynamic=1After reallocarr_dynamic=0arr_dynamic=1arr_dynamic=2arr_dynamic=3

Zusammenfassung

• Wir können den Speicher dynamisch verwalten, indem wir nach Bedarf Speicherblöcke im Heap anlegen
• Bei der dynamischen Speicherzuweisung in C wird der Speicher zur Laufzeit zugewiesen.
• Die dynamische Speicherzuweisung erlaubt die Manipulation von Strings und Arrays, deren Größe flexibel ist und jederzeit im Programm geändert werden kann.
• Sie wird benötigt, wenn Sie keine Ahnung haben, wie viel Speicher eine bestimmte Struktur belegen wird.
• Malloc() in C ist eine dynamische Speicherzuweisungsfunktion, die für die Zuweisung von Speicherblöcken mit einer bestimmten Größe steht, die auf einen Garbage-Wert initialisiert sind
• Calloc() in C ist eine Funktion zur Zuweisung von zusammenhängendem Speicher, die mehrere Speicherblöcke auf einmal zuweist, die auf 0 initialisiert sind
• Realloc() in C wird verwendet, um Speicher entsprechend der angegebenen Größe neu zuzuweisen.
• Die FunktionFree() wird verwendet, um den dynamisch zugewiesenen Speicher zu löschen.