Sei sulla pagina 1di 17

/*

* File: main.cpp
* Author: nicolabernardi
*
* Created on 9 ottobre 2017, 19.34
*/

#include <cstdlib>
#include <stdio.h>
#include <string.h>
#include <iostream>

using namespace std;

struct studente{
int nOrdine;
char Nome[20], Cognome[30];
float mediaVoti;
};

struct nodo{
studente dati;
nodo *next;
nodo *prev;
};

struct list{
nodo *lStart;
nodo *lEnd;
int nElem = 0;
};

list *registro = new list;

struct nodoResult{
nodo *element;
nodoResult *next;
nodoResult *prev;
};

struct listResult{
nodoResult *lStart;
nodoResult *lEnd;
int nElem = 0;
};

typedef nodo* link;

/**/

bool isAnInt(char *str);


studente* scanStudente();
void sortResultIds (int *dati, int dim_arr);
void destroyResultList(listResult *lista);

void newNodo(studente dato);


void printList();
listResult* findInListByName(char cercaNome[]);
listResult* findInListBySurname(char cercaCognome[]);
listResult* findInListByVoteAverage(float mediaVotiMin, float mediaVotiMax);

void deleteNodo(nodo* elemento);

int nOrdine = 0; //variabile globale, incremento ad ogni inserimento, in modo che


ogni studente ne abbia uno diverso
//viene assegnato all'inserimento, non per forza e' progressivo (se vi sono
cancellazioni sopratutto)

// TESTARE IL FUNZIONAMENTO DELL'ELIMINAZIONE PER MEDIA DEI VOTI DI UN SOLO


STUDENTE O PIU' STUDENTI CHE NON SEMBRA FUNZIONARE CORRETTAMENTE!
// I SUCCESSIVI INSERIMENTI DOPO L'ELIMINAZIONE NON LI FA VEDERE

//mettere a posto il case 2 : elimina indicando piu' ID

/*
*
*/
int main(int argc, char** argv) {

while(true){
char bufScelta[10] = "a";
int scelta;
bool eseguito = false;
printf("%s%s%s%s%s%s","Benvenuto nel programma di gestione del registro.",
"\n1. Visualizza studenti", /*(ordinati per numero ordine, Nome,
Cognome, media voti)*/
"\n2. Inserisci uno o piu' studenti",
"\n3. Modifica uno o piu' studenti",
"\n4. Elimina uno o piu' studenti",
"\n0. Esci dal programma");
while(!isAnInt(bufScelta) or atoi(bufScelta)<0 or atoi(bufScelta)>4){
if(eseguito) printf("\nValore non corretto.");
printf("\nScelta ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
scelta = atoi(bufScelta);
switch(scelta){
case 1:{
//readFile(pFile, pReg);
printList();
break;
}
case 2:{
//FILE *pFileW = fopen("registro.txt","a+");
//non chiudo tale file, me lo chiude la funzione writeFile()
//writeFile(pFileW);
bool insert = true;
while(insert){
newNodo(*scanStudente());

bool eseguito = false;


char aux = '2';
while(aux != '0' and aux!='1'){
if(eseguito) printf("Valore non corretto!\n");
printf("Inserire un altro elemento : ? (1=si, 0=no) ");
//fflush(stdin); solo su Windows
while ( getchar() != '\n' ); //"svuoto il buffer"
scanf("%c", &aux);
if(!eseguito) eseguito = true; //cosi', se lo eseguo pi di
1 volta, vuol dire che il valore
// non e' corretto e lo faccio notare
}
eseguito = false;
insert = (aux == '1') ? true : false;
}

break;
}
case 3:{

break;
}
case 4:{
bool eseguito = false;
bool Delete = true;
while(Delete){
int subScelta = 0;
char bufScelta[10] = "a";
printf("%s%s%s%s", "Scegli tipo di ricerca per l'elemento da
eliminare : ",
"\n1. Ricerca per Nome",
"\n2. Ricerca per Cognome", //ritengo inutile una
ricerca per mediaVoti
"\n3. Ricerca per intervallo di media dei voti");
while(!isAnInt(bufScelta) or atoi(bufScelta)<1 or
atoi(bufScelta)>3){
if(eseguito) printf("Valore non corretto.");
//while ( getchar() != '\n' ); //"svuoto il buffer"
printf("\nScelta ? ");
//while ( getchar() != '\n' ); //"svuoto il buffer"
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
subScelta = atoi(bufScelta);
switch(subScelta){

case 1:{
char nome[20];
printf("Inserisci nome da ricercare : ? ");
scanf("%s", nome);
listResult *result = findInListByName(nome);
if(result->lStart == NULL)
printf("Non e' stato trovato nessun studente di
nome %s\n", nome);
else{
if(result->nElem > 1){
printf("Vi sono piu' studenti con il nome
%s : \n",nome);
nodoResult *pos = result->lStart;
for(int i=0; i<result->nElem; i++){
printf("ID = %d nOrdine = %d\tNome =
%s\tCognome = %s\tmediaVoti = %f\n", i+1,
pos->element->dati.nOrdine, pos-
>element->dati.Nome,
pos->element->dati.Cognome, pos-
>element->dati.mediaVoti);
pos = pos->next;
}
printf("\nOperazioni possibili:"
"\n1: Elimina tutti gli studenti di
nome %s"
"\n2: Elimina piu' studenti
specificando gli ID"
"\n3: Elimina un solo studente
indicando l'ID", nome);
char bufScelta[10] = "a";
bool eseguito = false;
while(!isAnInt(bufScelta) or atoi(bufScelta)<1
or atoi(bufScelta)>3){
if(eseguito) printf("Valore non
corretto.\n");
printf("\nScelta ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
int scelta = atoi(bufScelta);
switch(scelta){
case 1:{ //elimina tutti i risultati
nodoResult *pos = result->lStart;
for(int j=0; j<result->nElem; j++){
deleteNodo(pos->element);
pos = pos->next;
}
break;
}

case 2:{
int k=0; //sara' il contatore che mi
serve per scrivere nel vettore di int scelti, dichiarato sotto
int temp = 1;
int scelti[result->nElem]; //puo'
sceglierne al massimo quanti sono i risultati!
for(int j=0; j<result->nElem; j++)
scelti[j] = 0;
while(temp != 0){
char bufScelta[10] = "a";
bool eseguito = false;
while(!isAnInt(bufScelta) or
atoi(bufScelta)<0 or atoi(bufScelta)>result->nElem){
if(eseguito) printf("Valore non
corretto.\n");
printf("\nInserisci ID (per
terminare l'inserimento scrivi 0) ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
temp = atoi(bufScelta);
scelti[k] = temp; //anche se scrive
0 non e' un problema, perche' non tengo in considerazione gli 0.
k++;
} //N.B GLI ID partono da 1 e non da
0!!!
int c=0;
while(scelti[c] != 0)
c++; //conto la lunghezza del
vettore inizializzato precedentemente a 0 (numero di elementi != 0 a partire
dall'inizio)

//prima di tutto ordino il vettore


scelti, tralasciando gli 0
sortResultIds(scelti,c); //ordino fino
a c, ovvero fino all'ultimo elemento != 0
//ripasso tutta la lista dei risultati
e dove i+1 = un elemento del vettore scelti, allora elimino
int n=0;
nodoResult *pos = result->lStart;
for(int j=0; j<result->nElem; j++){
if(scelti[n] -1 == j){ //tolgo 1 a
scelti[n] che contiene gli ID riferiti agli studenti scelti, che partono da 1 e non
da 0
deleteNodo(pos->element);
n++;
}
pos = pos->next;
}
break;
}

case 3:{
char bufScelta[10] = "a";
bool eseguito = false;
while(!isAnInt(bufScelta) or
atoi(bufScelta)<0 or atoi(bufScelta)>result->nElem){
if(eseguito) printf("Valore non
corretto.\n");
printf("\nInserisci ID dello
studente ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
int temp = atoi(bufScelta);

nodoResult *pos = result->lStart;


for(int j=0; j<=temp; j++)
pos = pos->next; //mi sposto nella
lista allo studente con ID indicato

deleteNodo(pos->element);
break;
}
}
}else{//c'e' solo 1 risultato --> lo mostro e lo
cancello
printf("E' stato trovato il seguente
risultato : \n");
printf("nOrdine = %d\tNome = %s\tCognome =
%s\tmediaVoti = %f\n",
result->lStart->element-
>dati.nOrdine, result->lStart->element->dati.Nome,
result->lStart->element-
>dati.Cognome, result->lStart->element->dati.mediaVoti);

char bufScelta[10] = "a";


bool eseguito = false;
while(!isAnInt(bufScelta) or atoi(bufScelta)<0
or atoi(bufScelta)>1){
if(eseguito) printf("Valore non
corretto.\n");
printf("Confermi l'eliminazione
dell'elemento : ? (1=si, 0=no) ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
int temp = atoi(bufScelta);
if(temp == 1)
deleteNodo(result->lStart->element);
}
}

break;
}

case 2:{

char cognome[30];
printf("Inserisci cognome da ricercare : ? ");
scanf("%s", cognome);
listResult *result = findInListBySurname(cognome);
if(result->lStart == NULL)
printf("Non e' stato trovato nessun studente di
cognome %s\n", cognome);
else{
if(result->nElem > 1){
printf("Vi sono piu' studenti con il cognome %s
: \n",cognome);
nodoResult *pos = result->lStart;
for(int i=0; i<result->nElem; i++){
printf("ID = %d nOrdine = %d\tNome =
%s\tCognome = %s\tmediaVoti = %f\n", i+1,
pos->element->dati.nOrdine, pos-
>element->dati.Nome,
pos->element->dati.Cognome, pos-
>element->dati.mediaVoti);
pos = pos->next;
}
printf("\nOperazioni possibili:"
"\n1: Elimina tutti gli studenti di
cognome %s"
"\n2: Elimina piu' studenti
specificando gli ID"
"\n3: Elimina un solo studente
indicando l'ID", cognome);
char bufScelta[10] = "a";
bool eseguito = false;
while(!isAnInt(bufScelta) or atoi(bufScelta)<1
or atoi(bufScelta)>3){
if(eseguito) printf("Valore non
corretto.\n");
printf("\nScelta ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
int scelta = atoi(bufScelta);
switch(scelta){
case 1:{ //elimina tutti i risultati
nodoResult *pos = result->lStart;
for(int j=0; j<result->nElem; j++){
deleteNodo(pos->element);
pos = pos->next;
}
break;
}

case 2:{
int k=0; //sara' il contatore che mi
serve per scrivere nel vettore di int scelti, dichiarato sotto
int temp = 1;
int scelti[result->nElem]; //puo'
sceglierne al massimo quanti sono i risultati!
for(int j=0; j<result->nElem; j++)
scelti[j] = 0;
while(temp != 0){
char bufScelta[10] = "a";
bool eseguito = false;
while(!isAnInt(bufScelta) or
atoi(bufScelta)<0 or atoi(bufScelta)>result->nElem){
if(eseguito) printf("Valore non
corretto.\n");
printf("\nInserisci ID (per
terminare l'inserimento scrivi 0) ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
temp = atoi(bufScelta);
scelti[k] = temp; //anche se scrive
0 non e' un problema, perche' non tengo in considerazione gli 0.
k++;
} //N.B GLI ID partono da 1 e non da
0!!!
int c=0;
while(scelti[c] != 0)
c++; //conto la lunghezza del
vettore inizializzato precedentemente a 0 (numero di elementi != 0 a partire
dall'inizio)

//prima di tutto ordino il vettore


scelti, tralasciando gli 0
sortResultIds(scelti,c); //ordino fino
a c, ovvero fino all'ultimo elemento != 0
//ripasso tutta la lista dei risultati
e dove i+1 = un elemento del vettore scelti, allora elimino
int n=0;
nodoResult *pos = result->lStart;
for(int j=0; j<result->nElem; j++){
if(scelti[n] -1 == j){ //tolgo 1 a
scelti[n] che contiene gli ID riferiti agli studenti scelti, che partono da 1 e non
da 0
deleteNodo(pos->element);
n++;
}
pos = pos->next;
}
break;
}

case 3:{
char bufScelta[10] = "a";
bool eseguito = false;
while(!isAnInt(bufScelta) or
atoi(bufScelta)<0 or atoi(bufScelta)>result->nElem){
if(eseguito) printf("Valore non
corretto.\n");
printf("\nInserisci ID dello
studente ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
int temp = atoi(bufScelta);

nodoResult *pos = result->lStart;


for(int j=0; j<=temp; j++)
pos = pos->next; //mi sposto nella
lista allo studente con ID indicato

deleteNodo(pos->element);
break;
}
}
}else{//c'e' solo 1 risultato --> lo mostro e lo
cancello
printf("E' stato trovato il seguente
risultato : \n");
printf("nOrdine = %d\tNome = %s\tCognome =
%s\tmediaVoti = %f\n",
result->lStart->element-
>dati.nOrdine, result->lStart->element->dati.Nome,
result->lStart->element-
>dati.Cognome, result->lStart->element->dati.mediaVoti);

char bufScelta[10] = "a";


bool eseguito = false;
while(!isAnInt(bufScelta) or atoi(bufScelta)<0
or atoi(bufScelta)>1){
if(eseguito) printf("Valore non
corretto.\n");
printf("Confermi l'eliminazione
dell'elemento : ? (1=si, 0=no) ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
int temp = atoi(bufScelta);
if(temp == 1)
deleteNodo(result->lStart->element);
}
}

break;
}

case 3:{

float mediaVotiMin = 0, mediaVotiMax = 0;


char bufScelta[10] = "-1";
bool eseguito = false;
while(atof(bufScelta)<0 or atof(bufScelta)>10){
while ( getchar() != '\n' ); //"svuoto il buffer"
fflush(stdin);
if(eseguito) printf("Valore non corretto.\n");
printf("Inserisci intervallo medie degli studenti
da ricercare : ? (0 <= media MIN <= 10) ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
mediaVotiMin = atof(bufScelta);

char bufSceltaB[10] = "-1";


eseguito = false;
while(atof(bufSceltaB)<0 or atof(bufSceltaB)>10){
if(eseguito) printf("Valore non corretto.\n");
printf("Inserisci intervallo medie degli studenti
da ricercare : ? (0 <= media MAX <= 10) ");
scanf("%s",bufSceltaB);
if(!eseguito) eseguito = true;
}
mediaVotiMax = atof(bufSceltaB);

listResult *result =
findInListByVoteAverage(mediaVotiMin,mediaVotiMax);
if(result->lStart == NULL)
printf("Non e' stato trovato nessun studente con la
media compresa "
"nell'intervallo specificato [%f, %f]\n",
mediaVotiMin, mediaVotiMax);
else{
if(result->nElem > 1){
printf("Vi sono piu' studenti con la media
nell'intervallo specificato [%f, %f]\n", mediaVotiMin, mediaVotiMax);
nodoResult *pos = result->lStart;
for(int i=0; i<result->nElem; i++){
printf("ID = %d nOrdine = %d\tNome =
%s\tCognome = %s\tmediaVoti = %f\n", i+1,
pos->element->dati.nOrdine, pos-
>element->dati.Nome,
pos->element->dati.Cognome, pos-
>element->dati.mediaVoti);
pos = pos->next;
}
printf("\nOperazioni possibili:"
"\n1: Elimina tutti gli studenti con la
media [%f, %f]"
"\n2: Elimina piu' studenti
specificando gli ID"
"\n3: Elimina un solo studente
indicando l'ID", mediaVotiMin, mediaVotiMax);
char bufScelta[10] = "a";
bool eseguito = false;
while(!isAnInt(bufScelta) or atoi(bufScelta)<1
or atoi(bufScelta)>3){
if(eseguito) printf("Valore non
corretto.\n");
printf("\nScelta ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
int scelta = atoi(bufScelta);
switch(scelta){
case 1:{ //elimina tutti i risultati
nodoResult *pos = result->lStart;
for(int j=0; j<result->nElem; j++){
deleteNodo(pos->element);
pos = pos->next;
}
break;
}

case 2:{
int k=0; //sara' il contatore che mi
serve per scrivere nel vettore di int scelti, dichiarato sotto
int temp = 1;
int scelti[result->nElem]; //puo'
sceglierne al massimo quanti sono i risultati!
for(int j=0; j<result->nElem; j++)
scelti[j] = 0;
while(temp != 0){
char bufScelta[10] = "a";
bool eseguito = false;
while(!isAnInt(bufScelta) or
atoi(bufScelta)<0 or atoi(bufScelta)>result->nElem){
if(eseguito) printf("Valore non
corretto.\n");
printf("\nInserisci ID (per
terminare l'inserimento scrivi 0) ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
temp = atoi(bufScelta);
scelti[k] = temp; //anche se scrive
0 non e' un problema, perche' non tengo in considerazione gli 0.
k++;
} //N.B GLI ID partono da 1 e non da
0!!!
int c=0;
while(scelti[c] != 0)
c++; //conto la lunghezza del
vettore inizializzato precedentemente a 0 (numero di elementi != 0 a partire
dall'inizio)

//prima di tutto ordino il vettore


scelti, tralasciando gli 0
sortResultIds(scelti,c); //ordino fino
a c, ovvero fino all'ultimo elemento != 0
//ripasso tutta la lista dei risultati
e dove i+1 = un elemento del vettore scelti, allora elimino
int n=0;
nodoResult *pos = result->lStart;
for(int j=0; j<result->nElem; j++){
if(scelti[n] -1 == j){ //tolgo 1 a
scelti[n] che contiene gli ID riferiti agli studenti scelti, che partono da 1 e non
da 0
deleteNodo(pos->element);
n++;
}
pos = pos->next;
}
break;
}

case 3:{
char bufScelta[10] = "a";
bool eseguito = false;
while(!isAnInt(bufScelta) or
atoi(bufScelta)<0 or atoi(bufScelta)>result->nElem){
if(eseguito) printf("Valore non
corretto.\n");
printf("\nInserisci ID dello
studente ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
int temp = atoi(bufScelta);

nodoResult *pos = result->lStart;


for(int j=0; j<=temp; j++)
pos = pos->next; //mi sposto nella
lista allo studente con ID indicato

deleteNodo(pos->element);
break;
}
}
}else{//c'e' solo 1 risultato --> lo mostro e lo
cancello
printf("E' stato trovato il seguente
risultato : \n");
printf("nOrdine = %d\tNome = %s\tCognome =
%s\tmediaVoti = %f\n",
result->lStart->element-
>dati.nOrdine, result->lStart->element->dati.Nome,
result->lStart->element-
>dati.Cognome, result->lStart->element->dati.mediaVoti);

char bufScelta[10] = "a";


bool eseguito = false;
while(!isAnInt(bufScelta) or atoi(bufScelta)<0
or atoi(bufScelta)>1){
if(eseguito) printf("Valore non
corretto.\n");
printf("Confermi l'eliminazione
dell'elemento : ? (1=si, 0=no) ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
int temp = atoi(bufScelta);
if(temp == 1)
deleteNodo(result->lStart->element);
}
}

break;
}
}

eseguito = false;
char aux = '2';
while(aux != '0' and aux!='1'){
if(eseguito) printf("Valore non corretto!\n");
printf("Eliminare altri studenti : ? (1=si, 0=no) ");
//fflush(stdin); solo su Windows
while ( getchar() != '\n' ); //"svuoto il buffer"
scanf("%c", &aux);
if(!eseguito) eseguito = true; //cosi', se lo eseguo pi di
1 volta, vuol dire che il valore
// non e' corretto e lo faccio notare
}
eseguito = false;
Delete = (aux == '1') ? true : false;
}

break;
}
case 0:{
printf("\nGrazie per aver usato il programma!");
exit(0);
}
}
}

return 0;
}

void newNodo(studente dato){


if(registro->lEnd == NULL){
registro->lStart = new nodo;
registro->lStart->dati = dato;
registro->lStart->prev = NULL;
registro->lStart->next = registro->lStart; //punta a se stessa perche' non
ci sono el.successivi
registro->lEnd = registro->lStart; //copio il valore del puntatore
//printf("\nIndirizzo di lStart : %d \n",registro->lStart);
}else{
nodo* nuovo = new nodo;
nuovo->dati = dato;
nuovo->prev = registro->lEnd; //il vecchio ultimo elemento
registro->lEnd->next = nuovo; //il vecchio ultimo elemento punta a questo
"nuovo ultimo"
nuovo->next = registro->lStart; //nuovo, che ora diventa l'ultimo elemento,
punta al primo (lista circolare)
registro->lEnd = nuovo; //ora l'ultimo elemento e' quello nuovo: copio il
valore del puntatore!
//printf("\nIndirizzo di lEnd : %d \n",registro->lEnd);
}
registro->nElem++;
}

void addResult(listResult *result, nodo *dato){ //ogni volta che devo aggiungere un
risultato di ricerca
if(result->lEnd == NULL){
result->lStart = new nodoResult;
result->lStart->element = dato;
result->lStart->prev = NULL;
result->lStart->next = result->lStart; //punta a se stessa perche' non ci
sono el.successivi
result->lEnd = result->lStart; //copio il valore del puntatore
}else{
nodoResult* nuovo = new nodoResult;
nuovo->element = dato;
nuovo->prev = result->lEnd; //il vecchio ultimo elemento
result->lEnd->next = nuovo; //il vecchio ultimo elemento punta a questo
"nuovo ultimo"
nuovo->next = result->lStart; //nuovo, che ora diventa l'ultimo elemento,
punta al primo (lista circolare)
result->lEnd = nuovo; //ora l'ultimo elemento e' quello nuovo: copio il
valore del puntatore!
}
result->nElem++;
}

void printList(){
if(registro->lEnd != NULL){
nodo *pos = registro->lStart;
do{
printf("| nOrdine: %d\tNome: %s\tCognome: %s\tmediaVoti:
%f\tIndirizzo : Ox%d\n",/*i,*/
pos->dati.nOrdine, pos->dati.Nome, pos->dati.Cognome,
pos->dati.mediaVoti,pos);
pos = pos->next;
}while(pos != registro->lStart); //finche' non torno ad lStart
//uso un do...while perche' la prima volta pos == lStart!
}else{
printf("Nessun studente presente nel registro. Utilizza la voce di
inserimento.\n");
}
}

listResult* findInListByName(char cercaNome[]){


//bool elimina indica se la funzione viene chiamata dalla voce di menu' per
l'eliminazione
//bool edit fa lo stesso per la modifica

listResult *results = new listResult; //facciamo una lista?

if(registro->lEnd != NULL){
nodo *pos = registro->lStart;
int c=0;
for(int i=0; i<registro->nElem; i++){
if(strcmp(pos->dati.Nome, cercaNome) == 0){
addResult(results,pos);
//break; non lo metto. perche' piu' persone possono avere lo stesso
nome
}
pos = pos->next;
}
}

return results;
/*
if(edit){
*nResults = 1; //per la modifica ritorno 1 solo risultato
if(results->nElem > 1){
printf("Vi sono piu' studenti con il nome %s : \n",cercaNome);
nodoResult *pos = results->lStart;
for(int i=0; i<results->nElem; i++){
printf("ID = %d nOrdine = %d\tNome = %s\tCognome =
%s\tmediaVoti = %f\n", i+1,
pos->element->dati.nOrdine, pos->element->dati.Nome,
pos->element->dati.Cognome, pos->element-
>dati.mediaVoti);
pos = pos->next;
}
char bufScelta[10] = "a";
bool eseguito = false;
while(!isAnInt(bufScelta) or atoi(bufScelta)<0 or
atoi(bufScelta)>results->nElem){
if(eseguito) printf("\nValore non corretto.");
printf("\nInserisci ID dello studente (per la modifica puoi
selezionarne solo uno) ? ");
scanf("%s",bufScelta);
if(!eseguito) eseguito = true;
}
int temp = atoi(bufScelta);

pos = results->lStart;
for(int j=0; j<temp; j++)
pos = pos->next; //mi sposto nella lista allo studente con ID
indicato

studente *risultati = new studente[*nResults];


risultati[0] = pos->element->dati;

destroyResultList(results);
return risultati;
}else{ //c'e' solo 1 risultato : ok!
studente *risultati = new studente[*nResults];
risultati[0] = results->lStart->element->dati;

destroyResultList(results);
return risultati;
}
}else{
//ritorno tutti i risultati trovati!
*nResults = results->nElem;
nodoResult *pos = results->lStart;
studente *risultati = new studente[*nResults];
for(int j=0; j<*nResults; j++){
*(risultati+j) = pos->element->dati;
pos = pos->next;
}

destroyResultList(results);
return risultati;
}
}

//return risultati;
//viene tornato un puntatore a puntatore a struct che poi dovra' essere
deallocato*/
}

listResult* findInListBySurname(char cercaCognome[]){


//bool elimina indica se la funzione viene chiamata dalla voce di menu' per
l'eliminazione
//bool edit fa lo stesso per la modifica

listResult *results = new listResult; //facciamo una lista?

if(registro->lEnd != NULL){
nodo *pos = registro->lStart;
int c=0;
for(int i=0; i<registro->nElem; i++){
if(strcmp(pos->dati.Cognome, cercaCognome) == 0){
addResult(results,pos);
//break; non lo metto. perche' piu' persone possono avere lo stesso
nome
}
pos = pos->next;
}
}

return results;
}

listResult* findInListByVoteAverage(float mediaVotiMin, float mediaVotiMax){


//specifico un intervallo di medie
//bool elimina indica se la funzione viene chiamata dalla voce di menu' per
l'eliminazione
//bool edit fa lo stesso per la modifica

listResult *results = new listResult; //facciamo una lista?

if(registro->lEnd != NULL){
nodo *pos = registro->lStart;
int c=0;
for(int i=0; i<registro->nElem; i++){
if(pos->dati.mediaVoti >= mediaVotiMin and pos->dati.mediaVoti <=
mediaVotiMax){
addResult(results,pos);
//break; non lo metto. perche' piu' persone possono avere lo stesso
nome
}
pos = pos->next;
}
}

return results;
}

void deleteNodo(nodo* elemento){


if(elemento != NULL){
if(elemento == registro->lStart){ //se e' il primo della lista
if(registro->nElem == 1){
//nella lista ce solo 1 elemento e deve essere eliminato
registro->lStart = NULL;
registro->lEnd = NULL;
}else{
registro->lStart = elemento->next; //aggiorno l'inizio
elemento->next->prev = NULL; //nuovo primo : prev = NULL
registro->lEnd->next = registro->lStart; //devo riaggiornare
l'ultimo elemento, che punta ad un "Nuovo primo"
}
}else{
if(elemento != registro->lEnd) //se non e' l'ultimo della lista
elemento->next->prev = elemento->prev; //devo cambiare nodo *prev
dell'elemento successivo
//se e' l'ultimo della lista non serve, in quanto il successivo e' il
primo, e prev di primo punta a NULL

//in tutti e due i casi comunque cambio nodo *next dell'elemento


precedente
elemento->prev->next = elemento->next;
}
//printf("\nIndirizzo dell'elemento prima del delete : %d \n",elemento);
delete elemento;
//printf("\nIndirizzo dell'elemento dopo del delete : %d \n",elemento);
}
registro->nElem--;
}

bool isAnInt(char *str) {


bool result = true;
while(*str != 0 and result){
if(!(*str >= '0' and *str <='9'))
result = false;
str++;
}
return result;
}

studente* scanStudente(){
//uso bool eseguito per far notare che l'utente ha sbagliato ad inserire
//quando il while viene eseguito piu' di 1 volta!

//uso bool insert per vedere se l'utente vuole continuare ad inserire


//e quindi continuo a chiedere dati, oppure no
studente *nuovo = new studente;
bool eseguito = false;
nOrdine++;
nuovo->nOrdine = nOrdine;

printf("Inserisci il Nome dello studente : ? ");


scanf("%s", nuovo->Nome);

printf("Inserisci il Cognome dello studente : ? ");


scanf("%s", nuovo->Cognome);

//inserimento media voti


char bufVoti[20] = "a";
bool floatOk = false;
while(!floatOk){
if(eseguito) printf("Valore non corretto!\n");
printf("Inserisci la media dei voti dello studente : ? ");
scanf("%s", bufVoti);
if(atoi(bufVoti)) floatOk = true;
if(!eseguito) eseguito = true;
}
eseguito = false;
nuovo->mediaVoti = atof(bufVoti);

//fflush(stdin);

return nuovo;
}

void sortResultIds (int *dati, int dim_arr){


bool continua=true;
long k, sup;
k = dim_arr - 1;

while (continua) {
continua = false;
sup = k;
for (long i = 0; i < sup; i++) {
if (*(dati+i) > *(dati+i +1)) {
swap(*(dati+i), *(dati+i+1));
continua = true;
k = i;
}
}
}
}

void destroyResultList(listResult *lista){


//prima elimino tutti i nodi
nodoResult* start = lista->lStart;
nodoResult* pos = start;
do{
nodoResult* next = pos->next;
delete pos;
pos = next;
}while(pos != start);
//poi elimino la "lista"
delete lista;
}