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 !