Discussion :

[phil23]

je suis sur windows XP et je travail avec visual studio 2005
mon probléme est que je n'arrive pas a créé le dictionnaire dans mon programme donc il me dit qu'il ne trouve pas le fichier dico.dat (normale)

Si cela peut vous aider, voici mon code

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
 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
#include<conio.h>
 
#define MAXMOTS 100
#define LONGMOT 20
 
char dico[MAXMOTS][LONGMOT];
char mot[LONGMOT];
char *pmot;
 
FILE*f;
 
//Fonction principale
int main(int argc,char*argv[])
{
	int i,res;
	extern int strcmp();
	short nb_mot=0;
	char touche;
	//declaration des fonctions
	short dichotomie(char dico[MAXMOTS][LONGMOT],char *mot,short nb_mot);
	void sup_ponc(char *pmot);
	void sup_maj(char *pmot);
	void ajout(char dico[MAXMOTS][LONGMOT],char *mot,short nb_mot);
	//ouverture du dictionnaire
	//Test que le fichier dico s'ouvre bien
	if ((f=fopen("dico.dat","r")) == NULL)
		printf("\nImpossible d'ouvrir le fichier Dico, creation d'un nouveau Dico");
	/*Puisqu'il est impossible d'ouvrir le fichier dico, la fin du programme permetra
	d'en créé un nouveau avec fopen("dico.dat","w")*/
	else 
	{
		/*remplissage du tableau dico par les mots presents dans le fichier dico*/
		while (fscanf(f,"%s",mot) !=EOF)
		{
			strcpy(dico[nb_mot],mot);
			nb_mot += 1;
		}
		/*Fermeture du fichier Dico*/
		fclose(f);
	}
		/*tri en mémoire du tableau Dico*/
		qsort((char **)dico,nb_mot,LONGMOT,strcmp);
		/*Ouverture du fichier a vérifier*/
		/*Test que le fichier s'ouvre bien*/
		if ((f=fopen("texte.dat","r")) == NULL)
			printf("\nImpossible d'ouvrir le fichier texte");
		/*Puisqu'il est impossible d'ouvrir le fichier, le if nous améne à la fin du
		programme*/
		else
		{
			pmot=mot;
			while (fscanf(f,"%s",mot) != EOF)
			{
				//appel de la fonction permettant de suprimer la ponctuation
				sup_ponc(pmot);
			/*appel de la fonction permettant de remplacer les majuscules 
			par des minuscules*/
			sup_maj(pmot);
			//Appel de la fonction dichotomie
			res=dichotomie(dico,mot,nb_mot);
			/*invite suivant le resultat de la dichotomie à rajouter le mot
			dans le dictionnaire*/
			if (res == 0)
			{
				printf("\nVoulez-vous enregistrer le mot '%s' dans le dico (o)oui ou (n)non?\n",mot);
				do
				{
					touche=getch();
				}
				while (touche!='o'&&touche!='n');
				//choix suivant le resultat de l'operateur
				if (touche=='o')
				{
					ajout(dico,mot,nb_mot);
					nb_mot+=1;
				}
			}
			}
 
					//fermeture du fichier texte
					fclose(f);
					//Ouverture du fichier dico en mode écriture
					f=fopen("dico.dat","w");
					//enregisrement dans le dico du tableau
					for (i=0;i<nb_mot;i++)
						fprintf(f,"%s\n",dico[i]);
					//Fermeture du fichier dico
					fclose(f);
			}//fin du if testant l'ouverture du fichier texte
				return 0;
}	
			//FONCTION DICHOTOMIE
			short dichotomie(char dico[MAXMOTS][LONGMOT],char *mot, short nb_mot)
			{
				//déclaration des variables
				int i=0,j=nb_mot,k,res;
				//Traitement
				while ((j-i)>1 && res!=0)
				{
					k=(i+j)/2;
					res=strcmp(dico[k],mot);
					if (res>0)
						j=k;
					else
						i=k;
					/*ce if afin d'atteindre le mot du tableau dico[0]
					puisque j-i ne peut qu'être strictement supérieur à 1*/
					if (k==0 && res!=0)
						res=strcmp(dico[0],mot);
				}
				//Affectation des valeurs retournées
				if (res!=0)
					res=0;
				else
					res=1;
				return res;
			}
 
			//FONCTION SUPPRESSION DE LA PNCTUATION
			void sup_ponc(char *pmot)
			{
				//Déclaration des variables locales
				int i=0,j=0;
				char c;
				//Traitement
				while (pmot[i]!=NULL)
				{
					c=pmot[i];
					if (isalpha(c))
					{
						pmot[j]=c;
						j++;
					}
					i++;
				}
				pmot[j]=0;
			}
 
			//FONCTION SUPPRESSION DES MAJUSCULES
			void sup_maj(char *pmot)
			{
				//Déclaration des variables locales
				int i=0;
				char c;
				//Traitement
				while (pmot[i]!=NULL)
				{
					c=pmot[i];
					if (isupper(c))
						c=tolower(c);
					pmot[i]=c;
					i++;
				}
				pmot[i]=0;
			}
 
			//FONCTION AJOUT
			void ajout(char dico[MAXMOTS][LONGMOT],char *mot,short nb_mot)
			{
				//Copie du nouveau mot dans le tableau
				strcpy(dico[nb_mot],mot);
				//Tri en mémoire du tableau dico
				qsort((char**)dico,nb_mot,LONGMOT,strcmp);
			}

merci pour votre aide

[Melem]

Fondamentalement un dictionnaire est un fichier texte qui contient une liste de mots. Chaque ligne ne doit contenir qu'un mot. Tu peux créer le dictionnaire manuellement ou à l'aide d'un programme. Un vérificateur d'orthographe est un programme qui prend tous les mots d'une phrase et vérifie si tous ces mots existent bel et bien dans le dictionnaire. Où est-ce que tu bloques.

[phil23]

bonjour, c'est ce que je croyais avoir fait dans mon programme mais apparement ça ne fonctionne pas
merci

[souviron34]

je n'ai que survolé le code, mais tu aurais de l'aide si tu INDENTAIS TON CODE CORRECTEMENT...

là c'est illisible...

De plus, juste en passant, si tu lis un fichier, tu ferais mieux de te servir de fgets, puis de sscanf une fois la ligne lue... fscanf est nettement plus difficile à utiliser...

[Emmanuel Delahaye]

je suis sur windows XP et je travail avec visual studio 2005
mon probléme est que je n'arrive pas a créé le dictionnaire dans mon programme donc il me dit qu'il ne trouve pas le fichier dico.dat (normale)
merci pour votre aide

http://delahaye.emmanuel.free.fr/dico/

[Emmanuel Delahaye]

Si cela peut vous aider, voici mon code

Un compilateur bien réglé signale beaucoup de problèmes :

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
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c: In function `main':
main.c:20: warning: function declaration isn't a prototype
main.c:46: warning: passing arg 4 of `qsort' from incompatible pointer type
main.c: At top level:
main.c:17: warning: unused parameter 'argc'
main.c:17: warning: unused parameter 'argv'
main.c: In function `dichotomie':
main.c:100: warning: 'res' might be used uninitialized in this function
main.c: In function `sup_ponc':
main.c:130: warning: comparison between pointer and integer
main.c: In function `sup_maj':
main.c:150: warning: comparison between pointer and integer
main.c: In function `ajout':
main.c:167: warning: passing arg 4 of `qsort' from incompatible pointer type
Linking console executable: console.exe
Process terminated with status 0 (0 minutes, 1 seconds)
0 errors, 8 warnings

Tu peux déjà travailler la-dessus...

De plus :

On déclare pas les fonctions dans une fonction. L'usage des prototypes séparés n'est justifié qu"en cas de compilation séparée. Dansce cas, il sont placés dans un header (.h) et inclus là où c'est nécessaire, à commencer par le fichier séparé (.c) qui contient les fonctions.

Ici, il suffit de respecter la règle de bon sens 'définir avant d'utiliser' et donc de placer le main() en dernier, comme c'est l'usage.

Enfin, si il s'agit d'une fonction standard comme strcmp(), on utilise le header prévu, à savoir ici, <string.h>. On ne redéfini jamais le prototype d'une fonction. On utilise toujours le header.

Code :

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

1
2
3
4
5
 
   //déclaration des variables
   int i = 0, j = nb_mot, k, res;
   //Traitement
   while ((j - i) > 1 && res != 0)

selon la valeur du paramètre 'nb_mot', il est possible que res soit utilisé avant d'avoir été initialisé. C'est un bug potentiel. Même si il est peu probable, le risque n'est pas nul.

Les globales sont source de problèmes et provoquent des difficultés de compréhension. Elle sont généralement inutiles (comme ici.).

Ton code corrigé selon les critères. attetion, je n'ai rien changé à la logique qui est probablement toujours défectueuse :

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
 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
 
#define MAXMOTS 100
#define LONGMOT 20
 
   /* FONCTION DICHOTOMIE */
short dichotomie (char dico[MAXMOTS][LONGMOT], char *mot, short nb_mot)
{
   /* déclaration des variables */
   int i = 0, j = nb_mot, k, res = -1;
   /* Traitement */
   while ((j - i) > 1 && res != 0)
   {
      k = (i + j) / 2;
      res = strcmp (dico[k], mot);
      if (res > 0)
         j = k;
      else
         i = k;
      /*ce if afin d'atteindre le mot du tableau dico[0]
         puisque j-i ne peut qu'être strictement supérieur à 1 */
      if (k == 0 && res != 0)
         res = strcmp (dico[0], mot);
   }
   /* Affectation des valeurs retournées */
   if (res != 0)
      res = 0;
   else
      res = 1;
   return res;
}
 
   /* FONCTION SUPPRESSION DE LA PNCTUATION */
void sup_ponc (char *pmot)
{
   /* Déclaration des variables locales */
   int i = 0, j = 0;
   char c;
   /* Traitement */
   while (pmot[i] != 0)
   {
      c = pmot[i];
      if (isalpha (c))
      {
         pmot[j] = c;
         j++;
      }
      i++;
   }
   pmot[j] = 0;
}
 
   /* FONCTION SUPPRESSION DES MAJUSCULES */
void sup_maj (char *pmot)
{
   /* Déclaration des variables locales */
   int i = 0;
   char c;
   /* Traitement */
   while (pmot[i] != 0)
   {
      c = pmot[i];
      if (isupper (c))
         c = tolower (c);
      pmot[i] = c;
      i++;
   }
   pmot[i] = 0;
}
 
int compare (void const *a, void const *b)
{
   return strcmp (a, b);
}
 
   /* FONCTION AJOUT */
void ajout (char dico[MAXMOTS][LONGMOT], char *mot, short nb_mot)
{
   /* Copie du nouveau mot dans le tableau */
   strcpy (dico[nb_mot], mot);
   /* Tri en mémoire du tableau dico */
   qsort (dico, nb_mot, LONGMOT, compare);
}
 
/* Fonction principale */
int main (void)
{
   int i, res;
   short nb_mot = 0;
   char touche;
   /* ouverture du dictionnaire */
   /* Test que le fichier dico s'ouvre bien */
   FILE *f;
 
   char dico[MAXMOTS][LONGMOT] = { {0} };
   if ((f = fopen ("dico.dat", "r")) == NULL)
      printf
         ("\nImpossible d'ouvrir le fichier Dico, creation d'un nouveau Dico");
   /*Puisqu'il est impossible d'ouvrir le fichier dico, la fin du programme permetra
      d'en créé un nouveau avec fopen("dico.dat","w") */
   else
   {
      char mot[LONGMOT];
      /*remplissage du tableau dico par les mots presents dans le fichier dico */
      while (fscanf (f, "%s", mot) != EOF)
      {
         strcpy (dico[nb_mot], mot);
         nb_mot += 1;
      }
      /*Fermeture du fichier Dico */
      fclose (f);
   }
   /*tri en mémoire du tableau Dico */
   qsort ((char **) dico, nb_mot, LONGMOT, compare);
   /*Ouverture du fichier a vérifier */
   /*Test que le fichier s'ouvre bien */
   if ((f = fopen ("texte.dat", "r")) == NULL)
      printf ("\nImpossible d'ouvrir le fichier texte");
   /*Puisqu'il est impossible d'ouvrir le fichier, le if nous améne à la fin du
      programme */
   else
   {
      char mot[LONGMOT];
      char *pmot = mot;
      while (fscanf (f, "%s", mot) != EOF)
      {
         /* appel de la fonction permettant de suprimer la ponctuation */
         sup_ponc (pmot);
         /*appel de la fonction permettant de remplacer les majuscules
            par des minuscules */
         sup_maj (pmot);
         /* Appel de la fonction dichotomie */
         res = dichotomie (dico, mot, nb_mot);
         /*invite suivant le resultat de la dichotomie à rajouter le mot
            dans le dictionnaire */
         if (res == 0)
         {
            printf
               ("\nVoulez-vous enregistrer le mot '%s' dans le dico (o)oui ou (n)non?\n",
                mot);
            do
            {
               touche = getchar ();
               getchar ();
            }
            while (touche != 'o' && touche != 'n');
            /* choix suivant le resultat de l'operateur */
            if (touche == 'o')
            {
               ajout (dico, mot, nb_mot);
               nb_mot += 1;
            }
         }
      }
 
      /* fermeture du fichier texte */
      fclose (f);
      /* Ouverture du fichier dico en mode écriture */
      f = fopen ("dico.dat", "w");
      /* enregisrement dans le dico du tableau */
      for (i = 0; i < nb_mot; i++)
         fprintf (f, "%s\n", dico[i]);
      /* Fermeture du fichier dico */
      fclose (f);
   }
   /* fin du if testant l'ouverture du fichier texte */
   return 0;
}

Autre principes de Bonne Programmation :
- Toujours utiliser les {} dans les structures de code
- Réduire la portée des variables au strict minimum.
- Utiliser les bons types (char et short sont inutiles ici)
- Utiliser les bonnes fonctions (ponctuation ; ispuct(), c'est fait pour).

Voici ton code modifié selon ce principe :

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
 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
 
#define MAXMOTS 100
#define LONGMOT 20
 
   /* FONCTION DICHOTOMIE */
int dichotomie (char dico[][LONGMOT], char *mot, size_t nb_mot)
{
   /* déclaration des variables */
   int res = -1;
   int i = 0;
   int j = nb_mot; 
   /* Traitement */
   while ((j - i) > 1 && res != 0)
   {
      int k = (i + j) / 2;
      res = strcmp (dico[k], mot);
      if (res > 0)
      {
         j = k;
      }
      else
      {
         i = k;
      }
      /*ce if afin d'atteindre le mot du tableau dico[0]
         puisque j-i ne peut qu'être strictement supérieur à 1 */
      if (k == 0 && res != 0)
      {
         res = strcmp (dico[0], mot);
      }
   }
   /* Affectation des valeurs retournées */
   if (res != 0)
   {
      res = 0;
   }
   else
   {
      res = 1;
   }
   return res;
}
 
   /* FONCTION SUPPRESSION DE LA PONCTUATION */
void sup_ponc (char *pmot)
{
   /* Déclaration des variables locales */
   int i = 0, j = 0;
   /* Traitement */
   while (pmot[i] != 0)
   {
      int c = pmot[i];
      if (!ispunct (c))
      {
         pmot[j] = c;
         j++;
      }
      i++;
   }
   pmot[j] = 0;
}
 
   /* FONCTION SUPPRESSION DES MAJUSCULES */
void sup_maj (char *pmot)
{
   /* Déclaration des variables locales */
   int i = 0;
   /* Traitement */
   while (pmot[i] != 0)
   {
      int c = pmot[i];
      if (isupper (c))
      {
         c = tolower (c);
      }
      pmot[i] = c;
      i++;
   }
   pmot[i] = 0;
}
 
int compare (void const *a, void const *b)
{
   return strcmp (a, b);
}
 
   /* FONCTION AJOUT */
void ajout (char dico[][LONGMOT], char *mot, size_t nb_mot)
{
   /* Copie du nouveau mot dans le tableau */
   strcpy (dico[nb_mot], mot);
   /* Tri en mémoire du tableau dico */
   qsort (dico, nb_mot, LONGMOT, compare);
}
 
/* Fonction principale */
int main (void)
{
   char dico[MAXMOTS][LONGMOT] = { {0} };
   size_t nb_mot = 0;
   /* ouverture du dictionnaire */
   /* Test que le fichier dico s'ouvre bien */
   {
      FILE *f = fopen ("dico.dat", "r");
 
      if (f == NULL)
         printf
            ("\nImpossible d'ouvrir le fichier Dico, creation d'un nouveau Dico");
      /*Puisqu'il est impossible d'ouvrir le fichier dico, la fin du programme permetra
         d'en créé un nouveau avec fopen("dico.dat","w") */
      else
      {
         char mot[LONGMOT];
         /*remplissage du tableau dico par les mots presents dans le fichier dico */
         while (fscanf (f, "%s", mot) != EOF)
         {
            strcpy (dico[nb_mot], mot);
            nb_mot += 1;
         }
         /*Fermeture du fichier Dico */
         fclose (f);
      }
   }
   /*tri en mémoire du tableau Dico */
   qsort (dico, nb_mot, LONGMOT, compare);
   /*Ouverture du fichier a vérifier */
   /*Test que le fichier s'ouvre bien */
   {
      FILE *f = fopen ("texte.dat", "r");
      if ((f) == NULL)
         printf ("\nImpossible d'ouvrir le fichier texte");
      /*Puisqu'il est impossible d'ouvrir le fichier, le if nous améne à la fin du
         programme */
      else
      {
         char mot[LONGMOT];
         char *pmot = mot;
         while (fscanf (f, "%s", mot) != EOF)
         {
            /* appel de la fonction permettant de suprimer la ponctuation */
            sup_ponc (pmot);
            /*appel de la fonction permettant de remplacer les majuscules
               par des minuscules */
            sup_maj (pmot);
            /* Appel de la fonction dichotomie */
            {
               int res = dichotomie (dico, mot, nb_mot);
               /*invite suivant le resultat de la dichotomie à rajouter le mot
                  dans le dictionnaire */
               if (res == 0)
               {
                  printf
                     ("\nVoulez-vous enregistrer le mot '%s' dans le dico (o)oui ou (n)non?\n",
                      mot);
                  {
                     int touche;
 
                     do
                     {
                        touche = getchar ();
                        getchar ();
                     }
                     while (touche != 'o' && touche != 'n');
                     if (touche == 'o')
                     {
                        ajout (dico, mot, nb_mot);
                        nb_mot += 1;
                     }
                  }             /* choix suivant le resultat de l'operateur */
               }
            }
         }
         /* fermeture du fichier texte */
         fclose (f);
      }
 
      {
         /* Ouverture du fichier dico en mode écriture */
         FILE *f = fopen ("dico.dat", "w");
         /* enregisrement dans le dico du tableau */
         {
            size_t i;
            for (i = 0; i < nb_mot; i++)
            {
               fprintf (f, "%s\n", dico[i]);
            }
         }                      /* Fermeture du fichier dico */
         fclose (f);
      }
   }
   /* fin du if testant l'ouverture du fichier texte */
   return 0;
}

L'effet sur la fonction main() est saisissant. D'une part, elle s'est allongée, ce qui montre qu'il va falloir travailler dessus pour la découper en fonctions, d'autre part, grâce à la réduction de la portée, le découpage apparait précisément en 'filigrane'.

Après action de découpage, on obtient :

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
 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
 
#define MAXMOTS 100
#define LONGMOT 20
 
   /* FONCTION DICHOTOMIE */
int dichotomie (char dico[][LONGMOT], char *mot, size_t nb_mot)
{
   /* déclaration des variables */
   int res = -1;
   int i = 0;
   int j = nb_mot;
   /* Traitement */
   while ((j - i) > 1 && res != 0)
   {
      int k = (i + j) / 2;
      res = strcmp (dico[k], mot);
      if (res > 0)
      {
         j = k;
      }
      else
      {
         i = k;
      }
      /*ce if afin d'atteindre le mot du tableau dico[0]
         puisque j-i ne peut qu'être strictement supérieur à 1 */
      if (k == 0 && res != 0)
      {
         res = strcmp (dico[0], mot);
      }
   }
   /* Affectation des valeurs retournées */
   if (res != 0)
   {
      res = 0;
   }
   else
   {
      res = 1;
   }
   return res;
}
 
   /* FONCTION SUPPRESSION DE LA PONCTUATION */
void sup_ponc (char *pmot)
{
   /* Déclaration des variables locales */
   int i = 0, j = 0;
   /* Traitement */
   while (pmot[i] != 0)
   {
      int c = pmot[i];
      if (!ispunct (c))
      {
         pmot[j] = c;
         j++;
      }
      i++;
   }
   pmot[j] = 0;
}
 
   /* FONCTION SUPPRESSION DES MAJUSCULES */
void sup_maj (char *pmot)
{
   /* Déclaration des variables locales */
   int i = 0;
   /* Traitement */
   while (pmot[i] != 0)
   {
      int c = pmot[i];
      if (isupper (c))
      {
         c = tolower (c);
      }
      pmot[i] = c;
      i++;
   }
   pmot[i] = 0;
}
 
int compare (void const *a, void const *b)
{
   return strcmp (a, b);
}
 
   /* FONCTION AJOUT */
void ajout (char dico[][LONGMOT], char *mot, size_t nb_mot)
{
   /* Copie du nouveau mot dans le tableau */
   strcpy (dico[nb_mot], mot);
   /* Tri en mémoire du tableau dico */
   qsort (dico, nb_mot, LONGMOT, compare);
}
 
void enregistrer_dico (char const *fname, char dico[][LONGMOT], size_t nb_mot)
{
   /* Ouverture du fichier dico en mode écriture */
   FILE *f = fopen (fname, "w");
   /* enregisrement dans le dico du tableau */
   {
      size_t i;
      for (i = 0; i < nb_mot; i++)
      {
         fprintf (f, "%s\n", dico[i]);
      }
   }                            /* Fermeture du fichier dico */
   fclose (f);
}
 
   /* ouverture du dictionnaire */
size_t lire_mots_dico (char const *fname, char dico[][LONGMOT])
{
   size_t nb_mot = 0;
   FILE *f = fopen (fname, "r");
 
   /* Test que le fichier dico s'ouvre bien */
   if (f == NULL)
   {
      printf ("Impossible d'ouvrir le fichier '%s'\n"
              "Creation d'un nouveau Dico\n", fname);
   }
   /*Puisqu'il est impossible d'ouvrir le fichier dico, la fin du programme permetra
      d'en créé un nouveau avec fopen("dico.dat","w") */
   else
   {
      char mot[LONGMOT];
      /*remplissage du tableau dico par les mots presents dans le fichier dico */
      while (fscanf (f, "%s", mot) != EOF)
      {
         strcpy (dico[nb_mot], mot);
         nb_mot += 1;
      }
      /*Fermeture du fichier Dico */
      fclose (f);
   }
   return nb_mot;
}
 
void importer_texte (char dico[][LONGMOT], size_t nb_mot)
{
   /* Test que le fichier s'ouvre bien */
   FILE *f = fopen ("texte.dat", "r");
   if ((f) == NULL)
      printf ("\nImpossible d'ouvrir le fichier texte");
   /*Puisqu'il est impossible d'ouvrir le fichier, le if nous améne à la fin du
      programme */
   else
   {
      char mot[LONGMOT];
      while (fscanf (f, "%s", mot) != EOF)
      {
         /* appel de la fonction permettant de suprimer la ponctuation */
         sup_ponc (mot);
         /*appel de la fonction permettant de remplacer les majuscules
            par des minuscules */
         sup_maj (mot);
         /* Appel de la fonction dichotomie */
         {
            int res = dichotomie (dico, mot, nb_mot);
            /*invite suivant le resultat de la dichotomie à rajouter le mot
               dans le dictionnaire */
            if (res == 0)
            {
               printf
                  ("\nVoulez-vous enregistrer le mot '%s' dans le dico (o)oui ou (n)non?\n",
                   mot);
               {
                  int touche;
 
                  do
                  {
                     touche = getchar ();
                     getchar ();
                  }
                  while (touche != 'o' && touche != 'n');
                  if (touche == 'o')
                  {
                     ajout (dico, mot, nb_mot);
                     nb_mot += 1;
                  }
               }                /* choix suivant le resultat de l'operateur */
            }
         }
      }
      /* fermeture du fichier texte */
      fclose (f);
   }
}
 
/* Fonction principale */
int main (void)
{
   static const char *fname = "dico.dat";
 
   char dico[MAXMOTS][LONGMOT] = { {0} };
   size_t nb_mot = 0;
 
   nb_mot = lire_mots_dico (fname, dico);
 
   /* tri en mémoire du tableau Dico */
   qsort (dico, nb_mot, LONGMOT, compare);
 
   importer_texte (dico, nb_mot);
 
   enregistrer_dico (fname, dico, nb_mot);
   /* fin du if testant l'ouverture du fichier texte */
   return 0;
}

Ce qui commence à ressembler à quelque chose de lisible !

Maintenant, on voit que les fonctions sont appelées les unes à la suite des autres, sans aucune vérification. Est-ce bien raisonnable ? Si le fichier existe, il est écrasé ? Un peu de reflexion s'impose...

D'autre part, il me semble que la fonction d'importation ne vérifie pas si le nombre de mots ajoutés ne dépasse pas la taille du dictionnaire.

Bref, il y a un risque de débordement... Mais maintenant que le code est organisé de façon lisible et modulaire, la mise au point devrait être facilitée...

Je te laisse terminer sur ces bonnes bases.

[phil23]

merci beaucoup pour votre aide je vais travailler dessus
encore merci