Forums Rue-Montgallet.com
Rue-Montgallet.comRue-Hardware.comRue-Occasion.comRue-DVD.comRue-Jeuxvideo.comRue-AudioVideo.comRue-Telephone.comForums
S'inscrire | S'identifier |
| Recherche avancée | Aide
 

  FORUM


  Programmation


  C - C++


  mot de passe

 
 

Il y a 50 utilisateurs connus et inconnus. Pour voir la liste des connectés connus, cliquez ici

 Mot :   Pseudo :  
 
Bas de page
Auteur
 Sujet :

mot de passe

 
n°17978
aaargh
Profil : Jeune recrue
Posté le 04-12-2006 à 11:38:26  profilanswer
 

Bonjour
je dois realiser un programme en c gestion de comptes bancaires et dois par la meme occasion creer un e mot de passe pour les utilisateurs des comptes ...
Je n'arrive vraiment pas à le faire
est-ce que qn pourrait m'aider ???
 
ca serait vraiment genial
Merci d'avance
 
aaargh

Message cité 1 fois
n°17982
-ed-
C is a sharp tool
Profil : Jeune recrue
Posté le 04-12-2006 à 16:01:48  profilanswer
 

aaargh a écrit :

Je n'arrive vraiment pas à le faire
est-ce que qn pourrait m'aider ???


Tu as oublié de poster le code avec lequel tu as un problème. Si il n'y a pas de code, poste au moins les études préalables :  
 
1 - Spécifications (on a une vague idée, mais ça demande des précisions : système, environnement...)
2 - Conception (comment résoudre les problèmes exposés en 1)
 
On ne code pas au hasard...


Message édité par -ed- le 04-12-2006 à 16:02:38

---------------
Emmanuel Delahaye
Des infos sur la programmation et le langage C:
http://bien-programmer.blogspot.com/  
http://mapage.noos.fr/emdel/
n°17983
aaargh
Profil : Jeune recrue
Posté le 04-12-2006 à 17:47:27  profilanswer
 


Voici le code que l'on a fait j'ai tout mis ca fait surement bcp la !
il y a 600lignes en gros, maintenant on a des structures, comptes, banques ...  
ce que l'on doit faire c'est insérer les mots de passe pour les comptes : l'ecran indique qu'il faut que le titulaire rentre un mot de passe qu'il le confirme, puis a chaque utilisation du code il faut lui redemander et verifier s'il est bon, on veut faire un seul code pour chaque titulaire, qui pourra avoir plusieur comptes.
Sinon on doit pouvoir faire des virements d'un compte a l'autre mais c'est lamot de passe qui nous embete plus !
voilà j'espere vraiment que l'on pourra nous aider .
Aaargh
 
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/types.h>
  5. #include <time.h>
  7. #define LONG_TITU 40
  8. #define MAX_COMPTES 256
  9. #define NB_OPS 4
  11. /* codage des operations */
  12. #define NO_OP 0
  13. #define OUVERTURE 1
  14. #define DEPOT 2
  15. #define RETRAIT 3
  16. #define CLOTURE 4
  18. /* codage des etats de compte */
  19. #define LIBRE 0
  20. #define OUVERT 1
  21. #define CLOS 2
  23. #ifdef linux
  24. #include <stdio_ext.h>
  25. #define PURGE(X) __fpurge(X)
  26. #else
  27. #ifdef __DARWIN_NULL
  28. #define PURGE(X) fpurge(X)
  29. #else
  30. #define PURGE(X) fflush(X)
  31. #endif
  32. #endif
  34. /**************************************************************/
  35. /* le type "operation" */
  36. struct operation {
  37.         double montant;
  38.         int type; /* NO_OP, OUVERTURE... */
  39.         time_t date; /* date au format "systeme" */
  40. };
  42. /* le type "compte" */
  43. struct compte {
  44.         int numero;
  45.         char titulaire[LONG_TITU];
  46.         int etat; /* LIBRE, OUVERT, CLOS */
  47.         double solde;
  48.         struct operation ops[NB_OPS];
  49. };
  50. /* NB : dans le tableau ops, les operations sont classees par */
  51. /* ordre de saisie decroissant, la derniere operation saisie */
  52. /* est toujours ops[0] */
  54. /* le type "agence" */
  55. struct agence {
  56.         double solde;
  57.         int num_prochain_compte;
  58.         struct compte comptes[MAX_COMPTES];
  59. };
  61. /**************************************************************/
  62. /* fonction d'initialisation de l'agence                      */
  63. /**************************************************************/
  64. void raz_agence (struct agence *ag)
  65. {
  66. int i;
  68.         ag->solde=0.;
  69.         ag->num_prochain_compte=0;
  70.         for (i=0;i<MAX_COMPTES;i++)
  71.                 ag->comptes[i].etat=LIBRE;
  72. }
  74. /* fonction de remise a zero d'un compte (utilise par purge)  */
  75. void raz_compte (struct compte *cpt)
  76. {
  77. int i;
  79.         cpt->numero=0;
  80.         memset(cpt->titulaire,0,LONG_TITU);
  81.         cpt->etat=0;
  82.         cpt->solde=0.;
  83.         for (i=0;i<NB_OPS;i++) {
  84.                 cpt->ops[i].montant=0.;
  85.                 cpt->ops[i].type=NO_OP;
  86.                 cpt->ops[i].date=0;
  87.         }
  88. }
  90. /**************************************************************/
  91. /* fonctions de lecture/ecriture d'une agence dans un fichier */
  92. /**************************************************************/
  93. int charge_agence (char *nomfichier, struct agence *ag)
  94. {
  95. FILE *pf;
  96. size_t sz;
  97. int status;
  99.         /* on ouvre le fichier en lecture seule */
  100.         pf=fopen(nomfichier,"r" );
  101.         if (pf==NULL)
  102.                 return -1;
  103.         sz=sizeof(struct agence);
  104.         /* on lit une structure de taille sz que l'on */
  105.         /* stocke a l'adresse indiquee par ag */
  106.         if (fread(ag,sz,1,pf)==1)
  107.                 status=0;
  108.         else
  109.                 status=-1;
  110.         fclose(pf);
  111.         return status;
  112. }
  114. int sauve_agence (char *nomfichier, struct agence *ag)
  115. {
  116. FILE *pf;
  117. size_t sz;
  118. int status;
  120.         /* on ouvre le fichier en (re)ecriture */
  121.         pf=fopen(nomfichier,"w" );
  122.         if (pf==NULL)
  123.                 return -1;
  124.         sz=sizeof(struct agence);
  125.         /* on ecrit la structure de taille sz stockee */
  126.         /* a l'adresse indiquee par ag */
  127.         if (fwrite(ag,sz,1,pf)==1)
  128.                 status=0;
  129.         else
  130.                 status=-1;
  131.         fclose(pf);
  132.         return status;
  133. }
  135. /*******************************************************/
  136. /* Diverses fonctions de recherche                     */
  137. /*******************************************************/
  138. /* le resultat est l'adresse du compte, NULL en cas de */
  139. /* non-existence du compte. Attention : le compte peut */
  140. /* etre CLOS ! */
  142. /* fonction de recherche d'un compte par son numero    */
  143. struct compte *cherche_cpt_num (struct agence *ag,int numcpt)
  144. {
  145. int i;
  147.         for (i=0;i<MAX_COMPTES;i++)
  148.                 if (((ag->comptes[i].etat==OUVERT)||
  149.                         (ag->comptes[i].etat==CLOS))&&
  150.                         (ag->comptes[i].numero==numcpt))
  151.                         return &(ag->comptes[i]);
  152.         return 0;
  153. }
  155. /* fonction de recherche d'un compte par son titulaire */
  156. struct compte *cherche_cpt_titu (struct agence *ag,char *titu)
  157. {
  158. int i;
  160.         for (i=0;i<MAX_COMPTES;i++)
  161.                 if (((ag->comptes[i].etat==OUVERT)||
  162.                         (ag->comptes[i].etat==CLOS))&&
  163.                         (!strcmp(ag->comptes[i].titulaire,titu)))
  164.                         return &(ag->comptes[i]);
  165.         return 0;
  166. }
  168. /* fonction de recherche d'un compte libre             */
  169. struct compte *cherche_cpt_libre (struct agence *ag)
  170. {
  171. int i;
  173.         for (i=0;i<MAX_COMPTES;i++)
  174.                 if (ag->comptes[i].etat==LIBRE)
  175.                         return &(ag->comptes[i]);
  176.         return 0;
  177. }
  179. /*******************************************************/
  180. /* fonctions de traitement                             */
  181. /*******************************************************/
  183. /* ouverture d'un compte pour titu a la date t         */
  184. /* la fonction rend : numero de compte si tout est OK, */
  185. /* -1 si l'agence est "complete", -2 si le titulaire a */
  186. /* deja un compte                                      */
  187. int traite_ouverture (struct agence *ag,char *titu,time_t t)
  188. {
  189. int i;
  190. struct compte *cpt;
  192.         /* on verifie d'abord que le titulaire n'a pas */
  193.         /* deja un compte                              */
  194.         cpt=cherche_cpt_titu(ag,titu);
  195.         if (cpt)
  196.                 return -2;
  197.         cpt=cherche_cpt_libre(ag);
  198.         if (!cpt)
  199.                 return -1;
  200.         /* on remplit les champs du compte cree */
  201.         cpt->numero=ag->num_prochain_compte++;
  202.         strncpy(cpt->titulaire,titu,LONG_TITU-1);
  203.         cpt->etat=OUVERT;
  204.         cpt->solde=0.;
  205.         /* on remplit l'operation 0 de type OUVERTURE */
  206.         cpt->ops[0].type=OUVERTURE;
  207.         cpt->ops[0].date=t;
  208.         cpt->ops[0].montant=0.;
  209.         /* on remplit les operations suivantes avec NO_OP */
  210.         for (i=1;i<NB_OPS;i++)
  211.                 cpt->ops[i].type=NO_OP;
  212.         return cpt->numero;
  213. }
  215. /* fonction de traitement de l'operation op sur le compte */
  216. /* de numero numcpt de l'agence ag (op != OUVERTURE)      */
  217. int traite_operation (struct agence *ag,int numcpt,
  218.         struct operation *op)
  219. {
  220. int i;
  221. struct compte *cpt;
  223.         /* on cherche le compte de numero numcpt */
  224.         cpt=cherche_cpt_num(ag,numcpt);
  225.         /* test de validite : compte inexistant ou CLOS */
  226.         if ((cpt==0)||(cpt->etat==CLOS))
  227.                 return -1;
  228.         switch (op->type) {
  229.                 case DEPOT:
  230.                         cpt->solde+=op->montant;
  231.                         ag->solde+=op->montant;
  232.                         break;
  233.                 case RETRAIT:
  234.                         if (cpt->solde < op->montant)
  235.                                 return -1;
  236.                         cpt->solde-=op->montant;
  237.                         ag->solde-=op->montant;
  238.                         break;
  239.                 case CLOTURE:
  240.                         if (cpt->solde!=0)
  241.                                 return -1;
  242.                         cpt->etat=CLOS;
  243.                         break;
  244.                 default:
  245.                         return -1;
  246.         }
  247.         /* on "decale" les operations du tableau ops */
  248.         for (i=NB_OPS-2;i>=0;i--)
  249.                 cpt->ops[i+1]=cpt->ops[i];
  250.         cpt->ops[0]= *op;
  251.         return 0;
  252. }
  254. /* fonction d'affichage du solde de l'agence             */
  255. void solde_agence (struct agence *ag)
  256. {
  257.         printf("Le solde de l'agence est %.2f\n",ag->solde);
  258. }
  260. /* fonction de "purge" de l'agence : libere les comptes  */
  261. /* CLOS avant la date t */
  262. void purge_agence (struct agence *ag,time_t t)
  263. {
  264. int i,nb;
  266.         for (i=0,nb=0;i<MAX_COMPTES;i++)
  267.                 /* si le compte est CLOS, et que la cloture a eu */
  268.                 /* lieu avant "cur", on remet a zero le compte */
  269.                 if ((ag->comptes[i].etat==CLOS) &&
  270.                         (ag->comptes[i].ops[0].date < t)) {
  271.                         printf("Purge du compte %d\n",
  272.                                 ag->comptes[i].numero);
  273.                         raz_compte(&(ag->comptes[i]));
  274.                         nb++;
  275.                 }
  276.         printf("%d comptes purges\n",nb);
  277. }
  279. /* effectue un releve de l'operation op. le format est :    */
  280. /* JJ/MM/AAAA HH:MM ouverture/cloture/[depot,retrait] de XX */
  281. /* on utilise localtime pour convertir les dates            */
  282. void releve_operation (struct operation *op)
  283. {
  284. struct tm *d;
  286.         if (op->type==NO_OP)
  287.                 return;
  288.         d=localtime(&(op->date));
  289.         if (d==0)
  290.                 fputs("\tXX/XX/XXXX XX:XX ",stdout);
  291.         else
  292.                 printf("\t%02d/%02d/%04d %02d:%02d ",
  293.                         d->tm_mday,d->tm_mon+1,d->tm_year+1900,
  294.                         d->tm_hour,d->tm_min);
  295.         switch (op->type) {
  296.                 case OUVERTURE:
  297.                         fputs("ouverture\n",stdout);
  298.                         return;
  299.                 case CLOTURE:
  300.                         fputs("cloture\n",stdout);
  301.                         return;
  302.                 case DEPOT:
  303.                         printf("depot de %.2f E\n",op->montant);
  304.                         return;
  305.                 case RETRAIT:
  306.                         printf("retrait de %.2f E\n",op->montant);
  307.                         return;
  308.         }
  309. }
  311. /* fonction de releve du compte de numero numcpt           */
  312. /* on affiche les informations du compte, puis les NB_OPS  */
  313. /* (au plus) dernieres operations                          */
  314. int releve_compte (struct agence *ag,int numcpt)
  315. {
  316. struct compte *cpt;
  317. int i;
  319.         cpt=cherche_cpt_num(ag,numcpt);
  320.         if (!cpt)
  321.                 return -1;
  322.         printf("Titulaire : %s\n",cpt->titulaire);
  323.         printf("Compte %d",cpt->numero);
  324.         if (cpt->etat==CLOS)
  325.                 fputs(" [CLOTURE]\n",stdout);
  326.         else
  327.                 printf(", solde %.2f E\n",cpt->solde);
  328.         for (i=NB_OPS-1;i>=0;i--)
  329.                 releve_operation(&(cpt->ops[i]));
  330.         return 0;
  331. }
  333. /*********************************************************/
  334. /* Diverses fonctions de saisie au clavier               */
  335. /* ces fonctions rendent -1 en cas d'annulation (CTRL-D  */
  336. /* frappe au clavier), sinon elles insistent indefiniment*/
  337. /* pour avoir une saisie "correcte"                      */
  338. /*********************************************************/
  339. int saisie_num_cpt (void)
  340. {
  341. int num;
  342. char rep[1024];
  344.         for (;;) {
  345.                 fputs("Numero de compte"
  346.                         " (CTRL-D pour annuler) ? ",stdout);
  347.                 PURGE(stdin);
  348.                 if (!fgets(rep,1024,stdin)) {
  349.   clearerr(stdin);
  350.                         return -1;
  351.  }
  352.                 if (sscanf(rep,"%d",&num)==1)
  353.                         return num;
  354.         }
  355. }
  357. int saisie_code_op (void)
  358. {
  359. char rep[1024];
  361.         for (;;) {
  362.                 fputs("D(epot), R(etrait), C(loture)"
  363.                         " (CTRL-D pour annuler) ? ",stdout);
  364.                 PURGE(stdin);
  365.                 if (!fgets(rep,1024,stdin)) {
  366.   clearerr(stdin);
  367.                         return -1;
  368.  }
  369.                 switch (rep[0]) {
  370.                         case 'D':
  371.                                 return DEPOT;
  372.                         case 'R':
  373.                                 return RETRAIT;
  374.                         case 'C':
  375.                                 return CLOTURE;
  376.                         default:
  377.                                 break;
  378.                 }
  379.         }
  380. }
  382. int saisie_titulaire (char *titu)
  383. {
  384. char *eol;
  386.         fputs("Titulaire (CTRL-D pour annuler) ? ",stdout);
  387.         PURGE(stdin);
  388.         if (!fgets(titu,LONG_TITU,stdin)) {
  389.  clearerr(stdin);
  390.                 return -1;
  391. }
  392.         /* on tronque le nom au premier saut de ligne      */
  393.         eol=strchr(titu,'\n');
  394.         if (eol)
  395.                 eol[0]=0;
  396.         return 0;
  397. }
  399. int saisie_montant (double *v)
  400. {
  401. char rep[1024];
  403.         for (;;) {
  404.                 fputs("Montant"
  405.                         " (CTRL-D pour annuler) ? ",stdout);
  406.                 PURGE(stdin);
  407.                 if (!fgets(rep,1024,stdin)) {
  408.   clearerr(stdin);
  409.                         return -1;
  410.  }
  411.                 if (sscanf(rep,"%lf",v)==1)
  412.                         return 1;
  413.         }
  414. }
  416. /* fonction de saisie de date                            */
  417. /* la date est saisie sous la forme JJ/MM/AAAA HH:MM     */
  418. /* la fonction propose la date courante, si l'utilisateur*/
  419. /* ne tape rien (<Return> ou CTRL-D), on accepte cette   */
  420. /* date courante                                         */
  421. time_t saisie_date (void)
  422. {
  423. time_t t;
  424. struct tm *d,buf;
  425. char rep[1024];
  427.         for (;;) {
  428.                 t=time(0);
  429.                 d=localtime(&t);
  430.                 fputs("Date ",stdout);
  431.                 if (d)
  432.                         printf("(%02d/%02d/%04d %02d:%02d) ? ",
  433.                                 d->tm_mday,1+d->tm_mon,d->tm_year+1900,
  434.                                 d->tm_hour,d->tm_min);
  435.                 PURGE(stdin);
  436.                 if (!fgets(rep,1024,stdin) || (rep[0]=='\n')) {
  437.   clearerr(stdin);
  438.                         return t;
  439.  }
  440.                 if (sscanf(rep," %d/%d/%d %d:%d",
  441.                         &(buf.tm_mday),&(buf.tm_mon),&(buf.tm_year),
  442.                         &(buf.tm_hour),&(buf.tm_min))==5) {
  443.                         buf.tm_mon--;
  444.                         buf.tm_year-=1900;
  445.                         buf.tm_sec=0;
  446.                         buf.tm_isdst=-1;
  447.                         return mktime(&buf);
  448.                 }
  449.         }
  450. }
  452. /*********************************************************/
  453. /* Les differents menus pour saisir les infos et traiter */
  454. /*********************************************************/
  455. void menu_recherche (struct agence *ag)
  456. {
  457. char titu[LONG_TITU];
  458. struct compte *cpt;
  459. int num;
  461.         for (;;) {
  462.                 puts("[Comptes/Recherche de compte]" );
  463.                 if (saisie_titulaire(titu)==-1)
  464.                         return;
  465.                 cpt=cherche_cpt_titu(ag,titu);
  466.                 if (cpt) {
  467.                         printf("compte %d, titulaire %s\n",
  468.                                 cpt->numero,cpt->titulaire);
  469.                         return;
  470.                 }
  471.                 /* on essaie d'interpreter le titulaire */
  472.                 /* comme un numero de compte            */
  473.                 if (sscanf(titu,"%d",&num)==1) {
  474.                         cpt=cherche_cpt_num(ag,num);
  475.                         if (cpt) {
  476.                                 printf("compte %d, titulaire %s\n",
  477.                                         cpt->numero,cpt->titulaire);
  478.                                 return;
  479.                         }
  480.                 }
  481.                 fputs("NON TROUVE\n",stdout);
  482.                 return;
  483.         }
  484. }
  486. void menu_saisie_op (struct agence *ag)
  487. {
  488. struct operation op;
  489. int num_cpt;
  491.         for (;;) {
  492.                 puts("[Comptes/Saisie d'operation]" );
  493.                 num_cpt=saisie_num_cpt();
  494.                 if (num_cpt==-1)
  495.                         return;
  496.                 op.type=saisie_code_op();
  497.                 if (op.type==-1)
  498.                         return;
  499.                 if (op.type!=CLOTURE)
  500.                         if (saisie_montant(&(op.montant))==-1)
  501.                                 return;
  502.                 op.date=saisie_date();
  503.                 if (traite_operation(ag,num_cpt,&op)==-1)
  504.                         printf("Echec du traitement !\n" );
  505.                 else
  506.                         printf("Traitement effectue !\n" );
  507.                         return;
  508.         }
  509. }
  511. void menu_releve (struct agence *ag)
  512. {
  513. int num_cpt;
  515.         for (;;) {
  516.                 puts("[Comptes/Releve de compte]" );
  517.                 num_cpt=saisie_num_cpt();
  518.                 if (num_cpt==-1)
  519.                         return ;
  520.                 if (releve_compte(ag,num_cpt)==-1)
  521.                         fputs("COMPTE INEXISTANT\n",stdout);
  522.                         return ;
  523.         }
  524.        
  525. }
  527. void menu_ouverture (struct agence *ag)
  528. {
  529. char titu[LONG_TITU];
  530. int num;
  531. time_t t;
  533.         for (;;) {
  534.                 puts("[Comptes/Ouverture]" );
  535.                 if (saisie_titulaire(titu)==-1)
  536.                         return;
  537.                 t=saisie_date();
  538.                 switch (num=traite_ouverture(ag,titu,t)) {
  539.                         case -2:
  540.                                 puts("CE TITULAIRE A DEJA UN COMPTE" );
  541.                                 return;
  542.                         case -1:
  543.                                 puts("L'AGENCE EST COMPLETE" );
  544.                                 return;
  545.                         default:
  546.                                 printf("compte %d cree\n",num);
  547.                                 return;
  548.                 }
  549.         }
  550. }
  552. void menu_purge (struct agence *ag)
  553. {
  554. time_t tpurge;
  555. char dummy[1024];
  557. puts("[ATTENTION : purge des comptes (CTRL-D pour annuler)]" );
  558. PURGE(stdin);
  559. if (!fgets(dummy,1024,stdin)) {
  560.  clearerr(stdin);
  561.  return;
  562. }
  563. tpurge=saisie_date();
  564. purge_agence(ag,tpurge);
  565. }
  567. void menu_comptes (struct agence *ag)
  568. {
  569. char rep[1024];
  570. int choix;
  572.         for (;;) {
  573.                 puts("[Comptes]" );
  574.                 puts("(1) recherche d'un numero de compte" );
  575.                 puts("(2) saisie d'une operation" );
  576.                 puts("(3) releve de compte" );
  577.                 puts("(4) ouverture de compte" );
  578.                 puts("(0) sortie" );
  579.                 fputs("--> ",stdout);
  580.                 PURGE(stdin);
  581.                 if (!fgets(rep,1024,stdin)) {
  582.   clearerr(stdin);
  583.                         return;
  584.  }
  585.                 if (sscanf(rep,"%d",&choix)!=1)
  586.                         continue;
  587.                 switch (choix) {
  588.                         case 0:
  589.                                 return;
  590.                         case 1:
  591.                                 menu_recherche(ag);
  592.                                 break;
  593.                         case 2:
  594.                                 menu_saisie_op(ag);
  595.                                 break;
  596.                         case 3:
  597.                                 menu_releve(ag);
  598.                                 break;
  599.                         case 4:
  600.                                 menu_ouverture(ag);
  601.                                 break;
  602.                         default:
  603.                                 printf("Mauvais choix %s !\n",rep);
  604.                                 break;
  605.                 }
  606.         }
  607. }
  609. void menu_principal (struct agence *ag)
  610. {
  611. char rep[1024];
  612. int choix;
  614.         for (;;) {
  615.                 puts("(1) consultation du solde agence" );
  616.                 puts("(2) acces au menu 'comptes'" );
  617.                 puts("(3) purge des comptes" );
  618.                 puts("(4) SORTIE IMMEDIATE SANS SAUVEGARDE" );
  619.  puts("(5) remise a zero de l'agence" );
  620.                 printf("(0) sortie\n--> " );
  621.                 PURGE(stdin);
  622.                 if (!fgets(rep,1024,stdin)) {
  623.   clearerr(stdin);
  624.                         continue;
  625.  }
  626.                 if (sscanf(rep,"%d",&choix)!=1)
  627.                         continue;
  628.                 switch (choix) {
  629.                         case 0:
  630.                                 return;
  631.                         case 1:
  632.                                 solde_agence(ag);
  633.                                 break;
  634.                         case 2:
  635.                                 menu_comptes(ag);
  636.                                 break;
  637.                         case 3:
  638.                                 menu_purge(ag);
  639.                                 break;
  640.                         case 4:
  641.                                 exit(1);
  642.                                 /*NOTREACHED*/
  643.                                 return;
  644.   case 5:
  645.    raz_agence(ag);
  646.    break;
  647.                         default:
  648.                                 break;
  649.                 }
  650.         }
  651.         return;
  652. }
  654. int main (int argc,char *argv[])
  655. {
  656. char *fic_agence;
  657. struct agence ag;
  658. char rep[1024];
  660.         if (argc==1)
  661.                 fic_agence="agence.dat";
  662.         else
  663.                 fic_agence=argv[1];
  664.         if (charge_agence(fic_agence,&ag)==-1) {
  665.                 perror(fic_agence);
  666.                 printf("Initialise une agence vide ?" );
  667.                 if (fscanf(stdin,"%s",rep)!=1) {
  668.                         perror("stdin" );
  669.                         fprintf(stderr,"STOP !!!\n" );
  670.                         return 2;
  671.                 }
  672.                 if (rep[0]=='o' || rep[0]=='O' || rep[0]=='y' ||
  673.                         rep[0]=='Y')
  674.                         raz_agence(&ag);
  675.                 else {
  676.                         fprintf(stderr,"STOP !!!\n" );
  677.                         return 2;
  678.                 }
  679.         }
  680.         menu_principal(&ag);
  681.         if (sauve_agence(fic_agence,&ag)==-1) {
  682.                 perror(fic_agence);
  683.                 return 1;
  684.         }
  685.         return 0;
  686. }

Message cité 1 fois
n°17984
-ed-
C is a sharp tool
Profil : Jeune recrue
Posté le 04-12-2006 à 20:00:25  profilanswer
 

aaargh a écrit :

Voici le code que l'on a fait j'ai tout mis ca fait surement bcp la !


Oui, tu aurais pu réduire au problème précis. Tant pis, tu vas te prendre une revue de code, ça ne fait pas de mal...

Citation :


il y a 600lignes en gros, maintenant on a des structures, comptes, banques ...  
ce que l'on doit faire c'est insérer les mots de passe pour les comptes : l'ecran indique qu'il faut que le titulaire rentre un mot de passe qu'il le confirme, puis a chaque utilisation du code il faut lui redemander et verifier s'il est bon, on veut faire un seul code pour chaque titulaire, qui pourra avoir plusieur comptes.
Sinon on doit pouvoir faire des virements d'un compte a l'autre mais c'est lamot de passe qui nous embete plus !
voilà j'espere vraiment que l'on pourra nous aider .


Voilà du code assez bien fait. Il y a quelques points à revoir, notamment au niveau des saisies, mais c'est plutôt bien analysé et bien construit, dans un esprit OO.
 

  • Attention, la sauvegarde des données 'brutes' n'est pas portable.


http://mapage.noos.fr/emdel/notes.htm#enreg_struct
 

  • Les entrées sont basées sur fgets(). C'est bien, mais c'est insuffisant. Il faut ensuite (et pas avant) nettoyer le flux si nécessaire et en profiter pour supprimer le \n. Je recommande la fonction fclean() (code minimum ci-après)


  • Attention a ne pas sur-dimensionner les chaines de saisie (1k dans la mémoire auto à chaque fois, c'est beaucoup). La taille devrait être déterminée avec l'opérateur sizeof (tableaux statiques).


  • Il est préférable de n'avoir qu'un return par fonction. Le code est plus clair et il y a moins de risque d'erreur de libération de ressource.


Ton code commenté et corrigé.

Code :
  1. /*
  2. Voici le code que l'on a fait j'ai tout mis ca fait surement bcp la !
  3. il y a 600lignes en gros, maintenant on a des structures, comptes, banques ...
  4. ce que l'on doit faire c'est insérer les mots de passe pour les comptes : l'ecran indique qu'il faut que le titulaire rentre un mot de passe qu'il le confirme, puis a chaque utilisation du code il faut lui redemander et verifier s'il est bon, on veut faire un seul code pour chaque titulaire, qui pourra avoir plusieur comptes.
  5. Sinon on doit pouvoir faire des virements d'un compte a l'autre mais c'est lamot de passe qui nous embete plus !
  6. voilà j'espere vraiment que l'on pourra nous aider .
  7. Aaargh
  8. */
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <sys/types.h>
  14. #include <time.h>
  16. #define LONG_TITU 40
  17. #define MAX_COMPTES 256
  18. #define NB_OPS 4
  20. /* codage des operations */
  21. #define NO_OP 0
  22. #define OUVERTURE 1
  23. #define DEPOT 2
  24. #define RETRAIT 3
  25. #define CLOTURE 4
  27. /* codage des etats de compte */
  28. #define LIBRE 0
  29. #define OUVERT 1
  30. #define CLOS 2
  32. /* -ed-
  33. #ifdef linux
  34. #include <stdio_ext.h>
  35. #define PURGE(X) __fpurge(X)
  36. #else
  37. #ifdef __DARWIN_NULL
  38. #define PURGE(X) fpurge(X)
  39. #else
  40. #define PURGE(X) fflush(X)
  41. #endif
  42. #endif
  44. Non ! fflush() n'est defini que pour les flux entrants...
  45. */
  47. /* -ed- a appeler apres un fgets() */
  48. static void fclean (char *s, FILE * fp)
  49. {
  50.    char *p = strchr (s, '\n');
  51.    if (p != NULL)
  52.    {
  53.       *p = 0;
  54.    }
  55.    else
  56.    {
  57.       int c;
  58.       while ((c = fgetc (fp)) != '\n' && c != EOF)
  59.       {
  60.       }
  61.    }
  62. }
  64. /**************************************************************/
  65. /* le type "operation" */
  66. struct operation
  67. {
  68.    double montant;
  69.    int type;                    /* NO_OP, OUVERTURE... */
  70.    time_t date;                 /* date au format "systeme" */
  71. };
  73. /* le type "compte" */
  74. struct compte
  75. {
  76.    int numero;
  77.    char titulaire[LONG_TITU];
  78.    int etat;                    /* LIBRE, OUVERT, CLOS */
  79.    double solde;
  80.    struct operation ops[NB_OPS];
  81. };
  82. /* NB : dans le tableau ops, les operations sont classees par */
  83. /* ordre de saisie decroissant, la derniere operation saisie */
  84. /* est toujours ops[0] */
  86. /* le type "agence" */
  87. struct agence
  88. {
  89.    double solde;
  90.    int num_prochain_compte;
  91.    struct compte comptes[MAX_COMPTES];
  92. };
  94. /**************************************************************/
  95. /* fonction d'initialisation de l'agence                      */
  96. /**************************************************************/
  97. /* -ed-
  98. void raz_agence (struct agence *ag)
  100. Fonction non exportee, donc 'static'
  101. */
  102. static void raz_agence (struct agence *ag)
  103. {
  104.    int i;
  106.    ag->solde = 0.;
  107.    ag->num_prochain_compte = 0;
  108.    for (i = 0; i < MAX_COMPTES; i++)
  109.       ag->comptes[i].etat = LIBRE;
  110. }
  112. /* fonction de remise a zero d'un compte (utilise par purge)  */
  113. static void raz_compte (struct compte *cpt)
  114. {
  115.    int i;
  117.    cpt->numero = 0;
  118.    memset (cpt->titulaire, 0, LONG_TITU);
  119.    cpt->etat = 0;
  120.    cpt->solde = 0.;
  121.    for (i = 0; i < NB_OPS; i++)
  122.    {
  123.       cpt->ops[i].montant = 0.;
  124.       cpt->ops[i].type = NO_OP;
  125.       cpt->ops[i].date = 0;
  126.    }
  127. }
  129. /**************************************************************/
  130. /* fonctions de lecture/ecriture d'une agence dans un fichier */
  131. /**************************************************************/
  132. /* -ed-
  133. int charge_agence (char *nomfichier, struct agence *ag)
  135. voir main()
  136. */
  137. static int charge_agence (char const *nomfichier, struct agence *ag)
  138. {
  139.    FILE *pf;
  140.    size_t sz;
  141.    int status;
  143.    /* on ouvre le fichier en lecture seule */
  144.    pf = fopen (nomfichier, "r" );
  145.    if (pf == NULL)
  146.       return -1;
  147.    sz = sizeof (struct agence);
  148.    /* on lit une structure de taille sz que l'on */
  149.    /* stocke a l'adresse indiquee par ag */
  150.    if (fread (ag, sz, 1, pf) == 1)
  151.       status = 0;
  152.    else
  153.       status = -1;
  154.    fclose (pf);
  155.    return status;
  156. }
  158. /* -ed-
  159. int sauve_agence (char *nomfichier, struct agence *ag)
  161. voir main().
  162. */
  163. static int sauve_agence (char const *nomfichier, struct agence *ag)
  164. {
  165.    FILE *pf;
  166.    size_t sz;
  167.    int status;
  169.    /* on ouvre le fichier en (re)ecriture */
  170.    pf = fopen (nomfichier, "w" );
  171.    if (pf == NULL)
  172.       return -1;
  173.    sz = sizeof (struct agence);
  174.    /* on ecrit la structure de taille sz stockee */
  175.    /* a l'adresse indiquee par ag */
  176.    if (fwrite (ag, sz, 1, pf) == 1)
  177.       status = 0;
  178.    else
  179.       status = -1;
  180.    fclose (pf);
  181.    return status;
  182. }
  184. /*******************************************************/
  185. /* Diverses fonctions de recherche                     */
  186. /*******************************************************/
  187. /* le resultat est l'adresse du compte, NULL en cas de */
  188. /* non-existence du compte. Attention : le compte peut */
  189. /* etre CLOS ! */
  191. /* fonction de recherche d'un compte par son numero    */
  192. static struct compte *cherche_cpt_num (struct agence *ag, int numcpt)
  193. {
  194.    int i;
  196.    for (i = 0; i < MAX_COMPTES; i++)
  197.       if (((ag->comptes[i].etat == OUVERT) ||
  198.            (ag->comptes[i].etat == CLOS)) &&
  199.           (ag->comptes[i].numero == numcpt))
  200.          return &(ag->comptes[i]);
  201.    return 0;
  202. }
  204. /* fonction de recherche d'un compte par son titulaire */
  205. static struct compte *cherche_cpt_titu (struct agence *ag, char *titu)
  206. {
  207.    int i;
  209.    for (i = 0; i < MAX_COMPTES; i++)
  210.       if (((ag->comptes[i].etat == OUVERT) ||
  211.            (ag->comptes[i].etat == CLOS)) &&
  212.           (!strcmp (ag->comptes[i].titulaire, titu)))
  213.          return &(ag->comptes[i]);
  214.    return 0;
  215. }
  217. /* fonction de recherche d'un compte libre             */
  218. static struct compte *cherche_cpt_libre (struct agence *ag)
  219. {
  220.    int i;
  222.    for (i = 0; i < MAX_COMPTES; i++)
  223.       if (ag->comptes[i].etat == LIBRE)
  224.          return &(ag->comptes[i]);
  225.    return 0;
  226. }
  228. /*******************************************************/
  229. /* fonctions de traitement                             */
  230. /*******************************************************/
  232. /* ouverture d'un compte pour titu a la date t         */
  233. /* la fonction rend : numero de compte si tout est OK, */
  234. /* -1 si l'agence est "complete", -2 si le titulaire a */
  235. /* deja un compte                                      */
  236. static int traite_ouverture (struct agence *ag, char *titu, time_t t)
  237. {
  238.    int i;
  239.    struct compte *cpt;
  241.    /* on verifie d'abord que le titulaire n'a pas */
  242.    /* deja un compte                              */
  243.    cpt = cherche_cpt_titu (ag, titu);
  244.    if (cpt)
  245.       return -2;
  246.    cpt = cherche_cpt_libre (ag);
  247.    if (!cpt)
  248.       return -1;
  249.    /* on remplit les champs du compte cree */
  250.    cpt->numero = ag->num_prochain_compte++;
  251.    strncpy (cpt->titulaire, titu, LONG_TITU - 1);
  252.    cpt->etat = OUVERT;
  253.    cpt->solde = 0.;
  254.    /* on remplit l'operation 0 de type OUVERTURE */
  255.    cpt->ops[0].type = OUVERTURE;
  256.    cpt->ops[0].date = t;
  257.    cpt->ops[0].montant = 0.;
  258.    /* on remplit les operations suivantes avec NO_OP */
  259.    for (i = 1; i < NB_OPS; i++)
  260.       cpt->ops[i].type = NO_OP;
  261.    return cpt->numero;
  262. }
  264. /* fonction de traitement de l'operation op sur le compte */
  265. /* de numero numcpt de l'agence ag (op != OUVERTURE)      */
  266. static int traite_operation (struct agence *ag, int numcpt,
  267.                              struct operation *op)
  268. {
  269.    int i;
  270.    struct compte *cpt;
  272.    /* on cherche le compte de numero numcpt */
  273.    cpt = cherche_cpt_num (ag, numcpt);
  274.    /* test de validite : compte inexistant ou CLOS */
  275.    if ((cpt == 0) || (cpt->etat == CLOS))
  276.       return -1;
  277.    switch (op->type)
  278.    {
  279.    case DEPOT:
  280.       cpt->solde += op->montant;
  281.       ag->solde += op->montant;
  282.       break;
  283.    case RETRAIT:
  284.       if (cpt->solde < op->montant)
  285.          return -1;
  286.       cpt->solde -= op->montant;
  287.       ag->solde -= op->montant;
  288.       break;
  289.    case CLOTURE:
  290.       if (cpt->solde != 0)
  291.          return -1;
  292.       cpt->etat = CLOS;
  293.       break;
  294.    default:
  295.       return -1;
  296.    }
  297.    /* on "decale" les operations du tableau ops */
  298.    for (i = NB_OPS - 2; i >= 0; i--)
  299.       cpt->ops[i + 1] = cpt->ops[i];
  300.    cpt->ops[0] = *op;
  301.    return 0;
  302. }
  304. /* fonction d'affichage du solde de l'agence             */
  305. static void solde_agence (struct agence *ag)
  306. {
  307.    printf ("Le solde de l'agence est %.2f\n", ag->solde);
  308. }
  310. /* fonction de "purge" de l'agence : libere les comptes  */
  311. /* CLOS avant la date t */
  312. static void purge_agence (struct agence *ag, time_t t)
  313. {
  314.    int i, nb;
  316.    for (i = 0, nb = 0; i < MAX_COMPTES; i++)
  317.       /* si le compte est CLOS, et que la cloture a eu */
  318.       /* lieu avant "cur", on remet a zero le compte */
  319.       if ((ag->comptes[i].etat == CLOS) && (ag->comptes[i].ops[0].date < t))
  320.       {
  321.          printf ("Purge du compte %d\n", ag->comptes[i].numero);
  322.          raz_compte (&(ag->comptes[i]));
  323.          nb++;
  324.       }
  325.    printf ("%d comptes purges\n", nb);
  326. }
  328. /* effectue un releve de l'operation op. le format est :    */
  329. /* JJ/MM/AAAA HH:MM ouverture/cloture/[depot,retrait] de XX */
  330. /* on utilise localtime pour convertir les dates            */
  331. static void releve_operation (struct operation *op)
  332. {
  333.    struct tm *d;
  335.    if (op->type == NO_OP)
  336.       return;
  337.    d = localtime (&(op->date));
  338.    if (d == 0)
  339.       fputs ("\tXX/XX/XXXX XX:XX ", stdout);
  340.    else
  341.       printf ("\t%02d/%02d/%04d %02d:%02d ",
  342.               d->tm_mday, d->tm_mon + 1, d->tm_year + 1900,
  343.               d->tm_hour, d->tm_min);
  344.    switch (op->type)
  345.    {
  346.    case OUVERTURE:
  347.       fputs ("ouverture\n", stdout);
  348.       return;
  349.    case CLOTURE:
  350.       fputs ("cloture\n", stdout);
  351.       return;
  352.    case DEPOT:
  353.       printf ("depot de %.2f E\n", op->montant);
  354.       return;
  355.    case RETRAIT:
  356.       printf ("retrait de %.2f E\n", op->montant);
  357.       return;
  358.    }
  359. }
  361. /* fonction de releve du compte de numero numcpt           */
  362. /* on affiche les informations du compte, puis les NB_OPS  */
  363. /* (au plus) dernieres operations                          */
  364. static int releve_compte (struct agence *ag, int numcpt)
  365. {
  366.    struct compte *cpt;
  367.    int i;
  369.    cpt = cherche_cpt_num (ag, numcpt);
  370.    if (!cpt)
  371.       return -1;
  372.    printf ("Titulaire : %s\n", cpt->titulaire);
  373.    printf ("Compte %d", cpt->numero);
  374.    if (cpt->etat == CLOS)
  375.       fputs (" [CLOTURE]\n", stdout);
  376.    else
  377.       printf (", solde %.2f E\n", cpt->solde);
  378.    for (i = NB_OPS - 1; i >= 0; i--)
  379.       releve_operation (&(cpt->ops[i]));
  380.    return 0;
  381. }
  383. /*********************************************************/
  384. /* Diverses fonctions de saisie au clavier               */
  385. /* ces fonctions rendent -1 en cas d'annulation (CTRL-D  */
  386. /* frappe au clavier), sinon elles insistent indefiniment*/
  387. /* pour avoir une saisie "correcte"                      */
  388. /*********************************************************/
  389. static int saisie_num_cpt (void)
  390. {
  391.    int num;
  392.    char rep[128];
  394.    for (;;)
  395.    {
  396.       fputs ("Numero de compte" " (CTRL-D pour annuler) ? ", stdout);
  397.       if (!fgets (rep, sizeof rep, stdin))
  398.       {
  399.          /* -ed- fonction non standard. */
  400.          clearerr (stdin);
  401.          return -1;
  402.       }
  403.       fclean (rep, stdin);
  404.       if (sscanf (rep, "%d", &num) == 1)
  405.          return num;
  406.    }
  407. }
  409. static int saisie_code_op (void)
  410. {
  411.    char rep[1024];
  413.    for (;;)
  414.    {
  415.       fputs ("D(epot), R(etrait), C(loture)"
  416.              " (CTRL-D pour annuler) ? ", stdout);
  417.       if (!fgets (rep, sizeof rep, stdin))
  418.       {
  419.          clearerr (stdin);
  420.          return -1;
  421.       }
  422.       fclean (rep, stdin);
  423.       switch (rep[0])
  424.       {
  425.       case 'D':
  426.          return DEPOT;
  427.       case 'R':
  428.          return RETRAIT;
  429.       case 'C':
  430.          return CLOTURE;
  431.       default:
  432.          break;
  433.       }
  434.    }
  435. }
  437. static int saisie_titulaire (char *titu, size_t size)
  438. {
  439.    fputs ("Titulaire (CTRL-D pour annuler) ? ", stdout);
  440.    if (!fgets (titu, size, stdin))
  441.    {
  442.       clearerr (stdin);
  443.       return -1;
  444.    }
  445.    fclean (titu, stdin);
  446.    return 0;
  447. }
  449. static int saisie_montant (double *v)
  450. {
  451.    char rep[32];
  453.    for (;;)
  454.    {
  455.       fputs ("Montant" " (CTRL-D pour annuler) ? ", stdout);
  456.       if (!fgets (rep, sizeof rep, stdin))
  457.       {
  458.          clearerr (stdin);
  459.          return -1;
  460.       }
  461.       fclean (rep, stdin);
  462.       if (sscanf (rep, "%lf", v) == 1)
  463.          return 1;
  464.    }
  465. }
  467. /* fonction de saisie de date                            */
  468. /* la date est saisie sous la forme JJ/MM/AAAA HH:MM     */
  469. /* la fonction propose la date courante, si l'utilisateur*/
  470. /* ne tape rien (<Return> ou CTRL-D), on accepte cette   */
  471. /* date courante                                         */
  472. static time_t saisie_date (void)
  473. {
  474.    time_t t;
  475.    struct tm *d, buf;
  476.    char rep[32];
  478.    for (;;)
  479.    {
  480.       t = time (0);
  481.       d = localtime (&t);
  482.       fputs ("Date ", stdout);
  483.       if (d)
  484.          printf ("(%02d/%02d/%04d %02d:%02d) ? ",
  485.                  d->tm_mday, 1 + d->tm_mon, d->tm_year + 1900,
  486.                  d->tm_hour, d->tm_min);
  487.       if (!fgets (rep, sizeof rep, stdin) || (rep[0] == '\n'))
  488.       {
  489.          clearerr (stdin);
  490.          return t;
  491.       }
  492.       fclean (rep, stdin);
  493.       if (sscanf (rep, " %d/%d/%d %d:%d",
  494.                   &(buf.tm_mday), &(buf.tm_mon), &(buf.tm_year),
  495.                   &(buf.tm_hour), &(buf.tm_min)) == 5)
  496.       {
  497.          buf.tm_mon--;
  498.          buf.tm_year -= 1900;
  499.          buf.tm_sec = 0;
  500.          buf.tm_isdst = -1;
  501.          return mktime (&buf);
  502.       }
  503.    }
  504. }
  506. /*********************************************************/
  507. /* Les differents menus pour saisir les infos et traiter */
  508. /*********************************************************/
  509. static void menu_recherche (struct agence *ag)
  510. {
  511.    char titu[LONG_TITU];
  512.    struct compte *cpt;
  513.    int num;
  515.    for (;;)
  516.    {
  517.       puts ("[Comptes/Recherche de compte]" );
  518.       if (saisie_titulaire (titu, sizeof titu) == -1)
  519.          return;
  520.       cpt = cherche_cpt_titu (ag, titu);
  521.       if (cpt)
  522.       {
  523.          printf ("compte %d, titulaire %s\n", cpt->numero, cpt->titulaire);
  524.          return;
  525.       }
  526.       /* on essaie d'interpreter le titulaire */
  527.       /* comme un numero de compte            */
  528.       if (sscanf (titu, "%d", &num) == 1)
  529.       {
  530.          cpt = cherche_cpt_num (ag, num);
  531.          if (cpt)
  532.          {
  533.             printf ("compte %d, titulaire %s\n", cpt->numero, cpt->titulaire);
  534.             return;
  535.          }
  536.       }
  537.       fputs ("NON TROUVE\n", stdout);
  538.       return;
  539.    }
  540. }
  542. static void menu_saisie_op (struct agence *ag)
  543. {
  544.    struct operation op;
  545.    int num_cpt;
  547.    for (;;)
  548.    {
  549.       puts ("[Comptes/Saisie d'operation]" );
  550.       num_cpt = saisie_num_cpt ();
  551.       if (num_cpt == -1)
  552.          return;
  553.       op.type = saisie_code_op ();
  554.       if (op.type == -1)
  555.          return;
  556.       if (op.type != CLOTURE)
  557.          if (saisie_montant (&(op.montant)) == -1)
  558.             return;
  559.       op.date = saisie_date ();
  560.       if (traite_operation (ag, num_cpt, &op) == -1)
  561.          printf ("Echec du traitement !\n" );
  562.       else
  563.          printf ("Traitement effectue !\n" );
  564.       return;
  565.    }
  566. }
  568. static void menu_releve (struct agence *ag)
  569. {
  570.    int num_cpt;
  572.    for (;;)
  573.    {
  574.       puts ("[Comptes/Releve de compte]" );
  575.       num_cpt = saisie_num_cpt ();
  576.       if (num_cpt == -1)
  577.          return;
  578.       if (releve_compte (ag, num_cpt) == -1)
  579.          fputs ("COMPTE INEXISTANT\n", stdout);
  580.       return;
  581.    }
  583. }
  585. static void menu_ouverture (struct agence *ag)
  586. {
  587.    char titu[LONG_TITU];
  588.    int num;
  589.    time_t t;
  591.    for (;;)
  592.    {
  593.       puts ("[Comptes/Ouverture]" );
  594.       if (saisie_titulaire (titu, sizeof titu) == -1)
  595.          return;
  596.       t = saisie_date ();
  597.       switch (num = traite_ouverture (ag, titu, t))
  598.       {
  599.       case -2:
  600.          puts ("CE TITULAIRE A DEJA UN COMPTE" );
  601.          return;
  602.       case -1:
  603.          puts ("L'AGENCE EST COMPLETE" );
  604.          return;
  605.       default:
  606.          printf ("compte %d cree\n", num);
  607.          return;
  608.       }
  609.    }
  610. }
  612. static void menu_purge (struct agence *ag)
  613. {
  614.    time_t tpurge;
  615.    char dummy[4];
  617.    puts ("[ATTENTION : purge des comptes (CTRL-D pour annuler)]" );
  618.    if (!fgets (dummy, sizeof dummy, stdin))
  619.    {
  620.       clearerr (stdin);
  621.       return;
  622.    }
  623.    fclean (dummy, stdin);
  624.    tpurge = saisie_date ();
  625.    purge_agence (ag, tpurge);
  626. }
  628. static void menu_comptes (struct agence *ag)
  629. {
  630.    char rep[4];
  631.    int choix;
  633.    for (;;)
  634.    {
  635.       puts ("[Comptes]" );
  636.       puts ("(1) recherche d'un numero de compte" );
  637.       puts ("(2) saisie d'une operation" );
  638.       puts ("(3) releve de compte" );
  639.       puts ("(4) ouverture de compte" );
  640.       puts ("(0) sortie" );
  641.       fputs ("--> ", stdout);
  642.       if (!fgets (rep, 1024, stdin))
  643.       {
  644.          clearerr (stdin);
  645.          return;
  646.       }
  647.       fclean (rep, stdin);
  648.       if (sscanf (rep, "%d", &choix) != 1)
  649.          continue;
  650.       switch (choix)
  651.       {
  652.       case 0:
  653.          return;
  654.       case 1:
  655.          menu_recherche (ag);
  656.          break;
  657.       case 2:
  658.          menu_saisie_op (ag);
  659.          break;
  660.       case 3:
  661.          menu_releve (ag);
  662.          break;
  663.       case 4:
  664.          menu_ouverture (ag);
  665.          break;
  666.       default:
  667.          printf ("Mauvais choix %s !\n", rep);
  668.          break;
  669.       }
  670.    }
  671. }
  673. static void menu_principal (struct agence *ag)
  674. {
  675.    char rep[4];
  676.    int choix;
  678.    for (;;)
  679.    {
  680.       puts ("(1) consultation du solde agence" );
  681.       puts ("(2) acces au menu 'comptes'" );
  682.       puts ("(3) purge des comptes" );
  683.       puts ("(4) SORTIE IMMEDIATE SANS SAUVEGARDE" );
  684.       puts ("(5) remise a zero de l'agence" );
  685.       printf ("(0) sortie\n--> " );
  686.       if (!fgets (rep, sizeof rep, stdin))
  687.       {
  688.          clearerr (stdin);
  689.          continue;
  690.       }
  691.       fclean (rep, stdin);
  692.       if (sscanf (rep, "%d", &choix) != 1)
  693.          continue;
  694.       switch (choix)
  695.       {
  696.       case 0:
  697.          return;
  698.       case 1:
  699.          solde_agence (ag);
  700.          break;
  701.       case 2:
  702.          menu_comptes (ag);
  703.          break;
  704.       case 3:
  705.          menu_purge (ag);
  706.          break;
  707.       case 4:
  708.          exit (1);
  709.           /*NOTREACHED*/ return;
  710.       case 5:
  711.          raz_agence (ag);
  712.          break;
  713.       default:
  714.          break;
  715.       }
  716.    }
  717.    return;
  718. }
  720. int main (int argc, char *argv[])
  721. {
  722. /* -ed-
  723. char *fic_agence;
  725. attention, une chaine litterale n'est pas modifiable.
  726. Il est preferable de qualifier en const (lecture seule).
  727. */
  728.    char const *fic_agence;
  730.    struct agence ag;
  732.    if (argc == 1)
  733.       fic_agence = "agence.dat";
  734.    else
  735.       fic_agence = argv[1];
  736.    if (charge_agence (fic_agence, &ag) == -1)
  737.    {
  738.       char rep[4];
  739.       perror (fic_agence);
  740.       printf ("Initialise une agence vide (o/n) ?\n" );
  741.       if (fgets (rep, sizeof rep, stdin) == NULL)
  742.       {
  743.          perror ("stdin" );
  744.          fprintf (stderr, "STOP !!!\n" );
  745.          return 2;
  746.       }
  747.       fclean (rep, stdin);
  748.       if (rep[0] == 'o' || rep[0] == 'O' || rep[0] == 'y' || rep[0] == 'Y')
  749.          raz_agence (&ag);
  750.       else
  751.       {
  752.          fprintf (stderr, "STOP !!!\n" );
  753.          return 2;
  754.       }
  755.    }
  756.    menu_principal (&ag);
  757.    if (sauve_agence (fic_agence, &ag) == -1)
  758.    {
  759.       perror (fic_agence);
  760.       return 1;
  761.    }
  762.    return 0;
  763. }


Au fait, pas une ligne sur ton histoire de mot de passe. De plus, c'est pas très clair. il y a déjà unproblème de spec. En effet, Un mot de passe 'cient' n'a de sens que si le client consulte son compte. Or
d'une part, l'ergonomie est pas organisée en 'client/action', mais en action/client ce qui veut dire demander le numéro de lient à cjhaque opération.
 
Si il s'agit d'ajouter une fonction 'consultation par le client, il faut imaginer une succession d'écrans comme ceci :  


Mon compte
-----------
 
- Compte existant
Nom :  
Mot de passe :  
 
- Nouveau compte
Nom :  
Mot de passe :  
Confirmation mot de passe :  
 
Opérations
----------
- Consultation
- Impression solde
- Impression relevé
- Quitter


quelque chose comme ça.
 
C'est à dire totalement autre chose (une autre application en faite) mais qui travaille sur le même fichier que celui de la banque.
 
C'est une application de gestion classique...


Message édité par -ed- le 04-12-2006 à 21:03:05

---------------
Emmanuel Delahaye
Des infos sur la programmation et le langage C:
http://bien-programmer.blogspot.com/  
http://mapage.noos.fr/emdel/
n°17987
cmoila
Profil : Membre
Posté le 05-12-2006 à 20:52:04  profilanswer