Dynamische Speicherzuweisung in C mit den Funktionen malloc(), calloc()

Bevor Sie die dynamische C-Speicherzuweisung lernen, sollten Sie Folgendes 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 namens zu Stapel.

Beispielsweise benötigt eine Float-Variable bei der Deklaration typischerweise 4 Bytes (je nach Plattform). Wir können diese Informationen mithilfe des überprüfen Größe von Operator wie im folgenden Beispiel gezeigt

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

Der Ausgang wird:

 The size of float is 4 bytes

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

#include <stdio.h>
int main() { float arr[10];
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 einen Prozess zum Zuweisen von Speicher in C, der es Ihnen ermöglicht, ein Programm zu implementieren, in dem die Array-Größe nicht festgelegt ist, bis Sie Ihr Programm ausführen (Laufzeit). Dieser Vorgang heißt „Dynamische Speicherzuordnung"

Jetzt können Sie zur Laufzeit problemlos ein Array von Elementen dynamisch erstellen und zerstören. Zusammenfassend lässt sich sagen, dass die automatische Speicherverwaltung den Stack und die C Dynamic Memory Allocation den Heap verwendet.

Der Die Bibliothek verfügt über Funktionen, die für die dynamische Speicherverwaltung verantwortlich sind.

Funktion	Sinn
malloc ()	Reserviert den Speicher der angeforderten Größe und gibt den Zeiger auf das erste Byte von zurück zugewiesener Platz.
calloc()	Weist den Platz für Elemente eines Arrays zu. Initialisiert die Elemente auf Null und gibt einen Zeiger auf den Speicher zurück.
realloc()	Es wird verwendet, um die Größe des zuvor zugewiesenen Speicherplatzes zu ändern.
Frei()	Gibt den zuvor zugewiesenen Speicherplatz frei oder leert ihn.

Lassen Sie uns die oben genannten Funktionen und ihre Anwendung besprechen

Syntax der Funktion malloc():

ptr = (cast_type *) malloc (byte_size);

Hier

• ptr ist ein Zeiger auf cast_type.
• Die C-Funktion malloc() gibt einen Zeiger auf den zugewiesenen Speicher von byte_size zurück.

Beispiel für malloc():

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

Bei erfolgreicher Ausführung dieser Anweisung 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 anderes 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));
    }
}

Ausgang:

Value of the 6th integer is 480

1. Beachte das sizeof(*ptr) wurde anstelle von verwendet sizeof(int) um den Code robuster zu machen, wenn die *ptr-Deklaration später in einen anderen Datentyp umgewandelt wird.
2. Die Zuweisung kann fehlschlagen, wenn der Speicher nicht ausreicht. In diesem Fall wird ein NULL-Zeiger zurückgegeben. Daher sollten Sie Code einschließen, um nach einem NULL-Zeiger zu suchen.
3. Beachten Sie, dass der zugewiesene Speicher zusammenhängend ist und als Array behandelt werden kann. Wir können Zeigerarithmetik verwenden, um auf die Array-Elemente zuzugreifen, anstatt Klammern [ ] zu verwenden. Wir empfehlen, + zu verwenden, um auf Array-Elemente zu verweisen, da die Verwendung der Inkrementierung ++ oder += die im Array gespeicherte Adresse ändert. Zeiger.

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

Beispielsweise:

#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);
}

Ausgang:

 Value of the 2nd integer is 50

Syntax der Funktion calloc():

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

• Die obige Anweisung wird verwendet, um n Speicherblöcke gleicher Größe zuzuweisen.
• Nachdem der Speicherplatz zugewiesen wurde, werden alle Bytes auf Null initialisiert.
• Zurückgegeben wird der Zeiger, der sich aktuell auf dem ersten Byte des allokierten Speicherplatzes befindet.

Immer wenn bei der Zuweisung von Speicherplatz ein Fehler auftritt, beispielsweise aufgrund von Speichermangel, wird ein Nullzeiger 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 terms
Sum = 45

calloc() vs. malloc(): Hauptunterschiede

Nachfolgend ist der Hauptunterschied zwischen malloc() vs. calloc() in C:

Die Funktion calloc() ist im Allgemeinen geeigneter und effizienter als die Funktion malloc(). Während beide Funktionen zum Zuweisen von Speicherplatz verwendet werden, kann calloc() mehrere Blöcke gleichzeitig zuordnen. Sie müssen nicht jedes Mal einen Speicherblock anfordern. Die Funktion calloc() wird in komplexen Datenstrukturen verwendet, die mehr Speicherplatz erfordern.

Der durch calloc() in C zugewiesene Speicherblock wird immer auf Null initialisiert, während er in der Funktion malloc() in C immer einen Müllwert enthält.

Syntax der realloc()-Funktion:

ptr = realloc (ptr,newsize);

Die obige Anweisung weist einen neuen Speicherplatz mit einer angegebenen Größe in der Variablen newsize zu. Nach Ausführung der Funktion wird der Zeiger auf das erste Byte des Speicherblocks zurückgesetzt. Die neue Größe kann größer oder kleiner als der vorherige Speicher sein. Wir können nicht sicher sein, ob der neu zugewiesene Block auf denselben Speicherort verweist wie der vorherige Speicherblock. Diese Funktion kopiert alle vorherigen Daten in die neue Region. Es stellt sicher, 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 die Operation von realloc() in C fehlschlägt, wird ein Nullzeiger zurückgegeben 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] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        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] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        free(arr_dynamic);
    }

Ergebnis des C Dynamic Array-Programms auf dem Bildschirm:

 
arr_dynamic[0]=0
arr_dynamic[1]=1
After realloc
arr_dynamic[0]=0
arr_dynamic[1]=1
arr_dynamic[2]=2
arr_dynamic[3]=3

Zusammenfassung

• Wir können den Speicher dynamisch verwalten, indem wir nach Bedarf Speicherblöcke im Heap erstellen
• Bei der dynamischen C-Speicherzuweisung wird der Speicher zur Laufzeit zugewiesen.
• Die dynamische Speicherzuweisung ermöglicht die Bearbeitung von Zeichenfolgen und Arrays, deren Größe flexibel ist und jederzeit in Ihrem Programm geändert werden kann.
• Dies ist erforderlich, wenn Sie nicht wissen, wie viel Speicher eine bestimmte Struktur belegen wird.
• Malloc() in C ist eine dynamische Speicherzuweisungsfunktion, die für die Speicherzuweisung steht, bei der Speicherblöcke mit einer bestimmten Größe auf einen Müllwert initialisiert werden
• Calloc() in C ist eine zusammenhängende Speicherzuweisungsfunktion, die mehrere Speicherblöcke gleichzeitig zuweist und auf 0 initialisiert wird
• Realloc() in C wird verwendet, um Speicher entsprechend der angegebenen Größe neu zuzuweisen.
• Die Funktion Free() wird verwendet, um den dynamisch zugewiesenen Speicher zu löschen.