nouveau programme à vérifier .

Version imprimable

Salut ,

j'ai déja posté l'ancienne version du programme sous l'intitulé 'programme à vérifier ,
j'ai fait les changements comme conseillé mais j'obtiens toujours erreur de segmentation :
alors voilà le nouveau code :

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "structure.h"
 
 
void Lecturefichier ( FILE *f , Module t[]);
void Ecriturefichier ( Module t[]);
 
 
 
 
int main () 
{ 
  Module exemple[LenM]; FILE *f;
  f = fopen ("donnees.csv", "r");
  if ( f == NULL ) 
    {
       printf ("erreur : le fichier ne s'ouvre pas  \n");
       return EXIT_FAILURE;
    }
  Lecturefichier (f,exemple);
  fclose (f);
  Ecriturefichier(exemple);
  return 1;
}
 
 
 
void Lecturefichier ( FILE *f , Module t[])
{
  char *pointeur;
  char *buffer;
  char ch[80];
  char *separateur = {";"};
  int i = 1;
  int valeur ; 
  int j = 1;
  t[1].Mod ="AP11";
 
  while ((fgets (ch,80,f)) != NULL )
    {
      buffer = strdup (ch);
      pointeur = strtok(buffer,separateur);
 
      if ( (strcmp (pointeur,t[i].Mod ))== 0 )
	{
	  t[i].Mod = strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Sem = strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Prom =strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Cord = strdup (pointeur);
	  pointeur = strtok (NULL , separateur);
	  t[i].act[j].Nom =strdup(pointeur) ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf(pointeur,"%d",&valeur);
	  t[i].act[j].Ng = valeur ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur ,"%d", &valeur);
	  t[i].act[j].Neg = valeur;
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur,"%d", &valeur);
	  t[i].act[j].Nhg = valeur;
	  j++;
	}
     else
	{
	  i++;
          t[i].Mod =strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Sem = strdup (pointeur) ; 
	  pointeur = strtok (NULL , separateur);
	  t[i].Prom =strdup (pointeur);
	  pointeur = strtok (NULL , separateur);
	  t[i].Cord = strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].act[j].Nom = strdup (pointeur) ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf(pointeur,"%d",&valeur);
	  t[i].act[j].Ng = valeur ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur ,"%d", &valeur);
	  t[i].act[j].Neg = valeur;
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur,"%d", &valeur);
	  t[i].act[j].Nhg = valeur;
	}
    }
}
 
 
 
 
 
void Ecriturefichier ( Module t[] )
{
  char nomfich[21];
  int i,j;
  FILE *sortie;
 
  printf ( "nom du fichier à créer : ");
  scanf ( "%20s" , nomfich);
  sortie = fopen (nomfich , "w" );
 
  for ( i=1;i<LenM;i++)
    {
      for ( j=1;j<LenA;j++)
	{
	  fputs (t[i].Mod , sortie ); fputc (';',sortie);
	  fputs (t[i].Sem , sortie ); fputc (';',sortie);
	  fputs (t[i].Prom, sortie ); fputc (';',sortie);
	  fputs (t[i].Cord, sortie ); fputc (';',sortie);
	  fputs (t[i].act[j].Nom, sortie ); fputc (';',sortie);
	   putw (t[i].act[j].Ng , sortie ); fputc (';',sortie);
	   putw (t[i].act[j].Neg, sortie ); fputc (';',sortie);
	   putw (t[i].act[j].Nhg, sortie ); fputc (';',sortie);
	}
    }
  fclose (sortie);
}

pour le module structure ,voilà le code ;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
# define LenA 4
 
# define LenM 2
 
FILE *f;
 
typedef struct { char *Nom;
                 int Ng, Neg, Nhg; } Activite ;
 
typedef struct { char *Mod, *Sem, *Prom, *Cord;
  Activite act[LenA]; } Module ; 
 
 
void Lecturefichier ( FILE *f , Module t[]);
 
void Ecrirefichier ( Module t[]);

le fichier est le suivant :

Code:

1
2
3
4
5
6
7
8
9
 
"AP11";"SEM1";"EI1";"PROTOY";"COURS";1;1;1
"AP11";"SEM1";"EI1";"PROTOY";"CGROUPE";8;1;30
"AP11";"SEM1";"EI1";"PROTOY";"TD";8;1;34
"AP11";"SEM1";"EI1";"PROTOY";"TP";8;2;65
"UX11";"SEM1";"EI1";"SILBER";"COURS";1;1;1
"UX11";"SEM1";"EI1";"SILBER";"CGROUPE";8;1;26
"UX11";"SEM1";"EI1";"SILBER";"TD";8;1;36
"UX11";"SEM1";"EI1";"SILBER";"TP";8;1;1

enfin le makefile est le suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
all	:	operationfichier
 
operationfichier	:	operationfichier.o
 
		gcc -Wall operationfichier.o -o operationfichier
 
operationfichier.o	:	operationfichier.c	structure.h
 
		gcc -Wall -c operationfichier.c
 
clean	:
		rm -f *.o operationfichier

qq pourra m'aider à identifier la faute ?
merci

Citation:

Envoyé par dnmfaw

j'ai fait les changements comme conseillé mais j'obtiens toujours erreur de segmentation :

Déjà un peu de réorganisation du code :

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
# define LenA 4
# define LenM 2
 
typedef struct
{
   char *Nom;
   int Ng, Neg, Nhg;
}
Activite;
 
typedef struct
{
   char const *Mod, *Sem, *Prom, *Cord;
   Activite act[LenA];
}
Module;
 
static void Lecturefichier (FILE * f, Module t[])
{
   char *pointeur;
   char *buffer;
   char ch[80];
   char const *separateur = { ";" };
   int i = 1;
   int valeur;
   int j = 1;
   t[1].Mod = "AP11";
 
   while ((fgets (ch, 80, f)) != NULL)
   {
      buffer = strdup (ch);
      pointeur = strtok (buffer, separateur);
 
      if ((strcmp (pointeur, t[i].Mod)) == 0)
      {
         t[i].Mod = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Sem = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Prom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Cord = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].act[j].Nom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         sscanf (pointeur, "%d", &valeur);
         t[i].act[j].Ng = valeur;
         pointeur = strtok (NULL, separateur);
         sscanf (pointeur, "%d", &valeur);
         t[i].act[j].Neg = valeur;
         pointeur = strtok (NULL, separateur);
         sscanf (pointeur, "%d", &valeur);
         t[i].act[j].Nhg = valeur;
         j++;
      }
      else
      {
         i++;
         t[i].Mod = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Sem = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Prom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Cord = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].act[j].Nom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         sscanf (pointeur, "%d", &valeur);
         t[i].act[j].Ng = valeur;
         pointeur = strtok (NULL, separateur);
         sscanf (pointeur, "%d", &valeur);
         t[i].act[j].Neg = valeur;
         pointeur = strtok (NULL, separateur);
         sscanf (pointeur, "%d", &valeur);
         t[i].act[j].Nhg = valeur;
      }
   }
}
 
static void Ecriturefichier (Module t[])
{
   char nomfich[21];
   int i, j;
   FILE *sortie;
 
   printf ("nom du fichier à créer : ");
   scanf ("%20s", nomfich);
   sortie = fopen (nomfich, "w");
 
   for (i = 1; i < LenM; i++)
   {
      for (j = 1; j < LenA; j++)
      {
         fputs (t[i].Mod, sortie);
         fputc (';', sortie);
         fputs (t[i].Sem, sortie);
         fputc (';', sortie);
         fputs (t[i].Prom, sortie);
         fputc (';', sortie);
         fputs (t[i].Cord, sortie);
         fputc (';', sortie);
         fputs (t[i].act[j].Nom, sortie);
         fputc (';', sortie);
         putw (t[i].act[j].Ng, sortie);
         fputc (';', sortie);
         putw (t[i].act[j].Neg, sortie);
         fputc (';', sortie);
         putw (t[i].act[j].Nhg, sortie);
         fputc (';', sortie);
      }
   }
   fclose (sortie);
}
 
int main (void)
{
   int ret = EXIT_SUCCESS;
   Module exemple[LenM];
   FILE *f = fopen ("donnees.csv", "r");
   if (f != NULL)
   {
      Lecturefichier (f, exemple);
      fclose (f);
      Ecriturefichier (exemple);
   }
   else
   {
      printf ("erreur : le fichier ne s'ouvre pas  \n");
      ret = EXIT_FAILURE;
   }
 
   return ret;
}

Ensuite, effectivement, ce code provoque un crash à l'exécution chez moi.

<analyse en cours ...>

Ca semble venir de la lecture... La fonction de lecture écrit dans un tableau, mais la taille du tableau est inconnue... Il n'y a pas de moyen d'éviter un dépassement. Revoir l'interface.

Je rappelle que les indices d'un tableau de taille N vont de 0 à N-1...

Il faut remettre j à 0 à chaque ligne...

Tout ce qui a été alloué par strdup() doit être libéré par free().

09/09/2007, 12h13
aoyou

Pourquoi tu n'as pas continué sur le post précédent ?

Les indices des tableaux commencent à 0 donc déjà tu écris en dehors des bornes du tableau. Revois le remplissage de ton tableau exemple.

Quand tu reviens dans le else, tu dois remettre j à 0 sinon tu vas aussi ecrire en dehors des bornes des tableaux d'activité.

Ton t[1].Mod (t[0].Mod quand tu auras corrigé) est mal initialisé. Tu dois l'initialiser à "\"AP11\"". Au passage tu devrais trouver une meilleure manière de faire. Et si la première ligne du fichier ne commence plus par "AP11".
09/09/2007, 12h26
dnmfaw

salut,

merci aoyou et Emmanuel pour votre aide , le programme a l'air de fonctionner , j'obtiens le nouveau fichier (celui crée par Ecriturefichier)
si cela te dérange pas , je vais te poser une toute dernière question :
je veux tester le prog ie voir si le nouveau fichier est identique au ficheir source comment puis je le faire ? y a-t-il une commande shell qui le permet ?

Merci
09/09/2007, 12h30
aoyou

Code:

diff file1 file2

Tu vas avoir des surprises...
09/09/2007, 12h41
dnmfaw

en exécutant diff , j'obtiens comme résulats le fichier donnees.csv affiché !!
c'est à dire quoi ? que le fichier résultant du prog ne contient rien ??? pourquoi ?
09/09/2007, 12h44
dnmfaw

j'ai fait comme conseillé (le gdb run ensuite where ) et j'obtiens ce message :

#0 0x0088b473 in strlen () from /lib/libc.so.6
#1 0x00874478 in fputs () from /lib/libc.so.6
#2 0x08048bbf in Ecriturefichier (t=0xbfbb21cc) at operationfichier.c:113
#3 0x0804865a in main () at operationfichier.c:21

qq pourra m'expliquer ce que cela veut dire ?? c'est la première fois que j'utilise gdb !
09/09/2007, 12h46
aoyou

Ah non, il doit contenir quelque chose mais pas ce que tu veux. L'as-tu regardé ?
09/09/2007, 12h50
Emmanuel Delahaye

Citation:

Envoyé par dnmfaw

merci aoyou et Emmanuel pour votre aide , le programme a l'air de fonctionner , i

Euh, non. Ce que j'ai posté est une réorganisation du code, pas une correction. Il y a encore plein d'erreurs (déjà signalées).
09/09/2007, 12h52
dnmfaw

le fichier résulat ne contient rein !!

oui je sais , j'ai corrigé le code , voilà le nouveau . Y a-t-il encore des erreurs ?

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "structure.h"
 
 
void Lecturefichier ( FILE *f , Module t[]);
void Ecriturefichier ( Module t[]);
 
 
 
int main (void)
{
   int ret = EXIT_SUCCESS;
   Module exemple[LenM];
   FILE *f = fopen ("donnees.csv", "r");
   if (f != NULL)
   {
      Lecturefichier (f, exemple);
      fclose (f);
      Ecriturefichier (exemple);
   }
   else
   {
      printf ("erreur : le fichier ne s'ouvre pas  \n");
      ret = EXIT_FAILURE;
   }
 
   return ret;
}
 
void Lecturefichier ( FILE *f , Module t[])
{
  char *pointeur;
  char *buffer;
  char ch[80];
  char *separateur = {";"};
  int i = 0;
  int valeur ; 
  int j = 0;
  t[0].Mod ="\"AP11\"";
 
  while ((fgets (ch,sizeof ch,f)) != NULL )
    {
      buffer = strdup (ch);
      pointeur = strtok(buffer,separateur);
 
      if ( (strcmp (pointeur,t[i].Mod ))== 0 )
	{
	  t[i].Mod = strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Sem = strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Prom =strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Cord = strdup (pointeur);
	  pointeur = strtok (NULL , separateur);
	  t[i].act[j].Nom =strdup(pointeur) ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf(pointeur,"%d",&valeur);
	  t[i].act[j].Ng = valeur ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur ,"%d", &valeur);
	  t[i].act[j].Neg = valeur;
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur,"%d", &valeur);
	  t[i].act[j].Nhg = valeur;
	  j++;
	}
     else
	{
	  i++;
          j=0;
          t[i].Mod =strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Sem = strdup (pointeur) ; 
	  pointeur = strtok (NULL , separateur);
	  t[i].Prom =strdup (pointeur);
	  pointeur = strtok (NULL , separateur);
	  t[i].Cord = strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].act[j].Nom = strdup (pointeur) ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf(pointeur,"%d",&valeur);
	  t[i].act[j].Ng = valeur ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur ,"%d", &valeur);
	  t[i].act[j].Neg = valeur;
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur,"%d", &valeur);
	  t[i].act[j].Nhg = valeur;
	}
    }
}
 
 
 
 
 
void Ecriturefichier ( Module t[] )
{
  char nomfich[21];
  int i,j;
  FILE *sortie;
 
  printf ( "nom du fichier à créer : ");
  scanf ( "%20s" , nomfich);
  sortie = fopen (nomfich , "w" );
 
  for ( i=0;i<LenM-1;i++)
    {
      for ( j=0;j<LenA-1;j++)
	{
	  fputs (t[i].Mod , sortie ); fputc (';',sortie);
	  fputs (t[i].Sem , sortie ); fputc (';',sortie);
	  fputs (t[i].Prom, sortie ); fputc (';',sortie);
	  fputs (t[i].Cord, sortie ); fputc (';',sortie);
	  fputs (t[i].act[j].Nom, sortie ); fputc (';',sortie);
	   putw (t[i].act[j].Ng , sortie ); fputc (';',sortie);
	   putw (t[i].act[j].Neg, sortie ); fputc (';',sortie);
	   putw (t[i].act[j].Nhg, sortie ); fputc (';',sortie);
	}
    }
}

09/09/2007, 12h57
Emmanuel Delahaye

Citation:

Envoyé par dnmfaw

le fichier résulat ne contient rein !!

Bah, oui, comme je l'ai dit, le programme n'est pas corrigé...

De toutes façons, tu vas beaucoup trop vite.

Une fois la lecture faite, tu devrais visualiser (printf) le contenu du tableau afin de vérifier que le lecture c'est bien déroulée.

(je rappelle que le fichier a 8 lignes et que le tableau en fait 2... Déjà, c'est mal parti)
09/09/2007, 13h00
aoyou

Citation:

(je rappelle que le fichier a 8 lignes et que le tableau en fait 2... Déjà, c'est mal parti)

Non ça suffit, les quatre premieres lignes correspondent à exemple[0].
Les quatre autres à exemple[1].
Il utilise un deuxième tableau de taille 4 pour stocker les élements des 4 lignes.
C'est suffisant même si ce n'est pas terrible...
09/09/2007, 13h01
dnmfaw

j'ai changé les indices du tableau , mais pour printf comment faire avec un tableau de structures ?
en fait , ça fait seulement 3 mois que je programme en C donc je sais ... je suis un peu ....
09/09/2007, 13h01
Emmanuel Delahaye

Citation:

Envoyé par dnmfaw

oui je sais , j'ai corrigé le code , voilà le nouveau .

putw() n'est pas du C standard et ne fait pas ce que tu crois. Il faut utiliser fprintf() avec "%d", par exemple.
09/09/2007, 13h04
Emmanuel Delahaye

Citation:

Envoyé par dnmfaw

j'ai changé les indices du tableau , mais pour printf comment faire avec un tableau de structures ?

Tu affiches chaque élément en utilisant le bon formateur selon le type.

Citation:

en fait , ça fait seulement 3 mois que je programme en C donc je sais ... je suis un peu ....

Alors vas moins vite, vas-y pas à pas, mets des traces (printf()) etc.

Citation:

Envoyé par aoyou

Non ça suffit, les quatre premieres lignes correspondent à exemple[0].
Les quatre autres à exemple[1].
Il utilise un deuxième tableau de taille 4 pour stocker les élements des 4 lignes.
C'est suffisant même si ce n'est pas terrible...

Euh... J'ai contrôlé les indices à coup d'assert(), ils ont pété joyeusement...

Dans l'état :

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
typedef struct
{
   char *Nom;
   int Ng, Neg, Nhg;
}
Activite;
 
typedef struct
{
   char const *Mod, *Sem, *Prom, *Cord;
   Activite act[4];
}
Module;
 
static size_t Lecturefichier (FILE * f, Module t[], size_t max)
{
   size_t n=0;
   char ch[128];
   size_t i = 0;
 
   t[i].Mod = "AP11";
 
   while ((fgets (ch, sizeof ch, f)) != NULL)
   {
      static char const *separateur = { ";" };
      char *pointeur = strtok (ch, separateur);
      size_t j = 0;
 
      assert (i < max);
 
      if ((strcmp (pointeur, t[i].Mod)) == 0)
      {
         t[i].Mod = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Sem = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Prom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Cord = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].act[j].Nom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         {
            int valeur;
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Ng = valeur;
            pointeur = strtok (NULL, separateur);
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Neg = valeur;
            pointeur = strtok (NULL, separateur);
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Nhg = valeur;
         }
      }
      else
      {
         i++;
         assert (i < max);
         t[i].Mod = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Sem = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Prom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Cord = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].act[j].Nom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         {
            int valeur;
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Ng = valeur;
            pointeur = strtok (NULL, separateur);
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Neg = valeur;
            pointeur = strtok (NULL, separateur);
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Nhg = valeur;
         }
      }
         j++;
   }
   n=i;
 
   return n;
}
 
static void Ecriturefichier (Module t[], size_t n)
{
   char nomfich[] = "donnees.txt";
   FILE *sortie = fopen (nomfich, "w");
   if (sortie != NULL)
   {
      size_t i;
      for (i = 0; i < n; i++)
      {
         printf ("i=%u\n", (unsigned) i);
         size_t j;
         for (j = 0; j < sizeof t[i].act / sizeof *t[i].act; j++)
         {
         printf (" j=%u '%s'", (unsigned) j, t[i].Sem);
            fputs (t[i].Mod, sortie);
            fputc (';', sortie);
#if 0
            fputs (t[i].Sem, sortie);
            fputc (';', sortie);
            fputs (t[i].Prom, sortie);
            fputc (';', sortie);
            fputs (t[i].Cord, sortie);
            fputc (';', sortie);
            fputs (t[i].act[j].Nom, sortie);
            fputc (';', sortie);
            fprintf (sortie, "%d", t[i].act[j].Ng);
            fputc (';', sortie);
            fprintf (sortie, "%d", t[i].act[j].Neg);
            fputc (';', sortie);
            fprintf (sortie, "%d", t[i].act[j].Nhg);
            fputc (';', sortie);
            fputc ('\n', sortie);
#endif
         }
printf ("\n");
      }
      fclose (sortie);
   }
}
 
int main (void)
{
   int ret = EXIT_SUCCESS;
   Module exemple[10];
   FILE *f = fopen ("donnees.csv", "r");
   if (f != NULL)
   {
      size_t n = Lecturefichier (f, exemple, sizeof exemple / sizeof *exemple);
      fclose (f);
      Ecriturefichier (exemple, n);
   }
   else
   {
      printf ("erreur : le fichier ne s'ouvre pas  \n");
      ret = EXIT_FAILURE;
   }
 
   return ret;
}

09/09/2007, 13h12
aoyou

Ah d'accord en fait tu as réintroduis des bugs. En fait ça marchait presque et avec quelques corrections, tu pouvais obtenir un fichier.

Code:

fgets (ch,strlen(ch),f)

ch n'est pas initialisé. strlen (ch) peut valoir n'importe quoi. Remets 80 comment c'était avant ou mets sizeof ch à la place de strlen si tu ne veux pas le retaper.
09/09/2007, 13h14
aoyou

Citation:

Euh... J'ai contrôlé les indices à coup d'assert(), ils ont pété joyeusement...

En théorie, pour son fichier, un tableau de taille 2 est suffisant. Pas de problème. Mais il faudrait que la lecture soit correcte.

Normal si tu as laissé t[0].Mod = "AP11"...
09/09/2007, 13h14
dnmfaw

voilà donc après tout les changements ( celles du putw aussi )
en exécutant gdb j'obitiens le message suivant :

#0 0x0088b473 in strlen () from /lib/libc.so.6
#1 0x00874478 in fputs () from /lib/libc.so.6
#2 0x08048bf4 in Ecriturefichier (t=0xbf9f981c) at operationfichier.c:115
#3 0x0804865a in main () at operationfichier.c:21

qq pourra me l'expliquer ?
09/09/2007, 13h23
aoyou

Citation:

qq pourra me l'expliquer ?

Au moment du segfault, tu étais à la ligne 115 de operationFichier.c. Ton problème est donc à cette ligne ou avant... La chaine que tu passes à fputs n'est pas celle à laquelle tu t'attends.

Je n'ai pas compris aussi pourquoi tu as changé ça.

Code:

for ( i=0;i<LenM-1;i++)

Enlève le -1. Pareil pour la boucle j. Prends LenM égal à 1 pour t'en convaincre : tu ne rentreras jamais dans la boucle alors qu'il faudrait faire un tour.

Curieux ton segfault, avec quelques corrections isolées, déjà citées, sur ton dernier fichier envoyé, j'obtiens bien un fichier mais pas celui que tu veux bien sûr et il n'est pas vide. Réintroduirais-tu des bugs ?
09/09/2007, 13h35
Emmanuel Delahaye

Citation:

Envoyé par aoyou

Code:

fgets (ch,strlen(ch),f)

ch n'est pas initialisé. strlen (ch) peut valoir n'importe quoi. Remets 80 comment c'était avant ou mets sizeof ch à la place de strlen si tu ne veux pas le retaper.

Ouah, la gamelle ! Oui, bien sûr. (brain fart, comme on dit. Inexcusable... je suis en train de vider la cheminée et je vais me couvrir de cendres...)

Corrigé.

merci aoyou ,

voilà le code corrigé :

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "structure.h"
 
 
void Lecturefichier ( FILE *f , Module t[]);
void Ecriturefichier ( Module t[]);
 
 
 
int main (void)
{
   int ret = EXIT_SUCCESS;
   Module exemple[LenM];
   FILE *f = fopen ("donnees.csv", "r");
   if (f != NULL)
   {
      Lecturefichier (f, exemple);
      fclose (f);
      Ecriturefichier (exemple);
   }
   else
   {
      printf ("erreur : le fichier ne s'ouvre pas  \n");
      ret = EXIT_FAILURE;
   }
 
   return ret;
}
 
void Lecturefichier ( FILE *f , Module t[])
{
  char *pointeur;
  char *buffer;
  char ch[80];
  char *separateur = {";"};
  int i = 0;
  int valeur ; 
  int j = 0;
  t[0].Mod ="\"AP11\"";
 
  while ((fgets (ch,sizeof(ch),f)) != NULL )
    {
      buffer = strdup (ch);
      pointeur = strtok(buffer,separateur);
 
      if ( (strcmp (pointeur,t[i].Mod ))== 0 )
	{
	  t[i].Mod = strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Sem = strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Prom =strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Cord = strdup (pointeur);
	  pointeur = strtok (NULL , separateur);
	  t[i].act[j].Nom =strdup(pointeur) ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf(pointeur,"%d",&valeur);
	  t[i].act[j].Ng = valeur ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur ,"%d", &valeur);
	  t[i].act[j].Neg = valeur;
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur,"%d", &valeur);
	  t[i].act[j].Nhg = valeur;
	  j++;
	}
     else
	{
	  i++;
          j=0;
          t[i].Mod =strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].Sem = strdup (pointeur) ; 
	  pointeur = strtok (NULL , separateur);
	  t[i].Prom =strdup (pointeur);
	  pointeur = strtok (NULL , separateur);
	  t[i].Cord = strdup (pointeur) ;
	  pointeur = strtok (NULL , separateur);
	  t[i].act[j].Nom = strdup (pointeur) ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf(pointeur,"%d",&valeur);
	  t[i].act[j].Ng = valeur ; 
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur ,"%d", &valeur);
	  t[i].act[j].Neg = valeur;
	  pointeur = strtok (NULL , separateur);
	  sscanf (pointeur,"%d", &valeur);
	  t[i].act[j].Nhg = valeur;
	}
    }
}
 
 
 
 
 
void Ecriturefichier ( Module t[] )
{
  char nomfich[21];
  int i,j;
  FILE *sortie;
 
  printf ( "nom du fichier à créer : ");
  scanf ( "%20s" , nomfich);
  sortie = fopen (nomfich , "w" );
 
  for ( i=0;i<LenM;i++)
    {
      for ( j=0;j<LenA;j++)
	{
	  fputs (t[i].Mod , sortie ); fputc (';',sortie);
	  fputs (t[i].Sem , sortie ); fputc (';',sortie);
	  fputs (t[i].Prom, sortie ); fputc (';',sortie);
	  fputs (t[i].Cord, sortie ); fputc (';',sortie);
	  fputs (t[i].act[j].Nom, sortie ); fputc (';',sortie);
	  fprintf (sortie, "%d",t[i].act[j].Ng); fputc (';',sortie);
	  fprintf (sortie, "%d",t[i].act[j].Neg); fputc (';',sortie);
	  fprintf (sortie, "%d",t[i].act[j].Nhg); fputc (';',sortie);
	  fprintf (sortie , "\n");
	}
    }
}

j'ai fait comme tu m'as dit , j'obtiens un fichier presque identique à celui que je voulais ; juste une petite différence :

"AP11";"SEM1";"EI1";"PROTOY";"COURS";1;1;1;
"AP11";"SEM1";"EI1";"PROTOY";"CGROUPE";8;1;30;
"AP11";"SEM1";"EI1";"PROTOY";"TD";8;1;34;
"AP11";"SEM1";"EI1";"PROTOY";"TP";8;2;65;
"UX11";"SEM1";"EI1";"SILBER";"CGROUPE";8;1;26;
"UX11";"SEM1";"EI1";"SILBER";"TD";8;1;36;
"UX11";"SEM1";"EI1";"SILBER";"TP";8;1;1;
"UX11";"SEM1";"EI1";"SILBER";ƒ ÿÿÿ‰Eðƒ ÿÿÿ)EðÁ}ð‹Uðาt+1ﾆ¶;8686821;-1080671988;-1080672136;

d'où provient cette erreur tu penses ?
merci

09/09/2007, 13h47
aoyou

En fait, il faudrait que tu fasses j++ à la fin du else pour que tu n'écrases pas les données pour j=0.
Il faudrait aussi que tu n'affiches pas de ; à la fin de la ligne. Pas très compliqué mais si tu veux exactement le même fichier...

Bon maintenant que tout est à peu près corrigé (ça doit être bon maintenant), il va te falloir faire un code un peu plus propre... et revoir ton algorithme de lecture. On dirait une chambre à air avec pleins de rustines maintenant.
09/09/2007, 13h52
dnmfaw

Merci beaucoup aoyou , ça marche maintenant ,
09/09/2007, 14h01
aoyou

Oups là, ne t'en vas pas. Si j'avais su, je ne t'aurais pas dit où était ton erreur.

Ton code n'est ni propre ni robuste. Regarde le code envoyé par Emmanuel.
09/09/2007, 14h15
dnmfaw

Citation:

Envoyé par aoyou

Ton code n'est ni propre ni robuste. Regarde le code envoyé par Emmanuel.

c'est pas grave pour le moment , le plus important c'est qu'il fonctionne correctement. j'essayerai de l'améliorer ultérieurement.

merci de ton aide
09/09/2007, 14h21
aoyou

Pas grave pas grave...
Si tu changes les données, ça ne marche plus.
Si l'ouverture du fichier de sortie échoue, ça plante.

Lis au moins le code envoyé par Emmanuel pour voir les améliorations. Tu es aussi là pour prendre des bonnes manières...
10/09/2007, 11h43
dnmfaw
salut ,

donc pour suivre le conseil de aoyou , je veux bien améliorer mon code.
mais en lisant le code d'Emmanuel , il y a des trucs que je comprenais pas ... alors si qq pourra m'expliquer ..
Code:

1 2 static size_t Lecturefichier (FILE * f, Module t[], size_t max)
déja ici , pourquoi on met static ? peut-on l'enlever ?
c'est quoi exactement size_t ?
Code:

1 2 assert (i < max);
ici c'est quoi assert ?
Code:

1 2 for (j = 0; j < sizeof t[i].act / sizeof *t[i].act; j++)
je ne comprends pas ici : sizeof[i].act / sizeof *t[i].act .. ça fait quoi ? {
Code:

1 2 #if 0
est il nécessaire de mettre #if 0 ici , y a-t-il d'autres moyens plus facile

Merci beaucoup de votre aide
10/09/2007, 11h58
Emmanuel Delahaye
Citation:
Envoyé par dnmfaw

donc pour suivre le conseil de aoyou , je veux bien améliorer mon code.
mais en lisant le code d'Emmanuel , il y a des trucs que je comprenais pas ... alors si qq pourra m'expliquer ..

Code:

1 2 static size_t Lecturefichier (FILE * f, Module t[], size_t max)

déja ici , pourquoi on met static ? peut-on l'enlever ?
http://emmanuel-delahaye.developpez....tes.htm#static

Citation:

c'est quoi exactement size_t ?

http://emmanuel-delahaye.developpez....tes.htm#size_t
Citation:
Code:

1 2 assert (i < max);

ici c'est quoi assert ?
Jamais tu ouvres ton livre de C ? Toutes les réponses à ces questions s'y trouvent...

http://emmanuel-delahaye.developpez....tes.htm#assert
Citation:
Code:

1 2 for (j = 0; j < sizeof t[i].act / sizeof *t[i].act; j++)

je ne comprends pas ici : sizeof[i].act / sizeof *t[i].act .. ça fait quoi ? {
Ca calcule le nombre d'éléments du tableau en divisant sa taille totale par la taille d'un de ses éléments.
Citation:
Code:

1 2 #if 0

est il nécessaire de mettre #if 0 ici , y a-t-il d'autres moyens plus facile
C'est une utilisation du préprocesseur (instructions #xxx) qui s'appelle la 'compilation conditionnelle'. L'intérêt est d'isoler des portions de code (à des fins de tests) de manière réversible. Pour réactiver le code, il suffit de remplacer 0 par 1.
10/09/2007, 13h22
dnmfaw

salut ,

alors j'ai essayé d'éxecuter le code qu'Emmanuel a posté ... ça donne un fichier mais qui contient uniquement la ligne suivante :
"AP11","AP11","AP11","AP11"

c normal ?
qq pourra m'aider à identifier l'erreur ??

Merci
10/09/2007, 13h42
Emmanuel Delahaye

Citation:

Envoyé par dnmfaw

qq pourra m'aider à identifier l'erreur ??

Il faudrait pour ça qu'on ait un exemple de fichier à traiter et une description précise du traitement attendu.

salut ,

alors voilà , j'ai pris le code d'Emmanuel et je l'ai changé un peu (pour des raisons perso)
voilà le code :

Code:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
typedef struct
{
   char *Nom;
   int Ng, Neg, Nhg;
}
Activite;
 
typedef struct
{
   char const *Mod, *Sem, *Prom, *Cord;
   Activite act[4];
}
Module;
 
static size_t Lecturefichier (FILE * f, Module t[], size_t max)
{
   size_t n=0;
   char *buffer;
   char *pointeur; 
   char ch[128];
   size_t i = 0;
   char  *separateur = { ";" };
   size_t j = 0;
   t[i].Mod = "\"AP11\"";
 
   while ((fgets (ch, sizeof ch, f)) != NULL)
   {
     buffer = strdup (ch);
     pointeur = strtok (buffer,separateur);
 
      assert (i < max);
 
      if ((strcmp (pointeur, t[i].Mod)) == 0)
      {
         t[i].Mod = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Sem = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Prom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Cord = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].act[j].Nom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         {
            int valeur;
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Ng = valeur;
            pointeur = strtok (NULL, separateur);
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Neg = valeur;
            pointeur = strtok (NULL, separateur);
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Nhg = valeur;
         }
	 j++;
      }
      else
      {
         i++;
	 j=0;
         assert (i < max);
         t[i].Mod = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Sem = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Prom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].Cord = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         t[i].act[j].Nom = strdup (pointeur);
         pointeur = strtok (NULL, separateur);
         {
            int valeur;
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Ng = valeur;
            pointeur = strtok (NULL, separateur);
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Neg = valeur;
            pointeur = strtok (NULL, separateur);
            sscanf (pointeur, "%d", &valeur);
            t[i].act[j].Nhg = valeur;
         }
	 j++;
      }
   }
   n=i+1;
 
   return n;
}
 
static void Ecriturefichier (Module t[], size_t n)
{
   char nomfich[] = "donnees.txt";
   FILE *sortie = fopen (nomfich, "w");
   if (sortie != NULL)
   {
      size_t i;
      for (i = 0; i < n; i++)
      {
         size_t j;
         for (j = 0; j < sizeof t[i].act / sizeof *t[i].act; j++)
         {
            fputs (t[i].Mod, sortie);
            fputc (';', sortie);
            fputs (t[i].Sem, sortie);
            fputc (';', sortie);
            fputs (t[i].Prom, sortie);
            fputc (';', sortie);
            fputs (t[i].Cord, sortie);
            fputc (';', sortie);
            fputs (t[i].act[j].Nom, sortie);
            fputc (';', sortie);
            fprintf (sortie, "%d", t[i].act[j].Ng);
            fputc (';', sortie);
            fprintf (sortie, "%d", t[i].act[j].Neg);
            fputc (';', sortie);
            fprintf (sortie, "%d", t[i].act[j].Nhg);
            fprintf (sortie, "\n");
         }
      }
      fclose (sortie);
   }
}
 
int main (void)
{
   int ret = EXIT_SUCCESS;
   Module exemple[10];
   FILE *f = fopen ("donnees1.csv", "r");
   if (f != NULL)
   {
      size_t n = Lecturefichier (f, exemple, sizeof exemple / sizeof *exemple);
      fclose (f);
      Ecriturefichier (exemple, n);
   }
   else
   {
      printf ("erreur : le fichier ne s'ouvre pas  \n");
      ret = EXIT_FAILURE;
   }
 
   return ret;}

je l'ai testé sur ce premier fichier :

Code:

1
2
3
4
5
6
7
8
9
 
"AP11";"SEM1";"EI1";"PROTOY";"COURS";1;1;1
"AP11";"SEM1";"EI1";"PROTOY";"CGROUPE";8;1;30
"AP11";"SEM1";"EI1";"PROTOY";"TD";8;1;34
"AP11";"SEM1";"EI1";"PROTOY";"TP";8;2;65
"UX11";"SEM1";"EI1";"SILBER";"COURS";1;1;1
"UX11";"SEM1";"EI1";"SILBER";"CGROUPE";8;1;26
"UX11";"SEM1";"EI1";"SILBER";"TD";8;1;36
"UX11";"SEM1";"EI1";"SILBER";"TP";8;1;1

ça bien marché , j'ai obtenu le fichier demandé

mais lorsque je le teste sur ce fichier :

Code:

1
2
3
4
5
6
7
8
9
10
 
"AP11";"S1";"EI1";"PROTOY";"COURS";1;1;1
"AP11";"S1";"EI1";"PROTOY";"CGROUPE";8;1;26
"AP11";"S1";"EI1";"PROTOY";"TD";8;1;60
"AP11";"S1";"EI1";"PROTOY";"TP";8;2;60
"UX11";"S1";"EI1";"SILBER";"COURS";1;1;1
"UX11";"S1";"EI1";"SILBER";"CGROUPE";8;1;50
"UX11";"S1";"EI1";"SILBER";"TD";8;1;20
"MA11";"S1";"EI1";"MARDIN";"COURS";15;1;60
"MA11";"S1";"EI1";"MARDIN";"TD";20;1;60

j'ai Erreur de segmentation !!

mon but de ce programme c'est de pouvoir lire un fichier donné et le réecrire dans un autre fichier
le tableau act de la structure Module peut changer de longueur selon le nom du module cad pour AP11 on a 4 act : cours , cgroupe, TD et TP par contre pour MA11 , on n'en a que deux .

Merci

10/09/2007, 15h30
aoyou

Il faut que tu sauvegardes dans ta structure Module le nombre d'activités par module. Un simple tableau de taille 4 ne suffit plus alors. Il faut que tu saches le nombre d'activités que tu as lu pour ne restituer que celles-ci. Autrement, tu tapes dans une mémoire que tu n'as jamais initialisé et segfault.
Peux-tu aussi faire le ménage dans tes topics ? Tu as ouvert des conversations, continuer dans d'autres. Du coup, on te répond sur tes anciens topics mais c'est obsolète. Marque les résolu même si ce n'est pas vraiment le cas.