Allocazione di memoria dinamica in C

In DMA, la decisione sui ricordi assegnati non può richiedere durante il tempo di compilazione. Questa decisione o memoria viene assegnata durante il runtime.

Ogni volta che creiamo qualsiasi variabile tramite DMA, quel tipo di variabili non ha alcun nome; Accediamo a queste variabili tramite indirizzo o puntatore.

In SMA, il programmatore sa dal tempo precedente che quante variabili o quanti ricordi sono necessari per il suo programma.

Ma in DMA, il programmatore non sa dallo stato precedente che quante variabili o memoria sono necessarie, dipende dal requisito dell'utente.

Tipi di DMA:

1. Malloc ()
2. caloc ()
3. realloc ()
4. Gratuito ()

Malloc ()

La funzione malloc () è un'istruzione di azione quando il compilatore leggi questa riga. Il compilatore non capisce quante memorie viene assegnato in quanto è un'affermazione di azione. Viene creato il blocco di memoria di runtime.

Ogni volta che chiamiamo malloc () passiamo un numero come argomento, che può capire il numero di byte di blocco di memoria deve essere creato da Malloc (). In Malloc (), non può dichiarare alcun tipo di dati. Malloc () restituisce sempre l'indirizzo, quale blocco di memoria viene creato.

Malloc () Il tipo di ritorno è un puntatore vuoto perché non sa quali tipi di indirizzo restituisce. Per questo dobbiamo digitare la casta.

P = (float*) malloc (4);

Qui digitiamo la casta, perché Malloc () è un puntatore vuoto.

Esempio 1:

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

int *a, *t;
dimensione int;
printf ("Qual è la dimensione della tabella ? ");
scanf ("%d", e dimensioni);
printf ("\ n");
if ((t = (int *) malloc (dimensione * sizeof (int)) == null)

printf ("Nessun spazio disponibile \ n");
uscita (1);

printf ("\ n indirizzo del primo byte è %u \ n", t);
/* Valori della tabella di lettura*/
printf ("\ n Valori della tabella di input \ n");
per (a = t; a < t + size ; a++ )
scanf ("%d", a);
/* Valori della tabella di stampa in ordine inverso*/
per (a = t + dimensione - 1; a> = t; a -)
printf (" %d è archiviato all'indirizzo %u \ n", *a, a);
libero (t);
restituzione 0;

Produzione:

Caloc ():

Con l'aiuto di Calloc () possiamo creare più di un blocco o array in Calloc (passiamo due argomenti; il primo è quanti blocchi vogliamo creare e 2 ° è la dimensione del blocco). caloc () anche indirizzo di ritorno in ciascun blocco di Predefinito 0 esiste.

Esempio-2:

#includere
#includere
int main ()

int *n, *freq, i, dimensione;
printf ("Qual è la dimensione dell'elenco ? ");
scanf ("%d", e dimensioni);
n = (int *) malloc (dimensione * sizeof (int));
printf ("Immettere i numeri:");
per (i = 0; i < size ; i++ )

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

printf ("\ n il numero dovrebbe essere nell'intervallo (0-4)");
io-- ;
Continua ;


freq = (int *) caloc (5, sizeof (int));
per (i = 0; i < size ; i++ )
freq [n [i]] ++;
printf ("\ n le frequenze dei numeri sono:");
per (i = 0; i < 5 ; i++ )
printf ("\ n freq [ %d] = %d", i, freq [i]);
printf ("\ n");
libero (freq);
restituzione 0;

Produzione:

realloc ()

Ogni volta che creiamo un blocco con l'aiuto di Malloc () o caloc () e vogliamo cambiare o ridimensionare il blocco, utilizziamo RealLoc ().

Void *realloc (void *blocco, int size)

In realloc () dobbiamo passare l'indirizzo come argomento da quale blocco vogliamo ridimensionare.

realloc (PTR, 8);

e la dimensione del blocco vogliamo ridimensionare. Quella dimensione dobbiamo passare una discussione in realloc ().

doppio *q;
Q = realloc (PTR, 8);

Solo quei blocchi creati da Malloc () o caloc () possono essere ridimensionati da RealLoc ().

Esempio-3:

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

char *buffer;
/ * Assegnazione della memoria */
if ((buffer = (char *) malloc (10)) == null)

printf ("Malloc non è riuscito. \N " ) ;
uscita (1);

printf ("buffer di dimensioni %d create \ n", sizeof (buffer));
strcpy (buffer, "hyderabad");
printf ("\ n buffer contiene: %s \ n", buffer);
/* Riallocazione */
if ((buffer = (char *) realloc (buffer, 15)) == null)
printf ("Riallocazione non riuscita. \N " ) ;
uscita (1);

printf ("\ n Dimensione buffer modificata. \N " ) ;
printf ("\ n buffer contiene ancora: %s \ n", buffer);
strcpy (buffer, "secunderabad");
printf ("\ n buffer ora contiene: %s \ n", buffer);
/ * Memoria di liberazione */
gratuito (buffer);
restituzione 0;

Produzione:

gratuito ()

Con l'aiuto di Free (), rilasciamo il blocco di memoria creato da Malloc () o caloc () o realloc ().

Le variabili statiche esistono solo nell'ambito del blocco o una funzione. Se non possiamo eseguire il libero (), ogni volta che la variabile statica P viene distrutta, la variabile che viene creata dinamicamente, che non viene distrutta, ma è rimasta per sempre in RAM o in memoria. Questa si chiama perdita di memoria. Per questo libero () è necessario per distruggere il blocco di memoria creato dinamicamente.

Free () distruggi solo quei memoria creata dinamicamente.

Conclusione:

DMA è un concetto potente nel linguaggio C perché rimuove lo svantaggio di SMA. In SMA dobbiamo prendere una decisione prima di eseguire il programma che vengono creati quanti blocchi di memoria. Di conseguenza, la memoria viene sprecata o la memoria non è sufficiente. DMA risolve il problema prendendo una decisione sul tempo di esecuzione che quanti blocchi sono richiesti per allocare la memoria. Assegna la memoria al requisito del programma.