Note Ingegneria Informatica · UniTN
Programmazione 1
esercizi
Teoria
bozza

Funzioni (esercizi)

Esercizi tipo esame di Funzioni, dove stanno teoria, metodo ed esempi svolti a lezione. Testo in chiaro, soluzione chiusa: prima provaci da solo. Gli esercizi sul passaggio per indirizzo, sugli array e sulle struct passate a funzione sono in Passaggio dei parametri (esercizi).

Dal più facile al livello del 30. Per i tracing: una colonna per ogni record attivo più una per le globali, una riga per istruzione, e alla fine la pila nel momento più alto. Tutti gli output sono verificati compilando con gcc -std=c11 -Wall -Wextra -Wpedantic ed eseguendo.

Esercizio 1. Scrivi l’output esatto.

#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 a = 3;

    printf("%d\n", power(a, 2));
    printf("%d\n", power(2, a) - power(a, 0));
    printf("%d\n", power(power(2, 2), 2));
    printf("a=%d\n", a);
    return 0;
}
Soluzione

Si riconosce: chiamate di una funzione che restituisce basenbase^n, con i parametri abbinati per posizione e una chiamata dentro l’altra.

espressioneparametricalcolovalore
power(a, 2)base = 3, n = 23 · 39
power(2, a)base = 2, n = 32 · 2 · 28
power(a, 0)base = 3, n = 0nessun giro, p resta 11
power(2, 2) (interna)base = 2, n = 24
power(4, 2) (esterna)base = 4, n = 24 · 416

La chiamata interna si valuta prima: il suo risultato è il parametro effettivo di quella esterna. Output:

9
7
16
a=3

Controllo: a non è mai a sinistra di un’assegnazione in main, e le funzioni ne ricevono solo il valore, quindi resta 3.

Esercizio 2. Scrivi l’output esatto.

#include <stdio.h>

int f(int n)
{
    if (n > 10) {
        return n - 10;
    }
    if (n % 2 != 0) {
        return n * 2;
    }
    return n / 2;
}

int main(void)
{
    printf("%d %d %d\n", f(15), f(7), f(8));
    printf("%d\n", f(f(26)));
    printf("%d\n", f(f(f(9))));
    return 0;
}
Soluzione

Più return: per ogni chiamata si esegue solo il primo che il flusso incontra.

chiamatan > 10n % 2 != 0returnvalore
f(15)vero15 - 105
f(7)falsovero7 * 214
f(8)falsofalso8 / 24
f(26)vero26 - 1016
f(16)vero16 - 106
f(9)falsovero9 * 218
f(18)vero18 - 108
f(8)falsofalso8 / 24

Le chiamate annidate si valutano dall’interno: f(f(26)) è f(16), f(f(f(9))) è f(f(18)), cioè f(8). Output:

5 14 4
6
4

Esercizio 3. Vero o falso? Motiva.

  1. Una funzione C può restituire un array di int.
  2. Il prototipo di una funzione contiene la testata e il corpo.
  3. In int g(int a, int b); i nomi a e b si possono omettere.
  4. Se una funzione int termina senza eseguire un return, restituisce 0.
  5. Le variabili locali di una funzione esistono finché il programma non termina.
  6. Una variabile locale static conserva il suo valore fra due chiamate.
  7. Una funzione può usare una variabile locale di main se main è ancora in esecuzione.
  8. L’invocazione di una funzione void si può usare a destra di un’assegnazione.
Soluzione
  1. Falso: il tipo del risultato non può essere un array (slide 51). Può essere un puntatore o una struct che contiene un array.
  2. Falso: il prototipo è la sola testata seguita da ;. Testata più corpo è la definizione.
  3. Vero: nel prototipo contano i tipi, int g(int, int); è valido.
  4. Falso: il risultato è indefinito. gcc avvisa control reaches end of non-void function. Solo main restituisce 0 implicitamente.
  5. Falso: sono automatiche, create all’ingresso nella funzione e distrutte all’uscita (il record viene tolto dalla pila).
  6. Vero: è allocata una volta sola e inizializzata una volta sola.
  7. Falso: la visibilità è sintattica. Il record di main è nella pila, ma il nome non è visibile dal corpo dell’altra funzione (undeclared). Per far lavorare una funzione su una variabile di main si passa il valore o l’indirizzo.
  8. Falso: una funzione void non ha valore. gcc: void value not ignored as it ought to be.

Esercizio 4. Trova gli errori, scrivi cosa dice il compilatore e correggi.

#include <stdio.h>

int media(int a, int b)
{
    int m;

    m = (a + b) / 2;
}

int main(void)
{
    int x = 4;

    printf("%d\n", media(x, 8));
    printf("%d\n", m);
    return 0;
}
Soluzione

Due errori, uno per ambiente.

  • In media manca il return: la funzione calcola m e lo butta. gcc avvisa control reaches end of non-void function e anche variable 'm' set but not used; compila, ma il valore stampato è indefinito.
  • In main si usa m, che è locale di media: non è visibile, e non esiste neanche più (il record di media è stato eliminato). gcc si ferma: error: 'm' undeclared (first use in this function).

Corretto:

#include <stdio.h>

int media(int a, int b)
{
    int m;

    m = (a + b) / 2;
    return m;
}

int main(void)
{
    int x = 4;
    int m = media(x, 8);

    printf("%d\n", m);
    return 0;
}

Stampa 6. La m di main è un’altra variabile con lo stesso nome, che riceve il valore restituito.

Esercizio 5. Variabile globale e locale con lo stesso nome. Scrivi l’output esatto.

#include <stdio.h>

int x = 5;

int g(int x)
{
    x = x * 2;
    return x + 1;
}

int h(int y)
{
    x = x + y;
    return x;
}

int main(void)
{
    int y = g(x);

    printf("x=%d y=%d\n", x, y);
    y = h(y);
    printf("x=%d y=%d\n", x, y);
    {
        int x = 100;
        y = g(x) + h(1);
        printf("x=%d y=%d\n", x, y);
    }
    printf("x=%d y=%d\n", x, y);
    return 0;
}
Soluzione

Si riconosce il tipo d’esame “globale e locale omonime”. Per ogni x si cerca la dichiarazione più interna: in g è il parametro, in h è la globale (h non dichiara x), nel blocco di main è la locale da 100.

istruzionex globaley mainx del bloccodettaglio
int y = g(x);511g: parametro x = 5, diventa 10, return 11. La globale non si tocca
printf511x=5 y=11
y = h(y);1616h: y = 11, globale x = 5 + 11 = 16, return 16
printf1616x=16 y=16
int x = 100;1616100maschera la globale
g(x)16100parametro 100, diventa 200, restituisce 201
h(1)17100h vede la globale: 16 + 1 = 17, restituisce 17
y = 201 + 1717218100
printf nel blocco17218100x=100 y=218: x qui è quella del blocco
printf fuori17218x=17 y=218

Output:

x=5 y=11
x=16 y=16
x=100 y=218
x=17 y=218

Il punto delicato è h(1) dentro il blocco: la x da 100 è visibile in main, ma h è scritta fuori da main e vede solo la globale. In y = g(x) + h(1) l’ordine in cui il C valuta le due chiamate non è fissato, ma qui non cambia niente: g non legge la globale.

Esercizio 6. Scrivi l’output esatto.

#include <stdio.h>

int prossimo(int passo)
{
    static int totale = 0;
    int chiamate = 0;

    chiamate++;
    totale += passo;
    printf("chiamate=%d totale=%d\n", chiamate, totale);
    return totale;
}

int main(void)
{
    int i;
    int r = 0;

    for (i = 1; i <= 3; i++) {
        r = prossimo(i * 10);
    }
    printf("r=%d\n", r);
    return 0;
}
Soluzione

Una locale automatica e una static nella stessa funzione.

ipassochiamatetotale (static)
110creata a 0, poi 10 all’avvio, poi 10
220creata a 0, poi 110, poi 30
330creata a 0, poi 130, poi 60

Output:

chiamate=1 totale=10
chiamate=1 totale=30
chiamate=1 totale=60
r=60

Controllo: totale è la somma 10 + 20 + 30 = 60; chiamate riparte da 0 a ogni chiamata perché il suo record è nuovo, quindi non conta proprio niente. Per contare le chiamate servirebbe static int chiamate = 0;.

Esercizio 7. Scrivi l’output esatto e disegna la pila nel momento in cui è più alta.

#include <stdio.h>

int c(int n)
{
    printf("c(%d)\n", n);
    return n + 1;
}

int b(int n)
{
    int r;

    printf("b(%d) entra\n", n);
    r = c(n * 2);
    r = r + c(n);
    printf("b(%d) esce con %d\n", n, r);
    return r;
}

int a(int n)
{
    printf("a(%d) entra\n", n);
    return b(n + 1) * 10;
}

int main(void)
{
    printf("main: %d\n", a(2));
    return 0;
}
Soluzione

Chiamate in catena: ogni funzione aspetta il risultato di quella che ha chiamato.

passopila (dal basso)stampa
main valuta a(2)main | a: n = 2a(2) entra
a valuta b(n + 1)main | a | b: n = 3, r = ?b(3) entra
b chiama c(6)main | a | b | c: n = 6c(6)
c restituisce 7main | a | b: r = 7
b chiama c(3)main | a | b | c: n = 3c(3)
c restituisce 4main | a | b: r = 11b(3) esce con 11
b restituisce 11main | aa calcola 11 · 10 = 110
a restituisce 110mainmain: 110

Output:

a(2) entra
b(3) entra
c(6)
c(3)
b(3) esce con 11
main: 110

La pila è più alta (4 record) durante ciascuna delle due chiamate di c:

c     n = 6        (poi, nella seconda chiamata, un record nuovo con n = 3)
b     n = 3, r = ?
a     n = 2
main

main: si stampa per ultimo anche se è scritto per primo nel printf: prima si valutano gli argomenti (cioè a(2), con tutte le sue stampe), poi printf stampa. Le due chiamate di c sono in due istruzioni separate di proposito: in c(n * 2) + c(n) il C non fissa quale delle due viene eseguita per prima, e l’ordine delle righe stampate non sarebbe garantito.

Esercizio 8. Scrivi tre funzioni con prototipo e una main che le prova:

  1. int max3(int a, int b, int c) che restituisce il massimo di tre interi usando una funzione max2;
  2. int somma_cifre(int n) che restituisce la somma delle cifre decimali di n (anche negativo);
  3. int bisestile(int anno) che restituisce 1 se l’anno è bisestile (divisibile per 4 ma non per 100, oppure divisibile per 400) e 0 altrimenti.
Soluzione

Ogni funzione lavora solo sui parametri e restituisce il risultato; le stampe stanno in main.

#include <stdio.h>

int max2(int a, int b);
int max3(int a, int b, int c);
int somma_cifre(int n);
int bisestile(int anno);

int main(void)
{
    printf("%d %d\n", max3(4, 9, 2), max3(-1, -5, -3));
    printf("%d %d\n", somma_cifre(254871), somma_cifre(0));
    printf("%d %d %d %d\n", bisestile(2024), bisestile(1900), bisestile(2000), bisestile(2026));
    return 0;
}

int max2(int a, int b)
{
    return a > b ? a : b;
}

int max3(int a, int b, int c)
{
    return max2(max2(a, b), c);
}

int somma_cifre(int n)
{
    int somma = 0;

    if (n < 0) {
        n = -n;
    }
    while (n > 0) {
        somma += n % 10;
        n /= 10;
    }
    return somma;
}

int bisestile(int anno)
{
    return (anno % 4 == 0 && anno % 100 != 0) || anno % 400 == 0;
}

Output:

9 -1
27 0
1 0 1 0

Controlli. max3(-1, -5, -3): max2(-1, -5) = -1, max2(-1, -3) = -1. somma_cifre(254871): 1 + 7 + 8 + 4 + 5 + 2 = 27 (le cifre escono dalla meno significativa con % 10); con 0 il while non parte e la somma resta 0, che è giusto. Modificare n dentro somma_cifre è lecito: è la copia. bisestile restituisce direttamente il valore della condizione, che in C vale 1 o 0: 1900 è divisibile per 100 e non per 400, quindi non è bisestile.

Esercizio 9. Prova al calcolatore, punto C. Scrivi:

  1. int casuale(int min, int max), intero casuale fra min e max compresi;
  2. float casuale_prezzo(float min, float max), prezzo casuale con due decimali fra min e max (per esempio fra 15.00 e 35.00), usando casuale;
  3. int leggi_intero(int min, int max), che chiede un intero da tastiera finché non è nell’intervallo e lo restituisce.

Poi un main che inizializza il generatore, stampa tre prezzi e legge un intero fra 1 e 10.

Soluzione

Sono tre mattoni che tornano in quasi ogni prova (vedi Esami passati, I mattoni che tornano in ogni prova).

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int casuale(int min, int max);
float casuale_prezzo(float min, float max);
int leggi_intero(int min, int max);

int main(void)
{
    int i;
    int n;

    srand((unsigned) time(NULL));
    for (i = 0; i < 3; i++) {
        printf("%.2f\n", casuale_prezzo(15.0f, 35.0f));
    }
    n = leggi_intero(1, 10);
    printf("\nletto %d\n", n);
    return 0;
}

int casuale(int min, int max)
{
    return rand() % (max - min + 1) + min;
}

float casuale_prezzo(float min, float max)
{
    int centesimi = casuale((int) (min * 100), (int) (max * 100));

    return centesimi / 100.0f;
}

int leggi_intero(int min, int max)
{
    int n;

    do {
        printf("valore fra %d e %d: ", min, max);
        if (scanf("%d", &n) != 1) {
            return min;
        }
    } while (n < min || n > max);
    return n;
}
  • casuale_prezzo lavora in centesimi: un intero casuale fra 1500 e 3500, diviso per 100.0f (non per 100, che darebbe una divisione intera). Così ha sempre al massimo due decimali.
  • leggi_intero ripete con un do-while (la domanda va fatta almeno una volta). Se scanf non riesce a leggere un intero (input non numerico) esce restituendo min invece di girare all’infinito.
  • srand sta in main, una volta sola.

Provato con input 0, 42, 7: la domanda compare tre volte e il programma stampa letto 7. I tre prezzi cambiano a ogni esecuzione (una prova: 30.08, 17.93, 29.96).

Esercizio 10. Livello del 30, sulla traccia delle matricole. Scrivi l’output esatto.

#include <stdio.h>

int t = 2;

int passo(int n)
{
    static int k = 1;
    int t = n % 10;

    k = k * 2;
    return t + k;
}

int giro(int m)
{
    int s = 0;

    while (m > 0) {
        s = s + passo(m);
        m = m / 10;
        t++;
    }
    return s;
}

int main(void)
{
    int r;

    r = giro(254);
    printf("r=%d t=%d\n", r, t);
    r = giro(7);
    r = r + t;
    printf("r=%d t=%d\n", r, t);
    return 0;
}
Soluzione

Tre trappole insieme: t globale in giro ma locale in passo, k statica che continua a raddoppiare anche fra le due chiamate di giro, m che perde una cifra a ogni giro.

Prima chiamata, giro(254):

mpasso(m): k (static)t locale di passo = m % 10restituiscest globale dopo t++
2541 · 2 = 24663
252 · 2 = 459154
24 · 2 = 8210255
0esce

r = 25, t = 5: prima riga r=25 t=5.

Seconda chiamata, giro(7): k non riparte da 1, vale 8.

mkt localerestituiscest globale
716723236

r = 23, poi r = r + t = 23 + 6 = 29. Output:

r=25 t=5
r=29 t=6

Controllo: t++ in giro tocca la globale (giro non dichiara t), una volta per cifra: 3 cifre più 1 cifra, da 2 a 6. La t di passo non interferisce mai. L’addizione è separata in due istruzioni apposta: in giro(7) + t il C non dice se t viene letta prima o dopo la chiamata, che la modifica, quindi il risultato potrebbe essere 28 o 29.