Dynamische Speicherzuweisung in C

In DMA kann die Entscheidung über die zugewiesenen Erinnerungen während der Kompilierungszeit nicht erfolgen. Diese Entscheidung oder dieses Gedächtnis wird während der Laufzeit zugewiesen.

Wenn wir eine Variable über DMA erstellen, haben diese Art von Variablen keinen Namen. Wir zugreifen über Adresse oder Zeiger auf diese Variablen.

In SMA weiß der Programmierer aus früheren Zeit, wie viele Variablen oder wie viele Erinnerungen für sein Programm erforderlich sind.

In DMA weiß der Programmierer jedoch nicht aus früheren Bundesstaat.

Arten von DMA:

1. malloc ()
2. CALLOC ()
3. realloc ()
4. Frei ()

malloc ()

Malloc () -Funktion ist eine Aktionsanweisung, wenn Compiler diese Zeile liest. Der Compiler versteht nicht, wie viele Erinnerungen zugewiesen werden, da es sich um eine Aktionserklärung handelt. Im Laufzeitspeicherblock wird erstellt.

Wenn wir malloc () nennen, geben wir eine Nummer als Argument vorbei, die die Anzahl der Bytes des Speicherblocks verstehen kann, die von der malloc erstellt werden sollen (). In malloc () kann es keinen Datentyp deklarieren. Malloc () geben immer die Adresse zurück, welcher Speicherblock erstellt wird.

Malloc () Rückgabetyp ist ein leerer Zeiger, da er nicht weiß, welche Arten von Adressen er zurücksetzt. Dafür müssen wir Kaste eingeben.

P = (float*) malloc (4);

Hier tippen wir Kaste, weil malloc () ein leerer Zeiger ist.

Beispiel 1:

#enthalten
#enthalten
#define null 0
int main ()

int *a, *t;
int Größe;
printf ("Wie groß ist die Tabelle ? ");
scanf ("%d", & Größe);
printf ("\ n");
if ((t = (int *) malloc (Größe * sizeof (int))) == null)

printf ("kein Platz verfügbar \ n");
Ausgang (1);

printf ("\ n Adresse des ersten Byte ist %U \ n", t);
/* Leseetabellenwerte*/
printf ("\ n Eingabetabellenwerte \ n");
für (a = t; a < t + size ; a++ )
scanf ("%d", a);
/* Drucktabellenwerte in umgekehrter Reihenfolge*//
für (a = t + Größe - 1; a> = t; a -)
printf (" %d wird unter Adresse %U \ n", *a, a) gespeichert;
frei (t);
Rückkehr 0;

Ausgang:

Calloc ():

Mit Hilfe von CALLOC () können wir mehr als einen Block oder ein Array in CALLOC erstellen (wir übergeben zwei Argumente; 1., wie viele Blöcke wir erstellen möchten und die Größe des Blocks ist). CALLOC () senden Sie auch die Adresse in jedem Block von Standard 0 ist existiert.

Beispiel 2:

#enthalten
#enthalten
int main ()

int *n, *freq, i, Größe;
printf ("Wie groß ist die Liste ? ");
scanf ("%d", & Größe);
n = (int *) malloc (Größe * sizeof (int));
printf ("die Zahlen eingeben:");
für (i = 0; i < size ; i++ )

printf ("\ n eingeben die num [%d]:", i);
scanf ("%d", & n [i]);
if (n [i] < 0 || n [ i ] > 4)

printf ("\ n Nummer sollte innerhalb des Bereichs (0-4)") sein;
ich-- ;
weitermachen ;


freq = (int *) CALLOC (5, sizeof (int));
für (i = 0; i < size ; i++ )
freq [n [i]] ++;
printf ("\ n Die Frequenzen der Zahlen sind:");
für (i = 0; i < 5 ; i++ )
printf ("\ n freq [ %d] = %d", i, freq [i]);
printf ("\ n");
frei (freq);
Rückkehr 0;

Ausgang:

realloc ()

Wenn wir mit Hilfe von malloc () oder calloc () einen Block erstellen und den Block ändern oder ändern möchten, verwenden wir Realloc ().

Void *realloc (void *block, intgröße)

In Realloc () müssen wir die Adresse als Argument über welchen Block übergeben, aus dem wir die Größe ändern möchten.

Realloc (PTR, 8);

und die Größe des Blocks, die wir ändern möchten, die Größe. Diese Größe müssen wir in Realloc () ein Argument verabschieden.

doppelt *q;
q = Realloc (PTR, 8);

Nur die Blöcke, die von malloc () oder calloc () erstellt werden, können von Realloc () geändert werden.

Beispiel-3:

#enthalten
#enthalten
#enthalten
#define null 0
int main ()

char *puffer;
/ * Speicher zuweisen */
if ((buffer = (char *) malloc (10)) == null)

printf ("malloc fehlgeschlagen. \N " ) ;
Ausgang (1);

printf ("Puffer von Größe %d erstellt \ n", sizeof (puffer));
Strcpy (Puffer, "Hyderabad");
printf ("\ n puffer enthält: %s \ n", puffer);
/ * Neuzuweisung */
if ((buffer = (char *) realloc (buffer, 15)) == null)
printf ("Neuzuweisung fehlgeschlagen. \N " ) ;
Ausgang (1);

printf ("\ n Puffergröße geändert. \N " ) ;
printf ("\ n Puffer enthält immer noch: %s \ n", Puffer);
Strcpy (Puffer, "Secunderabad");
printf ("\ n Puffer enthält jetzt: %s \ n", Puffer);
/ * Speicherfreier *///
frei (Puffer);
Rückkehr 0;

Ausgang:

frei ()

Mit Hilfe von Free () veröffentlichen wir den Speicherblock, der von malloc () oder calloc () oder realloc () erstellt wurde.

Statische Variablen existieren nur in den Umfang des Blocks oder einer Funktion. Wenn wir das Free () nicht ausführen können, wenn die statische Variable p zerstört wird, ist die dynamische Erstellung von Variablen, die nicht zerstört, sondern für immer im RAM oder im Speicher geblieben ist. Dies wird als Speicherleck bezeichnet. Für dieses Free () ist erforderlich, um den Speicherblock zu zerstören, der dynamisch erstellt wird.

Free () Zerstöre nur jene Speicher, die dynamisch erstellt werden.

Abschluss:

DMA ist ein starkes Konzept in der C -Sprache, weil es den Nachteil von SMA beseitigt. In SMA müssen wir Entscheidungen treffen, bevor wir das Programm ausführen, wie viele Speicherblöcke erstellt werden. Infolgedessen ist der Speicher verschwendet oder der Speicher reicht nicht aus. DMA löst das Problem auf, indem sie zur Laufzeit entschieden hat, wie viele Blocks erforderlich sind, um Speicher zuzuweisen. Es gibt den Anforderungen des Programms Speicher zugedacht.