Laboratorio 02: operatori e tipi

Il primo programma va letto prima di eseguirlo: per ogni printf prova a indovinare che cosa stampa, poi controlla. La slide dice di compilarlo con:

gcc -Wall aritmetica.c -o aritmetica        (Linux e macOS)
gcc -Wall aritmetica.c -o aritmetica.exe    (Windows)

Le divisioni

printf("99 / 50 = %d\n", 99 / 50);       // divisione intera
printf("99 %% 50 = %d\n", 99 % 50);      // resto della divisione intera
printf("99 / 50.0 = %f\n", 99 / 50.0);   // divisione reale
printf("99.0 / 50 = %f\n", 99.0 / 50);   // divisione reale

99 / 50 = 1
99 % 50 = 49
99 / 50.0 = 1.980000
99.0 / 50 = 1.980000

Due cose da notare.

• %% dentro la stringa di printf stampa un solo %. Un % da solo sarebbe l'inizio di uno specificatore.
• Basta un reale, a sinistra o a destra, per avere la divisione con la virgola: è la promozione di tipo della lezione 03B.

Poi il programma prova il cast in due posti diversi, con int m = 99 e int n = 50:

m / n, con cast su m: 1.980000
m / n, con cast sul risultato: 1.000000

(double) m / n converte m prima della divisione; (double) (m / n) converte il risultato di una divisione già intera. È la trappola della lezione 03B.

L'overflow

int max = INT_MAX;
printf("INT_MAX = %d\n", max);
max = max + 3;
printf("dopo aver sommato 3 = %d\n", max);

INT_MIN = -2147483648
INT_MAX = 2147483647
dopo aver sommato 3 = -2147483646

INT_MAX e INT_MIN sono il massimo e il minimo di un int, definiti in limits.h. Aggiungendo 3 al massimo, il numero esce dall'intervallo e ricomincia dai negativi, come il contachilometri all'indietro della lezione 03 di Fondamenti: è l'overflow in complemento a 2. Il compilatore non avvisa.

L'ultima riga stampa l'indirizzo di max con %p: cambia a ogni esecuzione, come nella lezione 02C.

Il primo programma da scrivere da zero: operazioni_su_interi.c. Chiede due interi n1 e n2, e stampa la somma, il prodotto, la divisione intera, la divisione reale e il resto.

#include <stdio.h>

int main(void) {
    int n1;
    int n2;
    printf("Inserisci due numeri interi: ");
    scanf("%d %d", &n1, &n2);

    int somma = n1 + n2;
    printf("Somma: %d\n", somma);
    printf("Prodotto: %d\n", n1 * n2);
    printf("Divisione intera: %d\n", n1 / n2);
    printf("Divisione reale: %f\n", (double)n1 / n2);
    printf("Resto: %d\n", n1 % n2);
}

Con l'input 17 5 stampa somma 22, prodotto 85, divisione intera 3, divisione reale 3.400000 e resto 2.

Il programma non controlla n2 = 0: con 0 come secondo numero, la divisione intera fa fallire il programma. Lo saprai sistemare con le condizioni.

Le slide chiedono di calcolare a mano tre espressioni, prima di provarle. Si usano le precedenze della lezione 02B: prima le parentesi, poi *, / e % da sinistra a destra, poi + e - da sinistra a destra.

Sono i risultati delle slide 5, e quelli che stampa il programma.

Quale formula è $y=a{x}^3+7$?

La slide 6 dà sei espressioni e chiede quali calcolano $a{x}^3+7$. La regola: la moltiplicazione viene prima della somma, e le parentesi intorno a una moltiplicazione non cambiano niente.

Ho controllato con a = 2 e x = 3: la formula vale 61. Le espressioni 1, 4 e 5 danno 61; la 2 e la 3 danno 180; la 6 dà 96.

Il programma circonferenza.c legge il raggio e deve stampare circonferenza e area. Le due righe di calcolo sono lasciate da completare: ricorda che la circonferenza è $2\pi r$ e l'area è $\pi r^2$.

#include <stdio.h>

int main(void) {
    // La costante pi greco
    const float PI_GRECO = 3.1415926535f;

    // Chiediamo all'utente il raggio
    printf("Inserisci il raggio del cerchio: ");
    float r;
    scanf("%f", &r);

    // Calcolo della circonferenza e dell'area
    float circonferenza = 2 * PI_GRECO * r;
    printf("La circonferenza del cerchio e': %f\n", circonferenza);

    float area = PI_GRECO * r * r;
    printf("L'area del cerchio e': %f\n", area);
}

Con il raggio 3 stampa 18.849556 e 28.274334. Così com'è, il codice di partenza non compila nemmeno con -Wall: circonferenza e area sono usate nelle printf ma non dichiarate.

La domanda: che cosa vuol dire const?

const davanti a una dichiarazione la rende una costante: il valore si dà all'inizio e poi non si può più cambiare. Se scrivi PI_GRECO = 3; più avanti, gcc si ferma con error: assignment of read-only variable 'PI_GRECO'. Il nome tutto maiuscolo è una convenzione per le costanti, non un obbligo.

Il commento del codice ricorda che math.h ha già la costante M_PI. Le slide avvisano che, su Linux, usando math.h può servire l'opzione -lm.

All'esame il compilatore ti dice dove ha trovato un errore, ma non sempre perché. Qui si allena l'occhio: prima si cercano gli errori leggendo, poi si controlla con gcc.

Il programma della slide 9

#include <stdio.h>
int main() {
int x, y;
printf("Inserisci due interi: ");
scanf("%d %d", &x, y)
z = x + y;
printf("La somma %d + %d vale ", x, y);
printf("%d\n", &z);
}

Gli errori sono quattro:

1. in scanf manca la & davanti a y: scanf vuole un indirizzo;
2. manca il ; dopo la scanf;
3. z non è dichiarata;
4. l'ultima printf stampa &z, l'indirizzo, invece del valore z.

gcc con -Wall -Werror ne trova subito tre: format '%d' expects argument of type 'int *', but argument 3 has type 'int', expected ';' before 'z' e 'z' undeclared. Il quarto lo segnala dopo aver corretto gli altri. Il programma corretto:

#include <stdio.h>

int main(void) {
    int x, y;
    printf("Inserisci due interi: ");
    scanf("%d %d", &x, &y);
    int z = x + y;
    printf("La somma %d + %d vale ", x, y);
    printf("%d\n", z);
}

errori.c: gli otto errori

La slide 11 chiede di trovare, senza compilare, gli 8 errori di errori.c. Prova da solo prima di leggere.

#include <stdio.h>

int main(void) {
    float f1, f2;
    printf("Inserisci due numeri reali: ");
    scanf("%f %d", &f1, &f2);

    float risultato = (f1 + f2) / 2);
    printf("Risultato = %f %d\n", &risultato);

    // Calcoliamo il quadrato
    // float quadrato = risultato * risultato;
    printf("Il quadrato e' \n", quadrato) }
}

Compilando il file originale con -Wall -Werror, gcc 16.1 segnala gli errori 1, 2, 3, 4, 5, 7 e 8. Il 6 lo segnala solo dopo le altre correzioni, come «troppi argomenti per il formato». Il programma corretto, con 3 e 4, stampa Risultato = 3.500000 e Il quadrato e' 12.250000.

media.c legge tre interi x, y, z e calcola la media in tre modi. Con l'input 8, 2, 3, che danno somma 13:

Solo la terza è giusta: è la divisione che inganna della lezione 03B.

Le tre varianti del commento

Il codice chiede che cosa fanno tre modi di scrivere media3, e dove avviene la conversione da int a double. Con 1, 2, 5, che danno somma 8:

Arrotondare

Il programma arrotonda media3 in quattro modi. Con 1, 2, 5, cioè 2.666667:

Con i numeri positivi il cast e floor danno lo stesso risultato. Con i negativi no: con −2.5 il cast dà −2, floor dà −3, ceil dà −2 e round dà −3, perché a metà strada round si allontana dallo zero.

8.136 per 1000

L'ultima parte del programma calcola (int)(f * 1000) con f = 8.136, e stampa 8135, non 8136. Il motivo è quello della lezione 03B: 8.136 non si scrive esattamente in base 2. In memoria è un po' meno di 8.136, e f * 1000 vale 8135.99999999999909… Il cast a int taglia, e resta 8135. Con (int)round(f * 1000) si ottiene 8136.

Le slide 13 e 14, e il foglio a parte, riportano la tabella dei tipi del C con dimensione, intervallo e specificatore. La slide 14 lo dice in grande: non serve impararla a memoria. La versione con le spiegazioni è nella lezione 02B.

Gli unsigned partono da 0 e arrivano al doppio: un unsigned char va da 0 a 255, un unsigned int da 0 a 4 294 967 295.

Che cosa stampa dim_tipi.c

dim_tipi.c stampa la dimensione di ogni tipo con sizeof e il suo intervallo, con le costanti di limits.h e float.h. Sul mio PC, Windows 11 a 64 bit:

sizeof(long)     = 4  intervallo: -2147483648, 2147483647
sizeof(long long)= 8  intervallo: -9223372036854775808, 9223372036854775807
...
sizeof(float) = 4  intervallo: 1.175494e-38, 3.402823e+38
sizeof(double)= 8  intervallo: 2.225074e-308, 1.797693e+308
...
sizeof(char*)    = 8
sizeof(int*)     = 8
sizeof(double*)  = 8

long vale 4 byte su Windows e 8 su Linux: la tabella lo avvisa, le dimensioni dipendono dal sistema. Al laboratorio Turing, con Linux, vedrai 8.

La domanda: che cosa hanno di speciale i puntatori?

Tutti i tipi puntatore hanno la stessa dimensione: 8 byte su un computer a 64 bit. Il perché è nella lezione 02C: un puntatore contiene un indirizzo, e tutti gli indirizzi di una macchina hanno la stessa lunghezza, qualunque cosa ci sia a quell'indirizzo. Un char è di 1 byte e un double di 8, ma i loro indirizzi sono tutti e due di 8 byte.

L'ultima parte del programma usa size_t, il tipo senza segno restituito da sizeof: 100 int occupano 100 * sizeof(int) = 400 byte.

Nessuno ricorda tutte le funzioni e tutti gli specificatori: si cercano nella documentazione. Il riferimento più usato è cppreference, che ha una versione da scaricare e usare senza Internet. La slide spiega come:

1. vai su cppreference.com/w/c;
2. in fondo alla pagina, «Offline version»: scarica la versione più recente;
3. apri la pagina html-book/reference/en/c.html;
4. nella sezione degli header cerca <stdio.h> e leggi la documentazione completa di printf.

La slide avverte che la documentazione vera è molto più dettagliata di quello visto a lezione. Serve proprio a imparare a cercare: nella pagina di printf trovi, per esempio, che %% stampa un % e che %.3f fissa le cifre dopo la virgola.

Il programma mercato.c calcola la spesa per 3 pacchi di orecchiette a 1.50 euro e 1 kg e mezzo di pomodori a 2.50 euro al kg. Le slide chiedono variabili con tipi adatti, una variabile per il totale, indentazione e commenti.

#include <stdio.h>

int main(void) {
    // prezzi unitari, in euro
    double prezzoOrecchiette = 1.50;   // un pacco
    double prezzoPomodori = 2.50;      // al kg

    // quantita' acquistate
    int pacchiOrecchiette = 3;
    double kgPomodori = 1.5;

    double totale = pacchiOrecchiette * prezzoOrecchiette + kgPomodori * prezzoPomodori;
    printf("Spesa totale: %.2f euro\n", totale);
}

Stampa Spesa totale: 8.25 euro: 3 per 1.50 fa 4.50, 1.5 per 2.50 fa 3.75.

Le scelte dei tipi: i pacchi si contano, quindi int; i chili e i prezzi hanno la virgola, quindi double. Il %.2f stampa i centesimi.

Con le quantità da tastiera

La seconda parte chiede di leggere le quantità da tastiera invece di scriverle nel codice. Servono due scanf, con lo specificatore giusto per ogni tipo:

int pacchiOrecchiette;
double kgPomodori;
printf("Pacchi di orecchiette: ");
scanf("%d", &pacchiOrecchiette);
printf("Kg di pomodori: ");
scanf("%lf", &kgPomodori);

Con 3 pacchi e 2 kg stampa Spesa totale: 9.50 euro. Il %lf per il double è obbligatorio: con %f, -Wall -Werror non compila.

L'ultimo esercizio riprende la lezione 03A. Prima si legge e si prova scambio.c, che scambia x = 5 e y = 8 con una variabile intermedia e stampa x: 8, y: 5. Poi si scrive scambio4.c: quattro variabili, in cui v1 prende il valore di v2, v2 di v3, v3 di v4 e v4 di v1.

La soluzione completa, provata, è nella lezione 03A, nell'esercizio «scambio4.c del Laboratorio 02». L'idea: una sola variabile d'appoggio, che salva v1 prima che venga sovrascritta.

int temp = v1;
v1 = v2;
v2 = v3;
v3 = v4;
v4 = temp;

Con 10, 20, 30, 40 alla fine i valori sono 20, 30, 40, 10.

L'esame è al PC, con CodeRunner: il tuo codice viene compilato con -Wall -Werror e le sue stampe confrontate con quelle attese. Questo laboratorio allena quasi tutto quello che serve per non perdere punti nei primi esercizi:

1. leggere gli errori del compilatore e correggerli uno alla volta, come in errori.c;
2. scegliere i tipi: int per contare, double per misurare;
3. le divisioni: intera quando vuoi la parte intera, con la virgola quando vuoi la media;
4. gli specificatori giusti in printf e in scanf, compresi %lf e %.2f;
5. niente variabili inutilizzate: con -Werror bloccano la compilazione.

Codice di partenza

I programmi già scritti forniti con il laboratorio, da leggere, provare e completare.

Divisione intera

/ tra due interi: tiene solo la parte intera, tagliando verso lo zero.

Modulo

%: il resto della divisione intera; in C ha il segno del primo numero.

Overflow

Un risultato intero che supera il massimo del suo tipo; per gli int con il segno è comportamento indefinito.

INT_MAX, INT_MIN

Massimo e minimo di un int, definiti in limits.h.

const

Parola chiave che rende una variabile non modificabile.

floor, ceil, round

Funzioni di math.h che arrotondano per difetto, per eccesso e al più vicino.

sizeof

Operatore che dà quanti byte occupa un tipo o una variabile.

cppreference

Sito di documentazione del C e del C++, scaricabile per l'uso senza Internet.

Wall

Opzione di gcc che mostra gli avvisi; con -Werror ogni avviso diventa un errore.

Spunta quando sai fare la cosa senza guardare gli appunti. Le spunte restano salvate in questo browser.

• So prevedere il risultato di / e % tra interi, anche con i negativi.
• So che cos'è l'overflow di un int e perché il compilatore non lo segnala.
• So calcolare un'espressione rispettando le precedenze.
• So completare circonferenza.c e spiegare che cosa fa const.
• So trovare gli errori di un programma, anche senza compilarlo.
• So calcolare una media con la virgola e arrotondarla nei quattro modi.
• So spiegare perché 8.136 per 1000 dà 8135.
• So che i puntatori hanno tutti la stessa dimensione, e perché.
• So scrivere mercato.c, anche con le quantità da tastiera.
• So ruotare quattro variabili con una sola variabile d'appoggio.