API tools faq
paste
Advertisement
rekkylaws

TP10 SDA

rekkylaws
Apr 15th, 2020
685
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 13.40 KB | None | 0 0
raw download clone embed print report
  1. ////////////////////////// TP10
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include "prod.h"
  7.  
  8.  
  9.  
  10. /******** **********************************************************/
  11. /*    fonction : lireNumeroProchaineCommande                       */
  12. /*    description  : lire l'entier contenu dans le fichier     */
  13. /*  numNextFact                            */
  14. /*    paramètres : aucun                          */
  15. /*    retourne : un entier qui est le numero de la premiere        */
  16. /*      commande à traiter                    */
  17. /*    condition : le fichier numNextFact doit exister          */
  18. /*          dans le repertoire de l'exe        */
  19. /*    auteur : kub                         */
  20. /*    date : 29/3/20                           */
  21. /*******************************************************************/
  22. int lireNumeroProchaineCommande()
  23. {
  24. FILE *f;
  25. int N;
  26. f=fopen("numNextFact","r");
  27. fread(&N,sizeof(int),1,f);
  28. fclose(f);
  29. //printf("\n--->lu N=%d",N);
  30. return N;
  31. }
  32.  
  33.  
  34. /*******************************************************************/
  35. /*    fonction : convertirNenChaine4                               */
  36. /*    description  : convertir l'entier en une chaine          */
  37. /*    paramètre : N l'entier à convertir en chaine           */
  38. /*    paramètre : N4 la chaine contenant le resultat          */
  39. /*    retourne : RIEN                              */
  40. /*    condition : 1<=N<=9999                       */
  41. /*    condition : N4 doit etre une chaine de 5 char ou         */
  42. /*    auteur : kub                         */
  43. /*    date : 29/3/20                           */
  44. /*******************************************************************/
  45.  
  46. void convertirNenChaine4(int N,char *N4)
  47. { // si N=1234 alors N4 sera égal à "1234"
  48. int m,c,d,u;
  49. char cm,cc,cd,cu;//chiffre des milliers, chiffre des centaines ...
  50. m=N/1000;cm=48+m;
  51. N%=1000;
  52. c=N/100;cc=48+c;
  53. N%=100;
  54. d=N/10;cd=48+d;
  55. u=N%10;
  56. cu=48+u;
  57. N4[0]=cm;N4[1]=cc;N4[2]=cd;N4[3]=cu;N4[4]='\0';
  58. }
  59.  
  60.  
  61.  
  62. /*******************************************************************/
  63. /*    fonction : chercherReference  (à compléter)              */
  64. /*    paramètre : ref : la reference du produit           */
  65. /*               à rechercher dans produits.txt    */
  66. /*    paramètre : lib : chaine de caractere qui contiendra    */
  67. /*               le libelle du produit             */
  68. /*    retourne : le prix unitaire du produit                   */
  69. /*    condition : on suppose que la reference existe dans le       */
  70. /*              fichier produits.txt           */
  71. /*    auteur : kub                         */
  72. /*    date : 29/3/20                           */
  73. /*******************************************************************/
  74. float chercherReference(int ref,char *lib)
  75. {
  76. printf("%d",ref);
  77. printf("%s",lib);
  78. //à coder : ouvrir produits.txt en lecture , le parcourir jusqu'à
  79. // trouver la refence ref. Dans ce cas, on aura aussi son prix unitaire et son
  80. // libelle (qui seront renvoyés). On fermera alors le fichier produits.txt
  81. return 0;
  82. }
  83.  
  84.  
  85.  
  86.  
  87.  
  88.  
  89.  
  90.  
  91.  
  92.  
  93.  
  94.  
  95.  
  96. /*******************************************************************/
  97. /*    fonction : lireCommande   (à compléter)                      */
  98. /*    paramètre : pf l'adresse du fichier de commande à lire, nf correspondant a NNNN lle numéro du fichier en 4 charactères*/
  99. /*    retourne : RIEN                              */
  100. /*    auteur : kub                         */
  101. /*    date : 29/3/20                           */
  102. /*******************************************************************/
  103. void lireCommande(FILE * pf, const char *nf)// le fichier pointé par pf est deja ouvert
  104. {
  105. FILE *fProduit=fopen("produits.txt","r"); //on ouvre le fichier produits.txt contenant les references associées au noms des produits
  106. FILE *factureNNNN=NULL; //on prépare l'ouverture du fichier facture correspondant a la commande traitée
  107. char nomFacture[21];
  108. char nomClient[TAILLE];
  109. T_Produit scanP; //permet de comparer les produits de produits.txt aux produits des commandes
  110. T_Produit p;
  111. float prixTotal=0;
  112.  
  113. //on initialise notre produit de comparaison
  114. p.reference=0;
  115. p.prixU=0.0;
  116. strcpy(p.libelle,"??");
  117. p.quantite=0;
  118.  
  119. strcpy(nomFacture,"factures/facture"); //On met en place le nom complet du fichierde facture
  120. strcat(nomFacture, nf);
  121. strcat(nomFacture, ".txt");
  122. //printf("\n nom du fichier facture en production : %s\n",nomFacture); //Affichage de debug
  123.  
  124. factureNNNN=fopen(nomFacture,"w+");
  125.  
  126. fscanf(pf,"%s",nomClient);//la commande contient tjrs le nom du client
  127. // en premiere ligne
  128. fprintf(factureNNNN,"Client : %s",nomClient);
  129. do
  130.     {
  131.     // à partir de la ligne2, toutes les lignes sont en 2 morceaux :
  132.     // un int suivi d'un int
  133.     //2 chaines sont lues et implicitement converties en int
  134.     fscanf(pf,"%d %d",&(p.reference),&(p.quantite));
  135.         //printf("\n\tReference recupérée : %d, qte récupérée : %d",p.reference,p.quantite);
  136.     while(!feof(fProduit))
  137.     {
  138.         fscanf(fProduit,"%d %s %f",&scanP.reference,scanP.libelle,&scanP.prixU);
  139.         if(scanP.reference==p.reference)
  140.         {
  141.                 //printf("\nReference recupérée : %d, qte récupérée : %d",p.reference,p.quantite);
  142.             strcpy(p.libelle,scanP.libelle);
  143.             p.prixU=scanP.prixU;
  144.         }
  145.     }
  146.    
  147.    
  148.     //Partie 1 Etape 1 (voir sujet) : pour afficher la facture à l'écran
  149.     if (!feof(pf))
  150.         {
  151.         //printf("\n-->ref = %d  qtt=%d",p.reference,p.quantite);
  152.         prixTotal=prixTotal+(p.quantite*p.prixU);
  153.         fprintf(factureNNNN,"\n%d %s (PU=%f€) :: %f€",p.quantite,p.libelle,p.prixU,p.quantite*p.prixU);
  154.         // à écrire :
  155.         //p.prixU= chercherReference(p.reference,p.libelle);
  156.         //printf("\n\t-->lib = %s  prixUnit=%f",p.libelle,p.prixU);
  157.        
  158.         //calculez aussi puis afficher le total de la facture
  159.         rewind(fProduit);
  160.         }
  161.  
  162.  
  163.  
  164.     }while(!feof(pf));
  165.     prixTotal=prixTotal+(p.quantite*p.prixU);
  166.     fprintf(factureNNNN,"\n%d %s (PU=%f€) :: %f€",p.quantite,p.libelle,p.prixU,p.quantite*p.prixU);
  167.     fprintf(factureNNNN,"\n");
  168.     fprintf(factureNNNN,"\n\tTOTAL = %f€",prixTotal);
  169.  
  170.     fclose(fProduit);
  171.     fclose(factureNNNN);
  172.  
  173. }
  174.  
  175.  
  176.  
  177.  
  178.  
  179.  
  180. /*******************************************************************/
  181. /*    fonction : lireLesCommandes                              */
  182. /*    description  : ouvrir 1 par 1 tous les fichiers de commande  */
  183. /*    description  : (commandes pas encore traitées)          */
  184. /*    description  : appel à la fonction lireCommande pour chacune */
  185. /*           des commandes                 */
  186. /*    description  : mettre à jour le fichier numNextFact     */
  187. /*    paramètre : aucun                           */
  188. /*    retourne : RIEN                              */
  189. /*    condition : 1<=N<=9999                       */
  190. /*    condition : N4 doit etre une chaine de 5 char ou         */
  191. /*    auteur : kub                         */
  192. /*    date : 29/3/20                           */
  193. /*******************************************************************/
  194.  
  195. void lireLesCommandes() //cette fonction ouvre tous les fichiers commandeXXXX.txt avec XXXX démarrant à N lu dans numNextFact
  196. {
  197. FILE *ficCommande=NULL;
  198. int FINI=0;
  199. int N = lireNumeroProchaineCommande(); //numero de la premiere commande qui sera lue et traitee lors de cette execution
  200. char NNNN[5];
  201. char nomCommande[29];
  202.  
  203. do //ce do while prend fin dès que fichier commandeXXXX.txt est absent
  204.     {
  205.     strcpy(nomCommande,"./commandes/commande");//pour lire ds le bon repertoire
  206.     convertirNenChaine4(N,NNNN);//convertion d'un int en chaine de 4
  207.     //printf("\n==>%s<==",NNNN);
  208.     ficCommande=NULL;
  209.     strcat(nomCommande,NNNN);
  210.     strcat(nomCommande,".txt");//le nom du fichier est formé
  211.    
  212.     //printf("\n traitement de  %s",nomCommande);
  213.    
  214.     ficCommande=fopen(nomCommande,"rt");//mode rt = "read" et "text"
  215.     if (ficCommande!=NULL)
  216.         { // le fichier commandeNNNN.txt existe
  217.             printf("\n fichier %s present",nomCommande);
  218.             lireCommande(ficCommande,NNNN); // à vous de coder cette fonction lors de ce TP10
  219.             fclose(ficCommande);
  220.         }
  221.     else
  222.         {
  223.            
  224.             printf("\n -> toutes les commandes presentes ont ete traitees.\n");
  225.             FILE *f=fopen("numNextFact","w"); // on va ecrire la valeur de N dans numNextFact
  226.             fwrite(&N,1,sizeof(int),f);
  227.             fclose(f);
  228.            
  229.             FINI=1;
  230.                        
  231.         }
  232.  
  233.     N++;
  234.     }while(FINI==0);       
  235.  
  236. }
  237.  
  238. /*******************************************************************/
  239. /*    fonction : lireCommande2                     */
  240. /*    paramètre : voir lireCommande       */
  241. /*    retourne : RIEN                              */
  242. /*    auteur : rekky                           */
  243. /*    date : 29/3/20                           */
  244. /*******************************************************************/
  245. void lireCommande2(FILE * pf, const char *nf)// le fichier pointé par pf est deja ouvert
  246. {
  247. FILE *fProduit=fopen("produits.txt","r");
  248. FILE *factureNNNN=NULL;
  249. FILE *fStock=fopen("stock.txt","w+");
  250. char nomFacture[21];
  251. char nomClient[TAILLE];
  252. T_Produit scanP;
  253. T_Produit p;
  254. float prixTotal=0;
  255.  
  256. p.reference=0;
  257. p.prixU=0.0;
  258. strcpy(p.libelle,"??");
  259. p.quantite=0;
  260.  
  261. strcpy(nomFacture,"factures/facture");
  262. strcat(nomFacture, nf);
  263. strcat(nomFacture, ".txt");
  264. printf("\n nom du fichier facture en production : %s\n",nomFacture);
  265.  
  266. factureNNNN=fopen(nomFacture,"w+");
  267.  
  268. fscanf(pf,"%s",nomClient);//la commande contient tjrs le nom du client
  269. // en premiere ligne
  270. fprintf(factureNNNN,"Client : %s",nomClient);
  271. do
  272.     {
  273.     // à partir de la ligne2, toutes les lignes sont en 2 morceaux :
  274.     // un int suivi d'un int
  275.     //2 chaines sont lues et implicitement converties en int
  276.     fscanf(pf,"%d %d",&(p.reference),&(p.quantite));
  277.         //printf("\n\tReference recupérée : %d, qte récupérée : %d",p.reference,p.quantite);
  278.     while(!feof(fProduit))
  279.     {
  280.         fscanf(fProduit,"%d %s %f",&scanP.reference,scanP.libelle,&scanP.prixU);
  281.         if(scanP.reference==p.reference)
  282.         {
  283.                 //printf("\nReference recupérée : %d, qte récupérée : %d",p.reference,p.quantite);
  284.             strcpy(p.libelle,scanP.libelle);
  285.             p.prixU=scanP.prixU;
  286.         }
  287.     }
  288.    
  289.    
  290.     //Partie 1 Etape 1 (voir sujet) : pour afficher la facture à l'écran
  291.     if (!feof(pf))
  292.         {
  293.         //printf("\n-->ref = %d  qtt=%d",p.reference,p.quantite);
  294.         prixTotal=prixTotal+(p.quantite*p.prixU);
  295.         fprintf(factureNNNN,"\n%d %s (PU=%f€) :: %f€",p.quantite,p.libelle,p.prixU,p.quantite*p.prixU);
  296.         // à écrire :
  297.         //p.prixU= chercherReference(p.reference,p.libelle);
  298.         //printf("\n\t-->lib = %s  prixUnit=%f",p.libelle,p.prixU);
  299.        
  300.         //calculez aussi puis afficher le total de la facture
  301.        
  302.         }
  303.         else
  304.         {
  305.            
  306.         }
  307.  
  308.  
  309.  
  310.     }while(!feof(pf));
  311.     prixTotal=prixTotal+(p.quantite*p.prixU);
  312.     fprintf(factureNNNN,"\n%d %s (PU=%f€) :: %f€",p.quantite,p.libelle,p.prixU,p.quantite*p.prixU);
  313.     fprintf(factureNNNN,"\n");
  314.     fprintf(factureNNNN,"\n\tTOTAL = %f€",prixTotal);
  315.  
  316.     fclose(fProduit);
  317.     fclose(factureNNNN);
  318.     fclose(fStock);
  319.  
  320. }
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327. /*******************************************************************/
  328. /*    fonction : lireLesCommandes2                             */
  329. /*    condition : 1<=N<=9999                       */
  330. /*    condition : N4 doit etre une chaine de 5 char ou         */
  331. /*    auteur : rekky                           */
  332. /*    date : 11/04/2020                        */
  333. /*******************************************************************/
  334.  
  335. void lireLesCommandes2() //cette fonction ouvre tous les fichiers commandeXXXX.txt avec XXXX démarrant à N lu dans numNextFact
  336. {
  337. FILE *ficCommande=NULL;
  338. int FINI=0;
  339. int N = lireNumeroProchaineCommande(); //numero de la premiere commande qui sera lue et traitee lors de cette execution
  340. char NNNN[5];
  341. char nomCommande[29];
  342.  
  343. do //ce do while prend fin dès que fichier commandeXXXX.txt est absent
  344.     {
  345.     strcpy(nomCommande,"./commandes/commande");//pour lire ds le bon repertoire
  346.     convertirNenChaine4(N,NNNN);//convertion d'un int en chaine de 4
  347.     //printf("\n==>%s<==",NNNN);
  348.     ficCommande=NULL;
  349.     strcat(nomCommande,NNNN);
  350.     strcat(nomCommande,".txt");//le nom du fichier est formé
  351.    
  352.     //printf("\n traitement de  %s",nomCommande);
  353.    
  354.     ficCommande=fopen(nomCommande,"rt");//mode rt = "read" et "text"
  355.     if (ficCommande!=NULL)
  356.         { // le fichier commandeNNNN.txt existe
  357.             printf("\n fichier %s present",nomCommande);
  358.             lireCommande(ficCommande,NNNN); // à vous de coder cette fonction lors de ce TP10
  359.             fclose(ficCommande);
  360.         }
  361.     else
  362.         {
  363.            
  364.             printf("\n -> toutes les commandes presentes ont ete traitees.\n");
  365.             FILE *f=fopen("numNextFact","w"); // on va ecrire la valeur de N dans numNextFact
  366.             fwrite(&N,1,sizeof(int),f);
  367.             fclose(f);
  368.            
  369.             FINI=1;
  370.                        
  371.         }
  372.  
  373.     N++;
  374.     }while(FINI==0);       
  375.  
  376. }
  377.  
  378. /**************************************************************************/
  379. /*        TP10         */
  380. /**************************************************************************/
  381. int main()
  382. {
  383.     char chx;
  384.     printf("\nLe code de quelle partie du tp voulez vous executer ? (1 ou 2)\n");
  385.     scanf("%c",&chx);
  386. //ci dessous :
  387. // creation d un fichier d'un seul int nommé umNnextFact et contenant l'int 1
  388. // code à utiliser pour réinitialiser numNextFact à 1 si besoin au cours du TP
  389.     /*
  390.     FILE *f;int N=1;
  391.     f=fopen("numNextFact","w");
  392.     fwrite(&N,1,sizeof(int),f);
  393.     fclose(f);
  394.      */
  395.             //J'ai remplacé ces lignes de codes par un argument "reset" dans le fichier makefile qui permet de reinitialiser numNextFact
  396.             //Il suffit simplement de taper "make reset"
  397.  
  398.  
  399.  
  400.     if(chx=='1')
  401.     {
  402.         //PARTIE 1 du TP : sans Gestion de stock
  403.         lireLesCommandes();
  404.         //lecture de tous les fichiers commandeXXXX.txt (cette fonction doit
  405.         //produire les factures des commandes non traitées jusqu'à maintenant)   
  406.     }
  407.  
  408.     else if(chx=='2')
  409.     {
  410.         //PARTIE 2 du TP : même sujet que PARTIE 1 MAIS avec Gestion de stock
  411.                 //copiez coller votre travail précédent puis modifiez le  
  412.                 lireLesCommandes2();
  413.                 // le fichier stock.txt devra évoluer au fur et à mesure des commandes
  414.                 //traitees (voir explications dans le sujet)
  415.     }
  416.  
  417.     else
  418.     {
  419.         printf("La valeur saisie est incorrecte, veuillez recommencer\n");
  420.     }
  421.    
  422.  
  423.     printf("Fin de l'execution du programme\n");
  424.     return 0;
  425. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!