Notes

/*****************************/
/* inclusione delle librerie */
/*****************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 10

/* inizializzazione delle componenti dei dispositivi */
typedef struct Indirizzi
{
int m;
int n;
int p;
int q;
char str[MAX]; /* lunghezza massima di caratteri disponibili per l'acquisizione della stringa */
} Indirizzi_t;

/********************************/
/* dichiarazione delle funzioni */
/********************************/

int AcquisizioneNumeroDispositivi(void);

void AcquisizioneListaDispositivi(Indirizzi_t *, Indirizzi_t *, int n);

int ConfrontoListaDispositivi(Indirizzi_t *, Indirizzi_t *, int n, int *);

void Trasferimento(int *, int j, Indirizzi_t *, Indirizzi_t *);

void StampaLista(Indirizzi_t *, Indirizzi_t *, int *, int vuoto);


/* definizione della funzione main */
int main(void)
{
int n, /* input: numero dispositivi da inserire */
c = 0, /* lavoro: variabile contatore */
vuoto = 0; /* lavoro: indica se la l'array di uscita è vuoto (0) o no (1) */
int* c_p = &c; /* lavoro: variabile puntatore che punta al contatore c */

/*inizializzazione array di struct*/
Indirizzi_t indirizzi[MAX];
Indirizzi_t coppie[MAX];

/* acquisizione numero dispositivi con validazione stretta */
n = AcquisizioneNumeroDispositivi();

/* acquisizione dispositivi con validazione stretta */
AcquisizioneListaDispositivi(coppie, indirizzi, n);

/* esegue il confronto tra i dispositivi inseriti */
vuoto = ConfrontoListaDispositivi(coppie, indirizzi, n, c_p);

/* esegue la stampa dei dispositivi, se presenti, della stessa rete locale */
StampaLista(coppie, indirizzi, c_p, vuoto);

return 0;
}

/* definizione della funzione per l'acquisizione del numero dispositivi */
int AcquisizioneNumeroDispositivi(void)
{
int n = 0; /* input: numero dispositivi da inserire */
int esito_lettura; /* lavoro: verifica una corretta acquisizione dei dati */
char carattere_rimosso; /* lavoro: variabile per pulizia buffer */

/* acquisizione dispositivi con validazione stretta */
do
{
printf("Inserire numero di dispositivi da acquisire [> 1]: ");
esito_lettura = scanf("%d", &n);

if (esito_lettura != 1 || n <= 1) {
printf("Input non accettabile!n");
do
carattere_rimosso = getchar();
while (carattere_rimosso != 'n');
}
} while (esito_lettura != 1 || n <= 1);

/* pulizia buffer */
while (getchar() != 'n');

return n;
}

/* definizione della funzione per l'acquisizione dei dispositivi della stessa rete locale */
void AcquisizioneListaDispositivi(Indirizzi_t *coppie, Indirizzi_t *indirizzi, int n)
{
int esito_lettura; /* lavoro: verifica una corretta acquisizione dei dati */
char carattere_rimosso; /* lavoro: variabile per pulizia buffer */

/*inizializzazione contatori*/
int i, /* lavoro: variabile contatore */
j; /* lavoro: variabile contatore */

/************************************************************************************/
/* acquisizione dei dispositivi e rispettivo nome simbolico con validazione stretta */
/************************************************************************************/

for (i = 0; i < n; i++)
{
do
{
printf("nInserire l'indirizzo del dispositivo numero %d ed il suo rispettivo nome simbolico [es. 1.1.1.1 nome]:n ", i + 1);
esito_lettura = scanf("%d.%d.%d.%dt %s[^n]",
&indirizzi[i].m,
&indirizzi[i].n,
&indirizzi[i].p,
&indirizzi[i].q,
indirizzi[i].str);

/* validazione input */
if (esito_lettura != 5 ||
indirizzi[i].m <= 0 ||
indirizzi[i].n < 0 ||
indirizzi[i].p < 0 ||
indirizzi[i].q < 0 ||
indirizzi[i].str[0] == '' ||
indirizzi[i].str[1] == 'Ì')
{
printf("Input non accettabile!n");
do
carattere_rimosso = getchar();
while (carattere_rimosso != 'n');
}
} while (esito_lettura != 5 ||
indirizzi[i].m <= 0 ||
indirizzi[i].n < 0 ||
indirizzi[i].p < 0 ||
indirizzi[i].q < 0 ||
indirizzi[i].str[0] == '' ||
indirizzi[i].str[1] == 'Ì');

/* controllo indirizzi già inseriti */
for (j = 0;
(j < i);
j++)
{
if ((indirizzi[i].m == indirizzi[j].m &&
indirizzi[i].n == indirizzi[j].n &&
indirizzi[i].p == indirizzi[j].p &&
indirizzi[i].q == indirizzi[j].q) ||
(indirizzi[i].str == indirizzi[j].str))
{
printf("Input non accettabile!nIndirizzo o nome già inserito!n");
i--;
}
}
}

/* pulizia buffer */
while (getchar() != 'n');
}

/* definizione della funzione per il confronto tra i dispositivi della stessa rete locale */
int ConfrontoListaDispositivi(Indirizzi_t *coppie, Indirizzi_t *indirizzi, int n, int* c)
{
/***********************************************************/
/*confronto tra le componenti dei vari dispositivi inseriti*/
/***********************************************************/

/*inizializzazione contatori*/
int i, /* lavoro: variabile contatore */
j, /* lavoro: variabile contatore */
flag = 0, /* lavoro: scarta l'indirizzo confrontanto con se stesso*/
vuoto = 0; /* lavoro: indica se l'array coppie è vuoto (0) o no (1) */

/*individua gli indirrizi presenti nella rete locale e gli alloca in un nuovo array*/
for (i = 0;
((i < n) && (*c < n));
i++,
j = flag = 0)
{
for (j = 0;
(j < n);
j++)
{
if (indirizzi[j].m == indirizzi[i].m &&
indirizzi[j].n == indirizzi[i].n &&
indirizzi[j].m != 0)
{
/* salta il confronto dell'indirizzo uguale a se stesso */
if (indirizzi[j].p != indirizzi[i].p ||
indirizzi[j].q != indirizzi[i].q)
{
if (flag == 0)
{
/* copia i dispositivi della stessa rete locale in un nuovo array di uscita */
Trasferimento(c,
i,
coppie,
indirizzi);
*c = *c + 1;
}

flag = vuoto = 1; /* l'array di uscita non è più vuoto */
/* copia i dispositivi della stessa rete locale in un nuovo array di uscita */
Trasferimento(c,
j,
coppie,
indirizzi);
indirizzi[j].m = 0; /* annulla la verifica dell'indirizzo già confrontato */
*c = *c + 1;
}
}
}
}
return vuoto;
}

/* definizione della funzione per la copia dei dispositivi della stessa rete locale in un nuovo array di uscita */
void Trasferimento(int* c, int j, Indirizzi_t *coppie, Indirizzi_t *indirizzi)
{
/*inizializzazione contatori*/
int i, /* lavoro: variabile contatore */
len; /* lavoro: dimensione array */

/* copia delle componenti m, n, p e q nell'array di uscita */
coppie[*c].m = indirizzi[j].m;
coppie[*c].n = indirizzi[j].n;
coppie[*c].p = indirizzi[j].p;
coppie[*c].q = indirizzi[j].q;

/* acquisizione dimensione della stringa da copiare */
len = sizeof(indirizzi[j].str);

/* copia ogni singolo carattere nella stringa dell'array di uscita */
for (i = 0;
(i < len);
i++)
{
coppie[*c].str[i] = indirizzi[j].str[i];
}
}

/* definizione della funzione per stampare i dispositivi, se presenti, della stessa rete locale */
void StampaLista(Indirizzi_t *coppie, Indirizzi_t *indirizzi, int* c, int vuoto)
{
/*inizializzazione contatori*/
int i, /* lavoro: variabile contatore */
j,
len;

len = sizeof(coppie[*c].str);

/* verifica se sono presenti coppie di dispositivi nella rete locale*/
if (vuoto == 0)
{
printf("nNon sono presenti coppie di dispositivi nella stessa rete localen");
}
else
{
printf("nLe coppie di dispositivi presenti nella rete locale sono: %dnn",
*c);

/* stampa array di uscita */
for (i = 0;
(i < *c);
i++)
{

if (coppie[i].str[9] != 'Ì')
{
for (j = 0; j < len; j++)
{
printf("%c",
coppie[i].str[j]);
}
printf("n");
}
else
{
printf("%sn",
coppie[i].str);
}
}
}
}