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

Bevor Sie sich mit der dynamischen Speicherzuweisung in C vertraut machen, lassen Sie uns Folgendes verstehen:

Wie funktioniert die Speicherverwaltung in C?

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

Beispielsweise benötigt eine Float-Variable normalerweise 4 Bytes (je nach Plattform), wenn sie deklariert wird. Wir können diese Informationen anhand von sizeof überprüfen 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;}

Die Ausgabe lautet:

 The size of float is 4 bytes

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

#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, mit dem Sie ein Programm implementieren können, bei dem die Array-Größe unbestimmt ist, bis Sie Ihr Programm (Laufzeit) ausführen. Dieser Vorgang wird als „Dynamische Speicherzuweisung“ bezeichnet .“

In diesem Tutorial lernen Sie-

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

Dynamische Speicherzuweisung in C

Dynamische Speicherzuweisung ist die manuelle Zuweisung und Freigabe von Speicher gemäß Ihren Programmieranforderungen. Dynamischer Speicher wird verwaltet und mit Zeigern versorgt, die auf den neu zugewiesenen Speicherplatz in einem Bereich zeigen, den wir Heap nennen.

Jetzt können Sie problemlos zur Laufzeit ein Array von Elementen dynamisch erstellen und zerstören. Zusammenfassend verwendet die automatische Speicherverwaltung den Stapel und die dynamische Speicherzuordnung von C verwendet den Heap.

Die Bibliothek enthält Funktionen, die für die dynamische Speicherverwaltung verantwortlich sind.

Funktion Zweck malloc() Weist den Speicher der angeforderten Größe zu und gibt den Zeiger auf das erste Byte des
zugewiesenen Speicherplatzes zurück.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.Free() Gibt den zuvor zugewiesenen Speicherplatz frei oder leert ihn.

Lassen Sie uns die obigen Funktionen mit ihrer Anwendung besprechen

malloc()-Funktion in C

Die Funktion C malloc() steht für Memory Allocation. Es ist eine Funktion, die verwendet wird, um einen Speicherblock dynamisch zuzuweisen. Es reserviert Speicherplatz der angegebenen Größe und gibt den Nullzeiger zurück, der auf die Speicherstelle 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);

Hier,

ptr ist ein Zeiger von 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));
    }
}

Ausgabe:

Value of the 6th integer is 480

Beachten Sie, dass sizeof(*ptr) wurde anstelle von sizeof(int) verwendet um den Code robuster zu machen, wenn die *ptr-Deklaration später in einen anderen Datentyp umgewandelt wird.
Die Zuordnung kann fehlschlagen, wenn der Speicher nicht ausreicht. In diesem Fall gibt es einen NULL-Zeiger zurück. Sie sollten also Code einfügen, um nach einem NULL-Zeiger zu suchen.
Denken Sie daran, 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 von Inkrementen ++ oder +=die vom Zeiger gespeicherte Adresse ändert.

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

free()-Funktion in C

Der Speicher für Variablen wird beim Kompilieren automatisch freigegeben. Bei der dynamischen Speicherallokation müssen Sie Speicher explizit freigeben. Wenn Sie dies nicht tun, kann ein Fehler aufgrund von Speichermangel auftreten.

Die kostenlose () Die Funktion wird aufgerufen, um Speicher in C freizugeben/freizugeben. Indem Sie Speicher in Ihrem Programm freigeben, machen Sie mehr für die spätere Verwendung verfügbar.

Zum 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

 Value of the 2nd integer is 50

calloc()-Funktion in C

Die C-Funktion calloc() steht für Contiguous Allocation. 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() zugeordnete 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 gerade auf dem ersten Byte des belegten Speicherplatzes steht.

Immer wenn ein Fehler bei der Speicherplatzzuweisung auftritt, wie z. B. 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

Das Folgende ist der Hauptunterschied zwischen malloc() und calloc() in C:

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

Der von einem calloc() in C zugewiesene Speicherblock wird immer auf Null initialisiert, während er in der Funktion malloc() in C immer einen Garbage-Wert enthält.

realloc()-Funktion in C

Verwenden von C realloc() Funktion können Sie dem bereits zugewiesenen Speicher mehr Speichergröße hinzufügen. Es erweitert den aktuellen Block, während der ursprüngliche Inhalt unverändert bleibt. realloc() in C steht für Reallocation of Memory.

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

Syntax der Funktion realloc():

ptr = realloc (ptr,newsize);

Die obige Anweisung weist einen neuen Speicherplatz mit einer bestimmten Größe in der Variablen newsize zu. Nach Ausführung der Funktion wird der Zeiger auf das erste Byte des Speicherblocks zurückgeführt. Die neue Größe kann größer oder kleiner als der vorherige Speicher sein. Wir können nicht sicher sein, ob der neu zugeordnete Block auf dieselbe Stelle zeigt 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;
}

Immer wenn realloc() in C zu einer nicht erfolgreichen Operation führt, gibt es einen Nullzeiger zurück und die vorherigen Daten werden ebenfalls freigegeben.

Dynamische Arrays in C

Ein dynamisches Array in C lässt zu, dass die Anzahl der Elemente nach Bedarf wächst. C Dynamische Arrays werden häufig in Informatikalgorithmen verwendet.

Im folgenden Programm haben wir ein dynamisches Array in C

erstellt und in der Größe angepasst

#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 dynamischen C-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 Speicher dynamisch verwalten, indem wir nach Bedarf Speicherblöcke im Heap erstellen
In C Dynamic Memory Allocation wird Speicher zur Laufzeit zugewiesen.
Dynamische Speicherzuweisung erlaubt es, Strings und Arrays zu manipulieren, deren Größe flexibel ist und jederzeit in Ihrem Programm geändert werden kann.
Es ist erforderlich, wenn Sie nicht wissen, wie viel Speicher eine bestimmte Struktur belegen wird.
Malloc() in C ist eine dynamische Speicherzuweisungsfunktion, die für eine Speicherzuweisung steht, die Speicherblöcke mit einer bestimmten Größe mit einem Garbage-Wert initialisiert
Calloc() in C ist eine fortlaufende Speicherzuweisungsfunktion, die mehrere Speicherblöcke gleichzeitig zuweist, initialisiert auf 0
Realloc() in C wird verwendet, um Speicher entsprechend der angegebenen Größe neu zuzuweisen.
Free()-Funktion wird verwendet, um den dynamisch zugewiesenen Speicher zu löschen.

Bitweise Operatoren in C:AND, OR, XOR, Shift &Complement Typumwandlung in C:Typkonvertierung, implizit, explizit mit Beispiel

C Sprache