2. Problema
• Abbiamo visto sequenze di istruzioni che risolvono
particolari “sotto-problemi”: controllo della primalità
di un numero, confronto di stringhe, etc.
• È possibile riutilizzare queste sequenze?
• È possibile consentire ad altri di riutilizzare queste
sequenze?
• È possibile dare a queste sequenze un nome che
ne indichi la funzionalità?
• È possibile “svincolare” lo sviluppo di soluzioni a
sotto-problemi di questo tipo dallo sviluppo di una
soluzione “complessa”?
3. Se fosse possibile…
• …fare queste cose, i vantaggi sarebbero
molti:
• Potendo riutilizzare facilmente le sequenze,
aumenterebbe la produttività (potremmo
scrivere più codice in meno tempo)
• Potremmo consentire ad altri di aumentare la
loro produttività
• Potremmo rendere il codice più leggibile
• Potremmo “spezzare” la risoluzione di un
problema in sotto-problemi
4. Le funzioni
• I principali linguaggi di programmazione offrono, in
risposta a queste esigenze, lo strumento delle
procedure o funzioni
• In C e C++, una funzione è una sequenza di comandi
che:
– ha un nome
– può essere invocata (cioè può esserne richiesta l’esecuzione)
– può ricevere dei valori di parametri che ne influenzano
l’esecuzione
– può produrre un valore risultato
4
5. Motivazioni
•
Modularità nello sviluppo del codice
– Affrontare il problema per raffinamenti successivi
•
Riusabilità
– Scrivere una sola volta il codice e usarlo più volte
– Esempi:
• un algoritmo di ordinamento
• Le operazioni del calcolo matriciale
• La ricerca di una parola in un testo
•
Astrazione
– Esprimere in modo sintetico operazioni complesse
– Definire operazioni specifiche dei tipi di dato definiti dal programmatore
– Esempi:
• Calcolo “totale + iva” di un ordine
• Lettura scrittura transazioni di vendita dei libri
• Operazioni con entità quali punti, segmenti, poligoni, numeri complessi
6. Esempio: gestione del dialogo con
l'utente
int main() {
char scelta;
int valore, risultato;
while (true) { // menu, loop infinito
cout << "Premere A per inserire un num tra 0 e 10 e calcolarne il cubo" << endl;
cout << "Premere B per inserire un num tra 11 e 20 e calcolarne il quadrato" << endl;
cout << "Premere C per inserire un num tra 21 e 30 e calcolarne il doppio" << endl;
cout << "Premere Q per uscire" << endl;
cin >> scelta;
switch (scelta) {
case 'a': case 'A':
cout << "Inserisci valore" << endl;
cin >> valore;
risultato = valore * valore * valore;
cout << "risultato = " << risultato << endl;
break;
6
7. … continua
case 'b': case 'B':
cout << "Inserisci valore" << endl;
cin >> valore;
risultato = valore * valore;
cout << "risultato = " << risultato << endl;
break;
case 'c': case 'C':
cout << "Inserisci valore" << endl;
cin >> valore;
risultato = valore * 2;
cout << "risultato = " << risultato << endl;
break;
case 'q': case 'Q':
cout << "GRAZIE E ARRIVEDERCI";
return 0; // termina il ciclo infinito
}
}
}
7
8. Fattorizzazione del dialogo
char menu() {
char ch;
cout << "Premere
cout << "Premere
cout << "Premere
cout << "Premere
cin >> ch;
return ch;
}
A
B
C
Q
per
per
per
per
inserire un num tra 0 e 10 e calcolarne il cubo" << endl;
inserire un num tra 11 e 20 e calcolarne il quadrato" << endl;
inserire un num tra 21 e 30 e calcolarne il doppio" << endl;
uscire" << endl;
int leggi() {
int v;
cout << "Inserisci valore" << endl;
cin >> v;
return v;
}
8
9. Programma principale
int main() {
char scelta;
int valore, risultato;
while (true) { // menu, loop infinito
scelta = menu();
switch (scelta) {
case 'a': case 'A':
valore = leggi();
risultato = valore * valore * valore;
cout << "risultato = " << risultato << endl;
break;
case 'b': case 'B':
valore = leggi();
risultato = valore * valore;
cout << "risultato = " << risultato << endl;
break;
case 'c': case 'C':
valore = leggi();
risultato = valore * 2;
cout << "risultato = " << risultato << endl;
break;
case 'q': case 'Q':
cout << "GRAZIE E ARRIVEDERCI";
return 0;
}
}
}
9
10. Osservazioni
• La funzione main() invoca le funzioni menu() e
leggi()
– main(): funzione chiamante
– menu() e leggi(): funzioni chiamate
• La comunicazione chiamante-chiamato nel caso
visto avviene tramite il valore di ritorno
char menu() {.. return ch; }
int main () {…
..
scelta = menu();
• Il chiamante copia in una propria variabile locale il
valore prodotto dall'invocazione della funzione
10
11. Definizione delle funzioni
<tipo restituito> <nome della funzione>
(<lista parametri>) {
}
•Tipo restituito: il tipo del valore di ritorno della
funzione
– Non può essere un tipo array
•Nome: un identificatore
•Lista parametri: una lista di coppie
<tipo-nomeParametro> separate da virgole
– Si possono usare 0 o più parametri
•{ . . . }: corpo della funzione
12. Definizione di una funzione
int leggi(int min, int max) {
int v;
bool ok = false;
while (!ok) {
cout << "Inserisci valore" << endl;
cin >> v;
if (v >= min && v <= max)
ok = true;
}
return v;
}
12
13. Chiamata di una funzione
int main() {
char scelta;
int valore, risultato;
while (true) { // menu, loop infinito
scelta = menu();
switch (scelta) {
case 'a':
case 'A':
valore = leggi(0,10);
risultato = valore * valore * valore;
cout << "risultato = " << risultato << endl;
break;
•Leggi(0,10) è un'espressione di chiamata a
funzione
•0 e 10 sono gli argomenti della chiamata
•Valore dell'espressione è il valore restituito dalla
funzione
•Il tipo dell'espressione è il tipo di ritorno delle funzione
13
14. Esempio
• Definiamo il fattoriale come una funzione
int fatt(int val)
{
int ris = 1;
while (val > 1)
ris *= val--; //assegna ris * val a ris e decrementa val
return ris;
}
int main() {
int numero;
cout << "Inserire un numero positivo" << endl;
cin >> numero;
cout << "Il fattoriale di " << numero << " vale "
<< fatt(numero) << endl;
return 0;
}
15. Sintassi dell’invocazione
• L'invocazione di una funzione è un’espressione
– es: possiamo immaginare una funzione somma(a,b) equivalente
ad a+b
• Quando, nell’esecuzione del codice, è necessario ‘valutare’
un’espressione-funzione, la funzione viene invocata
• La sintassi per la formulazione di una espressione-funzione è
semplicemente:
<nome funzione>(<lista argomenti>)
– dove <lista argomenti> è una lista di espressioni di tipo
corrispondente ai parametri della definizione della funzione
• Corrispondenza posizionale
– al primo parametro corrisponde il primo argomento, al secondo il
secondo, e così via ...
16. Semantica dell’invocazione
• Quando una funzione viene invocata:
– Le espressioni corrispondenti agli argomenti vengono
valutate, e il valore reso disponibile ("passato") alla
funzione
– I valori passati alla funzione sono utilizzati per inizializzare
i parametri della funzione
– Il controllo passa da chiamante alla funzione chiamata,
– Questa viene eseguita, fino a quando non viene incontrato
un comando return (o il termine del blocco principale })
– Il “valore” dell’espressione-funzione corrispondente alla
chiamata è il valore dell'espressione che appare
nell'istruzione return che ha causato la terminazione
• NB: oppure nessun valore se la funzione ha void come tipo di
ritorno
17. Comunicazione chiamantechiamato
• L'uso del valore di ritorno non è sufficiente
• Può essere necessario:
– Che il chiamante comunichi dei valori al chiamato
– Che il chiamato restituisca più di un valore al
chiamante
– Che il chiamato modifichi direttamente un valore
del chiamante
• Ad esempio, la funzione leggi() deve ricevere
dal chiamante i limiti inferiore e superiore del
valore da chiedere all'utente
17
18. Modalità di passaggio degli
argomenti
• Chiamante e chiamato devono comunicare
• Ci sono diverse esigenze a cui corrispondono diversi
meccanismi di comunicazione
– Il chiamante passa informazione al chiamato
• Il chiamante passa argomenti al chiamato
• Il chiamato opera su una variabile globale visibile al chiamante
– Il chiamante riceve informazione dal chiamato
• Il chiamato restituisce un valore
• Il chiamato modifica una variabile del chiamante
• Il chiamato opera su una variabile globale visibile al chiamante
• Ulteriore esigenza:
– Evitare di copiare argomenti di grandi dimensioni nei
parametri del chiamato, se non necessario
18
19. Argomenti e parametri
• Gli argomenti fungono da inizializzatori dei
parametri di una funzione
• Notazione posizionale:
– Argomento1 parametro1, argomento2
parametro2
– Tutti gli argomenti richiesti devono essere forniti
– Il tipo di un argomento deve corrispondere a quello
del parametro, secondo le stesse regole di
inizializzazione delle variabili
• Nomenclatura alternativa:
– Parametri Parametri formali
– Argomenti Parametri attuali
19
20. Passaggio per valore
• Call by value
• Funziona come nell'inizializzazione di una
variabile
– Il valore dell'argomento (inizializer) viene
copiato nel parametro
– Modifiche del parametro NON cambiano
l'argomento
void callByValue(int i) {
i = i * 2; // NON modifica l'argomento passato
}
20
21. Passaggio per riferimento
• Call by reference
• I parametri sono di ripo reference (&)
– Il valore dell'argomento (inizializer) è un sinonimo
del parametro
– Modifiche del parametro CAMBIANO l'argomento
del chiamante
– L'argomento deve essere una variabile, non una
costante
void callByRef(int &i) {
i = i * 2; // modifica l'argomento passato del chiamante
}
21
22. Passaggio per riferimento costante
• Call by const reference
• I parametri sono di ripo const reference (const &)
– Il valore dell'argomento (inizializer) è un sinonimo del
parametro
– Il costruttore const IMPEDISCE modifiche del
parametro, come nel passaggio per copia
– Come nel passaggio per riferimento si evita di copiare
il valore del parametro
– L'argomento deve essere una variabile, non una
costante
void callByConstRef(const int &i) {
i = i * 2; // errore: non si può modifica l'argomento
}
22
23. Esempio
void callByValue(int i) {
i = i * 2;
}
void callByRef(int &i) {
i = i * 2;
}
int main() {
int j=1;
callByValue(j);
cout << "After call by value j's value is " << j << endl;
callByRef(j);
cout << "After call by reference j's value is " << j << endl;
return 0;
}
23
24. Altro esempio
void swapByValue(int p, int q) {
int temp;
temp = p;
p = q;
q = temp;
}
void swapByRef(int &p, int &q) {
int temp;
temp = p;
p = q;
q = temp;
}
int main() {
int a = 1, b = 2;
cout << "Valori iniziali: " << a << ' ' << b << endl;
swapByValue(a, b);
cout << "Valori dopo swapByValue: " << a << ' ' << b << endl;
swapByRef(a, b);
cout << "Valori dopo swapByRef: " << a << ' ' << b << endl;
return 0;
}
24
25. Funzioni vs procedure
• Esistono sottoprogrammi che restituiscono valori
(funzioni) e sottoprogrammi che non lo fanno
(procedure)
• In C++ e C è possibile scrivere un sottoprogramma
che non restituisce un valore, ma produce solo un
effetto sullo stato del programma
• Tale fatto è segnalato dal tipo di ritorno void
void error_line (int line) {
cout << "Errore alla linea" << line << endl;
}
• Il sottoprogramma viene chiamato come segue:
error_line (line_number);
• La terminazione della funzione e il ritorno del
controllo al chiamante avvengono a fine blocco }
25
26. Intercambiabilità di procedure e
funzioni
• Funzione:
• Procedura:
int f (int par1) {
/* calcola valore
di variabile “risultato”
*/
return (risultato);
}
void f (int par1, int & par2)
{
/* calcola valore di
variabile “risultato” */
par2 = risultato;
}
• chiamata:
y = f(x);
• chiamata:
f (x, y);
• y del chiamante riceve il
valore di par2 del
chiamato
27. Raccomandazioni di stile
• Per le funzioni:
– passare i parametri per copia
– usare passaggio per riferimento per parametri di grandi
dimensione, per evitare la copia
– evitare l'abuso di variabili non locali, che rendono difficile
la comprensione dei rapporti tra chiamante e chiamato
• Una funzione che abbia parametri passati
per reference e ne modifichi il valore, si dice avere
un effetto collaterale (side effect)
• Benché ammissibili, gli effetti collaterali si devono
usare con prudenza, e in generale sono
sconsigliabili quando non strettamente necessari
27
28. Parametri: pro e contro
Modi di
passaggio
per valore
("per copia")
per riferimento
per riferimento
costante
Caratteristiche
Tempo e spazio
necessari a trasferire
(copiare) i dati
grandi
(per parametri di
grandi dimensioni)
piccoli
(si copia un indirizzo,
la cui dimensione non
dipende dai dati)
piccoli
(si evita la copia, si
definisce un sinonimo
dell'argomento)
C'è rischio di
effetti collaterali
indesiderati?
No
(i parametri attuale e
formale sono distinti)
Sì
(i parametri attuale e
formale "di fatto"
coincidono)
Sì
(i parametri attuale e
formale sono
sinonimi)
Permette la
restituzione di valori
al chiamante?
No
Sì
Sì
28
29. Esempio
• Funzione per ricercare un carattere in una
stringa e restituire la prima posizione in cui
appare e il numero di occorrenze
• Progettazione della comunicazione
– Input:
• La stringa: per riferimento costante
• Il carattere da cercare: per copia
– Output :
• La posizione: valore restituito (o parametro per
riferimento)
• Numero di occorrenze: parametro per riferimento
29
30. Funzione
string::size_type find_char(const string &s, char c, string::size_type &occurs)
{
auto ret = s.size(); // position of the first occurrence, if any
occurs = 0; // set the occurrence count parameter
for (decltype(ret) i = 0; i != s.size(); ++i) {
if (s[i] == c) {
if (ret == s.size())
ret = i; // remember first occurrence of c
++occurs; // increment the occurrence count
}
}
return ret; // count is returned implicitly in occurs
}
30
31. Main
#include <iostream>
#include <string>
using namespace std;
int main() {
string someString;
string::size_type count;
cout << "Insert the string to search" << endl;
getline(cin, someString);
char c;
cout << "Insert the char to search" << endl;
cin >> c;
auto index = find_char(someString, c, count);
if (index < someString.size()) {
cout << "Character " << c << " first occurs at pos: " << index << endl;
cout << "Number of occurrences is: " << count << endl;
} else
cout << "Character not found" << endl;
return 0;
31
}
32. Utilità di void e terminazione senza
valore
• http://stackoverflow.com/questions/11560068/
• http://stackoverflow.com/questions/1610030/w
32
33. Visibilità e durata
• Tutte le variabili di un programma hanno una visibilità (scope)
e una durata (lifetime)
– Scope: porzione del programma in cui il nome è visibile
– Lifetime: tempo durante l'esecuzione in cui la variabile esiste
• Il corpo della funzione definisce un ambito di visibilità (scope)
per cui
– Le variabili dichiarate nella funzione e i parametri sono locali alla
funzione
– Variabili locali e parametri della stessa funzione devono avere
nomi diversi
– Variabili locali e parametri di funzioni diverse possono avere
nomi coincidenti
– I nomi locali mascherano eventuali nomi uguali definiti in scope
più esterni (nomi di variabili globali)
33
34. Il blocco
• E' un delimitatore esplicito sia di scope sia di
lifetime
• Può comparire ovunque la sintassi preveda
un'istruzione
• Si compone di due parti racchiuse tra { }
– una sequenza di istruzioni
– può anche contenere dichiarazioni
• Due blocchi possono essere:
– annidati (uno è interno all’altro)
– paralleli (entrambi interni a un terzo blocco, ma
non annidati tra loro)
35. int
g1, g2;
char
g3;
int f1(int par1, int
int f2(int par3, int
par2); // Prototipo di f1
par1); // Prototipo di f2
main () {
int a, b;
{ char a, c;
...
{float a;
...
}
// Fine blocco2
}
// Fine blocco1
}
// Fine main
int f1(int par1,
intd;
{ int e;
...
}
// Fine
{ int d;
...
}
// Fine
}
// Fine
int
}
int
modello “a contorni”
par2) {
blocco3
par1, par2,
blocco4
f1
f2(int par3, int
int f;
...
// Fine f2
par4) {
par3, par4,
36. Mascheramento della visibilità
• La dichiarazione di un elemento in una
funzione o in un blocco maschera le
eventuali entità omonime più “esterne”
g1,g2,g3
livello globale
a,b
main
a,c
blocco1
a,d
blocco2
d
blocco3
f1
È possibile (ma
sconsigliato)
riusare nomi di
variabili
37. Denominare le variabili locali alle
funzioni
#include <iostream>
using namespace std;
double potenza (double base, int esp) {
double ris = 1.0;
for (int i = 0; i < esp; ++i)
ris = ris * base;
return ris;
}
Le variabili locali e i
parametri di funzioni diverse
appartengono a "scope"
distinti.
Per cui possono anche
avere lo stesso nome, senza
pericolo di confusione.
Meglio però evitare tale
pratica
int main() {
float base;
cout << "Inserire un numero reale come base" << endl;
cin >> base;
int esp;
cout << "Inserire un numero reale come base" << endl;
cin >> esp;
cout << endl << base << " elevato a " << esp << " vale " << potenza(base, esp) << endl;
return 0;
}
38. Durata delle variabili (lifetime)
• Va dalla creazione (allocazione della memoria) alla
distruzione (rilascio della memoria allocata)
• Due classi di variabili
– Statiche:
• Allocate una volta per tutte
• Distrutte solo al termine dell’esecuzione del programma
• Sono tutte le variabili globali e quelle locali al main()
– Anche le variabili di funzione o blocco dichiarabili static
• Possono fungere da ulteriore canale di comunicazione tra funzioni
– Automatiche:
•
•
•
•
•
Sono quelle dichiarate nelle funzioni (inclusi i parametri) e nei blocchi
Sono create quando il flusso di esecuzione "entra" nel loro ambito di visibilità
Sono distrutte all’uscita da tale ambito
Sono allocate ad ogni esecusione in celle di memoria differenti
Non conservano i valori prodotti da precedenti esecuzioni della funzione o
del blocco
39. Oggetti locali statici
•
•
Esigenza: memorizzare informazione locale a una funzione ( o a un
blocco) che permane per tutta l'esecuzione del programma (e non
solo per una singola chiamata)
Meccanismo: variabili locali static
int conta_chiamate()
{
static int ctr = 0; // persiste dopo la chiamata
return ++ctr;
}
int main()
{
for (int i = 0; i != 10; ++i)
cout << conta_chiamate() << endl;
return 0;
}
•
Stampa numeri da 1 a 10 incluso
39
40. Modello di esecuzione
• In seguito a una chiamata a sottoprogramma,
il programma in corso viene sospeso e il controllo
passa al sottoprogramma
• Al livello dell'ambiente di esecuzione:
– Salvataggio dell'indirizzo della prossima istruzione da
eseguire (program counter, PC) e del contesto
(valori di variabili) del programma chiamante
– Assegnazione al PC dell’indirizzo del sottoprogramma
– Esecuzione del sottoprogramma
– Ritorno al programma chiamante con ripristino
del suo contesto
40
41. Record di attivazione
• Ogni sottoprogramma (incluso il main) ha
associato un record di attivazione. Contiene:
– tutti i dati relativi all’ambiente locale del
sottoprogramma
– l’indirizzo di ritorno nel programma chiamante (serve
per poter eseguire l'istruzione del chiamante
immediatamente successiva alla invocazione del
sotto-programma)
• Per ogni attivazione di sottoprogramma si
crea un nuovo record di attivazione
41
42. Perché è necessario?
• In generale, una funzione può essere chiamata un
numero imprecisato di volte
• Ogni chiamata a procedura richiede allocazione di
spazio di memoria per le sue variabili locali
– Il compilatore potrebbe “preparare” un ambiente per ogni
funzione definita? In generale no...
• Vi sono procedure che richiamano se stesse
(vedremo: ricorsione)
– Possono esistere più “istanze” di una funzione,
“addormentate” in attesa della terminazione di una
“gemella” per riprendere l’esecuzione
• In questo ultimo caso il compilatore non può sapere
quanto spazio allocare per le variabili del programma
(nei vari ambienti)
42
43. La pila (stack) di sistema
• Una porzione della memoria di lavoro, chiamata stack (pila):
modalità LIFO (Last in First Out) permette al sistema operativo
di gestire i processi e di eseguire le chiamate a sottoprogramma
• Lo Stack Pointer (puntat. alla pila) è un registro che contiene
l’indirizzo della parola di memoria da leggere nello stack
312
311
310
• Operazione di inserimento:
- incremento SP
...
- scrittura nella parola indirizzata da SP
• Operazione di estrazione:
- lettura da parola indirizzata da SP
303
- decremento SP
SP
43
312
Stack pointer = 312
45. Esempio di esecuzione
int potenza(int a,int b);
int moltiplica(int x,int y);
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
i=2
j=3
k
46. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
i=2
j=3
x=2 y=3
k
47. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
k=6
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
47
48. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
k=6
a=2 b=3 i
p=1
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
48
49. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
k=6
a=2 b=3 i=1
p=1
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
49
50. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
k=6
x=1 y=2
a=2 b=3 i=1
p=1
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
50
51. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
k=6
a=2 b=3 i=1
p=2
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
51
52. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
k=6
a=2 b=3 i=2
p=2
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
52
53. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
k=6
x=2 y=2
a=2 b=3 i=2
p=2
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
53
54. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
k=6
a=2 b=3 i=2
p=4
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
54
55. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
k=6
x=4 y=2
a=2 b=3 i=3
p=4
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
55
56. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
k=6
a=2 b=3 i=3
p=8
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
56
57. Stack
int potenza(int a,int b);
int moltiplica(int x,int y);
i=2
j=3
k=8
int main(){
int i=2,j=3,k;
k=moltiplica(i,j);
k=potenza(i,j);
}
int potenza(int a,int b){
int i, p=1;
for(i=1;i<=b;i++)
p=moltiplica(p,a);
return p;
}
int moltiplica(int x,int y){
return x*y;
}
57
58. Call stack in Eclipse
Activation record del main
Stato delle variabili
58
59. Chiamata di funzione
Call stack con funzione chiamata
Stato del chiamato, parametri
passati per copia
59
61. Struttura di un programma C++
parte dichiarativa globale
inclusione librerie /∗ per poter richiamare funzioni utili (i/o, ...) ∗/
dichiarazione di variabili e tipi globali e funzioni
int main ( ) {
parte dichiarativa locale
dichiarazione di variabili locali
istruzione 1; /∗ tutti i tipi di operazioni, e cioè: ∗/
istruzione 2;
/∗ istr. di assegnamento ∗/
istruzione 3;
/∗ istr. di input / output ∗/
istruzione 4;
/∗ istr. di controllo (condizionali, cicli) ∗/
/∗ dich. altre variabili locali ∗/
istruzione N;
}
parte esecutiva
61
62. #include <iostream>
using namespace std;
Esempio mono-file
double potenza (double base, int esp) {
double ris = 1.0;
for (int i = 0; i < esp; ++i)
ris = ris * base;
return ris;
}
definizione
di funzione
chiamata
di funzione
int main() {
float numero;
cout << "Inserire un numero reale come base" << endl;
cin >> numero;
int esponente;
cout << "Inserire un numero reale come base" << endl;
cin >> esponente;
cout << endl << numero << " elevato a " << esponente
<< " vale " << potenza(numero, esponente) << endl;
return 0;
}
Definizione di variabili
locali alla funzione
definizione
di funzione
63. #include <iostream>
using namespace std;
Esempio mono-file
double potenza (double base, int esp);
dichiarazione
di funzione
int main() {
float numero;
cout << "Inserire un numero reale come base" << endl;
cin >> numero;
int esponente;
cout << "Inserire un numero intero come exp" << endl;
cin >> esponente;
cout << endl << numero << " elevato a " << esponente
<< " vale " << potenza(numero, esponente) << endl;
return 0;
}
double potenza (double base, int esp) {
double ris = 1.0;
for (int i = 0; i < esp; ++i)
ris = ris * base;
return ris;
}
definizione
di funzione
65. Segnatura (definizione) di una
funzione
• Come per le variabili le funzioni
– devono essere dichiarate e definite prima di essere usate
– possono essere definite una volta e dichiarate più volte
– Una funzione può essere dichiarata in un file di header (.h)
per poi venir inclusa da un altro programma
• La dichiarazione avviene specificando la segnatura
(o interfaccia, prototipo) della funzione (function
header), cioè:
– tipo del risultato
– identificatore del sottoprogramma
– elenco delle dichiarazioni dei parametri formali
double potenza (double base, int esp);
66. Esempio di programma multifile
/* File contenente funzioni di utilità sui cerchi
* dichiarazione e definizione di una costante
* riusabile : pigreco.cpp */
extern const float pigreco = 3.14159265;
float area(float r){
return r*r*pigreco;
}
float perimeter(float r){
return 2*r*pigreco;
}
67. File di intestazione della libreria
/*
*
*
*
*
File contenente solo le dichiarazioni delle
funzioni di utilità sui cerchi
e della costante riusabile: pigreco.h
Usato dal compilatore per controllare la
correttezza del programma */
extern const float pigreco;
float area(float r);
float perimeter(float r);
68. Programma principale
#include <iostream>
#include "pigreco.h"
using namespace std;
int main() {
float radius;
cout << "Insert the value of the radius: " << endl;
cin >> radius;
cout << "Value of pigreco: " << pigreco << endl;
cout << "Perimeter of circle: " << perimeter(radius) <<
cout << "Area of the circle: " << area(radius) << endl;
return 0;
}
endl;
69. Esempio
• Ristrutturiamo (rifattorizziamo) il
programma di evidenziazione del testo
• Spostiamo in una funzione:
– Le lettura del file
– La stampa del testo
– La stampa degli indici di riga delle occorrenze
– L'evidenziazione del testo
69
71. Passaggio argomenti
• Per non copiare nel parametro del chiamato
argomenti di grandi dimensioni (testo, righe)
usiamo passaggio per riferimento
• Prototipi delle funzioni:
void leggitesto(vector<string> &t);
void stampatesto(vector<string> &t);
void stamparighe(vector<int> &rr);
void evidenzia(vector<string> &t, string &parola,
vector<int> &righe)
71
72. Passaggio per riferimento
costante
• Laddove
– il chiamato non modifica l'argomento ricevuto dal
chiamante, ma
– L'argomento è di dimensioni non trascurabili
• Meglio usare const &
void stampatesto(const vector<string> &t);
void stamparighe(const vector<int> &rr);
void evidenzia(vector<string> &t, const string &parola,
vector<int> &righe)
• Le funzioni così non possono modificare
l'argomento ricevuto dal chiamante
72
73. Programma principale
#include <iostream>
#include <vector>
#include <string>
#include <fstream>
using namespace std;
int main() {
vector<string> testo; // il testo vettorializzato, inizialm. vuoto
vector<int> righe;
// l'indice delle righe, inizialmente vuoto
string par;
// la parola da cercare
leggitesto(testo);
// crea tutte le righe all'inizio
cout << "Inserisci parola da ricercare" << endl;
cin >> par;
evidenzia(testo, par, righe);
stampatesto(testo);
stamparighe(righe);
return 0;
}
73
74. Parametri array
• Gli array hanno una importante differenza
rispetto agli altri tipi primitivi o costruiti:
non è definita la copia né
all'inizializzazione ne all'assegnamento
• Pertanto non si possono passare come
argomenti per copia a una funzione
• Tuttavia si possono lo stesso definire
parametri e argomenti per copia, ma
bisogna capire che cosa succede
74
75. Parametri di tipo array
void stampa(char[10]);
•Apparentemente la funzione riceve in ingresso
un array di 10 caratteri
•In realtà riceve l'indirizzo (puntatore) al primo
elemento di un array di lunghezza ignota!
•E' equivalente a
void stampa(char[]);
void stampa(char *); // vedremo in seguito
75
76. Cautele
• Se il parametro denota l'indirizzo del primo
elemento allora di solito NON va
modificato
• Meglio allora renderlo const
void stampa(const char[10]);
void stampa(const char[]);
void stampa(const char *);
76
77. Passaggio di argomenti di tipo
array
void stampaArray(const char regione[6]){
cout << regione << endl;
}
int main() {
char array1[10]="Lombardia";
char array2[6]="Lazio";
stampaArray(array1);
stampaArray(array2);
return 0;
}
•Le dimensioni del parametro vengono ignorate
•Pericoloso: se manca il terminatore dell'array il
comportamento è indefinito
•Usato spesso comunque, perché apparentemente
"flessibile"
77
79. Passaggio esplicito delle
dimensioni
• Per ovviare al pericolo di fuoriuscita, si può
aggiungere un parametro esplicito che
rappresenta le dimensioni
– E' l'unica soluzione per array non terminati da '0'
• Difetto: i due parametri sono indipendenti e il
valore delle dimensioni deve essere gestito
con cura dal programmatore
– Se la dimensione passata è maggiore di quella
reale, il comportamento del chiamato è indefinito
79
80. Stampare un array di interi
const int corto = 2;
const int lungo = 4;
void stampaArray(const int array[], int dim) {
for (int i = 0; i < dim; ++i)
cout << array[i] << endl;
}
int main() {
int arraylungo[lungo]={1,2,3,4};
int arraycorto[corto]={5,6};
stampaArray(arraylungo, lungo);
stampaArray(arraycorto, corto);
return 0;
}
80
81. Warning
• Non si stampa con cout << un array
che non sia una stringa terminata da '0'
const int lungo = 4;
int main() {
int arraylungo[lungo]={1,2,3,4};
cout << arraylungo; // errato !!
return 0;
}
81
82. Modificabilità degli array
• Gli array non si possono passare per
copia
• Il chiamato riceve l'indirizzo del primo
elemento dell'array passato come
argomento
• Pertanto il chiamato modifica direttamente
i valori dell'array del chiamante
• Da considerare con cautela
82
83. Modifica di un parametro array
const int size = 4;
void modificaInt(int i) {
i = i + 100;
}
void modificaArray(int vett[], int dim) {
for (int i = 0; i < dim; i++)
vett[i] += 100;
}
int main() {
int a = 0, v[size] = { 0, 1, 2, 3 };
cout << "Valori prima" << endl;
cout << "a = " << a << endl;
for (int i = 0; i < size; ++i)
cout << "v[" << i << "] = " << v[i] << endl;
cout << "Chiamo le funzioni..." << endl;
modificaInt(a);
modificaArray(v, 4);
cout << "Valori dopo" << endl;
cout << " a = " << a << endl;
for (int i = 0; i < size; ++i)
cout << "v[" << i << "] = " << v[i] << endl;
return 0;
}
83
84. Passaggio di array
multidimensionali
• Ricordando che una matrice è in realtà un
array di array
f(int [][maxcol], int r, int c);
• Dichiara una funzione che riceve in input
una matrice, cioè maxcol array di interi
• Tutte le dimensioni successive alla prima
fanno parte del tipo e devono essere
fissate
84
85. Esempio
void stampaMatrice(int mat[][2], int r, int c) {
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) // c è cmque fissato a 2
cout << mat[i][j] << " ";
cout << 'n';
}
}
// il secondo indice DEVE valere 2
int main() {
int matrice[2][2] = { 1, 2, 3, 4 };
int matricebis[3][2] = {5,6,7,8,9,10};
stampaMatrice(matrice, 2, 2);
cout << endl;
stampaMatrice(matricebis, 3, 2);
return 0;
}
85
86. Perché la prima dimensione è
libera?
a[0,0]
a[0,1]
a[0]
a[0,2]
a[1,0]
a[1,1]
a[1]
a[1,2]
a[3,0]
a[3,1]
a[3]
a[3,2]
…
int a [][3]
• Matrice = Array di array di interi
• Ogni valore dell'array, tranne quelli
dell'array "più esterno" deve avere una
dimensione fissa e nota
– 3 celle nel caso presente
86
87. Forme sintattiche equivalenti
• Sono definite 3 forme sintattiche diverse
per rappresentare una matrice e quindi
anche un parametro di tipo matrice
• Si capirà meglio dopo aver studiato il
costruttore di tipo puntatore (*)
• http://stackoverflow.com/questions/8767166/p
87
88. Parametri di tipo array e struct
• Un parametro di tipo struct si può passare sia
per riferimento sia per valore (anche se la struct
contiene campi di tipo array!)
• Analogamente, una funzione può restituire una
struct (anche se la struct contiene degli array)
88
