Discussion :

[Hyrr0]

Bonjour à tous !

Mon premier message sur ce forum *verse sa petite larme émue*

Je me tourne vers vous aujourd'hui parce que je tourne en rond et ne vois pas de solutions.
Nous devons créer un dictionnaire géré par un arbre binaire de recherche afin que la recherche de mots soit plus aisée. On a tout codé, tout fonctionne avec le type char, sauf les accents. Tout les caractères s'y ajoute bien, sauf les accents, et lors de la recherche, tout se retrouve bien sauf devinez quoi ... les accents !

Alors j'ai tenté le type unsigned char qui n'a pas fonctionné, ainsi que le type wchar_t. Ce dernier semble fonctionner puisque j'ai des accents sur la sortie standard mais en revanche la fonction fgetws s'arrête dès la première ligne du fichier !

Si vous avez d'autres idées pour pouvoir gérer ces accents je suis preneur

Je poste le code que l'on a pour le moment (qui correspond à la partie qui pose problème)

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/**
* \file dictionnaire.c
* \brief Opérations liées au dictionnaire.
**/
#include "dictionnaire.h"
 
Dico* nouveauNoeud(wchar_t *caractereAInserer, booleen finMot){
  Dico *newNoeud = NULL;
  newNoeud = (Dico *) malloc (sizeof(Dico));
  newNoeud->carac = *caractereAInserer;
  newNoeud->finDemot = finMot;
  newNoeud->lettreSuivanteDuMot = NULL;
  newNoeud->nouvelleLettre = NULL;
  return newNoeud;
}
 
void ajouterPremierMot(Dico **arbre,wchar_t * mot){
	if(wcslen(mot) != 0){
		if(*arbre == NULL){
			if(wcslen(mot) == 1){
				*arbre = nouveauNoeud(mot,TRUE);
				ajouterPremierMot(arbre, ++mot);
			}
			else{
				*arbre = nouveauNoeud(mot,FALSE);
				ajouterPremierMot(arbre, ++mot);
			}
 
        }
		else{
            if(wcslen(mot)>1){
                (*arbre)->lettreSuivanteDuMot = nouveauNoeud(mot,FALSE);
                ajouterPremierMot(&((*arbre)->lettreSuivanteDuMot),++mot);
            }
            else{
                (*arbre)->lettreSuivanteDuMot = nouveauNoeud(mot,TRUE);
                ajouterPremierMot(&((*arbre)->lettreSuivanteDuMot),++mot);
            }
 
		}
	}
}
 
void ajouterUnMot(Dico **arbre, wchar_t *mot){
	if(wcslen(mot) != 0){
        if(*arbre == NULL)
        {
            ajouterPremierMot(arbre,mot);
        }
        else{
            if((*mot) == (*arbre)->carac){
                if(wcslen(mot) == 1)
                    (*arbre)->finDemot = TRUE;
                ajouterUnMot(&((*arbre)->lettreSuivanteDuMot),++mot);
            }
            else{
                if((*arbre)->nouvelleLettre != NULL){
                    ajouterUnMot(&((*arbre)->nouvelleLettre),mot);
                }
                else{
                    if(wcslen(mot)==1)
                        (*arbre)->nouvelleLettre = nouveauNoeud(mot,TRUE);
                    else
                        (*arbre)->nouvelleLettre = nouveauNoeud(mot,FALSE);
                    ajouterUnMot(&((*arbre)->nouvelleLettre),mot);
                }
            }
        }
	}
}
 
booleen motEstPresent(Dico **leDico, wchar_t* leMot){
    if(*leDico==NULL)
        return FALSE;
    else{
        if (wcslen(leMot)==1 && (*leDico)->finDemot){
            if  ((*leDico)->carac==(*leMot))
                return TRUE;
            else
                return FALSE;
            }
        else if (leMot[0] == (*leDico)->carac)
            return motEstPresent(&((*leDico)->lettreSuivanteDuMot),++leMot);    
        else
            return motEstPresent(&((*leDico)->nouvelleLettre),leMot);
        }
}
 
/* Fonction d'affichage de l'arbre avec un parcourt RGD de l'arbre binaire*/
void afficher(Dico *arbre){
    if(arbre != NULL)
    {
        if(arbre->finDemot == TRUE)
            printf("mot Fini\t");
        wprintf(L"%lc\n",(const wchar_t)arbre->carac);
        afficher(arbre->lettreSuivanteDuMot);
        afficher(arbre->nouvelleLettre);
    }
}
 
void remplirDictionnaire(Dico **arbre, FILE *fichierARentrer){
	wchar_t buffer[100];
	while (fgetws(buffer, 100, fichierARentrer)){
		wprintf(L"Entrée dans la boucle");
        buffer[wcslen(buffer)-1] = 0;
		wprintf(L"mot a ajouter : %ls\n",buffer);
        ajouterUnMot(arbre,buffer);	
    }
    fclose(fichierARentrer);
}
 
int verifDico(Dico **arbre, FILE *fichier){
    wchar_t buffer[50];
    int total = 0;
 
    printf("Entree dans verifDico \n");
    while(fgetws(buffer, 50, fichier) != NULL){
        printf("entrer dans while parcours fichier verif \n");
        buffer[wcslen(buffer)-1] = 0;
        if (motEstPresent(arbre, buffer)){
            total = total+1;
            printf("Nb mots : %d", total);
        }
    }
    return total;
}
 
int main(int argc, char *argv[]){
	setlocale(LC_ALL, "fr_FR.UTF-8");
    Dico *lex = NULL;
    FILE *fichier;
    /*int nombre = 0;*/
    fichier = fopen("dico-ref-ascii.txt","r");
    if(fichier == NULL){
        printf("impossible d'ouvrir le fichier. Verifier que ce dernier est bien present\n");
    }
    else{
        remplirDictionnaire(&lex,fichier);
    }
    afficher(lex);
    /*nombre = verifDico(&lex,fichier);
    printf("Le nombre total de mots est : %d",nombre);*/
    wchar_t *mot; 
    mot = malloc(8*sizeof(wchar_t));
    mot = L"zygène";
    if (motEstPresent(&lex,mot)){
        printf("J'ai trouve le mot!");
    }
    else{
        printf("fuck ca marche pas!");
    }
 
  return 0;
}

Ainsi que l'affichage en sortie standard :

Code :

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

1
2
3
[monUtilisateur@maMachine Documents]$ ./monDico 
Entrée dans la bouclemot a ajouter : a
a

Merci d'avance pour votre aide !

[Sve@r]

Code :

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

1
2
3
4
5
6
int main(int argc, char *argv[]){
...
    wchar_t *mot; 
    mot = malloc(8*sizeof(wchar_t));
    mot = L"zygène";
}

Bonjour

Après un premier parcours très rapide du code, moi je vois ça et ça ça me choque. Déjà bon on perd l'adresse allouée (à la limite on s'en fout) mais (je ne connais pas le wchat_t) cette affectation barbare...

Accessoirement moi je te conseillerais de créer une structure dédiée à l'arbre lui-même. Certes cette structure ne contiendrait qu'un élément (la racine de l'arbre) mais cela apporterait plusieurs avantages

• tu éviterais ces doubles étoiles (nécesaire à la modification de ladite racine). La fonction embarquant l'arbre aurait accès à la racine et pourrait la modifier facilement
• le jour où tu veux rajouter des outils de gestion de l'arbre (comme sa profondeur, d'autres pointeurs de recherche, etc) tu les rajoutes dans la structure. Ipso facto toutes les fonctions recevant cette structure auraient instantanément accès aux outils associés

Bref cela n'apporte que des avantages. y compris une relecture plus aisée du code (parce que parfois avec ces &(*truc->chose...). Comme je dis souvent, une chemise on peut la tenir par le col mais ça va beaucoup mieux si on la met sur un cintre...

[Médinoc]

@Sve@r: L'affectation est correcte (mais bien sûr, la fuite de mémoire ne l'est pas).

[Hyrr0]

Merci pour votre aide déjà

Le problème est en partie résolu par le passage du code en ISO 8859−1 et l'utilisation du char au lieu de wchar, et du terminal par la même occasion. Les tests unitaires devront vérifier que tout fonctionne, et je suis en ce moment même en train de les coder.

Si vous pouviez m'expliquer un peu pourquoi cette partie n'est pas bonne je suis preneur. Elle n'est pas destinée à rester dans le code, c'était juste un simple test pour chercher un mot. Mais la connaissance est toujours bonne à prendre

Je vous remercie pour tous les commentaires constructifs que vous pourrez m'apporter

[Médinoc]

Le problème est en partie résolu par le passage du code en ISO 8859−1 et l'utilisation du char au lieu de wchar,

Bienvenue dans le passé... *soupir*

[Sve@r]

Si vous pouviez m'expliquer un peu pourquoi cette partie n'est pas bonne je suis preneur. Elle n'est pas destinée à rester dans le code, c'était juste un simple test pour chercher un mot. Mais la connaissance est toujours bonne à prendre

Ben cette partie n'et pas bonne parce que tu demandes au système qu'il te fournisse une zone mémoire. Et ensuite tu écrases la variable qui contient l'adresse que t'a renvoyé le système. Tu perds donc cette adresse donc tu perds la mémoire allouée qui restera bloquée au-mieux jusqu'à la fin du programme et au pire jusqu'au reboot de ton OS...