Discussion :

[Darksnakes]

Bonsoir a tous,

actuellement je suis sur un projet, mais je bute sur les allocations de mémoire.

voila mon probleme : attente est un char* qui recoit des valeurs grace a strcpy et malloc, et avant de faire justement les malloc je voudrais faire un free dessus mais j'ai un probleme.
voici la ligne de code qui a un probleme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
printf("%s\n",attente);
	    printf("free attente\n");
	    free(attente);
	    printf("free effectue\n");

attente est déclaré avec un malloc également pou éviter de faire un free la première fois sur un pointeur ou j'ai aps fait de malloc


quand j'exécute ça me donne ceci au bout du troisième passage dans cette partie du code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
attente=w
free attente
*** glibc detected *** ./test: free(): invalid next size (fast): 0x0804b318 ***
======= Backtrace: =========
/lib/i686/cmov/libc.so.6[0xb7e5bcf5]
/lib/i686/cmov/libc.so.6(cfree+0x90)[0xb7e5f790]
./test[0x8049078]
./test[0x8049788]
/lib/i686/cmov/libc.so.6(__libc_start_main+0xe0)[0xb7e08050]
./test[0x8048711]
======= Memory map: ========
08048000-0804a000 r-xp 00000000 00:14 1013830    /reseau/v240/etudiant/yann.dumas/lzw/test
0804a000-0804b000 rw-p 00001000 00:14 1013830    /reseau/v240/etudiant/yann.dumas/lzw/test
0804b000-0806c000 rw-p 0804b000 00:00 0          [heap]
b7a00000-b7a21000 rw-p b7a00000 00:00 0 
b7a21000-b7b00000 ---p b7a21000 00:00 0 
b7bf1000-b7df2000 rw-p b7bf1000 00:00 0 
b7df2000-b7f34000 r-xp 00000000 08:02 639049     /lib/i686/cmov/libc-2.6.1.so
b7f34000-b7f35000 r--p 00142000 08:02 639049     /lib/i686/cmov/libc-2.6.1.so
b7f35000-b7f37000 rw-p 00143000 08:02 639049     /lib/i686/cmov/libc-2.6.1.so
b7f37000-b7f3a000 rw-p b7f37000 00:00 0 
b7f41000-b7f4b000 r-xp 00000000 08:02 638980     /lib/libgcc_s.so.1
b7f4b000-b7f4c000 rw-p 00009000 08:02 638980     /lib/libgcc_s.so.1
b7f4c000-b7f4f000 rw-p b7f4c000 00:00 0 
b7f4f000-b7f50000 r-xp b7f4f000 00:00 0          [vdso]
b7f50000-b7f6c000 r-xp 00000000 08:02 641443     /lib/ld-2.6.1.so
b7f6c000-b7f6e000 rw-p 0001b000 08:02 641443     /lib/ld-2.6.1.so
bf9ce000-bf9e3000 rw-p bf9ce000 00:00 0          [stack]
Abort

au début je pensais que je faisait un free sur un pointeur ou j'avais pas fait un malloc, mais quand j'affiche attente avant le free, il m'affiche bien son contenu(et je n'affecte a attente que des valeur par strcpy précédé de malloc)

bon mon projet est gros, donc je peux pas mettre toutes les sources, mais si vous pouviez me donner des pistes sur les possbiles sources de ce probleme.

merci d'avance

yann

[Médinoc]

Ça veut dire que tu fais ton free après que le tas ait été corrompu par quelque chose.
Généralement un débordement de buffer...

[Darksnakes]

humm hummm

bon si je comprend bien l'erreur vient bien de ma gestion des malloc et free

voici la fonction qui fonctionne mal, les fonction qu'elles utilisent fonctionne très bien quand à elle.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
void compressionLZW(char * nomfichier)
{
 
     FILE * Comp;
     FILE * Curs;
     char * seq=malloc(sizeof(char));
     char * attente=malloc(sizeof(char));
     char  lu;
     cell* Dico[100]={NULL};
     int code=259;
     //code==256=>fin de compression
     //code==257=>raz
     //code=258=>nbbit++
     int code_attente;
     int c,taille;
     char * nomfichierlzw;
     int nbbit;
 
     nomfichierlzw=(char *)malloc((strlen(nomfichier)+3)*sizeof(char));
     strcpy(nomfichierlzw,nomfichier);
     strcat(nomfichierlzw,"lzw");
     Comp=fopen(nomfichierlzw,"w");
     Curs=fopen(nomfichier,"r");
     attente[0]='\0';
     seq[0]='\0';
     while (fread(&lu,sizeof(char),1,Curs)==1)
       {
if (code == 65536) {
                           ecrire_x_bit(257,nbbit,Comp);
                           free(Dico);
                           code=259;
                           }
            free(seq);
            seq=malloc((strlen(attente)+2)*sizeof(char));
            strcpy(seq,attente);;
	    free(attente);
            strncat(seq,&lu,1);
            c=apprise(seq,Dico);
            nbbit=calculer_nbbit(code);
            if  (c!=-1)
//si on connais la sequence, on la met en attente.
                 attente=malloc((strlen(seq)+1)*sizeof(char));
                 strcpy(attente,seq);
                 code_attente=c;
                 }
            else
                {
     //sinon on l'apprend.
		apprend_seq(seq,code,Hach(seq),Dico);
                ecrire_x_bit(code_attente,nbbit,Comp);
                code++;
                if (nbbit != calculer_nbbit(code))
                   {ecrire_x_bit(258,nbbit,Comp);
                    nbbit=calculer_nbbit(code);
                    }
                attente=malloc(sizeof(char)+1);
                strcpy(attente,&lu);
                attente[1]='\0';
                code_attente=(unsigned char)lu;
 
                }
     }
//a la fin, il reste encore le dernier caractere lu en attente
      ecrire_x_bit(code_attente,nbbit,Comp);
      ecrire_x_bit(256,nbbit,Comp);
      fclose(Comp);
      fclose(Curs);
}

si vous avez besoin de plus de détail n'hésitez. Les erreurs se produisent sur seq et sur attente.

[diogene]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
                attente=malloc(sizeof(char)+1);
                strcpy(attente,&lu);
                attente[1]='\0';

lu est un char, pas une chaîne de char terminée par 0. Il va copier ce qu'il y a à partir de &lu jusqu'à trouver un 0 et déborder la partie allouée à attente

[Darksnakes]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
                attente=malloc(sizeof(char)+1);
                strcpy(attente,&lu);
                attente[1]='\0';

lu est un char, pas une chaîne de char terminée par 0. Il va copier ce qu'il y a à partir de &lu jusqu'à trouver un 0 et déborder la partie allouée à attente

pourtant quand je 'affiche le contenu de attente, ça marche.

et si je fais un strncpy(attente,&lu,1) le \0 vas t'il etre mis?
ou alors tous simplement attente[0]=lu et attente[1]='\0';

je vais voir ce que ça change.

[Darksnakes]

Bon ben merci beaucoup, effectivement le probleme venait bien de la.

Merci encore pour la réponse rapide

Yann

[Le Mérovingien]

Salut,

j'ai relu tout ça avec attention (enfin je pense) et j'ai trouvé 2 ou 3 petites erreurs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
cell* Dico = {NULL};
 ...
if (code == 65536) {

                           ecrire_x_bit(257,nbbit,Comp);
                           free(Dico);
                           code=259;
                           }

Tu fais un free(Dico) alors que Dico n'a pas été alloué, c'est juste un tableau. De plus, tu te resserts de Dico par la suite.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
nomfichierlzw=(char *)malloc((strlen(nomfichier)+3)*sizeof(char));
     strcpy(nomfichierlzw,nomfichier);
     strcat(nomfichierlzw,"lzw");

Tu ajoutes 3 à la taille de nomfichier pour créer nomfichierlzw, et tu ajoutes 3 caractères -> il manque la place pour le '\0' final.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

attente=malloc(sizeof(char)+1);

Même si ça ne change pas grand chose, mieux vaut mettre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

attente=malloc(2*sizeof(char));

Et enfin je pense comme diogène que strcpy(attente,&lu); c'est pas très propre, mieux vaut ce que tu as dis ensuite :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
attente[0]=lu;
attente[1]='\0';

Voilà voilà, en espérant que ça puisse t'aider, même si je pense pas que ça résolve tes problèmes de compilation...