Programmazione Procedurale in Linguaggio C++ Sottoprogrammi Parte 3 (b) Metodologia di Sviluppo versione 2.0 Questolavoroè concessoin uso secondoi termini di unalicenzacreative Commons (vedi ultima pagina) G. Mecca Università della Basilicata mecca@unibas.it Sottoprogrammi: Programmazione Modulare >> Sommario Sommario Introduzione Metodologia per Raffinamenti Esempio: Indovina il Numero Esempio: Linee Guida per la Scrittura del Codice 2
Sottoprogrammi: Programmazione Modulare >> Introduzione Introduzione Nella lezione precedente a) albero delle chiamate b) regole di visibilità e utilizzo dei dati c) compilazione separata e riuso del codice In questa lezione d) metodologia di sviluppo per raffinamenti successivi e) linee guida per la scrittura di codice di qualità 3 Metodologia per Raffinamenti Tecnica per la scrittura di programmi effettuare l analisi delle specifiche scegliere l algoritmo scrivere il codice sorgente compilare e correggere gli errori sintattici verificare e correggere gli errori logici I passi cruciali algoritmo, codice sorgente e verifica 4
Metodologia per Raffinamenti Tecnica per raffinamenti successivi partire dalla specifica del problema complessivo individuare (preliminarmente) una strategia di dichiarazioni per la rappresentazione dei dati individuare una prima divisione sommaria del problema in passi (sottoproblemi) supporre di disporre di un sottoprogramma per ciascun passo 5 Metodologia per Raffinamenti Tecnica per raffinamenti successivi (cont.) definire il prototipo del sottoprogramma (modalità di comunicazione con l esterno) a questo punto è possibile scrivere una prima versione del codice del programma principale per completare la soluzione, è necessario raffinare la soluzione riapplicando lo stesso procedimento a ciascun sottoproblema 6
Metodologia per Raffinamenti Attenzione la tecnica suggerita è centrata sulla scrittura del codice il procedimento viene applicato lavorando direttamente sul codice sorgente si alternano fasi di riflessione sulla strategia a fasi di scrittura del codice è necessario prevedere anche fasi di verifica incrementale del codice scritto 7 Metodologia per Raffinamenti Verifiche incrementali compilare frequentemente il codice scritto per intercettare precocemente gli errori sintattici eseguire il codice non appena si raggiungono punti stabili (es: lettura e stampa oppure soluzioni intermedie) per intercettare precocemente eventuali errori logici 8
Indovina il Numero Specifica il calcolatore acquisisce il nome del giocatore il calcolatore sceglie un numero a caso compreso tra 1 e 100 il giocatore deve indovinare il numero facendo dei tentativi; ad ogni tentativo, se il numero è corretto, il giocatore vince; altrimenti il calcolatore risponde con un suggerimento che può essere Prova con un numero più alto oppure Prova con un numero più basso il calcolatore tiene traccia del numero di tentativi effettuati dal giocatore in qualsiasi momento il giocatore deve poter interrompere la partita e visualizzare il numero da indovinare 9 Indovina il Numero Analisi delle specifiche dati di ingresso: nome del giocatore e sequenza dei tentativi dati di uscita: messaggi del computer e numero di tentativi effettuati Domanda: come interrompere la partita? prima soluzione: un menu apposito presentato ogni volta (poco usabile) seconda soluzione: valore 0 per il tentativo Algoritmo e codice (>>> scrittura del prog.) 10
Indovina il Numero Riassumiamo il metodo I iterazione: Programma principale passo n.1: inizia il gioco e acquisisci il nome passo n.2: gioca le partite passo n.3: fine gioco e stampa il saluto Per ognuno dei passi (sottoproblemi) un sottoprogramma in alcuni casi è necessario ripetere il procedimento 11 Indovina il Numero #include <iostream.h> void schermolegginome(string &nome); void gioca(string nome); void schermofinale(string nome); void main() { string nome; } schermolegginome(nome); // per il passo 1 gioca(nome); // per il passo 2 schermofinale(nome); // per il passo 3 12
Indovina il Numero schermolegginome scrittura diretta schermofinale scrittura diretta II iterazione: gioca passo 2.1: genera il numero passo 2.2: gestisci tentativi 13 Indovina il Numero int generanumero(); void gestiscitentativi(string nome, int numero); void gioca(string nome) { int numero; numero = generanumero(); gestiscitentativi(nome, numero); } 14
Indovina il Numero generanumero scrittura diretta III iterazione: gestiscitentativi finchè l utente vuole andare avanti passo 2.2.1: acquisisci il tentativo se il tentativo è uguale a 0 interrompi il gioco passo 2.2.2: visualizza lo schermo di partita interrotta altrimenti se il tentativo è uguale al numero passo 2.2.3: visualizza lo schermo di vittoria altrimenti passo 2.2.4: analizza il tentativo e stampa l esito 15 Indovina il Numero //...prototipi omessi per ragioni di spazio void gestiscitentativi(string nome, int numero) { int giocata; int tentativi = 0; bool continua = true; while (continua) { giocata = schermotentativo(nome, tentativi); if (giocata == 0) { continua = false; schermointerruzione(nome, numero, tentativi); } else if (giocata == numero) { continua = false; schermoindovinato(nome, tentativi); } else { schermoesitogiocata(nome, numero, giocata); } } return; } 16
Indovina il Numero schermotentativo scritura diretta schermointerruzione scrittura diretta schermoindovinato scrittura diretta schermoesitogiocata scrittura diretta 17 Indovina il Numero In sintesi quindi il metodo guida il programmatore dall inizio alla fine della scrittura del codice applicato sistematicamente consente di produrre abbastanza facilmente la soluzione Attenzione è opportuno compilare progressivamente è opportuno eseguire e verificare progressivamente il codice scritto 18
Specifica siano dati due rettangoli nel piano cartesiano si supponga che i due rettangoli abbiano i lati paralleli agli assi cartesiani analizzare i rettangoli e stampare il quadrante in cui sono contenuti verificare se i due rettangoli hanno una sovrapposizione (una parte di piano che cade in entrambi i rettangoli) se sì, stampare l area della superficie comune 19 Esempi rettangoli nel I quadrante in questo caso c è una superficie comune di area pari a 12 cm 2 I rettangolo a cavallo tra più quadranti II rettangolo nel I quadrante in questo caso non c è superficie comune 20
Analisi della specifica è fondamentale l ipotesi semplificativa per cui i lati sono paralleli agli assi il problema principale è che i rettangoli possono essere in uno qualsiasi dei quadranti e le posizioni reciproche possono essere varie (disgiunti, parz. sovrapp., tot. sovrapp.) la casistica è abbastanza ampia 21 Analisi della specifica (continua) ambiguità: nell analisi del quadrante bisogna stabilire come considerare gli assi soluzione: stabiliamo di considerare gli assi come parte dei quadranti positivi nel caso in cui il rettangolo non sia in un unico quadrante stamperemo un messaggio generico Rettangolo tra più quadranti 22
Strategia per la rappresentazione dei dati ci sono vari modi per rappresentare un rettangolo in questo caso utilizzeremo le coordinate di due dei vertici ogni rettangolo sarà rappresentato con 4 variabili reali 2 coordinate del vertice in basso a sinistra 2 coordinate del vertice in alto a destra 23 Esempi rettangolo 1: (1, 2) (7, 6) rettangolo 2: (3, 1) (8, 5) rettangolo 1: (-2, 3.5) (3, 5.5) rettangolo 2: (2, 1) (6.2, 3) 24
A questo punto è possibile passare alla scrittura del codice (>>> scrittura del programma) Programma Principale: I Raffinamento passo 1: leggi i dati dei rettangoli passo 2: stampa i dati dei rettangoli passo 3: analizza i quadranti passo 4: trova la superficie comune passo 5: stampa il risultato 25 void leggidatirettangolo(float &x1,float &y1,float &x2,float &y2); void stampadatirettangolo(float x1, float y1, float x2, float y2); void stampaquadrante(float x1, float y1, float x2, float y2); float areasovrapposizione(float x1,float y1,float x2,float y2, float x3,float y3,float x4,float y4); void stamparisultato(float superficie); NOTA: tutte le procedure sono schermi (il nome è abbreviato) void main() { float x1, y1, x2, y2, x3, y3, x4, y4; float superficie; leggidatirettangolo(x1, y1, x2, y2); leggidatirettangolo(x3, y3, x4, y4); stampadatirettangolo(x1, y1, x2, y2); stampaquadrante(x1, y1, x2, y2); stampadatirettangolo(x3, y3, x4, y4); stampaquadrante(x3, y3, x4, y4); superficie = areasovrapposizione(x1,y1,x2,y2,x3,y3,x4,y4); stamparisultato(superficie); } 26
II Raffinamento passo 1: procedura leggirettangolo > scrittura diretta del codice passo 2: procedura stamparettangolo > scrittura diretta del codice passo 3: procedura stampaquadrante > applico iterativamente il procedimento passo 4: funzione areasovrapposizione > applico iterativamente il procedimento passo 5: stampa il risultato > scrittura diretta del codice 27 Come al solito in generale scrivo prima il codice del modulo chiamante e poi quello dei moduli chiamati stabilisco un accordo relativo alla chiamata prima ancora di avere deciso i dettagli del codice accordo: nome del modulo, numero e tipo dei parametri, eventuale tipo del risultato 28
Passo 3: stampaquadrante passo 3.1: trova il quadrante del vertice in basso a sinistra passo 3.2: trova il quadrante del vertice in alto a destra se sono nello stesso quadrante stampa il quadrante altrimenti stampa Rettangolo tra quadranti diversi 29 int quadrante(float x, float y); void stampaquadrante(float x1, float y1, float x2, float y2){ int q1, q2; q1 = quadrante(x1, y1); q2 = quadrante(x2, y2); cout << "----------------------------------------\n"; if (q1==q2) { cout << "Rettangolo nel quadrante n. " << q1 << "\n"; } else { cout << "Rettangolo a cavallo tra quadranti diversi \n"; } cout << "----------------------------------------\n"; return; } 30
Passo 3.1: quadrante il passo 3.1 e il passo 3.2 richiedono la stessa funzione dato un punto, deve restituire un numero intero corrispondente al quadrante è possibile scrivere direttamente il codice analizzando il valore dell ascissa e dell ordinata 31 int quadrante(float x, float y) { int q; if (x >= 0 && y >= 0) { q = 1; } else if (x < 0 && y >= 0) { q = 2; } else if (x < 0 && y < 0) { q = 3; } else { q = 4; } return q; } 32
Passo 4: areasovrapposizione si tratta di calcolare effettivamente l area della sovrapposizione In effetti la sovrapposizione, se c è, è un rettangolo posso pensare di calcolarne separatamente la base e l altezza e poi calcolarne l area 33 Di conseguenza dovrei calcolare l eventuale sovrapposizione tra le due basi l eventuale sovrapposizione tra le due altezze 34
Passo 4: areasovrapposizione passo 4.1: trova la lunghezza dell eventuale sovrapposizione tra le basi passo 4.2: trova la lunghezza dell eventuale sovrapposizione tra le altezze se entrambe le lunghezze sono positive calcola il prodotto restituisci il prodotto calcolato altrimenti restituisci 0 35 In realtà il passo 4.1 e il passo 4.2 corrispondono a ripetere due volte la stessa operazione trovare la sovrapposizione tra due segmenti è un problema unidimensionale: dati due generici segmenti su un asse, trovare la lunghezza dell event. segmento comune la prima volta i segmenti sono le basi la seconda volta i segmenti sono le altezze 36
Quindi utilizzerò un unica funzione lunghezzasegmentocomune che lavora su due segmenti ogni segmento è rappresentato dalle coordinate dei due estremi su un asse -2 0 2 4 6 8 I caso: segmento 1: (-1, 3) segmento 2: (6, 8) II caso: segmento 1: (-1, 5) segmento 2: (3, 8) 37 float lunghezzasegmentocomune (float z1, float z2, float z3, float z4); float areasovrapposizione(float x1,float y1,float x2,float y2, float x3,float y3,float x4,float y4) { float sovrapposizionebasi; float sovrapposizionealtezze; float area = 0; sovrapposizionebasi = lunghezzasegmentocomune(x1,x2,x3,x4); sovrapposizionealtezze =lunghezzasegmentocomune(y1,y2,y3,y4); if (sovrapposizionebasi > 0 && sovrapposizionealtezze > 0) { area=sovrapposizionebasi*sovrapposizionealtezze; } return area; } 38
III Raffinamento è necessario scrivere la funzione lunghezzasegmentocomune Soluzione n.1 analisi caso per caso estremamente difficile da scrivere (casistica molto ampia) 39 Soluzione n.2 analizzando il problema, è possibile trovare una formula compatta che risolve il problema dati due segmenti di estremi z1-z2 e z3-z4 calcoliamo le lungh.: L1= z2-z1, L2= z4-z3 calcoliamo la coordinata di valore più basso INF = min(z1, z3) calcoliamo la coordinata di valore più alto SUP = max(z2, z4) 40
Soluzione n.2 (continua) calcoliamo L = (L1 + L2) - SUP - INF se L>0, i due segmenti hanno una porzione comune di lunghezza L Intuizione I caso: L1=5, L2=2, INF=1, SUP=8 L=5+2-8-1 =0 II caso: L1=4, L2=2, INF=-1, SUP=8 L=4+2-8+1 =-3 II caso: L1=6, L2=5, INF=-1, SUP=8 L=6+5-8+1 =2-2 0 2 4 6 8 41 Vantaggio della formula funziona in tutti i possibili casi (coordinate positive o negative, segmenti disgiunti, parzialmente o totalmente sovrapposti, ecc.) il codice è estremamente compatto soluzione elegante ma si tratta di un algoritmo per nulla scontato richiede capacità di analisi e conoscenza della geometria 42
A questo punto il problema è praticamente risolto è necessario utilizzare una funzione per il calcolo del minimo > scrittura diretta è necessario utilizzare una funzione per il calcolo del massimo > scrittura diretta la funzione lunghezzasegmentocomune può essere scritta come segue 43 float minimo(float a, float b); float massimo(float a, float b); float lunghezzasegmentocomune (float z1, float z2, float z3, float z4){ float lunghezza1, lunghezza2; float estremoinferiore, estremosuperiore; float lunghezza; lunghezza1 = fabs(z2-z1); lunghezza2 = fabs(z4-z3); estremoinferiore = minimo(z1, z3); estremosuperiore = massimo(z2, z4); lunghezza = lunghezza1 + lunghezza2 - fabs(estremosuperiore - estremoinferiore); return lunghezza; } 44
Una volta completata la scrittura è necessario verificare la correttezza Verifica è necessario costruire un insieme di dati di test per effettuare le verifiche devono rappresentare tutti o pressoché tutti i casi significativi ogni volta che il programma viene modificato, è necessario ripetere tutte le verifiche 45 Una porzione dei dati di test >> rettangoli1.cpp rettangolo 1: (1, 2) (7, 6) rettangolo 1: (-2, 3.5) (3, 5.5) rettangolo 2: (3, 1) (8, 5) rettangolo 2: (2, 1) (6.2, 3) sovrapposizione: 12 cm 2 sovrapposizione: 0 46
Metodologia per Raffinamenti In sintesi, ci sono buone e cattive notizie Buone notizie il metodo suggerito aiuta concretamente ad affrontare la soluzione di problemi complessi sequenza di passi sistematica centrata sulla scrittura del codice Cattive notizie non rappresenta di per sé la soluzione a tutti i problemi 47 Metodologia per Raffinamenti Il metodo è utile nella soluzione di problemi standard che rappresentano la maggioranza dei casi Ma, per essere un ottimo programmatore occorre anche essere creativi essere in grado di concepire soluzioni a volte originali a problemi meno usuali la creatività non si impara 48
Metodologia per Raffinamenti Statisticamente, al giorno d oggi il 90% circa del software sviluppato al giorno d oggi è software client-server con una logica applicativa molto semplice (interfaccia utente per sistemi di basi di dati) competenze standard Il resto del software applicazioni particolari che richiedono seria riflessione dal punto di vista della soluzione 49 Sottoprogrammi: Programmazione Modulare >> Linee Guida Linee Guida per Scrivere il Codice Obiettivo scrivere codice di qualità Qualità del codice correttezza (sintattica e semantica) semplicità e leggibilità (consente di semplificare la manutenzione) modularità (buona organizzazione) efficienza (consente di risolvere i problemi più rapidamente) 50
Sottoprogrammi: Programmazione Modulare >> Linee Guida Semplicità e Leggibilità Linea guida n.1 adottare sempre la soluzione più semplice tra quelle che potrebbero funzionare non complicare mai inutilmente il codice In generale la prima soluzione ad un problema non è mai la migliore conviene migliorarla e renderla più generale con il tempo, quando il problema è più chiaro 51 Sottoprogrammi: Programmazione Modulare >> Linee Guida Semplicità e Leggibilità Linea guida n.2 adottare regole di stile scegliere accuratamente gli identificatori per variabili e sottoprogrammi - notazione cammello indentare il codice adottare regole per la posizione delle parentesi utilizzare sempre le parentesi 52
Sottoprogrammi: Programmazione Modulare >> Linee Guida Semplicità e Leggibilità Linea guida n.3 scrivere moduli brevi nel caso di problemi complessi, spezzarli in più passi per frammentare la soluzione regola grossolana: il codice di un sottoprogramma non dovrebbe mai richiedere più di 30 secondi per essere interpretato da un altro programmatore di fatto questo può rendere inutili i commenti 53 Sottoprogrammi: Programmazione Modulare >> Linee Guida Modularità Linea guida n.4 adottare la metodologia incrementale procedere per raffinamenti successivi Linea guida n.5 compilare progressivamente e frequentemente il codice verificare progressivamente il codice eseguibile 54
Sottoprogrammi: Programmazione Modulare >> Linee Guida Modularità Linea guida n.6 ragionare accuratamente sui parametri scegliere con cura quali e quanti parametri (evitare parametri inutili) scegliere con cura il tipo dei parametri (standard o per riferimento) normalmente parametri standard per le funzioni 55 Sottoprogrammi: Programmazione Modulare >> Linee Guida Modularità Linea guida n.7 minimizzare l accoppiamento tra i sottoprogrammi analizzare il diagramma delle chiamate verificare che la logica applicativa del programma sia chiara ed ordinata Linea guida n.8 non utilizzare mai variabili globali è consentito di utilizzare costanti globali 56
Sottoprogrammi: Programmazione Modulare >> Linee Guida Modularità Linea guida n.9 massimizzare la coesione all interno di un sottoprogramma ogni sottoprogramma deve avere una funzione precisa nell applicazione deve risolvere un problema ben preciso e non fare due o più cose diverse 57 Sottoprogrammi: Programmazione Modulare >> Linee Guida Modularità Linea guida n.10 separare i sottoprogrammi orientati all elaborazione dai sottoprogrammi orientati all interazione con l utente i secondi (tipicamente chiamati schermi ) sono meno riutilizzabili, sia nella stessa applicazione che in applicazioni diverse i primi dovrebbero essere pensati per essere per quanto possibile riutilizzabili 58
Sottoprogrammi: Programmazione Modulare >> Linee Guida Modularità Linea guida n.10 (cont.) ogni applicazione dovrebbe avere una collezione di sottoprogrammi per le elaborazione che non interagiscono con l utente ed una collezione di sottoprogrammi per la gestione dell interazione con l utente >> sottoprogrammi di interfaccia le funzionalità dovrebbero essere ben separate 59 Sottoprogrammi: Programmazione Modulare >> Sommario Riassumendo Metodologia suggerita per raffinamenti successivi Linee Guida di Carattere Metodologico per la scrittura di codice di qualità 60
Termini della Licenza Termini della Licenza This work is licensed under the Creative Commons Attribution- ShareAlike License. To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/1.0/ or send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA. Questo lavoro viene concesso in uso secondo i termini della licenza Attribution-ShareAlike di Creative Commons. Per ottenere una copiadella licenza, è possibile visitare http://creativecommons.org/licenses/by-sa/1.0/ oppure inviare una lettera all indirizzo Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA. 61