Argomento di Programmazione 1. Fatto a lezione a ottobre, deck 6.2, prima parte e parte finale: slide 4-25 (sottoprogrammi, l’esempio dei movimenti, funzioni e procedure), slide 27-72 (struttura di un programma, definizione, return, invocazione, prototipi, rand e random), slide 73-90 (modello di esecuzione, ambienti, pila), slide 132-149 (ambienti, visibilità, ciclo di vita, libreria standard). La parte centrale del deck (slide 91-131 e gli esercizi 150-154) è in Passaggio dei parametri. Prima: Puntatori. Dopo: Passaggio dei parametri.
Il filo del deck:
perché blocchi ripetuti (due cicli uguali per entrate e uscite)
|
sottoprogramma totMov(entrate) - totMov(uscite): si chiama come un'espressione
|
sintassi testata + corpo, return, prototipo, struttura del programma
|
esempi Prodotto, AreaRettangolo, razionali con mcd, random
|
esecuzione una macchina dedicata per ogni chiamata, il suo ambiente
|
pila una sola macchina, gli ambienti impilati (LIFO)
|
[passaggio dei parametri: nota a parte]
|
ambienti globale, funzione, blocco: visibilità e mascheramento
|
ciclo di vita statiche, automatiche, static
1Definizioni
Perché i sottoprogrammi (slide 4-7). Due motivi:
- blocchi di istruzioni ripetuti in parti diverse dello stesso programma: inizializzare un array, sommarne gli elementi, trovarne il massimo;
- blocchi riutilizzabili da programmi e programmatori diversi: stringhe e caratteri, calcoli matematici, input/output.
Il sottoprogramma realizza un’astrazione (incapsulamento): separa il compito da eseguire (moltiplicare due interi, stampare una variabile) dal modo in cui viene eseguito. Chi usa printf conosce l’interfaccia (“stampa la variabile d”) e non sa niente del programma che pilota la periferica. Il sottoprogramma è asservito al chiamante: lavora per lui, quando lui lo chiede.
Sottoprogramma (slide 15-20). Un pezzo di programma con un nome, che prima si definisce e poi si invoca (chiama), cioè si attiva per calcolare i risultati richiesti. Nell’esempio dei movimenti (sotto, Esempi svolti) i due cicli che sommano entrate e uscite sono identici: si scorporano in un sottoprogramma totMov e il chiamante diventa una riga sola, utile = totMov(entrate) - totMov(uscite);.
Funzione e procedura (slide 25, slide 114). In C ci sono due tipi di sottoprogrammi:
- funzione: restituisce un valore al chiamante, come una funzione matematica ( applicata a 3 vale 9);
- procedura: svolge un compito per il chiamante ma non restituisce un valore. Si scrive come una funzione con tipo di ritorno
void, un tipo che non corrisponde a nessun valore e serve solo a rispettare la sintassi. Esempi: stampare un elenco di fatture, ordinare un array, leggere una tabella.
Definizione di una funzione (slide 29-32, slide 55). È composta da:
- una testata (header), con le informazioni per usarla correttamente: il tipo del risultato (il “codominio”), l’identificatore della funzione, la lista dei parametri formali con il loro tipo (il “dominio”);
- un blocco, il corpo (body), a sua volta diviso in parte dichiarativa locale (le variabili che servono all’esecuzione) e parte esecutiva (le istruzioni).
tipo di nome parametri formali
ritorno | |
| | ________|________
int power (int base, int n) { testata
int i, p=1; parte dichiarativa locale
for(i=1; i<=n; i++) .
{p*=base;} parte esecutiva
return p; .
}
power(base, n) calcola moltiplicando p per base volte.
Variabili locali (slide 59). Le variabili della parte dichiarativa locale (i e p in power) seguono le stesse regole della parte dichiarativa di main. Esistono solo durante la chiamata e sono visibili solo dentro la funzione.
Invocazione (slide 21, slide 56). La sintassi viene dalla matematica: una funzione applicata ai suoi argomenti fornisce un valore del suo codominio.
id_funzione(lista dei parametri effettivi)
L’invocazione è un’espressione: viene valutata e poi sostituita dal valore generato dall’esecuzione del sottoprogramma. Quindi si può mettere ovunque va un valore: a destra di un’assegnazione, dentro un printf, come argomento di un’altra funzione. Ogni parametro effettivo è a sua volta un’espressione e può contenere un’altra chiamata (slide 60):
x = sin(y) - cos(pi - alfa);
x = cos(atan(y) - beta);
risultatoDiGestione = fatturatoTotale(archivioFatture) - sommaCosti(archivioCosti);
Parametri formali ed effettivi (slide 58).
- Parametri formali: gli argomenti elencati nella testata (
baseeninint power(int base, int n)). Sono nomi segnaposto. - Parametri effettivi: i valori con cui la funzione viene invocata (
2eiinpower(2, i)). - All’atto dell’invocazione i parametri formali vengono inizializzati con i valori dei parametri effettivi, nell’ordine: il primo effettivo va nel primo formale, il secondo nel secondo. I nomi non contano: in
power(3, i)il valore diifinisce inn.
int power(int base, int n); parametri formali: base, n
printf("%d %d %d\n", i, power(2,i), power(3,i)); parametri effettivi: 2 e i, 3 e i
Ritorno al chiamante (slide 50). Tre modi per restituire il controllo:
- la funzione non restituisce niente (per esempio stampa un array) e l’esecuzione arriva alla
}che chiude il corpo; - la funzione esegue
return;; - la funzione esegue
return espressione;.
return (slide 52-53). In return x+y; il valore dell’espressione diventa il risultato della funzione: visto dal chiamante, è il valore della funzione in corrispondenza dei parametri di ingresso. L’istruzione termina subito il sottoprogramma e restituisce il controllo al chiamante: le istruzioni dopo non vengono eseguite. Nel corpo ci possono essere più return, e se ne esegue uno solo, quello che il flusso incontra per primo. Se in una funzione non void non se ne esegue nessuno, la funzione termina alla } e il risultato è indefinito: gcc con -Wall avvisa control reaches end of non-void function (verificato).
Il tipo del risultato (slide 51).
- Può essere un tipo predefinito (
int,float, …) o definito dall’utente (unastruct, comeRazionalesotto). - Non può essere un array (
int []). - Può essere un puntatore a qualsiasi tipo.
- Si restituisce un solo valore. Per restituirne di più si usano i parametri per indirizzo (Passaggio dei parametri) o una
struct.
main (slide 28, slide 54). main è di fatto una funzione particolare: quella da cui parte l’esecuzione. Ha tipo di ritorno int e il valore restituito indica l’esito del programma a chi l’ha lanciato (la shell): return 0 vuol dire terminato con successo. Se manca, lo standard restituisce implicitamente 0. Il significato dei valori diversi da 0 dipende dall’ambiente chiamante.
Definizione e dichiarazione (prototipo) (slide 62-64). Una funzione si può invocare solo se prima è stata definita o dichiarata: il compilatore deve conoscerne tipi e parametri per controllare che la chiamata sia corretta. Le due parole non sono sinonimi:
- la definizione comprende testata e corpo;
- la dichiarazione, o prototipo, comprende soltanto la testata, seguita da
;.
int power(int base, int n); prototipo: solo testata e ;
int power(int base, int n) { ... } definizione: testata e corpo
Il prototipo si mette nella parte dichiarativa globale, prima delle chiamate; la definizione può venire dopo l’invocazione o stare in un altro file (è quello che si fa con dati.h e dati.cpp all’esame). Le prime versioni del C (K&R) non chiedevano i tipi degli argomenti e non controllavano i parametri; il C moderno ha preso dal C++ il controllo dei tipi su prototipo e definizione (slide 63). Nel prototipo i nomi dei parametri sono facoltativi (int power(int, int); va bene), i tipi no.
Struttura di un programma C (slide 27-28, slide 33). In ordine:
- direttive al precompilatore (
#include,#define, …); - dichiarazioni degli elementi condivisi da tutto il programma (
maine sottoprogrammi): costanti, tipi, variabili globali, prototipi; - definizioni dei sottoprogrammi, cominciando da
main.
Ambiente (slide 86). La memoria della macchina dedicata a una chiamata. Contiene:
- le variabili locali;
- i parametri, trattati come variabili locali inizializzate all’atto della chiamata;
- il risultato.
Viene rilasciato al termine dell’esecuzione della funzione. Si chiama anche record di attivazione: un record per ogni chiamata in corso.
Pila (stack) (slide 89-90). In pratica CPU e memoria sono uniche, quindi tutti gli ambienti sono gestiti da una sola macchina nella memoria centrale, organizzata a pila: struttura dati LIFO (Last In First Out), l’ultimo entrato è il primo a uscire.
- L’invocazione di una funzione alloca nuova memoria in cima alla pila.
- La stessa macchina esegue il sottoprogramma usando i dati in cima.
- Quando il sottoprogramma termina, il suo ambiente viene rimosso dalla pila e la memoria recuperata.
Ambienti di un programma (slide 132-133). Un ambiente è definito dal perimetro sintattico:
- dell’intero programma (ambiente globale, esterno a tutte le macchine:
maine le altre funzioni ci accedono); - di una funzione;
- di un blocco
{ }.
Blocco (slide 138). Può comparire ovunque la sintassi consenta un’istruzione ed è fatto di una parte dichiarativa (facoltativa) e di una sequenza di istruzioni, fra graffe. Due blocchi sono annidati se uno è dentro l’altro, paralleli se sono tutti e due dentro un terzo blocco ma non uno dentro l’altro.
Visibile (slide 142). Un identificatore (variabile, sottoprogramma) è visibile in un punto se lì si può denotare con il suo nome: valutarlo in un’espressione, usarlo a sinistra di un’assegnazione.
Regole di visibilità (slide 143-144).
- Gli identificatori della parte dichiarativa globale sono visibili da tutte le funzioni (
maine procedure comprese) e da tutti i blocchi. Gli identificatori predefiniti del linguaggio si considerano dichiarati lì. - Le variabili della parte dichiarativa locale a una funzione sono visibili dalle istruzioni del suo corpo, blocchi interni compresi.
- Le variabili dichiarate in un blocco sono visibili nel blocco e nei blocchi interni.
- Mascheramento (deroga): una dichiarazione in un blocco maschera le entità omonime esterne al blocco. Dentro il blocco il nome indica la variabile più interna.
Ciclo di vita (slide 145-148). Va dalla creazione (allocazione della memoria) alla distruzione (rilascio). Due classi:
- statiche: allocate una sola volta e distrutte al termine del programma. Lo sono le globali, che fanno da canale di comunicazione fra funzioni. Anche una variabile di funzione o di blocco può essere dichiarata
static: allora persiste fra una chiamata e l’altra. - dinamiche: create e distrutte durante l’esecuzione, implicitamente dal sistema (automatiche) o esplicitamente dal programmatore con appositi costrutti (
malloc/new, più avanti nel corso).
Le variabili automatiche sono quelle dichiarate nelle funzioni (parametri compresi) e nei blocchi: create quando il flusso entra nel loro ambito, distrutte all’uscita. Se la funzione o il blocco viene eseguito più volte, ogni volta sono allocate in un ambiente nuovo: i valori delle esecuzioni precedenti non si conservano.
Effetto collaterale (side effect, slide 134). Una funzione che modifica una variabile globale (o una variabile del chiamante tramite un puntatore) ha un effetto che non resta confinato nel suo ambiente e può interessare variabili usate da altre funzioni. Per questo le variabili globali sono sconsigliate, o vanno giustificate.
Libreria standard (slide 149). Funzioni predefinite per gli usi comuni: ingresso/uscita (stdio.h), stringhe (string.h), matematica (math.h), memoria, caratteri (ctype.h), ordinamento e ricerca e numeri casuali (stdlib.h), comunicazione con il sistema operativo. Si usano includendo l’header, che contiene i loro prototipi.
2Concetti
2.1Una chiamata, passo per passo
Il modello del prof (slide 83): immaginiamo una macchina dedicata a main; quando main invoca una funzione, viene creata un’altra macchina dedicata a lei, con la sua memoria, e così per ogni invocazione. In realtà la macchina è una sola e le memorie sono record impilati, ma i passi sono questi:
chiamata f(e1, e2)
1. il chiamante valuta i parametri effettivi e1, e2 (valori)
2. si crea il record di f in cima alla pila
3. i parametri formali di f prendono quei valori (copia)
4. si esegue il corpo di f, che vede solo il suo record e le globali
5. return v: il valore v torna al chiamante, il record di f si elimina
6. nel chiamante l'espressione f(e1, e2) è sostituita da v
Esempio 1, una chiamata sola: power(2, 3).
| passo | record di main | record di power | nota |
|---|---|---|---|
| chiamata | i = 3 | base = 2, n = 3, i = ?, p = 1 | i formali prendono 2 e 3 |
i = 1, p *= base | i = 1, p = 2 | ||
i = 2, p *= base | i = 2, p = 4 | ||
i = 3, p *= base | i = 3, p = 8 | ||
i = 4, 4 <= 3 falso | i = 4, p = 8 | esce dal for | |
return p; | riceve 8 | eliminato |
Il record di power ha la sua i, che non ha niente a che fare con la i di main: due variabili diverse con lo stesso nome, in due ambienti diversi. La i di main resta 3. Il programma completo della slide 58:
#include <stdio.h>
int power(int base, int n)
{
int i;
int p = 1;
for (i = 1; i <= n; i++) {
p *= base;
}
return p;
}
int main(void)
{
int i;
for (i = 0; i <= 4; i++) {
printf("%d %d %d\n", i, power(2, i), power(3, i));
}
return 0;
}
Output (verificato):
0 1 1
1 2 3
2 4 9
3 8 27
4 16 81
Con n = 0 il for non esegue nessun giro e p resta 1: , come deve essere.
Esempio 2, una funzione che ne chiama un’altra:
#include <stdio.h>
int quadrato(int n)
{
int q;
q = n * n;
return q;
}
int somma_quadrati(int a, int b)
{
int s;
s = quadrato(a);
s = s + quadrato(b);
return s;
}
int main(void)
{
int x = 3;
int r;
r = somma_quadrati(x, x + 1);
printf("r=%d\n", r);
return 0;
}
La pila, dal basso (il primo record) verso l’alto:
| istante | pila | nota |
|---|---|---|
| prima della chiamata | main: x = 3, r = ? | |
somma_quadrati(x, x + 1) | main | somma_quadrati: a = 3, b = 4, s = ? | x + 1 si valuta prima: 4 |
quadrato(a) | main | somma_quadrati | quadrato: n = 3, q = 9 | tre record |
| ritorno | main | somma_quadrati: s = 9 | quadrato eliminato |
quadrato(b) | main | somma_quadrati | quadrato: n = 4, q = 16 | record nuovo, q riparte da ? |
| ritorno | main | somma_quadrati: s = 9 + 16 = 25 | |
| ritorno | main: r = 25 |
Output: r=25 (verificato). La seconda chiamata di quadrato non trova niente della prima: il suo record è stato eliminato e ricreato da zero.
2.2La pila delle chiamate
(slide 84-90) La funzione che chiama non sa come la chiamata svolge il suo compito, e neanche se a sua volta chiama altre funzioni: lo nasconde. Le chiamate formano un albero (Fun0 chiama Fun0.1 e Fun0.2, Fun0.1 chiama Fun0.1.1 e Fun0.1.2…), e ogni nodo ha il suo ambiente con le sue variabili (nella slide 85 Fun0 e Fun0.1.1 hanno tutte e due una int i, che sono variabili diverse). In ogni istante però è in esecuzione un ramo solo, dalla radice alla chiamata corrente: è quello che sta nella pila.
La figura è l’esempio delle slide 87-90 (sotto, Esempi svolti): main chiama f2, f2 chiama f1, f1 restituisce 0, f2 lo stampa. La variabile globale x sta fuori dalla pila, nell’ambiente globale, ed esiste per tutto il programma.
Perché una pila e non un’area fissa per funzione: l’ultima funzione chiamata è sempre la prima a finire (una funzione non può terminare prima di quelle che ha chiamato). Quindi gli ambienti si liberano nell’ordine inverso a quello di creazione, che è esattamente il LIFO. In più la stessa funzione può essere attiva più volte insieme (la ricorsione, più avanti nel corso), e ogni attivazione ha bisogno del suo record.
2.3I parametri sono variabili locali
Il parametro formale è una variabile locale come le altre, solo inizializzata con il valore del parametro effettivo. La si può modificare, e la modifica resta nel record della funzione. Il prof lo usa per risparmiare una variabile in power (slide 111-113): invece di contare con i fino a n, si conta all’indietro direttamente su n.
#include <stdio.h>
int power(int base, int n)
{
int p;
for (p = 1; n > 0; n--) {
p *= base;
}
return p;
}
int main(void)
{
int n = 3;
printf("%d\n", power(2, n));
printf("n=%d\n", n);
return 0;
}
| istruzione | n di main | n di power | p |
|---|---|---|---|
chiamata power(2, n) | 3 | 3 (copia) | ? |
p = 1, 3 > 0 | 3 | 3 | 1 |
p *= base, n-- | 3 | 2 | 2 |
p *= base, n-- | 3 | 1 | 4 |
p *= base, n-- | 3 | 0 | 8 |
0 > 0 falso, return p | 3 | eliminata | 8 |
Output: 8, poi n=3 (verificato). Il n-- di power agisce sulla copia: la n di main non cambia. È il passaggio per valore, l’unico che il C conosce; come si fa a far modificare a una funzione una variabile del chiamante è l’argomento di Passaggio dei parametri.
2.4return e il flusso
Esempio 1, più return, ne viene eseguito uno solo:
#include <stdio.h>
int segno(int x)
{
if (x > 0) {
return 1;
}
if (x < 0) {
return -1;
}
return 0;
}
void stampa_se_pari(int n)
{
if (n % 2 != 0) {
return;
}
printf("%d e' pari\n", n);
}
int main(void)
{
printf("%d %d %d\n", segno(-4), segno(0), segno(9));
stampa_se_pari(3);
stampa_se_pari(8);
return 0;
}
Output (verificato):
-1 0 1
8 e' pari
segno(-4):-4 > 0falso,-4 < 0vero,return -1: la funzione finisce lì,return 0non viene raggiunto.segno(0): falso, falso, si arriva areturn 0.stampa_se_pari(3):3 % 2vale 1, diverso da 0,return;esce dalla procedura senza stampare. Con 8 si arriva alprintf.
Esempio 2, il return che manca. Se segno non avesse l’ultimo return 0;, con x = 0 la funzione arriverebbe alla } senza restituire niente e il chiamante leggerebbe un valore indefinito (qualsiasi cosa ci sia in quel momento nel registro o nella cella del risultato). gcc lo segnala con -Wall (control reaches end of non-void function), ma compila lo stesso. Regola: in una funzione non void ogni strada deve finire in un return.
2.5Prototipi e ordine delle funzioni
Il compilatore legge il file dall’alto in basso. Se main chiama doppio(4) e doppio è definita dopo, senza prototipo, al punto della chiamata il compilatore non sa che tipo ha. Nel C K&R si supponeva int senza controlli; dal C99 è vietato e gcc 16 si ferma con error: implicit declaration of function 'doppio' (verificato). Due soluzioni equivalenti:
soluzione 1: definire prima di usare soluzione 2: prototipo in cima
int doppio(int n) { return 2 * n; } int doppio(int n);
int main(void) { ... doppio(4) ... } int main(void) { ... doppio(4) ... }
int doppio(int n) { return 2 * n; }
Il prof usa la seconda (prototipi in cima, main subito dopo, definizioni in fondo): si legge prima il programma principale e poi i dettagli, ed è la forma dell’esame, dove i prototipi stanno in dati.h.
Il prototipo deve coincidere con la definizione nei tipi: con int f(int a); in cima e int f(float a) { ... } in fondo gcc dà conflicting types for 'f'.
2.6Visibilità e mascheramento
La figura è l’esempio della slide 139 (sotto, Esempi svolti). Per sapere a quale variabile si riferisce un nome in un punto del programma si guarda dall’interno verso l’esterno: prima il blocco in cui ti trovi, poi quello che lo contiene, poi la funzione, poi il globale. La prima dichiarazione che trovi vince, e quelle più esterne con lo stesso nome sono mascherate.
Esempio 1, lo stesso nome a quattro livelli:
#include <stdio.h>
int a = 1;
void f(int a)
{
printf("f: a=%d\n", a);
a = 50;
{
int a = 7;
printf("blocco in f: a=%d\n", a);
}
printf("f dopo il blocco: a=%d\n", a);
}
int main(void)
{
printf("main: a=%d\n", a);
{
int a = 2;
printf("blocco: a=%d\n", a);
f(a + 10);
printf("blocco dopo f: a=%d\n", a);
}
printf("main dopo il blocco: a=%d\n", a);
return 0;
}
| punto | quale a | valore |
|---|---|---|
primo printf di main | globale (nessuna a locale ancora) | 1 |
nel blocco di main | a del blocco, maschera la globale | 2 |
f(a + 10) | si valuta a + 10 nel chiamante: 2 + 10 | parametro = 12 |
primo printf di f | parametro a di f, maschera la globale | 12 |
a = 50; | parametro di f | 50 |
blocco in f | a del blocco, maschera il parametro | 7 |
dopo il blocco in f | di nuovo il parametro, il 7 è sparito | 50 |
tornati nel blocco di main | a del blocco, f non l’ha toccata | 2 |
fuori dal blocco di main | globale, mai modificata | 1 |
Output (verificato):
main: a=1
blocco: a=2
f: a=12
blocco in f: a=7
f dopo il blocco: a=50
blocco dopo f: a=2
main dopo il blocco: a=1
Nota: f non vede la a del blocco di main, perché la visibilità è sintattica (dipende da dove è scritto il codice) e il corpo di f sta fuori da main. f vede solo i suoi nomi e quelli globali.
Esempio 2, la globale modificata da una funzione, l’effetto collaterale della slide 135:
#include <stdio.h>
int x = 1;
int fun(int par)
{
return par + x;
}
int main(void)
{
x = fun(1);
printf("x=%d\n", x);
x = fun(1);
printf("x=%d\n", x);
return 0;
}
| istruzione | par | x globale | risultato |
|---|---|---|---|
| inizio | 1 | ||
x = fun(1); | 1 | 1 | 1 + 1 = 2, poi x = 2 |
x = fun(1); | 1 | 2 | 1 + 2 = 3, poi x = 3 |
Output: x=2, x=3 (verificato). La stessa chiamata fun(1) dà due risultati diversi: dipende da una variabile che non sta fra i suoi parametri. È il motivo per cui il prof sconsiglia le globali: per capire cosa fa fun non basta guardare la chiamata.
2.7Automatiche e static
Una variabile locale normale (automatica) nasce a ogni chiamata e muore al ritorno. Una variabile locale static nasce una volta sola, all’avvio del programma, e conserva il valore fra una chiamata e l’altra; resta però visibile solo dentro la funzione.
#include <stdio.h>
int conta_auto(void)
{
int n = 0;
n++;
return n;
}
int conta_static(void)
{
static int n = 0;
n++;
return n;
}
int main(void)
{
int i;
for (i = 0; i < 3; i++) {
printf("%d %d\n", conta_auto(), conta_static());
}
return 0;
}
| giro | n di conta_auto | n di conta_static |
|---|---|---|
| 1 | creata a 0, diventa 1, distrutta | inizializzata a 0 all’avvio, diventa 1 |
| 2 | creata a 0, diventa 1, distrutta | era 1, diventa 2 |
| 3 | creata a 0, diventa 1, distrutta | era 2, diventa 3 |
Output (verificato):
1 1
1 2
1 3
L’inizializzazione static int n = 0; avviene una volta sola, non a ogni chiamata: è il punto che inganna. Le due funzioni sono chiamate dentro lo stesso printf; qui l’ordine in cui il C valuta gli argomenti non cambia niente, perché le due funzioni non toccano variabili comuni.
2.8Funzioni di libreria: rand e math.h
rand (slide 65), da stdlib.h, restituisce un intero pseudocasuale fra 0 e RAND_MAX (2147483647 con gcc su Linux, 32767 con Dev-C++ su Windows). Per un intero fra min e max compresi:
num = rand() % (max - min + 1) + min;
rand() % (max - min + 1) è un resto, quindi sta fra 0 e max - min; sommando min si va da min a max. Con min = 0 e max = 10: resto fra 0 e 10, num fra 0 e 10. Con min = 1 e max = 6 (un dado): resto fra 0 e 5, num fra 1 e 6.
srand (slide 72) imposta il seme da cui rand parte. Senza srand, ogni esecuzione produce la stessa sequenza. Con srand((unsigned) time(&t)); (serve time.h) il seme è l’ora corrente e la sequenza cambia a ogni esecuzione. Va chiamata una volta, in main, non dentro la funzione che genera i numeri: chiamata a ogni numero, con l’ora che cambia una volta al secondo, ridarebbe sempre lo stesso valore.
math.h (slide 61): sqrt(x), cbrt(x) (solo C99 e C11), exp(x), log(x) (base ), log10(x), fabs(x), ceil(x) (il più piccolo intero non minore di ), floor(x) (il più grande intero non maggiore di ), pow(x, y) (), fmod(x, y) (resto di in virgola mobile), sin(x), cos(x) (radianti). Lavorano in double; esistono versioni float e long double. Esempio verificato: sqrt(2.0) = 1.4142, pow(2.0, 10.0) = 1024.0, floor(-2.5) = -3.0, ceil(-2.5) = -2.0. Su Linux con gcc va aggiunta l’opzione -lm per collegare la libreria matematica, altrimenti il linker si ferma (ld returned 1 exit status, verificato); Dev-C++ e onlinegdb la collegano da soli.
3Metodo
Tracciare un programma con funzioni.
- Parti da
main. Tieni una colonna (o un riquadro) per ogni record attivo, più uno per le globali. - A ogni chiamata: valuta i parametri effettivi nel chiamante, apri un record nuovo in cima, copia i valori nei parametri formali per posizione, metti
?nelle locali non inizializzate (lestaticinvece hanno il valore rimasto dalla volta prima). - Dentro la funzione, ogni nome si cerca dall’interno: blocco, funzione, globale. Se una locale ha lo stesso nome di una globale, la globale non si tocca.
- Al
return v: scrivival posto della chiamata nel chiamante, cancella il record. Se la funzione èvoid, la chiamata non ha valore. - Alla fine controlla le variabili del chiamante: sono cambiate solo quelle assegnate nel chiamante stesso, le globali, e quelle passate per indirizzo.
Scrivere una funzione.
- Cosa entra (parametri, con il tipo) e cosa esce (tipo di ritorno, o
voidse non esce niente). - Un nome che dice cosa fa:
somma_cifre,max3,stampaDato. - Prototipo in cima (o in
dati.h), definizione in fondo (o indati.cpp). - Il corpo lavora solo sui parametri e sulle sue locali: niente
scanfoprintfdentro una funzione di calcolo, a meno che il testo lo chieda (stampaX,newX). - Ogni strada finisce in un
returndel tipo giusto. - Prova la funzione con un caso normale e con i casi limite (0, negativo, array vuoto).
4Esempi svolti a lezione
Gestione dei movimenti di un’azienda (slide 9-24). Una struct uscite contiene il numero di movimenti e un array dati di voci, ognuna con nome, data e importo: affitto 500.0, bancomat 250.0, regalo 150.0. Una struct entrate con la stessa forma: fattura 1 300.0, fattura 2 550.0, altro 100.0. Si accede con uscite.dati[0].nome, uscite.dati[0].importo (dot notation e array di struct come in Struct, typedef ed enum).
Il codice senza funzioni (slide 13):
int i;
float totEntrate, totUscite, utile;
totEntrate = 0;
for(i=0; i<entrate.numMovimenti; i++) {
totEntrate += entrate.dati[i].importo;
}
totUscite = 0;
for(i=0; i<uscite.numMovimenti; i++) {
totUscite += uscite.dati[i].importo;
}
utile = totEntrate - totUscite;
I due cicli sono praticamente identici: cambia solo la struct su cui lavorano (slide 15). Il ciclo si scorpora nella funzione totMov (slide 23), che riceve un elenco qualsiasi e ne restituisce il totale; il chiamante diventa utile = totMov(entrate) - totMov(uscite);. Il programma completo (la slide non definisce il tipo ElencoMovimenti né la data: qui la data è giorno, mese, anno):
#include <stdio.h>
#define MAXMOV 10
typedef struct {
char nome[20];
int giorno;
int mese;
int anno;
float importo;
} Movimento;
typedef struct {
int numMovimenti;
Movimento dati[MAXMOV];
} ElencoMovimenti;
float totMov(ElencoMovimenti mov)
{
int i;
float totale = 0;
for (i = 0; i < mov.numMovimenti; i++) {
totale += mov.dati[i].importo;
}
return totale;
}
int main(void)
{
ElencoMovimenti uscite = {3, {{"affitto", 10, 10, 2007, 500.0f},
{"bancomat", 11, 10, 2007, 250.0f},
{"regalo", 15, 10, 2007, 150.0f}}};
ElencoMovimenti entrate = {3, {{"fattura 1", 10, 10, 2007, 300.0f},
{"fattura 2", 11, 10, 2007, 550.0f},
{"altro", 15, 10, 2007, 100.0f}}};
float utile;
printf("entrate %.1f\n", totMov(entrate));
printf("uscite %.1f\n", totMov(uscite));
utile = totMov(entrate) - totMov(uscite);
printf("utile %.1f\n", utile);
return 0;
}
Come si valuta totMov(entrate) (slide 24): al parametro formale mov si sostituisce il parametro effettivo entrate (se ne fa una copia), si esegue il corpo, e totale è restituito come risultato. Poi totMov(uscite) allo stesso modo.
| chiamata | mov.numMovimenti | totale dopo ogni giro | risultato |
|---|---|---|---|
totMov(entrate) | 3 | 300, 850, 950 | 950.0 |
totMov(uscite) | 3 | 500, 750, 900 | 900.0 |
utile = 950.0 - 900.0 = 50.0. Output (verificato): entrate 950.0, uscite 900.0, utile 50.0.
Prodotto di due interi (slide 35-36). Esercizio: scrivere una funzione dedicata Prodotto. La soluzione della slide definisce la funzione prima di main (con il commento “riscrivi con testata + definizione dopo main”):
#include <stdio.h>
int Prodotto(int a, int b)
{
return a * b;
}
int main(void)
{
int a = 5;
int b = 10;
printf("a= %d, b=%d\n", a, b);
printf("Prodotto(%d,%d) è: %d\n", a, b, Prodotto(a, b));
return 0;
}
Output (verificato): a= 5, b=10 e Prodotto(5,10) è: 50. I parametri formali si chiamano a e b come le variabili di main, ma sono variabili diverse nel record di Prodotto. La domanda della slide, Prodotto(b,a) ?: il valore di b (10) va nel primo formale a e quello di a (5) nel secondo; il risultato è sempre 50, perché la moltiplicazione è commutativa. Con una funzione non simmetrica, per esempio power(b, a) al posto di power(a, b), cambierebbe tutto: invece di . Conta la posizione, non il nome.
La versione “con testata + definizione dopo main” chiesta dal commento è quella della slide 33: prototipo int Prodotto(int a, int b); in cima, main, poi la definizione.
Area di un rettangolo con una struct (slide 37-38).
#include <stdio.h>
typedef struct {
float base;
float altezza;
} Rettangolo;
float AreaRettangolo(Rettangolo r)
{
return r.base * r.altezza;
}
int main(void)
{
Rettangolo R = {5, 10};
printf("R->base: %.1f; R->altezza: %.1f\n", R.base, R.altezza);
printf("Area del rettangolo è: %.1f\n", AreaRettangolo(R));
return 0;
}
Output (verificato): R->base: 5.0; R->altezza: 10.0 e Area del rettangolo è: 50.0. Una struct si passa come un intero: alla chiamata r diventa una copia di R, con tutti i campi. La stringa del printf scrive R->base ma il codice usa R.base: R è una struct, non un puntatore, quindi il punto è giusto e la freccia è solo testo stampato.
Moltiplicazione di due razionali (slide 39-46). Moltiplicare due frazioni e semplificare il risultato con il MCD. I razionali si rappresentano con una struct (numeratore, denominatore); il MCD è quello per sottrazioni successive già visto in Ciclo while ed esempi, ora chiuso in una funzione mcd. Il programma completo della slide 46, con e , riscritto con le graffe e int main(void), più la funzione prodotto delle slide 47-49 che chiude tutto il calcolo in una funzione che restituisce una struct:
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int numeratore;
int denominatore;
} Razionale;
int mcd(int x, int y)
{
while (x != y) {
if (x > y) {
x -= y;
} else {
y -= x;
}
}
return x;
}
Razionale prodotto(Razionale p, Razionale q)
{
Razionale r;
int div;
r.numeratore = p.numeratore * q.numeratore;
r.denominatore = p.denominatore * q.denominatore;
div = mcd(abs(r.numeratore), abs(r.denominatore));
r.numeratore /= div;
r.denominatore /= div;
return r;
}
int main(void)
{
Razionale p = {3, 4};
Razionale q = {6, 9};
Razionale r;
int div;
printf("Prima Frazione: %d/%d\n", p.numeratore, p.denominatore);
printf("Seconda Frazione: %d/%d\n", q.numeratore, q.denominatore);
r.numeratore = p.numeratore * q.numeratore;
r.denominatore = p.denominatore * q.denominatore;
div = mcd(r.numeratore, r.denominatore);
printf("Il prodotto originale era: %d/%d\n", r.numeratore, r.denominatore);
printf("Che semplificato diventa: %d/%d\n", r.numeratore / div, r.denominatore / div);
r = prodotto(p, q);
printf("Con la funzione prodotto: %d/%d\n", r.numeratore, r.denominatore);
return 0;
}
Tracing della chiamata mcd(18, 36):
| giro | x | y | x != y | ramo |
|---|---|---|---|---|
| inizio | 18 | 36 | vero | 18 > 36 falso: y -= x |
| 1 | 18 | 18 | falso | esce, return 18 |
Poi 18/18 = 1 e 36/18 = 2. Output (verificato):
Prima Frazione: 3/4
Seconda Frazione: 6/9
Il prodotto originale era: 18/36
Che semplificato diventa: 1/2
Con la funzione prodotto: 1/2
Nella funzione prodotto (slide 48) il prof passa a mcd i valori assoluti con abs (da stdlib.h): il MCD per sottrazioni con un numero negativo non termina mai (con e si sottrae da e cresce all’infinito). Con un numeratore 0 il ciclo non termina neanche con abs (: y -= 0 lascia tutto com’è); se il programma deve accettare 0 il caso va gestito prima, per esempio con if (r.numeratore == 0). La slide 47 osserva che prodotto ha comunque bisogno delle definizioni di Razionale e di mcd prima di lei; la slide 49 lascia per casa di aggiungerla al programma, ed è la versione qui sopra.
Funzione random (slide 66-72). La formula con rand è ostica da ricordare e serve spesso negli esercizi: conviene incapsularla in una funzione con gli estremi come parametri, così il codice diventa più facile da scrivere e da capire. Per riempire un vettore di 20 numeri casuali fra 0 e 10 basta array[i] = random(0,10);. La valutazione di random(0,10) (slide 69) sostituisce ai formali min e max gli effettivi 0 e 10, calcola rand()%(10-0+1)+0 e restituisce il valore, per esempio 5: la riga diventa array[i] = 5;.
Versione 1 della slide 71, così com’è (stampa 10 numeri fra 0 e 10 e il valore di RAND_MAX):
#include <stdio.h>
#include <stdlib.h>
int random( int min , int max);//Prototipo: Dichiarazione
//della funzione
int main(int argc, char *argv[])
{
int min=0, max=10;
for(int i = 0 ; i < 10 ; i++ )
printf("%d\n", random(min,max));
printf("RAND_MAX = %d\n",RAND_MAX);
return 0;
}
int random( int min , int max){ //Definizione della funzione
return rand() % (max-min+1)+min;
}
La versione 2 (slide 72) aggiunge #include <time.h>, la variabile time_t t; e, prima del ciclo, srand((unsigned) time(&t));, con i commenti del prof: “1) se non invocata questa funzione, verrà usato lo stesso seme ⇒ stessa sequenza random; 2) srand va invocata qui e non all’interno della funzione random”. La riscrivo compilabile con il nome casuale (motivo sotto):
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int casuale(int min, int max);
int main(void)
{
time_t t;
int min = 0;
int max = 10;
srand((unsigned) time(&t));
for (int i = 0; i < 5; i++) {
printf("%d\n", casuale(min, max));
}
return 0;
}
int casuale(int min, int max)
{
return rand() % (max - min + 1) + min;
}
Stampa 5 numeri fra 0 e 10, diversi a ogni esecuzione (provato più volte). Il commento della slide 71 “random genera un numero casuale tra 0 e min” è sbagliato: genera un numero fra min e max.
Chi chiama chi: f1 e f2 (slide 75-78, slide 87-90). Cosa viene stampato?
int x=0;
int f1(int p);
void f2();
main(){
f2();
}
int f1(int p){
return p+x;
}
void f2(){
printf("%d",f1(x));
}
In C compilabile (tipo di main, virgolette dritte, void nella lista vuota):
#include <stdio.h>
int x = 0;
int f1(int p);
void f2(void);
int main(void)
{
f2();
return 0;
}
int f1(int p)
{
return p + x;
}
void f2(void)
{
printf("%d", f1(x));
}
| passo | pila (dal basso) | globale x | cosa succede |
|---|---|---|---|
| 1 | main | 0 | |
| 2 | main | f2 | 0 | main chiama f2(), senza parametri |
| 3 | main | f2 | f1: p = 0 | 0 | f2 valuta f1(x): x vale 0, p prende 0 |
| 4 | main | f2 | f1: p = 0 | 0 | return p + x = 0 + 0 = 0 |
| 5 | main | f2 | 0 | f1 eliminato, printf("%d", 0) stampa 0 |
| 6 | main | 0 | f2 termina alla } (procedura) |
Output: 0 (verificato), come nella slide 78. I prototipi in cima servono perché main chiama f2 prima della sua definizione e f2 chiama f1 (che qui è definita prima di f2, ma con il prototipo l’ordine delle definizioni non conta più). Le slide 88-90 disegnano proprio la pila del passo 3: ambiente di main in fondo, sopra quello di f2, in cima quello di f1. La figura della sezione La pila delle chiamate è questa sequenza.
L’albero delle chiamate (slide 84-85). Fun0 chiama Fun0.1 e Fun0.2; Fun0.1 chiama Fun0.1.1 e Fun0.1.2; Fun0.2 chiama Fun0.2.1. Ogni funzione ha il suo ambiente: Fun0 ha int i; char s[20];, Fun0.1 ha int k; char m[19];, Fun0.1.1 ha int i; char sot[2]; e così via. La i di Fun0 e quella di Fun0.1.1 sono due variabili diverse. Se le chiamate avvengono in quest’ordine, la pila passa per questi stati:
Fun0
Fun0 Fun0.1
Fun0 Fun0.1 Fun0.1.1
Fun0 Fun0.1 Fun0.1.1 finisce
Fun0 Fun0.1 Fun0.1.2
Fun0 Fun0.1
Fun0 Fun0.1 finisce
Fun0 Fun0.2
Fun0 Fun0.2 Fun0.2.1
Fun0 Fun0.2
Fun0
La pila non è mai più alta di 3 record, la profondità dell’albero, anche se le chiamate in tutto sono 6.
La struttura completa (slide 33). Lo scheletro della slide, con le sezioni commentate:
/* Direttive per il preprocessore */
#include <stdio.h>
#include <myfunctions.h>
#define PI 3.14
#define Max(a,b) (a > b ? a : b)
/* Definizioni di tipo e dichiarazioni globali */
typedef unsigned long int ulong
enum Color {Green, Red, Blue};
int global_count =0;
/* Prototipi di Funzioni */
int Prodotto ( int a, int b);
/* main */
int main(int argc, char * argv[]){
int a=5, b=10;
printf("prodotto è:%d\n",Prodotto(a,b)
return 0;
}
/* Definizioni Funzioni */
int Prodotto(int a, int b
{
return a * b;
}
È uno schema, non un programma: così non compila. Manca il ; dopo typedef unsigned long int ulong, manca la ) che chiude il printf e quella della testata di Prodotto, e myfunctions.h è un header di esempio che non esiste. Max(a,b) è una macro con parametri: il preprocessore sostituisce il testo prima della compilazione, non è una funzione e non ha record di attivazione.
Ambienti e visibilità (slide 139-141).
int g1, g2;
char g3;
int f1(int par1, int par2);
main(){
int a, b;
int f2(int par3, int par1);
if(a==0){
char a, c;
...
while(a==0){
float a;
...
}/* Fine blocco2 */
} /* Fine blocco1 */
} /* Fine main */
int f1(int par1, int par2) {
int d;
{
int e;
...
} /* Fine blocco3 */
if(d==0){
int d;
...
} /* Fine blocco4 */
} /* Fine f1 */
int f2(int par3, int par4) {
int f;
...
} /* Fine f2 */
| ambiente | dichiara | vede anche |
|---|---|---|
| globale | g1, g2, g3, f1 | |
main | a, b (int), prototipo di f2 | globali |
blocco 1 (if) | a, c (char): a maschera l’int a di main | b, f2, globali |
blocco 2 (while) | a (float): maschera il char a | c, b, f2, globali |
f1 | par1, par2, d | globali |
| blocco 3 | e | par1, par2, d, globali |
blocco 4 (if) | d: maschera la d di f1 | par1, par2, globali |
f2 | par3, par4, f | globali |
Due dettagli della slide. Il prototipo di f2 è dichiarato dentro main: quindi solo main può chiamare f2 prima della sua definizione, f1 no. Il prototipo dentro main ha il secondo parametro chiamato par1 e la definizione par4: va bene, nel prototipo contano solo i tipi. I blocchi 3 e 4 sono paralleli (entrambi dentro f1, nessuno dentro l’altro); i blocchi 1 e 2 sono annidati. Nella slide 139 la testata di f1 è scritta intpar1, un refuso per int par1. Nota anche che if(a==0) legge a non inizializzata: è un frammento per mostrare gli ambienti, non un programma da eseguire.
Effetti collaterali con un puntatore (slide 136-137). Una funzione che riceve l’indirizzo di una variabile del chiamante la può modificare, e se in più il risultato finisce in una globale le variabili cambiate sono due. Il programma della slide 137 e il suo tracing sono in Passaggio dei parametri, sezione Esempi svolti, perché usano il passaggio per indirizzo.
5Esercizi tipo esame
In una pagina a parte, dal più facile al livello del 30: Funzioni (esercizi).
6Errori tipici
- Chiamare una funzione prima di averla definita o dichiarata: gcc 16 si ferma con
implicit declaration of function. - Prototipo e definizione con tipi diversi (
conflicting types), o prototipo senza;. - Credere che il nome del parametro effettivo debba coincidere con quello del formale: i valori si abbinano per posizione.
- Credere che una funzione modifichi la variabile del chiamante assegnando al proprio parametro: modifica la copia (vedi Passaggio dei parametri).
- Funzione non
voidcon una strada senzareturn: risultato indefinito, gcc avvisacontrol reaches end of non-void function. - Scrivere istruzioni dopo un
returnaspettandosi che vengano eseguite. - Usare una variabile locale di un’altra funzione: non è visibile (
undeclared), anche se quella funzione è in esecuzione sotto nella pila. - Confondere la locale con la globale omonima: dentro la funzione vince la locale, e la globale non si tocca.
- Aspettarsi che una locale conservi il valore fra due chiamate: serve
static. Al contrario, dimenticare che unastaticsi inizializza una volta sola. - Chiamare
srand(time(...))dentro la funzione che genera i numeri: dentro lo stesso secondo dà sempre lo stesso numero. - Chiamare una propria funzione
randomogetline: su Linux in modalità GNU va in conflitto con la libreria. - MCD per sottrazioni con un argomento negativo o nullo: ciclo infinito.
- Mettere
printfescanfdentro funzioni di calcolo: la funzione non si riusa più e non si testa.
7Domande
-
Perché si usano i sottoprogrammi? Dai i due motivi delle slide.
-
Che differenza c’è fra una funzione e una procedura in C? Come si scrive una procedura?
-
Da quali parti è composta la definizione di una funzione? Cosa contiene la testata?
-
Cosa sono i parametri formali e i parametri effettivi? Come vengono abbinati alla chiamata?
-
Perché l’invocazione di una funzione è un’espressione? Cosa si può fare grazie a questo?
-
Quali sono i tre modi in cui una funzione restituisce il controllo al chiamante?
-
Cosa succede se in una funzione
intnon viene eseguito nessunreturn? -
Cosa non può restituire una funzione C, e quanti valori può restituire?
-
Che differenza c’è fra definizione e dichiarazione (prototipo) di una funzione? Perché serve il prototipo?
-
In che ordine si scrivono le parti di un programma C completo?
-
Cosa contiene l’ambiente (record di attivazione) di una funzione, e quando viene rilasciato?
-
Perché gli ambienti delle funzioni si gestiscono con una pila? Cosa vuol dire LIFO?
-
Cosa stampa il programma delle slide 75-78 con
f1ef2? Disegna la pila nel momento più alto. -
Quali sono le regole di visibilità per variabili globali, locali a una funzione e locali a un blocco? Cos’è il mascheramento?
-
Che differenza c’è fra variabili statiche e automatiche? Cosa cambia se dichiari
staticuna variabile locale? -
Cos’è un effetto collaterale, e perché le variabili globali sono sconsigliate?
-
Come si genera un intero casuale fra
minemaxconrand? A cosa servesrande dove va chiamata? -
In
power(int base, int n)con il ciclofor(p=1; n>0; n--), landel chiamante cambia? Perché?