double masortingce 3d libre ou de corruption en C

Je reçois une erreur ‘double free or corruption’ en libérant un tableau 3D. Quelqu’un peut-il me dire où est le problème dans le code? La taille du tableau est 2 * N * N. La valeur de N ici est 100. Même sans casting, même résultat. Voici le code:

// Mallocing double ***h = malloc(2 * (sizeof(double**))); for(i = 0; i < N; i++) { h[i] = malloc(N * sizeof(double*)); for(j = 0; j < N; j++) { h[i][j] = malloc(N * sizeof(double)); } } // Freeing for(i = 0; i < N; i++) { for(j = 0; j < N; j++) { free(h[i][j]); } free(h[i]); } free(h); 

Le programme fonctionne bien, mais à la fin, une erreur «double libre ou corruption (! Prev): 0x08cd24f8» est abandonnée (le fichier est vidé).

Pour la première dimension, vous affectez 2 éléments:

 double ***h = (double***) malloc(2 * (sizeof(double**))); 

Mais vous le traitez comme s’il contenait N éléments:

 for(i = 0; i < N; i++) { h[i] = ... 

Modifiez la comparaison de boucle la plus externe lors de l'atsortingbution et free à:

 for(i = 0; i < 2; i++) { 

Aussi, ne jetez pas la valeur de retour de malloc . En outre, la gestion des erreurs de votre code est manquante. Elle sera rompue si l'atsortingbution échoue.

Aussi vite que je peux voir, vous atsortingbuez 2 éléments, puis remplissez-en N.

 double ***h = (double***) malloc(2 * (sizeof(double**))); for(i = 0; i < N; i++) { h[i] = (double**) malloc(N * sizeof(double*)); .... .... } 

Vous écrasez l'espace non alloué si N> 2 ...

Le problème est ici:

 double ***h = (double***) malloc(2 * (sizeof(double**))); for(i = 0; i < N; i++) { // ... } 

Vous n'avez que malloc 2 éléments, et itérer sur N Je suppose que vous vouliez avoir un tableau de taille N*N*N , mais vous avez fini avec 2*N*N place.

Donc ça:

 double ***h = (double***) malloc(2 * (sizeof(double**))); 

Devrait être:

 double ***h = (double***) malloc(N * (sizeof(double**))); 

Si la valeur de N = 100 à votre commentaire, vous devez allouer de la mémoire pour maintenir N pointeur à pointeur où vous n’avez que 2.

 double ***h = malloc(N * (sizeof(double*))); 

Ne malloc() pas malloc()

Comme d’autres l’ont souligné, le problème spécifique à l’origine du bogue est que vous traitez la dimension avec 2 éléments comme si elle avait N éléments.

L’obscurcissement en est toutefois la raison principale. Il y a quelques règles que je vous recommande fortement de suivre:

  • Allouez toujours des tableaux multidimensionnels en tant que tableaux réels alloués dans la mémoire adjacente . Référence .
  • N’allouez jamais de tableaux multidimensionnels sous forme de tables de correspondance pointées à pointeurs fragmentées dans le tas. Non seulement ils sont plus lents et rendent le code plus difficile à lire, mais ils ne sont pas en réalité des tableaux. Vous ne pouvez pas les utiliser avec memcpy() etc.

    Malheureusement, il existe d’innombrables mauvais professeurs de programmation C et mauvais livres qui prêchent des tables de consultation fragmentées point par point. Tant de programmeurs doivent désapprendre ça, c’est effrayant …

  • N’utilisez jamais plus de deux niveaux d’indirection dans votre programme. Il ne devrait jamais y avoir de raison de le faire, tout ce que cela fait est de rendre votre programme moins lisible (Référence MISRA-C: Règle 18.5). C’est ce qu’on appelle “la programmation trois écanvass” et ce n’est pas un terme flatteur.

  • Ne jetez jamais le résultat de malloc, car il est inutile de le faire .

Ce que vous devriez faire:

 double (*array)[Y][Z] = malloc( sizeof(double[X][Y][Z]) ); ... free(array); 

Exemple:

 #include  #include  #define X 2 #define Y 3 #define Z 4 int main (void) { double (*array)[Y][Z] = malloc( sizeof(double[X][Y][Z]) ); double count = 0.0; for(int x=0; x 

Pour comstackr cela, vous avez besoin d'un compilateur qui n'a pas plus de 16 ans.