Où libérer dans un programme C
Où mettre gratuitement () dans un programme C?
En utilisant gratuit() Faire de la mémoire dynamique est un élément essentiel de la rédaction d'un programme C bien structuré. Cela peut empêcher les problèmes communs liés à la mémoire tels que les défauts de segmentation, les fuites de mémoire et la fragmentation de la mémoire. Étant donné que le fonctionnement du programme dépend de l'allocation et de la négociation des blocs de mémoire de taille correcte au bon moment, il est important d'utiliser le gratuit() Fonctionne d'une manière appropriée. Si la mémoire n'est pas libérée correctement, cela peut entraîner le piégeage de la mémoire, ce qui fait que le programme ne s'exécute pas comme prévu.
Il y a plusieurs endroits où vous pouvez définir le gratuit() Dans un programme C et les détails sont discutés ci-dessous.
1: Fin d'un programme C
Le gratuit() La fonction peut être placée à la fin d'un programme C, une fois toutes les allocations de mémoire terminées. Cela garantit que la mémoire est traitée une fois le programme terminé et qu'aucun problème lié à la fuite de mémoire ne surgira. De plus, le gratuit() La fonction doit être présente à la sortie du programme, afin qu'elle puisse traiter la mémoire à partir de blocs de mémoire alloués, libérant ainsi l'espace mémoire.
#inclure
#inclure
int main()
int * ptr1;
int n = 6;
ptr1 = (int *) malloc (n * sizeof (int));
if (ptr1 == null)
printf ("Erreur: l'allocation de mémoire a échoué \ n");
sortie (1);
pour (int i = 0; i < n; i++)
* (ptr1 + i) = i;
printf ("% d", * (ptr1 + i));
gratuit (ptr1);
retour 0;
Dans le code ci-dessus, nous utilisons d'abord malloc () Pour allouer la mémoire, après quoi nous l'utilisons pour stocker certains numéros. Nous utilisons le gratuit() fonction pour traiter la mémoire à la fin du programme.
Sortir
Si la gratuit() La fonction n'est pas utilisée à la sortie du programme, puis des résultats imprévisibles peuvent se produire, comme le programme perdant ses données, s'écraser ou s'exécuter trop lentement en raison de la mémoire piégée. En tant que tel, il est important de placer stratégiquement le gratuit() fonction en conséquence.
2: Avant la fin de la boucle
Enfin, il est de la meilleure pratique de placer le gratuit() fonction avant la fin d'une boucle afin de traiter la mémoire avant que la boucle ne s'exécute à nouveau. Ce faisant, le programme n'est pas accablé par la tâche d'allorer et de traiter la mémoire à plusieurs reprises dans une section en boucle du code.
#inclure
#inclure
int main()
int * ptr;
int n = 4;
pour (int i = 0; i < n; i++)
ptr = (int *) malloc (sizeof (int));
if (ptr == null)
printf ("Erreur: allocation de mémoire non réussie \ n");
sortie (1);
* ptr = i;
printf ("% d", * ptr);
gratuit (ptr);
retour 0;
Dans l'exemple ci-dessus, nous utilisons le malloc () fonction à l'intérieur de la boucle pour allouer la mémoire, qui est par la suite utilisée pour stocker un seul entier. Nous appelons gratuit() Pour traiter la mémoire à la fin de chaque itération de la boucle. Cela empêche les fuites de mémoire potentielles qui se produiraient si la mémoire n'était pas traitée à la fin du programme et garantit qu'elle est accessible pour des parties ultérieures du programme.
Sortir
Note: Il est crucial de se rappeler que vous ne devriez pas libérer de la mémoire allouée dynamiquement à l'intérieur d'une boucle si vous avez besoin de l'utiliser à l'extérieur. La mémoire doit ensuite être libérée lorsque vous avez terminé l'utilisation.
3: En cas d'erreur
Enfin, il faut veiller à ce que toute mémoire allouée dans un programme soit publiée lorsque le programme se termine, même si une erreur inattendue se produit. Si une erreur se produit, alors des soins spéciaux doivent être pris.
#inclure
#inclure
int main()
int * ptr1, * ptr2;
ptr1 = (int *) malloc (sizeof (int));
if (ptr1 == null)
printf ("Erreur: allocation de mémoire non réussie \ n");
sortie (1);
ptr2 = (int *) malloc (3 * sizeof (int));
if (ptr2 == null)
printf ("Erreur: allocation de mémoire non réussie \ n");
gratuit (ptr1);
sortie (1);
gratuit (ptr1);
gratuit (ptr2);
retour 0;
Dans cet exemple, la mémoire est allouée en utilisant malloc (), Et après chaque allocation, les erreurs sont vérifiées. Nous utilisons gratuit() Pour libérer toute mémoire qui avait été précédemment allouée si une erreur se produit avant d'arrêter l'application. Pour éviter les fuites de mémoire, nous libérons en outre toute la mémoire allouée avant la fin du programme.
Sortir
4: Dans le même bloc où la mémoire a été allouée
Pour vous assurer que la mémoire est libérée en temps opportun, tous les blocs de code qui utilisent des allocations de mémoire dynamique doivent être conçus pour libérer cette mémoire dès qu'il ne sera plus nécessaire. Cela signifie que si la mémoire est allouée dans un bloc de code spécifique, alors un appel à gratuit() devrait également être placé dans ce même bloc de code pour s'assurer que tous les tableaux, chaînes ou autres structures de données nécessaires sont relâchés au système.
#inclure
#inclure
int main()
int n = 5;
int * ptr = (int *) malloc (n * sizeof (int));
if (ptr == null)
printf ("Erreur: allocation de mémoire non réussie \ n");
sortie (1);
pour (int i = 0; i < n; i++)
* (ptr + i) = i;
printf ("% d", * (ptr + i));
gratuit (ptr);
retour 0;
L'exemple ci-dessus utilise un bloc de code pour allouer la mémoire à l'aide du malloc () fonction, qui est ensuite utilisée pour stocker un tableau de nombres. En utilisant gratuit(), Nous libérons ensuite la mémoire à la conclusion du bloc. Nous ne pouvons pas utiliser ou libérer la mémoire en dehors du bloc car il n'est valable que dans les limites du bloc.
Sortir
Note: N'oubliez pas d'utiliser uniquement gratuit() sur la mémoire qui a été allouée dynamiquement, comme l'utilisation malloc (), calloc (), ou realloc (). Un défaut de segmentation ou d'autres problèmes peuvent survenir si vous essayez de libérer une mémoire qui n'a pas été allouée dynamiquement car le comportement de votre application est inconnu dans ce cas.
Dernières pensées
Le gratuit() La fonction doit être soigneusement placée dans un programme C pour s'assurer que le programme s'exécute efficacement et qu'aucun problème lié à la fuite de mémoire ne survient. Cela implique d'utiliser le gratuit() fonction à la fin du programme, dans le même bloc où la mémoire a été allouée, et avant la fin de toute section de code en boucle. Des soins doivent également être pris. En utilisant correctement le gratuit() fonction, un programme C peut utiliser les ressources de manière appropriée, réduire la fragmentation de la mémoire et les fuites de mémoire et exécuter comme prévu.