Dove liberarsi in un programma C

In un programma C, il gratuito() La funzione viene utilizzata per rilasciare lo spazio di memoria allocato dinamicamente se utilizzata attentamente nel codice in quanto ciò ti aiuterà a evitare la perdita di memoria, poiché la perdita di memoria può portare all'inefficienza del sistema, all'instabilità dell'applicazione e alle variazioni di dati impreviste. La memoria gestita correttamente è essenziale affinché qualsiasi programma sia eseguito in modo efficace ed efficiente.

Dove configurare () in un programma C?

Usando gratuito() Trattare la memoria dinamica è una parte fondamentale della scrittura di un programma C ben strutturato. In questo modo può impedire problemi relativi alla memoria comuni come guasti di segmentazione, perdite di memoria e frammentazione della memoria. Poiché l'operazione del programma dipende dall'allocazione e dall'allocazione di blocchi di memoria di dimensioni corrette al momento corretto, è importante utilizzare il gratuito() funzione in modo appropriato. Se la memoria non viene rilasciata correttamente, può portare alla memoria intrappolare, causando così l'esecuzione del programma come previsto.

Ci sono diversi posti in cui è possibile impostare il gratuito() in un programma C e i dettagli sono discussi di seguito.

1: fine di un programma C

IL gratuito() La funzione può essere posizionata alla fine di un programma C, dopo che le allocazioni della memoria sono finite. Ciò assicura che la memoria venga deallocata una volta completato il programma e che non si verifichino problemi relativi alla memoria. Inoltre, il gratuito() La funzione dovrebbe essere presente quando il programma usci.

#includere
#includere
int main ()
int *ptr1;
int n = 6;
ptr1 = (int *) malloc (n * sizeof (int));
if (ptr1 == null)
printf ("Errore: allocazione della memoria non riuscita \ n");
uscita (1);

per (int i = 0; i < n; i++)
*(ptr1 + i) = i;
printf ("%d", *(ptr1 + i));

libero (PTR1);
restituzione 0;

Nel codice sopra, usiamo per la prima volta Malloc () Per allocare la memoria, dopo di che la utilizziamo per archiviare alcuni numeri. Noi usiamo il gratuito() funzione per trattare la memoria alla fine del programma.

Produzione

Se la gratuito() La funzione non viene utilizzata quando il programma sta uscendo, quindi possono verificarsi risultati imprevedibili, come il programma che perde i suoi dati, si arresta in modo anomalo o correre troppo lentamente a causa della memoria intrappolata. In quanto tale, è importante posizionare strategicamente il gratuito() funzionare di conseguenza.

2: prima della fine del ciclo

Infine, è la migliore pratica posizionare il gratuito() funzione prima della fine di un ciclo per trattare la memoria prima che il loop si esibisca di nuovo. In questo modo, il programma non è gravato dal compito di allocare e trattare ripetutamente la memoria all'interno di una sezione di codice.

#includere
#includere
int main ()
int *ptr;
int n = 4;
per (int i = 0; i < n; i++)
ptr = (int*) malloc (sizeof (int));
if (ptr == null)
printf ("Errore: allocazione della memoria non riuscita \ n");
uscita (1);

*ptr = i;
printf ("%d", *ptr);
libero (PTR);

restituzione 0;

Nell'esempio sopra, utilizziamo il Malloc () funzione all'interno del ciclo per allocare la memoria, che viene successivamente utilizzata per archiviare un singolo numero intero. Noi chiamiamo gratuito() per trattare la memoria alla fine di ogni iterazione del loop. Ciò impedisce potenziali perdite di memoria che si verificherebbero se la memoria non fosse trattata alla conclusione del programma e garantisce che sia accessibile per le parti successive del programma.

Produzione

Nota: È fondamentale ricordare che non dovresti rilasciare la memoria allocata dinamicamente all'interno di un ciclo se è necessario usarlo al di fuori di esso. La memoria dovrebbe quindi essere rilasciata quando hai finito di utilizzarla.

3: in caso di errore

Infine, si dovrebbe prestare attenzione per garantire che qualsiasi memoria allocata in un programma venga rilasciata quando il programma termina, anche se si verifica un errore imprevisto. Se si verifica un errore, è necessario prestare particolare attenzione per garantire che la memoria allocata nel programma venga rilasciata prima della risoluzione.

#includere
#includere
int main ()
int *ptr1, *ptr2;
ptr1 = (int*) malloc (sizeof (int));
if (ptr1 == null)
printf ("Errore: allocazione della memoria non riuscita \ n");
uscita (1);

ptr2 = (int *) malloc (3 * sizeof (int));
if (ptr2 == null)
printf ("Errore: allocazione della memoria non riuscita \ n");
libero (PTR1);
uscita (1);

libero (PTR1);
libero (PTR2);
restituzione 0;

In questo esempio, la memoria viene assegnata usando Malloc (), e dopo ogni allocazione, vengono controllati gli errori. Utilizziamo gratuito() per rilasciare qualsiasi memoria precedentemente assegnata se si verifica un errore prima di chiudere l'applicazione. Per evitare perdite di memoria, rilasciamo inoltre tutta la memoria allocata prima che il programma finisca.

Produzione

4: nello stesso blocco in cui è stata assegnata la memoria

Per aiutare a garantire che la memoria venga rilasciata in modo tempestivo, qualsiasi blocco di codice che utilizza le allocazioni di memoria dinamica dovrebbero essere progettati per rilasciare quella memoria non appena non è più necessario. Ciò significa che se la memoria viene assegnata all'interno di un blocco di codice specifico, allora una chiamata a gratuito() dovrebbe anche essere inserito nello stesso blocco di codice per garantire che eventuali matrici, stringhe o altre strutture di dati non necessarie più siano più rilasciate al sistema.

#includere
#includere
int main ()
int n = 5;

int *ptr = (int *) malloc (n *sizeof (int));
if (ptr == null)
printf ("Errore: allocazione della memoria non riuscita \ n");
uscita (1);

per (int i = 0; i < n; i++)
*(ptr + i) = i;
printf ("%d", *(ptr + i));

libero (PTR);

restituzione 0;

L'esempio sopra utilizza un blocco di codice per allocare la memoria usando il Malloc () funzione, che viene quindi utilizzata per archiviare una matrice di numeri. Usando gratuito(), Rilasciamo quindi la memoria alla conclusione del blocco. Non siamo in grado di utilizzare o rilasciare la memoria al di fuori del blocco poiché è valida solo all'interno dei confini del blocco.

Produzione

Nota: Ricordati di usare solo gratuito() sulla memoria che è stata assegnata dinamicamente, come l'uso Malloc (), caloc (), O realloc (). Un errore di segmentazione o altri problemi possono verificarsi se si tenta di rilasciare la memoria che non è stato assegnato dinamicamente poiché il comportamento dell'applicazione non è noto in questo caso.

Pensieri finali

IL gratuito() La funzione deve essere accuratamente inserita in un programma C per garantire che il programma sia eseguito in modo efficiente e che non si verifichino problemi relativi alla memoria. Ciò comporta l'uso del gratuito() funzione alla fine del programma, nello stesso blocco in cui è stata assegnata la memoria e prima della fine di qualsiasi sezione di codice. Si dovrebbe anche prestare attenzione per garantire che la memoria venga rilasciata anche se si verifica un errore imprevisto prima della risoluzione del programma. Utilizzando correttamente il file gratuito() Funzione, un programma C può utilizzare le risorse in modo appropriato, ridurre la frammentazione della memoria e le perdite di memoria ed eseguire come previsto.