// ————————————————————————————————————————-
// Università degli Studi di Ferrara - Corso di Laurea in Informatica - A.A. 2012/13
// ————————————————————————————————————————-
// D’Amato Alessandro, Mat. 113864
// Sacchetto Riccardo, Mat. 112203
// ———[Esercitazione 2]—————————————————————————————
//Includo le 3 librerie necessarie
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//Struttura dati per memorizzare le parole chiave
struct parole_chiave{
char parola_c[100];
};
//Struttura dati per memorizzare i libri
struct libro{
char codice[5];
char autore[100];
char titolo[100];
struct parole_chiave parole[5];
struct libro *next;
};
//Struttura dati per acquisire le parole chiave necessarie alla ricerca.
struct insieme_chiavi{
char chiave[100];
};
//Struttura dati per numerare i libri nella funzione elimina
struct elimina{
int numero;
struct libro *now;
};
//Funzione stampa, il cui scopo è visualizzare la lista dei libri contenuti nella lista. Alla funzione passo la testa della lista.
void stampa(struct libro **testa_lista_ciclo){
//Dichiaro la variabile p e le assegno la testa della lista.
struct libro *p;
p=*testa_lista_ciclo;
//Dichiaro la variabile conta_libro, per poter contare i libri contenuti nella lista
int conta_libro;
conta_libro=1;
//Se non vi sono elementi avverto l’utente che la libreria è vuota
if(p == NULL){
printf(“ \n”);
printf(“**********************\n”);
printf(“ LIBRERIA VUOTA! \n”);
printf(“**********************\n”);
printf(“ \n”);
return;
}
//Tramite un costrutto if ed un ciclo while, stampo tutti gli elementi finchè l’indirizzo del successivo esiste, quando diventa NULL
//stampo l’ultimo elemento.
if(p->next == NULL){
printf(“——————————————————————————————\n”);
printf(“Libro numero %d\n”,conta_libro);
printf(“************************************************************\n”);
printf(“Codice: %s \n”,p->codice);
printf(“Titolo: %s \n”,p->titolo);
printf(“Autore: %s \n”,p->autore);
printf(“Chiave 1: %s \n”,p->parole[0].parola_c);
printf(“Chiave 2: %s \n”,p->parole[1].parola_c);
printf(“Chiave 3: %s \n”,p->parole[2].parola_c);
printf(“Chiave 4: %s \n”,p->parole[3].parola_c);
printf(“Chiave 5: %s \n”,p->parole[4].parola_c);
printf(“——————————————————————————————\n”);
}else{
while(p->next != NULL){
printf(“——————————————————————————————\n”);
printf(“Libro numero %d\n”,conta_libro);
printf(“************************************************************\n”);
printf(“Codice: %s \n”,p->codice);
printf(“Titolo: %s \n”,p->titolo);
printf(“Autore: %s \n”,p->autore);
printf(“Chiave 1: %s \n”,p->parole[0].parola_c);
printf(“Chiave 2: %s \n”,p->parole[1].parola_c);
printf(“Chiave 3: %s \n”,p->parole[2].parola_c);
printf(“Chiave 4: %s \n”,p->parole[3].parola_c);
printf(“Chiave 5: %s \n”,p->parole[4].parola_c);
printf(“——————————————————————————————\n”);
p=p->next;
conta_libro++;
}
printf(“——————————————————————————————\n”);
printf(“Libro numero %d\n”,conta_libro);
printf(“************************************************************\n”);
printf(“Codice: %s \n”,p->codice);
printf(“Titolo: %s \n”,p->titolo);
printf(“Autore: %s \n”,p->autore);
printf(“Chiave 1: %s \n”,p->parole[0].parola_c);
printf(“Chiave 2: %s \n”,p->parole[1].parola_c);
printf(“Chiave 3: %s \n”,p->parole[2].parola_c);
printf(“Chiave 4: %s \n”,p->parole[3].parola_c);
printf(“Chiave 5: %s \n”,p->parole[4].parola_c);
printf(“——————————————————————————————\n”);
}
}
//Funzione inserisci_libro, necessaria per l’inserimento del libro nella lista
void inserisci_libro(struct libro **testa_lista_ciclo){
//Dichiaro le variabili necessarie: p, testo che sono gli elementi temporanei della lista, e conta libri, che provvede a contare i libri inseriti.
struct libro *p;
struct libro *testo;
int conta_libri;
conta_libri=0;
int len;
//Se i libri inseriti sono pari a 500, come da consegna, l’utente viene avvertito e viene impedito l’inserimento di ulteriori elementi.
if(conta_libri > 500){
printf(“****************************************************************\n”);
printf(“ E’ STATO RAGGIUNTO IL LIMITE MASSIMO DI LIBRI MEMORIZZABILI”);
printf(“****************************************************************\n”);
return;
}else{
//Altrimenti, viene allocato lo spazio necessario per un nuovo elemento
testo=(struct libro*)malloc(sizeof(struct libro));
//Tramite un costrutto if, se non vi sono elementi inseriti, viene creato il primo
//elemento e l’utente ne inserisce i dati: vengono usati scanf per le stringhe senza spazi, fgets per titolo ed autore, che possono contenere spazi,
//viene inoltre impiegato un ciclo for per l’inserimento delle 5 parole chiave
if(*testa_lista_ciclo == NULL){
printf(“Inserisci il codice del libro: \n”);
scanf(“%s”,testo->codice);
printf(“Inserisci il titolo del libro: \n”);
getchar();
fgets(testo->titolo,100,stdin);
//Rimuovo il caporiga automatico che fgets inserisce quando prende una stringa
len = strlen(testo->titolo);
if (testo->titolo[len - 1] == ‘\n’)
testo->titolo[len - 1] = ‘\0’;
printf(“Inserisci l’autore del libro: \n”);
fgets(testo->autore,100,stdin);
//Rimuovo il caporiga automatico che fgets inserisce quando prende una stringa
len = strlen(testo->autore);
if (testo->autore[len - 1] == ‘\n’)
testo->autore[len - 1] = ‘\0’;
int i;
for(i=0;i<5;i++){
printf(“Inserisci parola chiave %d: \n”, i+1);
scanf(“%s”,testo->parole[i].parola_c);
}
testo->next = NULL;
*testa_lista_ciclo=testo;
//Qui si passa all’inserimento degli elementi successivi. L’acquisizione dei dati avviene come nel caso precedente, l’unica differenza è un
//ciclo while che scorre la lista, in modo che l’inserimento sia effettuato in coda.
}else{
p=*testa_lista_ciclo;
while(p->next != NULL){
p = p->next;
}
p->next=testo;
printf(“Inserisci il codice del libro: \n”);
scanf(“%s”,testo->codice);
printf(“Inserisci il titolo del libro: \n”);
getchar();
fgets(testo->titolo,100,stdin);
len = strlen(testo->titolo);
if (testo->titolo[len - 1] == ‘\n’)
testo->titolo[len - 1] = ‘\0’;
printf(“Inserisci l’autore del libro: \n”);
fgets(testo->autore,100,stdin);
len = strlen(testo->autore);
if (testo->autore[len - 1] == ‘\n’)
testo->autore[len - 1] = ‘\0’;
int i;
for(i=0;i<5;i++){
printf(“Inserisci parola chiave %d: \n”, i+1);
scanf(“%s”,testo->parole[i].parola_c);
}
testo->next = NULL;
}
}
}
//Funzione ricerca_libro_1, cerca tra i libri memorizzati in base a 3 parole chiave fornitele,
//secondo un criterio OR, ovvero il libro deve contenere almeno una delle parole chiave inserite
void ricerca_libro_1(struct insieme_chiavi key_ciclo[3], struct libro **testa_lista_ciclo ){
//Creo le variabili i e j per i cicli, conta_libro per numerare i libri, sentinella per gestire
//le operazioni di ricerca, libro per contenere temporaneamente gli elementi della lista.
//risposta e da_eliminare per implementare la possibilità di cancellare i libri selezionati dalla lista
int j=0;
int i=0;
int conta_libro;
conta_libro=1;
int risposta;
struct elimina da_eliminare[500];
int sentinella;
sentinella=0;
struct libro *p;
//Assegno a p il primo elemento della lista
p=*testa_lista_ciclo;
if(p->next == NULL){
//Tramite due cicli for concatenati ed un costrutto if, comparo ognuna delle 3 parole chiave inserite ad ognuna delle 5 parole chiave definite per il primo libro
for(j=0;j<5;j++){
for(i=0;i<3;i++){
//Uso la variabile sentinella per resettare la ricerca dopo ogni elemento comparato
if(sentinella == 0){
//Se la parola combacia, stampo le informazioni del libro e gli assegno un numero che
//mi permette di identificarlo successivamente
if(strcmp(p->parole[j].parola_c,key_ciclo[i].chiave) == 0 ){
da_eliminare[conta_libro].numero=conta_libro;
da_eliminare[conta_libro].now=p;
printf(“——————————————————————————————\n”);
printf(“Libro numero %d\n”,conta_libro);
printf(“************************************************************\n”);
printf(“Codice: %s \n”,p->codice);
printf(“Titolo: %s \n”,p->titolo);
printf(“Autore: %s \n”,p->autore);
printf(“Chiave_1: %s \n”,p->parole[0].parola_c);
printf(“Chiave_2: %s \n”,p->parole[1].parola_c);
printf(“Chiave_3: %s \n”,p->parole[2].parola_c);
printf(“Chiave_4: %s \n”,p->parole[3].parola_c);
printf(“Chiave_5: %s \n”,p->parole[4].parola_c);
printf(“——————————————————————————————\n”);
conta_libro++;
sentinella=1;
}
}else{
break;
}
}
}
}else{
//Scorro gli altri elementi con un ciclo while
while(p->next != NULL){
//Sempre usando due cicli for concatenati ed un costrutto if, comparo ognuna delle 3 parole chiave inserite ad ognuna delle 5 parole chiave definite per ogni libro
for(j=0;j<5;j++){
for(i=0;i<3;i++){
//Uso la variabile sentinella per resettare la ricerca dopo ogni elemento comparato
if(sentinella == 0){
//Se la parola combacia, stampo le informazioni del libro e gli assegno un numero che
//mi permette di identificarlo successivamente
if(strcmp(p->parole[j].parola_c,key_ciclo[i].chiave) == 0 ){
da_eliminare[conta_libro].numero=conta_libro;
da_eliminare[conta_libro].now=p;
printf(“——————————————————————————————\n”);
printf(“Libro numero %d\n”,conta_libro);
printf(“************************************************************\n”);
printf(“Codice: %s \n”,p->codice);
printf(“Titolo: %s \n”,p->titolo);
printf(“Autore: %s \n”,p->autore);
printf(“Chiave_1: %s \n”,p->parole[0].parola_c);
printf(“Chiave_2: %s \n”,p->parole[1].parola_c);
printf(“Chiave_3: %s \n”,p->parole[2].parola_c);
printf(“Chiave_4: %s \n”,p->parole[3].parola_c);
printf(“Chiave_5: %s \n”,p->parole[4].parola_c);
printf(“——————————————————————————————\n”);
conta_libro++;
sentinella=1;
}
}else{
break;
}
}
}
sentinella=0;
p = p->next;
//Eseguo la stessa procedura per l’ultimo elemento.
for(j=0;j<5;j++){
for(i=0;i<3;i++){
if(sentinella == 0){
if(strcmp(p->parole[j].parola_c,key_ciclo[i].chiave) == 0 ){
da_eliminare[conta_libro].numero=conta_libro;
da_eliminare[conta_libro].now=p;
printf(“——————————————————————————————\n”);
printf(“Libro numero %d\n”,conta_libro);
printf(“************************************************************\n”);
printf(“Codice: %s \n”,p->codice);
printf(“Titolo: %s \n”,p->titolo);
printf(“Autore: %s \n”,p->autore);
printf(“Chiave_1: %s \n”,p->parole[0].parola_c);
printf(“Chiave_2: %s \n”,p->parole[1].parola_c);
printf(“Chiave_3: %s \n”,p->parole[2].parola_c);
printf(“Chiave_4: %s \n”,p->parole[3].parola_c);
printf(“Chiave_5: %s \n”,p->parole[4].parola_c);
printf(“——————————————————————————————\n”);
conta_libro++;
sentinella=1;
}
}else{
break;
}
}
}
}
}
//Chiedo all’utente se desidera eliminare un libro tra quelli trovati, in caso affermativo inserirà il numero assegnato al libro precedentemente. Se l’utente inserisce un numero errato, il programma glielo segnala.
risposta=501;
while(risposta > conta_libro || risposta < 0 ){
if(risposta > conta_libro || risposta < 0){
if(risposta==501){
printf(“Per eliminare un libro inserisci suo codice corrispondente, in caso contrario per tornare al menu principale premi il tasto 0: “);
scanf(“%d”,&risposta);
}else{
printf(“\n”);
printf(“Inserimento errato! devi inserire un numero valido: “);
scanf(“%d”,&risposta);
}
}else{
printf(“Per eliminare un libro inserisci suo codice corrispondente, in caso contrario per tornare al menu principale premi il tasto 0: “);
scanf(“%d”,&risposta);
}
}
//Se l’utente, invece, sceglie di non eliminare nulla, scrive 0 e viene così riportato al menù principale
if(risposta == 0){
return;
//Altrimenti il libro scelto viene eliminato dalla lista
}else{
//Vengono create due variabili temporanee per contenere gli elementi della lista da modificare
struct libro *now;
struct libro *temp;
//Viene assegnato l’indirizzo dell’elemento da eliminare a now
now=da_eliminare[risposta].now;
//Viene assegnato a p l’inizio della lista, con while scorro gli elementi finché trovo quello con
//l’indirizzo desiderato (che sarà l’elemento precedente) e gli assegno l’indirizzo dell’elemento successivo.
p=*testa_lista_ciclo;
//Se l’elemento è l’unico della lista, procedo con questa parte del codice
if(p->next == NULL){
//Svuoto l’area di memoria occupata dall’elemento
free(p);
//Assegno il puntatore all’elemento successivo (se presente) o a NULL
*testa_lista_ciclo= NULL;
//Avverto l’utente della compiuta eliminazione con un messaggio
printf(“ \n”);
printf(“*************************\n”);
printf(” ELIMINAZIONE EFFETTUATA\n”);
printf(“*************************\n”);
printf(“ \n”);
}else{
//Se l’elemento è il primo di una lista con più elementi, procedo con questa parte del codice, che funziona in modo analogo alla precedente
if(now == *testa_lista_ciclo){
*testa_lista_ciclo=p->next;
free(p);
printf(“ \n”);
printf(“*************************\n”);
printf(” ELIMINAZIONE EFFETTUATA\n”);
printf(“*************************\n”);
printf(“ \n”);
}else{
//Se l’elemento è successivo al primo, procedo con questa parte del codice, che funziona in modo analogo alla precedente
while(p->next != now){
p = p->next;
}
temp=p;
p = p->next;
temp->next=p->next;
free(p);
printf(“ \n”);
printf(“*************************\n”);
printf(” ELIMINAZIONE EFFETTUATA \n”);
printf(“*************************\n”);
printf(“ \n”);
}
}
}
}
//Funzione ricerca_libro_2, cerca tra i libri memorizzati in base a 3 parole chiave fornitele,
//secondo un criterio AND, ovvero il libro deve contenere tutte le parole chiave inserite
//Il funzionamento è analogo alla precedente, l’unica aggiunta è una variabile trovato, che
//viene incrementata ad ogni parola chiave corrispondente all’intenro di un singolo elemento.
//Se, e solo se, trovato diventa pari a 3,o vvero tutte le parole inserite sono state rilevate
//all’interno dello stesso libro, questo viene stampato.
void ricerca_libro_2(struct insieme_chiavi key_ciclo[3], struct libro **testa_lista_ciclo ){
int j=0;
int i=0;
int conta_libro;
conta_libro=1;
int risposta;
struct elimina da_eliminare[500];
int sentinella;
int trovato;
int k;
trovato=0;
sentinella=0;
struct libro *p;
p=*testa_lista_ciclo;
if(p->next == NULL){
for(j=0;j<5;j++){
//La variabile k mi permette di resettare la ricerca nel caso il criterio non sia rispettato
k=0;
for(i=0;i<3;i++){
if(sentinella == 0 && k==0){
if(strcmp(p->parole[j].parola_c,key_ciclo[i].chiave) == 0 || trovato==3){
if(trovato == 3){
da_eliminare[conta_libro].numero=conta_libro;
da_eliminare[conta_libro].now=p;
printf(“——————————————————————————————\n”);
printf(“Libro numero %d\n”,conta_libro);
printf(“************************************************************\n”);
printf(“Codice: %s \n”,p->codice);
printf(“Titolo: %s \n”,p->titolo);
printf(“Autore: %s \n”,p->autore);
printf(“Chiave 1: %s \n”,p->parole[0].parola_c);
printf(“Chiave 2: %s \n”,p->parole[1].parola_c);
printf(“Chiave 3: %s \n”,p->parole[2].parola_c);
printf(“Chiave 4: %s \n”,p->parole[3].parola_c);
printf(“Chiave 5: %s \n”,p->parole[4].parola_c);
printf(“——————————————————————————————\n”);
conta_libro++;
sentinella=1;
}
trovato++;
k=1;
}
}else{
break;
}
}
}
}else{
while(p->next != NULL){
for(j=0;j<5;j++){
k=0;
for(i=0;i<3;i++){
if(sentinella == 0 && k==0){
if(strcmp(p->parole[j].parola_c,key_ciclo[i].chiave) == 0 || trovato==3){
if(trovato == 3){
da_eliminare[conta_libro].numero=conta_libro;
da_eliminare[conta_libro].now=p;
printf(“——————————————————————————————\n”);
printf(“Libro numero %d\n”,conta_libro);
printf(“************************************************************\n”);
printf(“Codice: %s \n”,p->codice);
printf(“Titolo: %s \n”,p->titolo);
printf(“Autore: %s \n”,p->autore);
printf(“Chiave 1: %s \n”,p->parole[0].parola_c);
printf(“Chiave 2: %s \n”,p->parole[1].parola_c);
printf(“Chiave 3: %s \n”,p->parole[2].parola_c);
printf(“Chiave 4: %s \n”,p->parole[3].parola_c);
printf(“Chiave 5: %s \n”,p->parole[4].parola_c);
printf(“——————————————————————————————\n”);
conta_libro++;
sentinella=1;
}
trovato++;
k=1;
}
}else{
break;
}
}
}
trovato=0;
sentinella=0;
p = p->next;
}
for(j=0;j<5;j++){
k=0;
for(i=0;i<3;i++){
if(sentinella == 0 && k==0){
if(strcmp(p->parole[j].parola_c,key_ciclo[i].chiave) == 0 || trovato==3){
if(trovato == 3){
da_eliminare[conta_libro].numero=conta_libro;
da_eliminare[conta_libro].now=p;
printf(“—————————————————————————————— qui\n”);
printf(“Libro numero %d\n”,conta_libro);
printf(“************************************************************\n”);
printf(“Codice: %s \n”,p->codice);
printf(“Titolo: %s \n”,p->titolo);
printf(“Autore: %s \n”,p->autore);
printf(“Chiave 1: %s \n”,p->parole[0].parola_c);
printf(“Chiave 2: %s \n”,p->parole[1].parola_c);
printf(“Chiave 3: %s \n”,p->parole[2].parola_c);
printf(“Chiave 4: %s \n”,p->parole[3].parola_c);
printf(“Chiave 5: %s \n”,p->parole[4].parola_c);
printf(“——————————————————————————————\n”);
conta_libro++;
sentinella=1;
}
trovato++;
k=1;
}
}else{
break;
}
}
}
}
risposta=501;
while(risposta > conta_libro || risposta < 0 ){
if(risposta > conta_libro || risposta < 0){
if(risposta==501){
printf(“Per eliminare un libro inserisci suo codice corrispondente, in caso contrario per tornare al menu principale premi il tasto 0: “);
scanf(“%d”,&risposta);
}else{
printf(“\n”);
printf(“Inserimento errato! devi inserire un numero valido: “);
scanf(“%d”,&risposta);
}
}else{
printf(“Per eliminare un libro inserisci suo codice corrispondente, in caso contrario per tornare al menu principale premi il tasto 0: “);
scanf(“%d”,&risposta);
}
}
//Anche la procedura di eliminazione funziona in modo analogo a quanto esposto sopra nell’altra funzione.
if(risposta == 0){
return;
}else{
struct libro *now;
struct libro *temp;
now=da_eliminare[risposta].now;
p=*testa_lista_ciclo;
if(p->next == NULL){
free(p);
*testa_lista_ciclo= NULL;
printf(“ \n”);
printf(“*************************\n”);
printf(” ELIMINAZIONE EFFETTUATA \n”);
printf(“*************************\n”);
printf(“ \n”);
}else{
if(now == *testa_lista_ciclo){
*testa_lista_ciclo=p->next;
free(p);
printf(“ \n”);
printf(“*************************\n”);
printf(” ELIMINAZIONE EFFETTUATA \n”);
printf(“*************************\n”);
printf(“ \n”);
}else{
while(p->next != now){
p = p->next;
}
temp=p;
p = p->next;
temp->next=p->next;
free(p);
printf(“ \n”);
printf(“*************************\n”);
printf(” ELIMINAZIONE EFFETTUATA \n”);
printf(“*************************\n”);
printf(“ \n”);
}
}
}
}
//Funzione calcola_dimensione, usata per calcolare il numero di elementi presenti nel file
int calcola_dimensione(FILE *fp)
{
//Vengono inizializzati ed allocati un generico elemento della lista ed una variabile contatore
struct libro *p;
p=(struct libro*) malloc (sizeof(struct libro));
int cont=0;
//Mi posiziono alla fine del file
fseek(fp,0,SEEK_END);
//Prendo la dimensione del file e la divido per quella di un singolo elemento, trovando così il numero degli stessi
cont=ftell(fp)/sizeof(struct libro);
//Mi riporto all’inizio del file così come ero quando sono entrato nella funzione
rewind(fp);
//Restituisco il valore del contatore
return cont;
}
//Funzione apri, il cui scopo è aprire l’archivio dei libri precedentemente salvato o, in sua assenza, crearne uno nuovo
struct libro * apri(){
//Viene aperto il file esterno in modalità di lettura, gli viene assegnato il puntatore fp
FILE *fp=fopen(“libreria”, “r+”);
//Vengono creati p, p2 e testa_lista per contenere temporaneamente i dati, ed i per i cicli.
struct libro *p;
struct libro *p2;
struct libro *testa_lista;
int i;
//Se il file non esiste, viene allocato lo spazio necessario al primo elemento e viene restituito al programma
if(fp == NULL){
printf(“\n”);
printf(“*************************************************************\n”);
printf(“ FILE LIBERIA NON TROVATO. NE VERRA’ CREATO UNO NUOVO. \n”);
printf(“*************************************************************\n”);
printf(“\n”);
return(testa_lista);
}
//Conto il numero di elementi presenti nel file
int cont;
cont=calcola_dimensione(fp);
//Inizializzo la lista per prepararmi all’importazione dei dati
p=(struct libro*)malloc(sizeof(struct libro));
testa_lista=p;
//Leggo gli elementi (il cui numero ho calcolato prima) dal file e popolo la lista
for(i=1;i<=cont;i++)
{
fread(p,sizeof(struct libro),1,fp);
if(i!=cont)
{
p->next=(struct libro*)malloc(sizeof(struct libro));
p=p->next;
}
else
p->next=NULL;
}
//Viene chiuso il file e restituita la testa della lista alla funzione main.
fclose(fp);
return(testa_lista);
}
//Funzione salva, che provvede a salvare su un file esterno la lista generata dal programma
void salva(struct libro **testa_lista_ciclo){
//Viene creato un puntatore di tipo file ed uno di tipo p che conterrà temporaneamente i dati della lista mente vengono scritti su file.
FILE *fp;
struct libro *p;
//Assegno a p la testa della lista
p=*testa_lista_ciclo;
//Se il file su cui salvare non esiste (esisteva da prima oppure è stato creato all’apertura del programma) dò errore
if((fp=fopen(“libreria”, “w”)) == NULL) {
printf(“Errore nell’apertura del file.\n”);
exit(1);
}
//Altrimenti procedo scrivendo sul file tutti gli elementi, tramite un ciclo while che li scorre. Quando arrivo all’ultimo, la condizione
//del costrutto if mi assicura che sarà salvato pure lui.
if(p->next == NULL){
fwrite(p,sizeof(struct libro),1,fp);
}else{
while(p!=NULL)
{
fwrite(p,sizeof(struct libro),1,fp);
p=p->next;
}
}
//Chiudo il file
fclose(fp);
}
/*Funzione libera, per svuotare le aree di memoria usate durante l’esecuzione dell’algoritmo:
viene richiesta la testa della lista, memorizzata in testa_lista_ciclo*/
void libera(struct libro **testa_lista_ciclo)
{
//Creo due variabili temporanee, p e temp
struct libro *p;
struct libro *temp;
//Assegno a p la testa della lista
p=*testa_lista_ciclo;
//Avvio un ciclo while che assegna a temp l’indirizzo di p, passa p all’elemento successivo e svuota temp. Il ciclo continua finchè vi sono elementi nella lista.
while(p->next != NULL){
temp=p;
p=p->next;
free(temp);
}
}
//Funzione main, la funzione principale, che consente di accedere alle varie funzioni del programma
int main(void){
/*Dichiaro le variabili ed i vettori: scelta, che conterrà il numero relativo alla selezione effettuata dall’utente,
insieme_chiavi, che conterrà le chiavi, inserite dall’utente, necessarie alla ricerca, e testa_lista, un puntatore
all’inizio della lista contente i libri. Infine una variabile i necessaria come contatore per i cicli.*/
int scelta=0,ini=0;
struct insieme_chiavi key[3];
struct libro testo;
struct libro *testa_lista;
testa_lista=NULL;
int i=0;
//Apro il file esterno tramite la funzione apri, assegno l’inizio della lista ricavata da esso a testa_lista
testa_lista=apri();
//Visualizzo il menù, che si compone di 5 opzioni, e permette all’utente di sceglierne una.
//Sfrutto un ciclo while per continuare a visualizzarlo finché l’utente non esegue una scelta valida
while(scelta!=5){
printf(“———————————————————————————————- \n”);
printf(“Benvenuto, effettuare una scelta inserendo il numero associato:\n”);
printf(“-| 1 Inserisci un libro \n”);
printf(“-| 2 Ricerca un libro per 3 parola chiave (OR) \n”);
printf(“-| 3 Ricerca un libro per 3 parole chiave (AND) \n”);
printf(“-| 4 Visualizza tutta la libreria \n”);
printf(“-| 5 Esci \n”);
printf(“———————————————————————————————- \n”);
printf(“-| Scelta > “);
scanf(“%d”,&scelta);
//Se la scelta cade fuori dall’intervallo previsto, uso un costrutto if per segnalarlo all’utente
if(scelta <=0 || scelta >5){
printf(“ \n”);
printf(“******************************************* \n”);
printf(“ SCELTA ERRATA!\n”);
printf(“******************************************* \n”);
printf(“ \n”);
}else{
//Se la scelta è permessa, tramite uno switch avvio la procedura richiesta dall’utente
switch(scelta){
case 1:
//Nel caso dell’inserimento, avvio la funzione inserisci libro, passandogli l’indirizzo di testa della lista
inserisci_libro(&testa_lista);
break;
//Nei due casi delle ricerche, sfrutto un ciclo for per far inserire all’utente le parole da cercare, poi avvio la funzione corrispondente, ricerca_libro_1 per una ricerca di tipo OR, oppure ricerca_libro_2 per una ricerca di tipo AND.
//Se la lista risulta priva di elementi, avverto l’utente.
case 2:
if(testa_lista == NULL){
printf(“ \n”);
printf(“**********************\n”);
printf(“ LIBRERIA VUOTA! \n”);
printf(“**********************\n”);
printf(“ \n”);
break;
}
for(i=0;i<3;i++){
printf(“Inserisci parola chiave %d: \n”, i+1);
scanf(“%s”,key[i].chiave);
}
ricerca_libro_1(key, &testa_lista);
break;
case 3:
if(testa_lista == NULL){
printf(“ \n”);
printf(“**********************\n”);
printf(“ LIBRERIA VUOTA! \n”);
printf(“**********************\n”);
printf(“ \n”);
break;
}
for(i=0;i<3;i++){
printf(“Inserisci parola chiave %d: \n”, i+1);
scanf(“%s”,key[i].chiave);
}
ricerca_libro_2(key, &testa_lista);
break;
case 4:
//Se l’utente desidera visualizzare la lista, avvio la funzione stampa passando ad essa l’indirizzo di testa della lista
stampa(&testa_lista);
break;
case 5:
//Nel caso l’utente desideri uscire dal programma, uso la funzione salva per salvare su file la lista, la funzione libera per liberare la memoria utilizzata, e termino l’esecuzione del programma.
salva(&testa_lista);
libera(&testa_lista);
scelta=5;
break;
}
}
}
}
Design by Simon Fletcher. Powered by Tumblr.
© Copyright 2010
