Gestione Archivio Telefonico

printf("\nHAI SCELTO DI VEDERE IL NUMERO DI CHIAMATE DA E

VERSO UN NUMERO\n\nInserisci il numero: ");

gets(Numero_tel);

vedi_chiamate(persona,Numero_tel);//questa è la chiamata alla funzione

vedi_chiamate per visualizzare le chiamate ricevute ed effettuate

system("PAUSE");//serve per mettere il sistema in pausa e continuare solo se

viene premuto un tasto da tastiera

system("cls");//è un'istruzione che serve per pulire lo schermo del computer

break;

case '4':system("cls");//è un'istruzione che serve per pulire lo schermo del

computer if(visualizza_elenco(persona))//nell'if c'è la chiamata alla funzione

visualizza_elenco che ci consente di vedere tutti i dati relativi ai contatti inseriti

{ printf("\nQUESTI SONO I CONTATTI TROVATI NELLA

RUBRICA\n");

}

else

printf("\nLa rubrica e' vuota\n");// se non sono stati aggiunti ancora nominativi

si visualizza che la rubrica è priva di contatti

system("PAUSE");//serve per mettere il sistema in pausa e continuare solo se

viene premuto un tasto da tastiera

system("cls");//è un'istruzione che serve per pulire lo schermo del computer

break;

}

fflush(stdin);//questa istruzione pulisce il buffer della tastiera

}while (scelta!=27);//27 nel codice ASCII è il tasto ESC

system("cls");//è un'istruzione che serve per pulire lo schermo del computer

printf("Arrivederci\n");

}

FUNCTION.c

#include "header.h"

//************************visualizza_numero***************************************

*************************************

//Dati di input:la variabile struttura elenco relativa alla struct contatto,n che corrisponde al

//numero dei contatti, *chiave che è un puntatore ed è l'elemento da ricercare,

//*nome che è un puntatore e corrisponde al nome del contatto telefonico.

//Dati di output:la visualizzazione del numero telefonico di un contatto del quale sono stati

//inseriti solamente il nome e il cognome da tastiera.

//Caratteristiche:L'algoritmo qui usato per visualizzare il numero telefonico dati il nome e il

cognome del

//contatto si basa sull'approccio Divide-et-impera che permette di sezionare il problema in

diversi

//sottoproblemi,che sono simili a quello originale ma coinvolgono un minore numero di

dati.Risolvendo i sottoproblemi

//e combinando le loro soluzioni si ottiene la soluzione del problema di partenza.In questa

circostanza,

//dato un elenco telefonico in ordine crescente per cognome, effettuo la ricerca binaria in base

//al cognome e controllo se coincide anche il nome.

//*******************************************************************************

*************************************

//int n coincide con il define N

int visualizza_numero(struct contatto elenco[], int n, char *chiave, char *nome)

{ int mediano;

if(n == 0)//se il numero dei contatti inseriti è uguale a zero

return 0;//allora visto che non trova il nome e il cognome abbiamo return 0,cioè

non ritorna il numero telefonico

//autoattivazioni

mediano = (n-1)/2;

//soluzione del caso base

if((strcmp(chiave,elenco[mediano].cognome) == 0))

{ printf("\nEcco il numero telefonico: %s",elenco[mediano].numero);

return 1; // se trova il nome e il cognome abbiamo return 1

}

//autoattivazioni

else

{ if(strcmp(chiave,elenco[mediano].cognome) < 0)

return visualizza_numero(elenco,mediano,chiave,nome);

else return visualizza_numero(elenco+mediano+1, n-mediano-

1,chiave,nome);

}

}

//*******************************aggiungi_contatto********************************

*************

//Dati di input:la variabile struttura persona[] relativa al contatto.

//Dati di output:la visualizzazione che il contatto è stato aggiunto con successo.

//Caratteristiche:facendo uso di un ciclo for che utilizza l'indice i che va da 0 a N che è

// il numero massimo di contatti,vengono riempiti le variabili stringa e le variabili

//intere della struct contatto con tutti i dati e ovviamente la variabile Quantita viene posta

//ad 1 proprio per indicare l'aggiunta del contatto.

//*******************************************************************************

**************

//Questa è la function che serve per aggiungere un contatto nella rubrica telefonica

int aggiungi_contatto(struct contatto persona[])

{ char Nome[30],Cognome[30],Numero[30];

int i,ricevute,effettuate;

fflush(stdin);

printf("\nHAI SCELTO DI AGGIUNGERE UN CONTATTO\n\nInserisci il nome: ");

gets(Nome);

printf("\nInserisci il cognome: ");

gets(Cognome);

printf("\nInserisci il numero: ");

gets(Numero);

printf("\nInserisci il numero chiamate ricevuto: ");

scanf("%d",&ricevute);

printf("\nInserisci il numero chiamate effettuate: ");

scanf("%d", &effettuate);

for(i=0;i<N;i++)

{ if(persona[i].Quantita==0)

{ strcpy(persona[i].nome,Nome);

strcpy(persona[i].cognome,Cognome);

strcpy(persona[i].numero,Numero);

persona[i].Ricevuto = ricevute;

persona[i].Effettuate = effettuate;

persona[i].Quantita=1;

printf("\nLA PERSONA E' STATA AGGIUNTA ALLA RUBRICA

TELEFONICA\n"); return 1;

}

} printf("\nNON C'E' SPAZIO NELL'ARCHIVIO\n");//se il numero di contatti

aggiunti supera il 30

//viene visualizzato questo messaggio di errore

return 0;

}

//*********************************inizializza*************************************

*************

//Dati di input:la variabile struttura persona[] relativa alla struct contatto.

//Dati di output:tutte le variabili interne alla struct contatto vengono poste pari a zero

//in modo che se non sono stati ancora immessi contatti la rubrica è vuota.

//Caratteristiche:facendo uso di un ciclo for che usa l'indice i che va da 0 a N che è il numero

//massimo di contatti,viene svuotato il contenuto delle stringhe nome,cognome e numero e

vengono

//posti uguali a zero le variabili struttura Ricevuto,Effettuate e Quantita.

//*******************************************************************************

***************

//Questa è la function che serve per inizializzare a zero il numero dei contatti,con il relativo

nome,cognome,numero,

//numero di chiamate ricevute ed effettuate

void inizializza(struct contatto persona[])

{ int i;//contatore

for(i=0;i<N;i++)

{ strcpy(persona[i].nome,"");

strcpy(persona[i].cognome,"");

strcpy(persona[i].numero,"");

persona[i].Ricevuto = 0;

persona[i].Effettuate = 0;

persona[i].Quantita = 0;

}

}

//****************************cancella_contatto************************************

***************

//Dati di input:la variabile struttura persona[] relativa alla struct contatto.

//Dati di output:la visualizzazione della cancellazione del contatto avvenuta con successo.

//Caratteristiche:facendo un ciclo for che vede coinvolto l'indice i che va da 0 a N che è

//il numero massimo di contatti,si cerca di trovare il nome e il cognome immessi da tastiera

//nella rubrica attraverso la funzione strcmp: se vengono trovati il contatto viene cancellato,se

//non vengono trovati si ha un messaggio di errore.

//*******************************************************************************

*****************

//Questa è la function che serve per cancellare un contatto dalla rubrica telefonica

int cancella_contatto(struct contatto persona[])

{ int i;//contatore

char nome_cont[30];

char cognome_cont[15];

printf("\nHAI SCELTO DI CANCELLARE UN CONTATTO\n\nInserisci il nome: ");

gets(nome_cont);

printf("\nInserisci il cognome: ");

gets(cognome_cont);

for(i=0;i<N;i++)

{

if((strcmp(nome_cont,persona[i].nome)&&(strcmp(cognome_cont,persona[i].cognome)))==0)/

/la persona che si deve cancellare deve essere

//prima trovata nell'elenco per poi cancellarla

{

strcpy(persona[i].nome,"");

strcpy(persona[i].cognome,"");

persona[i].Quantita=0;

printf("\nLA PERSONA E' STATA ELIMINATA DALLA RUBRICA\n");

return 1;

}

//la ricerca ha prodotto risultati e quindi il contatto ricercato viene eliminato

}

printf("\nNON E' STATO TROVATO ALCUN CONTATTO CON I DATI

IMMESSI\n");//la ricerca ha dato esito negativo e quindi non si elimina niente

return 0;

}

//***************************************ordina_elenco****************************

*******************

//Dati di input:la variabile struttura persona[] relativa alla struct contatto.

//Dati di output:l'ordinamento in ordine alfabetico del cognome della lista dei contatti

aggiunti.

//Caratteristiche:facendo un ciclo for che vede coinvolti due contatori i e j compariamo la

stringa

//relativa al cognome di indice i con la stringa relativa al cognome di indice j:si usa una

variabile

// d'appoggio che si chiama temp per ordinare il contatto che viene prima nell'ordine

alfabetico.

//*******************************************************************************

********************

void ordina_elenco(struct contatto persona[])

{ struct contatto temp;//dichiaro rubrica come variabile temporanea

int i,j;//contatori

for(i=0;i<N-1;i++)

{ for(j=i+1;j<N;j++)

{ if(strcmp(persona[i].cognome,persona[j].cognome)>0)

{ temp= persona[i];

persona[i]= persona[j];

persona[j]=temp;

}

}

}

}

//**********************************vedi_chiamate********************************

******************************************

//Dati di input:la variabile struttura persona[] relativa alla struct contatto, il vettore chiave[].

//Dati di output:la visualizzazione delle chiamate ricevute ed effettuate da un contatto

//Caratteristiche:facendo un ciclo for in cui si usa un contatore i che va da 0 a N che è il

numero massimo di contatti,

//viene comparata la stringa relativa al numero con la variabile chiave che è l'elemento da

ricercare:se coincidono allora

//viene trovato il numero e viene fatto vedere il numero di chiamate ricevute ed effettuate dal

contatto

//*******************************************************************************

******************************************

int vedi_chiamate(struct contatto persona[], char chiave[])

{ int i;//contatore

for(i=0;i<N;i++)

{ if(strcmp(persona[i].numero,chiave)==0)

{ printf("I dati relativi al numero inserito sono questi:\n");

printf("*********************");

printf("\nNome: %s",persona[i].nome);

printf("\nCognome: %s",persona[i].cognome);

printf("\nChiamate ricevute: %d",persona[i].Ricevuto);

printf("\nChiamate effettuate: %d\n&q