Bug pas compris sur le résultat de mon programme Fermé

Question

Bonjour à tous, Je suis sur un projet pour mes cours, il est presque finalisé, mais j'ai quelques petits problèmes que je ne comprends pas. Le but du projet et de récupérer via un fichier CSV des informations selon les colonnes (dans notre cas la colonne 6/76/85e colonnes), de les trier avec les fonctions de tri d'insertion et de sélection, et ne pas les trier, selon un nombre de ligne précis. Ensuite nous devons les remettre dans un fichier csv avec le nombre de lignes analysés et le temps que cela a mis. Lorsqu'on sélectionne comme choix le tri par sélection, il nous laisse encore mettre les chiffres qu'on veut (while ligne 249). J'ai également un problème avec le fclose(fdonnees); dernière ligne du programme. (expected declaration of statement at end of input). Merci d'avance si vous pouvez m'aider un petit peu. #include #include #include #include #include #include #define MAX 1000000 typedef char string[1024];//def du type de variable string typedef struct reference { int AGED; long long int SURF; string PROF; }ref; ref reftab[MAX]; long int limite=0; void triParInsertion() //Permet de trier les données par un tri par insertion { //Déclaration des variables int cpt; //compteur int unit; //stockage temporaire int dureeTriInsert; //duree du tri long int unit2; //stockage temporaire int cpt2; //compteur 2 string unitPROF;//stockage temporaire pour PROF int PROFCOMP; clock_t debutTriInsert; //2 variables pour le temps de tri clock_t finTriInsert; char TriInsertBuffer[50]; char TriInsertBufferProf[50]; FILE* fdonneesInsertion = fopen("donneeInsertion.csv", "at"); //ouverture/création du fictier csv for (cpt=0;cpt<50;cpt++) //On met le buffer vide { TriInsertBuffer[cpt]='\0'; } printf("Tri par insertion......Tri par insertion "); debutTriInsert=clock(); for (cpt=0;cpt0)&&(reftab[cpt2-1].AGED>unit)) { reftab[cpt2].AGED=reftab[cpt2-1].AGED; cpt2=cpt2-1; } reftab[cpt2].AGED=unit; //tri PROF strcpy(TriInsertBufferProf,reftab[cpt].PROF); cpt2=cpt; PROFCOMP=strncmp(reftab[cpt2-1].PROF,TriInsertBufferProf,4); while( (cpt2 > 0) && (PROFCOMP > 0)) { strcpy(reftab[cpt2].PROF,reftab[cpt2-1].PROF); cpt2=cpt2-1; } strcpy(reftab[cpt2].PROF,TriInsertBufferProf); //tri SURF unit2=reftab[cpt].AGED; cpt2=cpt; while ((cpt2>0)&&(reftab[cpt2-1].AGED>unit)) { reftab[cpt2].AGED=reftab[cpt2-1].AGED; cpt2=cpt2-1; } reftab[cpt2].AGED=unit2; } finTriInsert=clock(); //affichage après tri for(cpt=0;cpt0) { top=0; for (cpt2=0;cpt2<=cpt;cpt2++) { if (reftab[cpt2].AGED>reftab[top].AGED) { top=cpt2; } } reftab[top].AGED; reftab[top].AGED=reftab[cpt].AGED; reftab[cpt].AGED=unit; cpt=cpt-1; } //Tri Selection SURF cpt=MAX; while (cpt>0) { top=0; for (cpt2=0;cpt2<=cpt;cpt2++) { if (reftab[cpt2].SURF>reftab[top].SURF) { top=cpt2; } } unit2=reftab[top].SURF; reftab[top].SURF=reftab[cpt].SURF; reftab[cpt].SURF=unit2; cpt=cpt-1; } //Tri Selection PROF cpt=MAX; while (cpt>0) { top=0; for (cpt2=0;cpt2<=cpt;cpt2++) { if (reftab[cpt2].PROF>reftab[top].PROF) { top=cpt2; } } strcpy(unitPROF,reftab[top].PROF); //changement de égal vers strcpy car chaîne de caractères strcpy(reftab[top].PROF,reftab[cpt].PROF); strcpy(reftab[cpt].PROF,unitPROF); cpt=cpt-1; } for(cpt=0;cpt problème avec le tri insertion. Correction des balises de code, voir ici https://codes-sources.commentcamarche.net/faq/11288-les-balises-de-code

[Dal] · Answer

Salut Arolios,

Je n'ai regardé que les lignes 246 et suivantes.

Tu te serts de scanf() très maladroitement :

 tu ne contrôles pas la valeur de retour de scanf() 
 tu ne vides pas le buffer de stdin
 ton while ((chiffre==2)||(chiffre==1)) teste la condition inverse à celle recherchée : ta boucle doit s'exécuter tant que ces conditions ne sont pas vérifiées
 tu dupliques du code en faisant un premier scanf() en dehors de la boucle de contrôle, qui devrait plutôt être do / while

Ensuite, en ligne 258, tu écris else (chiffre==2); alors que tu devrais écrire else if (chiffre==2) : il manque le if et tu as rajouté un point virgule à la fin. Du coup ton else ne fait qu'exécuter (chiffre==2) et le code qui suit dans les accolades s'exécute quelle que soit la valeur de chiffre.

Pour ton erreur : "expected declaration of statement at end of input", vois s'il ne te manque pas une accolade fermante (dans ce que tu as posté, elle est manifestement manquante, mais c'est peut-être que tu n'as pas posté la fin de ton main.

Dal

[Dal] · Answer

Pour la fonction de vidage du buffer de stdin, il n'y avait rien à remplacer dans la fonction que j'avais postée. Dans le code que tu postes, de nouveau, il manque la dernière accolade fermante pour main(). Sans elle ton code ne peut pas compiler. Ton indentation est trompeuse aussi. Je me suis résolu à tenter de compiler et exécuter ton code, bien que je ne dispose pas du fichier de données à trier, avec un FD_INDREGZD_2018.csv dans lequel je mets une 20aine de lignes similaires à ce que j'ai mis dans st[] dans mon exemple. Si on compile ton code, en ajoutant cette accolade fermante manquante après tes 2 fclose(), il compile sans erreurs de syntaxe, mais avec les warnings suivants : $ gcc -Wall -Wextra 37577339_02.c37577339_02.c: In function ‘triParInsertion’:37577339_02.c:42:13: warning: unused variable ‘unitPROF’ [-Wunused-variable] string unitPROF;//stockage temporaire pour PROF ^~~~~~~~37577339_02.c: In function ‘TriSelection’:37577339_02.c:140:21: warning: statement with no effect [-Wunused-value] reftab[top].AGED; ~~~~~~~~~~~^~~~~37577339_02.c: In function ‘main’:37577339_02.c:234:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘size_t’ {aka ‘long unsigned int’} [-Wsign-compare] for (i=0; i0) { top=0; for (cpt2=0;cpt2<=cpt;cpt2++) { if (reftab[cpt2].AGED>reftab[top].AGED) { top=cpt2; } } reftab[top].AGED; reftab[top].AGED=reftab[cpt].AGED; reftab[cpt].AGED=unit; cpt=cpt-1; } Ton ordinateur est tellement mis à genoux, que tu as l'impression qu'il ne fait rien, et tu t'obstine à taper 1 en pensant que tu es encore au stade du scanf() alors que ton programme a effectivement lancé TriSelection(), mais est occupé à faire tous ces calculs. Je pense aussi que tu ne chronomètres pas ce qu'on te demande de chronométrer, car ton timer débute et s'arrête avant et après la récupération des données, alors qu'il paraîtrait plus logique de timer les algorithmes de tri. Mais, c'est toi qui sais ce qu'on te demande de faire et vois quoi faire ...

[Dal] · Answer

Si tu as un fichier très volumineux, fais tes tests sur un fichier plus petit avec des données parlantes, avec lesquelles il sera facile de comprendre visuellement le résultat que tu obtiens, en affichant à chaque étape ce que tu fais, pour vérifier la bonne exécution de ton code.

[Dal] · Answer

Aussi, dans TriSelection(), tu déclares bien :

        clock_t debutTriSelection;
        clock_t finTriSelection;

mais tu n'affectes aucune valeur de temps à ces variables non initialisées avec la fonction clock().

Du coup, quand tu fais ton calcul TriSelectionDuree=(finTriSelection-debutTriSelection)/1000;, ce calcul se fait sur des valeurs arbitraires contenues dans ces variables non initialisées.

[Dal] · Answer

Ce que tu fais dans chaque boucle répétée 1 million de fois au carré (multiplié par trois fois), est de ce type :

/* cette ligne ne fait rien (cf. avertissement compilateur) */
        reftab[top].AGED;
        /* cette autre ligne affecte le contenu d'un champ d'un 
         * enregistrement en position cpt en écrasant celui en
         * position top, qui est donc perdu */
        reftab[top].AGED=reftab[cpt].AGED;
        /* cette autre ligne affecte le contenu de la variable unit,
         * qui n'est initialisée nulle part (cf avertissement 
         * compilateur) et contient donc une valeur arbitraire, à
         * un champ de l'enregistrement en position cpt, qui est 
         * donc aussi perdu */
        reftab[cpt].AGED=unit;


pendant le temps énorme que prend la fonction à s'exécuter, au point qu'elle a l'air de ne jamais pouvoir se terminer et que tu continues de taper 1, à tout hasard, en pensant qu'elle se lancera peut-être si tu tapes à nouveau, la fonction est en fait bien lancée et occupée à faire ce type d"opération 1 million de fois au carré (multiplié par trois fois).

Tes multiples saisies du chiffre 1 vont seulement dans le tampon de stdin et le programme n'en fait rien, car le programme fait autre chose et ne consomme pas les saisies à ce moment.

Si tu attends patiemment que ta fonction se termine (tu peux attendre des heures éventuellement), tu te retrouves avec des pertes de données en raison des données écrasées avec des valeurs arbitraires et des enregistrements incohérents en raison des permutations isolées résultant des multiples tentatives de tris isolés des 3 champs.

Tu dois :

 pour le nombre d'enregistrements que tu traites (et qui n'est pas de 1 million, je suppose, en tout cas tu demandes à l'utilisateur de saisir le nombre de données qu'il veut, si j'ai bien compris)
 trier selon le critère de tri qui t'est demandé (par exemple AGED dans l'ordre croissant)
 permuter les données en utilisant une struct temporaire, te permettant de conserver les données de la struct que tu choisis d'écraser en premier, pour affecter le contenu sauvegardé à l'autre. Tu n'as pas à affecter les membres de la struct individuellement, le C le fait pour toi, fais juste une affectation de la struct. Ainsi les données des struct sont permutées dans leur intégralité.

Si on te demande de trier selon un seul critère de tri, c'est tout ce que tu as à faire.

Si on te demande de trier selon de multiples critères de tri (par exemple AGED dans l'ordre croissant, puis SURF dans l'ordre croissant, afin que tous les enregistrements dont le AGED est identique soient ensuite classés par SURF), tu dois le faire une fois les données triées par AGED, en repérant les enregistrements dont le AGED est identique et en les triant selon leur SURF. Et ainsi de suite si tu as un 3ème critère.

Si on ne te demande pas de trier selon de multiples critères de tri, tu n'as pas à le faire.

[Dal] · Answer

L'algorithme du tri par sélection est :

  procédure tri_selection(tableau t)      n ← longueur(t)       pour i de 0 à n - 2          min ← i                 pour j de i + 1 à n - 1              si t[j] < t[min], alors min ← j          fin pour          si min ≠ i, alors échanger t[i] et t[min]      fin pour  fin procédure

https://fr.wikipedia.org/wiki/Tri_par_s%C3%A9lection

Ton code ne fait pas cela.

Dal

[Dal] · Answer

Ce code fonctionne en tenant compte des différentes indications que je t'ai données, et en faisant une allocation dynamique de la mémoire nécessaire pour stocker le tableau de struct des données récupérées à trier au lieu d'utiliser une variable globale allouée sur 1 million d'éléments. Le code utilise aussi des fonctions pour simplifier le main.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef char string[1024];

typedef struct reference {
        int AGED;
        long long int SURF;
        string PROF;

} ref;

void reftab_triselection(ref * reftab, size_t lignes_a_traiter) {
        /* on va trier par AGED dans l'ordre croissant selon l'algorithme :
         * https://fr.wikipedia.org/wiki/Tri_par_s%C3%A9lection */
         size_t n = lignes_a_traiter;
         for (size_t i = 0; i < n - 1; i++) {
                 size_t min = i;
                 for (size_t j = i + 1; j < n; j++)
                         if (reftab[j].AGED < reftab[min].AGED)
                                 min = j;
                 if (min != i) {
                         ref temp;
                         temp = reftab[i];
                         reftab[i] = reftab[min];
                         reftab[min] = temp;
                 }
         }
}

int str2int(char * st) {
        return (int)strtol(st, NULL, 10);
}

long long int str2ll(char * st) {
        return strtoll(st, NULL, 10);
}

ref * reftab_init(size_t lignes_a_traiter) {
        ref * reftab = malloc(sizeof(ref) * lignes_a_traiter);
        if (reftab == NULL) {
                printf("Erreur d'allocation de mémoire\n");
                exit(1);
        }
        return reftab;
}

void reftab_free(ref * reftab) {
        free(reftab);
}

void reftab_recuplignes(FILE * f, ref * reftab, size_t lignes_a_traiter) {
        char ligne[1024];
        size_t count = 0;
        while (fgets(ligne, 1024 ,f) != NULL && count < lignes_a_traiter) {
                char * pch;
                pch = strtok(ligne, ";");
                int nfield = 0;
                while (pch != NULL) {
                        nfield++;
                        if (nfield == 6)
                                reftab[count].AGED = str2int(pch);
                        else if (nfield == 76)
                                reftab[count].SURF = str2ll(pch);
                        else if (nfield == 85)
                                strncpy(reftab[count].PROF, pch, 1024);
                        pch = strtok(NULL, ";");
                }
                count++;
        }
}

void reftab_affiche(ref * reftab, size_t lignes_a_traiter) {
        for (size_t i = 0; i < lignes_a_traiter; i++) {
                printf("AGED: %d\t SURF: %lld\t PROF: %s\n",
                        reftab[i].AGED, reftab[i].SURF, reftab[i].PROF);
        }
}

int main(void) {
        FILE * f = fopen("FD_INDREGZD_2018.csv","r");
        if (f == NULL) {
                printf("Erreur d'ouverture du fichier FD_INDREGZD_2018.csv\n");
                return 1;
        }

        /* disons que l'on traite 5 lignes */
        size_t lignes_a_traiter = 5;
        ref * reftab = reftab_init(lignes_a_traiter);

        /* on récupère les 3 champs voulus sur les 5 lignes */
        reftab_recuplignes(f, reftab, lignes_a_traiter);

        /* on les affiche pour vérifier qu'on a bien ce qu'on veut */
        printf("Données récupérées, non triées :\n");
        reftab_affiche(reftab, lignes_a_traiter);

        /* on appelle la fonction de tri avec reftab */
        reftab_triselection(reftab, lignes_a_traiter);

        /* on affiche les données pour vérifier qu'on a bien ce qu'on veut */
        printf("\n");
        printf("Données triées par AGED :\n");
        reftab_affiche(reftab, lignes_a_traiter);

        reftab_free(reftab);
        fclose(f);

        return 0;
}

On fait un test minimaliste avec un fichier FD_INDREGZD_2018.csv comprenant les 7 lignes de données d'exemple suivantes :

1;2;3;4;5;3;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;176;77;78;79;80;81;82;83;84;rouge;86;87
1;2;3;4;5;4;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;376;77;78;79;80;81;82;83;84;orange;86;87
1;2;3;4;5;1;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;276;77;78;79;80;81;82;83;84;jaune;86;87
1;2;3;4;5;2;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;676;77;78;79;80;81;82;83;84;vert;86;87
1;2;3;4;5;2;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;276;77;78;79;80;81;82;83;84;bleu;86;87
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;1276;77;78;79;80;81;82;83;84;indigo;86;87
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;1276;77;78;79;80;81;82;83;84;violet;86;87

Dont on va extraire le contenu des 5 premières lignes en colonnes 6, 76 et 85, pour l'afficher, en faire un tri par sélection et le réafficher, ce qui donne :

$ gcc -Wall -Wextra 37577339.c
$ ./a.out 
Données récupérées, non triées :
AGED: 3  SURF: 176  PROF: rouge
AGED: 4  SURF: 376  PROF: orange
AGED: 1  SURF: 276  PROF: jaune
AGED: 2  SURF: 676  PROF: vert
AGED: 2  SURF: 276  PROF: bleu

Données triées par AGED :
AGED: 1  SURF: 276  PROF: jaune
AGED: 2  SURF: 676  PROF: vert
AGED: 2  SURF: 276  PROF: bleu
AGED: 3  SURF: 176  PROF: rouge
AGED: 4  SURF: 376  PROF: orange
$

Je te conseille de développer tes propres fonctions, car le but n'est pas que tu copie le travail d'un autre, et il te reste de toutes façons beaucoup de choses à faire pour que ton programme fasse ce qu'il est sensé devoir faire, mais veille à ce qu'en utilisant les mêmes données simplifiées de départ, tu obtiennes les mêmes résultats ci-dessus que tu puisses vérifier.

Sinon, tu alignes du code sans savoir ce que tu fais, ni où tu vas.

C'est tout, je n'écris plus pour le moment :-)

Dal

Bug pas compris sur le résultat de mon programme

7 réponses

Discussions similaires