Est-ce que le programmeur doit désallouer en sortie ()?

J’ai un programme et lorsque je saisis des données erronées à partir du clavier, il se ferme simplement avec exit(1) .

J’essayais avec Valgrind et bien que cela se produise, il n’y a pas d’erreur, mais je peux voir qu’il existe encore x octets accessibles.

Ma question est donc la suivante: est-ce que le programmeur doit libérer de la mémoire avant d’atteindre une exit() ou le système d’exploitation va-t-il s’en occuper?

C’est une bonne idée (et, dans les anciennes versions de Windows, c’était essentiel), mais lorsqu’un programme exit() un système d’exploitation moderne, tout son espace d’adressage est récupéré.

En fin de compte, le système d’exploitation s’en chargera (sur tous les systèmes d’exploitation modernes, ce n’était pas le cas avec l’ancienne version de Windows). Chaque ressource utilisée par votre programme (mémoire, descripteurs de fichier ouverts, …) sera récupérée par le système d’exploitation à la fin du programme (à l’exception de certaines ressources conçues pour survivre à la fin du processus, principalement une sorte de mémoire partagée / mutex).

Cependant, valgrind est là pour vous aider à valgrind memory leaks et signalera chaque région de mémoire disponible afin que vous puissiez, si vous le souhaitez, les libérer manuellement.

En supposant que nous parlons d’espace utilisateur, je pense qu’il est normalement prudent de supposer que laisser la mémoire allouée à la sortie n’est pas une erreur. Cependant, je considère comme mauvais un programme qui arrive à sa fin lors de l’exécution normale et ne désalloue pas à la sortie.

C’est une mauvaise idée de free mémoire avant de quitter () ing. Cela fait perdre du temps sans raison valable et, dans les programmes multithreads, il peut en réalité causer des bogues si d’autres threads ne sont pas joints en premier et peuvent accéder à une partie de la mémoire allouée.

Le “toujours accessible” n’est pas une fuite. Considérer:

 #include  void *a_global; int main() { void *a_local = malloc(10); a_global = malloc(20); } gcc -g tc && valgrind ./a.out ==12228== Copyright (C) 2002-2010, and GNU GPL'd, by Julian Seward et al. ==12228== Using Valgrind-3.7.0.SVN and LibVEX; rerun with -h for copyright info ==12228== Command: ./a.out ==12228== ==12228== ==12228== HEAP SUMMARY: ==12228== in use at exit: 30 bytes in 2 blocks ==12228== total heap usage: 2 allocs, 0 frees, 30 bytes allocated ==12228== ==12228== LEAK SUMMARY: ==12228== definitely lost: 10 bytes in 1 blocks ==12228== indirectly lost: 0 bytes in 0 blocks ==12228== possibly lost: 0 bytes in 0 blocks ==12228== still reachable: 20 bytes in 1 blocks ==12228== suppressed: 0 bytes in 0 blocks 

Ici, au moment où vous avez atteint la sortie, a_local est hors de scope. Il n’y a aucun moyen de libérer cette mémoire; c’est perdu pour toujours. C’est une fuite.

OTOH, vous pouvez facilement libérer a_global (vous ne devriez pas le faire), il est accessible et ce n’est pas une fuite.