Discussion :

[isoman]

Slt je viens d’ecrire une fonction qui charge le contenu d’un fichier dans une liste avec chainage simple . La compil est normale sans aucun warning mais lors de l’execution ça coince . Je m’explique :

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
 
typedef struct information_composant             //c pour l'arbre des procedures
{
	int code_composant;
	float qte;
	int code_section_usinage;
	int temps_integration_composant ;
}information_composant;
 
typedef struct liste_composant			//ça aussi
{
	information_composant info_composant;
	liste_composant* svt;
}liste_composant;
 
// fct qui ajoute la struct composant dans la liste chainée
void ajouter_fin_liste_composant(liste_composant** l_c,information_composant c)
{
	liste_composant* temp=*l_c;
 
	if (temp==NULL)
	{
		(*l_c)=(liste_composant*)malloc(sizeof(liste_composant*));
		(*l_c)->info_composant=c;
		(*l_c)->svt=NULL;
	}
	else
	{
		while(temp->svt!=NULL)
 
		{temp=temp->svt;}
 
		temp->svt=(liste_composant*)malloc(sizeof(liste_composant*));
		temp->svt->info_composant=c;
		temp->svt->svt=NULL;
	}
}
//fct qui chagre le contenu du fichier
noeud_compose* charger_fichier_procede(FILE* fichier_procede)
{
	noeud_compose* procede=NULL;
	int x,code_compose,entre=vrai;
	liste_composant *l_c=NULL;
	information_composant composant;
	char test[5],valeur[35];
	assert(fichier_procede!=NULL);
	do//tant que x=!EOF le scan du fichier continue
 
	{
	    x=fscanf(fichier_procede,"%s %s",&test,&valeur); // le probleme se    
               //situe ici lorsque le prog passe de cette instruction au if
               //composant.code_composant change de valeur et prend 0 !!!
		if (strcmp(test,"code")==0 && strcmp(valeur,"compose")==0)
		{
			x=fscanf(fichier_procede,"%s",&valeur);
			code_compose=atoi(valeur);// conversion en valeur                  
                                                            //numerique
 
		}
 
		else
		{
			do // lecture des caracteristiques des composant tant qu'on      
                            //n'a pas atteint la fin du fichier
			{
				entre=faux;
 
				if (strcmp(test,"code")==0 &&  
                                  strcmp(valeur,"composant")==0)
				{
					x=fscanf(fichier_procede,"%s",&valeur);
					composant.code_composant=atoi(valeur);
 
					entre=vrai;
 
				strcpy(test," ");// re-initialisation de test && valeur 
				strcpy(valeur," ");
				}
				if (strcmp(test,"quantite")==0)
				{
					composant.qte=(float)atof(valeur);
 
 
 
				entre=vrai;
				strcpy(test," ");
				strcpy(valeur," ");
				}
				if (strcmp(test,"code")==0 &&       
                                   strcmp(valeur,"section")==0)
				{
					x=fscanf(fichier_procede,"%s %s                                       
                                          %s",&valeur,&valeur,&valeur);
					composant.code_section_usinage=atoi(valeur);
 
 
					entre=vrai;
 
					strcpy(test," ");
					strcpy(valeur," ");
				}
				if ( strcmp(test,"temps")==0)
				{
					x=fscanf(fichier_procede,"%s 
                                                     %s",&valeur,&valeur);
 
                              composant.temps_integration_composant=atoi(valeur);
					entre=vrai;
					ajouter_fin_liste_composant(&l_c,composant);
                                                              // ajout des caracteristiques   // dans la liste
					strcpy(test," ");					
					strcpy(valeur," ");										 
				}
 
			}
			while (entre==vrai);
		}
 
 
 
	}	while(x!=EOF);
 
	return (procede);// ici procede==NULL prcq je n'ai pas encore ecrit la //fct qui ajoute la liste dans l'arbre des procedes .
}

Lrsq j’execute ma fonction code.code_composant change de valeur et prend 0.
Je travaille avec visual 6 et lorsque j’ai essayé le meme code sous code ::blocks et ça a marché !!!!
Svp est ce que qlqn sait comment on peut resoudre ce probleme ?
merci

[fearyourself]

La compil est normale sans aucun warning mais lors de l’execution ça coince .

Ah bon ?

warn.c:13: error: expected specifier-qualifier-list before 'liste_composant'
warn.c: In function 'ajouter_fin_liste_composant':
warn.c:21: error: 'NULL' undeclared (first use in this function)
warn.c:21: error: (Each undeclared identifier is reported only once
warn.c:21: error: for each function it appears in.)
warn.c:23: warning: incompatible implicit declaration of built-in function 'malloc'
warn.c:25: error: 'liste_composant' has no member named 'svt'
warn.c:29: error: 'liste_composant' has no member named 'svt'
warn.c:31: error: 'liste_composant' has no member named 'svt'
warn.c:33: error: 'liste_composant' has no member named 'svt'
warn.c:33: warning: incompatible implicit declaration of built-in function 'malloc'
warn.c:34: error: 'liste_composant' has no member named 'svt'
warn.c:35: error: 'liste_composant' has no member named 'svt'
warn.c: At top level:
warn.c:40: error: expected '=', ',', ';', 'asm' or '__attribute__' before '*' token
warn.c:93: error: missing terminating " character
warn.c:94: error: missing terminating " character
warn.c:105: error: missing terminating " character
warn.c:106: error: missing terminating " character
beyler@perceval:~/tmp$ gcc warn.c -Wall -Wextra -O3
warn.c:13: error: expected specifier-qualifier-list before 'liste_composant'
warn.c: In function 'ajouter_fin_liste_composant':
warn.c:21: error: 'NULL' undeclared (first use in this function)
warn.c:21: error: (Each undeclared identifier is reported only once
warn.c:21: error: for each function it appears in.)
warn.c:23: warning: implicit declaration of function 'malloc'
warn.c:23: warning: incompatible implicit declaration of built-in function 'malloc'
warn.c:25: error: 'liste_composant' has no member named 'svt'
warn.c:29: error: 'liste_composant' has no member named 'svt'
warn.c:31: error: 'liste_composant' has no member named 'svt'
warn.c:33: error: 'liste_composant' has no member named 'svt'
warn.c:33: warning: incompatible implicit declaration of built-in function 'malloc'
warn.c:34: error: 'liste_composant' has no member named 'svt'
warn.c:35: error: 'liste_composant' has no member named 'svt'
warn.c: At top level:
warn.c:40: error: expected '=', ',', ';', 'asm' or '__attribute__' before '*' token
warn.c:93: error: missing terminating " character
warn.c:94: error: missing terminating " character
warn.c:105: error: missing terminating " character
warn.c:106: error: missing terminating " character

Jc

[isoman]

dsl j'ai oublié de copier qlq ligne du 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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <assert.h>
#define vrai 1
#define faux 0
 
#define chemin_fichier_section "D:\\fichier_section.txt"
#define chemin_fichier_procede "D:\\fichier_procede.txt"
#define chemin_fichier_article "D:\\fichier_article.txt"
#define chemin_fichier_machine "D:\\fichier_machine.txt"
 
typedef struct information_composant             //c pour l'arbre des procedures
{
	int code_composant;
	float qte;
	int code_section_usinage;
	int temps_integration_composant ;
}information_composant;
 
 
 
typedef struct liste_composant			//ça aussi
{
	information_composant info_composant;
	liste_composant* svt;
}liste_composant;
 
 
 
 typedef struct noeud_compose // noeud de l'arbre des procedures
{
	int code_compose;
	liste_composant* les_composants;
	struct noeud_compose* fg;
	struct noeud_compose* fd;
 
 
}noeud_compose;
typedef noeud_compose* procede;
// fct qui ajoute la struct composant dans la liste chainée
void ajouter_fin_liste_composant(liste_composant** l_c,information_composant c)
{
	liste_composant* temp=*l_c;
 
	if (temp==NULL)
	{
		(*l_c)=(liste_composant*)malloc(sizeof(liste_composant*));
		(*l_c)->info_composant=c;
		(*l_c)->svt=NULL;
	}
	else
	{
		while(temp->svt!=NULL)
 
		{temp=temp->svt;}
 
		temp->svt=(liste_composant*)malloc(sizeof(liste_composant*));
		temp->svt->info_composant=c;
		temp->svt->svt=NULL;
	}
}
//fct qui chagre le contenu du fichier
noeud_compose* charger_fichier_procede(FILE* fichier_procede)
{
	noeud_compose* procede=NULL;
	int x,code_compose,entre=vrai;
	liste_composant *l_c=NULL;
	information_composant composant;
	char test[5],valeur[35];
	assert(fichier_procede!=NULL);
	do//tant que x=!EOF le scan du fichier continue
 
	{
	    x=fscanf(fichier_procede,"%s %s",&test,&valeur); // le probleme se    
               //situe ici lorsque le prog passe de cette instruction au if
               //composant.code_composant change de valeur et prend 0 !!!
		if (strcmp(test,"code")==0 && strcmp(valeur,"compose")==0)
		{
			x=fscanf(fichier_procede,"%s",&valeur);
			code_compose=atoi(valeur);// conversion en valeur                  
                                                            //numerique
 
		}
 
		else
		{
			do // lecture des caracteristiques des composant tant qu'on      
                            //n'a pas atteint la fin du fichier
			{
				entre=faux;
 
				if (strcmp(test,"code")==0 &&  
                                  strcmp(valeur,"composant")==0)
				{
					x=fscanf(fichier_procede,"%s",&valeur);
					composant.code_composant=atoi(valeur);
 
					entre=vrai;
 
				strcpy(test," ");// re-initialisation de test && valeur 
				strcpy(valeur," ");
				}
				if (strcmp(test,"quantite")==0)
				{
					composant.qte=(float)atof(valeur);
 
 
 
				entre=vrai;
				strcpy(test," ");
				strcpy(valeur," ");
				}
				if (strcmp(test,"code")==0 &&  strcmp(valeur,"section")==0)
				{
					x=fscanf(fichier_procede,"%s %s  %s",&valeur,&valeur,&valeur);
					composant.code_section_usinage=atoi(valeur);
 
 
					entre=vrai;
 
					strcpy(test," ");
					strcpy(valeur," ");
				}
				if ( strcmp(test,"temps")==0)
				{
					x=fscanf(fichier_procede,"%s%s",&valeur,&valeur);
 
                    composant.temps_integration_composant=atoi(valeur);
					entre=vrai;
					ajouter_fin_liste_composant(&l_c,composant);
                                                              // ajout des caracteristiques   // dans la liste
					strcpy(test," ");					
					strcpy(valeur," ");										 
				}
 
			}
			while (entre==vrai);
		}
 
 
 
	}	while(x!=EOF);
 
	return (procede);// ici procede==NULL prcq je n'ai pas encore ecrit la //fct qui ajoute la liste dans l'arbre des procedes .
}

ps:je compile en .cpp prcq comme je l'ai dit l'autre fois mon prof insiste sur ce point

[Thierry Chappuis]

ps:je compile en .cpp prcq comme je l'ai dit l'autre fois mon prof insiste sur ce point

C'est étrange comme approche... Thierry

[Trap D]

S'il veut que ce soit en .cpp, c'est qu'il veut du C++ et donc tu vas de faire saquer sur les malloc et autres !
Utilise les new (entre autres) et change de forum !

[Ulmo]

Il m'a fallu changer cetrte déclaration :

Code :

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

1
2
3
4
5
typedef struct liste_composant			//ça aussi
{
	information_composant info_composant;
	struct liste_composant* svt;
}liste_composant;

pour pouvoir compiler.

Ensuite les warnings (car j'en ai, moi...) me pointent les lignes suivantes :

Code :

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

1
2
3
4
5
6
x=fscanf(fichier_procede,"%s %s",&test,&valeur);
x=fscanf(fichier_procede,"%s",&valeur);
x=fscanf(fichier_procede,"%s",&valeur);
x=fscanf(fichier_procede,"%s",&valeur);
x=fscanf(fichier_procede,"%s %s  %s",&valeur,&valeur,&valeur);
x=fscanf(fichier_procede,"%s%s",&valeur,&valeur);

En effet, "valeur" et "test" sont des tableaux. Il ne faut donc pas en prendre l'adresse mais les passer directement (ils sont implicitement traduits en pointeurs).

Par ailleurs l'utilisation du scanf("%s", ...) est très fortement déconseillé.

[isoman]

Trap D:

non c du C pas du C++

Ulmo:

je compile en .cpp et ce n'est pas un scanf c'est un fscanf

sinon est ce quelqu'un a une idée pour mon probleme ?
merci

[Trap D]

non c du C pas du C++

Ton prof veut que tu compiles le C avec un compilo C++ ???

[Ulmo]

scanf et fscanf c'est kifkif. Tu auras des ennuis si ton fichier n'a pas le format attendu.
Et je ne pense pas qu'en C++ les scanf(..., &value) soient valables non plus. Essaye voir sans les "&".

Maintenant il faut te décider entre C et C++. Par exemple en C++ on a des flux plutôt que des fichiers. Et on utilise <cstdio> au lieu de <stdio.h>. Et on ne fait pas de "typedef class machin machin". On utilise les listes de la STL au lieu de les refaire.

[isoman]

le fichier c moi qui le cree donc je ne pense pas que j'aurais des surprises de ce coté la, je compile en cpp prsq dans l'ecole le prof n'accepte pas un malloc "normal" pour une raison qui m'echappe il veut le cast avec.

Code :

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

int t* p=(int*)malloc(sizeof(*p));

Sinon est ce que vous avez une p'tite idée de la cause du bug ?

[souviron34]

le fichier c moi qui le cree donc je ne pense pas que j'aurais des surprises de ce coté la, je compile en cpp prsq dans l'ecole le prof n'accepte pas un malloc "normal" pour une raison qui m'echappe il veut le cast avec.

Code :

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

int t* p=(int*)malloc(sizeof(*p));

Sinon est ce que vous avez une p'tite idée de la cause du bug ?

rien à voir avec cpp......

[Trap D]

C'est pas que le prof veut le cast c'est qu'il est obligatoire en C++ et pas en C !

Je travaille avec visual 6 et lorsque j’ai essayé le meme code sous code ::blocks et ça a marché !!!!
Svp est ce que qlqn sait comment on peut resoudre ce probleme ?

Ce genre de problème est souvent le signe d'une mauvaise initialisation (ou d'une absence de d'initialisation) d'un pointeur.

[Ulmo]

Essaye voir sans les "&".

[isoman]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int main()
{
 
char c[5] ;
 
scanf("%s",&c);
puts(c);
scanf("%s",c);
puts(c);
 	return 0;
}

ulmo>ça marche
trap d > yep je me suis mal exprimé dsl c'est vrai qu'il est obligatoire .sinon est ce que tu remarque un truc qui cloche dans mon code ? Je ne vois pas de pointeur mal initialisé , et meme si c le cas pourqoi ça fonctionne sous code::blocks ?

[Thierry Chappuis]

En plus de l'utilisation désastreuse de fscanf(), et le cast de malloc (OK, tu compile en C++), ce genre d'allocation, ça me choque:

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
typedef struct information_composant {
    int code_composant;
    float qte;
    int code_section_usinage;
    int temps_integration_composant ;
}
information_composant;
 
 
typedef struct liste_composan {
    information_composant info_composant;
    struct liste_composant* svt;
}
liste_composant;
 
/* ... */
 
 
        liste_composant* temp = *l_c;
 
        if (temp == NULL) { 
            (*l_c)= (liste_composant*) malloc(sizeof(liste_composant*));

Ici, tu alloue la taille d'un pointeur (4 bytes sur ma machine). Voici la bonne manière d'écrire ta fonction ajouter_fin_liste_component():

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
int ajouter_fin_liste_composant(liste_composant **pp_liste, information_composant *pc) {
    int err = 0;
    if (pp_liste != NULL && pc != NULL) {
        liste_composant *p_tmp = *pp_liste;
        liste_composant *p_new = NULL;
 
        p_new = malloc(sizeof *p_new);
        if (p_tmp != NULL) {
            p_tmp->info_conposant = *pc;
            p_tmp->svt = NULL;
 
            if (p_tmp == NULL) {
 
            } else {
                while (p_tmp->svt != NULL) {
                    p_tmp = p_tmp->svt;
                }
                p_tmp->svt = p_new;
            }
        }
        else {
            /* L'Allocation a échoué */
            err = 1;
        }
    }
    else {
        /* Erreur: La fonction ne peut recevoir NULL en argument*/
        err = 2;
    }
    return err;
}

Thierry

[isoman]

euh dsl je ne vois en quoi ta fonction est meilleure ?

[Thierry Chappuis]

euh dsl je ne vois en quoi ta fonction est meilleure ?

L'allocation de mémoire y est faite correctement!

Code :

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

(*l_c)= (liste_composant*) malloc(sizeof(liste_composant*)); /* PAS correct*/

Ici, tu n'alloues que sizeof(liste_composant *), à savoir 4 bytes sur ma machine, alors que tu dois allouer sizeof(liste_composant). Donc, une version correcte est, si l_c est de type liste_composant **:

Code :

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

*l_c = malloc(sizeof **l_c);

Une autre raison pour laquelle ma fonction est meilleure, c'est que je vérifie la valeur de retour de malloc(), comme tu devrais toujours le faire. En plus, tu passes une structure en argument par copie. C'est pas très efficace. En général, on préfère passer par un pointeur.

Thierry

[isoman]

ah ok ,sinon pour le bug y a pas de solution ?

[Trap D]

trap d > yep je me suis mal exprimé dsl c'est vrai qu'il est obligatoire .sinon est ce que tu remarque un truc qui cloche dans mon code ? Je ne vois pas de pointeur mal initialisé , et meme si c le cas pourqoi ça fonctionne sous code::blocks ?

Parce que lorsqu'un pointeur n'est pas initialisé sa valeur est aléatoire et peut indiquer une adresse valide. Je ne connais pas les détails d'implémentation des programmes par les compilateurs, mais suivant la manière dont ils crèent les objets en mémoire il peut se produire (ou pas) des crashs de ce genre.
Regarde bien les tailles de tableaux pour voir aussi s'il n'y a pas de débordements qui pourraient corrompre les données.

[Emmanuel Delahaye]

Slt je viens d’ecrire une fonction qui charge le contenu d’un fichier dans une liste avec chainage simple . La compil est normale sans aucun warning

Oué ! (version 'complétée')

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
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums2\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c:26: error: syntax error before "liste_composant"
main.c:26: warning: no semicolon at end of struct or union
main.c:27: warning: type defaults to `int' in declaration of `liste_composant'
main.c:27: warning: data definition has no type or storage class
main.c:34: error: syntax error before "liste_composant"
main.c:34: warning: no semicolon at end of struct or union
main.c:39: error: syntax error before '}' token
main.c:39: warning: type defaults to `int' in declaration of `noeud_compose'
main.c:39: warning: data definition has no type or storage class
main.c:40: error: syntax error before '*' token
main.c:40: warning: type defaults to `int' in declaration of `procede'
main.c:40: warning: data definition has no type or storage class
main.c:42: error: syntax error before '*' token
main.c:43: warning: function declaration isn't a prototype
main.c: In function `ajouter_fin_liste_composant':
main.c:44: error: `temp' undeclared (first use in this function)
main.c:44: error: (Each undeclared identifier is reported only once
main.c:44: error: for each function it appears in.)
main.c:44: error: `l_c' undeclared (first use in this function)
main.c:48: error: syntax error before ')' token
main.c:49: error: `c' undeclared (first use in this function)
main.c:58: error: syntax error before ')' token
main.c: At top level:
main.c:64: error: syntax error before '*' token
main.c:64: error: syntax error before '*' token
main.c:65: warning: return type defaults to `int'
main.c:65: warning: function declaration isn't a prototype
main.c: In function `charger_fichier_procede':
main.c:66: error: invalid operands to binary *
main.c:68: error: `l_c' undeclared (first use in this function)
main.c:71: error: `fichier_procede' undeclared (first use in this function)
main.c:75: warning: implicit declaration of function `fscanf'
main.c:75: warning: char format, different type arg (arg 3)
main.c:75: warning: char format, different type arg (arg 4)
main.c:80: warning: char format, different type arg (arg 3)
main.c:96: warning: char format, different type arg (arg 3)
main.c:116: warning: char format, different type arg (arg 3)
main.c:116: warning: char format, different type arg (arg 4)
main.c:116: warning: char format, different type arg (arg 5)
main.c:127: warning: char format, different type arg (arg 3)
main.c:127: warning: char format, different type arg (arg 4)
main.c:143: error: `EOF' undeclared (first use in this function)
Process terminated with status 1 (0 minutes, 4 seconds)
18 errors, 21 warnings