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.