ELEMENTI DI PROGRAMMAZIONE 2015/16 UNINA2 INGEGNERIA MECCANICA/AEROSPAZIALE Prof Andrea Prevete PUNTATORI, TARGET, STRUTTURE DATI DINAMICHE

Transcript

1 ELEMENTI DI PROGRAMMAZIONE 2015/16 UNINA2 INGEGNERIA MECCANICA/AEROSPAZIALE Prof Andrea Prevete PUNTATORI, TARGET, STRUTTURE DATI DINAMICHE

2 puntatori e target Le forme generali delle istruzioni per la dichiarazione di un puntatore e di un target sono le seguenti: tipo, POINTER [, attributi ] :: nome_puntatore tipo, TARGET [, attributi ] :: nome_target

3 puntatori e target Un puntatore deve avere lo stesso tipo e lo stesso rango del suo target. Nel caso di puntatori ad array l istruzione di dichiarazione deve specificare unicamente il rango ma non le estensioni. Vediamo due definizioni d esempio: INTEGER, POINTER, DIMENSION(:) :: punt1 REAL, POINTER, DIMENSION(:,:) :: punt2 Punt1 potrà puntare unicamente ad array monodimensionali di tipo intero, punt2 unicamente ad array bidimensionali di tipo reale.

4 puntatori e target Vediamo tre esempi, corretti, di definizione di variabili puntatore con il relativo target REAL, POINTER :: pt REAL, TARGET :: a=3 INTEGER, POINTER, DIMENSION(:) :: pt1, pt2 INTEGER, TARGET :: x(5), y(10), z(100) REAL, POINTER, DIMENSION(:,:,:) :: punt REAL, TARGET :: targ(:,:,:)

5 puntatori e target Un puntatore può essere associato ad un dato target a mezzo di una istruzione di assegnazione di puntatore: nome_puntatore => nome_target Quando la precedente istruzione è eseguita, l indirizzo di memoria del target viene immagazzinato nel puntatore: da questo momento, ogni riferimento al puntatore avrà lo stesso effetto di un riferimento ai dati immagazzinati nel target. Se un puntatore già associato ad un target viene usato in una nuova istruzione di assegnazione, allora l associazione con il primo target viene perduta, sostituita dalla nuova associazione. In una istruzione di assegnazione è anche possibile assegnare il valore di un puntatore ad un altro puntatore: puntatore1 => puntatore2 Come effetto di questa istruzione, entrambi i puntatori punteranno direttamente ed indipendentemente allo stesso target. Se uno dei due puntatori viene successivamente associato ad un diverso target l altro puntatore non sarà affetto da tale cambiamento. Tuttavia, se puntatore2 viene deassociato anche puntatore1 assumerà lo stesso stato.

6 puntatori e target A titolo di esempio si consideri il seguente insieme di istruzioni: REAL, TARGET :: x REAL, POINTER :: p1, p2 x = 3.14 p1 => x p2 => p1 x = 2.72 Se si esegue questo frammento di programma, sia p1 che p2 punteranno a x, per cui le istruzioni seguenti: WRITE(*,*) x WRITE(*,*) p1 WRITE(*,*) p2 forniranno tutte lo stesso risultato: 2.72.

7 puntatori e target Se ora si apporta una piccola modifica alle righe precedenti: REAL, TARGET :: x, y REAL, POINTER :: p1, p2 x = 3.14 y = 2.72 p1 => x p2 => y il nuovo valore di x e di p1 sarà 3.14 mentre il nuovo valore di y e p2 sarà Se a questo punto si esegue l istruzione di assegnazione: p2 = p1 tutte e quattro le variabili avranno valore Ciò significa che l istruzione di assegnazione di puntatori ha lo stesso effetto della assegnazione delle variabili a cui essi puntano. In altre parole si sarebbe avuto lo stesso risultato se si fosse posto: y = x

8 puntatori e target Se, invece, si fosse avuto: p2 => p1 si sarebbe fatto in modo che sia p1 che p2 puntassero alla stessa variabile x mentre alla variabile y non sarebbe stato riferito alcun puntatore, con il risultato che p1, p2 e x avrebbero avuto valore 3.14 mentre y avrebbe mantenuto il valore Questo esempio fa comprendere come ogni qualvolta un puntatore sia usato in una espressione al posto di un dato effettivo, nell espressione viene usato il valore del target a cui il puntatore è riferito. Questo processo è noto come dereferencing del puntatore: un puntatore, pertanto, è da riguardarsi semplicemente come un alias del suo target. Allo stesso modo, tutte le volte che un puntatore appare come un alias di un altra variabile, esso subisce automaticamente il dereferencing ossia è il valore del suo target che viene usato al posto del puntatore stesso. Ovviamente, affinché ciò possa avvenire è necessario che il puntatore sia associato ad un target. I puntatori sono automaticamente dereferenziati quando compaiono all interno di una espressione o nelle istruzioni di I/O.

9 puntatori e target Quindi i puntatori prevedono due differenti forme di assegnazione che, avendo due significati completamente diversi, non devono assolutamente essere confusi: assegnazione di puntatore (=>): è una forma di aliasing (ossia un modo di riferirsi ad uno stesso oggetto con nomi differenti), a mezzo della quale il puntatore ed il suo target sono riferiti ad una stessa locazione di memoria. Questo tipo di assegnazione può aver luogo tra una variabile puntatore ed una variabile target, oppure tra due variabili puntatore. assegnazione standard (=): quando a sinistra dell assegnazione c è l alias di un dato oggetto, l operazione di assegnazione deve essere pensata applicata proprio all oggetto puntato (ossia il valore specificato viene assegnato allo spazio puntato). Questo tipo di assegnazione può aver luogo tra una variabile puntatore ed un oggetto avente un appropriato tipo e rango; contrariamente a quanto avviene con l assegnazione di puntatore, l oggetto il cui nome è sul lato destro dell assegnazione non deve necessariamente avere l attributo TARGET. Se una particolare locazione di memoria ospita una variabile che sia puntata da un certo numero di puntatori, allora il cambiamento del valore immagazzinato in questa locazione chiaramente andrà a modificare i valori dereferenziati di tutti i puntatori associati a quella variabile.

10 puntatori e target Consideriamo, ad esempio, il seguente frammento di codice: REAL,TARGET,DIMENSION(3,3) :: b REAL,TARGET,DIMENSION(3) :: r, s REAL,POINTER,DIMENSION(:,:) :: a REAL,POINTER,DIMENSION(:) :: x, y y => s! Associazione di puntatore: nessuna!assegnazione WRITE(*,*) s! Stampa il valore originale di s a => b! Associazione di puntatore: nessuna!assegnazione x => r! Associazione di puntatore: nessuna!assegnazione y = MATMUL(a,x)! Equivale all istruzione di! assegnazione s=matmul(a,x) WRITE(*,*) s! Adesso s è cambiato e si avra un! output differente rispetto a prima

11 puntatori e target Un puntatore può essere deassociato dal suo target o a seguito di una nuova istruzione di assegnazione (a mezzo della quale esso risulta associato ad un nuovo target) oppure attraverso l esecuzione dell istruzione NULLIFY. Quest ultima ha la seguente forma: NULLIFY (puntatore1 [, puntatore2,...]) A seguito di tale istruzione, tutti i puntatori presenti nella lista degli argomenti risulteranno deassociati dai loro rispettivi target. Lo stato di associazione di un puntatore può essere conosciuto a mezzo della funzione intrinseca ASSOCIATED la cui espressione generale è la seguente: ASSOCIATED(puntatore [, target ]) Il valore ritornato da questa funzione può essere.true. o.false.

12 puntatori e target IMPORTANTE: In realtà un puntatore può avere tre stati, 1) ASSOCIATO 2) DEASSOCIATO o NULLO (in seguito all applicazione di un operazione esplicita di NULLIFY 3) INDEFINITO Quest ultimo stato, il più ambiguo, caratteristico di un puntatore dichiarato ma non ancora utilizzato dal programma, andrebbe accuratamente risolto per esempio inizializzando allo stato NULLO tutti i puntutatori dichiarati dal programma.

13 STRUTTURE DATI DINAMICHE L utilizzo più importante dei PUNTATORI è certamente connesso alla gestione dinamica delle strutture dati. Si consideri, ad esempio, il seguente segmento di codice: INTEGER, DIMENSION(:,:), POINTER, :: a, b, tmp INTEGER n, m, errore.. ALLOCATE(a(n, m), STAT=errore).. ALLOCATE(a(n, m), STAT=errore).. tmp=>a a=>b b=>tmp! sono stati allocate dinamicamente due tabelle, a e b.! quindi i contenuti delle tabelle sono stati scambiati in maniera molto! efficiente semplicemente scambiando i nomi delle tabelle

14 STRUTTURE DATI DINAMICHE All'inizio: a b?? Dopo l'allocazione: a b a b Alla fine:

15 STRUTTURE DATI DINAMICHE Una delle più comuni e potenti applicazioni dei puntatori è nella creazione e nella gestione delle cosiddette liste concatenate. Una lista concatenata è una collezione di oggetti di tipo derivato, ciascuno dei quali avente come componente un puntatore alla successiva variabile della lista. In una lista concatenata gli oggetti connessi (i nodi ) si caratterizzano per il fatto che: Non sono immagazzinati necessariamente in maniera contigua. Possono essere creati dinamicamente (cioè al tempo di esecuzione). Possono essere inseriti in un punto qualsiasi della lista. Possono essere rimossi dinamicamente. E, quindi, evidente che una lista può crescere o ridursi in maniera arbitraria durante l esecuzione di un programma.

16 STRUTTURE DATI DINAMICHE Una lista concatenata consiste essenzialmente di strutture (ossia, con terminologia Fortran, di oggetti di tipo derivato) contenenti campi per i comuni dati e in più un ulteriore campo che rappresenta un puntatore al successivo elemento della lista. Per convenzione il primo e l ultimo nodo della lista vengono chiamati rispettivamente testa e coda della lista. testa vlr pnt vlr pnt vlr pnt vlr pnt coda

17 STRUTTURE DATI DINAMICHE TYPE :: Nodo CHARACTER(8) :: colore TYPE(Nodo), POINTER :: ptr END TYPE Nodo TYPE(Nodo), POINTER :: headp, tmpp ROSSO GIALLO headp VIOLA X

18 STRUTTURE DATI DINAMICHE ALLOCATE (headp) headp%colore = VIOLA NULLIFY (headp%ptr) ALLOCATE (tempp) tmpp%colore = GIALLO tmpp%ptr => headp headp => tmpp ALLOCATE (tempp) tmpp%colore = ROSSO tmpp%ptr => headp headp => tmpp! alloca il primo nodo! headp-> VIOLA!alloca secondo nodo! headp-> GIALLO -> VIOLA!alloca terzo nodo! headp-> ROSSO -> GIALLO -> VIOLA NULLIFY (tmpp)

19 STRUTTURE DATI DINAMICHE!Per viaggiare attraverso la lista!stampando i valori dei singoli nodi!è sufficiente partire dalla testa e!quindi sfruttare il puntatore al prossimo nodo tmpp => headp DO WHILE (ASSOCIATED(tmpP)) WRITE(*,*) tmpp%colore tmpp => tmpp%ptr END DO

20 STRUTTURE DATI DINAMICHE Una caratteristica fondamentale delle organizzazioni a lista è l estrema semplicità e flessibilità delle operazioni di aggiornamento. Per esempio, l eliminazione dell elemento GIALLO si traduce in un semplice reindirizzamento del puntatore dell elemento che lo precede! ROSSO GIALLO headp VIOLA X

21 STRUTTURE DATI DINAMICHE! Nell esempio che segue un ciclo per attraversare una lista! alla ricerca dell elemento GIALLO per eliminarlo DO WHILE (ASSOCIATED(tmpP)) IF (tmpp%colore== ROSSO ) THEN precp%ptr => tmpp%ptr DEALLOCATE(tmpP) EXIT END IF precp => tmpp tmp => tmp%ptr END DO

22 PROGRAMMAZIONE MODULARE Il più generale programma FORTRAN può essere pensato come la combinazione/ interazione di: 1)Un main programma 2)Procedure esterne (Subroutine e/o Function) 3)Procedure interne (Subroutine e/o Function) 4)Moduli

23 PROGRAMMAZIONE MODULARE

24 PROGRAMMAZIONE MODULARE La generica struttura di una FUNCTION è la seguente: type FUNCTION function-name (arg1, arg2,.., argn) [dichiarazioni] [istruzioni] [procedure interne] END FUNCTION function-name

25 PROGRAMMAZIONE MODULARE PROGRAM mio INTEGER a, b, c, somma READ(*,*) a, b c=somma(a, b) WRITE(*,*) c END PROGRAM INTEGER FUNCTION somma(a1, a2) INTEGER, INTENT(in) :: a1, a2 somma=a1+a2 END FUNCTION Il programma principale dichiara la funzione esterna somma, passandole per riferimento i parametri a e b. L attributo INTENT(in) indica al compilatore che a1 ed a2 hanno solo funzione di INPUT per la procedura e non possono quindi essere modificate.

26 PROGRAMMAZIONE MODULARE PROGRAM mio INTEGER a, b, c, somma READ(*,*) a, b c=somma(a, b) WRITE(*,*) c WRITE(*,*) a END PROGRAM INTEGER FUNCTION somma(a1, a2) INTEGER :: a1, a2 a1=a1+a2 somma=a1 END FUNCTION Cambiare il valore di un parametro formale durante l esecuzione della funzione significa alterare il valore degli argomenti attuali passati dal programma chiamante!

27 PROGRAMMAZIONE MODULARE INTEGER FUNCTION somma(a1, a2) INTEGER, INTENT(in) :: a1, a2 somma=a1 somma=somma+a2 END FUNCTION Non è possibile usare una variabile-funzione nella parte destra di un espressione!

28 PROGRAMMAZIONE MODULARE FUNCTION add_vett (a, b, n) INTEGER, INTENT(IN) :: n REAL, DIMENSION (n), INTENT(IN) :: a, b REAL, DIMENSION (n) :: add_vett INTEGER :: i DO i = 1, n END DO add_vett(i) = a(i) + b(i) END FUNCTION add_vett E possibile impostare un array come valore ritornato da una funzione!

29 PROGRAMMAZIONE MODULARE La generica struttura di una SUBROUTINE è la seguente: SUBROUTINE subroutine-name(arg1,arg2,...,argn) [dichiarazioni] [istruzioni] [procedure interne] END SUBROUTINE subroutine-name

30 PROGRAMMAZIONE MODULARE PROGRAM mio INTEGER a, b, c READ(*,*) a, b CALL somma(a, b, c) WRITE(*,*) c END PROGRAM SUBROUTINE somma(a1, a2, s) INTEGER, INTENT(IN) :: a1, a2 INTEGER, INTENT(OUT) :: s s=a1+a2 RETURN END SUBROUTINE L esito del codice sopra riportato è lo stesso di quello visto per l analoga FUNCTION. INTENT(in) ed INTENT(out) devono essere obbligatoriamente usate. Se qualche variabile ha entrambe le funzioni si userà INTENT(inout)

31 PROGRAMMAZIONE MODULARE PROGRAM mio INTEGER a, b, c READ(*,*) a, b CALL somma(a, b, c) WRITE(*,*) c END PROGRAM SUBROUTINE somma(a1, a2, s) INTEGER, INTENT(IN) :: a1, a2 INTEGER, INTENT(OUT) :: s WRITE(*,*) a s=a1+a2 END SUBROUTINE Una procedura esterna non ha accesso alle variabili definite nel programma chiamante!

32 PROGRAMMAZIONE MODULARE PROGRAM mio INTEGER a, b, c READ(*,*) a, b CALL somma(a, b, c) WRITE(*,*) c CONTAINS SUBROUTINE somma(a1, a2, s) INTEGER, INTENT(IN) :: a1, a2 INTEGER, INTENT(OUT) :: s WRITE(*,*) a s=a1+a2 END SUBROUTINE END PROGRAM La parola chiave CONTAINS consente di dichiarare una procedura come INTERNA al programma principale. In questo caso cambia la visibilità delle variabili e l istruzione WRITE darà il risultato aspettato.

33 PROGRAMMAZIONE MODULARE La più flessibile, potente ed innovativa UNITA DI PROGRAMMA resa disponibile da FORTRAN 90 è sicuramente il MODULO. Vediamo un esempio. MODULE mudulo_punti TYPE :: punto REAL :: x,y END TYPE punto CONTAINS FUNCTION addpunti(p,q) TYPE (punto),intent(in) :: p,q TYPE (punto) :: addpunti addpunti%x = p%x + q%x addpunti%y = p%y + q%y END FUNCTION addpunti END MODULE modulo_punti

34 PROGRAMMAZIONE MODULARE Quindi il programma principale potrebbe fruire dei contenuti del modulo precedente con una semplice dichiarazione di uso: USE modulo_punti TYPE (punto) :: px, py, pz... pz = addpunti(px,py)...

35 PROGRAMMAZIONE MODULARE MODULE dati_condivisi SAVE INTEGER, PARAMETER :: NUM_VALORI = 5 REAL, DIMENSION(NUM_VALORI) :: valori END MODULE dati_condivisi PROGRAM test_modulo USE dati_condivisi valori = (/ 1., 2., 3., 4., 5. /) WRITE (*,*) "prima esecuzione sub" CALL sub1 WRITE (*,*) "seconda esecuzione sub" CALL sub1 END PROGRAM test_modulo SUBROUTINE sub1 USE dati_condivisi WRITE (*,*) valori valori = 2 * valori WRITE (*,*) valori END SUBROUTINE sub1 La direttiva SAVE consente di congelare le variabili assicurando la permanenza del loro valore fra più chiamate d uso del modulo!

36 PROGRAMMAZIONE MODULARE PROGRAM test INTERFACE REAL FUNCTION quoz(x,y) REAL, INTENT(IN)::x,y END FUNCTION quoz END INTERFACE INTEGER :: i=3,j=25 WRITE(*, *) Il quoziente è &, quoz(i,j) END PROGRAM test REAL FUNCTION quoz(x,y) REAL,INTENT(IN):: x,y quoz=x/y END FUNCTION quoz Una ragione profonda perchè un progettista FORTRAN dovrebbe includere i sottoprogrammi in un modulo piuttosto che pensarli come procedure esterne è che nel primo caso il compilatore possiede un interfaccia esplicita del sottoprogramma stesso e, quindi, ha tutte le informazioni necessarie per controllare la corrispondenza fra gli argomenti fittizi e quelli effettivi. Alternativamente è possibile utilizzare un INTERFACE BLOCK come nell esempio a sinistra. Il compilatore segnalerebbe errore riconoscendo, grazie all interfaccia, la mancata corrispondenza fra parametri REAL ed INTEGER.

37 PROGRAMMAZIONE MODULARE PROGRAM esempio INTERFACE REAL FUNCTION esp(a, b) REAL, INTENT(IN) :: a INTEGER, INTENT(IN), & OPTIONAL :: b END FUNCTION esp END INTERFACE REAL :: x=2. INTEGER :: y=3 WRITE(*,*) esp(x) END PROGRAM esempio REAL FUNCTION esp(a, b) REAL, INTENT(IN) :: a INTEGER, INTENT(IN), & OPTIONAL :: b IF (PRESENT(b)) THEN FUN = a**b ELSE FUN = a END IF END FUNCTION esp L interfaccia esplicita rende possibile l impostazione di parametri opzionali!

38 PROGRAMMAZIONE MODULARE THE END