Discussion :

[ggnore]

Bonjour.

ça fait des mois que j'ai pas fait de langage C, et je suis déjà tout rouillé.

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
void erreur(char * msg){
        printf ("\n Erreur : %s\n", msg);
}
 
void affiche(char * msg){
        printf ("\n-------------------------------\n");
        printf ("%s",msg);
        printf ("\n-------------------------------");
}
 
int     lire_ligne( int * lot_n, float * cout_n)
{
        char * dummy;
        char chaine[128];
 
        char * lot_c;
        char * cout_c;
 
        if(fgets(chaine, 128, stdin) == NULL){
                erreur("fgets");
                return -1;
        }
 
        lot_c = strtok (chaine,":");
        cout_c = strtok (NULL, ":");
 
        *lot_n = strtol ( lot_c, &dummy, 10);
        *cout_n = atof(cout_c);
        return 0;
}
 
int traitement (float ** tableau_resultat, int nb_ligne){
 
        char tmp[128];
        float chaine_cout[1024];
 
 
        int lot_courant=0;
        int nb_prod_par_lot=0;
        int nb_prod_tot=0;
        int ligne_faite=0, ligne_lue=0;
        int prod_traite=0;
 
        float max, min;
        float cout_lot;
 
        float test;
 
        int lot_n=-1;
        float cout_n;
 
        // tant qu'on n'a pas parcouru et traite tous les produits (et donc tous les lots)
        while (ligne_faite < nb_ligne){
 
                cout_lot = 0;
 
                if (lot_n != lot_courant)
                        lire_ligne(&lot_n, &cout_n);
 
                sprintf(tmp,"\n%d. =>lot: %d >cout: %f ¹", ligne_lue, lot_n, cout_n);
                affiche(tmp);
 
                lot_courant = lot_n;
                max = min = cout_n;
                chaine_cout[ligne_lue] = cout_n;
                cout_lot += cout_n;
 
                nb_prod_par_lot++;
                ligne_lue++;
 
                // tant qu'on n'a pas parcouru tous les produits d'un lot
                while (lot_courant == lot_n){
                        lire_ligne(&lot_n, &cout_n);
                        sprintf(tmp,"\n%d. =>lot: %d >cout: %f ²", ligne_lue, lot_n, cout_n);
                                affiche(tmp);
 
                        if (lot_courant != lot_n) continue;
 
                        if (max<cout_n) max=cout_n;
                        if (min>cout_n) min=cout_n;
                        chaine_cout[ligne_lue]=cout_n;
                        nb_prod_par_lot++;
                        cout_lot+=
                        ligne_lue++;
                }
 
                // calcul des notes
                for (prod_traite = 0 ; prod_traite < nb_prod_par_lot ; prod_traite++){
                        sprintf(tmp,"calcul de notre pour le %deme produit, cout=%f max=%f min=%f", prod_traite, chaine_cout[prod_traite], max, min);
                        affiche(tmp);
                        if (max==min) {chaine_cout[prod_traite] = 5;}
                        // si le cout est minimum on a un 10
                        else if (chaine_cout[prod_traite] == min)               {*tableau_resultat[prod_traite] = 10;}
                        // si le cout est max, on a un 1
                        else if (chaine_cout[prod_traite] == max)       {*tableau_resultat[prod_traite] = 1;}
                        // sinon on calcule relativement
                        else {
                                /*
                                sprintf(tmp, "10 - (10 * ( %f - %f)/(%f-%f))", chaine_cout[prod_traite], min, max,min);
                                affiche(tmp);
 
                                test=chaine_cout[prod_traite] - min;
                                sprintf(tmp, "chaine_cout[prod_traite] - min = %f", test );
                                affiche(tmp);
 
                                test=max-min;
                                sprintf(tmp, "max-min=%f", test);
                                affiche(tmp);
 
                                sprintf(tmp, "(chaine_cout[prod_traite] - min)/(max-min) = %f", (chaine_cout[prod_traite] - min)/(max-min) );
                                affiche(tmp);
                                */
                                *tableau_resultat[prod_traite] = 10 - (10 * (chaine_cout[prod_traite] - min)/(max-min));
                        }
                        sprintf(tmp, "note: %f / 10", *tableau_resultat[prod_traite]);
                        affiche(tmp);
                }
                ligne_faite+=prod_traite-1;
                nb_prod_par_lot=0;
 
        }
 
        return(0);
 
}
 
int main(int argc, char *argv[])
{
        int nb_ligne=0;
        int curseur;
 
        char tmp[64];
        char * dummy;
        float * tableau_resultat;
 
        if (argc == 2){
                printf ("argv[1]=%s", argv[1]);
                nb_ligne=strtol(argv[1], &dummy, 10);
                sprintf(tmp, "nb_l=%d", nb_ligne);
                affiche(tmp);
        }
        else {
                sprintf(tmp,"arguments > besoin du nombre de ligne, argc=%d", argc);
                erreur(tmp);
                return -1;
        }
 
        if ( (tableau_resultat = malloc ( sizeof(float) * nb_ligne)) == NULL ){
                sprintf(tmp,"allocation tableau %d elements", nb_ligne);
                erreur(tmp);
                return -1;
        }
 
        sprintf(tmp,"allocation tableau %d elements", nb_ligne);
        affiche(tmp);
 
 
        sprintf(tmp,"lecture");
        affiche (tmp);
 
        traitement( &tableau_resultat, nb_ligne);
 
        return 0;
}

je travaille sous linux.
mon fichier entree contient :

1:1.54
1:1.65
1:2.05
1:1.40556
1:1.4
1:1.5
1:2.49
1:2.02
1:1.65
2:1.76
2:1.76
2:1.76
2:1.76
2:1.8
2:2.13
2:1.26776
2:1.5
2:1.6
2:2.7
2:2.09
2:1.8

pour lancer mon programme, je fais :

Code :

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

cat entree | ./test 21

Quand le calcul commence, mon programme ne calcule que les 3 premières valeurs puis il part en vadrouille dans l'univers du segfault:

[...]
-------------------------------
note: 7.706422 / 10
-------------------------------
-------------------------------
calcul de notre pour le 2eme produit, cout=2.050000 max=2.490000 min=1.400000
Erreur de segmentation

Je ne trouve pas ce qui cloche.

C'est un programme fait à l'arrache pour dépanner, il doit marcher demain soir au plus tard. Je suis pas loin d'avoir ce que je veux, mais ... j'y suis pas

Merci d'avance.

[ggnore]

hum, allocation d'un tableau d'entier alors que c'est un tableau de float

mais ça ne résout rien

[gege2061]

hum, allocation d'un tableau d'entier alors que c'est un tableau de float

mais ça ne résout rien

Arf, je vois qu'il est temps de te rappeler les bonnes manières : Bien utiliser malloc()

Code :

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

tableau_resultat = malloc ( sizeof(*tableau_resultat) * nb_ligne)

Comme ça plus de problème

Allez on va dire que c'est la remise en route

[fearyourself]

Deux erreurs:

Code :

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

1
2
3
 
 
tableau_resultat = malloc ( sizeof(int) * nb_ligne))

devrait être:

Code :

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

1
2
 
tableau_resultat = malloc ( sizeof(float) * nb_ligne))

EDITION: en effet, ceci aurait éviter des ennuis...

Code :

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

1
2
 
tableau_resultat = malloc ( sizeof(*tableau_resultat) * nb_ligne))

Ensuite:

Code :

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

*tableau_resultat[prod_traite]

Est faux puisque ton tableau n'est qu'un tableau de flottant... Ce que tu voudrais faire c'est

Code :

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

(*tableau_resultat)[prod_traite]

Mais cela ne sert à rien, ton prototype pourrait simplement être:

Code :

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

int traitement (float * tableau_resultat, int nb_ligne)

Et tes affectations seraient donc:

Code :

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

tableau_resultat[prod_traite]

Tu n'aurais pas eu d'erreurs à ce moment là...

Jc

[ggnore]

merci beaucoup
C'est loin de fonctionner correctement, mais là ça doit être algorithmique.

Je voulais abosulement passer ce tableau par adresse, alors que ça n'a rien de nécessaire.

to be continued

[ggnore]

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define debug1
 
void erreur(char * msg){
        printf ("\n Erreur : %s\n", msg);
}
 
void affiche(char * msg){
#ifdef debug
        printf ("\n--\n%s\n--",msg);
#endif
 
}
 
int     lire_ligne( int * lot_n, float * cout_n, int * ligne_lue)
{
        char * dummy;
        char chaine[128];
        char tmp[64];
 
        char * lot_c;
        char * cout_c;
 
        if(fgets(chaine, 128, stdin) == NULL){
                erreur("fgets");
                return -1;
        }
 
        sprintf(tmp,"Lecture ligne n°%d", *ligne_lue);
        affiche(tmp);
 
        lot_c = strtok (chaine,":");
        cout_c = strtok (NULL, ":");
 
        *lot_n = strtol ( lot_c, &dummy, 10);
        if( (*cout_n = strtod(cout_c, &dummy)) == 0){
                sprintf(tmp, "valeur vaut 0, ligne %d ", *ligne_lue);
                affiche(tmp);
 
        }
 
 
        (*ligne_lue)++;
 
        return 0;
}
 
int traitement (float * tableau_resultat, int nb_ligne){
 
        char tmp[128];
        float chaine_cout[1024];
 
 
        int lot_courant=0;
        int nb_prod_par_lot=0;
        int nb_prod_tot=0;
        int ligne_faite=0, ligne_lue=0;
        int prod_traite=0;
 
        float max, min;
        float cout_lot;
 
        float test;
 
        int lot_n=-1;
        float cout_n;
 
        // tant qu'on n'a pas parcouru et traite tous les produits (et donc tous les lots)
        while (ligne_faite < nb_ligne){
                cout_lot = 0;
 
                if (lot_n != lot_courant){
                        if (lire_ligne(&lot_n, &cout_n, &ligne_lue) == -1) return -1;
                        sprintf(tmp, "amorce car (lot_n %d) != (lot_courant %d)", lot_n, lot_courant);
                        affiche(tmp);
                }
 
                sprintf(tmp,"\n%d. =>lot: %d >cout: %f ¹", ligne_lue, lot_n, cout_n);
                affiche(tmp);
 
                lot_courant = lot_n;
                max = min = cout_n;
                chaine_cout[ligne_lue-1] = cout_n;
                cout_lot += cout_n;
 
                nb_prod_par_lot++;
 
                // tant qu'on n'a pas parcouru tous les produits d'un lot
                while ( (lot_courant == lot_n) && (ligne_lue < nb_ligne) ){
                        sprintf(tmp, "while ( (lot_courant %d == lot_n %d ) && (ligne_lue %d  < nb_ligne %d) )",lot_courant,lot_n,ligne_lue,nb_ligne);
                        affiche(tmp);
                        if(lire_ligne(&lot_n, &cout_n, &ligne_lue) == -1) return -1;
 
                        sprintf(tmp,"\n%d. =>lot: %d >cout: %f ²", ligne_lue, lot_n, cout_n);
                                affiche(tmp);
 
                        if (lot_courant != lot_n) {
                                continue;
                        }
 
                        if (max<cout_n) max=cout_n;
                        if (min>cout_n) min=cout_n;
 
                        chaine_cout[ligne_lue-1]=cout_n;
 
                        nb_prod_par_lot++;
                        cout_lot+=cout_n;
                }
 
                // calcul des notes
                for (prod_traite = 0 ; prod_traite < nb_prod_par_lot ; prod_traite++){
                        sprintf(tmp,"calcul note pour %deme produit, cout=%f max=%f min=%f", prod_traite, chaine_cout[ligne_faite], max, min);
                        affiche(tmp);
 
                        if (max==min) {
                                tableau_resultat[ligne_faite] = 5;
                        }
                        // si le cout est minimum on a un 10
                        else if (chaine_cout[ligne_faite] == min){
 
                                tableau_resultat[ligne_faite] = 10;
                        }
                        // si le cout est max, on a un 1
                        else if (chaine_cout[ligne_faite] == max){
 
                                tableau_resultat[ligne_faite] = 1;
                        }
                        // sinon on calcule relativement
                        else {
                                tableau_resultat[ligne_faite] = (float)(10 -  (10 * (chaine_cout[ligne_faite] - min)/(max-min)));
                        }
                        printf("%f\n",tableau_resultat[ligne_faite]);
 
                        ligne_faite++;
                }
                nb_prod_par_lot = 0;
                lot_courant = lot_n;
 
        }
        return(0);
 
}
 
int main(int argc, char *argv[])
{
        int nb_ligne=0;
        int curseur;
 
        char tmp[64];
        char * dummy;
        float * tableau_resultat;
 
        if (argc == 2){
                sprintf (tmp,"argv[1]=%s", argv[1]);
                affiche(tmp);
                nb_ligne=strtol(argv[1], &dummy, 10);
                sprintf(tmp, "nb_l=%d", nb_ligne);
                affiche(tmp);
        }
        else {
                sprintf(tmp,"arguments > besoin du nombre de ligne, argc=%d", argc);
                erreur(tmp);
                return -1;
        }
 
        if ( (tableau_resultat = (float*) malloc ( sizeof(*tableau_resultat) * nb_ligne)) == NULL ){
                sprintf(tmp,"allocation tableau %d elements", nb_ligne);
                erreur(tmp);
                return -1;
        }
 
        sprintf(tmp,"allocation tableau %d elements", nb_ligne);
        affiche(tmp);
 
        traitement( tableau_resultat, nb_ligne);
 
        free(tableau_resultat);
 
        return 0;
}

J'ai encore un segfault quand je traite beaucoup de données.
Comment puis détecter une erreur quand j'utilise strtod ? il se peut que je récupère un 0 comme valeur, donc ça n'est pas un bon test.
Je n'ai pas bien compris avec le man strtod quoi faire pr détecter un erreur.
Merci d'avance.

[Médinoc]

Au lieu de NULL, tu passes l'adresse d'un pointeur.

Exemple:
Si après l'appel, le caractère pointé est nul, c'est que la chaîne a été entièrement lue -->aucune erreur

[ggnore]

Au lieu de NULL, tu passes l'adresse d'un pointeur.

Exemple:
Si après l'appel, le caractère pointé est nul, c'est que la chaîne a été entièrement lue -->aucune erreur

Ok merci, j'ai rajouté ce test, mais je ne détecte aucune erreur.

Je considère le problème comme résolu : après moultes tests, je me suis rendu compte que ça plantait systématiquement au 1025 éléments.
C'est marrant, j'ai un tableau qui fait 1024 cases ...

Bon c'était un programme fait à l'arrache.
Maintenant c'est bon, je me suis mis 65536 éléments