c questions malloc (mem corruption)

Question

Lors de l’utilisation de malloc, s’il génère un vidage de la mémoire avec l’erreur suivante:

malloc(): memory corruption: ....... ***

Cela signifie-t-il que malloc a essayé d'allouer de la mémoire non allouée? Si oui, quelles en sont les causes?

Answer 1

Cela dépend complètement de votre implémentation de malloc, mais cela signifie généralement qu’avant ce malloc, quelque chose écrivait plus de données dans un tampon malloc que sa taille.

De nombreuses implémentations malloc stockent certaines de leurs données en ligne avec leur mémoire, en d'autres termes:

+--------------------------------+
|14 bytes -> Padding             | 
+--------------------------------+
|2 bytes -> Internal malloc info |
+--------------------------------+
|6 bytes -> Your data            |
+--------------------------------+
|8 bytes -> Padding              |
+--------------------------------+
|2 bytes -> Internal malloc info |
+--------------------------------+

Ainsi, si un de vos codes ou une bibliothèque écrivait 16 octets dans ce tampon de 6 octets, cela écraserait le remplissage et les 2 octets d’informations malloc internes. La prochaine fois que vous appelez malloc, il essaiera de parcourir ses données pour trouver de l’espace, tapera sur l’espace écrasé. Ce sera absurde, car vous l’avez écrasé, ce qui a corrompu le tas.

En fonction de la mise en oeuvre, une telle erreur peut également être provoquée par la suppression d'un double libre.

Answer 2

Très probablement, ce n'est pas un problème dans Malloc lui-même. Il s’agit plutôt d’un problème lié au fait que votre application modifie des parties du tas qu’elle ne devrait pas utiliser.

Si vous utilisez Linux, essayez d’utiliser Valgrind pour voir le code qui détruit votre segment de mémoire.

Answer 3

La cause habituelle en est que vous avez écrit sur des données que malloc () ne vous a pas donné la permission d'écrire - soit un dépassement de tampon (écriture au-delà de la fin de l'espace qui vous était donné) ou un dépassement de tampon (écriture avant le début). du tampon).

Cela peut parfois être provoqué par la libération d’un pointeur qui n’a pas été attribué par malloc () et al, ou par la libération (libération double) d’un pointeur attribué par malloc (). Par exemple, libérer un tampon statique est une mauvaise idée. vous aurez la corruption.

Vous devez supposer que le problème provient de votre code. Il est extrêmement peu probable qu'il s'agisse d'un problème dans malloc () et autres et plutôt dans une autre bibliothèque que vous utilisez.

Answer 4

Plusieurs causes sont généralement responsables de la corruption de tas:

• dépassement de l'allocation de mémoire (écriture après la fin du bloc alloué)
• double libération d'un bloc
• utiliser un pointeur après sa libération
• et bien sûr, quelque chose qui écrit par erreur via un pointeur qui n'a rien à voir avec une allocation précédente (un "coup de bélier" ou un pointeur non autorisé) - c'est le cas général qui inclut tout ce qui précède.

Ces problèmes peuvent être difficiles à résoudre car la cause et l’effet sont souvent séparés par le temps et l’espace (zone de code différente). Ainsi, le bogue ne sera pas remarqué tant qu’une éternité (après l’installation de l’ordinateur) ne se sera pas écoulée après l’exécution du bogue qui a causé le problème.

L'utilisation d'un segment de débogage peut s'avérer très utile pour résoudre ces problèmes. Les compilateurs de Microsoft ont un tas CrtDebug activé dans les versions debug (mais peut avoir des éléments de configuration supplémentaires définis). Je ne sais pas ce que GCC a prévu, mais certains outils me sont familiers, tels que Valgrind et clôture électrique qui pourraient aider. Enfin, il existe une tonne de bibliothèques de débogage de segment de mémoire maison qui pourraient vous être utiles (Google autour de).

Answer 5

Pouvez-vous fournir votre déclaration malloc ()?

De plus, je voulais vérifier que la valeur de retour n'est pas nulle?

En dehors du fait de ne pas avoir la mémoire à allouer pour commencer, les problèmes que j'ai rencontrés lors de l’utilisation de malloc () ou nouveau sont similaires à la nature de la résultante de un tas corrompu. J'ai l'habitude de trouver des "intéressants". code ailleurs dans le programme faisant quelque chose comme memcpy () avec un tampon de caractères provoquant un dépassement de tampon et un espace adresse mutilé.

-bn