API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 19th, 2014
136
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 33.88 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <math.h>
  5.  
  6. #include "main.h"
  7.  
  8. // Mai eliminare i file .dat,servono per il corretto funzionamento del programma
  9.  
  10. Globale* piatto;
  11. Scontrino tavolo[15];
  12. int numpiatti = 0;
  13.  
  14. int main()
  15. {
  16.     int i, scelta=10;
  17.  
  18.     // Carica dal file num.dat il numero di piatti presente in list.dat
  19.     FILE* numeropiatti;
  20.     numeropiatti = fopen("num.dat", "rb");
  21.     if (!numeropiatti) {
  22.         printf("Errore: impossibile aprire il file num.dat.");
  23.         exit(-1);
  24.     }
  25.     fread(&numpiatti, sizeof(int), 1, numeropiatti);
  26.     fclose(numeropiatti);
  27.     //printf("numpiatti %d", numpiatti); // per vedere se carica correttamente
  28.  
  29.     piatto = calloc(numpiatti, sizeof(Globale));
  30.  
  31.     // Carica dal file binario list.dat un numero di piatti pari a numpiatti, ricavato precedentemente
  32.     FILE* lista_piatti;
  33.     lista_piatti = fopen("list.dat", "rb");
  34.     if (!lista_piatti) {
  35.         printf("Errore: impossibile aprire il file list.dat.");
  36.         exit(-1);
  37.     }
  38.     fread(piatto, sizeof(Globale), numpiatti, lista_piatti);
  39.     fclose(lista_piatti);
  40.     //printf(" %s", piatto[1].nome); // per vedere se carica correttamente
  41.  
  42.     // Inizializzo l'array degli scontrini con un valore neutro usato per triggerare operazioni future
  43.     for (i=0;i<15;i++) tavolo[i].ID = 16;
  44.  
  45.     do {
  46.  
  47.         pulisci_schermata();
  48.         printf("Benvenuto nel programma di gestione del ristorante.\n\n");
  49.         printf("- Gestione menu' -\n\n");
  50.         printf("(1) Aggiungi un nuovo piatto\n");
  51.         printf("(2) Modifica un piatto esistente\n");
  52.         printf("(3) Elimina un piatto esistente\n");
  53.         printf("(4) Visualizza l'elenco dei piatti\n");
  54.         printf("(5) Cerca nell'elenco dei piatti\n");
  55.         printf("\n- Gestione cassa -\n\n");
  56.         printf("(6) Crea un nuovo scontrino al tavolo\n");
  57.         printf("(7) Aggiungi un ordine al tavolo\n");
  58.         printf("(8) Stampa scontrino\n");
  59.         printf("\n- Altre opzioni -\n\n");
  60.         printf("(9) Esci dal programma\n\n");
  61.         printf("Digita a schermo il numero dell'operazione da eseguire: ");
  62.         scanf("%d", &scelta);
  63.  
  64.         if (scelta == 1) {aggiungi_piatto(); scelta=10;}
  65.  
  66.         if (scelta == 2) {modifica_piatto(); scelta=10;}
  67.  
  68.         if (scelta == 3) {elimina_piatto(); scelta=10;}
  69.  
  70.         if (scelta == 4) {visualizza_elenco(); scelta=10;}
  71.  
  72.         if (scelta == 5) {cerca_in_elenco(); scelta=10;}
  73.  
  74.         if (scelta == 6) {crea_nuovo_scontrino(); scelta=10;}
  75.  
  76.         if (scelta == 7) {aggiungi_ordine(); scelta=10;}
  77.  
  78.         if (scelta == 8) {stampa_scontrino(); scelta=10;}
  79.  
  80.         if (scelta == 9) {
  81.             printf("\n--------------------------------------------------------\n");
  82.             printf("\nGrazie per aver utilizzato il programma, buona giornata!\n");
  83.             printf("\n--------------------------------------------------------\n");
  84.             free(piatto);
  85.             return 0;
  86.         }
  87.     }while (scelta<1 || scelta>9);
  88.     return 0;
  89. }
  90.  
  91. /* Portabilità. La funzione pulisce lo schermosia in winzozz che linux */
  92. void pulisci_schermata() {
  93.     #ifdef _WIN32
  94.         system("cls");
  95.     #endif
  96.     #ifdef linux
  97.         system("clear");
  98.     #endif
  99. }
  100.  
  101. /* Carica la lista dei piatti precedentemente salvata,si occupa quindi di aggiungerne uno alla fine della lista,salvando poi i file*/
  102.  
  103. void aggiungi_piatto() {
  104.     piatto = realloc(piatto, (numpiatti+1) * sizeof(Globale)); // Preparo la memoria necessaria al nuovo piatto
  105.  
  106.     int i, tipopiatto, esiste=0; // Variabili di trigger varie
  107.  
  108.     printf("\n--------------------------------------------------------\n");
  109.     printf("\n- INSERIMENTO NUOVO PIATTO -\n\n");
  110.  
  111.     piatto[numpiatti].ID = numpiatti;
  112.  
  113.     while (esiste == 0) {
  114.         printf("Inserisci il nome del piatto: ");
  115.         scanf("%s", piatto[numpiatti].nome);
  116.         esiste = 1;
  117.         for (i=0;i<numpiatti;i++)
  118.  
  119.             esiste *= strcmp(piatto[i].nome, piatto[numpiatti].nome);
  120.  
  121.    while (scelta<1 || scelta>9)     /*  Come funziona il for alla riga di codice precedente:
  122.             strcmp(s1, s2) compara le stringhe restituendo un valore numerico intero.
  123.             Questo intero è positivo o negativo se le stringhe sono diverse tra loro.
  124.             La funzione restituisce zero se queste due stringhe sono uguali tra loro.
  125.             Moltiplicare una variabile intera per l'intero restituito dalla funzione
  126.             ci farà avere come risultato zero solo nel caso che vengano scoperte due
  127.             stringhe uguali tra loro tra tutte quelle dell'elenco. Non succederà mai
  128.             che capiti più di una moltiplicazione per zero poiché dovrebbero esserci
  129.             più di due occorrenze dello stesso nome, il che è impossibile. */
  130.  
  131.         if (esiste == 0) printf("Il nome inserito e' gia' presente all'interno dell'elenco dei piatti.\n");
  132.     }
  133.  
  134.     printf("Inserisci la tipologia, seguendo le istruzioni.\n");
  135.     printf("Scrivi 0 per antipasto.\nScrivi 1 per primo.\nScrivi 2 per secondo.\nScrivi 3 per contorno.\nScrivi 4 per dessert.\n");
  136.     printf("Inserisci ora la tipologia scelta: ");
  137.     scanf("%d", &tipopiatto);
  138.     if (tipopiatto == 0) piatto[numpiatti].tipologia = antipasto;
  139.     if (tipopiatto == 1) piatto[numpiatti].tipologia = primo;
  140.     if (tipopiatto == 2) piatto[numpiatti].tipologia = secondo;
  141.     if (tipopiatto == 3) piatto[numpiatti].tipologia = contorno;
  142.     if (tipopiatto == 4) piatto[numpiatti].tipologia = dessert;
  143.     printf("Inserisci il primo ingrediente del piatto: ");
  144.     scanf("%s", piatto[numpiatti].ingredienti[0]);
  145.     printf("Inserisci il secondo ingrediente: ");
  146.     scanf("%s", piatto[numpiatti].ingredienti[1]);
  147.     printf("Inserisci il terzo: ");
  148.     scanf("%s", piatto[numpiatti].ingredienti[2]);
  149.     printf("Inserisci il prezzo, scrivendolo in formato numerico usando il punto e due cifre decimali (esempio: 2.00): ");
  150.     scanf("%f", &piatto[numpiatti].prezzo);
  151.     numpiatti++;
  152.  
  153.     FILE* totpiatti;
  154.     totpiatti = fopen("num.dat", "wb");
  155.     if (!totpiatti) exit(-1);
  156.     fwrite(&numpiatti, sizeof(int), 1, totpiatti);
  157.     fclose(totpiatti);
  158.  
  159.     FILE* listapiatti;
  160.     listapiatti = fopen("list.dat", "wb");
  161.     if (!listapiatti) exit(-1);
  162.     fwrite(piatto, sizeof(Globale), numpiatti, listapiatti);
  163.     fclose(listapiatti);
  164.  
  165.     printf("Inserimento completato.\n");
  166.  
  167.     printf("-----------------------\n");
  168.     printf("Premi Invio per tornare al menu'.");
  169.     fflush(stdin);
  170.     getchar();
  171.     /* fflush() pulisce il buffer per far sì che getchar() richieda effettivamente un carattere,
  172.        anziché accontentarsi del \n posto automaticamente dal sistema per via dell'ultimo scanf. */
  173. }
  174.  
  175. /* La funzione di modifica chiede all'utente di inserire il numero (l'ID) del piatto da modificare e
  176.    dopo aver controllato il valore permette la modifica di tutti i campi del piatto. Il piatto viene
  177.    salvato solo a modifica conclusa, poiché il file binario viene trascritto solo dopo l'inserimento. */
  178. void modifica_piatto() {
  179.     int i, visualizza=2, modifica, tipopiatto;
  180.  
  181.     printf("\n--------------------------------------------------------\n");
  182.     printf("\n- MODIFICA PIATTO ESISTENTE -\n\n");
  183.  
  184.     while (visualizza != 0 && visualizza != 1) {
  185.         printf("Per modificare un piatto hai bisogno di conoscere il suo numero identificativo.\nPrima di proseguire, vuoi visualizzare l'elenco dei piatti?\nScrivi 1 per accettare, oppure 0 per proseguire: ");
  186.         scanf("%d", &visualizza);
  187.     }
  188.     if (visualizza == 1) {
  189.         for (i=0;i<numpiatti;i++) printf("- Piatto numero %d - Nome: %s\n", piatto[i].ID, piatto[i].nome);
  190.     }
  191.     printf("\nInserisci il numero identificativo del piatto da modificare: ");
  192.     scanf("%d", &modifica);
  193.  
  194.     if (modifica > 0 && modifica < numpiatti) {// Il valore inserito è un piatto effettivo in elenco, si può proseguire
  195.  
  196.         // INIZIO BLOCCO DI CODICE PRINCIPALE
  197.         printf("Inserisci il nuovo nome del piatto: ");
  198.         scanf("%s", piatto[modifica].nome);
  199.         printf("Inserisci la nuova tipologia, secondo lo schema seguente.\n");
  200.         printf("Scrivi 0 per antipasto.\nScrivi 1 per primo.\nScrivi 2 per secondo.\nScrivi 3 per contorno.\nScrivi 4 per dessert.\n");
  201.         printf("Inserisci ora la nuova tipologia scelta: ");
  202.         scanf("%d", &tipopiatto);
  203.         if (tipopiatto == 0) piatto[modifica].tipologia = antipasto;
  204.         if (tipopiatto == 1) piatto[modifica].tipologia = primo;
  205.         if (tipopiatto == 2) piatto[modifica].tipologia = secondo;
  206.         if (tipopiatto == 3) piatto[modifica].tipologia = contorno;
  207.         if (tipopiatto == 4) piatto[modifica].tipologia = dessert;
  208.         printf("Inserisci il nuovo primo ingrediente del piatto: ");
  209.         scanf("%s", piatto[modifica].ingredienti[0]);
  210.         printf("Inserisci il nuovo secondo ingrediente: ");
  211.         scanf("%s", piatto[modifica].ingredienti[1]);
  212.         printf("Inserisci il nuovo terzo: ");
  213.         scanf("%s", piatto[modifica].ingredienti[2]);
  214.         printf("Inserisci il nuovo prezzo, scrivendolo in formato numerico usando il punto e due cifre decimali (esempio: 2.00): ");
  215.         scanf("%f", &piatto[modifica].prezzo);
  216.  
  217.         // Salvo l'intero vettore nel file binario, una volta terminata la sua modifica
  218.         FILE* listapiatti;
  219.         listapiatti = fopen("list.dat", "wb");
  220.         if (!listapiatti) exit(-1);
  221.         fwrite(piatto, sizeof(Globale), numpiatti, listapiatti);
  222.         fclose(listapiatti);
  223.  
  224.         printf("Modifica completata.\n");
  225.         // FINE BLOCCO DI CODICE PRINCIPALE
  226.     }
  227.     else printf("Il numero di piatto inserito non e' presente in elenco. Ricomincia il procedimento.\n");
  228.  
  229.     printf("-----------------------\n");
  230.     printf("Premi Invio per tornare al menu'.");
  231.     fflush(stdin);
  232.     getchar();
  233.     /* fflush() pulisce il buffer per far sì che getchar() richieda effettivamente un carattere,
  234.        anziché accontentarsi del \n posto automaticamente dal sistema per via dell'ultimo scanf. */
  235. }
  236.  
  237. /* La funzione elimina un piatto dall'elenco (fornito all'utente), in base al suo ID.
  238.    Eliminato il piatto gli indici del vettore shiftano di 1 dal punto eliminato fino
  239.    all'ultimo membro del vettore, la memoria dinamica viene diminuita e alla fine si
  240.    salva nuovamente l'intera lista tutta assieme nel file binario. */
  241. void elimina_piatto() {
  242.     int i, visualizza=2, elimina;
  243.  
  244.     printf("\n--------------------------------------------------------\n");
  245.     printf("\n- ELIMINAZIONE PIATTO ESISTENTE -\n\n");
  246.  
  247.     while (visualizza != 0 && visualizza != 1) {
  248.         printf("Per eliminare un piatto hai bisogno di conoscere il suo numero identificativo.\nPrima di proseguire, vuoi visualizzare l'elenco dei piatti?\nScrivi 1 per accettare, oppure un altro numero per proseguire: ");
  249.         scanf("%d", &visualizza);
  250.     }
  251.     if (visualizza == 1) {
  252.         for (i=0;i<numpiatti;i++) printf("- Piatto numero %d - Nome: %s\n", piatto[i].ID, piatto[i].nome);
  253.     }
  254.     printf("\nInserisci il numero identificativo del piatto da eliminare: ");
  255.     scanf("%d", &elimina);
  256.  
  257.     if (elimina > 0 && elimina < numpiatti) { // Il valore inserito è compreso nell'intervallo dei piatti, si può proseguire
  258.  
  259.         // INIZIO BLOCCO DI CODICE PRINCIPALE
  260.         for (i=elimina;i<numpiatti;i++) {
  261.             piatto[i] = piatto[i+1];
  262.             piatto[i].ID--;
  263.         }
  264.         numpiatti--;
  265.         piatto = realloc(piatto, (numpiatti) * sizeof(Globale));
  266.  
  267.         FILE* totpiatti;
  268.         totpiatti = fopen("num.dat", "wb");
  269.         if (!totpiatti) exit(-1);
  270.         fwrite(&numpiatti, sizeof(int), 1, totpiatti);
  271.         fclose(totpiatti);
  272.  
  273.         FILE* listapiatti;
  274.         listapiatti = fopen("list.dat", "wb");
  275.         if (!listapiatti) exit(-1);
  276.         fwrite(piatto, sizeof(Globale), numpiatti, listapiatti);
  277.         fclose(listapiatti);
  278.  
  279.         printf("Eliminazione completata.\n");
  280.         // FINE BLOCCO DI CODICE PRINCIPALE
  281.  
  282.     }
  283.  
  284.     printf("-----------------------\n");
  285.     printf("Premi Invio per tornare al menu'.");
  286.     fflush(stdin);
  287.     getchar();
  288.     /* fflush() pulisce il buffer per far sì che getchar() richieda effettivamente un carattere,
  289.        anziché accontentarsi del \n posto automaticamente dal sistema per via dell'ultimo scanf. */
  290. }
  291.  
  292. /* La funzione più semplice di tutte. Selezionare il quarto
  293.    comando fa visualizzare l'elenco completo dei piatti con
  294.    tutti i dati per ogni singolo. */
  295. void visualizza_elenco() {
  296.     int i;
  297.  
  298.     printf("\n--------------------------------------------------------\n");
  299.     printf("\n- VISUALIZZAZIONE ELENCO -\n\n");
  300.  
  301.     for (i=0;i<numpiatti;i++) {
  302.         printf("-----------------------\n");
  303.         printf("- Piatto numero %d\n", piatto[i].ID);
  304.         printf("Nome: %s\n", piatto[i].nome);
  305.         printf("Tipologia: ");
  306.         switch (piatto[i].tipologia) {
  307.             case antipasto:
  308.                 printf("Antipasto\n");
  309.                 break;
  310.             case primo:
  311.                 printf("Primo\n");
  312.                 break;
  313.             case secondo:
  314.                 printf("Secondo\n");
  315.                 break;
  316.             case contorno:
  317.                 printf("Contorno\n");
  318.                 break;
  319.             case dessert:
  320.                 printf("Dessert\n");
  321.         }
  322.         printf("Ingrediente 1: %s\n", piatto[i].ingredienti[0]);
  323.         // Stampa gli ingredienti 2 e 3 solo se non sono stringhe vuote
  324.         if (strlen(piatto[i].ingredienti[1]) != 0) printf("Ingrediente 2: %s\n", piatto[i].ingredienti[1]);
  325.         if (strlen(piatto[i].ingredienti[2]) != 0) printf("Ingrediente 3: %s\n", piatto[i].ingredienti[2]);
  326.         printf("Prezzo: %.2f euro\n", piatto[i].prezzo);
  327.     }
  328.     printf("Stampa elenco completata.\n");
  329.  
  330.     printf("-----------------------\n");
  331.     printf("Premi Invio per tornare al menu'.");
  332.     fflush(stdin);
  333.     getchar();
  334.     /* fflush() pulisce il buffer per far sì che getchar() richieda effettivamente un carattere,
  335.        anziché accontentarsi del \n posto automaticamente dal sistema per via dell'ultimo scanf. */
  336. }
  337.  
  338. /* cerca_in_elenco() è simile alla funzione di semplice visualizzazione dei piatti
  339.    poiché sfrutta bene o male lo stesso codice, con la differenza che la lista dei
  340.    piatti viene ricavata in base ad una comparazione tra la stringa fatta inserire
  341.    dall'utente e l'elenco degli ingredienti dei piatti. */
  342. void cerca_in_elenco() {
  343.     int i, numtrovati=0, *trovati=NULL;
  344.     char cerca[100];
  345.  
  346.     trovati = (int *) calloc(numtrovati, sizeof(int));
  347.  
  348.     printf("\n--------------------------------------------------------\n");
  349.     printf("\n- RICERCA IN ELENCO TRAMITE INGREDIENTE -\n\n");
  350.  
  351.     printf("\nInserisci il nome dell'ingrediente da cercare (minuscole e maiuscole fanno differenza): ");
  352.     scanf("%s", cerca);
  353.  
  354.     for (i=0;i<numpiatti;i++) {
  355.         if (strcmp(cerca, piatto[i].ingredienti[0]) == 0 ||
  356.             strcmp(cerca, piatto[i].ingredienti[1]) == 0 ||
  357.             strcmp(cerca, piatto[i].ingredienti[2]) == 0) {
  358.                 numtrovati++;
  359.                 trovati = (int *) realloc(trovati, (numtrovati) * sizeof(int));
  360.                 trovati[numtrovati-1] = piatto[i].ID;
  361.         }
  362.     }
  363.  
  364.     if (numtrovati == 0) printf("\nNessun risultato trovato.\n");
  365.     else {
  366.         printf("\nStampa dell'elenco dei risultati trovati (hai cercato '%s'): ", cerca);
  367.         for (i=0;i<numtrovati;i++) {
  368.  
  369.         printf("-----------------------\n");
  370.         printf("- Piatto numero %d\n", piatto[trovati[i]].ID);
  371.         printf("Nome: %s\n", piatto[trovati[i]].nome);
  372.         printf("Tipologia: ");
  373.         switch (piatto[trovati[i]].tipologia) {
  374.             case antipasto:
  375.                 printf("Antipasto\n");
  376.                 break;
  377.             case primo:
  378.                 printf("Primo\n");
  379.                 break;
  380.             case secondo:
  381.                 printf("Secondo\n");
  382.                 break;
  383.             case contorno:
  384.                 printf("Contorno\n");
  385.                 break;
  386.             case dessert:
  387.                 printf("Dessert\n");
  388.         }
  389.         printf("Ingrediente 1: %s\n", piatto[trovati[i]].ingredienti[0]);
  390.         if (strlen(piatto[trovati[i]].ingredienti[1]) != 0) printf("Ingrediente 2: %s\n", piatto[trovati[i]].ingredienti[1]);
  391.         if (strlen(piatto[trovati[i]].ingredienti[2]) != 0) printf("Ingrediente 3: %s\n", piatto[trovati[i]].ingredienti[2]);
  392.         printf("Prezzo: %.2f euro\n", piatto[trovati[i]].prezzo);
  393.         }
  394.  
  395.     }
  396.  
  397.     printf("Stampa elenco risultati completata.\n");
  398.     free(trovati);
  399.  
  400.     printf("-----------------------\n");
  401.     printf("Premi Invio per tornare al menu'.");
  402.     fflush(stdin);
  403.     getchar();
  404.     /* fflush() pulisce il buffer per far sì che getchar() richieda effettivamente un carattere,
  405.        anziché accontentarsi del \n posto automaticamente dal sistema per via dell'ultimo scanf. */
  406. }
  407.  
  408. /* Svolti i controlli sul numero (se esiste almeno un tavolo libero, se non è già
  409.    stato aperto il tavolo, se il tavolo inserito supera l'intervallo) la funzione
  410.    si preoccupa di predisporre un valore del vettore tavolo[] (con indice - 1 per
  411.    via degli indici del vettore poiché vanno da 0 a max - 1) in modo che abbia la
  412.    possibilità di accettare degli ordini al suo interno. */
  413. void crea_nuovo_scontrino() {
  414.     int i, numscontrino, liberi=0, esiste=0;
  415.     printf("\n--------------------------------------------------------\n");
  416.     printf("\n- CREAZIONE NUOVO SCONTRINO AL TAVOLO -\n\n");
  417.  
  418.     // Cerca un tavolo libero (dove libero = valore 16 pre-impostato)
  419.     for (i=0;i<15;i++) if (tavolo[i].ID == 16) liberi++;
  420.     if (liberi > 0) { // Esiste almeno un tavolo accessibile, l'esecuzione può proseguire
  421.  
  422.         printf("\nInserisci il numero del tavolo di cui creare il nuovo scontrino: ");
  423.         scanf("%d", &numscontrino);
  424.  
  425.         // Controlla che il tavolo non sia già stato aperto
  426.         for (i=0;i<15;i++) if (tavolo[i].ID == numscontrino) esiste=1;
  427.         if (numscontrino > 0 && numscontrino < 16) {
  428.             if (esiste == 0) { // Se il tavolo non è già stato aperto, si può proseguire
  429.  
  430.                 // INIZIO BLOCCO DI CODICE PRINCIPALE
  431.                 // Il tavolo numero 1 avrà ID = 0, il tavolo 15 avrà ID = 14.
  432.                 tavolo[numscontrino-1].ID = numscontrino;
  433.                 // Inizializzo l'array degli ordini usando un valore predefinito che userò in seguito come trigger.
  434.                 for (i=0;i<100;i++) tavolo[numscontrino-1].ordini[i] = 200;
  435.  
  436.                 printf("\nCreazione nuovo scontrino completata.\nUtilizza la funzione 7 per aggiungere ordini allo scontrino.\n");
  437.                 // FINE DEL BLOCCO DI CODICE PRINCIPALE
  438.  
  439.             }
  440.             else printf("\nIl tavolo da te inserito possiede gia' uno scontrino aperto. Chiudilo prima di aprirne uno nuovo.\n");
  441.         }
  442.         else printf("\nIl numero da te inserito supera l'intervallo 1-15, non esiste un tavolo relativo a quel valore.\n");
  443.     }
  444.     else printf("\nTutti gli scontrini disponibili sono stati aperti. Prima di aprirne uno nuovo, chiudine il precedente.\n");
  445.  
  446.     printf("-----------------------\n");
  447.     printf("Premi Invio per tornare al menu'.");
  448.     fflush(stdin);
  449.     getchar();
  450.     /* fflush() pulisce il buffer per far sì che getchar() richieda effettivamente un carattere,
  451.        anziché accontentarsi del \n posto automaticamente dal sistema per via dell'ultimo scanf. */
  452. }
  453.  
  454. /* Svolti i dovuti controlli (se almeno un tavolo è accessibile, se il tavolo scelto
  455.    è aperto, se il patto scelto per l'ordine esiste) la funzione aggiunge alla lista
  456.    del tavolo scelto l'ordine inserito dall'utente in base al suo ID. */
  457. void aggiungi_ordine() {
  458.     int aperti=0, esiste=0, esistepiatto=0, i, j, numtavolo, numordine, indice=100, visualizza;
  459.  
  460.     printf("\n--------------------------------------------------------\n");
  461.     printf("\n- AGGIUNTA ORDINE AL TAVOLO -\n\n");
  462.  
  463.     // Cerca un tavolo aperto
  464.     for (i=0;i<15;i++) if (tavolo[i].ID != 16) aperti++;
  465.     if (aperti > 0) { // Esiste almeno un tavolo aperto, posso proseguire
  466.         printf("Inserisci il numero del tavolo a cui aggiungere un ordine: ");
  467.         scanf("%d", &numtavolo);
  468.  
  469.         // Cerco il tavolo scelto dall'utente nella lista
  470.         for (i=0;i<15;i++) if (tavolo[i].ID == numtavolo) esiste=1;
  471.         if (esiste == 1) { // Il tavolo scelto e' stato gia' aperto, posso proseguire
  472.             // Le tre righe successive stampano a scelta dell'utente la lista dei piatti
  473.             printf("Per aggiungere un ordine hai bisogno di conoscere il suo numero identificativo.\nPrima di proseguire, vuoi visualizzare l'elenco dei piatti?\nScrivi 1 per accettare, oppure un altro numero per proseguire: ");
  474.             scanf("%d", &visualizza);
  475.             if (visualizza == 1) for (i=0;i<numpiatti;i++) printf("- Piatto numero %d - Nome: %s\n", piatto[i].ID, piatto[i].nome);
  476.  
  477.             printf("Inserisci il numero del piatto da aggiungere come ordine: ");
  478.             scanf("%d", &numordine);
  479.  
  480.             // Cerco il piatto inserito nella lista dei piatti
  481.             for (i=0;i<numpiatti;i++) if (piatto[i].ID == numordine) esistepiatto=1;
  482.             if (esistepiatto == 1) { // Il piatto inserito esiste, si può proseguire
  483.  
  484.                 // INIZIO BLOCCO DI CODICE PRINCIPALE
  485.                 for (i=0;i<numpiatti;i++) {
  486.                     if (piatto[i].ID == numordine) {
  487.                         // Trovato il piatto, ed allora lo aggiungo al primo indice libero più piccolo
  488.                         for (j=99;j>=0;j--) if (tavolo[numtavolo-1].ordini[j] == 200) indice--;
  489.                         // printf("l'indice e' %d", indice);
  490.                         tavolo[numtavolo-1].ordini[indice] = numordine;
  491.                         // Ora il tavolo contiene l'ID dell'ordine, cioé del piatto
  492.                     }
  493.                 }
  494.                 printf("\nAggiunta nuovo ordine completata.\nUtilizza la funzione 8 per stampare lo scontrino o la 7 per aggiungere un altro piatto.\n");
  495.                 // FINE BLOCCO DI CODICE PRINCIPALE
  496.  
  497.             }
  498.             else printf("\nIl numero di piatto inserito non e' presente nella lista. Ricominciare il processo di aggiunta.\n");
  499.         }
  500.         else printf("\nPer il tavolo selezionato non e' ancora stato aperto uno scontrino. Aprine uno prima di proseguire.\n");
  501.     }
  502.     else printf("\nPer nessun tavolo e' stato ancora aperto uno scontrino. Aprine uno prima di proseguire.\n");
  503.  
  504.     printf("-----------------------\n");
  505.     printf("Premi Invio per tornare al menu'.");
  506.     fflush(stdin);
  507.     getchar();
  508.     /* fflush() pulisce il buffer per far sì che getchar() richieda effettivamente un carattere,
  509.        anziché accontentarsi del \n posto automaticamente dal sistema per via dell'ultimo scanf. */
  510. }
  511.  
  512. /* La funzione più complessa, si preoccupa, una volta fatti i dovuti controlli (se esistono scontrini
  513.    aperti e se lo scontrino scelto dall'utente è aperto) recupera la lista di ordini e, dopo che l'ha
  514.    organizzata nel vettore struttura per contare le occorrenze, restituisce la stampa dello scontrino
  515.    sia su console che sui due files di testo. Al termine dell'operazione, resetta lo scontrino. */
  516. void stampa_scontrino() {
  517.     // occtipologia[5] si basa sullo stesso ordine dell'enumerazione
  518.     int aperti=0, esiste=0, occorrenzetot=0, i, j, k, numscontrino, occtipologia[5]={0,0,0,0,0};
  519.     Numerordine* occorrenze;
  520.     float totale=0;
  521.  
  522.     occorrenze = calloc(numpiatti, sizeof(Numerordine));
  523.  
  524.     printf("\n--------------------------------------------------------\n");
  525.     printf("\n- STAMPA E CHIUSURA SCONTRINO -\n");
  526.  
  527.     for (i=0;i<15;i++) if (tavolo[i].ID != 16) aperti++;
  528.  
  529.     if (aperti > 0) { // Almeno uno scontrino è già stato aperto, posso proseguire
  530.         printf("\nInserisci il numero del tavolo di cui stampare a schermo lo scontrino: ");
  531.         scanf("%d", &numscontrino);
  532.  
  533.         for (i=0;i<15;i++) if (tavolo[i].ID == numscontrino) esiste=1;
  534.  
  535.         if (esiste == 1) { // Il numero di tavolo inserito possiede uno scontrino aperto, posso proseguire
  536.             // Resetto le occorrenze per la stampa dello scontrino
  537.             for (i=0;i<numpiatti;i++) occorrenze[i].ID = piatto[i].ID;
  538.  
  539.             // TODO: I VARI CONTROLLI
  540.  
  541.             // INIZIO BLOCCO DI CODICE PRINCIPALE
  542.             for (i=0;i<100;i++) {
  543.                 if (tavolo[numscontrino-1].ordini[i] != 200) {
  544.                     // Faccio un controllo al quadrato per verificare le occorrenze degli ordini e nel caso cerco l'ID da incrementare
  545.                     for (j=0;j<100;j++) {
  546.                         if (tavolo[numscontrino-1].ordini[i] == tavolo[numscontrino-1].ordini[j]) {
  547.                             for (k=0;k<numpiatti;k++) {
  548.                                 if (occorrenze[k].ID == tavolo[numscontrino-1].ordini[i]) {
  549.                                     occorrenze[k].occorrenze++;
  550.                                     occorrenzetot++;
  551.                                     // printf("Aggiunta occorrenza del piatto con ID %d\n", tavolo[numscontrino-1].ordini[i]);
  552.                                 }
  553.                             }
  554.                         }
  555.                     }
  556.                 }
  557.             }
  558.  
  559.             if (occorrenzetot > 0) { // Esiste almeno un ordine nello scontrino, si può proseguire
  560.  
  561.                 /* Dato che il numero delle occorrenze esce sempre al quadrato, mi basta ricavarne la radice.
  562.                    In aggiunta, controllo le occorrenze trovate ed aumento il numero delle tipologie trovate.*/
  563.                 for (k=0;k<numpiatti;k++) if (occorrenze[k].occorrenze != 0) {
  564.                     occorrenze[k].occorrenze = sqrt(occorrenze[k].occorrenze);
  565.  
  566.                     switch (piatto[occorrenze[k].ID].tipologia) {
  567.                         case antipasto:
  568.                             occtipologia[0]++;
  569.                             break;
  570.                         case primo:
  571.                             occtipologia[1]++;
  572.                             break;
  573.                         case secondo:
  574.                             occtipologia[2]++;
  575.                             break;
  576.                         case contorno:
  577.                             occtipologia[3]++;
  578.                             break;
  579.                         case dessert:
  580.                             occtipologia[4]++;
  581.                             break;
  582.                     }
  583.                 }
  584.  
  585.                 /* for (j=0;j<numpiatti;j++) printf("Il piatto con ID %d e' stato ordinato %d volte\n", occorrenze[j].ID, occorrenze[j].occorrenze); */
  586.  
  587.                 // Comincio la stampa sui due files
  588.  
  589.                 FILE* scontrino = NULL;
  590.                 scontrino = fopen("scontrino.txt", "w");
  591.                 FILE* registro = NULL;
  592.                 registro = fopen("registro.txt", "a");
  593.  
  594.                 fprintf(scontrino, "\nTavolo: %d\n\n", numscontrino);
  595.                 fprintf(registro, "\nTavolo: %d\n\n", numscontrino);
  596.                 printf("\nTavolo: %d\n\n", numscontrino);
  597.  
  598.                 if (occtipologia[0] > 0) {
  599.                     fprintf(scontrino, "Antipasti: \n");
  600.                     fprintf(registro, "Antipasti: \n");
  601.                     printf("Antipasti: \n");
  602.                     for (k=0;k<numpiatti;k++) {
  603.                         if (piatto[occorrenze[k].ID].tipologia == antipasto && occorrenze[k].occorrenze > 0) {
  604.                             fprintf(scontrino, "- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  605.                             fprintf(registro, "- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  606.                             printf("- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  607.                         }
  608.                     }
  609.                 }
  610.  
  611.                 if (occtipologia[1] > 0) {
  612.                     fprintf(scontrino, "Primi: \n");
  613.                     fprintf(registro, "Primi: \n");
  614.                     printf("Primi: \n");
  615.                     for (k=0;k<numpiatti;k++) {
  616.                         if (piatto[occorrenze[k].ID].tipologia == primo && occorrenze[k].occorrenze > 0) {
  617.                             fprintf(scontrino, "- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  618.                             fprintf(registro, "- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  619.                             printf("- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  620.                         }
  621.                     }
  622.                 }
  623.  
  624.                 if (occtipologia[2] > 0) {
  625.                     fprintf(scontrino, "Secondi: \n");
  626.                     fprintf(registro, "Secondi: \n");
  627.                     printf("Secondi: \n");
  628.                     for (k=0;k<numpiatti;k++) {
  629.                         if (piatto[occorrenze[k].ID].tipologia == secondo && occorrenze[k].occorrenze > 0) {
  630.                             fprintf(scontrino, "- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  631.                             fprintf(registro, "- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  632.                             printf("- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  633.                         }
  634.                     }
  635.                 }
  636.  
  637.                 if (occtipologia[3] > 0) {
  638.                     fprintf(scontrino, "Contorni: \n");
  639.                     fprintf(registro, "Contorni: \n");
  640.                     printf("Contorni: \n");
  641.                     for (k=0;k<numpiatti;k++) {
  642.                         if (piatto[occorrenze[k].ID].tipologia == contorno && occorrenze[k].occorrenze > 0) {
  643.                             fprintf(scontrino, "- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  644.                             fprintf(registro, "- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  645.                             printf("- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  646.                         }
  647.                     }
  648.                 }
  649.  
  650.                 if (occtipologia[4] > 0) {
  651.                     fprintf(scontrino, "Desserts: \n");
  652.                     fprintf(registro, "Desserts: \n");
  653.                     printf("Desserts: \n");
  654.                     for (k=0;k<numpiatti;k++) {
  655.                         if (piatto[occorrenze[k].ID].tipologia == dessert && occorrenze[k].occorrenze > 0) {
  656.                             fprintf(scontrino, "- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  657.                             fprintf(registro, "- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  658.                             printf("- %d x %s - euro %.2f\n", occorrenze[k].occorrenze, piatto[occorrenze[k].ID].nome, piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze);
  659.                         }
  660.                     }
  661.                 }
  662.  
  663.                 for (k=0;k<numpiatti;k++) if (occorrenze[k].occorrenze != 0) totale += piatto[occorrenze[k].ID].prezzo*occorrenze[k].occorrenze;
  664.  
  665.                 fprintf(scontrino, "\nImporto parziale: %.2f\n", totale);
  666.                 fprintf(registro, "\nImporto parziale: %.2f\n", totale);
  667.                 printf("\nImporto parziale: %.2f\n", totale);
  668.  
  669.                 if (totale > 40.00) {
  670.                     fprintf(scontrino, "Valore sconto (10%%): %.2f\n", totale*0.10);
  671.                     fprintf(scontrino, "Importo totale: %.2f\n", totale*0.90);
  672.                     fprintf(registro, "Valore sconto (10%%): %.2f\n", totale*0.10);
  673.                     fprintf(registro, "Importo totale: %.2f\n", totale*0.90);
  674.                     printf("Valore sconto (10%%): %.2f\n", totale*0.10);
  675.                     printf("Importo totale: %.2f\n", totale*0.90);
  676.                 }
  677.  
  678.                 fprintf(registro, "-----------------------\n\n");
  679.  
  680.                 fclose(scontrino);
  681.                 fclose(registro);
  682.                 free(occorrenze);
  683.  
  684.                 // Resetto l'ID del tavolo
  685.                 tavolo[numscontrino-1].ID = 16;
  686.                 // Re-imposto i valori dell'array in modo che non compaiano come nuovi ordini
  687.                 for (i=0;i<100;i++) tavolo[numscontrino-1].ordini[i] = 200;
  688.  
  689.                 printf("Stampa dello scontrino completata.\nControlla i files scontrino.txt e registro.txt.\n\n");
  690.                 // FINE BLOCCO DI CODICE PRINCIPALE
  691.  
  692.             }
  693.             else printf("\nNello scontrino non e' presente alcun ordine. Inserire un ordine prima di proseguire.\n");
  694.         }
  695.         else printf("\nIl tavolo inserito non ha ancora uno scontrino aperto. Aprirne uno prima di proseguire.\n");
  696.     }
  697.     else printf("\nPer nessun tavolo e' stato ancora aperto uno scontrino. Aprirne uno prima di proseguire.\n");
  698.  
  699.     printf("-----------------------\n");
  700.     printf("Premi Invio per tornare al menu'.");
  701.     fflush(stdin);
  702.     getchar();
  703.     /* fflush() pulisce il buffer per far sì che getchar() richieda effettivamente un carattere,
  704.        anziché accontentarsi del \n posto automaticamente dal sistema per via dell'ultimo scanf. */
  705. }
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!