Bonjour à tous j'ai un petit soucis, je bosse actuellement sur l'algorithme de Huffman et j'ai une variable qui change de valeur suite à un printf  .

Lorsque j'enlève le printf, il n'y a aucun problème.

Voici le code:

-La structure :

typedef struct 
{
	char * code;
	int taille;
}Code;

-Les fonction utilisés pour remplir un tableau de cette structure:

void code_comp (Noeud arbreH[], int indice, Code traduc[], char code[], int *taille_texte_comp ){

	int fils_g = arbreH[indice].fg;
	int fils_d = arbreH[indice].fd;
	int lettre = arbreH[indice].lettre;
	char code_1[NBLETTRES] ;
	char code_2[NBLETTRES] ;
	
	if (fils_g == -1 && fils_d == -1 ){

		printf("Taille de la lettre %d code %s\n", strlen(code),code);
		traduc[lettre].code = code;
		printf(" lettre : %c code : %s\n",lettre,code );
		traduc[lettre].taille = strlen (code);
		printf("taille : %d\n",traduc[lettre].taille );

		*taille_texte_comp += arbreH[indice].occur * traduc[lettre].taille;
		return ;
	}
	

	printf("Taille de la lettre %d code %s\n", strlen(code),code);
	strcpy (code_1,code);
	strcpy (code_2,code);

	code_comp (arbreH, fils_g, traduc,strcat (code_1,"0") ,taille_texte_comp);
	code_comp (arbreH, fils_d , traduc, strcat (code_2,"1") ,taille_texte_comp);

}

int construitCode(Noeud arbreH[], int racine, Code traduc[]){

	int taille_texte_comp = 0;
	int fils_g = arbreH[racine].fg;
	int fils_d = arbreH[racine].fd;

	char code_1[NBLETTRES] = "0";
	char code_2[NBLETTRES] = "1";

	initialiser_tab_code (traduc);
	code_comp (arbreH, fils_g, traduc, code_1, &taille_texte_comp);
	code_comp (arbreH, fils_d, traduc, code_2, &taille_texte_comp);	

	return taille_texte_comp;
}	

-La fonction en question qui contient le printf provoquant la fuite mémoire:

void codeHuffmanX8 (FILE *in, FILE *out){

	int taille_texte, racine, taille_texte_comp ;
	Noeud arbreH[NBNOEUDS];
	Code traduc[NBLETTRES];

	taille_texte = compte_lettre (in, arbreH);
	afficher_tab_noeud (arbreH, NBLETTRES - taille_texte, NBLETTRES);
	racine = construitArbre (arbreH, taille_texte);
	afficher_tab_noeud (arbreH, NBLETTRES, NBLETTRES + taille_texte - 1);
	taille_texte_comp =  construitCode(arbreH, racine, traduc);
	/*afficher_tab_code(traduc);*/	

	printf("La taille_texte est de %d\n",taille_texte_comp );
	/*Le printf précédent créer une fuite mémoire mais je ne sais pas encore pourquoi.*/
	afficher_tab_code(traduc);
	afficher_tab_code(traduc);	
	afficher_tab_code(traduc);		
	
	/*representation_codeX8 (out, arbreH, traduc,racine);

	rewind(in);

	ecrire_compX8 (in, out, traduc);*/
}

Ici le printf modifie uniquement le champs code de la lettre 'b'  les codes des autres lettres restent inchangés .

Merci beaucoup de votre aide

Salut,

Tout d'abord, une fuite mémoire, ce n'est pas ça. C'est un malloc non désalloué.

Ici, tu as très probablement des débordements. contrôle les sorties de tes tableaux.

Et le fait de rajouter un printf décale juste la mémoire, et donc change l'adressage, et les bords de segments.

Quelle  variable est pourrie ? 

Fvirtman a écrit:

Salut,

Tout d'abord, une fuite mémoire, ce n'est pas ça. C'est un malloc non désalloué.

Ici, tu as très probablement des débordements. contrôle les sorties de tes tableaux.

Et le fait de rajouter un printf décale juste la mémoire, et donc change l'adressage, et les bords de segments.

Quelle  variable est pourrie ? 

Merci pour vos précisions, alors sur un premier affichage du tableau de ma structure,  il semblerait que seul le champs "code" de l'indice " 'b' "  ne fonctionne pas mais ensuite plusieurs champs code d'autres indices dysfonctionnent lorsque j'appelle d'autres fonctions.

Je vous joint le résultat de l'affichage sur mon terminal les deux premières colonnes correspondent aux indices de mon tableau et la troisième colonne correspond aux codes (char *) associés à chaque indice:

a 97 0
b 98 110
c 99 1110
d 100 1111
r 114 10
b 98 110

Le printf: La taille_texte est de 26

a 97 0
b 98 /�-C�U
c 99 1110
d 100 1111
r 114 10
b 98 /�-C�U

Alors j'ai réussi à résoudre mon problème en augmentant la taille de mes chaînes de caractères qui contenaient le code associé à chaque lettre, ils étaient à NBLETTRES (255) et je les ai tous mis à 1000, mais je ne saisis pas vraiment ce qui a provoqué le dépassement mémoire car normalement aucun codes ne dépassaient la taille de 255, ils étaient de taille 4 maximum. L'utilisation de strcat et strcpy ont-ils un lien avec mon erreur ? 

-
Edité par Yohan_Ra 1 mai 2019 à 12:12:25

Salut,

Les chaines qui foirent, et vu ton code, ça sent la variable locale passée à un pointeur :

Ta structure contient char* code. et tu fais : traduc[lettre].code = code;

Donc tu poses un pointeur sur une variable locale, qui disparait quand tu quittes la fonction, donc ton pointeur Code::code pointe sur un truc désalloué.

Mon conseil, change ta structure :

struct
{
   char code[MAXCODE];
   int taille;
}

Et fait un strcpy au lieu de faire un = ligne 12 de code_comp

Bonjour,

D'accord merci beaucoup, je comprend mieux mon erreur à présent j'ai effectué les changements et tout marche comme sur des roulettes ! 

Je passe en résolu , bonne journée à toi !