erreur dans C à l'aide de malloc : corrompu taille vs prev_size

J'ai trouvé une réponse pour python, mais je n'ai pas compris.

Le code est une modification de la fusion de tri. Il fonctionne très bien pour un petit nombre d'entrées que j'ai vérifié jusqu'à 10. Mais quand je le lance en ligne par l'intermédiaire d'un juge, lorsque le nombre d'entrées étaient élevés (500), il m'a donné ce message d'erreur:

Error in 'a.out': corrupted size vs. prev_size: 0x0000000000d5b8b0
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x777e5)[0x7f3b83a5b7e5]
/lib/x86_64-linux-gnu/libc.so.6(+0x80dfb)[0x7f3b83a64dfb]
/lib/x86_64-linux-gnu/libc.so.6(cfree+0x4c)[0x7f3b83a6853c]
a.out[0x4009d1]
a.out[0x400ac7]
a.out[0x400a87]
a.out[0x400aa4]
a.out[0x400a87]
a.out[0x400bc7]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7f3b83a04830]
a.out[0x4005b9]
======= Memory map: ========

et il va pour un autre 15 lignes. Pourquoi j'obtiens cette erreur? Est-il en raison d'une erreur que j'ai fais lors de l'allocation dynamique de mémoire à l'aide de malloc?

Voici mon code:

#include <stdio.h>
#include <stdlib.h>
void *Merge(int *A,int l,int m,int r,int *B,int *F);
void *Merge(int *A,int l,int m,int r,int *B,int *F){
int i=l,j=m,k=0,*C,x,y=l,z,cSize,temp,*D,*E;
cSize = r-l;
C = (int *) malloc (cSize * sizeof(int));
D = (int *) malloc (cSize * sizeof(int));
E = (int *) malloc (cSize * sizeof(int));
while (k < cSize){
if((j==r) || ((i!=m) && ((A[j]*B[i]) >= (A[i]*B[j])))){
C[k] = A[i];
D[k] = B[i];
E[k] = F[i];
i++;
k++;
}
if((i>=m) || ((j!=r) && ((A[j]*B[i]) < (A[i]*B[j])))){
C[k] = A[j];
D[k] = B[j];
E[k] = F[j];
j++;
k++;
}
}
for(x=0;x<k;x++){
A[y] = C[x];
B[y] = D[x];
F[y] = E[x];
y++;
}
free(C);
free(D);
free(E);
}
void *MergeSort(int *A,int left,int right,int *B,int *C);
void *MergeSort(int *A,int left,int right,int *B,int *C){
int mid,i,j,k=0,l=0,*R,*L;
if(right - left == 1){
A[left] = A[left];
}
if(right-left > 1){
mid = (left+right)/2;
MergeSort(A,left,mid,B,C);
MergeSort(A,mid,right,B,C);
Merge(A,left,mid,right,B,C);
}
}
int main(){
int n,i=0,newNumt,newNumo,*a,*b,*c;
scanf("%d",&n);
a = (int *) malloc (n * sizeof(int));
b = (int *) malloc (n * sizeof(int));
c = (int *) malloc (n * sizeof(int));
for(i=0;i<n;i++){
scanf("%d %d",&a[i],&b[i]);
c[i]= i+1;
}
MergeSort(a,0,n,b,c);
for(i=0;i<n;i++){
printf("%d\n",c[i]);
}
return 0;
}
Vous écrivez en dehors des limites / libération de deux fois. Utilisation valgrind. valgrind ./a.out
Aussi, vous devez trouver le fracas d'entrée de vous-même et l'ajouter à la question
A[j], D[k] sont hors limites. L'utilisation d'un débogueur.
Lorsque vous obtenez une corruption de segment, le problème n'est pas dans l'allocation de mémoire en soi. Le problème est dans la façon dont vous utilisez d'autres de la mémoire, et comment les modifier. Vous modifier la mémoire en dehors de la plage qui a été allouée pour vous à utiliser, et le système constate que ses données de contrôle a été corrompu, et se plaint — pas de façon déraisonnable. Si vous demandez de 16 octets, dire, et dit "vous pouvez utiliser ptr à ptr + 15 (inclus)", mais continuer de modifier des octets qui sont avant ou après cette gamme, l'enfer peut — et dans votre cas, n'est — barder. Et le problème, c'est habituellement révélé loin de l'endroit où il est dû.
Quand je compile ton programme, j'obtiens 10 avertissements. Fixer que le premier.

OriginalL'auteur ab29007 | 2017-08-15