Discussion :

[abdelhamidem]

Bonjour,

Désolé pour le flou du titre, mais je n'ai pas trouvé mieux...
En fait je suis en train de faire un programme où l'utilisateur doit entrer un "mot" au depart.

Si le mot est du genre "allo" ou "baba" ... il y a un traitement qui s'en suit et tout est OK.

Ce que je cherche à faire, c'est que quand l'utilisateur n'entre RIEN (c'est à dire il tape directement sur entrée) alors le programme est quitté.

J'ai essayé de faire avec scanf, gets, avec une ptite fonction myGets que j'ai trouvé dans les cours du site ... mais je n'y arrive pas.
Je ne sais meme pas avec quoi je dois comparer le mot entrer pour savoir si l'utilisateur a bien juste tapé la touche "entrée" (avec "\n" ou '\0' ou "" ou ...)

voila la fonction myGets si elle peut s'averer utile dans mon cas :

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
 
char *myGets(char *mot)
{
    int c, i = 0;
    c = getchar();
    while (c != '\n')
    {
        if (c == EOF)
            return NULL;
        mot[i++] = c;
        c = getchar();
    }
    mot[i] = '\0';
    return mot;
}

[Emmanuel Delahaye]

Ce que je cherche à faire, c'est que quand l'utilisateur n'entre RIEN (c'est à dire il tape directement sur entrée) alors le programme est quitté.

Je conseille d'utiliser fgets() pour faire toutes les saisies. On utilise ensuite une fonction [f]clean() développée par la communauté, et dont tu trouveras le code et des exemples d'utilisation sur ce forum en cherchant un peu. Le but est de nettoyer à la fois la chaine saisie et le flux entrant de façon à obtenir des conditions stables.

Si l'utilisateur entre 'rien', on se retrouve tout simplement avec une chaine vide, ce qui se teste très simplement en vérifiant la valeur du premier caractère de la ligne saisie : if (*ligne == 0)

[diogene]

myGets teste si la fin de l'entrée est obtenue par '\n' ou EOF, mais dans les deux cas, elle devrait retourner la chaîne entrée correctement terminée par '\0'

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
char *myGets(char *mot)
{
    int c, i = 0;
    c = getchar();
    while (c != '\n' && c != EOF)
    {
        mot[i++] = c;
        c = getchar();
    }
    mot[i] = '\0';
    return c==EOF ? NULL : mot;
}

La fonction retourne NULL si la fin de l'entrée est EOF . Si l'utilisateur a tapé directement '\n' ou EOF, la chaîne retournée est vide (elle ne contient que le zéro terminal) et le code appelant cette fonction peut donc facilement tester cette condition.

[abdelhamidem]

Je conseille d'utiliser fgets() pour faire toutes les saisies. On utilise ensuite une fonction [f]clean() développée par la communauté, et dont tu trouveras le code et des exemples d'utilisation sur ce forum en cherchant un peu. Le but est de nettoyer à la fois la chaine saisie et le flux entrant de façon à obtenir des conditions stables.

Si l'utilisateur entre 'rien', on se retrouve tout simplement avec une chaine vide, ce qui se teste très simplement en vérifiant la valeur du premier caractère de la ligne saisie : if (*ligne == 0)

Bon j'ai essayé d'appliquer votre solution, mais ca ne marche pas. A chaque fois que je tape entrée, le programme me redemande "Entrez le mot a reconnaitre..."

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
 
int main()
{
    int i;
 
    mot = (char*) malloc(10*sizeof(char));
 
    printf("Nombre d'etats      :");
    scanf("%d",&nb_etats);
 
    printf("Nombre de lettres   :");
    scanf("%d",&nb_lettres);
 
    /*saisie des elements de l'automate*/
    saisie(nb_etats,nb_lettres);
 
    /*affichage des elements de l'automate*/
    affichage();
 
    do
    {
        printf("Entrer le mot à reconnaitre : ");
        //scanf("%s",mot);
 
        /*Si l'utilisateur n'entre rien, le programme est terminé*/
        fgets(mot, sizeof(mot), stdin);
        fclean(mot, stdin);
        if(*mot==0)
        {
            puts("au revoir!");
            return 0;
        }
 
        /*traitement du mot entré par l'automate*/
        for(i = 0; i<nb_etats; i++)
        {
            if(Initiaux[i]==1)
            {
                if(estReconnu(mot, i)==1)
                {
                    puts("mot est reconnu");
                    //getch();
                    //return 0;
                    break;
                }
 
            }
        }
 
    }
    while(1);
 
    puts("mot NON reconnu");
    getch();
    return 0;
}

[Emmanuel Delahaye]

Bon j'ai essayé d'appliquer votre solution, mais ca ne marche pas.

Ben oui. Quels sont les mots que tu ne comprends pas dans "Je conseille d'utiliser fgets() pour faire toutes les saisies."

Ton code est bourré de scanf() et autres getch() imbuvables... Fait exactement ce qui est conseillé et après tu pourras dire si ça fonctionne ou non.

Nota : ton code est incomplet et il ne compile pas.

[abdelhamidem]

Ben oui. Quels sont les mots que tu ne comprends pas dans "Je conseille d'utiliser fgets() pour faire toutes les saisies."

Ton code est bourré de scanf() et autres getch() imbuvables... Fait exactement ce qui est conseillé et après tu pourras dire si ça fonctionne ou non.

Nota : ton code est incomplet et il ne compile pas.

Je ne pensais pas que mes 2 premiers scanf auraient tant d'influence sur mon probleme. C'est surtout parceque je trouve scanf plus commode pour entrer des entiers que je l'utilise. Et aussi pcq je ne maitrise pas encore fgets/fclean comme vous pourrez le voir...

Voila mon code en entier:

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
 
#include<stdio.h>
#include<conio.h>
#include<string.h>
 
typedef struct noeud
{
    int etat;
    struct noeud *suiv;
}
noeud;
 
typedef noeud *Liste;
 
int nb_etats,nb_lettres;
 
 
int Finaux[10], Initiaux[10];
Liste A[10][10];
char* mot;
 
Liste ajout_noeud(Liste lst, int nouvEtat)
{
    /* On crée un nouvel élément */
    noeud* nouvNoeud = malloc(sizeof(noeud));
 
    /* On assigne la valeur au nouvel élément */
    nouvNoeud->etat = nouvEtat;
 
    /* On assigne l'adresse de l'élément suivant au nouvel élément */
    nouvNoeud->suiv = lst;
 
    /* On retourne la nouvelle liste, i.e. le pointeur sur le premier élément */
    return nouvNoeud;
 
}
 
/* Fonction de saisie de l'automate*/
void saisie()
{
 
    int i,j,k;
    int max, succ;
 
    for(i=0;i<nb_etats;i++)
    {
        for(j=0;j<nb_lettres;j++)
        {
            A[i][j]=NULL;
            printf("entrez le nb de successeur a delta( Q(%d) , %c ) : ",i,j+97);
            scanf("%d",&max);
            for(k=1; k<=max; k++)
            {
                printf("entrez le %de etat successeur de l'etat %d par %c: ", k,i,j+97);
                scanf("%d", &succ);
                A[i][j]=ajout_noeud(A[i][j], succ);
            }
 
        }
        printf("\n");
    }
 
    for(i=0;i<nb_etats;i++)
    {
        printf("entrer -1- si q(%d) est Initial ou -0- sinon :  ",i);
        scanf("%d",&Initiaux[i]);
    }
 
    for(i=0;i<nb_etats;i++)
    {
        printf("entrer -1- si q(%d) est final ou -0- sinon :  ",i);
        scanf("%d",&Finaux[i]);
    }
 
}
 
/*Fonction qui teste si un mot est reconnu par l'automate ou non*/
int estReconnu(char* mot, int etatinit)
{
    char lettre;
    Liste nouv_list;
    int estrec=0;
 
    if (strlen(mot) == 0)
        return (Finaux[etatinit]);
    else
    {
        lettre=mot[0];
        nouv_list=A[etatinit][lettre-97];
 
        while( (nouv_list != NULL) && (estrec!=1))
        {
            estrec=estReconnu(mot+1,nouv_list->etat);
            nouv_list=nouv_list->suiv;
        }
        return estrec;
    }
}
 
/* Affichage de l'automate ... */
void affichage()
{
    int i, j;
    noeud *temp;
 
    for(i=0; i<nb_etats; i++)
        for(j=0; j<nb_lettres; j++)
        {
            temp = A[i][j];
            printf("delta( Q(%d) , %c ) ={\n", i, j+97);
            while(temp)
            {
                printf("%d, \t", temp->etat);
                temp = temp->suiv;
            }
            puts("}");
 
        }
 
}
 
/*Fonction pour libere la memoire utilisée par l'automate. Pas encore OK*/
void liberation_memoire(Liste *p)
{
    noeud *tmp;
    while(*p)
    {
        //tmp = (*p)->prec;
        free(*p);
        *p = tmp;
    }
 
}
 
char *myGets(char *mot)
{
    int c, i = 0;
    c = getchar();
    while (c != '\n' && c != EOF)
    {
        mot[i++] = c;
        c = getchar();
    }
    mot[i] = '\0';
    return c==EOF ? NULL : mot;
}
 
static void fclean(char *chaine, FILE *fp)
{
    char *p = strchr(chaine, '\n');
 
    if (p != NULL)
    {
        *p = 0;
    }
    else
    {
        int c;
 
        while ((c = fgetc(fp)) != '\n' && c != EOF)
        {
        }
    }
}
 
int main()
{
    int i;
    char* temp;
 
    mot = (char*) malloc(10*sizeof(char));
 
    printf("Nombre d'etats      :");
    //scanf("%d",&nb_etats);
    fgets(temp, sizeof(temp), stdin);
    /*on convertit temp en chiffre*/
    nb_etats = (*temp)-97;
    fclean(temp, stdin);
 
    printf("Nombre de lettres   :");
    //scanf("%d",&nb_lettres);
    fgets(temp, sizeof(temp), stdin);
    /*on convertit temp en chiffre*/
    nb_lettres=(*temp)-97;
    fclean(temp, stdin);
 
    /* ces deux appels peuvent etre ignorés vu qu'ils n'interviennent pas dans le probleme*/
    saisie(nb_etats,nb_lettres);
    affichage();
 
    do
    {
        printf("Entrer le mot … reconnaitre : ");
        //scanf("%s",mot);
 
        fgets(mot, sizeof(mot), stdin);
        fclean(mot, stdin);
 
        if(*mot=='\0')
        {
            puts("au revoir!");
            return 0;
        }
 
        for(i = 0; i<nb_etats; i++)
        {
            if(Initiaux[i]==1)
            {
                if(estReconnu(mot, i)==1)
                {
                    puts("mot est reconnu");
                    break;
                }
 
            }
        }
 
    }
    while(1);
 
    puts("mot NON reconnu");
    system("PAUSE");
    return 0;
}

Merci pour votre aide.

[Trap D]

Je ne pensais pas que mes 2 premiers scanf auraient tant d'influence sur mon probleme. C'est surtout parceque je trouve scanf plus commode pour entrer des entiers que je l'utilise.

Tu as la démonstration par le vécu que ce n'est pas commode du tout, au contraire.

[abdelhamidem]

Dans le main j'utilisais 3 scanf:

2 pour entrer les valeurs de nb_etats et nb_lettres qui sont des nombres => no problem.

1 scanf pour entrer un mot, une chaine de lettre: scanf("%s", mot) => probleme quand l'utilisateur n'entre 'rien'.

A Emmanuel Delahaye: Soyez indulgent pour la foultitude de scanf qu'on trouve dans les autres fonctions, en dehors du main . Je pourrais les remplacer apres...

[Emmanuel Delahaye]

Je ne pensais pas que mes 2 premiers scanf auraient tant d'influence sur mon probleme. C'est surtout parceque je trouve scanf plus commode pour entrer des entiers que je l'utilise. Et aussi pcq je ne maitrise pas encore fgets/fclean comme vous pourrez le voir...

Le problème, c'est que tu ne maitrises pas non plus scanf(), ce qui n'est pas surprenant, vue la complexité de cette fonction...

http://xrenault.developpez.com/tutoriels/c/scanf/

Voila mon code en entier:

Tu peux commencer par corriger ça :

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
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c: In function `ajout_noeud':
main.c:24: warning: implicit declaration of function `malloc'
main.c: At top level:
main.c:39: warning: function declaration isn't a prototype
main.c:101: warning: function declaration isn't a prototype
main.c: In function `liberation_memoire':
main.c:128: warning: implicit declaration of function `free'
main.c:124: warning: 'tmp' might be used uninitialized in this function
main.c: At top level:
main.c:166: warning: function declaration isn't a prototype
main.c: In function `main':
main.c:221: warning: implicit declaration of function `system'
main.c:220: warning: will never be executed
main.c:220: warning: will never be executed
main.c:168: warning: 'temp' might be used uninitialized in this function
Linking console executable: console.exe
Process terminated with status 0 (0 minutes, 2 seconds)
0 errors, 10 warnings

Si ton compilateur ne dit rien, il est probablement mal réglé :

http://emmanuel-delahaye.developpez....tm#cfg_compilo

Il y a des globales inutiles dans ton code. Les fonctions ont des paramètres, c'est fait pour. Les structures permettent d'organiser les données...

Attention, tu 'caches' un pointeur :

Code :

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

typedef noeud *Liste;

Cette pratique peut rendre fou...

Code :

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

1
2
3
4
5
6
7
 
/* Fonction de saisie de l'automate*/
void saisie ()
{
<...>
 
   saisie (nb_etats, nb_lettres);

ça aussi...

Code :

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

1
2
3
4
5
 
   fgets (temp, sizeof (temp), stdin);
   /*on convertit temp en chiffre */
   nb_etats = (*temp) - 97;
   fclean (temp, stdin);

sizeof n'a de sens que si on a un tableau. Evidemment, avec un pointeur, ça ne veut rien dire. Il faut passer la taille allouée... de plus, temp n'a jamais été initialisé. Contente toi de définir un simple tableau de 10 char...

La conversion d'une chaine en valeur numérique se fait avec strtol(), et certainement pas avec cette bidouille infâme...

Ton code rendu présentable, compilable avec avec des saisies correctes :

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
 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
typedef struct noeud
{
   int etat;
   struct noeud *suiv;
}
noeud;
 
typedef noeud *Liste;
 
int nb_etats, nb_lettres;
 
int Finaux[10], Initiaux[10];
Liste A[10][10];
char *mot;
 
Liste ajout_noeud (Liste lst, int nouvEtat)
{
   /* On crée un nouvel élément */
   noeud *nouvNoeud = malloc (sizeof (noeud));
 
   /* On assigne la valeur au nouvel élément */
   nouvNoeud->etat = nouvEtat;
 
   /* On assigne l'adresse de l'élément suivant au nouvel élément */
   nouvNoeud->suiv = lst;
 
   /* On retourne la nouvelle liste, i.e. le pointeur sur le premier élément */
   return nouvNoeud;
 
}
 
#if 0
/* Fonction de saisie de l'automate*/
void saisie (void)
{
 
   int i, j, k;
   int max, succ;
 
   for (i = 0; i < nb_etats; i++)
   {
      for (j = 0; j < nb_lettres; j++)
      {
         A[i][j] = NULL;
         printf ("entrez le nb de successeur a delta( Q(%d) , %c ) : ", i,
                 j + 97);
         scanf ("%d", &max);
         for (k = 1; k <= max; k++)
         {
            printf ("entrez le %de etat successeur de l'etat %d par %c: ", k,
                    i, j + 97);
            scanf ("%d", &succ);
            A[i][j] = ajout_noeud (A[i][j], succ);
         }
 
      }
      printf ("\n");
   }
 
   for (i = 0; i < nb_etats; i++)
   {
      printf ("entrer -1- si q(%d) est Initial ou -0- sinon :  ", i);
      scanf ("%d", &Initiaux[i]);
   }
 
   for (i = 0; i < nb_etats; i++)
   {
      printf ("entrer -1- si q(%d) est final ou -0- sinon :  ", i);
      scanf ("%d", &Finaux[i]);
   }
 
}
#endif
 
/*Fonction qui teste si un mot est reconnu par l'automate ou non*/
int estReconnu (char *mot, int etatinit)
{
   char lettre;
   Liste nouv_list;
   int estrec = 0;
 
   if (strlen (mot) == 0)
      return (Finaux[etatinit]);
   else
   {
      lettre = mot[0];
      nouv_list = A[etatinit][lettre - 97];
 
      while ((nouv_list != NULL) && (estrec != 1))
      {
         estrec = estReconnu (mot + 1, nouv_list->etat);
         nouv_list = nouv_list->suiv;
      }
      return estrec;
   }
}
 
/* Affichage de l'automate ... */
void affichage (void)
{
   int i, j;
   noeud *temp;
 
   for (i = 0; i < nb_etats; i++)
      for (j = 0; j < nb_lettres; j++)
      {
         temp = A[i][j];
         printf ("delta( Q(%d) , %c ) ={\n", i, j + 97);
         while (temp)
         {
            printf ("%d, \t", temp->etat);
            temp = temp->suiv;
         }
         puts ("}");
 
      }
 
}
 
/*Fonction pour libere la memoire utilisée par l'automate. Pas encore OK*/
void liberation_memoire (Liste * p)
{
   noeud *tmp;
   while (*p)
   {
      //tmp = (*p)->prec;
      free (*p);
      *p = tmp;
   }
 
}
 
char *myGets (char *mot)
{
   int c, i = 0;
   c = getchar ();
   while (c != '\n' && c != EOF)
   {
      mot[i++] = c;
      c = getchar ();
   }
   mot[i] = '\0';
   return c == EOF ? NULL : mot;
}
 
static void fclean (char *chaine, FILE * fp)
{
   char *p = strchr (chaine, '\n');
 
   if (p != NULL)
   {
      *p = 0;
   }
   else
   {
      int c;
 
      while ((c = fgetc (fp)) != '\n' && c != EOF)
      {
      }
   }
}
 
int main (void)
{
   int i;
   char temp[10];
 
   mot = (char *) malloc (10 * sizeof (char));
 
   printf ("Nombre d'etats      :");
   fgets (temp, sizeof temp, stdin);
   fclean (temp, stdin);
   nb_etats = strtol(temp, NULL, 10);
 
   printf ("Nombre de lettres   :");
   fgets (temp, sizeof (temp), stdin);
   fclean (temp, stdin);
   nb_lettres = strtol(temp, NULL, 10);
 
   /* ces deux appels peuvent etre ignorés vu qu'ils n'interviennent pas dans le probleme */
#if 0
   saisie (nb_etats, nb_lettres);
#endif
   affichage ();
 
   do
   {
      printf ("Entrer le mot … reconnaitre : ");
      //scanf("%s",mot);
 
      fgets (mot, sizeof (mot), stdin);
      fclean (mot, stdin);
 
      if (*mot == '\0')
      {
         puts ("au revoir!");
         return 0;
      }
 
      for (i = 0; i < nb_etats; i++)
      {
         if (Initiaux[i] == 1)
         {
            if (estReconnu (mot, i) == 1)
            {
               puts ("mot est reconnu");
               break;
            }
 
         }
      }
 
   }
   while (1);
   return 0;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Nombre d'etats      :1
Nombre de lettres   :2
delta( Q(0) , a ) ={
}
delta( Q(0) , b ) ={
}
Entrer le mot à reconnaitre : azer
Entrer le mot à reconnaitre : sert
Entrer le mot à reconnaitre :
au revoir!
 
Press ENTER to continue.

[abdelhamidem]

Oh lala, je sais pas comment j'ai pu declarer saisie() sans parametre, et faire un appel avec deux parametres...

Maintenant, je vais appliquer tout ca...

EDIT: Merci beaucoup Emmanuel Delahaye, maintenant ca marche nickel.
vive fclean ...