Sei sulla pagina 1di 55

Corso di Fondamenti di Informatica

Ingegneria delle Comunicazioni – BCOR


Ingegneria Elettronica – BELR

Introduzione al C

Unità 5 – Funzioni

D. Bloisi, A. Pennisi, S. Peluso, S. Salza


Sommario – Unità 5
•  Definizione di funzioni
•  Passaggio dei parametri
•  Esecuzione di una funzione
•  Variabili dichiarate in una funzione e visibilità
•  Gestione della memoria su chiamate di funzioni

Funzioni - Unità 5 2013/2014 Pagina 2


Astrazione sulle operazioni: funzioni

L'astrazione sulle operazioni è supportata da tutti i


linguaggi di programmazione attuali (Java, C#, C++, C,
Pascal, Fortran, Lisp, ecc.).

In C l'astrazione sulle operazioni si realizza attraverso la


nozione di funzione.

Una funzione può essere vista come una scatola nera che
prende dei parametri in ingresso e restituisce dei risultati
o compie delle azioni.

Funzioni - Unità 5 2013/2014 Pagina 3


Definizione di funzioni
tipoRisultato nomeFunzione(parametriFormali){!
!
!istruzioni! Intestazione
}! Corpo
tipoRisultato: tipo del risultato restituito dalla funzione
(e.g. int, double) oppure void se la funzione non
restituisce risultato.
nomeFunzione: nome della funzione.
parametriFormali: lista (eventualmente vuota) di
dichiarazioni di parametri (coppie tipo e nome) separate da
virgola.
istruzioni: corpo della funzione contenente le istruzioni da
eseguire all’invocazione della funzione stessa.
Funzioni - Unità 5 2013/2014 Pagina 4
Esempio: funzione main
int main(){! int main(void){!
! !...!
!...! }!
}!
oppure
void main(){! void main(void){!
! !...!
!...! }!
}!
Nota: la lista dei parametri formali vuota può essere
denotata con void!
Funzioni - Unità 5 2013/2014 Pagina 5
Esempio: stampa potenza
void stampaPotenza(double b, double esp){
!
!!
!double r = pow(b,esp);!
!printf(“%f\n”, r);!
!!
}!

Nota: per utilizzare la funzione pow includere file di


header math.h, i.e. #include <math.h>

Funzioni - Unità 5 2013/2014 Pagina 6


Risultato di una funzione:
l’istruzione return!
Sintassi:
return espressione;
dove
• espressione è un’espressione il cui valore è
compatibile con il tipo del risultato dichiarato
nell’intestazione della funzione.

Funzioni - Unità 5 2013/2014 Pagina 7


Semantica di return!

L’istruzione return eseguita all’interno di una


funzione f termina l’esecuzione della stessa e
restituisce il risultato nel punto del programma
dove è stata invocata f.

Funzioni - Unità 5 2013/2014 Pagina 8


Esempio: return nella funzione main!
int main() {
return 0; // terminazione normale del programma
}

Se il tipo del risultato della funzione è void, l’istruzione


return si può omettere, oppure può essere usata
semplicemente per interrompere l’esecuzione della funzione
stessa. La sintassi dell’istruzione è in questo caso:
return;

Nota: l'esecuzione dell'istruzione return fa sempre


terminare la funzione, anche se ci sono altre istruzioni
che seguono.
Funzioni - Unità 5 2013/2014 Pagina 9
Mancato return!
#include <stdio.h>
#include <math.h>
Verificare se il
double radice(double x) { compilare (gcc)
double r = sqrt(x); segnala eventuali
} errori
int main() {
printf("%f\n", radice(4.0));
}

Funzioni - Unità 5 2013/2014 Pagina 10


Esempi di defininizione di funzioni
Esempio 1
void stampaSaluto() {
printf("Buon giorno!\n");
}

Esempio 2
double dist(double x1, double y1, double x2, double y2)
{
return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
}

Funzioni - Unità 5 2013/2014 Pagina 11


Esempio: calcolo potenza mediante
definizione di due funzioni (1/2)

int moltiplicazione(int moltiplicando,


int moltiplicatore) {
int prodotto = 0;
while (moltiplicatore > 0) {
moltiplicatore--;
prodotto = prodotto + moltiplicando;
}
return prodotto;
}

Funzioni - Unità 5 2013/2014 Pagina 12


Esempio: calcolo potenza mediante
definizione di due funzioni (2/2)

int potenza(int base, int esponente) {


int risultato = 1;
while (esponente > 0) {
esponente--;
risultato =
moltiplicazione(risultato, base);
}
return risultato;
}

Funzioni - Unità 5 2013/2014 Pagina 13


Passaggio dei parametri (1/3)
La definizione di una funzione presenta nell’intestazione
una lista di parametri formali. Questi parametri sono
utilizzati come variabili all’interno del corpo della funzione.
L’invocazione di una funzione contiene i parametri da
utilizzare come argomenti della funzione stessa. Questi
parametri sono detti parametri attuali, per distinguerli dai
parametri formali presenti nell’intestazione della
definizione della funzione.
Quando, attraverso una invocazione, attiviamo una
funzione, i parametri attuali devono essere legati ai
parametri formali. Esistono diversi modi possibili di
effettuare questo legame.
Funzioni - Unità 5 2013/2014 Pagina 14
Passaggio dei parametri (2/3)
Molti linguaggi di programmazione prevedono due
modi per il passaggio dei parametri:
• passaggio per valore
• passaggio per riferimento

Funzioni - Unità 5 2013/2014 Pagina 15


Passaggio dei parametri (3/3)
Quando gli argomenti saranno passati in una
chiamata per valore, sarà preparata una copia dei
loro valori e questa sarà passata alla funzione
chiamante.

Quando un argomento sarà passato in una


chiamata per riferimento, esso farà riferimento
alla variabile originale (parametro attuale) definita
nell’ambiente della funzione chiamante.

Funzioni - Unità 5 2013/2014 Pagina 16


Passaggio dei parametri per valore
(1/2)
Sia pa un parametro attuale presente nell’invocazione della
funzione e pf il corrispondente parametro formale nella
definizione della funzione: legare pa a pf per valore
significa, al momento della attivazione della funzione:

1. valutare il parametro attuale pa (che in generale è


un’espressione)
2. associare una locazione di memoria al parametro
formale pf
3. inizializzare tale locazione con il valore di pa.

Funzioni - Unità 5 2013/2014 Pagina 17


Passaggio dei parametri per valore
(2/2)
Il parametro formale pf si comporta esattamente come una
variabile creata al momento dell’attivazione della funzione
e inizializzata con il valore del parametro attuale pa.
Alla fine dell’esecuzione del corpo della funzione la
memoria riservata per il parametro formale viene rilasciata
e il suo valore si perde.

Nota: i valori delle variabili che compaiono


nell’espressione pa non vengono alterati
dall’esecuzione della funzione.

Funzioni - Unità 5 2013/2014 Pagina 18


Esempio di passaggio di parametri per
valore (1/5)
int raddoppia(int x) {
x = x * 2;
return x;
}

int main() {
int a, b;
a = 5;
b = raddoppia(a + 1);
printf("%d %d\n", a, b);
}

Funzioni - Unità 5 2013/2014 Pagina 19


Esempio di passaggio di parametri per
valore (2/5)
1.  Sono definite due variabili intere a, b e a è inizializzata al
valore 5.
2. Sono valutati i parametri attuali: nel nostro caso il
parametro attuale è l’espressione a + 1 che ha come
valore 6.
3.  E’ individuata la funzione da eseguire, cercando la
definizione di una funzione il cui prototipo sia conforme alla
invocazione: il nome della funzione deve essere lo stesso e i
parametri attuali devono corrispondere in numero e tipo ai
parametri formali (nel nostro caso la funzione che cerchiamo
deve avere la segnatura raddoppia(int)).

Funzioni - Unità 5 2013/2014 Pagina 20


Esempio di passaggio di parametri per
valore (3/5)
4. L’esecuzione dell’unità di programma
chiamante è sospesa (nell’esempio la funzione main).
5. Sono riservate (allocate) in memoria locazioni per i
parametri formali (considerati come variabili) e le variabili
definite nella funzione (vedremo in seguito): nel nostro
esempio sarà riservata memoria per il parametro formale
x.
6. I valori dei parametri attuali sono associati ai
corrispondenti parametri formali: nell’esempio il
parametro formale x è inizializzato con il valore 6.

Funzioni - Unità 5 2013/2014 Pagina 21


Esempio di passaggio di parametri per
valore (4/5)
7. Sono eseguite le istruzioni del corpo della funzione
invocata (a partire dalla prima): nell’esempio il valore
di x è moltiplicato per 2 e diventa 12;
8. L’esecuzione della funzione invocata termina (o per
l’esecuzione dell’istruzione return o perché non ci
sono altre istruzioni da eseguire): nell’esempio
si esegue l’istruzione return x;
9.  La memoria utilizzata per i parametri formali e le
variabili della funzione è deallocata, perdendo qualsiasi
informazione ivi contenuta: nell’esempio viene
eliminata la locazione di memoria corrispondente al
parametro formale x.
Funzioni - Unità 5 2013/2014 Pagina 22
Esempio di passaggio di parametri per
valore (5/5)
10. Se la funzione restituisce un risultato, tale risultato
diviene il valore dell’espressione costituita
dall’invocazione nell’unità di programma chiamante:
nell’esempio il risultato è 12.
11. Si riprende l’esecuzione dell’unità di programma
chiamante dal punto in cui era stata interrotta
dall’invocazione: il valore 12 è assegnato alla
variabile b.

Nel passaggio di parametri per valore il contenuto delle


variabili usate come parametri attuali non viene mai
modificato. Il programma illustrato stampa quindi 5 12.
Funzioni - Unità 5 2013/2014 Pagina 23
Perché il C adotta il passaggio per
valore?
• E’ sicuro: le variabili del chiamante e del
chiamato sono completamente disaccoppiate.

• Consente di ragionare per componenti e servizi:


la struttura interna dei singoli componenti è
irrilevante (la funzione può anche modificare il
contenuto dei parametri formali, senza che ciò
abbia alcun impatto sui valori dei parametri
attuali nell’ambiente del chiamante).

Funzioni - Unità 5 2013/2014 Pagina 24


Limiti del passaggio per valore
• Il passaggio per valore ha una SEMANTICA
PER COPIA

– Impedisce a priori di scrivere funzioni che


abbiano come scopo quello di modificare i
dati passati dall’ambiente chiamante.

– Impedisce di restituire più di un risultato


all’ambiente chiamante (es. non è possibile
creare una funzione che restituisca quoziente
e resto di una divisione).
Funzioni - Unità 5 2013/2014 Pagina 25
Effetti del passaggio per valore
void swapVal(int a, int b) {
int temp;
temp = a;
a = b;
Cosa stampa
b = temp;
} questo
programma?
int main() {
int x = 12, y = 27;
printf("x = %d y = %d\n", x, y);
swapVal(x, y);
printf("x = %d y = %d\n", x, y);
}
Funzioni - Unità 5 2013/2014 Pagina 26
Passaggio dei parametri per
riferimento
• La versione corretta del programma C che
realizza l'effettivo scambio di valore delle
variabili passate come parametri attuali
necessita di un passaggio per riferimento.

• Occorre un metodo per consentire alla funzione


di poter manipolare le (fare riferimento alle)
variabili dell’ambiente del chiamante.

Funzioni - Unità 5 2013/2014 Pagina 27


Principi del passaggio per riferimento
• Una funzione deve poter dichiarare, nella sua
intestazione, che un parametro costituisce un riferimento
• In tal caso:
– il parametro formale indicato come “riferimento” non
è più una variabile locale inizializzata al valore del
parametro attuale, ma è un riferimento alla variabile
originale (parametro attuale) nell’ambiente della
funzione chiamante;
– ogni modifica fatta al parametro formale, in realtà
viene effettuata sul parametro attuale della funzione
chiamante (le modifiche fatte dall’ambiente chiamato
si propagano all’ambiente chiamante).
Funzioni - Unità 5 2013/2014 Pagina 28
Passaggio parametri per riferimento in
C
Il passaggio per riferimento è disponibile in
molti linguaggi di alto livello (Pascal, C++), ma
non in tutti.

In particolare, NON è disponibile in C.

Può essere simulato tramite l’uso di puntatori


che saranno analizzati nella Unità 6.

Funzioni - Unità 5 2013/2014 Pagina 29


Variabili locali
Il corpo di una funzione può contenere dichiarazioni di
variabili. Tali variabili vengono dette variabili locali.

Una variabile ha due aspetti fondamentali:

• campo d’azione (è una nozione statica, che dipende dal


testo del programma);

• tempo di vita (è una nozione dinamica, che dipende


dall’esecuzione del programma).

Funzioni - Unità 5 2013/2014 Pagina 30


Campo d’azione delle variabili locali
Il campo d'azione (o scope) di una variabile è l'insieme
delle unità di programma in cui la variabile è visibile (cioè
accessibile ed utilizzabile).
Il campo di azione di una variabile locale è il corpo
della funzione in cui essa è dichiarata.
Più in generale, una variabile dichiarata in un qualsiasi
blocco ( istruzione {...} ) è visibile in quel blocco (inclusi
eventuali blocchi interni), ma non è visibile all'esterno del
blocco stesso.
Una variabile non può essere utilizzata nel corpo della
funzione prima di essere dichiarata.
Funzioni - Unità 5 2013/2014 Pagina 31
Esempio
int raddoppia (int x) {
return x*2;
}
void stampa() {
printf("%d\n", a); //ERRORE a non e’ definita
}
int main() {
int a = 5;
a = raddoppia(a); nella funzione stampa la
stampa(); variabile a non è visibile
printf("%d\n", a); (perché definita nella
} funzione main).

Funzioni - Unità 5 2013/2014 Pagina 32


Variabili globali
In C le variabili globali, cioè definite al di fuori di
una definizione di funzione sono visibili in tutte le
funzioni.

In ogni funzione sono visibili le variabili dichiarate


localmente e le variabili globali.

Funzioni - Unità 5 2013/2014 Pagina 33


Esempio
int a = 1; // dichiarazione globale di a
void f1 () {
printf("In f1\n");
printf("a = %d\n", a);
//printf("b = %d\n", b);
return;
}
int main () {
int b = 1;
f1();
printf("In main\n");
printf("a = %d\n", a);
return 0;
}
Funzioni - Unità 5 2013/2014 Pagina 34
Tempo di vita delle variabili
Il tempo di vita di una variabile è il tempo in cui la variabile
rimane effettivamente accessibile in memoria durante
l'esecuzione.
Le variabili locali ad una funzione vengono create al
momento dell'attivazione della funzione (come i parametri
formali) e vengono distrutte al momento dell'uscita
dall'attivazione.
Le variabili globali restano in vita per tutta la durata
dell'esecuzione del programma.
Il tempo di vita di una variabile è un concetto rilevante a
tempo di esecuzione. Da esso dipende l’insieme delle
variabili utilizzabili in ciascun punto del programma.
Funzioni - Unità 5 2013/2014 Pagina 35
Esempio: tempo di vita delle variabili
locali (1/2)
int raddoppia (int x) {
int temp = x*2;
return temp;
}
void stampa(int b) {
printf("b = %d\n", b);
}
int main() {
int a = 5;
a = raddoppia(a);
a = raddoppia(a);
stampa(a);
printf("a = %d\n", a);
}
Funzioni - Unità 5 2013/2014 Pagina 36
Esempio: tempo di vita delle variabili
locali (2/2)
La variabile a inizia ad essere in vita quando viene
eseguita la sua dichiarazione nella funzione main.
Il parametro x della funzione raddoppia (che corrisponde
ad una variabile locale) e la variabile locale temp iniziano
ad essere in vita quando viene invocata la funzione
raddoppia e “muoiono”, al termine della sua esecuzione.
Ad ogni esecuzione di raddoppia corrispondono in
esecuzione, diverse istanze di variabili.
Analogamente il parametro x della funzione stampa nasce
e muore con l’esecuzione di stampa.

Funzioni - Unità 5 2013/2014 Pagina 37


Esercizi
Esercizio 5.1
Scrivere una funzione che calcoli il volume di una sfera,
dato il raggio. Scrivere un programma di prova che usi tale
funzione, leggendo da tastiera il valore del raggio e
stampando il volume della sfera con tale raggio.

Esercizio 5.2
Scrivere una funzione che dati due valori reali a e b
restituisca il massimo tra i due. Scrivere un programma di
prova per tale funzione, leggendo l’input da tastiera.

Funzioni - Unità 5 2013/2014 Pagina 38


Layout di memoria (1/2)
A tempo di esecuzione, il sistema operativo deve gestire
diverse zone di memoria:
• Zona testo: contiene il codice eseguibile del programma
– determinata a tempo di esecuzione al momento del
caricamento del codice;
– con dimensione fissata per ogni funzione a tempo di
compilazione.

• Heap: zona di memoria allocata dinamicamente


– cresce e decresce dinamicamente durante l’esecuzione

•  Zona dati: zona di memoria allocata a tempo di


caricamento contenente le variabili globali

Funzioni - Unità 5 2013/2014 Pagina 39


Layout di memoria (2/2)

• stack o pila dei record di attivazione: zona di memoria


per i dati locali alle funzioni (e.g. variabili, parametri)
– cresce e decresce dinamicamente durante
l’esecuzione.
– gestita con un meccanismo a pila.

Funzioni - Unità 5 2013/2014 Pagina 40


Pila dei record di attivazione
Una pila (o stack) è una struttura dati con accesso LIFO

Last In First Out = l’ultimo entrato è il primo a uscire


(Esempio: pila di piatti).

A run-time il sistema operativo gestisce la pila dei record


di attivazione (RDA):
• per ogni attivazione di funzione viene creato un nuovo
RDA in cima alla pila;
• al termine dell’attivazione della funzione il RDA viene
rimosso dalla pila.

Funzioni - Unità 5 2013/2014 Pagina 41


PF v1
Record di attivazione VL v2
VR v3
Un RDA tiene traccia IR v4
• delle locazioni di memoria per i parametri formali (se
presenti);
• delle locazioni di memoria per le variabili locali (se
presenti);
• del valore di ritorno dell’invocazione della funzione (se
la funzione ha tipo di ritorno diverso da void);
• della locazione di memoria per l’indirizzo di ritorno,
ovvero l’indirizzo della prossima istruzione da eseguire
nella funzione chiamante.
Funzioni - Unità 5 2013/2014 Pagina 42
Esempio di evoluzione della pila
dei record di attivazione (1/2)
int B(int pb) {
/* b0 */ printf("In B. Parametro pb = %d\n", pb);
/* b1 */ return pb+1;
}

int A(int pa) {


/* a0 */ printf("In A. Parametro pa = %d\n", pa);
/* a1 */ printf("Chiamata di B(%d).\n", pa * 2 );
/* a2 */ int va = B(pa * 2);
/* a3 */ printf("Di nuovo in A. va = %d\n", va);
/* a4 */ return va + pa;
}

Funzioni - Unità 5 2013/2014 Pagina 43


Esempio di evoluzione della pila
dei record di attivazione (2/2)
int main() {
/* m0 */ printf("In main.\n");
/* m1 */ int vm = 22;
/* m2 */ printf("Chiamata di A(%d).\n", vm);
/* m3 */ vm = A(vm);
/* m4 */ printf("Di nuovo in main. vm = %d\n", vm);
/* m5 */ return 0;
}

Funzioni - Unità 5 2013/2014 Pagina 44


Output prodotto dal programma

In main.
Chiamata di A(22).
In A. Parametro pa = 22
Chiamata di B(44).
In B. Parametro pb = 44
Di nuovo in A. va = 45
Di nuovo in main. vm = 67

Funzioni - Unità 5 2013/2014 Pagina 45


Program Counter (PC)
Per comprendere cosa avviene durante
l’esecuzione del codice, è necessario fare
riferimento, oltre che alla pila dei RDA, al
program counter (PC), il cui valore è l’indirizzo
della prossima istruzione da eseguire.

Si assuma che
m0 abbia indirizzo 100
a0 abbia indirizzo 200
b0 abbia indirizzo 300

Funzioni - Unità 5 2013/2014 Pagina 46


Evoluzione della pila dei RDA

Figura 5.1

Funzioni - Unità 5 2013/2014 Pagina 47


Evoluzione della pila dei RDA:
individuazione e chiamata di A!
Prima dell’attivazione di A(vm), la pila dei RDA è come
mostrato in 1 nella Fig. 5.1:
1. Sono valutati i parametri attuali: in questo caso il
parametro attuale è l’espressione vm che ha come
valore l’intero 22.
2. E’ individuata la funzione da eseguire in base al
numero e tipo dei parametri attuali, cercando la
definizione di una funzione la cui segnatura sia
conforme alla invocazione: nel nostro caso la funzione
da eseguire deve avere la segnatura A(int).
3. E’ sospesa l’esecuzione della funzione chiamante
(nell’esempio la funzione main).
Funzioni - Unità 5 2013/2014 Pagina 48
Evoluzione della pila dei RDA:
creazione dei record di A!
4. E’ creato il RDA relativo all’attivazione corrente della
funzione chiamata: nell’esempio è creato il RDA
relativo all’attivazione corrente di A; il RDA contiene:
• le locazioni di memoria per i parametri formali
(nell’esempio, il parametro pa di tipo int);
• le locazioni di memoria per le variabili locali
(nell’esempio, la variabile va di tipo int);
• una locazione di memoria per il valore di ritorno
(nell’esempio indicata con VR);
• una locazione di memoria per l’indirizzo di ritorno
(nell’esempio indicata con IR).
5. Il valore dei parametri attuali è assegnato ai parametri
formali: nel nostro caso, il parametro formale pa è
inizializzato con il valore 22.
Funzioni - Unità 5 2013/2014 Pagina 49
Evoluzione della pila dei RDA:
modifica valore del PC!
6. L’indirizzo di ritorno nel RDA è uguagliato
all’indirizzo della prossima istruzione che deve essere
eseguita nella funzione chiamante al termine
dell’invocazione: nel’esempio, l’indirizzo di ritorno
nel RDA relativo all’attivazione di A è impostato al
valore 104, che è l’indirizzo dell’istruzione di main
corrispondente all’istruzione m4, da eseguire quando
l’attivazione di A sarà terminata; a questo punto, la pila
dei RDA è come mostrato in 2 nella Fig. 5.1;
7. Al program counter è assegnato l’indirizzo della
prima istruzione della funzione invocata: nell’esempio
al program counter è assegnato l’indirizzo
200, che è l’indirizzo della prima istruzione di A;
Funzioni - Unità 5 2013/2014 Pagina 50
Evoluzione della pila dei RDA:
esecuzione di A!
8. Si passa ad eseguire la prossima istruzione indicata
dal program counter, che sarà la prima istruzione della
funzione invocata: nell’esempio l’istruzione di
indirizzo 200, ovvero la prima istruzione di A.
Dopo questi passi, le istruzioni della funzione chiamata,
(A), sono eseguite in sequenza. In particolare, avverrà
l’attivazione, l’esecuzione e la terminazione di eventuali
funzioni a loro volta invocate nella funzione chiamata.
Nell’esempio, avverrà l’attivazione, l’esecuzione e la
terminazione della funzione B, con un meccanismo
analogo a quello adottato per A; la pila dei RDA passerà
attraverso gli stati 3 e 4.
Funzioni - Unità 5 2013/2014 Pagina 51
Evoluzione della pila dei RDA:
terminazione di A!
Analizziamo ora in dettaglio cosa avviene al momento
della terminazione dell’attivazione di A, cioè quando viene
eseguita l’istruzione return va+pa;

Prima dell’esecuzione, la pila dei RDA è come mostrato in


4 nella Fig. 5.1 (in realtà, la zona di memoria predisposta
a contenere il valore di ritorno, indicata con VR nella
figura, è inizializzata contestualmente all’esecuzione
dell’istruzione return, e non prima).

Funzioni - Unità 5 2013/2014 Pagina 52


Evoluzione della pila dei RDA:
valore di ritorno!
1.  Al program counter è assegnato il valore
memorizzato nella locazione di memoria riservata
all’indirizzo di ritorno nel RDA corrente: nell’esempio
tale valore è pari a 104, che è proprio l’indirizzo,
memorizzato in IR, della prossima istruzione di main
che dovrà essere eseguita;
2. Nel caso la funzione invocata preveda la restituzione di
un valore di ritorno, tale valore è memorizzato in
un’apposita locazione di memoria del RDA corrente:
nell’esempio, il valore 67, risultato della valutazione
dell’espressione va+pa è assegnato alla locazione di
memoria indicata con VR, predisposta per contenere il
valore di ritorno;
Funzioni - Unità 5 2013/2014 Pagina 53
Evoluzione della pila dei RDA:
eliminazione del record!
3. Il RDA relativo all’attivazione corrente è eliminato dallo
stack; contestualmente all’eliminazione del RDA dalla
pila dei RDA, un eventuale valore di ritorno è copiato in
una locazione di memoria del RDA del chiamante:
nell’esempio il RDA relativo all’attivazione di A è
eliminato; inoltre, il valore 67, memorizzato nella
locazione di memoria VR è assegnato alla variabile vm nel
RDA di main; la pila dei RDA è come mostrata in 5 nella
Fig. 5.1;

Funzioni - Unità 5 2013/2014 Pagina 54


Evoluzione della pila dei RDA:
prossima istruzione da eseguire!
4. Si passa ad eseguire la prossima istruzione il
cui indirizzo è memorizzato nel program counter.
Nell’esempio si passa ad eseguire l’istruzione di
indirizzo 104, che fa riprendere l’esecuzione di
main.

Funzioni - Unità 5 2013/2014 Pagina 55