Note Ingegneria Informatica · UniTN
Programmazione 1
Esercizi
Lezione
ott, giorno?
bozza

Funzioni

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:

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:

Definizione di una funzione (slide 29-32, slide 55). È composta da:

 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 basenbase^n moltiplicando p per base nn 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).

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:

  1. la funzione non restituisce niente (per esempio stampa un array) e l’esecuzione arriva alla } che chiude il corpo;
  2. la funzione esegue return;;
  3. 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).

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:

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:

  1. direttive al precompilatore (#include, #define, …);
  2. dichiarazioni degli elementi condivisi da tutto il programma (main e sottoprogrammi): costanti, tipi, variabili globali, prototipi;
  3. definizioni dei sottoprogrammi, cominciando da main.

Ambiente (slide 86). La memoria della macchina dedicata a una chiamata. Contiene:

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.

Ambienti di un programma (slide 132-133). Un ambiente è definito dal perimetro sintattico:

  1. dell’intero programma (ambiente globale, esterno a tutte le macchine: main e le altre funzioni ci accedono);
  2. di una funzione;
  3. 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).

Ciclo di vita (slide 145-148). Va dalla creazione (allocazione della memoria) alla distruzione (rilascio). Due classi:

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).

passorecord di mainrecord di powernota
chiamatai = 3base = 2, n = 3, i = ?, p = 1i formali prendono 2 e 3
i = 1, p *= basei = 1, p = 2
i = 2, p *= basei = 2, p = 4
i = 3, p *= basei = 3, p = 8
i = 4, 4 <= 3 falsoi = 4, p = 8esce dal for
return p;riceve 8eliminato

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: 20=12^0 = 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:

istantepilanota
prima della chiamatamain: 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 = 9tre record
ritornomain | somma_quadrati: s = 9quadrato eliminato
quadrato(b)main | somma_quadrati | quadrato: n = 4, q = 16record nuovo, q riparte da ?
ritornomain | somma_quadrati: s = 9 + 16 = 25
ritornomain: 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;
}
istruzionen di mainn di powerp
chiamata power(2, n)33 (copia)?
p = 1, 3 > 0331
p *= base, n--322
p *= base, n--314
p *= base, n--308
0 > 0 falso, return p3eliminata8

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

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;
}
puntoquale avalore
primo printf di mainglobale (nessuna a locale ancora)1
nel blocco di maina del blocco, maschera la globale2
f(a + 10)si valuta a + 10 nel chiamante: 2 + 10parametro = 12
primo printf di fparametro a di f, maschera la globale12
a = 50;parametro di f50
blocco in fa del blocco, maschera il parametro7
dopo il blocco in fdi nuovo il parametro, il 7 è sparito50
tornati nel blocco di maina del blocco, f non l’ha toccata2
fuori dal blocco di mainglobale, mai modificata1

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;
}
istruzioneparx globalerisultato
inizio1
x = fun(1);111 + 1 = 2, poi x = 2
x = fun(1);121 + 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;
}
giron di conta_auton di conta_static
1creata a 0, diventa 1, distruttainizializzata a 0 all’avvio, diventa 1
2creata a 0, diventa 1, distruttaera 1, diventa 2
3creata a 0, diventa 1, distruttaera 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 ee), log10(x), fabs(x), ceil(x) (il più piccolo intero non minore di xx), floor(x) (il più grande intero non maggiore di xx), pow(x, y) (xyx^y), fmod(x, y) (resto di x/yx/y 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.

  1. Parti da main. Tieni una colonna (o un riquadro) per ogni record attivo, più uno per le globali.
  2. 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 (le static invece hanno il valore rimasto dalla volta prima).
  3. 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.
  4. Al return v: scrivi v al posto della chiamata nel chiamante, cancella il record. Se la funzione è void, la chiamata non ha valore.
  5. 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.

  1. Cosa entra (parametri, con il tipo) e cosa esce (tipo di ritorno, o void se non esce niente).
  2. Un nome che dice cosa fa: somma_cifre, max3, stampaDato.
  3. Prototipo in cima (o in dati.h), definizione in fondo (o in dati.cpp).
  4. Il corpo lavora solo sui parametri e sulle sue locali: niente scanf o printf dentro una funzione di calcolo, a meno che il testo lo chieda (stampaX, newX).
  5. Ogni strada finisce in un return del tipo giusto.
  6. 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.

chiamatamov.numMovimentitotale dopo ogni girorisultato
totMov(entrate)3300, 850, 950950.0
totMov(uscite)3500, 750, 900900.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: 10510^5 invece di 5105^{10}. 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 p=3/4p = 3/4 e q=6/9q = 6/9, 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):

giroxyx != yramo
inizio1836vero18 > 36 falso: y -= x
11818falsoesce, 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 x=−2x = -2 e y=4y = 4 si sottrae xx da yy e yy cresce all’infinito). Con un numeratore 0 il ciclo non termina neanche con abs (x=0x = 0: 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));
}
passopila (dal basso)globale xcosa succede
1main0
2main | f20main chiama f2(), senza parametri
3main | f2 | f1: p = 00f2 valuta f1(x): x vale 0, p prende 0
4main | f2 | f1: p = 00return p + x = 0 + 0 = 0
5main | f20f1 eliminato, printf("%d", 0) stampa 0
6main0f2 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 */
ambientedichiaravede anche
globaleg1, g2, g3, f1
maina, b (int), prototipo di f2globali
blocco 1 (if)a, c (char): a maschera l’int a di mainb, f2, globali
blocco 2 (while)a (float): maschera il char ac, b, f2, globali
f1par1, par2, dglobali
blocco 3epar1, par2, d, globali
blocco 4 (if)d: maschera la d di f1par1, par2, globali
f2par3, par4, fglobali

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

7Domande