Fonction gratuite dans le langage C

Dans l'allocation dynamique, un espace mémoire d'une certaine taille est réservé au moment de l'exécution pour une utilisation exclusive par le processus qui l'attribue.

Le langage C a plusieurs fonctions complémentaires pour la gestion de la mémoire dynamique. Les plus couramment mis en œuvre sont malloc (), realloc () et free () qui font partie de la bibliothèque standard et sont définis dans le «stdlib.en-tête h ”. Ces trois fonctions allouent la mémoire à un processus, modifient sa taille et la libérent à nouveau.

En programmation, il est très important de gérer strictement la mémoire dynamique, car chaque fois que nous allouons les ressources à un programme, nous les éloignons du système d'exploitation. La mauvaise gestion de la mémoire dynamique peut avoir des conséquences catastrophiques pour les processus qui s'exécutent dans le système à ce moment-là.

Dans cet article de Linux Hint, vous apprendrez à utiliser la fonction libre () qui est l'une des trois fonctions de base que le langage C fournit la gestion de la mémoire dynamique qui libère les ressources allouées et les renvoie au système d'exploitation pour la réutilisation.

Nous allons vous montrer la syntaxe et la description de son fonctionnement, de l'argument d'entrée et du type de données qui se comporte. Ensuite, nous implémenterons l'utilisation de la fonction libre () dans des exemples pratiques avec des extraits de code et des images qui démontrent son utilisation et ses effets sur le système.

Syntaxe de la fonction libre () dans le langage C

vide gratuit (vide * ptr);

Description de la fonction libre () dans le langage C

La fonction libre () libère une quantité spécifiée de mémoire allouée dynamiquement.

La mémoire dynamique est allouée en appelant la fonction malloc () et en spécifiant la taille des octets de la zone que vous souhaitez allouer dans son argument d'entrée. En conséquence, cette fonction renvoie le pointeur «PTR» qui pointe vers la zone nouvellement allouée.

La fonction libre () libère l'espace mémoire réservé qui est référencé par «PTR» dans son argument d'entrée unique et renvoie sa disponibilité au système d'exploitation. Cette fonction ne renvoie aucun résultat et n'a aucune définition d'erreur dans le «Errno.h ” entête.

La fonction libre () fait partie de la bibliothèque standard et est définie dans le «STDLIB.h ” entête. Pour l'utiliser et les autres fonctions de gestion de la mémoire dynamique, vous devez inclure cet en-tête dans votre code comme suit:

#inclure

Comment libérer la mémoire allouée dynamiquement à l'aide de la fonction libre ()

Dans cet exemple, nous créons une application de console très simple qui nous donne un contrôle sur l'allocation de la mémoire avec la fonction malloc () et la libération de la mémoire avec la fonction libre (). Nous compilons ensuite le code et exécutons l'application, surveillons le système et observons les effets.

Pour créer l'application Console, nous incluons d'abord les en-têtes requis et ouvrir une fonction Main () avec un retour vide. Nous déclarons le pointeur «PTR» qui est utilisé dans les fonctions malloc () et free () pour les pointeurs vers les zones de mémoire allouées. Nous déclarons également la taille entière qui détermine la taille de la mémoire allouée et l'option entière qui est la condition pour le commutateur que nous utilisons pour sélectionner l'option de menu.

Une fois les variables requises déclarées, l'application affiche son PID à l'aide des fonctions printf () et getPid (). Ensuite, le programme entre dans une boucle infinie où elle affiche un menu avec deux options. L'élément sélectionné par l'utilisateur est récupéré à l'aide de la fonction Scanf () dans l'option entière et est la condition pour un commutateur avec deux cas, un pour chaque option.

L'option 1 appelle la fonction malloc () qui alloue un bloc de mémoire de 122 Mo au processus. Tandis que l'option 2 libère ce bloc en appelant la fonction libre (). Vous pouvez voir le code complet de cette application dans l'illustration suivante:

#inclure
#inclure
#inclure
#inclure
vide main ()

option int;
char * ptr;
INT SIZE = 64000000;
printf ("\ nprocess id:% i \ n", getPid ());
tandis que (1)
printf ("\ n [1] Attribution de la mémoire.\ n [2] Libérer la mémoire.\ n ");
scanf ("% i", & option);
commutateur (option)
cas 1:
printf ("\ Nallocating Memory… \ n");
Ptr = malloc (taille * sizeof (char));
casser;
Cas 2:
printf ("\ nreleasing Memory… \ n");
gratuit (ptr);
casser;
// Commutateur de fin
// Terminez pendant que (1)

Notez que dans le cas 1, la fonction malloc () alloue une zone de taille de la taille et renvoie le pointeur «ptr». Dans le cas 2, la fonction libre () utilise le même pointeur que l'argument d'entrée pour libérer la mémoire allouée.

Pour voir les effets de ces deux fonctions sur le système, nous devons ouvrir deux consoles de commande. Dans le terminal 1, nous exécutons la commande supérieure pour voir les ressources utilisées par chaque processus système. Dans le terminal 2, nous compilons et exécutons l'application que nous venons de voir.

Une fois l'application en cours d'exécution, nous examinons la console 1 pour les ressources utilisées par le processus dont le PID est affiché dans la console 2.

Comme nous pouvons le voir sur la figure, le système a attribué le numéro PID 13009 au processus. Nous pouvons voir dans la colonne 10 du terminal gauche que notre application consomme moins de 0.1% de la mémoire système.

Si nous sélectionnons l'option 1 de notre application et appuyons sur «Entrée», la fonction malloc () alloue 122 Mo de mémoire au processus.

Comme nous pouvons le voir dans cette image, la mémoire utilisée par notre application est maintenant 3.6% de la mémoire totale disponible dans le système.

Maintenant, nous sélectionnons l'option 2 de notre application qui appelle la fonction libre (), passant le pointeur «ptr» comme argument d'entrée. Cette action libère la mémoire allouée par la fonction malloc () dans l'option 1.

Dans cette image, nous pouvons voir comment la fonction libre () a libéré la mémoire allouée de 3.6% à 0.1% du système total utilisé par notre application.

Conclusion

Dans cet article de Linux Hint, nous vous avons montré comment utiliser la fonction libre () pour libérer la mémoire allouée dynamiquement. Nous avons examiné la syntaxe de cette fonction et la description théorique de son fonctionnement.

Ensuite, nous avons appliqué ce que nous avons appris dans un exemple pratique avec des extraits de code et des images où nous avons créé une application de console qui contrôle l'appel des fonctions malloc () et free (). Nous l'avons exécuté étape par étape et surveillé le système pour voir les effets de l'appel des fonctions pour allouer et libérer la mémoire du système.