Problème avec fwrite sous windows

**cerede2000** · 12/10/2008, 16h37

Pour ma fonction de récupération pour ma version avec taille de chaîne variable voici comment je fais:

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
 
typedef struct {
	char *nom;
	char *prenom;
	char *tel;
	unsigned char age;
} fiche;
 
typedef struct element {
	fiche * pfiche;
	 struct element * NextElem;
} element;
 
typedef struct {
	element * PremElem;
	element * DernElem;
} fichier;
 
void Restaure(fichier *p_fic) {
	int i, nbpv;
	element *NElem;
	fiche *f;
	char tamp[100], c;
 
	FILE *fd = fopen(FNAME, "r");
	if(fd == NULL) {
		printf("Erreur d'ouverture du fichier\n");
		return;
	}
 
	i = 0;
	nbpv = 0;
 
	while((c = fgetc(fd)) != EOF) {
		switch(c) {
			case ';':
				tamp[i] = '\0';
				nbpv++;
				switch(nbpv) {
					case 1:
						NElem = malloc(sizeof *NElem);
						if(NElem == NULL) {
							printf("Erreur d'allocation\n");
							break;
						}
						NElem->NextElem = NULL;
 
						f = malloc(sizeof *f);
						if(f == NULL) {
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
 
						f->nom = malloc((strlen(tamp)+1) * sizeof *f->nom);
						if(f->nom == NULL) {
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->nom, tamp);
					break;
 
					case 2:
						f->prenom = malloc((strlen(tamp)+1) * sizeof *f->prenom);
						if(f->nom == NULL) {
							free(f->nom);
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->prenom, tamp);
					break;
 
					case 3:
						f->tel = malloc((strlen(tamp)+1) * sizeof *f->tel);
						if(f->nom == NULL) {
							free(f->prenom);
							free(f->nom);
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->tel, tamp);
					break;
				}
				i = 0;
			break;
 
			case '\n':
				tamp[i] = '\0';
				f->age = atoi(tamp);
 
				NElem->pfiche = f;
 
				if(p_fic->PremElem == NULL) {
					p_fic->PremElem = NElem;
					p_fic->DernElem = NElem;
				} else {
					p_fic->DernElem->NextElem = NElem;
					p_fic->DernElem = NElem;
				}
 
				i = 0;
				nbpv = 0;
			break;
 
			default:
				tamp[i] = c;
				i++;
			break;
		}
	}
 
	fclose(fd);
}

Est ce optimisable?

Merci

**Emmanuel Delahaye** · 12/10/2008, 17h32

Envoyé par cerede2000

Est ce optimisable?

Il faudrait d'abord qu'il soit compilable...

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
 
 
-------------- Build: Debug in hello ---------------
 
Compiling: main.c
Linking console executable: bin\Debug\hello.exe
C:\dev\hello\main.c: In function `Restaure':
C:\dev\hello\main.c:25: error: `FILE' undeclared (first use in this function)
C:\dev\hello\main.c:25: error: (Each undeclared identifier is reported only once
C:\dev\hello\main.c:25: error: for each function it appears in.)
C:\dev\hello\main.c:25: error: `fd' undeclared (first use in this function)
C:\dev\hello\main.c:25: warning: implicit declaration of function `fopen'
C:\dev\hello\main.c:25: error: `FNAME' undeclared (first use in this function)
C:\dev\hello\main.c:26: error: `NULL' undeclared (first use in this function)
C:\dev\hello\main.c:27: warning: implicit declaration of function `printf'
C:\dev\hello\main.c:34: warning: implicit declaration of function `fgetc'
C:\dev\hello\main.c:34: error: `EOF' undeclared (first use in this function)
C:\dev\hello\main.c:41: warning: implicit declaration of function `malloc'
C:\dev\hello\main.c:50: warning: implicit declaration of function `free'
C:\dev\hello\main.c:55: warning: implicit declaration of function `strlen'
C:\dev\hello\main.c:62: warning: implicit declaration of function `strcpy'
C:\dev\hello\main.c:95: warning: implicit declaration of function `atoi'
C:\dev\hello\main.c:118: warning: implicit declaration of function `fclose'
Process terminated with status 1 (0 minutes, 0 seconds)
7 errors, 9 warnings

**cerede2000** · 12/10/2008, 17h46

Eu c'est juste une fonction...
Dans mon post il y a juste la fonction Restaure et mes structures

**Emmanuel Delahaye** · 12/10/2008, 18h00

Envoyé par cerede2000

Eu c'est juste une fonction...
Dans mon post il y a juste la fonction Restaure et mes structures

C'est bien le problème. Le code n'est pas complet. On doit deviner ce qui manque ?

**cerede2000** · 12/10/2008, 18h07

Pourquoi tant d'agressivité

Pour appeler la fonction:

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
 
#include <stdio.h>
#include <string.h>
 
#define FNAME "carnet.agd"
 
typedef struct {
	char *nom;
	char *prenom;
	char *tel;
	unsigned char age;
} fiche;
 
typedef struct element {
	fiche * pfiche;
	 struct element * NextElem;
} element;
 
typedef struct {
	element * PremElem;
	element * DernElem;
} fichier;
 
void Restaure(fichier *);
 
int main(void) {
    fichier carnet;
    Restaure(&carnet);
}
 
void Restaure(fichier *p_fic) {
	int i, nbpv;
	element *NElem;
	fiche *f;
	char tamp[100], c;
 
	FILE *fd = fopen(FNAME, "r");
	if(fd == NULL) {
		printf("Erreur d'ouverture du fichier\n");
		return;
	}
 
	i = 0;
	nbpv = 0;
 
	while((c = fgetc(fd)) != EOF) {
		switch(c) {
			case ';':
				tamp[i] = '\0';
				nbpv++;
				switch(nbpv) {
					case 1:
						NElem = malloc(sizeof *NElem);
						if(NElem == NULL) {
							printf("Erreur d'allocation\n");
							break;
						}
						NElem->NextElem = NULL;
 
						f = malloc(sizeof *f);
						if(f == NULL) {
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
 
						f->nom = malloc((strlen(tamp)+1) * sizeof *f->nom);
						if(f->nom == NULL) {
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->nom, tamp);
					break;
 
					case 2:
						f->prenom = malloc((strlen(tamp)+1) * sizeof *f->prenom);
 
						if(f->nom == NULL) {
							free(f->nom);
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->prenom, tamp);
					break;
 
					case 3:
						f->tel = malloc((strlen(tamp)+1) * sizeof *f->tel);
 
						if(f->nom == NULL) {
							free(f->prenom);
							free(f->nom);
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->tel, tamp);
					break;
				}
				i = 0;
			break;
 
			case '\n':
				tamp[i] = '\0';
				f->age = atoi(tamp);
 
				NElem->pfiche = f;
 
				if(p_fic->PremElem == NULL) {
					p_fic->PremElem = NElem;
					p_fic->DernElem = NElem;
				} else {
					p_fic->DernElem->NextElem = NElem;
					p_fic->DernElem = NElem;
				}
 
				i = 0;
				nbpv = 0;
			break;
 
			default:
				tamp[i] = c;
				i++;
			break;
		}
	}
 
	fclose(fd);
}

Le fichier carnet.agd est composé comme ceci:
chaine1;chaine2;chaine3;entier\n
chaine1;chaine2;chaine3;entier\n
...

**Emmanuel Delahaye** · 12/10/2008, 18h35

Envoyé par cerede2000

Pour appeler la fonction:

C'est encore incomplet...

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
 
 
-------------- Build: Debug in hello ---------------
 
Compiling: main.c
Linking console executable: bin\Debug\hello.exe
C:\dev\hello\main.c: In function `main':
C:\dev\hello\main.c:28: warning: control reaches end of non-void function
C:\dev\hello\main.c: In function `Restaure':
C:\dev\hello\main.c:52: warning: implicit declaration of function `malloc'
C:\dev\hello\main.c:61: warning: implicit declaration of function `free'
C:\dev\hello\main.c:108: warning: implicit declaration of function `atoi'
C:\dev\hello\main.c:32: warning: 'NElem' might be used uninitialized in this function
C:\dev\hello\main.c:33: warning: 'f' might be used uninitialized in this function
Output size is 21.43 KB
Process terminated with status 0 (0 minutes, 1 seconds)
0 errors, 6 warnings

**cerede2000** · 12/10/2008, 18h39

Eu la je ne vois pas... J'ai tester chez moi ça passe tout a fait

(Dev-CPP)

**cerede2000** · 12/10/2008, 18h45

Voila passe avec Code::Blocks:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define FNAME "carnet.agd"
 
typedef struct {
	char *nom;
	char *prenom;
	char *tel;
	unsigned char age;
} fiche;
 
typedef struct element {
	fiche * pfiche;
	 struct element * NextElem;
} element;
 
typedef struct {
	element * PremElem;
	element * DernElem;
} fichier;
 
void Restaure(fichier *);
 
int main(void) {
    fichier carnet;
    Restaure(&carnet);
 
    return 0;
}
 
void Restaure(fichier *p_fic) {
	int i, nbpv;
	element *NElem;
	fiche *f;
	char tamp[100], c;
 
	FILE *fd = fopen(FNAME, "r");
	if(fd == NULL) {
		printf("Erreur d'ouverture du fichier\n");
		return;
	}
 
	i = 0;
	nbpv = 0;
 
	while((c = fgetc(fd)) != EOF) {
		switch(c) {
			case ';':
				tamp[i] = '\0';
				nbpv++;
				switch(nbpv) {
					case 1:
						NElem = malloc(sizeof *NElem);
						if(NElem == NULL) {
							printf("Erreur d'allocation\n");
							break;
						}
						NElem->NextElem = NULL;
 
						f = (fiche*)malloc(sizeof *f);
						if(f == NULL) {
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
 
						f->nom = malloc((strlen(tamp)+1) * sizeof *f->nom);
						if(f->nom == NULL) {
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->nom, tamp);
					break;
 
					case 2:
						f->prenom = malloc((strlen(tamp)+1) * sizeof *f->prenom);
 
						if(f->nom == NULL) {
							free(f->nom);
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->prenom, tamp);
					break;
 
					case 3:
						f->tel = malloc((strlen(tamp)+1) * sizeof *f->tel);
 
						if(f->nom == NULL) {
							free(f->prenom);
							free(f->nom);
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->tel, tamp);
					break;
				}
				i = 0;
			break;
 
			case '\n':
				tamp[i] = '\0';
				f->age = atoi(tamp);
 
				NElem->pfiche = f;
 
				if(p_fic->PremElem == NULL) {
					p_fic->PremElem = NElem;
					p_fic->DernElem = NElem;
				} else {
					p_fic->DernElem->NextElem = NElem;
					p_fic->DernElem = NElem;
				}
 
				i = 0;
				nbpv = 0;
			break;
 
			default:
				tamp[i] = c;
				i++;
			break;
		}
	}
 
	fclose(fd);
}

Mais bon je ne comprends pas pourquoi Code::Blocks veut absolument que je cast les malloc...

Edit: C'est bon en faisant un projet complet au lieu de seulement un source

gl · 12/10/2008, 18h53

Envoyé par cerede2000

Mais bon je ne comprends pas pourquoi Code::Blocks veut absolument que je cast les malloc...

Déjà ce n'est pas Code::blocks qui remonte un problème mais le compilateur utilisé par celui-ci (probablement gcc dans ton cas).

Ensuite s'il remonte une erreur nécessitant de caster le retour du malloc(), c'est probablement parce que tu compiles non pas en C mais en C++.
L'extension du fichier est-elle bien .c et non .cpp ni .C ?

**cerede2000** · 12/10/2008, 18h55

Oui j'ai bien mit en .c
Enfin j'utilise plutôt Dev-CPP mais bon je voulais voir si j'avais des erreurs comme Emmanuel Delahaye avec un autre IDE.

**Emmanuel Delahaye** · 12/10/2008, 18h56

Envoyé par cerede2000

Mais bon je ne comprends pas pourquoi Code::Blocks veut absolument que je cast les malloc...

Il n'est absolument pas nécessaire de mettre des cast avec malloc()

http://emmanuel-delahaye.developpez....tes.htm#malloc

par contre il fallait ajouter <stdlib.h>

Ceci compile :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define FNAME "carnet.agd"
 
typedef struct {
	char *nom;
	char *prenom;
	char *tel;
	unsigned char age;
} fiche;
 
typedef struct element {
	fiche * pfiche;
	 struct element * NextElem;
} element;
 
typedef struct {
	element * PremElem;
	element * DernElem;
} fichier;
 
void Restaure(fichier *);
 
int main(void) {
    fichier carnet;
    Restaure(&carnet);
}
 
void Restaure(fichier *p_fic) {
	int i, nbpv;
	element *NElem;
	fiche *f;
	char tamp[100], c;
 
	FILE *fd = fopen(FNAME, "r");
	if(fd == NULL) {
		printf("Erreur d'ouverture du fichier\n");
		return;
	}
 
	i = 0;
	nbpv = 0;
 
	while((c = fgetc(fd)) != EOF) {
		switch(c) {
			case ';':
				tamp[i] = '\0';
				nbpv++;
				switch(nbpv) {
					case 1:
						NElem = malloc(sizeof *NElem);
						if(NElem == NULL) {
							printf("Erreur d'allocation\n");
							break;
						}
						NElem->NextElem = NULL;
 
						f = malloc(sizeof *f);
						if(f == NULL) {
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
 
						f->nom = (char*)malloc((strlen(tamp)+1) * sizeof *f->nom);
						if(f->nom == NULL) {
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->nom, tamp);
					break;
 
					case 2:
						f->prenom = malloc((strlen(tamp)+1) * sizeof *f->prenom);
 
						if(f->nom == NULL) {
							free(f->nom);
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->prenom, tamp);
					break;
 
					case 3:
						f->tel = malloc((strlen(tamp)+1) * sizeof *f->tel);
 
						if(f->nom == NULL) {
							free(f->prenom);
							free(f->nom);
							free(f);
							free(NElem);
							printf("Erreur d'allocation\n");
							break;
						}
						strcpy(f->tel, tamp);
					break;
				}
				i = 0;
			break;
 
			case '\n':
				tamp[i] = '\0';
				f->age = atoi(tamp);
 
				NElem->pfiche = f;
 
				if(p_fic->PremElem == NULL) {
					p_fic->PremElem = NElem;
					p_fic->DernElem = NElem;
				} else {
					p_fic->DernElem->NextElem = NElem;
					p_fic->DernElem = NElem;
				}
 
				i = 0;
				nbpv = 0;
			break;
 
			default:
				tamp[i] = c;
				i++;
			break;
		}
	}
 
	fclose(fd);
}

Mais il y a des warnings plutôt inquiétants...

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

Avant de parler d'optimisation, il faudrait déjà être sûr que le code fonctionne correctement...

ceci a l'air de fonctionner correctement.

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
 
#include "ed/inc/prt.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define FNAME "carnet.agd"
 
typedef struct
{
   char *nom;
   char *prenom;
   char *tel;
   unsigned char age;
}
fiche;
 
typedef struct element
{
   fiche *pfiche;
   struct element *NextElem;
}
element;
 
typedef struct
{
   element *PremElem;
   element *DernElem;
}
fichier;
 
static void Restaure (fichier * p_fic)
{
   int i, nbpv;
   element *NElem;
   fiche *f;
   char tamp[100], c;
 
   FILE *fd = fopen (FNAME, "r");
   if (fd == NULL)
   {
      printf ("Erreur d'ouverture du fichier\n");
      return;
   }
 
   i = 0;
   nbpv = 0;
 
   while ((c = fgetc (fd)) != EOF)
   {
      switch (c)
      {
      case ';':
         tamp[i] = '\0';
         nbpv++;
         switch (nbpv)
         {
         case 1:
            NElem = malloc (sizeof *NElem);
            if (NElem == NULL)
            {
               printf ("Erreur d'allocation\n");
               break;
            }
            NElem->NextElem = NULL;
 
            f = malloc (sizeof *f);
            if (f == NULL)
            {
               free (NElem);
               printf ("Erreur d'allocation\n");
               break;
            }
 
            f->nom = (char *) malloc ((strlen (tamp) + 1) * sizeof *f->nom);
            if (f->nom == NULL)
            {
               free (f);
               free (NElem);
               printf ("Erreur d'allocation\n");
               break;
            }
            strcpy (f->nom, tamp);
            break;
 
         case 2:
            f->prenom = malloc ((strlen (tamp) + 1) * sizeof *f->prenom);
 
            if (f->nom == NULL)
            {
               free (f->nom);
               free (f);
               free (NElem);
               printf ("Erreur d'allocation\n");
               break;
            }
            strcpy (f->prenom, tamp);
            break;
 
         case 3:
            f->tel = malloc ((strlen (tamp) + 1) * sizeof *f->tel);
 
            if (f->nom == NULL)
            {
               free (f->prenom);
               free (f->nom);
               free (f);
               free (NElem);
               printf ("Erreur d'allocation\n");
               break;
            }
            strcpy (f->tel, tamp);
            break;
         }
         i = 0;
         break;
 
      case '\n':
         tamp[i] = '\0';
         f->age = atoi (tamp);
 
         NElem->pfiche = f;
 
         if (p_fic->PremElem == NULL)
         {
            p_fic->PremElem = NElem;
            p_fic->DernElem = NElem;
         }
         else
         {
            p_fic->DernElem->NextElem = NElem;
            p_fic->DernElem = NElem;
         }
 
         i = 0;
         nbpv = 0;
         break;
 
      default:
         tamp[i] = c;
         i++;
         break;
      }
   }
 
   fclose (fd);
}
 
int main (void)
{
   fichier carnet = { NULL, NULL };
   Restaure (&carnet);
 
   /* affichage */
   {
      element const *p = carnet.PremElem;
      while (p != NULL)
      {
         fiche const *const f = p->pfiche;
         if (f != NULL)
         {
            PRT_S (f->nom);
            PRT_S (f->prenom);
            PRT_S (f->tel);
            PRT_I (f->age);
            printf ("\n");
         }
         p = p->NextElem;
      }
   }
 
   /* liberation  */
   {
      element const *p = carnet.PremElem;
      while (p != NULL)
      {
         element const *const old = p;
         p = p->NextElem;
         {
            fiche *const f = old->pfiche;
            if (f != NULL)
            {
               free (f->nom);
               free (f->prenom);
               free (f->tel);
               free (f);
            }
         }
         free (old);
      }
   }
 
   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
14
 
f->nom       = 'chaine1'
f->prenom    = 'chaine2'
f->tel       = 'chaine3'
f->age       = 1
 
f->nom       = 'chaine1'
f->prenom    = 'chaine2'
f->tel       = 'chaine3'
f->age       = 2
 
done in 0.022 s
Process returned 0 (0x0)   execution time : 0.071 s
Press any key to continue.

**cerede2000** · 12/10/2008, 19h03

Tu compile avec quoi

Moi que ce soit sous Dev-CPP ou Code::Blocks je n'ai aucun warning et le code fonctionne parfaitement.

**Emmanuel Delahaye** · 12/10/2008, 19h23

Envoyé par cerede2000

Tu compile avec quoi

Code::Blocks

Moi que ce soit sous Dev-CPP ou Code::Blocks je n'ai aucun warning et le code fonctionne parfaitement.

J'ai déjà indiqué comment faire les réglages du compilateur.

**cerede2000** · 12/10/2008, 19h32

Pourtant j'ai même compiler et tapant moi même dans la console et même en -W -Wall je n'ai pas de warning:

C:\Documents and Settings\Benjy\Bureau\Dev-CppPortable\App\devcpp\bin>gcc -c "C:\Documents and Settings\Benjy\Bureau\test.c" -W -Wall

C:\Documents and Settings\Benjy\Bureau\Dev-CppPortable\App\devcpp\bin>

Apres en rajoutant vraiment tout ce que tu propose j'obtiens ceci:

C:\Documents and Settings\Benjy\Bureau\test.c: In function `Restaure':
C:\Documents and Settings\Benjy\Bureau\test.c:35: warning: 'NElem' might be used uninitialized in this funct
C:\Documents and Settings\Benjy\Bureau\test.c:36: warning: 'f' might be used uninitialized in this function

Mais je sait que ils ne sont pas initialisé a la création mais qu'il ne sont pas utilisé sans être initialisé ensuite...

Le code est parfaitement fonctionnel.
Je voudrais juste savoir si c'est optimisable.

Merci

**Emmanuel Delahaye** · 12/10/2008, 19h33

Envoyé par cerede2000

Pourtant j'ai même compiler et tapant moi même dans la console et même en -W -Wall je n'ai pas de warning:

Ma configuration est plus complète que -W -Wall ...

**Emmanuel Delahaye** · 12/10/2008, 19h38

Envoyé par cerede2000

Le code est parfaitement fonctionnel.

Je crois que tu vas un peu vite.

c doit être de type int et non char

**cerede2000** · 12/10/2008, 19h41

Quoi? int pourquoi cela????
Selon le prototype oui il renvoi un int mais bon je lit un fichier texte, donc du caractère ASCII. Non?

**Emmanuel Delahaye** · 12/10/2008, 20h06

Envoyé par cerede2000

Quoi? int pourquoi cela????
Selon le prototype oui il renvoi un int mais bon je lit un fichier texte, donc du caractère ASCII. Non?

Peu importe ce que tu lis. L'important est de détecter correctement EOF qui est un int. Un caractère valant 255 pourrait très bien être pris pour un faux EOF.

**Emmanuel Delahaye** · 12/10/2008, 20h09

Envoyé par cerede2000

Je voudrais juste savoir si c'est optimisable

Qu'entends-tu par 'optimisable' ?

Si tu veux dire simplifiable, oui. (fgets(), strtok(), strdup(), éviter de réinventer la roue...)

**Jean-Marc.Bourguet** · 12/10/2008, 20h10

Envoyé par cerede2000

Quoi? int pourquoi cela????
Selon le prototype oui il renvoi un int mais bon je lit un fichier texte, donc du caractère ASCII. Non?

Pour faire la différence entre EOF et le caractère (unsigned char)EOF. (ÿ dans le jeu de caractère ISO-8859-1 si EOF vaut -1 -- j'ai pas encore vu une autre valeur même si c'est autorisé).

En fait il y a deux manifestations de ce bug (socker le résultat de fgetc dans un char avant de tester s'il était EOF), suivant que char soit signé ou pas. Un (unsigned char)EOF est pris pour EOF avec les implémentations ayant un char signé. Celles ayant un char non signé se retrouvent avec une boucle infinie parce que le résultat n'est jamais EOF (et donc l'erreur ne passe pas souvent le premier test sur une telle implémentation).

Problème avec fwrite sous windows

C

Discussions similaires

Partager

Partager