demande d'aide en programmation en c

demande d'aide en programmation en c - C - Programmation

Marsh Posté le 29-01-2012 à 12:45:20    

Bonjours pouvez-vous m'aider à résoudre cet exercice d'algorithme en .
structure étudiant
matricule:entier
chaines de caractère
prénom: chaîne
age:entier
filière: chaîne
 
1 procédure enregistrement  
2 procédure affichage étudiant
3 procédure recherche étudiant
4 procédure supprimé étudiant
5 procedure inserer étudiant
6 procedure trier  
 
et faire le void menu de ces procédures


Message édité par christyleblack le 11-02-2012 à 16:46:17
Reply

Marsh Posté le 29-01-2012 à 12:45:20   

Reply

Marsh Posté le 29-01-2012 à 13:28:37    

Montres nous le code que tu as produit, et on t'aidera à le corriger, mais pas question qu'on fasse tes exercices à ta place.
Surtout que la, c'est du B.A. BA.
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 29-01-2012 à 14:19:44    

voici ce que j'ai essaigné de faire  
 

Code :
  1. #include<stdio.h>
  2. #include<conio.h>
  3. #include<string.h>
  4. struct etudiant
  5. {int matricule;
  6.     char nom[10];
  7.     char prenom[10];
  8.     int age;
  9.     char filiere[10];
  10. }etudiant[3];
  11. void saisie()
  12. {/*etudiant*/ int i;
  13.     for(i=1;i<=3;i++)
  14. {
  15.     printf("taper matricule:" );
  16.     scanf("%d",&etudiant[i].matricule);
  17.     printf("taper nom:" );
  18.     scanf("%s",&etudiant[i].nom);
  19.     printf("taper prenom:" );
  20.     scanf("%s",&etudiant[i].prenom);
  21.     printf("entrer age:" );
  22.     scanf("%d",&etudiant[i].age);
  23.     printf("taper la filiere:" );
  24.     scanf("%s",&etudiant[i].filiere);
  25. }
  26. }
  27. void affichage()
  28. {int i;
  29.     for (i=1;i<=3;i++)
  30. {printf("%d",etudiant[i].matricule);
  31.     printf("%s",etudiant[i].nom);
  32.     printf("%s",etudiant[i].prenom);
  33.     printf("%d",etudiant[i].age);
  34.     printf("%s",etudiant[i].filiere);
  35. }}
  36. void recherche()
  37. {int i,x;
  38.     printf("taper matricule:" );
  39.     scanf("%d",x);
  40.     for(i=1;i<=3;i++)
  41. {if(x==etudiant[i].matricule)
  42.  {printf("d",etudiant[i].matricule);
  43.      printf("%s",etudiant[i].nom);
  44.      printf("%s",etudiant[i].prenom);
  45.      printf("%d",etudiant[i].age);
  46.      printf("%s",etudiant[i].filiere);}
  47.     else
  48.  {printf("n'existe pas" );}
  49. }
  50. }
  51. /*void suppressionetudiant()
  52.   {int i,x;
  53.   printf("taper matricule:" );
  54.   scanf("%d",x);
  55.   trouve=0;
  56.   for(i=1;i<=3;i++)
  57.   {if(etudiant[i].matricule==x)
  58.   {trouve=1;}}
  59.   if(trouve==1)
  60.   {j=i;}
  61.   for(i=j;i<=4;i++)
  62.   {etudiant[i].matricule=etudiant[i+1].matricule;
  63.   etudiant[i].nom=etudiant[i+1].nom;
  64.   etudiant[i].prenom=etudiant[i+1].prenom;
  65.   etudiant[i].age=etudiant[i+1].age;
  66.   etudiant[i].filiere=etudiant[i+1].filiere;
  67.   }
  68.   etudiant[5].matricule="";
  69.   etudiant[5].nom="";
  70.   etudiant[5].prenom="";
  71.   etudiant[5].age="";
  72.   etudiant[5].filiere="";
  73.   }*/
  74. void menu()
  75. {int k/*,etudiant[5].matricule,etudiant[5].age;
  76. char etudiant[5].nom,etudiant[5].prenom,etudiant[5].filiere*/;
  77.     printf("1-saisie etudiant\n" );
  78.     printf("2-affichage etudiant\n" );
  79.     printf("3-recherche etudiant\n" );
  80.     printf("4-suppression etudiant\n" );
  81.     printf("entrer votre choix" );
  82.     scanf("%d",&k);
  83.     switch(k)
  84. {
  85. case 1:saisie();break;
  86. case 2:affichage();break;
  87. case 3:recherche();break;
  88.     /*case 4:supression(etudiant);*/}
  89. }
  90. int main()
  91. {menu();
  92.     getch();
  93.     return 0;
  94. }


 
 
merci d'avance en faite je suis en 1er année miage je ne veux qu'apprendre plus c'est parce qu’on n'a pas encore commencé les structures.j'utilise comme IDE le dev c++.


Message édité par gilou le 29-01-2012 à 15:53:53
Reply

Marsh Posté le 29-01-2012 à 16:17:51    

Déjà, il faut formatter correctement ton code, sinon celui ci devient illisible, et c'est source d'erreurs.
Ton texte, non corrigé, mais reformaté pour plus de lisibilité:
 
 

Code :
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <string.h>
  4.  
  5. struct etudiant {
  6.     int matricule;
  7.     char nom[10];
  8.     char prenom[10];
  9.     int age;
  10.     char filiere[10];
  11. } etudiant[3];
  12.  
  13. /* etudiant */ 
  14. void saisie() {
  15.     int i;
  16.  
  17.     for(i = 1; i <= 3; ++i) {
  18.     printf("taper matricule:" );
  19.     scanf("%d",&etudiant[i].matricule);
  20.     printf("taper nom:" );
  21.     scanf("%s",&etudiant[i].nom);
  22.     printf("taper prenom:" );
  23.     scanf("%s",&etudiant[i].prenom);
  24.     printf("entrer age:" );
  25.     scanf("%d",&etudiant[i].age);
  26.     printf("taper la filiere:" );
  27.     scanf("%s",&etudiant[i].filiere);
  28.     }
  29. }
  30.  
  31. void affichage() {
  32.     int i;
  33.  
  34.     for (i = 1; i <= 3; ++i) {
  35.     printf("%d",etudiant[i].matricule);
  36.     printf("%s",etudiant[i].nom);
  37.     printf("%s",etudiant[i].prenom);
  38.     printf("%d",etudiant[i].age);
  39.     printf("%s",etudiant[i].filiere);
  40.     }
  41. }
  42.  
  43. void recherche() {
  44.     int i, x;
  45.  
  46.     printf("taper matricule:" );
  47.     scanf("%d",x);
  48.     for(i = 1; i <= 3; ++i) {
  49.     if (x == etudiant[i].matricule) {
  50.         printf("d",etudiant[i].matricule);
  51.         printf("%s",etudiant[i].nom);
  52.         printf("%s",etudiant[i].prenom);
  53.         printf("%d",etudiant[i].age);
  54.         printf("%s",etudiant[i].filiere);
  55.     }
  56.     else {
  57.         printf("n'existe pas" );
  58.     }
  59.     }
  60. }
  61.  
  62. /************
  63. void suppressionetudiant() {
  64.     int i, x;
  65.     
  66.     printf("taper matricule:" );
  67.     scanf("%d",x);
  68.     trouve=0;
  69.     for(i = 1; i <= 3; ++i) {
  70.     if (etudiant[i].matricule == x) {
  71.         trouve=1;
  72.     }
  73.     }
  74.     
  75.     if (trouve == 1) {
  76.     j = i;
  77.     }
  78.     for(i = j; i <= 4; ++i) {
  79.     etudiant[i].matricule=etudiant[i+1].matricule;
  80.     etudiant[i].nom=etudiant[i+1].nom;
  81.     etudiant[i].prenom=etudiant[i+1].prenom;
  82.     etudiant[i].age=etudiant[i+1].age;
  83.     etudiant[i].filiere=etudiant[i+1].filiere;
  84.     }
  85.     etudiant[5].matricule="";
  86.     etudiant[5].nom="";
  87.     etudiant[5].prenom="";
  88.     etudiant[5].age="";
  89.     etudiant[5].filiere="";
  90. }
  91. *********/
  92.  
  93. void menu() {
  94.     int k;
  95.     /* int etudiant[5].matricule,etudiant[5].age;
  96.       char etudiant[5].nom,etudiant[5].prenom,etudiant[5].filiere; */
  97.  
  98.     printf("1-saisie etudiant\n" );
  99.     printf("2-affichage etudiant\n" );
  100.     printf("3-recherche etudiant\n" );
  101.     printf("4-suppression etudiant\n" );
  102.     printf("entrer votre choix" );
  103.     scanf("%d",&k);
  104.     switch(k) {
  105.     case 1: 
  106.     saisie();
  107.     break;
  108.     case 2: 
  109.     affichage();
  110.     break;
  111.     case 3: 
  112.     recherche();
  113.     break;
  114.     /*case 4:supression(etudiant);*/
  115.     }
  116. }
  117.  
  118. int main() {
  119.     menu();
  120.     getch();
  121.     return 0;
  122. }


C'est pas parfait ici, parce que le forum et son formatage bouffe les tabulations, mais c'est déjà plus lisible.
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 29-01-2012 à 17:19:52    

Bon ensuite regardons la logique de ta fonction main:
 
Ton programme veut pouvoir exécuter une succession de commandes choisies à partir d'un menu.
La logique ici est donc la suivante:
 
tant qu'on ne quitte pas
demander la commande à executer à l'utilisateur
executer la commande
fin tant que
 
C'est le genre de chose qui s'implémente très vite:
 

Code :
  1. int main () {
  2.     char commande;
  3.     
  4.     do {
  5.     commande = demander_commande();
  6.     executer_commande(commande);
  7.     } while (commande != 'Q');
  8.  
  9.     printf("\nFin du programme\n" );
  10.     getch();
  11.     return 0;
  12. }


 
Bon en ajoutant ce qui manque, on obtient un cadre de base qui gère la saisie du menu, fait tourner la boucle principale et tient compte des erreurs:
 

Code :
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <string.h>
  4.  
  5. void clean_stdin() {
  6.     int c;
  7.     
  8.     do {
  9.         c = getchar();
  10.     } while (c != '\n' && c != EOF);
  11. }
  12.  
  13.  
  14. void affiche_menu() {
  15.     char *items[] = {
  16.     "Saisie etudiant",
  17.     "Affichage etudiant",
  18.     "Recherche etudiant",
  19.     "Suppression etudiant",
  20.     "Quitter",
  21.     };
  22.     int i;
  23.  
  24.     printf("\n" );
  25.     for (i = 0; i < 5; ++i) {
  26.     printf("%d-%s\n", i+1, items[i]);
  27.     }
  28.     printf("entrer votre choix " );
  29. }
  30.  
  31.  
  32. char demander_commande() {
  33.     unsigned short saisie = 0;
  34.     char commande;
  35.     
  36.     affiche_menu();
  37.     scanf("%d", &saisie);
  38.     clean_stdin();
  39.  
  40.     switch (saisie) {
  41.     case 1: /* Créer */
  42.     commande = 'C';
  43.     break;
  44.     case 2: /* Afficher */
  45.     commande = 'A';
  46.     break;
  47.     case 3: /* Rechercher */
  48.     commande = 'R';
  49.     break;
  50.     case 4: /* Supprimer */
  51.     commande = 'S';
  52.     break;
  53.     case 5: /* Quitter */
  54.     commande = 'Q';
  55.     break;
  56.     default: /* Erreur */
  57.     commande = 'E';
  58.     break;
  59.     }
  60.     return commande;  
  61. }
  62.  
  63. void executer_commande(char commande) {
  64.  
  65.     switch (commande) {
  66.     case 'C': /* Créer */
  67.     break;
  68.     case 'A': /* Afficher */
  69.     break;
  70.     case 'R': /* Rechercher */
  71.     break;
  72.     case 'S': /* Supprimer */
  73.     break;
  74.     case 'Q': /* Quitter */
  75.     break;
  76.     default: /* Erreur est inclus dans ce cas */
  77.     printf("\nCommande incomprise, recommencez" );
  78.     break;
  79.     }
  80. }
  81.  
  82. #define MAX_ERRORS 5
  83. int main () {
  84.     char commande;
  85.     unsigned short errors = 0;
  86.     
  87.     do {
  88.     commande = demander_commande();
  89.     if (commande == 'E') {
  90.         ++errors;
  91.         if (errors > MAX_ERRORS) {
  92.         printf("\nTrop d'erreurs!" );
  93.         commande = 'Q';
  94.         }
  95.     }
  96.     else { // errors est remis à 0
  97.         errors = 0; 
  98.     }
  99.     executer_commande(commande);
  100.     } while (commande != 'Q');
  101.  
  102.     printf("\nFin du programme\n" );
  103.     getch();
  104.     return 0;
  105. }


 
A ce stade la, tu peux passer a la partie principale de ton programme:
La structure de données et sa gestion.
Note: il y a moyen de faire des menus un peu plus intelligents, avec une structure contenant pour chaque item le texte et la commande, mais je n'ai pas voulu compliquer les choses.
La chose importante a comprendre ici, c'est qu'on ne mélange pas les torchons avec les serviettes, et donc on ne mélange pas le dialogue avec l'utilisateur et le traitement des structures internes à ton programme, comme ta procédure menu faisait.
 
Pour ta structure de donnée principale, si tu veux passer par une table de structures, je suggère:
typedef struct {
    int matricule;
    int age;
    char nom[10];
    char prenom[10];
    char filiere[10];
}t_etudiant;
 
#define MAX_ETUDIANTS 8
static t_etudiant etudiants[MAX_ETUDIANTS];
static unsigned short num_etudiants = 0;
 
A+,


Message édité par gilou le 29-01-2012 à 18:53:34

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 30-01-2012 à 10:12:53    

merci pour le coup de main je ferai tout pour comprendre et executer le programme

Reply

Marsh Posté le 30-01-2012 à 19:03:53    

void suppressionetudiant()
{int i,x,trouve,k;
printf("taper matricule:" );
scanf("%d",x);
for(i=1;i<=3;i++)
{
if(x==etudiant[i].matricule)
{j=i;}
}
for(k=j;k<=2;i++)
{
etudiant[k].matricule=etudiant[i+1].matricule;
etudiant[k].nom=etudiant[k+1].nom;
etudiant[k].prenom=etudiant[k+1].prenom;
etudiant[k].age=etudiant[k+1].age;
etudiant[k].filiere=etudiant[k+1].filiere;
}
etudiant[3].matricule="";
etudiant[3].nom="";
etudiant[3].prenom="";
etudiant[3].age="";
etudiant[3].filiere="";
}
VOICI MON CODE POUR LA SUPPRESSION MAIS J'AI TOUJOURS PAS TROUVER DE SOLUTION PUIS-JE AVOIR UN P'TIT COUP DE MAIN,

Reply

Marsh Posté le 30-01-2012 à 20:59:18    

Taper du code, tout le monde peut le faire, expliquer de manière claire quel algorithme tu veux mettre en place pour la suppression serait bien plus utile. Ça permet de savoir ce qu'on va coder au lieu de se mettre a coder au jugé.
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 31-01-2012 à 08:49:52    

en faite c'est une procédure du programme d'en haut je voulais juste avoir une autre méthode et faire une confrontation.

Reply

Marsh Posté le 31-01-2012 à 12:03:03    

Bon alors on va te donner une indication une manière la plus efficace de gérer cela quand on travaille avec un tableau de taille fixe:
Plutôt que de passer du temps a recopier les cases les unes dans les autres, autant avoir un flag "entrée utilisée" que tu met a faux 0 partout au départ, a 1 quand tu utilises l'entrée pour une opération de saisie d'un étudiant, et a 0 de nouveau quand tu supprime l'étudiant dont c'est l'entrée.
Quand tu saisis un étudiant, tu utilises la première case inutilisée trouvée.
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 31-01-2012 à 12:03:03   

Reply

Marsh Posté le 01-02-2012 à 15:10:31    

peux tu être plus clair en faisant un exemple par un code j'espère que je ne te dérange pas trop.

Reply

Marsh Posté le 01-02-2012 à 22:32:21    

Pas de pb, je t'ai tapé vite fait un petit exemple.
Ne te préoccupes pas de la gestion des menus, elle est probablement trop compliquée pour ton niveau, mais par contre, en regardant les fonctions elementaires de gestion de la table, et comment elles sont employées par les fonctions déclenchées par le chois du menu, cela te donnera une idée sur la manière dont cela fonctionne.
 
 

Code :
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdbool.h>
  4. #include <time.h>
  5.  
  6. #define MAX_ELEMENTS 12
  7. typedef struct {
  8.     unsigned short num_elements; // le nb d'éléments contenus dans la table
  9.     unsigned short next_unused;  // indice pour la prochaine insertion
  10.     struct {
  11.         bool in_use; // la case est utilisee
  12.         char *data; // en general, c'est une structure plus complexe ici
  13.     } entry[MAX_ELEMENTS];
  14. } t_fixed_table;
  15.  
  16. #define MAX_ITEM_SIZE 64
  17. typedef struct {
  18.     unsigned short nb_items;
  19.     bool zerostart;
  20.     char question[MAX_ITEM_SIZE];
  21.     struct {
  22.         bool (*command)(t_fixed_table *);
  23.         bool (*display)(t_fixed_table *);
  24.         bool displayed;
  25.         char text[MAX_ITEM_SIZE];
  26.     } item[];
  27. } t_menu;
  28.  
  29. static char *cluedo_name[10] = {
  30.     "Mademoiselle Rose",
  31.     "Colonel Moutarde",
  32.     "Madame Leblanc",
  33.     "Docteur Olive",
  34.     "Madame Pervenche",
  35.     "Professeur Violet",
  36.     "Mademoiselle Peche",
  37.     "Monsieur Prunelle",
  38.     "Sergent Legris",
  39.     "Madame Chose"
  40. };
  41.  
  42. /*************************************************************
  43.  * Les 4 actions de base proposées par menus                 *
  44.  * On mettra le code après le main, histoire de les séparer  *
  45.  * des fonctions utilitaires                                 *
  46.  *************************************************************/
  47. bool ajouter_element(t_fixed_table *table);
  48. bool supprimer_element(t_fixed_table *table);
  49. bool lister_table(t_fixed_table *table);
  50. bool quitter(t_fixed_table *table);
  51. /* action supplémentaire spéciale christyleblack */
  52. bool toggle_pedagogical(t_fixed_table *table);
  53. /* codage vite fait d'une fonction de lecture et inversion */
  54. bool acces_pedagogical(bool invert) {
  55.     static bool pedagogical_mode = false;
  56.     if (invert) {
  57.         pedagogical_mode = pedagogical_mode?false:true;
  58.     }
  59.     return pedagogical_mode;
  60. }
  61. bool toggle_pedagogical(t_fixed_table *table) {
  62.     acces_pedagogical(true);
  63.     return true;
  64. }
  65.  
  66. /*************************************************************
  67.  * Fonctions élémentaires de manipulation de la table        *
  68.  * - Initialisation de la table                              *
  69.  * - Ajout d'une entrée                                      *
  70.  * - Suppression d'une entrée                                *
  71.  * - Listage de la table                                     *
  72.  *************************************************************/
  73. void init_table(t_fixed_table *table) {
  74.     if (table) {
  75.         int i;
  76.         table->num_elements = 0;
  77.         table->next_unused = 0;
  78.         for (i = 0; i < MAX_ELEMENTS; ++i) {
  79.             table->entry[i].in_use = false;
  80.             table->entry[i].data = NULL;
  81.         }
  82.     }
  83. }
  84.  
  85. void add_data(t_fixed_table *table, char *data) {
  86.     if (table && (table->next_unused < MAX_ELEMENTS)) {
  87.         int i;
  88.         // On ajoute le contenu et declare la case utilisée
  89.         table->entry[table->next_unused].in_use = true;
  90.         table->entry[table->next_unused].data = data;
  91.         // on met a jour le nb d'elts
  92.         ++table->num_elements;
  93.         // et l'indice pour la prochaine insertion
  94.         ++table->next_unused;
  95.         for (i = table->next_unused; i < MAX_ELEMENTS; ++i) {
  96.             if (table->entry[i].in_use == false) {
  97.                 break;
  98.             }
  99.             ++table->next_unused;
  100.         }
  101.     }
  102. }
  103.  
  104. void delete_data(t_fixed_table *table, unsigned short index) {
  105.     if (table && (index < table->num_elements)) {
  106.         int i, j;
  107.         // on trouve l'indice dans le tableau a partir de celui donné
  108.         // par l'utilisateur en sautant les cases inutilisées
  109.         j = 0;
  110.         for (i = 0; i < MAX_ELEMENTS; ++i) {
  111.             if (table->entry[i].in_use == true) {
  112.                 if (j == index) {
  113.                     break;
  114.                 }
  115.                 j++;
  116.             }
  117.         }
  118.         // on supprime le contenu et declare la case inutilisée
  119.         table->entry[i].in_use = false;
  120.         table->entry[i].data = NULL;
  121.         // on met a jour le nb d'elts
  122.         --table->num_elements;
  123.         // et si necessaire l'indice pour la prochaine insertion
  124.         if (table->next_unused > i) {
  125.             table->next_unused = i;
  126.         }
  127.     }
  128. }
  129.  
  130. void print_table_state(t_fixed_table *table, bool pedagogical) {
  131.     if (table) {
  132.         int i, j;
  133.  
  134.         /* impression avec toute la table */
  135.         if (pedagogical) {
  136.             j = 1;
  137.             printf("--------------------------------------\n" );
  138.             printf("| case | numero |        nom         |\n" );
  139.             printf("--------------------------------------\n" );
  140.             for (i = 0; i < MAX_ELEMENTS; ++i) {
  141.                 printf("|  %-2d  |", i);
  142.                 if (table->entry[i].in_use == true) {
  143.                     printf("   %-2d   |", j);
  144.                     printf(" %-18s |\n", table->entry[i].data);
  145.                     j++;
  146.                 }
  147.                 else {
  148.                     printf("   %-2c   |", ' ');
  149.                     printf(" %-18c |\n", ' ');
  150.                 }
  151.             }
  152.             printf("--------------------------------------\n" );
  153.         }
  154.         /* impression de la partie utilisée de la table */
  155.         else {
  156.             j = 1;
  157.             printf("-------------------------------\n" );
  158.             printf("| numero |        nom         |\n" );
  159.             printf("-------------------------------\n" );
  160.             for (i = 0; i < MAX_ELEMENTS; ++i) {
  161.                 if (table->entry[i].in_use == true) {
  162.                     printf("|   %-2d   |", j);
  163.                     printf(" %-18s |\n", table->entry[i].data);
  164.                     j++;
  165.                 }
  166.             }
  167.             printf("-------------------------------\n" );
  168.         }
  169.     }
  170. }
  171.  
  172. /*************************************************************
  173.  * Fonctions renseignant les menus de l'état de la table        *
  174.  *************************************************************/
  175. bool table_not_full(t_fixed_table *table) {
  176.     return (table && (table->num_elements < MAX_ELEMENTS))?true:false;
  177. }
  178.  
  179. bool table_not_empty(t_fixed_table *table) {
  180.     return (table && (table->num_elements > 0))?true:false;
  181. }
  182.  
  183. bool table_exists(t_fixed_table *table) {
  184.     return (table)?true:false;
  185. }
  186.  
  187. bool always_true(t_fixed_table *table) {
  188.     return true;
  189. }
  190.  
  191. /* vidage de buffer classique */
  192. void clean_stdin() {
  193.     int c;
  194.  
  195.     do {
  196.         c = getchar();
  197.     } while (c != '\n' && c != EOF);
  198. }
  199.  
  200.  
  201. /*************************************************************
  202.  * Fonctions de gestion des menus                            *
  203.  *************************************************************/
  204. void items_enable(t_menu *menu, t_fixed_table *table) {
  205.     int i;
  206.  
  207.     for (i = 0; i < menu->nb_items; ++i) {
  208.         menu->item[i].displayed = (*menu->item[i].display)(table);
  209.     }
  210. }
  211.  
  212. int affiche_menu(t_menu *menu) {
  213.     int i;
  214.     int displayed = menu->zerostart?0:1;
  215.  
  216.     printf("\n" );
  217.     for (i = 0; i < menu->nb_items; ++i) {
  218.         if (menu->item[i].displayed) {
  219.             printf("%d - %s\n", displayed++, menu->item[i].text);
  220.         }
  221.     }
  222.     return menu->zerostart?displayed:displayed-1;
  223. }
  224.  
  225. #define MAX_MENU_ERRORS 5
  226. bool (*choix_menu(t_menu *menu))(t_fixed_table *) {
  227.     unsigned short saisie = 0;
  228.     unsigned short nb_errors = 0;
  229.     int min_item = 1;
  230.     int nb_items, retcode, i, j;
  231.  
  232.     nb_items = affiche_menu(menu);
  233.     if (menu->zerostart) {
  234.         --nb_items;
  235.         --min_item;
  236.     }
  237.     do  {
  238.         printf(menu->question);
  239.         retcode = scanf("%d", &saisie);
  240.         clean_stdin();
  241.  
  242.         if ((retcode == 1) && (min_item <= saisie) && (saisie <= nb_items)) {
  243.             j = menu->zerostart?0:1;
  244.             for (i = 0; i < menu->nb_items; ++i) {
  245.                 if  (menu->item[i].displayed) {
  246.                     if (j == saisie) {
  247.                         break;
  248.                     }
  249.                     ++j;
  250.                 }
  251.             }
  252.             return menu->item[i].command;
  253.         }
  254.         else {
  255.             ++nb_errors;
  256.             if (nb_errors >= MAX_MENU_ERRORS) {
  257.                 printf("\nTrop d'erreurs!" );
  258.                 return &quitter;
  259.             }
  260.             else {
  261.                 printf("\nErreur! reponse incorrecte, recommencez.\n" );
  262.             }
  263.         }
  264.     } while(true);
  265. }
  266.  
  267. /*************************************************************
  268.  * recuperation d'un entier entre par l'utilisateur          *
  269.  * avec controle de la validité                              *
  270.  *************************************************************/
  271. #define MAX_SAISIE_ERRORS 5
  272. bool get_user_num(t_fixed_table *table, int *num) {
  273.     int saisie, retcode;
  274.     int nb_errors = 0;
  275.  
  276.     do {
  277.         printf("Donnez le numero de l'élément à supprimer [1-%d]: ", table->num_elements);
  278.         retcode = scanf("%d", &saisie);
  279.         clean_stdin();
  280.         printf("\n" );
  281.  
  282.         if (retcode == 1) {
  283.             if (saisie < 1) {
  284.                 printf("Valeur trop petite! valeur minimale: 1 " );
  285.             }
  286.             else if (saisie > table->num_elements) {
  287.                 printf("Valeur trop grande! valeur maximale: %d", table->num_elements);
  288.             }
  289.             else {
  290.                 *num = saisie;
  291.                 return true;
  292.             }
  293.         }
  294.         else {
  295.             printf("Valeur saisie incorrecte! " );
  296.         }
  297.         ++nb_errors;
  298.         if (nb_errors >= MAX_SAISIE_ERRORS ) {
  299.             printf("Trop d'erreurs!\n" );
  300.             return false;
  301.         }
  302.         else {
  303.             printf("Recommencez\n" );
  304.         }
  305.     } while(true);
  306. }
  307.  
  308. /* ------------------------------------------------------------------------ */
  309. int main() {
  310.     t_fixed_table mytable;
  311.     static t_menu mymenu = {
  312.         5,
  313.         false,
  314.         "Entrer votre choix : ",
  315.         {   {&ajouter_element, &table_not_full, true, "Ajouter un element"},
  316.             {&supprimer_element, &table_not_empty, true, "Supprimer un element"},
  317.             {&lister_table, &table_exists, true, "Lister les elements"},
  318.             {&toggle_pedagogical, &always_true, true, "Changer de mode (normal/pedagogique)"},
  319.             {&quitter, &always_true, true, "Quitter"},
  320.         }
  321.     };
  322.  
  323.     init_table(&mytable);
  324.     do {
  325.         items_enable(&mymenu, &mytable);
  326.     } while((*choix_menu(&mymenu))(&mytable));
  327.  
  328.     return 0;
  329. }
  330. /*************************************************************
  331.  * les 4 actions associées aux menus                         *
  332.  * elles font appel aux fonctions basiques de manipulation   *
  333.  * de la table, avec les parametres ad-hoc                   *
  334.  * en sortie, false fait sortir de la boucle du main         *
  335. **************************************************************/
  336. bool ajouter_element(t_fixed_table *table) {
  337.     add_data(table, cluedo_name[rand() % 10]);
  338.     return true;
  339. }
  340.  
  341. bool supprimer_element(t_fixed_table *table) {
  342.     int numero;
  343.  
  344.     printf("\n" );
  345.     print_table_state(table, false); // pour choisir le numero
  346.     if (get_user_num(table, &numero)) {
  347.         delete_data(table, numero-1);
  348.     }
  349.     return true;
  350. }
  351.  
  352. bool lister_table(t_fixed_table *table) {
  353.     printf("\n" );
  354.     print_table_state(table, acces_pedagogical(false));
  355.     return true;
  356. }
  357.  
  358. bool quitter(t_fixed_table *table) {
  359.     return false;
  360. }


Testé et compilé avec gcc (sous windows, mais ça devrait passer sur n'importe quelle plateforme).
 
Je t'ai rajouté une option "changer de mode".
En mode par défaut, en faisant lister, tu ne vois que la partie de la table qui est non vide
En mode pédagogique, tu vois ce qui se passe dans toute la table.
 
A+,


Message édité par gilou le 12-02-2012 à 18:42:40

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 11-02-2012 à 15:59:58    

merci mon pote

Reply

Marsh Posté le 11-02-2012 à 16:32:28    

pouvez vous m'aider à resoudre une procedure insertion et une procedure de trie.voici mes codes mais sa ne marche pas trop.
 
 
//procedure insertion
void insertion()
{int j,i;
printf("taper le rang au quel vous voulez inserer" );
scanf("%d",&j);
printf("taper un matricule:" );
scanf("%d",&etudiant[n+1].matricule);
printf("taper un nom:" );
scanf("%s",&etudiant[n+1].nom);
printf("taper un prenom:" );
scanf("%s",&etudiant[n+1].prenom);
printf("taper un age:" );
scanf("%d",&etudiant[n+1].age);
printf("taper une filiere:" );
scanf("%s",&etudiant[n+1].filiere);
 
while (i>j)
{etudiant[i+1]=etudiant[i];
i++;}
for(i=1;i<=n+1;i++)
{
 
if(j==i)
{etudiant[j]=etudiant[n+1];}
}
}  
 
 
//procedure trie
void trie()
{int i,j;
 
do
{j=0;
for(i=1;i<=n;i++)
{
if(etudiant[i].matricule<etudiant[i+1].matricule)
{j++;}
etudiant[0]=etudiant[i];
etudiant[i]=etudiant[i+1];
etudiant[i+1]=etudiant[0];
 
 
}
}
while(j=0);
printf("trier!!!!!!!!!!!!" );
 
}

Message cité 1 fois
Reply

Marsh Posté le 12-02-2012 à 17:36:52    

christyleblack a écrit :

pouvez vous m'aider à resoudre une procedure insertion et une procedure de trie.voici mes codes mais sa ne marche pas trop.
 
 
//procedure insertion
void insertion()
{int j,i;
printf("taper le rang au quel vous voulez inserer" );
scanf("%d",&j);
printf("taper un matricule:" );
scanf("%d",&etudiant[n+1].matricule);
printf("taper un nom:" );
scanf("%s",&etudiant[n+1].nom);
printf("taper un prenom:" );
scanf("%s",&etudiant[n+1].prenom);
printf("taper un age:" );
scanf("%d",&etudiant[n+1].age);
printf("taper une filiere:" );
scanf("%s",&etudiant[n+1].filiere);
 
while (i>j)
{etudiant[i+1]=etudiant[i];
i++;}
for(i=1;i<=n+1;i++)
{
 
if(j==i)
{etudiant[j]=etudiant[n+1];}
}
}  
 
 
//procedure trie
void trie()
{int i,j;
 
do
{j=0;
for(i=1;i<=n;i++)
{
if(etudiant[i].matricule<etudiant[i+1].matricule)
{j++;}
etudiant[0]=etudiant[i];
etudiant[i]=etudiant[i+1];
etudiant[i+1]=etudiant[0];
 
 
}
}
while(j=0);
printf("trier!!!!!!!!!!!!" );
 
}


 
Salut
Déjà on t'a dit de formater proprement ton code. On se demande pourquoi Gilou s'est fendu d'un exemple complet et professionnel quand on voit ce que tu ressors (surtout après t'y être désintéressé pendant 10 jours). Ah pour sortir un "merci mon pote" tu es champion mais pour montrer que tu sais apprécier et tirer profit du travail des autres pour t'améliorer efficacement là il n'y a plus personne. "partager" ne signifie pas "je fais sous-traiter mon TP par des pros pendant que je joue à CODWAW"...
Donc déjà pour la forme pas de "&" pour la saisies des chaines (de plus utiliser scanf() pour un nombre et ensuite pour une chaine est source de problèmes à cause du caractère <return> resté dans le clavier lors de la saisie du nombre et qui est récupéré au scanf() suivant). De plus je ne vois pas trop pourquoi tu fais saisir "j" pour remplir [n+1] (avec n non initialisé en plus).
Ensuite une structure n'étant pas un élément manipulable, tu n'as pas le droit d'utiliser "=" pour la recopier d'un endroit à l'autre. Te faut soit recopier ses membres un par un, soit passer par memcpy(). De même tu n'as pas le droit d'utiliser les opérateurs de comparaison <> pour l'évaluer. Te faut soit évaluer les membres soit passer par une fonction dédiée (qui, elle, évaluera les membres pour détecter quel élément est plus petit ou plus grand que tel autre).
Et pour le fond c'est dommage de sacrifier l'élément [0] d'un tableau pour l'utiliser comme élément temporaire de tri...


Message édité par Sve@r le 12-02-2012 à 17:47:01
Reply

Marsh Posté le 12-02-2012 à 18:36:07    

Citation :

Déjà on t'a dit de formater proprement ton code. On se demande pourquoi Gilou s'est fendu d'un exemple complet et professionnel quand on voit ce que tu ressors (surtout après t'y être désintéressé pendant 10 jours).

Tu as tout à fait compris pourquoi je n'ai plus l'intention d'aller plus loin dans mon aide sur ce topic.
Tout au plus je signalerai que trier réellement le tableau est inutile et coûteux, et qu'il vaut bien mieux trier un tableau de pointeurs pointant sur les fiches elles mêmes.
A+,


Message édité par gilou le 12-02-2012 à 18:36:27

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed