Informatica per Statistica Riassunto della lezione del 21/10/2011

Transcript

1 Informatica per Statistica Riassunto della lezione del 1/10/011 Igor Melatti Costrutti del linguaggio C: ripasso Si consideri il programma C alla Figura 1 ci sono due dichiarazioni di funzioni, insertion sort e main nel main, l array A è dichiarato con una dimensione fissa inoltre, l inizializzazione è pure fissata una volta compilato il programma, la lunghezza di A non può essere cambiata quindi ogni esecuzione di questo programma avrà A di lunghezza scrivere #define LENGTH OF A è come dire al compilatore di sostituire, prima di compilare, ogni occorrenza di LENGTH OF A con in questo esempio, anche i valori di A sono fissati a tempo di compilazione tutt al più, insertion sort cambia di posto qualche elemento tutte le esecuzioni di questo programma avranno sempre lo stesso risultato ovvero, quello che viene stampato a video non cambia mai per avere qualcosa di diverso, occorre cambiare qualcosa (lunghezza e/o inizializzazione di A) e ricompilare se si vuole ordinare un altro array di lunghezza, occorre cambiare la riga 1, mettendoci i nuovi valori, ricompilare e rieseguire se si vuole ordinare un altro array di lunghezza diversa da, occorre cambiare anche le istruzioni alle righe 6 e 8, aggiungendo o togliendo elementi ad esempio, per un array di lunghezza 7 occorrerebbe scrivere printf("%le\t%le\t%le\t%le\t%le\n", A[0], A[1], A[], A[3], A[4], A[], A[6]); la soluzione non è certo elegante per due motivi: 1

2 4 { unsigned j; 6 int i; 7 double key ; 8 9 for (j = 1; j < length_of_a ; j ++) { 10 key = A[ j]; 11 i = j - 1; 1 while ( i >= 0 && A[ i] > key ) { 13 A[i + 1] = A[i]; 14 i = i - 1; 1 } 16 A[ i + 1] = key ; 17 } 18 return; 19 } 0 1 #define LENGTH_ OF_ A 3 int main () 4 { double A[ LENGTH_OF_A ] = {0.1, 1., 3e -1, 3.4, -1 e10 }; 6 printf ("%le\t%le\t%le\t%le\t%le\n", A[0], A[1], A[], A[3], A [4]) ; 7 insertion_sort (A, LENGTH_OF_A ); 8 printf ("%le\t%le\t%le\t%le\t%le\n", A[0], A[1], A[], A[3], A [4]) ; 9 return 0; 30 } Figure 1: Implementazione in C dell Insertion Sort: input ed output fissi

3 1. si può fare di molto meglio, ovvero far sì che occorra compilare il programma una volta sola (vedere nel seguito). se si vuole ordinare un array di 1000 elementi il codice diventa noioso da scrivere (notare che il copia-incolla non risolve...) Si consideri il programma C alla Figura 4 /* il corpo della funzione insertion_ sort e lo stesso di Figura 1 */ 6 #define LENGTH_ OF_ A 7 8 int main () 9 { 10 double A[ LENGTH_ OF_ A ]; 11 unsigned i; 1 13 scanf ("%le%le%le%le%le", &A[0], &A[1], &A[], &A[3], &A [4]) ; 14 printf ("%le\t%le\t%le\t%le\t%le\n", A[0], A[1], A[], A[3], A [4]) ; 1 insertion_sort (A, LENGTH_OF_A ); 16 printf ("%le\t%le\t%le\t%le\t%le\n", A[0], A[1], A[], A[3], A [4]) ; 17 return 0; 18 } Figure : Implementazione in C dell Insertion Sort: I/O da terminale con codice non parametrico ci sono due dichiarazioni di funzioni, insertion sort (il cui corpo non è riportato, ma è lo stesso della Figura 1) e main nel main, l array A è dichiarato con una dimensione fissa, ma senza inizializzazione (riga 10) una volta compilato il programma, la lunghezza di A non può essere cambiata i suoi valori iniziali (cioè prima delle istruzioni) potrebbero essere qualsiasi nel senso che non ci si può fare alcuna assunzione ad esempio, non si può supporre che siano tutti 0 la prima istruzione del main legge da tastiera i valori per A (riga 13) un po meglio di Figura 1 almeno, se si vuole ordinare una sequenza con la stessa lunghezza, e solo i valori sono diversi, non occorre ricompilare, ma solo rieseguire il programma 3

4 quindi questo programma non stampa sempre le stesse cose ogni volta che lo si esegue: dipende da che valori si immettono in input ma se si cambia la lunghezza, c è di nuovo lo stesso problema di Figura 1 anzi, qui il problema si pone sia in lettura (riga 13) che in scrittura (righe 14 e 16): se la nuova lunghezza è 10000, diventa molto disagevole Si consideri il programma C alla Figura 3 4 /* il corpo della funzione insertion_ sort e lo stesso di Figura 1 */ 6 #define LENGTH_ OF_ A 7 8 int main () 9 { 10 double A[ LENGTH_ OF_ A ]; 11 unsigned i; 1 13 for (i = 0; i < LENGTH_OF_A ; i ++) 14 scanf ("%le", &A[i]); 1 for (i = 0; i < LENGTH_OF_A ; i ++) 16 printf ("%le\t", A[i]); 17 printf ("\n"); 18 insertion_sort (A, LENGTH_OF_A ); 19 for (i = 0; i < LENGTH_OF_A ; i ++) 0 printf ("%le\t", A[i]); 1 printf ("\n"); return 0; 3 } Figure 3: Implementazione in C dell Insertion Sort: I/O da terminale ci sono due dichiarazioni di funzioni, insertion sort (il cui corpo non è riportato, ma è lo stesso della Figura 1) e main nel main, l array A è dichiarato con una dimensione fissa, ma senza inizializzazione come nella Figura, i valori di A vengono letti da tastiera quindi anche questo programma non stampa sempre le stesse cose, dipende da cosa si immette da tastiera ma qui c è un ciclo for (righe 13 14) anziché un istruzione singola 4

5 altri due cicli for sono usati per scrivere a video i valori di A prima (righe 1 16) e dopo (righe 19 0) l ordinamento questa soluzione può essere definita parametrica nella lunghezza dell array infatti, ancora una volta in questo programma la lunghezza di A è fissa se la si volesse cambiare, occorrerebbe ricompilare il programma ma a differenza dei programmi nelle Figure 1 e, l unica cosa che occorre cambiare è la lunghezza dell array, dopodiché si ricompila e si riesegue se si vogliono ordinare 1000 elementi, basta sostituire con 1000 alla riga 6 infatti, la semantica del ciclo for alle righe (per gli altri due cicli si può fare un ragionamento analogo) prevede che l istruzione di lettura alla riga 14, che pure legge un singolo valore e lo mette in A[i], venga ripetuto esattamente LENGTH OF A volte, con i che di volta in volta prende i valori che vanno da 0 a LENGTH OF A - 1, ottenendo quindi lo stesso risultato della riga 13 di Figura Si consideri il programma C alla Figura 4 semanticamente è come il programma di Figura 3 solo che è meglio leggibile infatti, ci sono 4 definizioni di funzioni: oltre che insertion sort e main, ci sono anche leggi un array e scrivi un array leggi un array sfrutta il fatto che lo stesso pezzo di codice doveva essere scritto, in Figura 3, sia alle righe 1 17 che alle righe 19 1 allora tanto vale scrivere queste righe una volta per tutte in una definizione di funzione (leggi un array, righe 14 1), per poi semplicemente chiamare questa funzione nel main (righe 9 e 31) fatto questo, viene naturale fare la stessa cosa con il ciclo di lettura, definendo quindi la funzione scrivi un array e chiamandola poi nel main Si consideri il programma C alla Figura molto simile al programma di Figura solo che legge anche la lunghezza del vettore notare che length of A e LENGTH OF A sono due identificatori diversi: il case (ovvero la scelta minuscolo/maiuscolo) è importante notare anche che si tratta di due categorie sintattiche diverse: length of A è una variabile, LENGTH OF A è una costante

6 4 /* il corpo della funzione insertion_ sort e lo stesso di Figura 1 */ 6 void leggi_ un_ array ( double *A, unsigned length_ of_ A ) 7 { 8 unsigned i; 9 10 for (i = 0; i < length_of_a ; i ++) 11 scanf ("%le", &A[i]); 1 } void scrivi_ un_ array ( double *A, unsigned length_ of_ A ) 1 { 16 unsigned i; for (i = 0; i < length_of_a ; i ++) 19 printf ("%le\t", A[i]); 0 printf ("\n"); 1 } 3 #define LENGTH_ OF_ A 4 int main () 6 { 7 double A[ LENGTH_ OF_ A ]; 8 leggi_un_array (A, LENGTH_OF_A ); 9 scrivi_un_array (A, LENGTH_OF_A ); 30 insertion_sort (A, LENGTH_OF_A ); 31 scrivi_un_array (A, LENGTH_OF_A ); 3 return 0; 33 } Figure 4: Implementazione in C dell Insertion Sort: I/O da terminale con funzioni 6

7 4 /* il corpo della funzione insertion_ sort e lo stesso di Figura 1 */ 6 void leggi_ un_ array ( double *A, unsigned length_ of_ A ) 7 { 8 unsigned i; 9 10 for (i = 0; i < length_of_a ; i ++) 11 scanf ("%le", &A[i]); 1 } void scrivi_ un_ array ( double *A, unsigned length_ of_ A ) 1 { 16 unsigned i; for (i = 0; i < length_of_a ; i ++) 19 printf ("%le\t", A[i]); 0 printf ("\n"); 1 } 3 #define LENGTH_ OF_ A 0 4 int main () 6 { 7 double A[ LENGTH_ OF_ A ]; 8 unsigned length_ of_ A ; 9 scanf ("%u", & length_of_a ); 30 leggi_un_array (A, length_of_a ); 31 scrivi_un_array (A, length_of_a ); 3 insertion_sort (A, length_of_a ); 33 scrivi_un_array (A, length_of_a ); 34 return 0; 3 } Figure : Implementazione in C dell Insertion Sort: I/O da terminale con funzioni, con lunghezza array variabile 7

8 se si immettono più di 10 elementi, il programma va in crash (segmentation fault, provare per credere) infatti, la dichiarazione dell array A prevede che abbia esattamente 10 elementi il resto di questo programma è fatto in maniera che si possano considerare solo i primi length of A elementi di A infatti, length of A viene usato come limite per i vari for (compreso quello dell insertion sort...), quindi gli unici elementi che saranno letti/scritti/ordinati/scritti sono solo i primi length of A elementi Esercizi: provare a fare le seguenti modifiche ai programmi sopra riportati (verranno visti alla prossima esercitazione in laboratorio) 1. modificare main in modo che si rifiuti di continuare nell esecuzione se la lunghezza immessa è maggiore di LENGTH OF A quindi le successive operazioni (lettura elementi di A, stampa, ordinamento, stampa) andranno effettuate solo se length of A è al più LENGTH OF A) altrimenti, il programma deve finire subito. modificare leggi un array in modo che stampi anche una frase esplicativa prima di leggere un elemento, del tipo Immettere l elemento i-esimo al posto di i occorre mettere il numero vero, quindi le varie stampe saranno così: Immettere il 1-esimo elemento, Immettere il -esimo elemento, come al punto, ma fare in modo che stampi, anziché 1-esimo, primo 4. come al punto 3, ma fare in modo che stampi, anziché -esimo, secondo. come al punto 4, ma fare in modo che stampi correttamente i numeri ordinali fino a 10 (dopo il 10, è corretto aggiungere esimo : 11-esimo, 1-esimo...) 6. modificare il main in modo tale che, prima di stampare il vettore solo nella parte da ordinare, lo stampi anche per intero (sia prima che dopo l ordinamento) 7. fare la stessa cosa del punto 6, ma senza modificare il main 8. fare la stessa cosa del punto 1, ma spostando la lettura della lunghezza dal main alla funzione leggi un array; per farlo, modificare la funzione leggi un array in modo che restituisca la lunghezza letta modificare il programma ottenuto al punto 8 in modo tale che effettui ripetutamente le operazioni di lettura/scrittura/ordinamento/scrittura finché la lunghezza letta non diventa minore od uguale di zero, o maggiore di LENGTH OF A 8