provaesamematteomemoria

/*
Studente: RUGGIERO MATTEO
Matricola: 042/005027
Docente: Amalfitano1

 Esercitazione di Fondamenti di Informatica (9 CFU)
Data: 13/12/2019
docente: Ing. Domenico Amalfitano

Scrivere un programma per la gestione di una nuova tipologia di memoria. La memoria può essere modellata come
un vettore di registri. Ogni registro è caratterizzato dal valore in esso memorizzato (stringa di 8 caratteri '0' e '1'), dal
tempo di accesso in scrittura (valore float), e dal tempo di accesso in scrittura.
Il programma deve fornire le funzionalità descritte di seguito, tenendo presente che i primi tre requisiti
sono precondizioni per l'esecuzione dei rimanenti. Per raggiungere la sufficienza è necessario svolgere
correttamente i primi tre punti e un punto scelto tra il quarto e il quinto.
1.	Inserimento del numero di registri della memoria. Il programma chiede all'utente di inserire il numero
di registri della memoria. Se l'utente inserisce un valore di dimensione minore o uguale di zero allora il
programma deve mostrare un messaggio di errore e chiedere all'utente di inserire nuovamente la dimensione
fin quando questa non sia corretta.
2.	Inserimento dei valori dei registri. Il programma chiede all'utente di inserire i valori dei diversi registri
della memoria.
3.	Stampa a video dello stato della memoria. Il programma mostra a video lo stato attuale della memoria
RAM.
4.	Riorganizzazione della memoria. Scrivere una funzione che riorganizza i registri della memoria in base ai
tempi medi di accesso in lettura di ogni registro. La riorganizzazione viene fatta in ordine crescente.
5.	Calcolo del tempo medio di accesso in scrittura di tutti i registri in cui è memorizzato il valore
'00000000'. Scrivere una funzione che calcola e restituisce il tempo medio di accesso in scrittura di tutti i
registri in cui è memorizzato il valore '00000000'. Nel caso in cui non ci siano registri che memorizzano
il valore '00000000' deve essere mostrato un opportuno messaggio di avviso (Prevedere un
opportuno valore di ritorno della funzione).


Esempio di funzionamento:
Inserisci il numero di registri: 0
Errore la memoria non puo' essere vuota

Inserisci il numero di registri: 5

Inserimento del registro 0:
Valore memorizzato: 00000000
Tempo accesso lettura: 0.23
Tempo accesso scrittura: 6.25

Inserimento del registro 1:
Valore memorizzato: 00001000
Tempo accesso lettura: 0.43
Tempo accesso scrittura: 5.33

Inserimento del registro 2:
Valore memorizzato: 00000000
Tempo accesso lettura: 0.11
Tempo accesso scrittura: 11.25

Inserimento del registro 3:
Valore memorizzato: 00000000
Tempo accesso lettura: 0.12
Tempo accesso scrittura: 3.45

Inserimento del registro 4:
Valore memorizzato: 00011000
Tempo accesso lettura: 0.23
Tempo accesso scrittura: 0.11

Lo stato della memoria e':
Registro 0: 00000000 0.23 6.25
Registro 1: 00001000 0.43 5.33
Registro 2: 00000000 0.11 11.25
Registro 3: 00000000 0.12 3.44
Registro 4: 00011000 0.23 0.11
Lo stato della memoria dopo la riorganizzazione e':

Registro 0: 00000000 0.11 11.25
Registro 1: 00000000 0.12 3.44
Registro 2: 00000000 0.23 6.25
Registro 3: 00011000 0.23 0.11
Registro 4: 00001000 0.43 5.33

Il tempo medio di accesso in scrittura di tutti i registri in cui è memorizzato il valore
'00000000' e': 6.98

*/


#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

typedef struct{
	char valore[9];
	float lettura;
	float scrittura;
}registro;

void insDim(int&);
void insReg(registro*, int);
void StampaMem(registro*, int);
void OrdinaCrescente(registro *, int);

int main (){
	registro *memoria;
	int dim;
	//PUNTO 1
	insDim(dim);
	memoria = new registro[dim];
	//PUNTO 2
	cout<<endl;
	insReg(memoria, dim);
	//PUNTO 3
	cout<<"Lo stato della memoria e\': "<<endl;
	StampaMem(memoria, dim);
	//PUNTO 4
	cout<<"\nLo stato della memoria dopo l'ordinamento crescente 'e\': "<<endl;
	OrdinaCrescente(memoria, dim);
	StampaMem(memoria, dim);




  cout<<endl;
  system("PAUSE");
  return 0;
}

void insDim(int &dim){
	do{
		cout<<"Inserisci il numero di registri: ";
		cin>>dim;
		if(dim<=0){
			cout<<"Errore la memoria non puo\' essere vuota!!"<<endl;
		}
	}while(dim<=0);
}

void insReg(registro* vet, int dim){
	for(int i=0; i<dim; i++){
	cout<<"Inserimento del registro "<<i<<endl;
	cout<<"Valore memorizzato: ";
	cin>>(vet+i)->valore;
	cout<<"Tempo accesso lettura: ";
	cin>>(vet+i)->lettura;
	cout<<"Tempo accesso scrittura: ";
	cin>>(vet+i)->scrittura;
	cout<<endl;
	}
}

void StampaMem(registro * vet, int dim){
	for(int i=0; i<dim; i++){
		//Registro 0: 00000000 0.23 6.25
		cout<<"Registro "<<i<<": "<<(vet+i)->valore<<" "<<(vet+i)->lettura<<" "<<(vet+i)->scrittura<<endl;
	}
}

void OrdinaCrescente(registro *vet, int dim){
/*4.Riorganizzazione della memoria. Scrivere una funzione che riorganizza i registri della memoria in base ai
tempi medi di accesso in lettura di ogni registro. La riorganizzazione viene fatta in ordine crescente.*/
registro temp;

for(int volte=0; volte<dim-1; volte++){
	for(int i=0; i<dim-1; i++){
		if((vet+i)->lettura>(vet+i+1)->lettura){
			//scambio
			temp=*(vet+i);
			*(vet+i)=*(vet+i+1);
			*(vet+i+1)=temp;
		}
	}
}

}