fondamenti di informatica parte 5

1. fondamenti di informatica parte 5 appunti per la laurea in Ingegneria Civile, Edile, Ambientale a.a. 2005-2006 di anna maria carminelli gregori carmin@units.it Approfondimenti fond. di informatica1 parte 5

2. Tema del 17.10.2000 • Scrivere in C++ un programma, strutturato in sottoprogrammi, che letti da tastiera 3 dati numerici, positivi e ciascuno <1 • _ ne valuti il minimo e il massimo; • _ se il minimo e’ inferiore a 0.25 proceda a moltiplicare per 1.1 i dati e a rivalutarne il minimo e il massimo, ripetendo tali operazioni fintantoche’ il minimo risulti maggiore o uguale a 0.25; • (segue) fond. di informatica1 parte 5

3. Tema ... • _ visualizzi sul video o i dati modificati, • o la stringa ”Non occorre modificare i valori letti”; e (memorizzi in una tabella in Memoria Centrale e) visualizzi sul video i dati originali. • N.B. E' SCONSIGLIATO L' USO DI VARIABILI GLOBALI. • L’ uso delle tabelle ormai è noto e quindi nell’ ultima domanda va considerata la richiesta di visualizzazionee di memorizzazione in array. fond. di informatica1 parte 5

4. Considerazioni e ... • I 3 dati numerici, sono positivi e ciascuno <1: per memorizzarli occorreranno 3 variabili di tipo ….Di questi 3 dati si deve valutare il minimo e il massimo, NON l’ ordinamento ! • Per valutare il minimo occorre considerare una variabile dello stesso tipo dei dati e chiamarla per esempio min. Per il massimo la variabile dello stesso tipo sara’ max. • La rivalutazione del minimo implica un procedimento iterativo che si puo’ realizzare con una funzione contenente la frase while. fond. di informatica1 parte 5

5. … svolgimento: • Il main deve leggere i 3 valori, attivare una funzione che calcoli il minimo, un’ altra che calcoli il massimo, se il minimo e’ inferiore a 0.25 deve attivare una funzione che rivaluti minimo e massimo,e poi c’e la memorizzazione e la visualizzione: • main() • {/* Inizio Modulo principale*/float a, b, c, min, max, v[3]; • /*Parte esecutiva*/clrscr();cout <“\n dammi i 3 float: “; • cin >> a >> b >> c; • min = minimo(a, b, c); // passaggio per valore • max = massimo(a, b, c); // “ “ “ • if(min<0.25){max=rivaluta(&min, &a, &b, &c); // indirizzi ! • visual(a,b,c);} else memovis (a,b,c,v); cin >> " "; • return 0;} fond. di informatica1 parte 5

6. … e la funzione minimo ? • Eccola … (e analoga sara’ la funzione massimo:) • float minimo(float x, float y, float z) • {float mi; // si puo’ usare min ?!? • cout<<“\nCon i dati: ”<<x<<“ “<<y<<“ “<<z; • if (x<y && x< z) mi=x; • else if (y<x && y<z) mi=y; • else mi = z; • cout <<“\n il minimo e’:”<< mi; <<endl; • return mi; //la funz. ha in piu’ le visualizzazioni... • } fond. di informatica1 parte 5

7. Alla funzione rivaluta i parametri sono passati per indirizzo quindi: • float rivaluta (float *m, float *x1, float *y1, float *z1) // m, x1, y1, z1 sono puntatori a float: per lavorare sui valori puntati occorre usare l’ operatore * • {floatma=0;//var. locale usata per restituire il massimo • while (*m < 0.25) • {*x1= unoeun*(*x1); *y1= unoeun*(*y1); • *z1=unoeun*(*z1); *m=minimo(*x1,*y1,*z1);} • ma=massimo(*x1, *y1, *z1); // *x1,… valori !!! • return ma;} fond. di informatica1 parte 5

8. CAPIRE BENE E completare • il programma con le direttive al precompilatore (per es. • #define unoeun 1.1), ed • i prototipi dei sottoprogrammi, la funzione massimo, la procedura visual che mancano, le costanti … • farlo girare; • con l’ introduzione delle tabelle realizzare anche la procedura memovis che memorizza in una tabella (= vettore v) i dati originali. • Farlo per martedì 28.11.2006

9. void scambia(float *a, float *b) • /* Esegue lo scambio del valore float puntato da a con il valore puntato da b moltiplicato per w che tramite un #define vale 2.0 */ • { /* Inizio scambia */ • float com; /* variabile LOCALE di comodo per fare lo scambio */ • com = *a; /* pone il valore numerico puntato da a in com */ • *a = w*(*b); /* sovrappone il valore numerico puntato da b moltiplicato per w nel posto di memoria puntato da a .....! NON DA’ ERRORI!!!*/ • *b = com; /* sovrappone il valore numerico assunto da com nel posto di memoria puntato da b: scambio effettuato! */ • } /*Fine scambia */ fond. di informatica1 parte 5

10. E per emulare la memoria? • prima di fare nuovi discorsi, occorrono precisazioni sull’ uso di array, sulla sinteticita’ del C e C++, su errori comuni …. e altro! E’ bene ricordare le 2 versioni della procedura: • void strcp(char *s, char *t) /* strcp copia la stringa puntata da t in quella puntata da s */ • { while ((*s=*t)!=‘\0’) /*fintantoche’ il contenuto di t assegnato alla cella puntata da s e’ diverso da ‘\0’ (=fine stringa) fai*/ { s++; t++}; // + sintetica ?! while (*s++=*t++); // perche’ manca != ‘\0’ ?? • } fond. di informatica1 parte 5

11. Frasi sintetiche • Questo tipo di sintesi e’ normale nei programmi in C o in C++ ed e’ utile conoscerla ed abituarcisi per poter leggere programmi C e C++ in circolazione; • si tratta di “compattare” alcuni tipi di frasi in una sola. • Es. lettura e calcolo indicate nel progetto logico posto in parte 4 diapo 69: fintantoche’ il carattere letto non è il punto, aggiungi 1 all’ elemento che indica la frequenza del carattere letto… ma come si scrive in C o C++ sintetic … ? fond. di informatica1 parte 5

12. Sinteticamente … ? • Non e’ in linea con la sintesi leggere la sequenza di caratteri in un array di char e poi analizzare il vettore ... Sarebbe comunque corretto farlo se fosse necessario tenere memoria della sequenza di caratteri per altri scopi per es. per successive analisi. In tal caso occorre dimensionare l’ array con il numero di caratteri +1 per salvare un posto dove posizionare ‘.’. Se invece l’ analisi e’ solo quella indicata allora: • while( (cin >> ch) /* fintantoche’ c’e’ un ch (carattere) da leggere*/ && ( ch != ‘.’) ) /* e inoltre questo ch e’ diverso da punto FAI */... fond. di informatica1 parte 5

13. In definitiva • il significato di queste considerazioni riguarda l’ utilizzo di matrici e/o vettori. • E’ bene usarli quando richiesto e/o esiste la necessita’ di tenere memoria dei valori calcolati o letti: se tali condizioni sono false, allora usare il valore corrente (per es. appena letto) per i calcoli ad esso relativi e passare ad altro valore (per es. il successivo). • E poi bisogna essere attenti ad errori ed a esigenze comuni come indicato qui di seguito. fond. di informatica1 parte 5

14. Attenzione al fallimento dell’ input ! • In iostream.h del C++ esiste una funzione collegata al flusso cin ossia cin.fail() che restituisce il valore true se l’ input fallisce, per es. se si ha: • int x,y, elabora(int); • while(true) • {cin>>x; if ( cin.fail() ) break • else {y=elabora (x); • …. } • Il fallimento dell’ input può avvenire per esempio per un errore di battitura attribuendo ad x un carattere fond. di informatica1 parte 5

15. Attenzione alla fine file ! • In iostream.h delC++ esiste una funzione collegata al flusso cin ossia cin.eof() che restituisce il valore true se si incontra EOF. Nell’ es. precedente si analizzerà la fine file solodopo il fallimento dell’ input: • int x,y, elabora(int); • while(true) • {cin>>x; if ( cin.fail() ) {if ( cin.eof()) cout <<“ EOF”; • else cout “ dati sbagliati”; cin>>” “; break } • else {y=elabora (x); …. } fond. di informatica1 parte 5

16. Attenzione alle condizioni di confronto! • Ricordarsi le codifiche Fixed e Floating point(!!!) quando si devono confrontare i numeri in virgola mobile che hanno precisione limitata. • Per es. avendo: • double r= sqrt(2.0); • if (r*r == 2.0) cout << “il quadrato di sqrt(2) è2\n”; • else {cout<< “il quadrato di sqrt(2) NON è 2, ma “<< r*r<<endl; } • La visualizzazione sarà: il quadrato di sqrt(2) NON è 2, ma 2 !!!? • Ponendo {cout<< “il quadrato di sqrt(2) NON è 2, ma “<< setprecision(16)<< r*r<<endl; } • la visualizzazione sarà: il quadrato di sqrt(2) NON è 2, ma 2.000000000000004 fond. di informatica1 parte 5

17. Attenzione alle richieste di dati • Quale può essere la risposta implementativa ad una richiesta di un valore float <1.0 ? Le seguenti 3 frasi: • { float val; • cin >> val; • if (val > 1.0) cin >>val; } • sono una soluzione valida? … • NO! PERCHé ripete la lettura solo una volta e invece deve essere ripetuta fintantochè é errata, quindi: • while (val > 1.0) cin >> val; fond. di informatica1 parte 5

18. Attenzione ai dimensionamenti errati come nel project27 che vuole • ampliare array e produce errore in esecuzione …! • void riscrivamplia (int t[]) //attivata con: riscrivamplia(tab); (e tab[MAX]) • { int i; /* Inizio riscrivamplia */ • cout<<"\nin riscriviamplia t = vettore tab ampliata"; • for( i= 0; i<MAX; i++) • cout<< "\n "<< t[i]; • cout<<"\nin riscriviamplia oltre MAX"; • for( i= MAX; i<3*MAX; i++) • {cout<< "\nprima "<< t[i]; • t[i]=99; • cout<< " dopo "<< t[i]; • } /* il compilatore non segnala errori, ma in fase di esecuzione c'e l' indicazione + Access violation .... e problemi in chiusura*/ • } /* Fine riscrivamplia*/

19. Break e altro La frase break si può usare anche in cicli while, do… while, for: vedere project 20 - 22 di programm4 dove si esce con un break da un ciclo infinito come qui riportato CON : bool attiva = false; • forever • { • switch (menu(!attiva)) • { case 1: cout <<"\nnumero 1 e ris: "; • ris = elabora(menu(attiva)); cout <<ris; break; • case 2: cout <<"\nnumero 2 e ris: "; • ris = elabor1(menu(attiva)); cout <<ris; break; • case 99: cout<< " Un numero 99 =>fine forever”; break; • default: cout <<"\n intero non previsto\n";}//fine switch • if (menu(attiva) == 99) break; // fine forever • } fond. di informatica1 parte 5

20. dove la funzioneint menu(bool); è • int menu(bool attua) • { /* Inizio menu che mostra anche come da una funzione se ne puo' attivare un' altra */ • static int c; // c e' var. locale di menu' • if (attua) leggi(&c); // passaggio per indirizzo: c da inizializzare • return( c); // ritorma sempre il valore letto con attua=TRUE • } /* Fine menu */ fond. di informatica1 parte 5

21. A proposito della variabile logica da usare in project22… riprendiamo qui il discorso • Ossevare i project 21 e 22. Quando la funzione menu() viene attivata nella frase switch e’ giusto che richiami la funzione leggi(n) in quanto n deve dirottare il controllo al caso ennesimo; invece quando la funzione menu() viene attivata nelle 2 funzioni di elaborazione non occorrera’ una nuova lettura purche’ n sia ancora disponibile. Questo e’ il punto: n e’ ancora disponibile? NO se menu() è richiamata come in project21 ed al suo interno non si dichiara: static int n;

22. Meo 1 lez.33 Significato delle variabili automatiche e statiche • In C e C++ ogni variabile e’ caratterizzata oltre che dal tipo dalla sua classificazione rispetto alla sua allocazione in memoria ed alla sua durata. Le variabili finora trattate sono dette automatiche perche’ iniziano ad esistere (sono allocate in memoria) quando la funzione in cui sono definite e’ attivata e “spariscono” all’ uscita dalla funzione. Non conservano il loro valore tra una attivazione e l’ altra della funzione. Per conservarlo devono essere dichiarate static: senza questo attributo sono automatiche. fond. di informatica1 parte 5

23. Static => protezione • Tutte la variabili (locali o globali) definite static sono create ed inizializzate prima che il main inizi l’ esecuzione e sono distrutte solo al termine dell’ esecuzione del main program: la loro inizializzazione e’ eseguita una sola volta, se manca sono inizializzate a 0. • Anche una var. globale (o esterna) puo’ essere dichiarata static: in tal caso diventa visibile e usabile solo all’ interno delle funzioni definite nello stesso file sorgente in cui essa e’ definita, ma diventa invisibile ad altri file: è un tipo di protezione. fond. di informatica1 parte 5

24. Conclusione per menu() • Per salvare il valore di n letto solo la prima volta bisogna dichiarare n static (non solo int) e quindi scrivere menu cosi’ (come in project22): • int menu (bool attiva) /* attiva param. formale di tipo logico che deve essere True solo al primo richiamo e False ai richiami successivi in cui si potrà usare il suo duale senza cambiarlo */ • {static int n; // n inizializzata a 0 • if (attiva) leggi(&n) /*se attiva = True in n va il valore digitato che resta immutato fino a nuova lettura che non si verifica se attiva = False */ • return n; } fond. di informatica1 parte 5

25. Attenzione a leggere e scrivere matrici • void leggi(int m[][MAX-5]) /* m è una matrice di MAX righe e MAX-5 colonne */ • { /* Inizio leggi */ • int ic,n; • cout<<"\n dammi i valori della tabella per righe"; • for (n=0; n<MAX; n++) • { • cout<<"\n dammi i MAX-5 valori di riga n="<< n<<" "; • for (ic=0; ic<MAX-5; ic++) • cin>> m[n][ic]; • }// fine lettura riga • }// fine righe fond. di informatica1 parte 5

26. E…per tornare al problema del SORT • Si riprende il project26 che ordina un vettore di interi con l’algoritmo di selezione o scelta diretta con il quale l‘ ordinamento di una tabella di n elementi si ottiene in n-1 passi come indicato nella diapo seguente. fond. di informatica1 parte 5

27. SORT & Algoritmo di Scelta diretta. • Con questo metodo l'ordinamento di una tabella di N elementi si ottiene in N-1 passi. • Al passo 1 si ricerca il minimo tra gli N elementi con N confronti (il CONFRONTO è l’ operazione dominante!) e trovatolo si scambia (di posto) col primo elemento; • al passo 2 si ricerca il minimo tra gli N-1 elementi (dal secondo all'ennesimo con N-1 confronti) e trovatolo si scambia (di posto) col secondo elemento ; • cosi' di seguito fino al passo N-1 quando si potranno scambiare di posto l' elemento N-1 con l'elemento N. • Ad ogni passo #confronti  N • #passi  N • #operazioni effettuate dall'algoritmo è dell' ordine di N*N ... QUINDI da usare se N <10. fond. di informatica1 parte 5

28. void ordina(int x[], int n) /* x è “orlata” cioè l’ elemento x[0] è trascurato.Effettua l' ordinamento di x (tabella di n elementi) con Alg. Scelta Diretta. Variabili locali usate: i,j,k,min Parametri in ingresso: n,x; per es. n=3, x[1] =3, x[2] = 4 x[3] =1 Parametri che escono definiti: x; x[1] =1, x[2] = 3, x[3] = 4 */ { int i,j; /* var. di controllo cicli */ int k; /* indice del minimo */ int min; /* var. contenente il minimo */ /* Inizio parte esecutiva di ordina */

29. for (i = 1; i <= n-1; i++) • { min = x[i]; k = i; // se i=1 allora min = 3 e k =1 • for (j = i+1; j <= n; j++) //ciclo ricerca minimo • { if (x[j] < min) /* solo per j=3 questa condizione è vera (1<3) */ • { k= j; min = x[j]; /*per i=1 si ha: k=3 e • min= 1 se i=2  k=3 e min= 3*/ } • }// fine del for su j • x[k] = x[i]; /* scambio tra x[3] e x[1] ottenendo 1, 4, 3 per i=1 e 1, 3, 4 per i=2*/ • x[i] = min; /* per ricerche del min. senza successo queste due frasi non hanno effetto */ • } //fine del for su i }/* fine di ordina */ fond. di informatica1 parte 5

30. E… vedere +oltre • …cercare altri algoritmi di SORT per esempio da pag. 503 del testo di Franco Crivellari: “Elementi di programmazione con il C++”, Franco Angeli; (primo riferimento in Bibliografia) dove sono descritti • METODI (Algoritmi) DI ORDINAMENTO come: • 1) selezione (per minimi successivi) • complessita’ = O(n2) • 2) scambi (bubble sort) • complessita’ = O(n2) • 3) inserzione • complessita’ = O(n2) • 4) ad albero: doppio indice (quicksort) • heap-sort • 5) distribuzione e fusione o MergeSort • Per la Complessità diapo seguente • complessita’ = • O(n log(n)) fond. di informatica1 parte 5

31. La complessità computazionale • di un ALGORITMO A ne indica il COSTO come numero di operazioni eseguite per arrivare al risultato desiderato: fornisce una misura del “running time” t del Programma realizzato con A; • il COSTO é funzione del tipo di elaborazione ( scansione lineare ? doppio ciclo o ciclo al quadrato ? è una funzione logaritmica ?…), e del tipo e dimensione n dei dati di ingresso: COSTO= f(n). • Interessa soprattutto il Costo per n ELEVATO  COSTO ASINTOTICO  lim f(n) • n  • e NEL CASO PEGGIORE (meno spesso nei casi migliore e medio!) • Quindi il Costo si indica con la notazione O(f(n)) fond. di informatica1 parte 5

32. Altro metodo di ORDINAMENTO CON DOPPIO INDICE (quicksort) se N 10 1) algoritmo di separazione:scelto nell’ array un elemento X come perno (o elemento di separazione), si effettuano spostamenti nell’ array in modo da ripartirlo in due parti: sinistra (ps) e destra (ds) che, rispetto a X (elemento di separazione), siano: elementi ps X  elementi ds 2) Si ripete “ricorsivamente” l’algoritmo di separazioneper ps e ds fino all'ordinamento completo fond. di informatica1 parte 5

33. ALGORITMO DI SEPARAZIONE • _ si sceglie un valore dell’ array (p.e. il mediano) come elemento di separazione X • _ si cerca da sinistra il primo elemen. > X e lo si sposta a destra di X se c' e’ un elem. • _ si cerca da destra il primo elemen. < X e lo si sposta a sinistra di X se c' e’ un elem. • _ si prosegue da sinistra e da destra per gli elementi successivi finche’‚ la ricerca di sinistra non si "incrocia" con quella di destra • Si ottiene: • elementi ps  X  elementi ds fond. di informatica1 parte 5

34. ESEMPIO ALGORITMO SEPARAZIONE con N=10 LISTA SIN. X LIS. DESTRA 9 1 6 4 5 8 2 7 3 0 s d 1ø riordinamento 0 1 6 4 5 8 2 7 3 9 s d 2ø riordinamento 0 1 6 4 5 3 2 7 8 9 d s s e d si "incrociano": separaz. Finita #operaz. fatte <= n; #passi da fare  log2 n se le liste sono sempre divise a metà altrimenti n fond. di informatica1 parte 5

35. COMPLESSITA' QUICKSORT • Caso peggiore: n2 • Caso medio: n log2 n • non richiede extra memoria • si realizza facilmente con una procedura ricorsiva fond. di informatica1 parte 5

36. La ricorsione • Che cosa è ? la sua definizione appare immediata dalla figura successiva tratta dal testo “Algorithm + Data Structure = Programs” di N. Wirth creatore del linguaggio Pascal; • la definizione di un oggetto in modo ricorsivo si avvale dell’ uso di versioni più semplici dell’ oggetto stesso. • Si pensi alla definizione ricorsiva di numero naturale: • 1 è un numero naturale; • il successore di un numero naturale è un numero naturale con successore(n)=n+1. fond. di informatica1 parte 5

37. fond. di informatica1 parte 5

38. Algoritmi ricorsivi • Usano una funzione che si definisce attraverso se stessa. • Vantaggi della forma ricorsiva: • formulazione naturale di problemi matematici definiti in termini di se stessi; • programmi +facili da leggere. • Svantaggi della forma ricorsiva: • attenzione a non entrare in cicli senza fine: occorre porre un limite alla definizione ricorsiva di un oggetto! • Talvolta può essere utile una soluzione di tipo iterativo! fond. di informatica1 parte 5

39. Ricorsione in C e C++ • Un sottoprogramma ricorsivo e’ attivato ricorsivamente con un SOLO richiamo per ogni attivazione. • Come esempio illustrativo si considera il fattoriale di n che si può definire in 2 modi: • n! = n.(n-1).(n-2)….3.2.1 (“produttoria”) • n! = n.(n-1)! (forma ricorsiva) Occorre porre un limite alla definizione ricorsiva della funzione fattoriale(n) limite dato dalla matematica che stabilisce: n>0 e 0!=1. Quindi la funzione ricorsiva fattoriale di n è la seguente: fond. di informatica1 parte 5

40. int fattoriale (int n) /* funzione che calcola il fattoriale di n in modo ricorsivo: se n>0 si autoattiva con n-1 ponendo in risultato il valore di n * fattoriale (n-1)… continua così finchè n diventa 0. A quel punto ritorna 1, ma a chi ? A chi l’ ha attivata l’ ultima volta ossia a se stessa ... */ { int risultato; if (n <= 0) return 1; //CONDIZIONE INDISPENSABILE!!! else { risultato = n * fattoriale (n-1); //Autoattivazione con n-1 return risultato; } } fond. di informatica1 parte 5

41. In programm7 • si trovano sia il programma per il calcolo del fattoriale con una funzione ricorsiva, sia la procedura di ordinamento che usa l’ algoritmo Quick descritto precedentemente e che segue… • A voi il compito di fare una funzione ricorsiva per calcolare i numeri di Fibonacci! Ricordare: Fib0 = 0; Fib1 = 1; Fibn+1 = Fibn + Fibn-1con n>0 (In Programm7 project33 risolve il problemino….) fond. di informatica1 parte 5

42. Quick-Sort • void ordina(int x[],int sin, int des) • /* Effettua l' ordinamento di x (tabella di n elementi) • col metodo Quick da sin a des • Parametri in ingresso: sin, des, x; • Parametri che escono definiti: x; • Variabili locali usate: i,j,k,w,perno; */ { int i,j,k; /* var. di controllo */ int w; /* var. di comodo */ int perno; /* var. col perno */ • /* Inizio parte esecutive di ordina */ i = sin; j = des; • k= (sin +des)/2; perno= x[k]; • while (x[i]<perno) i++; • while (perno< x[j]) j--; • if (i<=j) • {w= x[i]; x[i]=x[j]; x[j]=w; }//scambio • if (sin < j) ordina (x, sin,j); • //cout<<"\n finii sin ora des i="<<i<<" des="<<des; • if ((i+1) < des) ordina (x,i+1,des); • }/* fine di ordina */

43. …la provetta2 ? è in programm6 project344..Qui di seguito le dichiarazioni ed il main il main #include “…” #define MAXR 6 #define MAXC 3 /* Dichiarazione dei Prototipi dei MODULI usati */ void scrivi(int [][MAXC], char); //scrivi: visualizza la matrice per righe void attendi(); void legginiz(int [][MAXC]); //legge e inizializza la matrice per righe void calcol2colonn2 ( int [][MAXC]); //calcola i valori da porre in colonna2 void colonn3 (int[][MAXC]); // “ “ “ “ “ “ colonna3int maxcomdiv(int,int); // “ MCD int mini(int[]); // “ il min int maxi(int[]); // “ il max void scambia(int *, int *) // scambia 2 interi

44. main() { /* Inizio Modulo principale */ int A[MAXR][MAXC]; /* INIZIO Parte esecutiva */ legginiz (A); clrscr(); scrivi(A, 'A'); calcol2colonn2(A); scrivi(A, 'A'); colonn3(A); scrivi(A, 'A'); attendi(); return(0); } /* Fine Modulo principale */ fond. di informatica1 parte 5

45. Mezzalama 2 lez. 18 & seg. Vai a pag. 31 L’ emulazione della menoria introduce il ritorno all’ hardware • con lo scopo di parlare del linguaggio di E.E. • Si ricordi: • C.M. & CPU: indirizzo di ogni locazione di C.M. => in registri della CPU ( es. registro P =Punta- tore, registro I.C.= Instruction Counter ...); • Contenuto di ogni locazione di C.M. => in altri registri della CPU (per es. A = Accumulatore...); • C.M. (RAM): scandibile e rintracciabile per es. col Registro P : IndirizziMemoria <=> Registro P; • CPU = Unita’ Centrale = Unita’ Elaborativa = MicroProcessore per Personal Computer fond. di informatica1 parte 5

46. Si ricordi anche la struttura funzionale di EE gia’ vista: • Temporizzatore • Unita’ Centrale di Controllo Unita’ Aritmetico - Logica • CPU • RegistriFlag • Unita’ di controllo di I/O • Memoria Centrale • Memorie di massa • Periferiche fond. di informatica1 parte 5

47. La CPU controlla tutte le operazioni di E.E. • Le operazioni possono essere: • interne alla CPU (per es. Somma i contenuti di 2 Registri); • esterne come trasferimenti di dati verso la (o dalla) C.M. o verso le (o dalle) interfacce (Controller Unit) dei dispositivi periferici. • Notare: la CPU non invia i dati al dispositivo, ma alla sua interfaccia! fond. di informatica1 parte 5

48. La CPU lavora • in stretto contatto con la C.M. e per svolgere i suoi compiti usa i registri, i Flag (indicatori di stato) e inoltre le Unita’ di Controllo e Aritmetico-Logica (A.L.U.). I registri piu’ usati sono: • Registri P e I.C. (Istruction Counter) per tenere gli Indirizzi, • Registri tipo Accumulatore (A, B, C … ed anche Reg.1, Reg.2 ...) per tenere i Dati , • Registro Istruzione (I.R.) per tenere le Istruzioni del linguaggio di macchina. fond. di informatica1 parte 5

49. CPU: funzionamento ciclico • Ogni ciclo della CPU si compone di 3 fasi: fase di fetch (=prelievo) dell’ istruzione, • fase di decodifica dell’ istruzione, • fase di esecuzione dell’ istruzione. • In ogni fase sono usati alcuni Registri. • Le operazioni relative ad ogni fase sono idicate alla diapo seguente, ma • SALTARE 13 diapo, riprendere dai BUS. fond. di informatica1 parte 5

50. Prelievo e decodifica saltare 13 diapo • fase di fetch (=prelievo: uso dei Reg. IC e IR): • 1) Esame del Reg. I.C.; • 2) Accesso alla locazione di C.M. indirizzata da I.C.; • 3) Trasferimento del contenuto della locazione di C.M. in I.R.; • fase di decodifica: (uso del Reg. IR): • 4) Interpretazione del contenuto di I.R.; • 5) SE non e’ un' istruzione ALLORA segnalazione ERRORE e STATO DI ATTESA fond. di informatica1 parte 5