Malloc Basic / Gratuit

Si j’ai un extrait de mon programme comme ceci:

struct Node *node; while(...){ node = malloc(100); //do stuff with node } 

Cela signifie que chaque fois que je passe en boucle dans la boucle while, je viens d’allouer 100 octets pointés par le pointeur du nœud, non?

Si cela est vrai, comment puis-je libérer toute la mémoire que j’ai créée avec toutes les boucles si je ne dispose plus que d’un pointeur pointant vers le dernier malloc qui s’est produit?

Merci!

Veuillez allouer exactement la taille dont vous avez besoin: malloc(sizeof *node); – Si vous passez à une plate-forme 64 bits qui double la taille de tous vos membres, votre ancienne structure de 96 octets peut prendre 192 octets dans le nouvel environnement.

Si vous n’avez pas d’indication sur les struct Node vous avez créées, alors je ne pense pas que vous devriez les allouer avec malloc(3) en premier lieu. malloc(3) est préférable si votre application nécessite que les données persistent en dehors du domaine d’appel de la fonction en cours. J’espère que vous pourriez réécrire votre fonction comme ceci:

 struct Node node; while(...){ //do stuff with node } 

ou

 while(...){ struct Node node; //do stuff with node } 

Cela dépend si vous voulez accéder au dernier nœud (la première version) ou non (la deuxième version).

Bien sûr, si vous avez réellement besoin de ces structures en dehors de cette partie de code, vous devez alors stocker les références à celles-ci quelque part . Ajoutez-les à une liste globale en gardant la trace des objects struct Node , ou ajoutez-les chacun au pointeur next de la struct Node précédent , ou ajoutez-les à une struct User correspondante, qui fait référence à ces objects, selon vos préférences.

Si vous définissez node = NULL avant la boucle, puis que vous utilisez free (node) avant node = malloc (100), tout devrait bien se passer. Vous aurez également besoin de faire un free (nœud) après la fin de la boucle. Mais là encore, tout dépend de ce que fait “// do stuff with node”. Comme d’autres l’ont déjà souligné, malloc (100) n’est pas une bonne idée. Ce que je voudrais utiliser est malloc (sizeof (* noeud)). Ainsi, si le type de nœud change, vous n’aurez pas à changer la ligne malloc.

Si vous n’avez plus besoin de l’espace mallocé à la fin d’une itération, vous devez le libérer immédiatement.

Pour garder une trace des nœuds alloués, vous pouvez les enregistrer dans une liste de plus en plus dynamic:

 #include  int main() { int i; void *node; int prt_len = 0; void **ptrs = NULL; for (i = 0; i < 10; i++) { node = malloc(100); ptrs = realloc(ptrs, sizeof(void*) * ++prt_len); ptrs[prt_len-1] = node; /* code */ } for (i = 0; i < prt_len; i++) { free(ptrs[i]); } free(ptrs); return 0; } 

Remarque: vous devriez probablement repenser votre algorithme si vous devez utiliser de telles méthodes!

Sinon, voir la réponse de sarnold .

Alors, comment puis-je libérer de toutes les boucles toute la mémoire que j’ai créée s’il ne me rest qu’un pointeur pointant vers le dernier malloc qui s’est produit?

Tu ne peux pas. Vous venez de créer une fuite de mémoire géante.

Vous devez garder une trace de chaque bloc de mémoire que vous malloc() et free() lorsque vous avez fini de l’utiliser.

Vous ne pouvez pas. Vous devez stocker tout le pointeur pour libérer la mémoire. si vous enregistrez ces pointeurs quelque part, vous seul pouvez libérer la mémoire.