Dynamisk minnetildeling i C

I DMA kan ikke beslutningen om minner som er tildelt ta i løpet av kompileringstiden. Denne avgjørelsen eller minnet blir tildelt under kjøretiden.

Hver gang vi oppretter noen variabel gjennom DMA, har den typen variabler ikke noe navn; Vi får tilgang til disse variablene via adresse eller peker.

I SMA vet programmerer fra tidligere tid at hvor mange variabler eller hvor mange minner som kreves for programmet hans.

Men i DMA vet ikke programmerer fra tidligere stat at hvor mange variabler eller minne er nødvendig, avhenger det av brukerens krav.

Typer DMA:

1. Malloc ()
2. Calloc ()
3. realloc ()
4. Gratis ()

Malloc ()

Malloc () -funksjonen er en handlingserklæring når kompilatoren leser denne linjen. Compiler forstår ikke hvor mange minner som er tildelt, da det er en handlingserklæring. I runtime minneblokk opprettes.

Hver gang vi kaller Malloc () passerer vi et tall som et argument, som det kan forstå antallet byte med minneblokk skal opprettes av Malloc (). I Malloc () kan den ikke erklære noen datatype. Malloc () returner alltid adressen, hvilken minneblokk som opprettes.

Malloc () Returtype er en tomromspeker fordi den ikke vet hvilke typer adresse den returnerer. For dette må vi skrive kaste.

P = (float*) malloc (4);

Her skriver vi kaste, fordi malloc () er en tomrom.

Eksempel 1:

#inkludere
#inkludere
#Define NULL 0
int main ()

int *a, *t;
int -størrelse;
printf ("Hva er størrelsen på tabellen ? ");
scanf ("%d", og størrelse);
printf ("\ n");
if ((t = (int *) malloc (størrelse * sizeof (int))) == null)

printf ("Ingen plass tilgjengelig \ n");
Avslutt (1);

printf ("\ n adresse til den første byten er %u \ n", t);
/* Lese tabellverdier*/
printf ("\ n inngangstabellverdier \ n");
for (a = t; a < t + size ; a++ )
scanf ("%d", a);
/* Skriv ut tabellverdier i omvendt rekkefølge*/
for (a = t + størrelse - 1; a> = t; a -)
printf (" %d lagres ved adresse %u \ n", *a, a);
gratis (t);
retur 0;

Produksjon:

Calloc ():

Ved hjelp av Calloc () kan vi lage mer enn en blokk eller matrise i Calloc (vi passerer to argumenter; 1. er hvor mange blokker vi ønsker å lage og 2. er størrelsen på blokken). calloc () også returadresse i hver blokk innen standard 0 er eksistens.

Eksempel-2:

#inkludere
#inkludere
int main ()

int *n, *freq, i, størrelse;
printf ("Hva er størrelsen på listen ? ");
scanf ("%d", og størrelse);
n = (int *) malloc (størrelse * størrelse av (int));
printf ("Angi tallene:");
for (i = 0; i < size ; i++ )

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

printf ("\ n tall skal være innenfor rekkevidde (0-4)");
Jeg-- ;
Fortsette ;


freq = (int *) calloc (5, sizeof (int));
for (i = 0; i < size ; i++ )
freq [n [i]] ++;
printf ("\ n Frekvensene til tallene er:");
for (i = 0; i < 5 ; i++ )
printf ("\ n freq [ %d] = %d", i, freq [i]);
printf ("\ n");
gratis (freq);
retur 0;

Produksjon:

realloc ()

Hver gang vi oppretter en blokk ved hjelp av Malloc () eller Calloc () og vi ønsker å endre eller endre størrelsen på blokken, bruker vi Realloc ().

Void *realloc (tomrom *blokk, int -størrelse)

I realloc () må vi passere adressen som et argument som vi ønsker å endre størrelse på.

Realloc (PTR, 8);

og størrelsen på blokken vi ønsker å endre størrelse på. Den størrelsen vi må gi et argument i Realloc ().

dobbel *q;
q = realloc (ptr, 8);

Bare de blokkene som er opprettet av Malloc () eller Calloc () kan endres av Realloc ().

Eksempel-3:

#inkludere
#inkludere
#inkludere
#Define NULL 0
int main ()

char *buffer;
/ * Tildeling av minne */
if ((buffer = (char *) malloc (10)) == null)

printf ("Malloc mislyktes. \ n ");
Avslutt (1);

printf ("buffer av størrelse %d opprettet \ n", størrelse av (buffer));
strcpy (buffer, "Hyderabad");
printf ("\ n buffer inneholder: %s \ n", buffer);
/ * Omfordeling */
if ((buffer = (char *) realloc (buffer, 15)) == null)
printf ("omfordeling mislyktes. \ n ");
Avslutt (1);

printf ("\ n bufferstørrelse modifisert. \ n ");
printf ("\ n buffer inneholder fremdeles: %s \ n", buffer);
strcpy (buffer, "secunderabad");
printf ("\ n buffer inneholder nå: %s \ n", buffer);
/ * Frigjøre minne */
gratis (buffer);
retur 0;

Produksjon:

gratis ()

Ved hjelp av gratis () slipper vi minneblokken som er opprettet av Malloc () eller Calloc () eller Realloc ().

Statiske variabler eksisterer bare i omfanget av blokken eller en funksjon. Hvis vi ikke kan kjøre gratis (), når statisk variabel P blir ødelagt, er variabelen som er opprettet dynamisk, som ikke blir ødelagt, men ble værende for alltid i RAM eller i minnet. Dette kalles minnelekkasje. For denne gratis () er det nødvendig å ødelegge minneblokken som er opprettet dynamisk.

Gratis () bare ødelegge minnet som er opprettet dynamisk.

Konklusjon:

DMA er et kraftig konsept på C -språk fordi det fjerner ulempen med SMA. I SMA må vi ta beslutninger før vi kjører programmet om at hvor mange minneblokker som er opprettet. Som et resultat er minnet bortkastet eller minnet ikke er nok. DMA løser problemet ved å ta beslutning på kjøretid om at hvor mange blokker som er pålagt å tildele minne. Det tildeler minnet til kravet til programmet.