Dynamische Speicherverwaltung in C: malloc(), calloc()

Wie funktioniert die Speicherverwaltung in C?

Wenn Sie eine Variable mit einem Basisdatentyp deklarieren, reserviert der C-Compiler automatisch Speicherplatz für die Variable in einem Speicherbereich, der als Stack bezeichnet wird.

Eine Gleitkommazahl belegt beispielsweise typischerweise 4 Byte (plattformabhängig), wenn sie deklariert wird. Diese Information lässt sich mit dem sizeof-Operator überprüfen, 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 der Speicher bei der Deklaration eines Basisdatentyps oder eines Arrays automatisch verwaltet. In C gibt es jedoch ein Verfahren zur Speicherallokation, das es Ihnen ermöglicht, ein Programm zu implementieren, bei dem die Arraygröße erst zur Laufzeit festgelegt wird. Dieses Verfahren wird als „dynamische Speicherallokation“ bezeichnet.

Dynamische Speicherzuweisung in C

Die dynamische Speicherverwaltung ermöglicht das manuelle Zuweisen und Freigeben von Speicher entsprechend den Programmieranforderungen. Dynamischer Speicher wird mithilfe von Zeigern verwaltet, die auf den neu zugewiesenen Speicherbereich im sogenannten Heap verweisen.

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.

Lassen Sie uns die oben genannten Funktionen und ihre Anwendung besprechen

malloc()-Funktion in C

Die C-Funktion malloc() steht für Speicherzuweisung. Es handelt sich um eine Funktion, die zur dynamischen Zuweisung eines Speicherblocks verwendet wird. Es reserviert Speicherplatz der angegebenen Größe und gibt den Nullzeiger zurück, der auf den Speicherort zeigt. Der zurückgegebene Zeiger ist normalerweise vom Typ void. Das bedeutet, dass wir jedem Zeiger die Funktion C malloc() zuweisen können.

Syntax der Funktion malloc():

ptr = (cast_type *) malloc (byte_size);

Dabei steht:

• 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. Beachten Sie, dass sizeof(*ptr) anstelle von sizeof(int) verwendet wurde, um den Code robuster zu gestalten, falls 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.

free()-Funktion in C

Die Erinnerung an Variablen wird zur Kompilierzeit automatisch freigegeben. Bei der dynamischen Speicherzuweisung müssen Sie den Speicher explizit freigeben. Wenn Sie dies nicht tun, kann es zu einem Fehler wegen unzureichendem Arbeitsspeicher kommen.

Die Funktion free() wird in C aufgerufen, um Speicher freizugeben. Indem Sie Speicher in Ihrem Programm freigeben, stellen Sie mehr Speicher für die spätere Verwendung zur Verfügung.

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

calloc()-Funktion in C

Die C-Funktion calloc() steht für zusammenhängende Zuweisung. Diese Funktion wird verwendet, um mehrere Speicherblöcke zuzuweisen. Es handelt sich um eine dynamische Speicherzuweisungsfunktion, die verwendet wird, um den Speicher komplexen Datenstrukturen wie Arrays und Strukturen zuzuweisen.

Die Funktion Malloc() wird verwendet, um einen einzelnen Block Speicherplatz zuzuweisen, während die Funktion calloc() in C verwendet wird, um mehrere Blöcke Speicherplatz zuzuweisen. Jeder von der Funktion calloc() zugewiesene Block hat die gleiche Größe.

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.

realloc()-Funktion in C

Mit der C-Funktion `realloc()` lässt sich bereits reservierter Speicher vergrößern. Dabei wird der aktuelle Speicherblock erweitert, während der ursprüngliche Inhalt unverändert bleibt. `realloc()` steht in C für „Reallocation of Memory“ (Speicherneuzuweisung).

realloc() kann auch verwendet werden, um die Größe des zuvor zugewiesenen Speichers zu reduzieren.

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.

Dynamische Arrays in C

Ein dynamisches Array in C ermöglicht es, die Anzahl der Elemente nach Bedarf zu erhöhen. Dynamische C-Arrays werden häufig in Informatikalgorithmen verwendet.

Im folgenden Programm haben wir ein dynamisches Array erstellt und seine Größe geändert in C

#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

Häufig gestellte Fragen