Discussion :

[Zakuh]

Bonjour,

Je tient tout d'abord à dire que je viens poster ici à contrecoeur, je voulais vraiment finir mon programme tout seul, mais franchement, je vois pas du tout comment résoudre mon problème (j'ai déjà fais pleins de tests)

Je créé un programme de révisions de verbes irrégulier (pour l'instant il ne fait que l'anglais, mais l'allemand sera très simple à instaurer une fois le prog fini)

C'est tout bête, on met quelque trou dans les verbes irréguliers (do; did; ______; faire, par exemple) les trous sont des gtk_entry, et pour la correction, je dois comparer le texte des gtk_entry avec le texte correspondant dans le grand tableau tridimensionnel verbe (le problème vient d'ailleur de ce grand tableau je crois, mais pas sûr) qui contient tout les verbes pris au hasard (ben oui, on va pas mettre les 10 même verbes à chaque éxécution du programme, hein :p )

Le problème, c'est qu'une fois que l'utilisateur valide, même si le texte de l'entry est bien correct (égal au verbe correspondant, si je me comprendre), il affiche quand même 0 pts (ouh, le méchant programme !)

Donc, j'ai un problème lors de la comparaison du texte d'une entry et d'une chaine de caractères...

Je vous donne mon code, mais je vous conseil de tester le programme avant de lire le code, ça vous aidera surement à comprendre les commentaires...

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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
#include <stdlib.h>
#include <time.h>
#include <gtk/gtk.h>
 
#define NOMBRE_VERBES 10 /* nombre de verbes différents, beaucoup de choses dépendent de cette macro */
 
void on_validate(GtkWidget *widget, gpointer data); /* callback du bouton valider */
GtkWidget* preparer_fenetre(); /* fonction pour préparer la hbox principale de la fenêtre */
 
char verbe[NOMBRE_VERBES][4][50]; /* mon tableau tridimensionnel des verbes, première dimension pour
                                     les colonnes, deuxième pour les lignes, et troisième pour le text
                                     (on suppose qu'un mot fait maximum 50 lettres)*/
GtkWidget *pLabelOrEntry[NOMBRE_VERBES][4]; /* le tableau de label ou d'entry, avant l'éxécution du
                                               prog, on ne sait pas quelles cases sont des entry */
int tableauBoleens[NOMBRE_VERBES][4] = {0}; /* un tableau de boleens pour savoir quelles cases du
                                               pLabelOrEntry sont des entry (si jme fais comprendre^^) */
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pBtnValider;
    GtkWidget *pVBoxMain; /* vbox principale */
    GtkWidget *pFrameBox; /* la box des 4 frames */
 
    srand(time(NULL));
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Language training");
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    pVBoxMain = gtk_vbox_new(FALSE, 10);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBoxMain);
 
    pBtnValider = gtk_button_new_with_label("Valider");
    gtk_box_pack_end(GTK_BOX(pVBoxMain), pBtnValider, FALSE, FALSE, 0);
 
    pFrameBox = gtk_hbox_new(TRUE, 3);
    pFrameBox = preparer_fenetre(); /* on met tout ce qu'il faut dans la frameBox */
    gtk_box_pack_start(GTK_BOX(pVBoxMain), pFrameBox, FALSE, FALSE, 0);
 
    gtk_widget_show_all(pWindow);
 
    g_signal_connect(G_OBJECT(pBtnValider), "clicked", G_CALLBACK(on_validate), (GtkWidget*) pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
GtkWidget* preparer_fenetre()
{
    GtkWidget *pSeparator; /* un separator pour séparer les verbes */
    GtkWidget *pVBox[4]; /* les 4 vbox contenu des frame */
    GtkWidget *pFrame[4]; /* les 4 frames (infinitif, prétérit, ...) */
    GtkWidget *pFrameBox; /* la box des 4 frames, le widget que l'on va retourner en gros */
 
    pFrameBox = gtk_hbox_new(TRUE, 5);
 
    int i, j;
 
    FILE* fichier = NULL;
 
    fichier = fopen("verbes.txt", "r"); /* on ouvre le fichier des verbes en mode lecture */
 
    if (fichier == NULL)
    {
        printf("Erreur lors de l'ouverture de fichier");
        return EXIT_FAILURE;
    } /* si ça bug on quitte le prog */
 
    int chiffreHasard = 0, nombreVerbeListe = 0;
    int tableauHasardPris[NOMBRE_VERBES] = {0};
    int boleenEntry = 0;
    int caractereLu = 0;
 
    do
    {
        caractereLu = fgetc(fichier);
        if (caractereLu == '\n')
            nombreVerbeListe++;
    } while(caractereLu != EOF); /* On compte le nombre de verbe dans le fichier */
 
 
    /* Ici, ça se complique un tout petit peu, c'est une petite méthode qui permet de remplir le
       tableauBoleens au hasard (tableau qui, je rapelle, sert à définir si on doit mettre une entry
       ou un label), de 0 et de 1, sans mettre deux fois 1 dans une même ligne i */
    for (i = 0; i < NOMBRE_VERBES; i++)
    {
        boleenEntry = 0;
        for (j = 0; j < 4; j++)
        {
            if (!boleenEntry) /* si l'on a pas déjà mis un 1 */
                tableauBoleens[i][j] = rand() % 2; /* on prend un nombre entre 0 et 1 */
 
            else
                tableauBoleens[i][j] = 0; /* sinon on met 0, pour ne pas avoir plusieurs fois 1 */
 
            if (tableauBoleens[i][3] == 0 && boleenEntry == 0) /* si jamais on allait remplir la ligne
                                                                  de 0, on met un 1 à la dernière
                                                                  ligne */
                tableauBoleens[i][3] = 1;
 
            if (tableauBoleens[i][j]) /* si jamais on a attribué un 1 quelque part, il ne faut pas
                                         mettre 2 entry donc on attribue 1 au boleenEntry (en gros
                                         ça signifie qu'il ne faut pas remettre une autre entry */
                boleenEntry = 1;
        }
    }
 
    pFrame[0] = gtk_frame_new("Infinitif"); /* on donne des noms au 4 frames */
    pFrame[1] = gtk_frame_new("Prétérit");
    pFrame[2] = gtk_frame_new("Participe passé");
    pFrame[3] = gtk_frame_new("Traduction");
 
    for (i = 0; i < 4; i++) /* puis on leur ajoute une vbox et on les met dans le frameBox */
    {
        pVBox[i] = gtk_vbox_new(TRUE, 0);
        gtk_container_add(GTK_CONTAINER(pFrame[i]), pVBox[i]);
        gtk_box_pack_start(GTK_BOX(pFrameBox), pFrame[i], FALSE, TRUE, 0);
    }
 
    /* Ici, c'est encore une petite méthode pour remplir le tableau de verbe */
    for (i = 0; i < NOMBRE_VERBES; i++)
    {
        rewind(fichier); /* on remonte au début du fichier */
 
        do
        {
            chiffreHasard = rand() % nombreVerbeListe; /* on prend une ligne au hasard */
            for (j = 0; j < NOMBRE_VERBES; j++)
            {
                if (tableauHasardPris[j] == chiffreHasard) /* si la ligne a déjà été prise */
                    chiffreHasard = 0; /* on recommence ! */
            }
        } while (!chiffreHasard);
 
        tableauHasardPris[i] = chiffreHasard; /* on met le numéro de la ligne dans le tableau pour ne
                                                 pas reprendre la même ligne et avoir deux fois le même
                                                 verbe dans la fenêtre */
        while (chiffreHasard > 0) /* on avance jusqu'à la ligne voulue */
        {
            caractereLu = fgetc(fichier);
            if (caractereLu == '\n')
                chiffreHasard--;
        }
 
        /* puis on enregistre la ligne dans verbe */
        fscanf(fichier, "%s %s %s %s", &verbe[i][0], &verbe[i][1], &verbe[i][2], &verbe[i][3]);
    }
 
    /* on créer ensuite des label et des entry en fonction du tableauBoleens et des verbes pris */
    for (i = 0; i < NOMBRE_VERBES; i++)
    {
        for (j = 0; j < 4; j++)
        {
            if (tableauBoleens[i][j]) /* si tableauBoleens == 1 */
                pLabelOrEntry[i][j] = gtk_entry_new(); /* c'est une entry */
 
            else
                pLabelOrEntry[i][j] = gtk_label_new(verbe[i][j]); /* sinon un label */
 
            gtk_box_pack_start(GTK_BOX(pVBox[j]), pLabelOrEntry[i][j], FALSE, FALSE, 0);
 
            if (i != NOMBRE_VERBES - 1) /* si c'est pas la dernière ligne */
            {
                pSeparator = gtk_hseparator_new(); /* on ajoute un separateur */
                gtk_box_pack_start(GTK_BOX(pVBox[j]), pSeparator, FALSE, FALSE, 0);
            }
        }
    }
 
    fclose(fichier);
 
    return pFrameBox; /* puis on retourne notre frameBox, voilà, notre fenêtre principale est prête ! */
}
 
void on_validate(GtkWidget *widget, gpointer data)
{
    /* avec toutes ces définitions, on recréer la fenêtre principale sans les entry en gros */
    GtkWidget *pDialogWindow;
    GtkWidget *pSeparator;
    GtkWidget *pFrameBox;
    GtkWidget *pFrame[5];
    GtkWidget *pVBox[5];
    GtkWidget *pLabelReponse[NOMBRE_VERBES][4];
 
    int i, j;
 
    /* la fenêtre de dialogue */
    pDialogWindow = gtk_dialog_new_with_buttons("Résultat",
                                                GTK_WINDOW((GtkWidget*) data),
                                                GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
                                                GTK_STOCK_OK,
                                                GTK_RESPONSE_ACCEPT,
                                                NULL);
    pFrameBox = gtk_hbox_new(TRUE, 5);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pDialogWindow)->vbox), pFrameBox, TRUE, FALSE, 0);
 
    pFrame[0] = gtk_frame_new("Infinitif");
    pFrame[1] = gtk_frame_new("Prétérit");
    pFrame[2] = gtk_frame_new("Participe passé");
    pFrame[3] = gtk_frame_new("Traduction");
    pFrame[4] = gtk_frame_new("Résultats");
 
    /* ces deux boucles for sont les même que dans preparerFenetre */
    for (i = 0; i < 5; i++)
    {
        gtk_box_pack_start(GTK_BOX(pFrameBox), pFrame[i], TRUE, TRUE, 0);
        pVBox[i] = gtk_vbox_new(TRUE, 0);
        gtk_container_add(GTK_CONTAINER(pFrame[i]), pVBox[i]);
    }
 
    for (i = 0; i < NOMBRE_VERBES; i++)
    {
        for (j = 0; j < 4; j++)
        {
            pLabelReponse[i][j] = gtk_label_new(verbe[i][j]);
            gtk_box_pack_start(GTK_BOX(pVBox[j]), pLabelReponse[i][j], FALSE, FALSE, 0);
 
            if (i != NOMBRE_VERBES - 1)
            {
                pSeparator = gtk_hseparator_new();
                gtk_box_pack_start(GTK_BOX(pVBox[j]), pSeparator, FALSE, FALSE, 0);
            }
        }
    }
 
    /* c'est par contre dans celle ci qu'il y a un problème */
 
    for (i = 0; i < NOMBRE_VERBES; i++)
    {
        for (j = 0; j < 4; j++)
        {
            if (tableauBoleens[i][j]) /* en gros avec ça, on cherche une entry */
            {
                /* une fois trouvé, on regarde si le texte de l'entry correspondant au texte de verbe */
                if (gtk_entry_get_text(GTK_ENTRY(pLabelOrEntry[i][j])) == verbe[i][j])
                    pLabelReponse[i][4] = gtk_label_new("1 pts");
 
                /* malheuresement même si le texte est correct, il n'entre pas dans le if :( */
                else
                    pLabelReponse[i][4] = gtk_label_new("0 pts"); /* et il affiche 0 pts */
            }
        }
        gtk_box_pack_start(GTK_BOX(pVBox[4]), pLabelReponse[i][4], FALSE, FALSE, 0);
 
        if (i != NOMBRE_VERBES - 1)
        {
            pSeparator = gtk_hseparator_new();
            gtk_box_pack_start(GTK_BOX(pVBox[4]), pSeparator, FALSE, FALSE, 0);
        }
    }
 
    gtk_widget_show_all(pDialogWindow);
    gtk_dialog_run(GTK_DIALOG(pDialogWindow));
    gtk_widget_destroy(pDialogWindow);
}

le problème est à la ligne 239 :

Code :

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

1
2
 
if (gtk_entry_get_text(GTK_ENTRY(pLabelOrEntry[i][j])) == verbe[i][j])

Voilà, merci d'avance...

ps : j'ai oublié de vous dire de créer un petit verbes.txt dans le dossier pour pouvoir tester, j'ai rajouté quelque verbes de bases dedans, vous pouvez prendre les miens, ou en mettre d'autre :

be was been etre
become became become devenir
beat beat beaten battre
lose lost lost perdre
go went gone aller
buy bought bought acheter
choose chose chosen choisir
cut cut cut couper
draw drew drawn dessiner
dream dreamt dreamt rever
do did done faire

[teuf13]

Les chaînes de caractère en C ne se comparent pas avec ==, il faut utiliser strcmp

[liberforce]

Il y a d'autres erreurs aussi... On voit rapidement:

Code :

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

return EXIT_FAILURE;

Dans une fonction qui renvoie un GtkWidget *, tu vas forcément te gaufrer. Tu dois soit faire un

Code :

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

exit(EXIT_FAILURE);

ou bien un

Code :

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

return NULL;

Mais comme les codes de succès valent quasiment toujours 0 et les codes d'erreur sont ≠ 0, alors tu vas renvoyer une valeur non nulle qui va être prise pour l'adresse d'un GtkWidget... Crash assuré dès que tu utiliseras cette valeur.

De plus, il te faudrait gérer des tableaux dynamiques plutôt que des tableaux à taille fixe. Ainsi tu pourrais avoir autant de lignes que tu veux dans ton dictionnaire sans avoir à recompiler l'application dès que tu en rajoutes une. Regarde du côté de GPtrArray pour stocker chacune des chaînes correspondant à un verbe.

De même, regarde du côté de g_strsplit pour faire le découpage sur une ligne des différents verbes. Ensuite, je te conseille d'utiliser une virgule comme séparateur, c'est le format CSV. Cela te permettra de gérer plus facilement les temps du passé où tu as un modal + verbe (ex: have been), car ils contiennent un espace.

Tu peux aussi pour aller plus vite lire ton fichier avec g_file_get_contents, et appeler g_strsplit sur le résultat en prenant "\n" comme séparateur, ce qui te permettra d'avoir directement le découpage du fichier en lignes, ou utiliser g_io_channel_read_line pour lire les lignes une à une... Mais Rome ne s'est pas faite un un jour

[Zakuh]

C'est marrant, j'y ai pensé cette nuit à utiliser strcmp, en tout cas, merci bien, ça marche.
Sinon pour liberforce, j'vais regarder tout ce que tu me dis là, et modifier ce qui va pas

merci à vous deux

edit: tant qu'on y ai, je crois que j'avais déjà comparé des caractères (char) entre eux (=), et ça marchait, c'est normal que ça marche sur des caractères et pas sur des chaines ?

[teuf13]

edit: tant qu'on y ai, je crois que j'avais déjà comparé des caractères (char) entre eux (=), et ça marchait, c'est normal que ça marche sur des caractères et pas sur des chaines ?

Oui c'est normal. Un caractère c'est une valeur entière donc ça peut se comparer avec ==, une chaîne est un objet plus complexe donc on ne peut pas le comparer avec ==

[liberforce]

En fait un caractère est une valeur numérique comme une autre. Le processeur peut comparer 2 nombres sans soucis.

Mais dans le cas de chaînes de caractères, tu vas te retrouver avec l'opérateur == à comparer des adresses entre elles, et là c'est très différent. Que ce soit un tableau ou via un pointeur de caractères, le comportement est sensiblement même. Ce qu'il faut c'est comparer le "contenu" des chaînes de caractères, et pas leur adresse en mémoire.

exemple:

Code :

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

1
2
3
4
5
6
7
 
/* a pointe sur la zone mémoire contenant "toto" */
const char *a = "toto";
/* b contient la même adresse que a, celle de la zone mémoire contenant "toto" */
const char *b = a;
a == b; /* c'est faux */
strcmp (a, b) == 0; /* c'est vrai */