• caratteristichedigeneralità Sottoprogrammi • decomposizione di un problema (programma) in sottoproblemi Sottoprogrammi

(1)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 1

Motivazioni:

• decomposizione di un problema (programma) in sottoproblemi (sottoprogrammi)

– permette di ridurre la complessità del problema complessivo che viene risolto più facilmente risolvendo ciascun sottoproblema per volta

• caratteristiche di generalità

– risolvere un problema di tipo generale molto diffuso: il codice relativo è prodotto una sola volta e riusato chiamando (attivando) lo specifico sottoprogramma all’interno di differenti programmi

… meccanismo di astrazione funzionale ….

il (nome del) sottoprogramma è associato ad “una funzionalità”, nascondendo i dettagli dell’algoritmo e della relativa codifica

Sottoprogrammi

… esempi ...

– Gioco ‘Mastermind’

• Generare in modo casuale i valori del codificatore da indovinare

• Leggere i valori del decodificatore

• Verificare se ciascun valore del decodificatore è presente nella combinazione del codificatore

• Verificare se la combinazione del codificatore è uguale a quella del codificatore

• Stampare se il decodificatore ha vinto o meno

– risolvere un problema di tipo generale molto diffuso: il codice relativo è prodotto una sola volta e riusato (più volte) chiamando (attivando) lo specifico sottoprogramma

Ad es.

• Si definisce una sola volta la parte di programma per generare in modo casuale i valori del codificatore

• Si definisce una sola volta la parte di programma per verificare se ciascun valore del decodificatore è presente nella combinazione del codificatore

(2)

Es. … verificare se ciascun valore del decodificatore è presente nella combinazione del codificatore

if(indovinato1 == indovina1) pos1 = '+';

else

if((indovinato1 == indovina2) || (indovinato1 == indovina3)) pos1 = '=';

elsepos1 = '-';

else

elsepos2 = '-';

else

elsepos3 = '-‘;

… ripetute per tre volte una sequenza di istruzioni molto simili tra loro …

Prof. G. A. Di Lucca - Univ. del Sannio

Modulo_sottoprogramma

VerificaValore ( indovinatoX, codificatoreX, codificatoreY, codificatoreZ, pos ) { …

if(indovinatoX == codificatoreX) pos = '+';

else

if((indovinatoX == codificatoreY) || (indovinato == codificatoreZ)) pos= '=';

elsepos = '-';

}

… di volta in volta i parametri indovinatoX e pos saranno associati rispettivamente alle variabili indovinato1, indovinato2, indovinato3, e pos1, pos2 e pos3

invece di ripetere tre volte le istruzioni per assegnare l’opportuno valore a pos1, pos2, e pos3 si può scrivere del codice più generale che fa tali operazioni

‘racchiudendole’ in un modulo separato di programma che è attivato quando serve

Esempio

(3)

Prof. G. A. Di Lucca - Univ. del Sannio

Elementi di Informatica 5

Un sottoprogramma è un costrutto sintattico messo a disposizione dai linguaggi di programmazione per:

• Raggruppare una sequenza di istruzioni, che svolgono una certa azione elaborativa, associando ad esse un nome (significativo della azione svolta) usato per invocarne la loro esecuzione

• Descrivere tale azione elaborativa una sola volta per tutte

utilizzandola più volte in uno stesso programma, o in differenti programmi, senza dover riscrivere le stesse linee di codice

• attivare (chiamare, invocare) tale azione all’interno del programma che definisce il sottoprogramma o di un altro sottoprogramma

– Es. scanf( ), printf( )

sottoprogrammi raggruppanti istruzioni in grado di, rispettivamente, leggere i valori corrispondenti ai tasti premuti e di visualizzare caratteri sullo schermo

Sono una tipologia di programmi NON eseguibili autonomamente, ma soltanto sotto il controllo di un programma, o di un altro sottoprogramma, che ne attiva (chiama) l’esecuzione.

Sottoprogrammi

Vantaggi:

• Strutturazione e decomposizione funzionale del programma:

si ottiene una scrittura del programma che meglio riflette l’analisi delle funzionalità del problema

• Compattezza ed efficienza del codice:

– si evita di ripetere stesse sequenze di istruzioni in più parti del programma

• Facilità di Riuso:

– sottoprogrammi (non troppo specifici) possono essere memorizzati in particolari file (le ‘librerie’) in modo da poter essere riusati (chiamati) da programmi diversi

• Migliore Modificabilità:

– Si modifica il sottoprogramma e non le varie ‘repliche’ del codice (la modifica vale per tutte le attivazioni del sottoprogramma)

• Miglioramento della leggibilità e comprensione del programma

• Maggiore facilità di testing:

– Il testing è facilitato dal poter testare i singoli sottoprogrammi e poi l’intero programma visto come insieme di chiamate che si scambiano informazioni

(4)

Sottoprogrammi

… esempi ...

– Gioco ‘Mastermind’

• Generare in modo casuale i valori del codificatore da indovinare

• Leggere i valori del decodificatore

• Verificare se ciascun valore del decodificatore è presente nella combinazione del codificatore

• Verificare se la combinazione del codificatore è uguale a quella del codificatore

• Stampare se il decodificatore ha vinto o meno

– risolvere un problema di tipo generale molto diffuso: il codice relativo è prodotto una sola volta e riusato (più volte) chiamando (attivando) lo specifico sottoprogramma

Ad es.

• Si definisce una sola volta la parte di programma per generare in modo casuale i valori del codificatore

• Si definisce una sola volta la parte di programma per verificare se ciascun valore del decodificatore è presente nella combinazione del codificatore

Sottoprogrammi

… esempio ….

Gioca a Mastermind

…. Un programma + sottoprogrammi Program

…..

begin

…………

GeneraNumeroCasualeTra_0_e_9 ( X ); //invocazione sottoprogramma per ...

// istruzioni programma per leggere valori decodificatore

…

VerificaValore (Indovinato1, codificatore1, codificatore2, codificatore3, pos1 );

//invocazione sottoprogramma per ...

// istruzioni programma per verificare se combinazioni codificatore e decodificatore uguali

…..

// istruzioni nel programma per stampare risultato end.

(5)

Struttura di un Sottoprogramma :

Sottoprogramma SP (X,Y);

begin

<dichiarazione variabili> ;

………..;

end;

Sottoprogramma SP

Parametri formali

Intestazione

Nome Sottoprogramma

‘Corpo’ (istruzioni) Sottoprogramma

Sottoprogrammi

L’attivazione di un Sottoprogramma SP avviene tramite una istruzione di chiamata effettuata da un programma (o da un altro

sottoprogramma), che indichiamo con P_Calling, detto programma principale o chiamante

All’attivazione di SP:

• l’esecuzione di P_Calling è sospesa

• è effettuata l’esecuzione di SP

• alla fine dell’esecuzione di SP viene ripresa l’esecuzione di P_Calling eseguendo la prima istruzione successiva a quella di chiamata di SP

Uno stesso sottoprogramma può essere chiamato più volte sia dal programma principale che da altri sottoprogrammi

Uno stesso sottoprogramma può essere usato in differenti programmi/sottoprogrammi

(6)

Sottoprogrammi

Programma P_Calling

………..

begin

………..;

Chiama SP;

………..;

Chiama SP;

………..;

end.

Sottoprogramma SP ();

begin

………..;

end;

… flusso di controllo in chiamate a sottoprogramma

Sottoprogrammi

Programma P_Calling

………..;

Chiama SP;

………..;

Chiama SP;

………..;

Sottoprogramma SP();

………..;

end

;

… uno stesso sottoprogramma può essere usato (chiamato) da diversi programmi

Programma M_Calling

………..;

Chiama SP;

………..;

(7)

Sottoprogrammi

Tra programma chiamante e sottoprogramma vi può essere uno scambio di informazioni effettuato tramite una

lista di parametri

I parametri sono passati dal chiamante al sottoprogramma

Il sottoprogramma opera sui valori di alcuni parametri di ingresso e può calcolare i valori di alcuni parametri di uscita, che sono resi disponibili (ritornati) al programma chiamante

Il sottoprogramma può dichiarare delle proprie variabili locali, proprie solo del sottoprogramma (definite ed usate nel

sottoprogramma insieme ai parametri). Le variabili locali sono

‘conosciute’ dal solo sottoprogramma e non possono essere usate in altri sottoprogrammi o nel programma chiamante.

Sottoprogrammi Parametri effettivi:

la lista delle variabili che il programma chiamante indica (passa) al sottoprogramma; sono variabili proprie del programma chiamante (sono variabili dichiarate in esso) e contengono i valori effettivi dell’elaborazione.

i parametri effettivi sono detti anche attuali

la lista delle variabili usate dal sottoprogramma nella sua esecuzione; sono proprie del sottoprogramma e contengono i valori scambiati con il programma principale corrispondenti ai parametri effettivi

Parametri formali:

I parametri effettivi possono essere nomi di variabili,

costanti, espressioni

(8)

Sottoprogrammi

La lista dei parametri effettivi è indicata tra parentesi nella istruzione di chiamata del sottoprogramma

La lista dei parametri formali è indicata tra parentesi nell’intestazione del sottoprogramma. Ad ogni parametro effettivo deve corrispondere uno, ed uno solo, parametro formale, e viceversa

La corrispondeza tra parametri è per posizione: al primo parametro effettivo corrisponde il primo parametro formale, e così via

All’attivazione di un sottoprogramma, a ciascun parametro formale di questo è ‘sostituito’ il corrispondente parametro effettivo

Sottoprogrammi

Programma chiamante PG Programma PG;

………..;

Chiama SP(A, B);

………..;

Chiama SP(M, 24);

………..;

end.

………..;

INT Somma;

………..;

Somma=X+Y;

write(“Somma= “, Somma);

………..;

end;

Parametri effettivi Parametri formali Un esempio:

Prima Attivazione: A X, B Y,

se A=5, B= 8 nell’esecuzione di SP è stampato Somma=13

(9)

Programma chiamante PG Programma PG;

………..;

Chiama SP(A, B);

………..;

Chiama SP(M, 24);

………..;

end.

………..;

INT Somma;

………..;

Somma=X+Y;

write(“Somma= “, Somma);

………..;

end;

Parametri effettivi Parametri formali Un esempio:

Seconda Attivazione: M X, 24 Y,

se M=10, nell’esecuzione di SP è stampato Somma=34

Sottoprogrammi

Principali meccanismi di scambio dei parametri:

per VALORE:

all’atto della chiamata il valore dei parametri attuali viene copiato nei corrispondenti parametri formali.

Durante l’esecuzione del sottoprogramma, il valore dei parametri effettivi NON viene modificato, anche se quello dei parametri formali lo è.

Sono utilizzate locazioni di memoria diverse per i parametri attuali e formali

(10)

Registri parametri effettivi A

B

Registri parametri formali X Y 27

513

27 513

all’attivazione all’attivazione

Sottoprogrammi: scambio per valore

Programma PG;

…

A = 27; B=513;

Chiama SP(A, B);

…

Sottoprogramma SP (X, Y);

… X= Y+X;

…

… quando durante l’esecuzione di SP (X, Y) si ha X = Y + X = 540 Registri parametri effettivi

A B

Registri parametri formali X Y 27

513

540 513 I valori dei parametri effettivi restano immutati

Sottoprogrammi

Principali meccanismi di scambio dei parametri:

per RIFERIMENTO:

è detto anche per indirizzo:

all’atto della chiamata l’indirizzo di memoria di ciascun parametro effettivo viene ricopiato in quello del corrispondente parametro formale.

Durante l’esecuzione del sottoprogramma, qualsiasi variazione del valore del parametro formale si riflette sul corrispondente parametro effettivo.

E’ utilizzata la stessa locazione di memoria per ciascun parametro effettivo ed il corrispondente formale

(11)

Parametro effettivo A = 35

Parametro formale

indirizzo registro = 246000 X 35

A

A = 35 X

indirizzo registro = 246000

35 A

all’attivazione Programma PG;

…

A = 35;

Chiama SP(A);

…

Sottoprogramma SP (X);

… X= 731;

…

all’attivazione

X = 35

… quando durante l’esecuzione di SP (X) si ha X = 731

indirizzo registro = 246000

731 X X = 731

A = 731 A

Valore del parametro effettivo uguale a quello del parametro formale

Sottoprogrammi Ricapitolando:

Scambio per valore: il valore dei parametri effettivi viene copiato nei corrispondenti parametri formali. Eventuali modifiche dei valori dei parametri formali nel

sottoprogramma non hanno alcun effetto sui valori dei parametri effettivi che restano immutati.

Scambio per riferimento: ai parametric formali viene

passato l’indirizzo di memoria dei corrispondenti parametric

effettivi. Eventuali modifiche dei valori dei parametri formali

nel sottoprogramma hanno effetto sui valori dei parametri

effettivi che avranno lo stesso valore di quelli formali

(12)

Sottoprogrammi

In una lista di parametri è possibile avere parametri scambiati sia per valore che per riferimento

Il tipo di scambio è indicato nella lista dei parametri formali, cioè nell’intestazione del sottoprogramma.

Ciascun linguaggio di programmazione ha proprie regole per indicare la modalità di scambio per valore o per riferimento

Sottoprogrammi

In un Sottoprogramma, i parametri formali possono essere:

• solo di ingresso,

ovvero il valore dei parametri effettivi non deve essere modificato

==> Scambio per VALORE

• solo di uscita,

ovvero il parametro rappresenta uno dei risultati che il

sottoprogramma calcola ed il valore calcolato deve essere noto al programma chiamante

==> Scambio per RIFERIMENTO

• di ingresso e di uscita,

ovvero il valore di ingresso del parametro effettivo modificato dal sottoprogramma deve essere noto al programma chiamante

==> Scambio per RIFERIMENTO

(13)

Indicazione del meccanismo di scambio parametri in LDP:

Sottoprogramma <nome> ( [in <lista parametri solo di ingresso>];

[out <lista parametri solo di uscita>];

[inout <lista par. ingresso/uscita>]);

per VALORE per RIFERIMENTO

per RIFERIMENTO

N.B. Per ogni parametro nella lista deve essere indicato il tipo Sottoprogramma <nome> (in float A,B; out float C, char S);

per VALORE

Program PG;

………..;

C = 7;

SP(A,B,C);

write(“C= “, “%d” C);

………..;

SP(M,24,C);

write(“C= “, “%d” C);

………..;

end.

Sottoprogramma SP (in int X,Y, Somma);

………..;

Somma=X+Y+Somma;

Write(“Somma = “, “%d” Somma);

………..;

end;

In PG sarà sempre stampato C = 7 perché C è scambiato per VALORE In SP: Prima Attivazione: A X, B Y, C = 7 Somma

se A=5, B= 8, C=7 => Somma = 20 In PG ,dopo l’esecuzione di SP, è stampato C = 7

In SP: Seconda Attivazione: M X, 24 Y, C = 7 Somma se M=10, => Somma = 41

In PG dopo l’esecuzione di SP è stampato C=7

Sottoprogrammi: effetto dei diversi tipi di scambio

tutti per VALORE

(14)

Sottoprogrammi: effetto dei diversi tipi di scambio

Program PG;

………..;

C = 7;

SP(A,B,C);

write(“C= “, “%d” C);

………..;

SP(M,24,C);

Write(“C= “, “%d” C);

………..;

end.

Sottoprogramma SP(in int X,Y; inout int Somma);

………..;

Somma= Somma + X+Y;

Write(“Somma = “, “%d” Somma);

………..;

end;

Prima Attivazione di SP: A X, B Y, C = 7 Somma se A=5, B= 8 => Somma = 7+5+8= 20

In PG, dopo la prima esecuzione di SP, è stampato C=20

Seconda Attivazione: M X, 24 Y, C = 20 Somma

(ora è C = 20 essendoci stato lo scambio per riferimento tra C e Somma) se M=10 => Somma = 20+10+24= 54

In PG, dopo la nuova esecuzione di SP, PG è stampato C =54

per VALORE per RIFERIMENTO

Sottoprogrammi

Tipi di sottoprogrammi:

PROCEDURE:

simile ad un programma;

è definito il nome della procedure ed indicati i nomi dei parametri formali ed il modo con cui questi sono scambiati con il chiamante L’attivazione è fatta riportando nel chiamante un’istruzione contenente unicamente il <nome> della procedure con la lista dei relativi

parametri effettivi

Struttura di una procedure in LDP:

procedure <nome> (<lista parametri formali>);

begin

end;

(15)

Programma chiamante PG Program PG;

………..;

Proc(<lista1_par_effettivi>);

………..;

Proc(<lista2_par_effettivi>);

………..;

end.

Procedure Proc (<lista_par_formali>);

begin;

………..;

end;

Procedura Proc Esempio di chiamata a procedure

Istruzioni di chiamata a Procedura

Sottoprogrammi

Program PG;

………..;

read (“%d” A, “%d” B, “%d” C);

Max(A, B, C, Max);

Min(A, B, C, Min);

write(“Massimo = “, “%d” Max);

write(“Minimo = “, “%d” Min);

………..;

end.

procedure Max (in int X,Y,W; out int Massimo);

// trova il Massimo fra tre numeri begin

Massimo=X;

if (Y > Massimo) then Massimo = Y; endif;

if (W > Massimo) then Massimo = W; endif;

end;

Esempio di chiamata a procedure:

procedure Min(in int X,Y,W; out int Minimo);

// trova il Minimo fra tre numeri begin

Minimo=X;

if (Y < Minimo) then Minimo = Y; endif;

if (W < Minimo) then Minimo = W; endif;

end;

(16)

Max e Min producono:

Massimo = Y= 80 Minimo = W=12

Alla attivazione di Max e Min : Max(A, B, C, Max);

Min(A, B, C, Min);

Se: A=15, B= 80, C=12

A X = 15 B Y = 80 C W = 12

… per valore

Max  Massimo = ?

… per riferimento

Massimo = 80 Max = 80 Minimo = 12 Min 12

… per riferimento In PG sarà visualizzato: Massimo = 80

Minimo = 12 Program PG;

………..;

read (“%d” A, “%d” B, “%d” C);

Max(A, B, C, Max);

Min(A, B, C, Min);

write(“Massimo = “, “%d” Max);

write(“Minimo = “, “%d” Min);

………..;

end.

procedure Max (in int X,Y,W; out int Massimo);

// trova il Massimo fra tre numeri begin

Massimo=X;

if (Y > Massimo) then Massimo = Y; endif;

if (W > Massimo) then Massimo = W; endif;

end;

Min  Minimo = ?

… per riferimento

Sottoprogrammi Tipi di sottoprogrammi:

FUNZIONE:

– ha un tipo

– è identificata da un nome ed assume un valore, associato al nome della Funzione (quindi è come un’informazione);

– è indicato il nome dei parametri formali ed il modo con cui questi sono scambiati con il chiamante

L’attivazione è fatta indicando il nome della Funzione in una

espressione o in una condizione (in cui sarà usato il valore scaturente dall’esecuzione della Funzione ) e la lista dei relativi parametri effettivi

.... il nome della Funzione è usato come se fosse quello di una variabile

(17)

<tipo> function <nome> (<lista parametri formali>);

begin

<parte dichiarativa>

<corpo della function>

return <valore_calcolato>;

end;

Struttura di una Funzione in LDP:

... al programma chiamante è ‘ritornato’ <valore_calcolato>, che è associato al <nome> della funzione; <valore_calcolato> in genere è rappresentato da una variabile o più in generale da un’espressione...

... l’esecuzione di una function termina quando si incontra return ...

Sottoprogrammi

Programma chiamante PG Program PG;

………..;

A= B + C + Funz(<lista_par_effettivi>);

………..;

………..….;

………..;

end.

INT function Funz (<lista_par_formali>);

………..;

Z = ……..;

return Z;

end;

Funzione Funz

Esempio di chiamata a Funzione:

… nell’esecuzione di PG, nelle espressioni dove c’è la chiamata alla funzione Funz, sarà usato il valore calcolato per Z eseguendo Funz

Es. Se B = 7, C = 9 e Funz ‘ritorna’ Z = 4 sarà: A = 7 + 9 + 4 = 20

(18)

Sottoprogrammi

Programma chiamante PG

Program PG;

………..;

B=10; C=5; D=7; X=350;

A= B + C * Funz(D, 4);

if (Funz(A, C) > X ) then write (“Vero”) else write(“Falso”);

endif end.

INT function Funz (in int W, Y);

………..;

INT Z;

Z = 2*W – Y;

…..;

return Z;

end;

Funzione F

… nella prima invocazione di Funz è D W = 7

4 Y = 4

e quindi: Z = 2 * 7 - 4 = 10

… per cui sarà A = 10 + 5*10 = 60

… nella seconda invocazione di Funz è

A W = 60 C Y = 5

Quindi : Z = 2 * 60 - 5 = 115

… per cui la condizione :

(F(A, C) > X ) => 115 >350 ? è falsa

Ed è perciò stampato:

Falso

Sottoprogrammi

Programma chiamante PG

Program PG;

………..;

read(“%f” base, “%f” altezza);

if ((base >0) and (altezza > 0)) then

write (‘AreaTriangolo = ‘, “%f” Area(base, altezza) ) else write (‘base e/o altezza minori di zero’);

endif;

end.

FLOAT function Area (in int W,Y);

………..;

FLOAT Area_triangolo;

Area_triangolo = (W*Y)/2;

return Area_triangolo;

end;

Funzione Area

se:

base = 20 W =20 altezza = 15 Y = 15

=>

Area (base, altezza) = 150 Sarà visualizzato:

Area triangolo = 150 se:

base = - 10 altezza = 5

=>

Sarà visualizzato:

“base e/o altezza minori di zero”

Ovviamente, la function Area non è eseguita