unità didattica 6 Le procedure e le funzioni create dall utente

Transcript

1 unità didattica 6 Le procedure e le funzioni create dall utente 1. Introduzione Si è più volte sottolineato quanto sia importante, nel realizzare i programmi di elaborazione dati, la semplicità strutturale dell algoritmo risolutivo che ispira il codice presente nel programma. seguimi Se un programma ha una struttura semplice è facile da leggere e agevole da comprendere. Si tratta di una caratteristica che rende molto produttiva l attività di aggiornamento del programma nel corso del tempo. Viceversa, programmi realizzati mediante algoritmi complicati, lunghi e poco chiari non consentono facilmente nei tempi futuri il cambiamento immediato delle funzioni svolte. Come abbiamo già avuto modo di sottolineare in precedenza, a queste esigenze di semplicità, leggibilità e chiarezza risponde efficacemente la metodologia di programmazione Top-Down (dall alto verso il basso), consistente nella scomposizione di un problema in sottoproblemi, i cd. moduli o fasi, più semplici da analizzare e da risolvere. Ad esempio, nel caso in cui si voglia calcolare la media aritmetica di ciascuna riga e colonna di una matrice da memorizzare in memoria centrale, con il risultato finale di visualizzare la matrice di partenza e le medie individuate, si potrebbe pensare di scomporre (o raffinare) il problema nel suo insieme in tre fasi: caricamento iniziale della matrice in memoria centrale; calcolo delle medie; visualizzazione dei risultati. La fig. 1 mostra la rappresentazione grafica del procedimento seguito. Nella figura distinguiamo una logica di controllo generale in base alla quale, dopo l inizio dell esecuzione del programma (programma principale) viene dapprima «passato» il controllo al modulo CARICA, che eseguirà le funzioni tipiche della memorizzazione di un array bidimensionale. UD6 Le procedure e le funzioni create dall utente 33

2 INIZIO CARICA MEDIE VISUALIZZA FINE Fig. 1 Programma principale di elaborazione di una matrice Alla fine del suo compito il modulo (o sottoprogramma) CARICA ritornerà il controllo al programma principale che a sua volta ripasserà il controllo al sottoprogramma MEDIE che ancora a sua volta alla fine ritornerà il controllo al programma principale e così via. La figura presente nel flow-chart: SOTTOPROGRAMMA A indica il comando dell esecuzione, da parte di un modulo (detto modulo chiamante), di un modulo gerarchicamente inferiore (sottoprogramma) il cui nome è presente all interno della figura stessa. È chiaro che l algoritmo delineato in fig. 1 non è completo; mancano, infatti, le operazioni di dettaglio di ciascun sottoprogramma (CARICA, MEDIE e VISUALIZZA). Separatamente, poi (se non esistono già), occorrerà realizzare i sottoprogrammi. In fig. 2 sono disegnati i flow-chart relativi al programma di cui all esempio. INIZIO CARICA LEGGI N, M I = 1, N J = 1, M INIZIO MEDIE SOM = 0 I = 1, N J = 1, M INIZIO VISUALIZZA VISUALIZZA V(J) J = 1, N LEGGI MAT (I, J) SOM = SOM + MAT (I, J) FINE VISUALIZZA V(I) = SOM/M FINE CARICA FINE MEDIE Fig. 2 Sottoprogrammi relativi alla fig Modulo on line Uno strumento per programmare: cenni al linguaggio Pascal

3 Il procedimento appena descritto si itera se un sottoprogramma si riferisce ad un problema che merita di essere ulteriormente scomposto. In questo caso il sottoprogramma sarà diviso in diversi sottoprogrammi, gerarchicamente subordinati, che saranno dettagliati in un momento successivo. Si forma la struttura ad albero che spiega anche il nome, Top-Down, della metodologia adottata. Nella fig. 2 è mostrato chiaramente come la struttura del programma, nel suo insieme, si scompone in tre livelli, ottenuti focalizzando la propria analisi progettuale «dall alto verso il basso». Prima si scompone il problema principale in tre moduli e poi, allorché nell analisi del secondo modulo si rileva una certa complessità, si «scende più in basso» a dettagliare un ulteriore sottoproblema. La figura ottenuta viene anche detta skeleton del programma. seguimi Il risultato raggiunto offre, tra gli altri, il vantaggio di dividere il lavoro di programmazione tra diverse risorse umane: un programmatore potrebbe realizzare il primo sottoprogramma, un altro programmatore realizzare il secondo sottoprogramma ecc. Il Pascal consente di realizzare un progetto di programmazione ottenuto secondo la metodologia Top- Down. Ogni volta che si incontra nell algoritmo un passaggio di controllo ad un sottoprogramma, si può far uso di una funzione o di una procedura, definita dall utente. Abbiamo visto in precedenza che la differenza tra una funzione ed una procedura in Pascal consiste nel fatto che la prima restituisce alla fine un valore in base ad elaborazioni matematiche o su stringhe, mentre la procedura dà semplicemente luogo ad operazioni ed elaborazioni, senza necessariamente restituire in output un valore. In base al sottoprogramma progettato, pertanto, se si vuole codificare in Pascal l algoritmo ideato, si utilizzeranno procedure o funzioni definite dall utente. 2. Le procedure definite dall utente Per utilizzare una procedura definita dall utente occorre prevedere due azioni: definizione della procedura; richiamo dell esecuzione della procedura. Per definire una procedura, occorre usare la parola chiave PROCEDURE, seguita dal nome attribuito alla procedura e dal segno di punto e virgola (;). Ad esempio, se vogliamo definire una procedura che calcola la media, potremmo scrivere la linea: PROCEDURE media ; Talvolta occorre passare dei parametri ad una procedura, ciò capita quando la procedura esegue dei calcoli su grandezze che, di volta in volta, possono cambiare il loro contenuto e non su variabili fisse. In questi casi si parla di parametri di ingresso. In altri casi, oltre ai parametri di ingresso, possono essere presenti parametri in uscita, ovvero risultati ottenuti dall esecuzione della procedura che non sono memorizzati in variabili fissate, ma in variabili che, di volta in volta, sono indicate dall istruzione che richiama la procedura. Quando una procedura contiene dei parametri di ingresso e/o di uscita, tali parametri sono racchiusi tra le parentesi che seguono il nome della procedura. Inoltre, ciascun parametro deve essere anche seguito dai due punti e dal suo tipo. Ad esempio, se la procedura media prevede la presenza dei parametri mat, n e m (ad esempio individuanti una certa matrice mat composta di n righe e di m colonne), sui quali evidentemente saranno compiute delle elaborazioni, si dovrà scrivere: PROCEDURE media (mat: matrice; n,m : INTEGER); dove matrice è il tipo (definito nel modulo chiamante) relativo ad una matrice bidimensionale, come ad esempio: TYPE MATRICE = array[1..10, 1..10] ; UD6 Le procedure e le funzioni create dall utente 35

4 A prescindere dall esistenza o meno dei parametri di ingresso-uscita, successivamente alla linea di nome della procedura, occorre dettagliare le azioni effettuate dalla procedura, seguendo le stesse regole che valgono per un programma Pascal: si può far uso della sezione di dichiarazione dei tipi (TYPE) e delle variabili (), si scriveranno delle linee ed END laddove necessario e così via. Una procedura, però, a differenza del programma principale, deve terminare con una linea END senza porre il punto alla fine, ma solo il carattere «;». Quando all interno del programma principale si vuole fare eseguire una determinata procedura, è sufficiente scrivere una linea costituita soltanto dal nome della procedura desiderata. Ad esempio, dopo aver definito la procedura calcola, se la si vuole eseguire nel programma principale, basta semplicemente scrivere: calcola ; Si tenga presente che il richiamo (call) di una procedura che prevede il passaggio di parametri deve però essere effettuata passando i parametri: ciò avviene ponendo le variabili che prenderanno il posto dei parametri tra parentesi. Ad esempio, dopo aver definito la procedura media definita con i parametri mat, n e m, si scriverà: media (a, 10, 5); per comandare la materiale esecuzione della procedura media sulla matrice di nome a che ha 10 righe e 5 colonne. Nella fig. 3 riportiamo la codifica di un programma che, dopo aver provveduto alla memorizzazione in memoria centrale (attraverso la tastiera) di due matrici bidimensionali rispettivamente di dimensioni (5 x 10) e (3 x 7), ne determina per ciascuna la media aritmetica per riga, eventualmente visualizzando le medie. Risulta a questo punto necessario avanzare alcune osservazioni riguardo l uso di procedure create dall utente, prendendo spunto dall esempio contenuto in fig. 3. PROGRAM elab_mat; USES WINCRT; TYPE matrice=array[1..50,1..50] OF INTEGER; a: matrice; b: matrice; PROCEDURE media(n,m: INTEGER; mat:matrice; r:char); {PROCEDURA DI CALCOLO DELLE MEDIE PER RIGHE DI UNA MATRICE BIDIMENSIONALE n: RIGHE DELLA MATRICE m: COLONNE DELLA MATRICE mat: MATRICE r: SE = S ALLORA LE MEDIE SONO ANCHE VISUALIZZATE } som,i,j: INTEGER; med: REAL; som:=0; FOR j:=1 TO m DO som:=som+mat[i,j]; med:=som/m; WRITELN( LA MEDIA DELLA RIGA,i, E,med); IF r= S THEN 36 Modulo on line Uno strumento per programmare: cenni al linguaggio Pascal

5 WRITELN( ); WRITELN( DIGITA UN TASTO PER CONTINUARE ); REPEAT UNTIL KEYPRESSED; PROCEDURE carica_media(n,m: INTEGER; mat:matrice; s:char); {PROCEDURA DI CARICAMENTO DI UNA MATRICE BIDIMENSIONALE CON CALCOLO DELLA MEDIA n: RIGHE DELLA MATRICE m: COLONNE DELLA MATRICE mat: MATRICE s: SE = S ALLORA LE MEDIE SONO ANCHE VISUALIZZATE } i,j: INTEGER; med: REAL; WRITELN( CARICAMENTO DELLA RIGA,i); WRITELN( ); FOR j:=1 TO m DO WRITE( DIGITA L ELEMENTO DI COLONNA,J); READLN(mat[i,j]); media(n,m,mat,s); {PROGRAMMA PRINCIPALE} { } carica_media(5,10,a, S ); carica_media(3,7,b, N ); { } END. Fig. 3 Uso di procedure con passaggio di parametri Innanzitutto, è importante che la dichiarazione della procedura preceda il segmento di programma che ne richiede l esecuzione. Ciò significa che in presenza di una struttura di programma del tipo (v. pagina seguente) UD6 Le procedure e le funzioni create dall utente 37

6 Istruzione 1 Istruzione 2 ** PROCEDURA cento ** Istruzione 110 Istruzione 120 ** PROCEDURA mille ** Istruzione 1001 Istruzione 1002 Istruzione 130 ** PROCEDURA duemila ** Istruzione 2001 Istruzione 2002 Istruzione 2003 Istruzione 140 Istruzione 3 Istruzione 4 **PROCEDURA duecento ** Istruzione 210 Istruzione 220 Istruzione 230 Istruzione 5 bisogna fare attenzione all ordine secondo il quale si descrivono, e si dichiarano, le diverse procedure cento, duecento, mille e duemila. La regola generale che bisogna seguire è che la procedura chiamata sia definita precedentemente rispetto alla procedura chiamante. Pertanto, nel nostro esempio, occorre fare così: PROCEDURE mille ( ) PROCEDURE duemila ( ) PROCEDURE duecento ( ) PROCEDURE cento ( ) PROGRAMMA PRINCIPALE fai attenzione È irrilevante scrivere prima mille o duemila, così come non è essenziale far precedere duecento a cento. Quel che è importante, invece è che mille e duemila precedano cento. 38 Modulo on line Uno strumento per programmare: cenni al linguaggio Pascal

7 3. Il passaggio di parametri per valore Nell esempio di cui alla fig. 3, si è fatto uso di due procedure con passaggio di parametri, di nomi carica_media e media. La prima procedura, di nome carica_media, si prefigge l obiettivo di memorizzare un insieme di valori numerici interi in una matrice bidimensionale, nonché di richiamare un ulteriore procedura annidata per calcolare la media (procedura media). Questa procedura è generalizzata, nel senso che riesce a memorizzare qualsiasi matrice bidimensionale, purché inferiore a 51 righe e 51 colonne. Questo è molto importante perché qualsiasi sia la matrice bidimensionale da caricare, si può sfruttare l esistenza della procedura carica_media, semplicemente richiamandola. Chiaramente, per il caso specifico richiesto, cioè a seconda del numero di righe e di colonne desiderate, bisogna passare al sottoprogramma i parametri richiesti, ovvero nel nostro esempio, rispettivamente il numero di righe, il numero di colonne ed il nome della matrice da caricare. Perciò, con l istruzione presente nel programma principale: carica_media (5, 10, a, s ) si intende caricare la matrice a costituita da 5 righe e da 10 colonne. Una particolarità dell esempio di codifica in esame riguarda il fatto che, dato che tra i parametri passati c è una variabile di tipo strutturato (ovvero la matrice), non è possibile dichiarare il suo tipo come ARRAY, ma è necessario definire un nuovo tipo introdotto dal programmatore (nella terza e nella quarta linea del codice): TYPE Matrice : ARRAY [1.. 50, 1 50]; Questa istruzione è poi sfruttata sia nel programma principale che nel sottoprogramma. fai attenzione La matrice è stata dichiarata intenzionalmente grande (50 righe x 50 colonne), in quanto così facendo si allargano i limiti di applicazione del programma anche ai casi di dati notevolmente numerosi. In verità, nel programma principale le effettive dimensioni delle due matrici da elaborare sono come abbiamo già sottolineato (5 x 10) per la prima matrice e (3 x 7) per la seconda matrice. Perciò, sfruttando la stessa istruzione di call: carica_media (.) si possono caricare ambedue le matrici. È chiaro che n e m sono parametri di ingresso alla procedura carica_media, mentre mat è un parametro di elaborazione interno alla procedura. Analogamente, la procedura media, che determina le medie per righe di una certa matrice, possiede parametri di ingresso n, m e mat che rappresentano rispettivamente le righe, le colonne e la matrice da elaborare. In più, esiste il parametro di ingresso r che orienta la procedura media a visualizzare o meno ciascuna media calcolata: se r contiene il carattere S, allora il sottoprogramma media, oltre a determinare le varie medie, le visualizzerà anche. Le procedure che prevedono i parametri di ingresso-uscita viste sin qui sfruttano il cosiddetto passaggio parametri per valore. Infatti, le variabili definite all interno della procedura che costituiscono i parametri hanno una validità solo locale. In altre parole, sono create dinamicamente: quando viene eseguita la procedura, le variabili locali (n, m e mat nel nostro esempio) assumono il valore che viene passato nel richiamo procedurale. Quando la procedura termina le variabili locali (e quindi anche quelle che fungevano da parametri) non hanno più consistenza. Riferendoci al programma scelto come esempio, se si comandasse all interno del programma principale, mediante un istruzione di scrittura (come la WRITE) di emettere il contenuto della matrice a, non si otterrebbero i dati costituenti la matrice immessa tramite la procedura carica_media. Il che significa che, attraverso questo passaggio di parametri, alla fine dell esecuzione della procedura i parametri non ritornano con i risultati calcolati nella procedura. Ciò implica che i nomi delle variabili non hanno alcuna importanza all infuori della procedura. UD6 Le procedure e le funzioni create dall utente 39

8 seguimi Se si usasse una variabile all interno del programma principale (variabile globale) con lo stesso nome di una variabile locale, si tratterebbe di due cose distinte: al di fuori della procedura, la variabile locale non influenzerebbe in alcun modo il contenuto della variabile globale. Comunque è sempre sconsigliato utilizzare una variabile globale con lo stesso nome di una variabile locale. Perciò, i parametri possono essere classificati in parametri formali e parametri effettivi: i primi sono i parametri citati nella dichiarazione di una procedura. Come abbiamo visto, si tratta di variabili dinamiche in quanto a contenuto. I parametri effettivi sono, invece, quelle variabili che all interno del programma principale hanno una loro validità ed i cui valori sono trasferiti nei parametri formali di una procedura. Nell esempio del programma di cui alla fig. 3 i parametri effettivi della procedura carica_media sono; 5, 10, a e s mentre n, m mat e v sono i parametri formali. Ricordiamo in ultima analisi che le variabili appartenenti al blocco chiamante, cioè i parametri effettivi, non sono modificate. 4. Il passaggio di parametri per variabile Esiste anche un altro modo di trasmettere dei parametri ad una procedura: si tratta del passaggio per variabile (o per indirizzo) in base al quale anche i parametri effettivi subiscono eventuali modifiche ad opera dell esecuzione di una procedura. Se si utilizza il passaggio per variabile, la procedura può condizionare variabili esterne o trasmesse ad essa. Nel Pascal, il passaggio dei parametri per variabile viene esplicitato anteponendo la parola al parametro nella dichiarazione della procedura, come ad esempio nel seguente statement: PROCEDURE somma(n: INTEGER; i: INTEGER); In questo caso nella procedura somma esistono due parametri: il primo si chiama n ed è un parametro passato per valore, mentre il secondo si chiama i e costituisce un parametro passato per variabile in quanto è preceduto dalla parola. Come esempio di passaggio di parametri per variabile, presentiamo il seguente programma che si pone l obiettivo di raddoppiare un valore inserito tramite tastiera un certo numero di volte, visualizzando alla fine il risultato. PROGRAM raddoppio; USES WINCRT; num,i,valore: INTEGER; PROCEDURE somma(n:integer ; i: INTEGER); {PROCEDURA DI RADDOPPIO DI UN CERTO NUMERO PER N VOLTE n: NUMERO DI RADDOPPI DA EFFETTUARE i: RISULTATO DINAMICO DEL RADDOPPIO} j:integer; FOR j:=1 TO n DO i:=i*2; {PROGRAMMA PRINCIPALE} { } 40 Modulo on line Uno strumento per programmare: cenni al linguaggio Pascal

9 WRITELN( DIGITA UN VALORE DA RADDOPPIARE DI VOLTA IN VOLTA ); READLN(valore); WRITELN( DIGITA IL NUMERO DI VOLTE CHE VUOI RADDOPPIARE ); READLN(num); i:=valore; somma(num,i); WRITELN( IL RADDOPPIO DI,valore, PER,num, VOLTE FA:,i); REPEAT UNTIL KEYPRESSED; { } END. 5. Le funzioni create dall utente Ad ogni funzione è assegnato un tipo ben preciso come il tipo intero, reale, booleano ecc. Come avviene anche per le procedure, per utilizzare una funzione definita dall utente, occorre procedere a due azioni distinte: definizione della funzione; richiamo della funzione. Per definire una funzione occorre usare la parola FUNCTION seguita dal nome assegnato alla funzione e dai parametri che vanno indicati, così come per le procedure, tra le parentesi tonde. Il tipo posseduto dalla funzione deve infine terminare la definizione. Ad esempio, la funzione relativa al calcolo dell area di un rettangolo sarà definita così: FUNCTION area(base, altezza: REAL): REAL; Un altro esempio potrebbe riguardare una funzione che deve verificare se tre numeri possano corrispondere alle misure dei tre lati di un triangolo, così dichiarabile: FUNCTION triangolo(l1, l2, l3: REAL): BOOLEAN; Il passaggio dei parametri alla funzione può avvenire anche in questo caso per valore o per variabile. È ovvio che prima della fine del blocco eseguibile della funzione, il nome usato per la funzione deve ricevere un valore compatibile con il tipo in precedenza indicato. Per richiamare una funzione si dovrà semplicemente citarne il nome e dichiararne i parametri. Ad esempio, l istruzione presente nel corpo del programma principale: IF area(b,h) > 100 THEN WRITE( AREA > 100 ) ELSE WRITE( AREA <= 100 ); contiene una chiamata di funzione che è: area(b,h). In questo caso precedentemente a tale istruzione deve essere stata dichiarata la funzione, così come segue: FUNCTION area(base, altezza: REAL): REAL); area := base * altezza ; Viceversa, la funzione triangolo precedentemente descritta va completata in questo modo: FUNCTION triangolo(l1, l2, l3 : REAL): BOOLEAN); IF (l1<(l2+l3)) AND (l2<(l1+l3)) AND (l3<(l1+l2)) THEN triangolo:=true ELSE triangolo:= FALSE ; Allora, nel corpo del programma chiamante, per sapere se tre valori memorizzati in v1, v2 e v3 possano costituire i lati di un triangolo, basta interrogare la funzione triangolo, come ad esempio: WRITELN( Digita tre valori ); READLN (v1, v2, v3); IF triangolo(v1, v2, v3) THEN WRITELN( Sono lati di un triangolo ) ELSE WRITELN( non sono lati di un triangolo ); UD6 Le procedure e le funzioni create dall utente 41

10 6. Esempi Come applicazione dei concetti sin qui esposti, seguono cinque esempi di codifiche in Pascal. Esempio 1 Il programma che segue ha lo scopo di permettere all utente di inserire tre numeri reali e di verificare se essi corrispondano o meno ai lati di un triangolo. Ricordiamo che in un triangolo occorre che qualsiasi lato sia minore della somma degli altri lati. PROGRAM triangoli; USES WINCRT; a,b,c: REAL; {PROGRAMMA PRINCIPALE} WRITELN( ************************************************************* ); WRITELN( * TRE VALORI RAPPRESENTANO TRE LATI DI UN TRIANGOLO?* ); WRITELN( ************************************************************* ); WRITE( Digita i tre valori da verificare: ); READLN(a,b,c); IF (a < (b + c)) AND (b < (a + c)) AND (c < (a + b)) THEN WRITELN( I valori,a:3:1,,b:3:1, e,c:3:1, sono lati di un triangolo ) ELSE WRITELN( I valori,a:3:1,,b:3:1, e,c:3:1, non sono lati di un triangolo ) END. Esempio 2 Il programma che segue ha lo scopo di permettere all utente di inserire N numeri reali allo scopo di visualizzare per ciascuno di essi, a fianco, il quadrato e la radice quadrata. La cardinalità dei valori da inserire (N) è indicata dallo stesso utente. PROGRAM qua_rad; USES WINCRT; n,i: INTEGER; num: REAL; {PROGRAMMA PRINCIPALE} WRITELN( ********************************** ); WRITELN( * QUADRATI E RADICI QUADRATE * ); WRITELN( ********************************** ); WRITE( Quanti valori vuoi elaborare? ); READLN(n); WRITE( Inizia l elaborazione. ); WRITE( Digita un valore ); READLN(num); WRITELN( Quadrato:,SQR(num):6:0, Radice:,SQRT(num):6:2); END. 42 Modulo on line Uno strumento per programmare: cenni al linguaggio Pascal

11 Esempio 3 Il programma che segue permette all utente di digitare N numeri reali da memorizzare in un vettore in memoria centrale per il quale si desidera poi calcolare la media aritmetica, il massimo ed il minimo e visualizzare i risultati. Il programma che segue sfrutta l esecuzione di procedure tramite passaggio di parametri per valore. PROGRAM ela_vet; USES WINCRT; TYPE vettore=array[1..50] OF INTEGER; v: vettore; n: INTEGER; PROCEDURE min_max(n: INTEGER; vet:vettore); {PROCEDURA DI CALCOLO DEL MINIMO E MASSIMO DI UN VETTORE n: ELEMENTI DEL VETTORE vet: VETTORE } i: INTEGER; min,max: REAL; min:=vet[1]; max:=vet[1]; FOR i:=2 TO n DO IF vet[i] > max THEN max:=vet[i]; IF vet[i] < min THEN min:=vet[i]; WRITELN( Il minimo è,min); WRITELN( Il massimo è,max); PROCEDURE media(n: INTEGER; vet:vettore); {PROCEDURA DI CALCOLO DELLA MEDIA DI UN VETTORE n: ELEMENTI DEL VETTORE vet: VETTORE } som,i: INTEGER; med: REAL; som:=0; som:=som + vet[i]; med:=som/n; WRITELN( LA MEDIA DEGLI ELEMENTI E,med); UD6 Le procedure e le funzioni create dall utente 43

12 PROCEDURE carica(n: INTEGER; vet:vettore); {PROCEDURA DI CARICAMENTO DI UN VETTORE n: ELEMENTI VETTORE vet: vettore } i: INTEGER; WRITELN( Digita l elemento,i); READLN(vet[i]); media(n,vet); min_max(n,vet); {PROGRAMMA PRINCIPALE} WRITELN( Digita il numero di elementi del vettore ); READLN(n); CARICA(n,v); END. Esempio 4 Con il programma di seguito mostrato si vuole consentire all utente di inserire trenta nomi propri di persona da memorizzare in un vettore in memoria centrale e di determinare la presenza fra essi di un certo nome scelto ed indicato dall utente. Viene infine visualizzato se e quante volte il nome indicato è presente. Il programma fa uso di varie istruzioni di richiamo (call) dell esecuzione di procedure attraverso passaggio di parametri per variabile. PROGRAM ela_nom; { QUESTO PROGRAMMA SFRUTTA LE CHIAMATE DI PROCEDURA TRAMITE PARAMETRI PER IABILI } USES WINCRT; TYPE vettore=array[1..50] OF STRING[15]; stringa=string[15]; v: vettore; n,volte: INTEGER; vnom:stringa; PROCEDURE ricerca( n: INTEGER; vet:vettore; vnom:stringa; num: INTEGER); {PROCEDURA DI RICERCA DI UN NOME NEL VETTORE n: ELEMENTI DEL VETTORE 44 Modulo on line Uno strumento per programmare: cenni al linguaggio Pascal

13 i: INTEGER; vet: VETTORE vnom: NOME DA RICERCARE } num:=0; IF vet[i]=vnom THEN num:=num+1; PROCEDURE CARICA( N: INTEGER; VET:VETTORE); {PROCEDURA DI CARICAMENTO DI UN VETTORE n: ELEMENTI VETTORE vet: VETTORE } i: INTEGER; WRITELN( Digita l elemento,i); READLN(vet[i]); {PROGRAMMA PRINCIPALE} volte:=0; WRITELN( Digita il nome da cercare nel vettore ); READLN(vnom); WRITELN( Digita il numero di elementi del vettore ); READLN(n); carica(n,v); ricerca(n,v,vnom,volte); IF volte>0 THEN WRITELN( Il nome è presente,volte, volte ) ELSE WRITELN( Il nome non è presente ); END. Esempio 5 Il programma che segue intende permettere la digitazione da parte dell utente di N numeri naturali da memorizzare in un vettore in memoria centrale. Successivamente il programma calcola il fattoriale di ogni componente del vettore e visualizza i risultati. Le chiamate procedurali del programma utilizzano il criterio del passaggio parametri per variabile. UD6 Le procedure e le funzioni create dall utente 45

14 PROGRAM fattor; { QUESTO PROGRAMMA SFRUTTA LE CHIAMATE DI PROCEDURA TRAMITE PARAMETRI PER IABILI } USES WINCRT; TYPE vettore=array[1..50] OF INTEGER; v,vfatt: vettore; n,j: INTEGER; PROCEDURE cal_fatt( n: INTEGER; vet:vettore; vetfat:vettore ); {PROCEDURA DI CALCOLO FATTORIALI ELEMENTI DEL VETTORE n: ELEMENTI DEL VETTORE vet: VETTORE vetfat: VETTORE DEI FATTORIALI } i,k: INTEGER; { INIZIALIZZAZIONE VETTORE DEI FATTORIALI } vetfat[i]:=1; { CALCOLO DEL FATTORIALE } FOR k:=1 TO vet[i] DO vetfat[i]:=vetfat[i]*k; 46 Modulo on line Uno strumento per programmare: cenni al linguaggio Pascal

15 PROCEDURE CARICA( n: INTEGER; vet:vettore); {PROCEDURA DI CARICAMENTO DI UN VETTORE n: ELEMENTI VETTORE vet: VETTORE } i: INTEGER; WRITELN( Digita l elemento,i); READLN(vet[i]); {PROGRAMMA PRINCIPALE} END. WRITELN( Digita il numero di elementi del vettore ); READLN(n); carica(n,v); cal_fatt(n,v,vfatt); FOR j:=1 TO n DO WRITELN( Il fattoriale di,v[j], è,vfatt[j]); UD6 Le procedure e le funzioni create dall utente 47