0       /*
1        * Nome del file: rubrica.c
2        * Autore - Fabrizio Ciacchi
3        * Dicembre 2003
4        * Rubrica dimostrativa per Html.it
5        * Il programma genere un file rubrica.txt in formato CSV, Comma
6        * Separated Value, e quindi permette ad Outlook o Mozilla di
7        * importare i contatti.
8        */
9       
10      // Inclusione delle librerie
11      #include <stdio.h>
12      #include <math.h>
13      #include <string.h>
14      
15      // SISTEMA = 1 -> Sistema Linux;
16      // SISTEMA = 0 -> Sistema Windows;
17      #ifndef SISTEMA
18      #define SISTEMA 0
19      #endif
20      
21      // Scelgo la funzione di sistema per pulire lo schermo
22      #if SISTEMA==0
23        char* pulisci = "cls";
24      #elif SISTEMA==1
25        char* pulisci = "clear";
26      #endif
27      
28      // Creo la struttura per contenere i contatti
29      typedef struct
30      {
31        char nome[50];
32        char cognome[50];
33        char telefono[30];
34        char email[100];
35        char sitoweb[200];
36      } t_contatto;
37      
38      // Creo la struttura per creare la lista
39      struct elemento
40      {
41        t_contatto inf;
42        struct elemento *pun;
43      };
44      
45      // Prototipi delle funzioni
46      void visualizzaContatto(struct elemento* p);
47      struct elemento *aggiungiContatto(struct elemento *p);
48      struct elemento *modificaContatto(struct elemento *p);
49      struct elemento *rimuoviContatto(struct elemento *p);
50      struct elemento *leggiDaFile(struct elemento *p);
51      int salvaSuFile(struct elemento *p);
52      void substring(char *dest, char *source, int i_base, int i_dim);
53      void pausa();
54      
55      
56      // Funzione principale - MAIN
57      
58      int main()
59      { // MAIN() - OPEN
60      
61      // dichiaro la variabile scelta e la lista vuota
62      int scelta;
63      struct elemento *lista = NULL;
64      
65        // Ciclo infinito
66        for ( ; ; )
67        { // FOR - OPEN
68      
69          // Stampo il menu
70          system(pulisci);
71          printf (" #######################\n");
72          printf (" # RUBRICA EASY v1.0   #\n");
73          printf (" #######################\n\n");
74          printf (" 1) VISUALIZZA CONTATTO\n\n");
75          printf (" 2) AGGIUNGI CONTATTO\n\n");
76          printf (" 3) MODIFICA CONTATTO\n\n");
77          printf (" 4) RIMUOVI CONTATTO\n\n");
78          printf (" 5) LEGGI CONTATTI DA FILE\n\n");
79          printf (" 6) SALVA CONTATTI SU FILE\n\n");
80          printf (" 0) ESCI\n\n\n\n");
81          printf (" la tua scelta > ");
82      
83          // Aspetto scelta dell'utente
84          scanf ("%i", &scelta);
85          scelta = (int)scelta;
86      
87          if (scelta == 0) // ESCO DAL PROGRAMMA
88          { // IF - OPEN
89      
90            // Stampo info di uscita
91            system(pulisci); // PULISCE LO SCHERMO
92            printf ("--------------------------------------\n");
93            printf (" www.HTML.it - Rubrica Easy v1.0\n");
94            printf (" Programma creato da Fabrizio Ciacchi\n");
95            printf (" http://fabrizio.ciacchi.it\n");
96            printf (" fabrizio@ciacchi.it\n");
97            printf ("--------------------------------------\n\n");
98            break;
99      
100         } // ELSE
101         else if (scelta == 1) // Visualizzo i contatti presenti
102         { // ELSEIF 1 - OPEN
103     
104           visualizzaContatto(lista);
105     
106         } // ELSEIF 1 - CLOSE
107         else if (scelta == 2) // Aggiungo un nuovo contatto
108         { // ELSEIF 2 - OPEN
109     
110           lista = aggiungiContatto(lista);
111     
112         } // ELSEIF 2 - CLOSE
113         else if (scelta == 3) // Modifico un contatto
114         { // ELSEIF 3 - OPEN
115     
116           lista = modificaContatto(lista);
117     
118         } // ELSEIF 3 - CLOSE
119         else if (scelta == 4) // Rimuovo un contatto
120         { // ELSEIF 4 - OPEN
121     
122           lista = rimuoviContatto(lista);
123     
124         } // ELSEIF 4 - CLOSE
125         else if (scelta == 5) // Leggo i contatti da File
126         { // ELSEIF 5 - OPEN
127     
128           lista = leggiDaFile(lista);
129     
130         }  // ELSEIF 5 - CLOSE
131         else if (scelta == 6) // Salvo i contatti su File
132         { // ELSEIF 6 - OPEN
133     
134           salvaSuFile(lista);
135     
136         } // IF - CLOSE
137     
138       } // FOR - CLOSE
139     
140     } // MAIN() - OPEN
141     
142     // Fine del MAIN, adesso ci sono le funzioni che eseguono il
143     // compito a loro assegnato
144     
145     /*
146      * Visualizza i contatti presenti
147      */
148     void visualizzaContatto(struct elemento* p)
149     { // visualizzaContatto() - OPEN
150     
151       if (p == NULL)
152       { // IF - OPEN
153     
154         /*
155          * Se non ci sono contatti lo stampo a video
156          */
157         system(pulisci); // PULISCE LO SCHERMO
158         printf (" #######################\n");
159         printf (" # RUBRICA EASY v1.0   #\n");
160         printf (" #######################\n");
161         printf (" # VISUALIZZA CONTATTO #\n");
162         printf (" #######################\n\n");
163         printf (" Nessun contatto presente\n");
164         pausa();
165     
166       } else { // ELSE
167     
168         /*
169          * Stampo il primo contatto presente
170          */
171         system(pulisci); // PULISCE LO SCHERMO
172         printf (" #######################\n");
173         printf (" # RUBRICA EASY v1.0   #\n");
174         printf (" #######################\n");
175         printf (" # VISUALIZZA CONTATTO #\n");
176         printf (" #######################\n\n");
177         printf (" NOME > %s\n", p->inf.nome);
178         printf (" COGNOME > %s\n", p->inf.cognome);
179         printf (" TELEFONO > %s\n", p->inf.telefono);
180         printf (" EMAIL > %s\n", p->inf.email);
181         printf (" SITOWEB > %s\n", p->inf.sitoweb);
182         pausa();
183     
184       } // IF - CLOSE
185     
186       while (p != NULL)
187       { // WHILE - OPEN
188     
189         /*
190          * Stampo gli altri contatti
191          */
192         system(pulisci); // PULISCE LO SCHERMO
193         printf (" #######################\n");
194         printf (" # RUBRICA EASY v1.0   #\n");
195         printf (" #######################\n");
196         printf (" # VISUALIZZA CONTATTO #\n");
197         printf (" #######################\n\n");
198         printf (" NOME > %s\n", p->inf.nome);
199         printf (" COGNOME > %s\n", p->inf.cognome);
200         printf (" TELEFONO > %s\n", p->inf.telefono);
201         printf (" EMAIL > %s\n", p->inf.email);
202         printf (" SITOWEB > %s\n", p->inf.sitoweb);
203         pausa();
204         // Leggo l'elemento successivo
205         p = p->pun;
206     
207       } // WHILE - CLOSE
208     
209       return;
210     
211     } // visualizzaContatto() - CLOSE
212     
213     /*
214      * Aggiungo un nuovo contatto
215      */
216     struct elemento *aggiungiContatto(struct elemento *p)
217     { // aggiungiContatto() - OPEN
218     
219       system(pulisci); // PULISCE LO SCHERMO
220       printf (" #######################\n");
221       printf (" # RUBRICA EASY v1.0   #\n");
222       printf (" #######################\n");
223       printf (" # AGGIUNGI CONTATTO   #\n");
224       printf (" #######################\n\n");
225     
226       // Dichiaro le variabili
227       char nome[50];
228       char cognome[50];
229       char telefono[30];
230       char email[100];
231       char sitoweb[200];
232       t_contatto daInserire;
233       struct elemento *punt;
234     
235       // Popolo la variabile daInserire
236       printf (" NOME > ");
237       scanf ("%s", nome);
238       strcpy(daInserire.nome, nome);
239       printf (" COGNOME > ");
240       scanf ("%s", cognome);
241       strcpy(daInserire.cognome, cognome);
242       printf (" TELEFONO > ");
243       scanf ("%s", telefono);
244       strcpy(daInserire.telefono, telefono);
245       printf (" EMAIL > ");
246       scanf ("%s", email);
247       strcpy(daInserire.email, email);
248       printf (" SITOWEB > ");
249       scanf ("%s", sitoweb);
250       strcpy(daInserire.sitoweb, sitoweb);
251     
252       if(p != NULL)
253       { // IF - OPEN
254     
255         /* creazione elementi successivi */
256         // Alloco la memoria necessaria
257         punt = (struct elemento *)malloc(sizeof(struct elemento));
258         // Metto daInserire nell'informazione del puntatore
259         punt->inf = daInserire;
260         // Metto il puntatore in testa alla lista
261         punt->pun = p;
262     
263       } else { // ELSE
264     
265         /* creazione primo elemento */
266         // Alloco la memoria necessaria
267         p = (struct elemento *)malloc(sizeof(struct elemento));
268         // Metto daInserire nell'informazione del puntatore
269         p->inf = daInserire;
270         // p punta a NULL, ovvero il marcatore di fine lista
271         p->pun = NULL;
272         // Assegno p a punt
273         punt = p;
274     
275       } // IF - CLOSE
276     
277       // Esce dalla funzione e restituisce la lista
278       return(punt);
279     
280     } // aggiungiContatto() - CLOSE
281     
282     /*
283      * Modifico un contatto presente
284      */
285     struct elemento *modificaContatto(struct elemento *p)
286     { // modificaContatto() - OPEN
287     
288       // Dichiaro le variabili

[289 - 294 omissis]

295       struct elemento *twin = p;
296       int subscelta;
297       int i=1;
298       int n=1;
299     
300       // Stampo la schermata
301       system(pulisci); // PULISCE LO SCHERMO
302       printf (" #######################\n");
303       printf (" # RUBRICA EASY v1.0   #\n");
304       printf (" #######################\n");
305       printf (" # MODIFICA CONTATTO   #\n");
306       printf (" #######################\n\n");
307     
308       // Stampo la lista di contatti
309       while (p != NULL)
310       { // WHILE - OPEN
311     
312         printf ("%i) \t %s \t %s\n", i, p->inf.nome, p->inf.cognome);
313         // Leggo l'elemento successivo
314         p = p->pun;
315         i++;
316     
317       } // WHILE - CLOSE
318     
319       // Ottengo il valore originario di p
320       p = twin;
321     
322       // Scelgo l'emento da modificare
323       printf("\n\n Inserisci il numero del contatto che vuoi modificare: ");
324       scanf("%i", &subscelta);
325     
326       for (n=1; n<i; n++)
327       { // FOR - OPEN
328     
329         /*
330          * Trovato l'elemento modifico l'informazione dentro di esso
331          */
332         if (subscelta == n)
333         { // IF - OPEN
334     
335           // Popolo la variabile daInserire
336           printf (" NOME [%s] > ", p->inf.nome);
337           scanf ("%s", p->inf.nome);
338           printf (" COGNOME [%s] > ", p->inf.cognome);
339           scanf ("%s", p->inf.cognome);
340           printf (" TELEFONO [%s] > ", p->inf.telefono);
341           scanf ("%s", p->inf.telefono);
342           printf (" EMAIL [%s] > ", p->inf.email);
343           scanf ("%s", p->inf.email);
344           printf (" SITOWEB [%s] > ", p->inf.sitoweb);
345           scanf ("%s", p->inf.sitoweb);
346     
347         } // IF - CLOSE
348     
349         p = p->pun;
350     
351       } // FOR - CLOSE
352     
353       // Esce dalla funzione e restituisce la lista
354       return twin;
355     
356     } // modificaContatto() - CLOSE
357     
358     /*
359      * Rimuovo un contatto
360      */
361     struct elemento *rimuoviContatto(struct elemento *p)
362     { // rimuoviContatto() - OPEN
363     
364       // Dichiaro le variabili
365       struct elemento *aus;
366       struct elemento *twin = p;
367       int subscelta;
368       int i=1;
369       int n=1;
370     
371       // Stampo la schermata
372       system(pulisci); // PULISCE LO SCHERMO
373       printf (" #######################\n");
374       printf (" # RUBRICA EASY v1.0   #\n");
375       printf (" #######################\n");
376       printf (" # RIMUOVI CONTATTO    #\n");
377       printf (" #######################\n\n");
378     
379       // Stampo la lista di contatti
380       while (p != NULL)
381       { // WHILE - OPEN
382     
383         printf ("%i) \t %s \t %s\n", i, p->inf.nome, p->inf.cognome);
384         p = p->pun; // scorre di un elemento
385         i++;
386     
387       } // WHILE - CLOSE
388     
389       // Ottengo il valore originario di p
390       p = twin;
391     
392       // Scelgo l'emento da eliminare
393       printf("\n\n Inserisci il numero del contatto che vuoi rimuovere: ");
394       scanf("%i", &subscelta);
395     
396       if (subscelta < i)
397       { // IF - OPEN
398     
399         // Se la lista èvuota esco
400         if(p == NULL)
401           return;
402     
403         // Se la lista ha almeno due elmenti...
404         if(p->pun != NULL)
405         { // IF - OPEN
406     
407           // ... inizializzo un puntatore ausiliario ...
408           aus=p;
409           n++;
410     
411           // ... e faccio un ciclo per trovare l'elemento da eliminare ...
412           while(n != i)
413           { // WHILE - OPEN
414     
415             // Trovato l'elemento gli faccio puntare l'oggetto puntato dal suo
416             // puntatore, in poche parole "salto" l'elemento da eliminare
417             if(subscelta == n)
418             { // IF - OPEN
419     
420               aus->pun=aus->pun->pun;
421     
422             } else { // ELSE
423     
424               // Nel caso in cui il puntatore fosse NULL, per non creare casini
425               // glielo assegniamo direttamente
426               aus=aus->pun;
427     
428             } // IF - CLOSE
429     
430             n++;
431     
432           } // WHILE - CLOSE
433     
434         } // IF - CLOSE
435     
436         /*
437          * Se si vuole rimuovere il primo elemento, si assegna
438          * a p il valore del suo oggetto puntato; questo accade
439          * quando subscelta == 1
440          */
441         if(subscelta == 1)
442         { // IF - OPEN
443     
444           p=p->pun;
445     
446         } // IF - CLOSE
447     
448       } // IF - CLOSE
449     
450       // Copia di nuovo il valore p modificato in twin
451       twin = p;
452     
453       // Esce dalla funzione e restituisce la lista
454       return twin;
455     
456     } // rimuoviContatto() - CLOSE
457     
458     /*
459      * Leggo i contatti dal file rubrica.txt
460      */
461     struct elemento *leggiDaFile(struct elemento *p)
462     { // leggiDaFile - OPEN
463     
464       // Dichiaro le variabili
465       t_contatto daInserire;
466       t_contatto vuoto; // elemento vuoto
467       struct elemento *punt = p;
468       char linea[500]; // stringa per l'acquisizione
469       int index=0; // inizializza l'indice
470     
471       // Apre il file
472       FILE *stream = fopen("rubrica.txt","rt");
473     
474       // Salvo la lista di contatti
475       while(fgets(linea, 500, stream) != NULL)
476       { // WHILE - OPEN
477     
478         
479         index = strcspn(linea, ",");
480         strncpy(daInserire.nome, linea, index);
481         substring(daInserire.nome, daInserire.nome, 0, index-1);
482         substring(linea, linea, index+1, strlen(linea));
483         index = strcspn(linea, ",");
484         strncpy(daInserire.cognome, linea, index);
485         substring(daInserire.cognome, daInserire.cognome, 0, index-1);
486         substring(linea, linea, index+1, strlen(linea));
487         index = strcspn(linea, ",");
488         strncpy(daInserire.telefono, linea, index);
489         substring(daInserire.telefono, daInserire.telefono, 0, index-1);
490         substring(linea, linea, index+1, strlen(linea));
491         index = strcspn(linea, ",");
492         strncpy(daInserire.email, linea, index);
493         substring(daInserire.email, daInserire.email, 0, index-1);
494         substring(linea, linea, index+1, strlen(linea));
495         strcpy(daInserire.sitoweb, linea);
496         substring(daInserire.sitoweb, daInserire.sitoweb, 0, strlen(daInserire.sitoweb)-2);
497     
498         // Aggiunge l'elemento alla lista
499         p = punt;
500         punt = (struct elemento *)malloc(sizeof(struct elemento));
501         punt->inf = daInserire;
502         punt->pun = p;
503     
504         // azzera il valore di daInserire
505         daInserire = vuoto;
506     
507       } // WHILE - CLOSE
508     
509       // Chiude il file
510       fflush(stream);
511       fclose(stream);
512     
513       // Esce dalla funzione e restituisce la lista
514       return(punt);
515     
516     } // leggiDaFile - CLOSE
517     
518     /*
519      * Salvo i contatti inseriti in un file di nome rubrica.txt
520      */
521     int salvaSuFile(struct elemento *p)
522     { // salvaSuFile() - OPEN
523     
524       // Apre il file
525       FILE *stream = fopen("rubrica.txt","w");
526     
527       // Salvo la lista di contatti
528       while (p != NULL)
529       { // WHILE - OPEN
530     
531         // Scrive sul file
532         fprintf(stream, "%s,%s,%s,%s,%s\n", p->inf.nome, p->inf.cognome, p->inf.telefono, p->inf.email, p->inf.sitoweb);
533         // legge l'emento successivo
534         p = p->pun;
535     
536       } // WHILE - CLOSE
537     
538       // Chiude il file
539       fflush(stream);
540       fclose(stream);
541     
542       // Esce dalla funzione
543       return;
544     
545     } // salvaSuFile() - CLOSE
546     
547     /*
548      * Funzione che prende una sottostringa partendo da un'indice
549      * base per un numero di caratteri pari a dimensione
550      */
551     void substring(char* dest, char *source, int i_base, int i_dim)
552     { // substring() - OPEN
553     
554       int i = 0;
555     
556       for (i=i_base; i<i_dim+1; i++)
557       { // FOR - OPEN
558     
559         dest[i-i_base] = source[i];
560     
561       } // FOR - CLOSE
562     
563       dest[i]='\0';
564     
565       return;
566     
567     } // substring() - CLOSE
568     
569     /*
570      * Funzione che blocca lo schermo ad aspetta che l'utente
571      * prema INVIO
572      */
573     void pausa()
574     { // pausa() - OPEN
575     
576       char invio;
577       printf("\n\n - premi INVIO per continuare -\n");
578       invio = getchar();
579       return;
580     
581     } // pausa() - CLOSE