Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Gestione dei film - film v.1.5.5.c

film v.1.5.5.c

 Caricato da:
Scarica il programma completo

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/stat.h>
  5. #include <sys/types.h>
  6. #include <dirent.h>
  7. #include <fcntl.h>
  8. #include <unistd.h>
  9. #define LUNG_MAX_TITOLO 40  /*indica la lunghezza massima del titolo del film*/
  10. #define LUNG_MAX_NOMI 35    /*indica la lunghezza massima del cognome + nome di attori e regista*/
  11. #define LUNG_MAX_ANNO 4     /*indica la lunghezza massima di un anno*/
  12. #define NUM_MAX_FILM 10000  /*indica il numero di film per cui il Cont va avanti (è indicata la cifra ipotetica di 10.000)*/
  13. #define LINEE_PAR 10  /*sono le linee dei parametri quando si salvano nel file (n° parametri 8 + 2 linee vuote)*/
  14.  
  15. typedef char TipoTitolo[LUNG_MAX_TITOLO];
  16.  
  17. typedef enum {azione,avventura,commedia,drammatico,cartone_animato,sacro,documentario,spettacolo,concerto,porno,altro}TipoCategoria;
  18.        
  19. typedef enum {DVD,VHS,DivX}TipoSupporto;
  20.        
  21. typedef char TipoPersona [LUNG_MAX_NOMI];
  22.  
  23. typedef struct
  24. {
  25.         TipoTitolo Titolo;               /*titolo del film*/
  26.         TipoCategoria Categoria;         /*indica la categoria del film*/
  27.         TipoSupporto Supporto;           /*indica il supporto su qui è registrato il film*/
  28.         TipoTitolo NomeSupporto;         /*indica il nome del supporto su cui è presente il film*/
  29.         TipoPersona Attore1;             /*indica il nome dell'attore principale*/
  30.         TipoPersona Attore2;             /*indica il nome dell'attore secondario*/
  31.         TipoPersona Regista;             /*indica il nome del regista, se sono due quello del principale*/
  32.         int Anno;                   /*indica l'anno in cui è stato pubblicato il film*/
  33. } TipoFilm;
  34.        
  35. typedef struct EL
  36. {
  37.         TipoFilm Dato;
  38.         struct EL* Prossimo;
  39. } TipoElenco;
  40.      
  41. FILE* file_elenco_film;              /*punta al file dove sono contenuti i titoli dei film*/
  42. FILE* file_numero_film;              /*punta al file che contiene il numero di film registrati*/
  43.  
  44. TipoFilm AggiungiFilm (TipoTitolo Titolo);        /*serve ad aggiungere un film nell'elenco*/
  45.  
  46. int main ()
  47. {
  48.     TipoElenco* RiempiElenco (void);
  49.     /*restituisce un puntatore alla Testa dell'elenco di film*/
  50.     void NumeroFilmIn (void);
  51.     /*serve a indicare e stampare il numero di film inseriti e quelli rimasti da inserire*/
  52.     void VisualizzaFilm (void);
  53.     /*serve a caricare i film già salvati nel file e stamparli a schermo*/
  54.     TipoElenco* AggiungiNuovoFilm (void);
  55.     /*serve, una volta che si è già costruito un elenco di film, ad aggiungere uno o più film*/
  56.     void RicercaFilm (void);
  57.     /*serve a caricare i film dall'elenco e cercare un film con dei parametri inseriti dall'utente*/
  58.     void ModificaFilm (int SpazioInput);
  59.     /*serve a modificare il parametro di un film già inserito nell'elenco*/
  60.     void Disinstallazione (void);
  61.     /*serve a rimuovere tutti i file e cartelle del programma*/
  62.     DIR* trova_directory;                 /*serve a verificare l'esistenza della directory dove si salveranno i file*/
  63.    
  64.     TipoElenco* TestaElenco;
  65.     int SceltaOperazione;   /*serve per scegliere l'operazione da fare*/
  66.     char Vuoto[LUNG_MAX_NOMI];
  67.     int Error;                /*serve a contenere l'eventuale errore nella mkdir()*/
  68.     int Continua;             /*serve per continuare a modificare film*/
  69.     int SpazioInput;          /*se è stato modificato più di un film inserisce un Vuoto*/
  70.     char Risposta;            /*contiene s o n*/
  71.    
  72.     printf ("\n\n\t\tRACCOGLITORE FILM\n\n");
  73.    
  74.     trova_directory=opendir ("C://film");
  75.     if (trova_directory==NULL)
  76.     {
  77.        printf ("\nNon è stata trovata la directory \"C://film\" dove andranno salvati i file del programma.");
  78.        printf ("\nVerrà creata la directory necessaria al programma. Premi Enter\n");
  79.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  80.        Error=mkdir ("C://film");
  81.        if (Error==-1)
  82.        {
  83.                    printf ("\nErrore nella creazione della cartella.\n");
  84.                    printf ("\nPremere il tasto 'Esc' per uscire dal programma.\n\n");
  85.                    getch();
  86.                    return (0);
  87.        }
  88.        printf ("\nLa directory \"C://film\" è stata creata correttamente.\n");
  89.     }  
  90.    
  91.     file_elenco_film=fopen("C://film/elenco film.txt","r");
  92.     if (NULL==file_elenco_film)
  93.     {
  94.        printf ("\nNessun elenco di film trovato. Si verrà indirizzati direttamente alla creazione di un elenco. Premi Enter.\n");
  95.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  96.        TestaElenco=RiempiElenco();
  97.        fclose (file_elenco_film);
  98.        printf ("\nPremere il tasto 'Esc' per uscire dal programma.\n\n");
  99.        getch();
  100.        return (0);
  101.     }
  102.    
  103.     fclose (file_elenco_film);
  104.     closedir (trova_directory);
  105.    
  106.     printf ("\nScegliere cosa fare:");
  107.     printf ("\naggiungere un film (1), creare un elenco di film (2), visualizzare i film (3), cercare dei film (4), modificare un film (5), numero di film inseriti (6),   disinstallare il programma (7).");
  108.     printf ("\n\nDigitare la scelta:  ");
  109.     scanf ("%d",&SceltaOperazione);
  110.    
  111.     if (SceltaOperazione==1)
  112.     {
  113.        printf ("\nHai scelto di aggiungere un film. Premi Enter\n");
  114.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  115.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  116.        AggiungiNuovoFilm ();
  117.     }
  118.    
  119.     if (SceltaOperazione==2)
  120.     {
  121.        printf ("\nHai scelto di creare un elenco di film. Questo sostituira l'elenco già presente.\n");
  122.        printf ("Si è sicuri di voler continuare (s/n)?  ");
  123.        scanf ("%s",&Risposta);
  124.        if (Risposta=='s')
  125.        {
  126.           printf ("\n");
  127.           fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  128.           TestaElenco=RiempiElenco();
  129.        }
  130.        else if (Risposta=='n')
  131.        {
  132.             printf ("\n");
  133.             goto TerminaProg;
  134.        }
  135.     }
  136.    
  137.     if (SceltaOperazione==3)
  138.     {
  139.        printf ("\nHai scelto di vedere tutti i film inseriti nell'elenco. Premi Enter\n");
  140.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  141.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  142.        VisualizzaFilm ();
  143.     }
  144.    
  145.     if (SceltaOperazione==4)
  146.     {
  147.        printf ("\nHai scelto di cercare i film inseriti nell'elenco secondo un parametro. Premi Enter\n");
  148.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  149.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  150.        RicercaFilm ();
  151.     }
  152.    
  153.     if (SceltaOperazione==5)
  154.     {
  155.        printf ("\nHai scelto di modificare il parametro di un film scelto. Premi Enter\n");
  156.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  157.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  158.        SpazioInput=0;
  159.        do
  160.        {
  161.              ModificaFilm (SpazioInput);
  162.              printf ("\n\nVuoi modificare altri film?  ");
  163.              printf ("\n(Inserire un numero negativo per terminare l'input, uno positivo per avanzare) ");
  164.              scanf ("%d",&Continua);
  165.              if (Continua<0)
  166.              {
  167.                  printf ("\n\nModifiche terminate.\n\n");
  168.                  break;
  169.              }
  170.              ++SpazioInput;
  171.        } while (Continua>0);
  172.     }
  173.    
  174.     if (SceltaOperazione==6)
  175.     {
  176.        printf ("\nHai scelto di vedere il numero di film inseriti nell'elenco e i posti rimanenti. Premi Enter\n");
  177.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  178.        fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  179.        NumeroFilmIn();
  180.     }
  181.    
  182.     if (SceltaOperazione==7)
  183.     {
  184.        printf ("\nHai scelto di disinstallare il programma. Si è sicuri di voler continuare (s/n)?  ");
  185.        scanf ("%s",&Risposta);
  186.        if (Risposta=='s')
  187.        {
  188.           printf ("\n");
  189.           fgets (Vuoto,LUNG_MAX_NOMI,stdin);
  190.           Disinstallazione();
  191.        }
  192.        else if (Risposta=='n')
  193.        {
  194.             printf ("\n");
  195.             goto TerminaProg;
  196.        }  
  197.     }
  198.    
  199.     if ((SceltaOperazione >7) || (SceltaOperazione<1))
  200.     {
  201.        printf ("\nERRORE: Comando errato. Verificare il numero inserito.\n");
  202.     }
  203.    
  204.     TerminaProg:
  205.     printf ("\nPremere il tasto 'Esc' per uscire dal programma.\n\n");
  206.     getch();
  207.     return (0);
  208. }
  209. /***************************************************************************************************************/
  210. TipoElenco* RiempiElenco ()
  211. {
  212.           file_elenco_film=fopen ("C://film/elenco film.txt","w");
  213.           fclose (file_elenco_film);
  214.           file_numero_film=fopen ("C://film/numero film.txt","w");
  215.           fclose (file_numero_film);
  216.          
  217.           TipoElenco* Testa;   /*è la testa dell'elenco dei film*/
  218.           TipoElenco* NuovoFilm;           /*punta ad un nuovo film dell'elenco appena aggiunto*/
  219.           int Cont;   /*serve per tenere il conto dei film inseriti*/
  220.           int Input;
  221.           int ContFilm;       /*serve per contare il numero di film inseriti*/
  222.           char Vuoto[LUNG_MAX_NOMI];     /*serve per fare una fgets vuota (se no le successive non funzionano)*/
  223.          
  224.           Testa=NULL;
  225.           printf ("\nInserimento dei film:");
  226.           printf ("\nN.B.\tI campi Categoria e Supporto sono obbligatori. Negli altri campi, se non se ne è a conoscenza, possono essere immessi trattini.");
  227.           printf ("\n\tI campi coi trattini non saranno oggetto di ricerca. Premi Enter per continuare.\n");
  228.          
  229.           Cont=0;
  230.           ContFilm=0;
  231.          
  232.           while (Cont<NUM_MAX_FILM)
  233.           {
  234.                 if (Cont==NUM_MAX_FILM-1)
  235.                 {
  236.                    printf ("\n\nULTIMA possibilità di inserimento di film!!!\n\n");
  237.                 }
  238.                
  239.                 NuovoFilm=malloc (sizeof(TipoElenco));
  240.                
  241.                 fgets (Vuoto,LUNG_MAX_NOMI,stdin);    /*è una chiamata a vuoto che permette di azionare gli fgets successivi*/
  242.                
  243.                 printf ("\n\n\tFilm n§%d:",Cont+1);
  244.                 printf ("\n\nInserire il titolo del film:  ");
  245.                 fgets ((NuovoFilm->Dato.Titolo),LUNG_MAX_TITOLO,stdin);
  246.                 NuovoFilm->Dato=AggiungiFilm (NuovoFilm->Dato.Titolo);
  247.                 NuovoFilm->Prossimo=NULL;
  248.                 Testa=NuovoFilm;
  249.                 ++ContFilm;
  250.                 ++Cont;
  251.                
  252.                 printf ("\n\nVuoi inserire altri film?  ");
  253.                 printf ("\n(Inserire un numero negativo per terminare l'input, uno positivo per avanzare) ");
  254.                 scanf ("%d",&Input);
  255.                 if (Input<0)
  256.                 {
  257.                     printf ("\n\n\tBuona visione!\n\n");
  258.                     break;
  259.                 }
  260.           }
  261.          
  262.           if (Cont>=NUM_MAX_FILM)
  263.           {
  264.              printf ("\n\nCi dispiace ma NON è più possibile inserire film.\n\n");
  265.           }
  266.          
  267.           file_numero_film=fopen ("C://film/numero film.txt","a");
  268.           fprintf (file_numero_film,"%d",ContFilm);
  269.           fclose (file_numero_film);
  270.          
  271.           return (Testa);
  272.          
  273. }
  274. /***********************************************************************************************************/
  275. TipoFilm AggiungiFilm (TipoTitolo Titolo)
  276. {
  277.          TipoFilm Film;
  278.          int Categoria;           /*serve per raccogliere l'intero che rappresenta la categoria*/
  279.          int Supporto;            /*serve per raccogliere l'intero che rappresenta il supporto*/
  280.          char TipoSupporto;        /*contiene il tipo di supporto: dvd,vhs,...*/
  281.          int Anno;                /*serve per contenere l'anno di pubblicazione del film*/
  282.          char Vuoto[LUNG_MAX_NOMI];       /*serve per fare una fgets vuota (se no le successive non funzionano*/
  283.          
  284.          file_elenco_film=fopen ("C://film/elenco film.txt","a");
  285.          
  286.          strcpy (Film.Titolo,Titolo);
  287.          fputs (Film.Titolo,file_elenco_film);
  288.          
  289.          printf ("\nScegliere tra: azione (0), avventura (1), commedia (2), cartone animato (3), sacro (4), documentario (5), spettacolo (6), concerto (7), porno (8), altro (9)  ");
  290.          scanf ("%d",&Categoria);
  291.          while ((Categoria<0) || (Categoria>9))
  292.          {
  293.             printf ("\nIl numero inserito non corrisponde a nessuna categoria. Controllare e re-inserire.");
  294.             printf ("\nRe-inserire il numero della categoria:  ");
  295.             scanf ("%d",&Categoria);
  296.          }
  297.          if (Categoria==0)
  298.          {
  299.             Film.Categoria=azione;
  300.             fprintf (file_elenco_film,"azione\n");
  301.          }
  302.          if (Categoria==1)
  303.          {
  304.             Film.Categoria=avventura;
  305.             fprintf (file_elenco_film,"avventura\n");
  306.          }
  307.          if (Categoria==2)
  308.          {
  309.             Film.Categoria=commedia;
  310.             fprintf (file_elenco_film,"commedia\n");
  311.          }
  312.          if (Categoria==3)
  313.          {
  314.             Film.Categoria=cartone_animato;
  315.             fprintf (file_elenco_film,"cartone animato\n");
  316.          }
  317.          if (Categoria==4)
  318.          {
  319.             Film.Categoria=sacro;
  320.             fprintf (file_elenco_film,"sacro\n");
  321.          }
  322.          if (Categoria==5)
  323.          {
  324.             Film.Categoria=documentario;
  325.             fprintf (file_elenco_film,"documentario\n");
  326.          }
  327.          if (Categoria==6)
  328.          {
  329.             Film.Categoria=spettacolo;
  330.             fprintf (file_elenco_film,"spettacolo\n");
  331.          }
  332.          if (Categoria==7)
  333.          {
  334.             Film.Categoria=concerto;
  335.             fprintf (file_elenco_film,"concerto\n");
  336.          }
  337.          if (Categoria==8)
  338.          {
  339.             Film.Categoria=porno;
  340.             fprintf (file_elenco_film,"porno\n");
  341.          }
  342.          if (Categoria==9)
  343.          {
  344.             Film.Categoria=altro;
  345.             fprintf (file_elenco_film,"altro\n");
  346.          }
  347.          
  348.          printf ("\nInserire il tipo di supporto su cui è presente il film:");
  349.          printf ("\nScegliere tra: DVD (0), VHS (1), DivX (2)  ");
  350.          scanf ("%d",&Supporto);
  351.          while ((Supporto<0) || (Supporto>2))
  352.          {
  353.             printf ("\nIl numero inserito non corrisponde a nessun supporto. Controllare e re-inserire.");
  354.             printf ("\nRe-inserire il numero del supporto:  ");
  355.             scanf ("%d",&Supporto);
  356.          }
  357.          if (Supporto==0)
  358.          {
  359.             Film.Supporto=DVD;
  360.             fprintf (file_elenco_film,"DVD\n");
  361.          }
  362.          if (Supporto==1)
  363.          {
  364.             Film.Supporto=VHS;
  365.             fprintf (file_elenco_film,"VHS\n");
  366.          }
  367.          if (Supporto==2)
  368.          {
  369.             Film.Supporto=DivX;
  370.             fprintf (file_elenco_film,"DivX\n");
  371.          }
  372.          
  373.          fgets (Vuoto,LUNG_MAX_NOMI,stdin); /*è una chiamata a vuoto che permette di azionare gli fgets successivi*/
  374.          
  375.          printf ("\nScrivere il nome del ");
  376.          if (Film.Supporto==0)
  377.          {
  378.             printf ("DVD");
  379.          }
  380.          if (Film.Supporto==1)
  381.          {
  382.             printf ("VHS");
  383.          }
  384.          if (Film.Supporto==2)
  385.          {
  386.             printf ("DivX");
  387.          }
  388.          printf (" su cui è presente il film (digitare '=' per nominare il supporto come il titolo del film):  ");
  389.          fgets (Film.NomeSupporto,LUNG_MAX_NOMI,stdin);
  390.          if (strcmp (Film.NomeSupporto,"=\n")==0)
  391.          {
  392.             fprintf (file_elenco_film,"%s",Film.Titolo);
  393.          }
  394.          else
  395.          {
  396.              fprintf (file_elenco_film,"%s",Film.NomeSupporto);
  397.          }
  398.          
  399.          printf ("\nScrivere il nome dell'attore/attrice principale:  ");
  400.          fgets (Film.Attore1,LUNG_MAX_NOMI,stdin);
  401.          fprintf (file_elenco_film,"%s",Film.Attore1);
  402.          
  403.          printf ("\nScrivere il nome dell'attore/attrice secondario/a:  ");
  404.          fgets (Film.Attore2,LUNG_MAX_NOMI,stdin);
  405.          fprintf (file_elenco_film,"%s",Film.Attore2);
  406.          
  407.          printf ("\nScrivere il nome del regista:  ");
  408.          fgets (Film.Regista,LUNG_MAX_NOMI,stdin);
  409.          fprintf (file_elenco_film,"%s",Film.Regista);
  410.          
  411.          printf ("\nInserire l'anno (digitare '0' se non si conosce) in cui è stato pubblicato o acquistato il film:  ");
  412.          scanf ("%d",&(Film.Anno));
  413.          
  414.          while ((((Film.Anno)>9999) && ((Film.Anno)!=0)) || (((Film.Anno<1000)) && ((Film.Anno)!=0)))   /*ovvero se ha 5 cifre (cosa impossibile dato che un anno ne ha 4)*/
  415.          {
  416.             printf ("\nL'anno inserito è scritto in maniera errata, si prega di riscriverlo.");
  417.             printf ("\nRe-inserire l'anno in cui è stato pubblicato il film (o in cui si è acquistato):  ");
  418.             scanf ("%d",&(Film.Anno));
  419.          }
  420.          
  421.          if (Film.Anno==0) /*è la codifica in decimale del '-' messo dall'utente per indicare che non si conosce l'anno*/
  422.          {
  423.             fprintf (file_elenco_film,"-\n");
  424.          }
  425.          else
  426.          {
  427.             fprintf (file_elenco_film,"%d\n",Film.Anno);
  428.          }
  429.          
  430.          fprintf (file_elenco_film,"\n\n");
  431.          fclose (file_elenco_film);
  432.              
  433.          return (Film);
  434. }
  435. /***********************************************************************************************************/
  436. void NumeroFilmIn ()
  437. {
  438.      file_numero_film=fopen ("C://film/numero film.txt","r");
  439.      int NumeroFilm;        /*serve a memorizzare il numero di film salvati su disco*/
  440.      int NumFilmRimasti;        /*serve per memorizzare il numero di film che si possono ancora inserire*/
  441.      
  442.      fscanf (file_numero_film,"%d",&NumeroFilm);
  443.      printf ("\nNumero di film inseriti: %d su %d disponibili.\n",NumeroFilm,NUM_MAX_FILM);
  444.      
  445.      NumFilmRimasti=NUM_MAX_FILM-NumeroFilm;
  446.      printf ("\nIl numero dei film che si possono ancora inserire è %d.\n",NumFilmRimasti);
  447.      fclose (file_numero_film);
  448.      
  449.      return;
  450.      
  451. }
  452. /*************************************************************************************************************/
  453. void VisualizzaFilm ()
  454. {
  455.      file_numero_film=fopen ("C://film/numero film.txt","r");
  456.      int NumeroFilm;        /*serve a memorizzare il numero di film salvati sul disco*/
  457.      int Cont,ContR;
  458.      
  459.      file_numero_film=fopen ("C://film/numero film.txt","r");
  460.      fscanf (file_numero_film, "%d",&NumeroFilm);
  461.      fclose (file_numero_film);
  462.    
  463.      file_elenco_film=fopen ("C://film/elenco film.txt","r");
  464.      
  465.      typedef TipoTitolo TipoMatrice[NumeroFilm*LINEE_PAR][1];
  466.      
  467.      TipoMatrice Matrice;
  468.      
  469.      printf ("\n\n");
  470.      
  471.      for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  472.      {
  473.          fgets (Matrice[Cont][1],LUNG_MAX_TITOLO,file_elenco_film);
  474.      }
  475.      
  476.      ContR=0;
  477.      while (ContR<NumeroFilm)
  478.      {
  479.            printf ("\nFilm n§%d:\t",ContR+1);
  480.            for (Cont=ContR*LINEE_PAR;Cont<(ContR*LINEE_PAR)+LINEE_PAR;++Cont)
  481.            {
  482.                printf ("%s\t\t",Matrice[Cont][1]);
  483.            }
  484.            ++ContR;
  485.            sleep (650);
  486.      }
  487.      
  488.      fclose (file_elenco_film);
  489.      return;    
  490. }
  491. /***********************************************************************************************************/
  492. TipoElenco* AggiungiNuovoFilm ()
  493. {          
  494.           int VerificaEsiste (TipoTitolo Titolo,int NumeroFilm);   /*verifica se, all'inserimento del titolo, esiste un film con uguale titolo*/
  495.           void VediFilmUguale (TipoTitolo Titolo,int NumeroFilm);  /*fa vedere, se richiesto, il film con uguale titolo a quello di input*/
  496.           TipoElenco* Testa;   /*è la testa dell'elenco dei film*/
  497.           TipoElenco* NuovoFilm;           /*punta ad un nuovo film dell'elenco appena aggiunto*/
  498.           int Cont;   /*serve per tenere il conto dei film inseriti*/
  499.           int Input,Risposta;
  500.           int ContFilm;       /*serve per contare il numero di film inseriti*/
  501.           int Risultato;      /*contiene il risultato della funzione VerificaEsiste*/
  502.           char Vuoto[LUNG_MAX_NOMI];     /*serve per fare una fgets vuota (se no le successive non funzionano*/
  503.          
  504.           file_numero_film=fopen("C://film/numero film.txt","r");
  505.           fscanf (file_numero_film,"%d",&ContFilm);              /*prende il numero di film già inseriti*/
  506.           fclose (file_numero_film);
  507.           file_numero_film=fopen ("C://film/numero film.txt","w");
  508.           fclose (file_numero_film);
  509.          
  510.           Testa=NULL;
  511.           printf ("\nInserimento dei film:");
  512.           printf ("\nN.B.\tI campi Categoria e Supporto sono obbligatori. Negli altri campi, se non se ne è a conoscenza, possono essere immessi trattini.");
  513.           printf ("\n\tI campi coi trattini non saranno oggetto di ricerca. Premi Enter per continuare.\n");
  514.          
  515.           Cont=ContFilm;
  516.          
  517.           while (Cont<NUM_MAX_FILM)
  518.           {
  519.                 if (Cont==NUM_MAX_FILM-1)
  520.                 {
  521.                    printf ("\n\nULTIMA possibilità di inserimento di film!!!\n\n");
  522.                 }
  523.                
  524.                 NuovoFilm=malloc (sizeof(TipoElenco));
  525.                
  526.                 fgets (Vuoto,LUNG_MAX_NOMI,stdin);    /*è una chiamata a vuoto che permette di azionare gli fgets successivi*/
  527.                
  528.                 printf ("\n\n\tFilm n§%d:",Cont+1);
  529.                 printf ("\n\nInserire il titolo del film:  ");
  530.                 fgets ((NuovoFilm->Dato.Titolo),LUNG_MAX_TITOLO,stdin);
  531.                 Risultato=VerificaEsiste (NuovoFilm->Dato.Titolo,ContFilm);
  532.                 if (Risultato==1)
  533.                 {
  534.                    printf ("\nE' stato trovato %d film con lo stesso titolo di quello inserito\n",Risultato);
  535.                    printf ("Cosa vuoi fare: continuare l'inserimento del film (1) o vedere il film con lo stesso titolo già presente in archivio (2)?  ");
  536.                    scanf ("%d",&Risposta);
  537.                    while (Risposta<1 || Risposta>2)
  538.                    {
  539.                          printf ("\nHai sbagliato a digitare il numero.");
  540.                          printf ("\nRidigitare il numero corrispondente alla scelta:  ");
  541.                          scanf ("%d",&Risposta);
  542.                    }
  543.                    if (Risposta==1) goto ContinuaInput;
  544.                    if (Risposta==2) VediFilmUguale (NuovoFilm->Dato.Titolo,ContFilm);
  545.                    printf ("\nHai visto il film che ha lo stesso titolo del film che stavi inserendo.");
  546.                    printf ("\nCosa vuoi fare: continuare l'inserimento del film che stavi inserendo (1), inserire un nuovo film terminando quello precedente (2), terminare l'inserimento  dei film (3)?  ");
  547.                    scanf ("%d",&Risposta);
  548.                    while (Risposta<1 || Risposta>3)
  549.                    {
  550.                          printf ("\nHai sbagliato a digitare il numero.");
  551.                          printf ("\nRidigitare il numero corrispondente alla scelta:  ");
  552.                          scanf ("%d",&Risposta);
  553.                    }
  554.                    if (Risposta==1) goto ContinuaInput;
  555.                    if (Risposta==2) continue;
  556.                    if (Risposta==3)
  557.                    {
  558.                       printf ("\n\n\tBuona visione!\n\n");
  559.                       break;
  560.                    }
  561.                 }
  562.                 else if (Risultato>1)
  563.                 {
  564.                    printf ("\nSono stati trovati %d film con lo stesso titolo di quello inserito\n",Risultato);
  565.                    printf ("Cosa vuoi fare: continuare l'inserimento del film (1) o vedere i film con lo stesso titolo già presenti in archivio (2)?  ");
  566.                    scanf ("%d",&Risposta);
  567.                    while (Risposta<1 || Risposta>2)
  568.                    {
  569.                          printf ("\nHai sbagliato a digitare il numero.");
  570.                          printf ("\nRidigitare il numero corrispondente alla scelta:  ");
  571.                          scanf ("%d",&Risposta);
  572.                    }
  573.                    if (Risposta==1) goto ContinuaInput;
  574.                    if (Risposta==2) VediFilmUguale (NuovoFilm->Dato.Titolo,ContFilm);
  575.                    printf ("\nHai visto i film che hanno lo stesso titolo del film che stavi inserendo.");
  576.                    printf ("\nCosa vuoi fare: continuare l'inserimento del film che stavi inserendo (1), inserire un nuovo film terminando quello precedente (2), terminare l'inserimento  dei film (3)?  ");
  577.                    scanf ("%d",&Risposta);
  578.                    while (Risposta<1 || Risposta>3)
  579.                    {
  580.                          printf ("\nHai sbagliato a digitare il numero.");
  581.                          printf ("\nRidigitare il numero corrispondente alla scelta:  ");
  582.                          scanf ("%d",&Risposta);
  583.                    }
  584.                    if (Risposta==1) goto ContinuaInput;
  585.                    if (Risposta==2) continue;
  586.                    if (Risposta==3)
  587.                    {
  588.                       printf ("\n\n\tBuona visione!\n\n");
  589.                       break;
  590.                    }
  591.                 }
  592.                 ContinuaInput:
  593.                 NuovoFilm->Dato=AggiungiFilm (NuovoFilm->Dato.Titolo);
  594.                 NuovoFilm->Prossimo=NULL;
  595.                 Testa=NuovoFilm;
  596.                 ++ContFilm;
  597.                 ++Cont;
  598.                
  599.                 printf ("\n\nVuoi inserire altri film?  ");
  600.                 printf ("\n(Inserire un numero negativo per terminare l'input, uno positivo per avanzare) ");
  601.                 scanf ("%d",&Input);
  602.                 if (Input<0)
  603.                 {
  604.                     printf ("\n\n\tBuona visione!\n\n");
  605.                     break;
  606.                 }
  607.           }
  608.          
  609.           if (Cont>=NUM_MAX_FILM)
  610.           {
  611.              printf ("\n\nCi dispiace ma NON è più possibile inserire film.\n\n");
  612.           }
  613.          
  614.           file_numero_film=fopen ("C://film/numero film.txt","a");
  615.           fprintf (file_numero_film,"%d",ContFilm);
  616.           fclose (file_numero_film);
  617.          
  618.           return (Testa);
  619.          
  620. }
  621. /********************************************************************************************************/
  622. void RicercaFilm ()
  623. {
  624.      int NumeroFilm;        /*serve a memorizzare il numero di film salvati sul disco*/
  625.      int Cont,Cont2,ContFilm,Parametro;
  626.      int ContNonUguali;  /*cresce ogni volta che strcmp da esito negativo*/
  627.      TipoTitolo Ricerca;    /*serve per contenere il parametro da cercare*/
  628.      char Vuoto[LUNG_MAX_TITOLO];
  629.      int LungStringa;
  630.      
  631.      file_numero_film=fopen ("C://film/numero film.txt","r");
  632.      fscanf (file_numero_film, "%d",&NumeroFilm);
  633.      fclose (file_numero_film);
  634.    
  635.      file_elenco_film=fopen ("C://film/elenco film.txt","r");
  636.      
  637.      typedef TipoTitolo TipoMatrice[NumeroFilm*LINEE_PAR][1];
  638.      
  639.      TipoMatrice Matrice;
  640.      
  641.      printf ("\n");
  642.      
  643.      for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  644.      {
  645.          fgets (Matrice[Cont][1],LUNG_MAX_TITOLO,file_elenco_film);
  646.      }
  647.      
  648.      fclose (file_elenco_film);
  649.      
  650.      printf ("Inserire il parametro di ricerca.");
  651.      printf ("\nScegliere tra:  titolo (0), categoria (1), supporto (2), nome del supporto (3), attore principale (4), attore secondario (5), regista (6), anno (7):  ");
  652.      scanf ("%d",&Parametro);
  653.      
  654.      if (Parametro==0)
  655.      {
  656.          printf ("\n\nInserire il titolo del film da cercare:  ");
  657.          fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  658.          fgets (Ricerca,LUNG_MAX_TITOLO,stdin);
  659.          LungStringa=strlen(Ricerca);
  660.          Ricerca[LungStringa-1]=0;   /*toglie il \n alla fine di Ricerca*/
  661.          printf ("\n");
  662.          Cont=Parametro;
  663.          ContFilm=0;
  664.          ContNonUguali=0;
  665.          while (Cont<(NumeroFilm*LINEE_PAR))
  666.          {
  667.              if (strstr (Matrice[Cont][1],Ricerca)>=Matrice[Cont][1])
  668.              {  
  669.                 printf ("\nFilm n§%d:\t",ContFilm+1);
  670.                 for (Cont2=Cont-Parametro;Cont2<((Cont-Parametro)+LINEE_PAR);++Cont2)
  671.                 {
  672.                     printf ("%s\t\t",Matrice[Cont2][1]);
  673.                 }
  674.                 sleep (650);
  675.              }
  676.              else
  677.              {
  678.                  ++ContNonUguali;
  679.              }
  680.              Cont=Cont+LINEE_PAR;
  681.              ++ContFilm;
  682.          }
  683.          if (ContNonUguali==NumeroFilm)
  684.          {
  685.             printf ("\nNessun film corrisponde al parametro di ricerca fornito.\n\n");
  686.          }
  687.      }
  688.      
  689.      if (Parametro==1)
  690.      {
  691.          printf ("\n\nInserire la categoria del film da cercare. ");
  692.          printf ("\nScegliere tra: azione, avventura, commedia, cartone animato, sacro, documentario, spettacolo, concerto, porno, altro:  ");
  693.          fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  694.          fgets (Ricerca,LUNG_MAX_TITOLO,stdin);
  695.          LungStringa=strlen(Ricerca);
  696.          Ricerca[LungStringa-1]=0;   /*toglie il \n alla fine di Ricerca*/
  697.          printf ("\n");
  698.          Cont=Parametro;
  699.          ContFilm=0;
  700.          ContNonUguali=0;
  701.          while (Cont<(NumeroFilm*LINEE_PAR))
  702.          {
  703.              if (strstr (Matrice[Cont][1],Ricerca)>=Matrice[Cont][1])
  704.              {  
  705.                 printf ("\nFilm n§%d:\t",ContFilm+1);
  706.                 for (Cont2=Cont-Parametro;Cont2<((Cont-Parametro)+LINEE_PAR);++Cont2)
  707.                 {
  708.                     printf ("%s\t\t",Matrice[Cont2][1]);
  709.                 }
  710.                 sleep (650);
  711.              }
  712.              else
  713.              {
  714.                  ++ContNonUguali;
  715.              }
  716.              Cont=Cont+LINEE_PAR;
  717.              ++ContFilm;
  718.          }
  719.          if (ContNonUguali==NumeroFilm)
  720.          {
  721.             printf ("\nNessun film corrisponde al parametro di ricerca fornito.\n\n");
  722.          }
  723.      }
  724.      
  725.      if (Parametro==2)
  726.      {
  727.          printf ("\n\nInserire il supporto su cui è registrato il film da cercare. ");
  728.          printf ("\nScegliere tra: DVD, VHS, DivX:  ");
  729.          fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  730.          fgets (Ricerca,LUNG_MAX_TITOLO,stdin);
  731.          LungStringa=strlen(Ricerca);
  732.          Ricerca[LungStringa-1]=0;   /*toglie il \n alla fine di Ricerca*/
  733.          printf ("\n");
  734.          Cont=Parametro;
  735.          ContFilm=0;
  736.          ContNonUguali=0;
  737.          while (Cont<(NumeroFilm*LINEE_PAR))
  738.          {
  739.              if (strstr (Matrice[Cont][1],Ricerca)>=Matrice[Cont][1])
  740.              {  
  741.                 printf ("\nFilm n§%d:\t",ContFilm+1);
  742.                 for (Cont2=Cont-Parametro;Cont2<((Cont-Parametro)+LINEE_PAR);++Cont2)
  743.                 {
  744.                     printf ("%s\t\t",Matrice[Cont2][1]);
  745.                 }
  746.                 sleep (650);
  747.              }
  748.              else
  749.              {
  750.                  ++ContNonUguali;
  751.              }
  752.              Cont=Cont+LINEE_PAR;
  753.              ++ContFilm;
  754.          }
  755.          if (ContNonUguali==NumeroFilm)
  756.          {
  757.             printf ("\nNessun film corrisponde al parametro di ricerca fornito.\n\n");
  758.          }
  759.      }
  760.      
  761.      if (Parametro==3)
  762.      {
  763.          printf ("\n\nInserire il nome del supporto su cui è presente il film da cercare:  ");
  764.          fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  765.          fgets (Ricerca,LUNG_MAX_TITOLO,stdin);
  766.          LungStringa=strlen(Ricerca);
  767.          Ricerca[LungStringa-1]=0;   /*toglie il \n alla fine di Ricerca*/
  768.          printf ("\n");
  769.          Cont=Parametro;
  770.          ContFilm=0;
  771.          ContNonUguali=0;
  772.          while (Cont<(NumeroFilm*LINEE_PAR))
  773.          {
  774.              if (strstr (Matrice[Cont][1],Ricerca)>=Matrice[Cont][1])
  775.              {  
  776.                 printf ("\nFilm n§%d:\t",ContFilm+1);
  777.                 for (Cont2=Cont-Parametro;Cont2<((Cont-Parametro)+LINEE_PAR);++Cont2)
  778.                 {
  779.                     printf ("%s\t\t",Matrice[Cont2][1]);
  780.                 }
  781.                 sleep (650);
  782.              }
  783.              else
  784.              {
  785.                  ++ContNonUguali;
  786.              }
  787.              Cont=Cont+LINEE_PAR;
  788.              ++ContFilm;
  789.          }
  790.          if (ContNonUguali==NumeroFilm)
  791.          {
  792.             printf ("\nNessun film corrisponde al parametro di ricerca fornito.\n\n");
  793.          }
  794.      }
  795.      
  796.      if (Parametro==4)
  797.      {
  798.          printf ("\n\nInserire il nome dell'attore/attrice principale del film da cercare:  ");
  799.          fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  800.          fgets (Ricerca,LUNG_MAX_TITOLO,stdin);
  801.          LungStringa=strlen(Ricerca);
  802.          Ricerca[LungStringa-1]=0;   /*toglie il \n alla fine di Ricerca*/
  803.          printf ("\n");
  804.          Cont=Parametro;
  805.          ContFilm=0;
  806.          ContNonUguali=0;
  807.          while (Cont<(NumeroFilm*LINEE_PAR))
  808.          {
  809.              if (strstr (Matrice[Cont][1],Ricerca)>=Matrice[Cont][1])
  810.              {  
  811.                 printf ("\nFilm n§%d:\t",ContFilm+1);
  812.                 for (Cont2=Cont-Parametro;Cont2<((Cont-Parametro)+LINEE_PAR);++Cont2)
  813.                 {
  814.                     printf ("%s\t\t",Matrice[Cont2][1]);
  815.                 }
  816.                 sleep (650);
  817.              }
  818.              else
  819.              {
  820.                  ++ContNonUguali;
  821.              }
  822.              Cont=Cont+LINEE_PAR;
  823.              ++ContFilm;
  824.          }
  825.          if (ContNonUguali==NumeroFilm)
  826.          {
  827.             printf ("\nNessun film corrisponde al parametro di ricerca fornito.\n\n");
  828.          }
  829.      }
  830.      
  831.      if (Parametro==5)
  832.      {
  833.          printf ("\n\nInserire il nome dell'attore/attrice secondario/a del film da cercare:  ");
  834.          fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  835.          fgets (Ricerca,LUNG_MAX_TITOLO,stdin);
  836.          LungStringa=strlen(Ricerca);
  837.          Ricerca[LungStringa-1]=0;   /*toglie il \n alla fine di Ricerca*/
  838.          printf ("\n");
  839.          Cont=Parametro;
  840.          ContFilm=0;
  841.          ContNonUguali=0;
  842.          while (Cont<(NumeroFilm*LINEE_PAR))
  843.          {
  844.              if (strstr (Matrice[Cont][1],Ricerca)>=Matrice[Cont][1])
  845.              {  
  846.                 printf ("\nFilm n§%d:\t",ContFilm+1);
  847.                 for (Cont2=Cont-Parametro;Cont2<((Cont-Parametro)+LINEE_PAR);++Cont2)
  848.                 {
  849.                     printf ("%s\t\t",Matrice[Cont2][1]);
  850.                 }
  851.                 sleep (650);
  852.              }
  853.              else
  854.              {
  855.                  ++ContNonUguali;
  856.              }
  857.              Cont=Cont+LINEE_PAR;
  858.              ++ContFilm;
  859.          }
  860.          if (ContNonUguali==NumeroFilm)
  861.          {
  862.             printf ("\nNessun film corrisponde al parametro di ricerca fornito.\n\n");
  863.          }
  864.      }
  865.      
  866.      if (Parametro==6)
  867.      {
  868.          printf ("\n\nInserire il nome del regista del film da cercare:  ");
  869.          fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  870.          fgets (Ricerca,LUNG_MAX_TITOLO,stdin);
  871.          LungStringa=strlen(Ricerca);
  872.          Ricerca[LungStringa-1]=0;   /*toglie il \n alla fine di Ricerca*/
  873.          printf ("\n");
  874.          Cont=Parametro;
  875.          ContFilm=0;
  876.          ContNonUguali=0;
  877.          while (Cont<(NumeroFilm*LINEE_PAR))
  878.          {
  879.              if (strstr (Matrice[Cont][1],Ricerca)>=Matrice[Cont][1])
  880.              {  
  881.                 printf ("\nFilm n§%d:\t",ContFilm+1);
  882.                 for (Cont2=Cont-Parametro;Cont2<((Cont-Parametro)+LINEE_PAR);++Cont2)
  883.                 {
  884.                     printf ("%s\t\t",Matrice[Cont2][1]);
  885.                 }
  886.                 sleep (650);
  887.              }
  888.              else
  889.              {
  890.                  ++ContNonUguali;
  891.              }
  892.              Cont=Cont+LINEE_PAR;
  893.              ++ContFilm;
  894.          }
  895.          if (ContNonUguali==NumeroFilm)
  896.          {
  897.             printf ("\nNessun film corrisponde al parametro di ricerca fornito.\n\n");
  898.          }
  899.      }
  900.      
  901.      if (Parametro==7)
  902.      {
  903.          printf ("\n\nInserire l'anno di pubblicazione del film da cercare:  ");
  904.          fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  905.          fgets (Ricerca,LUNG_MAX_TITOLO,stdin);
  906.          LungStringa=strlen(Ricerca);
  907.          Ricerca[LungStringa-1]=0;   /*toglie il \n alla fine di Ricerca*/
  908.          printf ("\n");
  909.          Cont=Parametro;
  910.          ContFilm=0;
  911.          ContNonUguali=0;
  912.          while (Cont<(NumeroFilm*LINEE_PAR))
  913.          {
  914.              if (strstr (Matrice[Cont][1],Ricerca)>=Matrice[Cont][1])
  915.              {  
  916.                 printf ("\nFilm n§%d:\t",ContFilm+1);
  917.                 for (Cont2=Cont-Parametro;Cont2<((Cont-Parametro)+LINEE_PAR);++Cont2)
  918.                 {
  919.                     printf ("%s\t\t",Matrice[Cont2][1]);
  920.                 }
  921.                 sleep (650);
  922.              }
  923.              else
  924.              {
  925.                  ++ContNonUguali;
  926.              }
  927.              Cont=Cont+LINEE_PAR;
  928.              ++ContFilm;
  929.          }
  930.          if (ContNonUguali==NumeroFilm)
  931.          {
  932.             printf ("\nNessun film corrisponde al parametro di ricerca fornito.\n\n");
  933.          }
  934.      }
  935.      return;
  936. }
  937. /************************************************************************************************************/
  938. void ModificaFilm (int SpazioInput)
  939. {
  940.      FILE* elenco_nuovo;
  941.      int NumeroFilm;        /*serve a memorizzare il numero di film salvati sul disco*/
  942.      int Cont,Cont2,Cont3,ContFilm,ContR;
  943.      int ContNonUguali;  /*cresce ogni volta che strcmp da esito negativo*/
  944.      int ContFilmUguali; /*conta se ci sono più film uguali con lo stesso titolo*/
  945.      int NumFilmAttuale;
  946.      TipoTitolo Ricerca;    /*serve per contenere il parametro da cercare*/
  947.      TipoTitolo NuovoValore;        /*è il valore da sostituire nella matrice*/
  948.      char Vuoto[LUNG_MAX_TITOLO];   /*segna il numero del film che sta stampando*/
  949.      int FilmScelto;             /*in caso di film uguali contiene il numero del film che si vuole modificare*/
  950.      int Parametro;              /*contiene il parametro del film da modificare*/
  951.      int LungStringa;
  952.      
  953.      file_numero_film=fopen ("C://film/numero film.txt","r");
  954.      fscanf (file_numero_film, "%d",&NumeroFilm);
  955.      fclose (file_numero_film);
  956.    
  957.      file_elenco_film=fopen ("C://film/elenco film.txt","r");
  958.      
  959.      typedef TipoTitolo TipoMatrice[NumeroFilm*LINEE_PAR][1];
  960.      
  961.      TipoMatrice Matrice;
  962.      
  963.      printf ("\n");
  964.      
  965.      for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  966.      {
  967.          fgets (Matrice[Cont][1],LUNG_MAX_TITOLO,file_elenco_film);
  968.      }
  969.      
  970.      fclose (file_elenco_film);
  971.      
  972.      if (SpazioInput>0)
  973.      {
  974.         printf ("\n");
  975.      }
  976.      
  977.      printf ("Inserire il titolo del film da modificare:  ");
  978.      if (SpazioInput>0)
  979.      {
  980.         /*se è stato modificato già un film si mette un Vuoto per lasciare inserire Ricerca*/
  981.         fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  982.      }
  983.      fgets (Ricerca,LUNG_MAX_TITOLO,stdin);
  984.      LungStringa=strlen(Ricerca);
  985.      Ricerca[LungStringa-1]=0;   /*toglie il \n alla fine di Ricerca*/
  986.      printf ("\n");
  987.      Cont=0;
  988.      ContFilm=0;
  989.      ContNonUguali=0;
  990.      ContFilmUguali=0;
  991.      NumFilmAttuale=0;
  992.      printf ("\nFilm corrispondenti al titolo inserito:\n");
  993.      while (Cont<(NumeroFilm*LINEE_PAR))
  994.      {
  995.          if (strstr (Matrice[Cont][1],Ricerca)>=Matrice[Cont][1])
  996.          {  
  997.               printf ("\nFilm n§%d:\t",ContFilm+1);
  998.               for (Cont2=Cont;Cont2<(Cont+LINEE_PAR);++Cont2)
  999.               {
  1000.                   NumFilmAttuale=ContFilm+1;
  1001.                   printf ("%s\t\t",Matrice[Cont2][1]);
  1002.               }
  1003.               ++ContFilmUguali;
  1004.          }
  1005.          else
  1006.          {
  1007.               ++ContNonUguali;
  1008.          }
  1009.          Cont=Cont+LINEE_PAR;
  1010.          ++ContFilm;
  1011.      }
  1012.      if (ContNonUguali==NumeroFilm)
  1013.      {
  1014.          printf ("\nNessun film corrisponde al parametro di ricerca fornito.\n\n");
  1015.      }
  1016.      
  1017. /******************  se c'è un solo film che corrisponde al parametro   *********************************/
  1018.  
  1019.      if (ContFilmUguali==1)
  1020.      {
  1021.         Cont=0;
  1022.         ContFilm=0;
  1023.         ContNonUguali=0;
  1024.         ContFilmUguali=0;
  1025.        
  1026.         while (Cont<(NumeroFilm*LINEE_PAR))
  1027.         {
  1028.               if (strstr (Matrice[Cont][1],Ricerca)>=Matrice[Cont][1])
  1029.               {  
  1030.                  printf ("\nInserire il parametro che si vuole modificare.");
  1031.                  printf ("\nScegliere tra: categoria (1), supporto (2), nome del supporto (3), attore principale (4), attore secondario (5), regista (6), anno (7):  ");
  1032.                  scanf ("%d",&Parametro);
  1033.                  
  1034.                  if (1==Parametro)
  1035.                  {
  1036.                     printf ("\nInserisci la nuova categoria.");
  1037.                     printf ("\nScegliere tra: azione, avventura, commedia, cartone animato, sacro, documentario, spettacolo, concerto, porno, altro:  ");
  1038.                     fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1039.                     fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1040.                     Cont3=Cont+Parametro;
  1041.                     ContFilm=0;  
  1042.                     Cont2=Cont3;
  1043.                     if (Cont2==Cont3)
  1044.                     {  
  1045.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1046.                        {
  1047.                              printf ("\nCopiatura riuscita\n\n\n");
  1048.                        }
  1049.                        else
  1050.                        {
  1051.                               printf ("\nCopiatura non riuscita\n\n\n");
  1052.                        }
  1053.                     }
  1054.                     else
  1055.                     {
  1056.                              ++Cont2;
  1057.                     }
  1058.      
  1059.                     elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1060.                     fclose(elenco_nuovo);
  1061.      
  1062.                     elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1063.      
  1064.                     for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1065.                     {
  1066.                         fputs (Matrice[Cont][1],elenco_nuovo);
  1067.                     }
  1068.                   }
  1069.                  
  1070.                   if (2==Parametro)
  1071.                   {
  1072.                     printf ("\nInserisci il nuovo supporto.");
  1073.                     printf ("\nScegliere tra: DVD, VHS, DivX:  ");
  1074.                     fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1075.                     fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1076.                     Cont3=Cont+Parametro;
  1077.                     ContFilm=0;  
  1078.                     Cont2=Cont3;
  1079.                     if (Cont2==Cont3)
  1080.                     {  
  1081.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1082.                        {
  1083.                              printf ("\nCopiatura riuscita\n\n\n");
  1084.                        }
  1085.                        else
  1086.                        {
  1087.                               printf ("\nCopiatura non riuscita\n\n\n");
  1088.                        }
  1089.                     }
  1090.                     else
  1091.                     {
  1092.                              ++Cont2;
  1093.                     }
  1094.      
  1095.                     elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1096.                     fclose(elenco_nuovo);
  1097.      
  1098.                     elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1099.      
  1100.                     for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1101.                     {
  1102.                         fputs (Matrice[Cont][1],elenco_nuovo);
  1103.                     }
  1104.                   }
  1105.                  
  1106.                   if (3==Parametro)
  1107.                   {
  1108.                     printf ("\nInserisci il nuovo nome del supporto su cui è presente il film:  ");
  1109.                     fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1110.                     fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1111.                     Cont3=Cont+Parametro;
  1112.                     ContFilm=0;  
  1113.                     Cont2=Cont3;
  1114.                     if (Cont2==Cont3)
  1115.                     {  
  1116.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1117.                        {
  1118.                              printf ("\nCopiatura riuscita\n\n\n");
  1119.                        }
  1120.                        else
  1121.                        {
  1122.                               printf ("\nCopiatura non riuscita\n\n\n");
  1123.                        }
  1124.                     }
  1125.                     else
  1126.                     {
  1127.                              ++Cont2;
  1128.                     }
  1129.      
  1130.                     elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1131.                     fclose(elenco_nuovo);
  1132.      
  1133.                     elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1134.      
  1135.                     for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1136.                     {
  1137.                         fputs (Matrice[Cont][1],elenco_nuovo);
  1138.                     }
  1139.                   }
  1140.                  
  1141.                   if (4==Parametro)
  1142.                   {
  1143.                     printf ("\nInserisci il nuovo nome dell'attore/attrice principale:  ");
  1144.                     fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1145.                     fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1146.                     Cont3=Cont+Parametro;
  1147.                     ContFilm=0;  
  1148.                     Cont2=Cont3;
  1149.                     if (Cont2==Cont3)
  1150.                     {  
  1151.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1152.                        {
  1153.                              printf ("\nCopiatura riuscita\n\n\n");
  1154.                        }
  1155.                        else
  1156.                        {
  1157.                               printf ("\nCopiatura non riuscita\n\n\n");
  1158.                        }
  1159.                     }
  1160.                     else
  1161.                     {
  1162.                              ++Cont2;
  1163.                     }
  1164.      
  1165.                     elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1166.                     fclose(elenco_nuovo);
  1167.      
  1168.                     elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1169.      
  1170.                     for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1171.                     {
  1172.                         fputs (Matrice[Cont][1],elenco_nuovo);
  1173.                     }
  1174.                   }
  1175.                  
  1176.                   if (5==Parametro)
  1177.                   {
  1178.                     printf ("\nInserisci il nuovo nome dell'attore/attrice secondario/a:  ");
  1179.                     fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1180.                     fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1181.                     Cont3=Cont+Parametro;
  1182.                     ContFilm=0;  
  1183.                     Cont2=Cont3;
  1184.                     if (Cont2==Cont3)
  1185.                     {  
  1186.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1187.                        {
  1188.                              printf ("\nCopiatura riuscita\n\n\n");
  1189.                        }
  1190.                        else
  1191.                        {
  1192.                               printf ("\nCopiatura non riuscita\n\n\n");
  1193.                        }
  1194.                     }
  1195.                     else
  1196.                     {
  1197.                              ++Cont2;
  1198.                     }
  1199.      
  1200.                     elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1201.                     fclose(elenco_nuovo);
  1202.      
  1203.                     elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1204.      
  1205.                     for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1206.                     {
  1207.                         fputs (Matrice[Cont][1],elenco_nuovo);
  1208.                     }
  1209.                   }
  1210.                  
  1211.                   if (6==Parametro)
  1212.                   {
  1213.                     printf ("\nInserisci il nuovo nome del regista:  ");
  1214.                     fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1215.                     fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1216.                     Cont3=Cont+Parametro;
  1217.                     ContFilm=0;  
  1218.                     Cont2=Cont3;
  1219.                     if (Cont2==Cont3)
  1220.                     {  
  1221.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1222.                        {
  1223.                              printf ("\nCopiatura riuscita\n\n\n");
  1224.                        }
  1225.                        else
  1226.                        {
  1227.                               printf ("\nCopiatura non riuscita\n\n\n");
  1228.                        }
  1229.                     }
  1230.                     else
  1231.                     {
  1232.                              ++Cont2;
  1233.                     }
  1234.      
  1235.                     elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1236.                     fclose(elenco_nuovo);
  1237.      
  1238.                     elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1239.      
  1240.                     for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1241.                     {
  1242.                         fputs (Matrice[Cont][1],elenco_nuovo);
  1243.                     }
  1244.                   }
  1245.                  
  1246.                   if (7==Parametro)
  1247.                   {
  1248.                     printf ("\nInserisci il nuovo anno in cui è stato prodotto il film:  ");
  1249.                     fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1250.                     fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1251.                     Cont3=Cont+Parametro;
  1252.                     ContFilm=0;  
  1253.                     Cont2=Cont3;
  1254.                     if (Cont2==Cont3)
  1255.                     {  
  1256.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1257.                        {
  1258.                              printf ("\nCopiatura riuscita\n\n\n");
  1259.                        }
  1260.                        else
  1261.                        {
  1262.                               printf ("\nCopiatura non riuscita\n\n\n");
  1263.                        }
  1264.                     }
  1265.                     else
  1266.                     {
  1267.                              ++Cont2;
  1268.                     }
  1269.      
  1270.                     elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1271.                     fclose(elenco_nuovo);
  1272.      
  1273.                     elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1274.      
  1275.                     for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1276.                     {
  1277.                         fputs (Matrice[Cont][1],elenco_nuovo);
  1278.                     }
  1279.                   }
  1280.                  
  1281.                   if ((Parametro<1) || (Parametro>7))
  1282.                   {
  1283.                      printf ("\nERRORE: Comando errato. Verificare il numeroinserito.\n");
  1284.                      return;
  1285.                   }
  1286.               }
  1287.               Cont=Cont+LINEE_PAR;
  1288.               ++ContFilm;
  1289.         }
  1290.         fclose (elenco_nuovo);
  1291.        
  1292.         file_elenco_film=fopen ("C://film/elenco film.txt","r");
  1293.        
  1294.         printf ("Film con le nuove modifiche:\n");
  1295.         for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1296.         {
  1297.              fgets (Matrice[Cont][1],LUNG_MAX_TITOLO,file_elenco_film);
  1298.         }
  1299.            
  1300.         ContR=0;
  1301.         ContFilm=0;
  1302.         while (ContR<(NumeroFilm*LINEE_PAR))
  1303.         {
  1304.               if (ContR==NumFilmAttuale-1)
  1305.               {
  1306.                   printf ("\nFilm n§%d:\t",ContFilm+1);
  1307.                   for (Cont=ContR*LINEE_PAR;Cont<((ContR*LINEE_PAR)+LINEE_PAR);++Cont)
  1308.                   {
  1309.                      printf ("%s\t\t",Matrice[Cont][1]);
  1310.                      fflush (stdout);
  1311.                   }  
  1312.               }
  1313.               ++ContR;
  1314.               ++ContFilm;
  1315.         }
  1316.      }
  1317.      
  1318. /***********************  se ci sono più fim uguali  ******************************************************/
  1319.      
  1320.      if (ContFilmUguali>1)
  1321.      {
  1322.         printf ("\nATTENZIONE: Ci sono %d film con lo stesso titolo. Inserisci il numero del film:  ",ContFilmUguali);
  1323.         scanf ("%d",&FilmScelto);
  1324.        
  1325.         printf ("\n\nFilm scelto:\n");
  1326.         Cont=0;
  1327.         ContFilm=0;
  1328.         while (Cont<(NumeroFilm*LINEE_PAR))
  1329.         {
  1330.               if (ContFilm+1==FilmScelto)
  1331.               {  
  1332.                  printf ("\nFilm n§%d:\t",ContFilm+1);
  1333.                  for (Cont2=Cont;Cont2<(Cont+LINEE_PAR);++Cont2)
  1334.                  {
  1335.                      printf ("%s\t\t",Matrice[Cont2][1]);
  1336.                  }
  1337.               }
  1338.               Cont=Cont+LINEE_PAR;
  1339.               ++ContFilm;
  1340.         }
  1341.         printf ("\nInserire il parametro che si vuole modificare.");
  1342.         printf ("\nScegliere tra: categoria (1), supporto (2), nome del supporto (3), attore principale (4), attore secondario (5), regista (6), anno (7):  ");
  1343.         scanf ("%d",&Parametro);
  1344.        
  1345.         if (1==Parametro)
  1346.         {
  1347.            printf ("\nInserisci la nuova categoria.");
  1348.            printf ("\nScegliere tra: azione, avventura, commedia, cartone animato, sacro, documentario, spettacolo, concerto, porno, altro:  ");
  1349.            fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1350.            fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1351.            Cont=Parametro;
  1352.            ContFilm=0;
  1353.            while (Cont<(NumeroFilm*LINEE_PAR))
  1354.            {
  1355.                  if (ContFilm+1==FilmScelto)
  1356.                  {  
  1357.                     Cont2=Cont;
  1358.                     if (Cont2==Cont)
  1359.                     {  
  1360.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1361.                        {
  1362.                                      printf ("\nCopiatura riuscita\n\n\n");
  1363.                        }
  1364.                        else
  1365.                        {
  1366.                            printf ("\nCopiatura non riuscita\n\n\n");
  1367.                        }
  1368.                     }
  1369.                     else
  1370.                     {
  1371.                        ++Cont2;
  1372.                     }
  1373.                  }
  1374.                  Cont=Cont+LINEE_PAR;
  1375.                  ++ContFilm;
  1376.            }
  1377.      
  1378.            elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1379.            fclose(elenco_nuovo);
  1380.      
  1381.            elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1382.      
  1383.            for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1384.            {
  1385.                fputs (Matrice[Cont][1],elenco_nuovo);
  1386.            }
  1387.         }
  1388.        
  1389.      
  1390.      if (2==Parametro)
  1391.         {
  1392.            printf ("\nInserisci il nuovo supporto.");
  1393.            printf ("\nScegliere tra: DVD, VHS, DivX:  ");
  1394.            fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1395.            fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1396.            Cont=Parametro;
  1397.            ContFilm=0;
  1398.            while (Cont<(NumeroFilm*LINEE_PAR))
  1399.            {
  1400.                  if (ContFilm+1==FilmScelto)
  1401.                  {  
  1402.                     Cont2=Cont;
  1403.                     if (Cont2==Cont)
  1404.                     {  
  1405.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1406.                        {
  1407.                                      printf ("\nCopiatura riuscita\n\n\n");
  1408.                        }
  1409.                        else
  1410.                        {
  1411.                            printf ("\nCopiatura non riuscita\n\n\n");
  1412.                        }
  1413.                     }
  1414.                     else
  1415.                     {
  1416.                        ++Cont2;
  1417.                     }
  1418.                  }
  1419.                  Cont=Cont+LINEE_PAR;
  1420.                  ++ContFilm;
  1421.            }
  1422.      
  1423.            elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1424.            fclose(elenco_nuovo);
  1425.      
  1426.            elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1427.      
  1428.            for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1429.            {
  1430.                fputs (Matrice[Cont][1],elenco_nuovo);
  1431.            }
  1432.         }  
  1433.        
  1434.         if (3==Parametro)
  1435.         {
  1436.            printf ("\nInserisci il nuovo nome del supporto su cui è presente il film:  ");
  1437.            fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1438.            fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1439.            Cont=Parametro;
  1440.            ContFilm=0;
  1441.            while (Cont<(NumeroFilm*LINEE_PAR))
  1442.            {
  1443.                  if (ContFilm+1==FilmScelto)
  1444.                  {  
  1445.                     Cont2=Cont;
  1446.                     if (Cont2==Cont)
  1447.                     {  
  1448.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1449.                        {
  1450.                                      printf ("\nCopiatura riuscita\n\n\n");
  1451.                        }
  1452.                        else
  1453.                        {
  1454.                            printf ("\nCopiatura non riuscita\n\n\n");
  1455.                        }
  1456.                     }
  1457.                     else
  1458.                     {
  1459.                        ++Cont2;
  1460.                     }
  1461.                  }
  1462.                  Cont=Cont+LINEE_PAR;
  1463.                  ++ContFilm;
  1464.            }
  1465.      
  1466.            elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1467.            fclose(elenco_nuovo);
  1468.      
  1469.            elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1470.      
  1471.            for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1472.            {
  1473.                fputs (Matrice[Cont][1],elenco_nuovo);
  1474.            }
  1475.         }  
  1476.        
  1477.         if (4==Parametro)
  1478.         {
  1479.            printf ("\nInserisci il nuovo nome dell'attore/attrice principale:  ");
  1480.            fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1481.            fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1482.            Cont=Parametro;
  1483.            ContFilm=0;
  1484.            while (Cont<(NumeroFilm*LINEE_PAR))
  1485.            {
  1486.                  if (ContFilm+1==FilmScelto)
  1487.                  {  
  1488.                     Cont2=Cont;
  1489.                     if (Cont2==Cont)
  1490.                     {  
  1491.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1492.                        {
  1493.                                      printf ("\nCopiatura riuscita\n\n\n");
  1494.                        }
  1495.                        else
  1496.                        {
  1497.                            printf ("\nCopiatura non riuscita\n\n\n");
  1498.                        }
  1499.                     }
  1500.                     else
  1501.                     {
  1502.                        ++Cont2;
  1503.                     }
  1504.                  }
  1505.                  Cont=Cont+LINEE_PAR;
  1506.                  ++ContFilm;
  1507.            }
  1508.      
  1509.            elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1510.            fclose(elenco_nuovo);
  1511.      
  1512.            elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1513.      
  1514.            for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1515.            {
  1516.                fputs (Matrice[Cont][1],elenco_nuovo);
  1517.            }
  1518.         }  
  1519.        
  1520.         if (5==Parametro)
  1521.         {
  1522.            printf ("\nInserisci il nuovo nome dell'attore/attrice secondario/a:  ");
  1523.            fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1524.            fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1525.            Cont=Parametro;
  1526.            ContFilm=0;
  1527.            while (Cont<(NumeroFilm*LINEE_PAR))
  1528.            {
  1529.                  if (ContFilm+1==FilmScelto)
  1530.                  {  
  1531.                     Cont2=Cont;
  1532.                     if (Cont2==Cont)
  1533.                     {  
  1534.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1535.                        {
  1536.                                      printf ("\nCopiatura riuscita\n\n\n");
  1537.                        }
  1538.                        else
  1539.                        {
  1540.                            printf ("\nCopiatura non riuscita\n\n\n");
  1541.                        }
  1542.                     }
  1543.                     else
  1544.                     {
  1545.                        ++Cont2;
  1546.                     }
  1547.                  }
  1548.                  Cont=Cont+LINEE_PAR;
  1549.                  ++ContFilm;
  1550.            }
  1551.      
  1552.            elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1553.            fclose(elenco_nuovo);
  1554.      
  1555.            elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1556.      
  1557.            for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1558.            {
  1559.                fputs (Matrice[Cont][1],elenco_nuovo);
  1560.            }
  1561.         }
  1562.        
  1563.         if (6==Parametro)
  1564.         {
  1565.            printf ("\nInserisci il nuovo nome del regista:  ");
  1566.            fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1567.            fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1568.            Cont=Parametro;
  1569.            ContFilm=0;
  1570.            while (Cont<(NumeroFilm*LINEE_PAR))
  1571.            {
  1572.                  if (ContFilm+1==FilmScelto)
  1573.                  {  
  1574.                     Cont2=Cont;
  1575.                     if (Cont2==Cont)
  1576.                     {  
  1577.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1578.                        {
  1579.                                      printf ("\nCopiatura riuscita\n\n\n");
  1580.                        }
  1581.                        else
  1582.                        {
  1583.                            printf ("\nCopiatura non riuscita\n\n\n");
  1584.                        }
  1585.                     }
  1586.                     else
  1587.                     {
  1588.                        ++Cont2;
  1589.                     }
  1590.                  }
  1591.                  Cont=Cont+LINEE_PAR;
  1592.                  ++ContFilm;
  1593.            }
  1594.      
  1595.            elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1596.            fclose(elenco_nuovo);
  1597.      
  1598.            elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1599.      
  1600.            for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1601.            {
  1602.                fputs (Matrice[Cont][1],elenco_nuovo);
  1603.            }
  1604.         }
  1605.        
  1606.         if (7==Parametro)
  1607.         {
  1608.            printf ("\nInserisci l'anno in cui è stato prodotto il film:  ");
  1609.            fgets (Vuoto,LUNG_MAX_TITOLO,stdin);
  1610.            fgets (NuovoValore,LUNG_MAX_TITOLO,stdin);          
  1611.            Cont=Parametro;
  1612.            ContFilm=0;
  1613.            while (Cont<(NumeroFilm*LINEE_PAR))
  1614.            {
  1615.                  if (ContFilm+1==FilmScelto)
  1616.                  {  
  1617.                     Cont2=Cont;
  1618.                     if (Cont2==Cont)
  1619.                     {  
  1620.                        if (0!=strcpy (Matrice[Cont2][1],NuovoValore))
  1621.                        {
  1622.                                      printf ("\nCopiatura riuscita\n\n\n");
  1623.                        }
  1624.                        else
  1625.                        {
  1626.                            printf ("\nCopiatura non riuscita\n\n\n");
  1627.                        }
  1628.                     }
  1629.                     else
  1630.                     {
  1631.                        ++Cont2;
  1632.                     }
  1633.                  }
  1634.                  Cont=Cont+LINEE_PAR;
  1635.                  ++ContFilm;
  1636.            }
  1637.      
  1638.            elenco_nuovo=fopen ("C://film/elenco film.txt","w");
  1639.            fclose(elenco_nuovo);
  1640.      
  1641.            elenco_nuovo=fopen ("C://film/elenco film.txt","a");
  1642.      
  1643.            for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1644.            {
  1645.                fputs (Matrice[Cont][1],elenco_nuovo);
  1646.            }
  1647.         }
  1648.        
  1649.         if ((Parametro<1) || (Parametro>7))
  1650.         {
  1651.                printf ("\nERRORE: Comando errato. Verificare il numeroinserito.\n");
  1652.                return;
  1653.         }
  1654.        
  1655.         fclose (elenco_nuovo);
  1656.        
  1657.         file_elenco_film=fopen ("C://film/elenco film.txt","r");
  1658.        
  1659.         printf ("Film con le nuove modifiche:\n");
  1660.         for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1661.         {
  1662.              fgets (Matrice[Cont][1],LUNG_MAX_TITOLO,file_elenco_film);
  1663.         }
  1664.            
  1665.         ContR=0;
  1666.         ContFilm=0;
  1667.         while (ContR<(NumeroFilm*LINEE_PAR))
  1668.         {
  1669.               if (ContR==FilmScelto-1)
  1670.               {
  1671.                   printf ("\nFilm n§%d:\t",ContFilm+1);
  1672.                   for (Cont=ContR*LINEE_PAR;Cont<((ContR*LINEE_PAR)+LINEE_PAR);++Cont)
  1673.                   {
  1674.                      printf ("%s\t\t",Matrice[Cont][1]);
  1675.                      fflush (stdout);
  1676.                   }  
  1677.               }
  1678.               ++ContR;
  1679.               ++ContFilm;
  1680.         }
  1681.      }
  1682.      fclose (file_elenco_film);
  1683.      return;
  1684. }
  1685.  
  1686. /***********************************************************************************************************/
  1687.  
  1688. int VerificaEsiste (TipoTitolo Titolo,int NumeroFilm)
  1689. {
  1690.      int Cont,ContFilm;
  1691.      int ContNonUguali;  /*cresce ogni volta che strcmp da esito negativo*/
  1692.      int ContFilmUguali; /*è il numero di film che corrispondono al titolo dato in input*/
  1693.      char Vuoto[LUNG_MAX_TITOLO];
  1694.    
  1695.      file_elenco_film=fopen ("C://film/elenco film.txt","r");
  1696.      
  1697.      typedef TipoTitolo TipoMatrice[NumeroFilm*LINEE_PAR][1];
  1698.      TipoMatrice Matrice;
  1699.      
  1700.      for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1701.      {
  1702.          fgets (Matrice[Cont][1],LUNG_MAX_TITOLO,file_elenco_film);
  1703.      }
  1704.      
  1705.      fclose (file_elenco_film);
  1706.      Cont=0;
  1707.      ContFilmUguali=0;
  1708.      ContNonUguali=0;
  1709.      while (Cont<(NumeroFilm*LINEE_PAR))
  1710.      {
  1711.          if (0==strcmp (Titolo,Matrice[Cont][1]))
  1712.          {  
  1713.              ++ContFilmUguali;
  1714.          }
  1715.          else
  1716.          {
  1717.              ++ContNonUguali;
  1718.          }
  1719.          Cont=Cont+LINEE_PAR;
  1720.      }
  1721.      if (ContNonUguali==NumeroFilm)
  1722.      {  
  1723.         /*restituiamo 0 che indica che non c'è nessun vilm uguale*/
  1724.          return 0;
  1725.      }
  1726.      else
  1727.      {
  1728.          /*ritorniamo 1 che significa che è stato trovato un film con lo stesso titolo*/
  1729.          return (ContFilmUguali);
  1730.      }
  1731. }
  1732.      
  1733. /***********************************************************************************************************/
  1734.  
  1735. void VediFilmUguale (TipoTitolo Titolo,int NumeroFilm)
  1736. {
  1737.      int Cont,Cont2,ContFilm;
  1738.      int ContFilmUguali; /*è il numero di film che corrispondono al titolo dato in input*/
  1739.      char Vuoto[LUNG_MAX_TITOLO];
  1740.    
  1741.      file_elenco_film=fopen ("C://film/elenco film.txt","r");
  1742.      
  1743.      typedef TipoTitolo TipoMatrice[NumeroFilm*LINEE_PAR][1];
  1744.      TipoMatrice Matrice;
  1745.      
  1746.      for (Cont=0;Cont<(NumeroFilm*LINEE_PAR);++Cont)
  1747.      {
  1748.          fgets (Matrice[Cont][1],LUNG_MAX_TITOLO,file_elenco_film);
  1749.      }
  1750.      
  1751.      fclose (file_elenco_film);
  1752.      Cont=0;
  1753.      ContFilm=0;
  1754.      ContFilmUguali=0;
  1755.      while (Cont<(NumeroFilm*LINEE_PAR))
  1756.      {
  1757.          if (0==strcmp (Titolo,Matrice[Cont][1]))
  1758.          {  
  1759.              printf ("\nFilm n§%d:\t",ContFilm+1);
  1760.              for (Cont2=Cont;Cont2<(Cont+LINEE_PAR);++Cont2)
  1761.              {
  1762.                 printf ("%s\t\t",Matrice[Cont2][1]);
  1763.              }
  1764.              ++ContFilmUguali;
  1765.          }
  1766.          Cont=Cont+LINEE_PAR;
  1767.          ++ContFilm;
  1768.      }
  1769.      return;
  1770. }
  1771.  
  1772. /*******************************************************************************************************/
  1773.  
  1774. void Disinstallazione ()
  1775. {
  1776.      int Cont;        /*serve solo per creare una barra di progressione*/
  1777.      
  1778.      printf ("\nSi sta per disinstallare ");
  1779.      system("del C:\\film\\*.*");
  1780.      
  1781.      printf ("\n");
  1782.      Cont=0;
  1783.      while (Cont<100)
  1784.      {
  1785.            printf ("Eliminazione dei file: %d %% in corso...\r",Cont);
  1786.            sleep (50);
  1787.            ++Cont;
  1788.      }
  1789.      printf ("Eliminazione dei file: 100 %%                         \r");
  1790.      
  1791.      rmdir ("C:\\film");
  1792.      
  1793.      sleep (200);
  1794.      printf ("\n\n\nDisinstallazione completata con successo.");
  1795.      
  1796.      printf ("\n\n\n");
  1797.      
  1798.      sleep (350);
  1799.      return;
  1800. }