Numeri reali in C, float e double, conversioni di tipo

Per contare le persone in aula bastano gli interi. Ma per la media dei voti, il prezzo al chilo dei pomodori o la velocità di un'auto servono i numeri con la virgola: una parte intera e una parte frazionaria. In C si chiamano numeri reali e hanno due tipi principali.

Il nome double viene da «doppia precisione»: usa il doppio dei bit di float. In memoria funzionano come la virgola mobile della lezione 03 di Fondamenti: un bit di segno, un esponente che dice dove sta la virgola, e una mantissa con le cifre. Lo standard che lo descrive si chiama IEEE 754.

Le cifre giuste sono poche

«Circa 7 cifre» vuol dire proprio questo: dopo la settima cifra il numero è approssimato. Ho provato sul mio PC tre stampe con tante cifre:

float f = 0.1f;
double d = 0.1;
printf("%.20f\n%.20f\n", f, d);

0.10000000149011611938
0.10000000000000000555

Un decimo non si scrive esattamente in base 2, come un terzo non si scrive esattamente in base 10. Il float sbaglia dall'ottava cifra, il double dalla diciottesima. Per la stessa ragione 0.1 + 0.2 in double vale 0.30000000000000004.

Le operazioni

Sui reali ci sono le quattro operazioni: +, -, *, /. La divisione / tra due reali è quella vera, con la virgola: 5.0 / 2.0 fa 2.5.

Il resto % non c'è: con due double gcc si ferma con error: invalid operands to binary % (have 'double' and 'double'). Le slide avvisano che esiste una funzione di libreria, fmod, ma nel corso non si usa.

Con printf un reale si può stampare in tre modi. Con double z = 2.5;:

e+00 vuol dire «per 10 alla 0». Così 1.5e+03 è $1,5\cdot 10^3=1500$.

Quante cifre dopo la virgola

Tra il % e la lettera si può scrivere un punto e un numero: è quante cifre stampare dopo la virgola.

printf("z vale %f\n", z);      // z vale 2.500000
printf("z vale %.3f\n", z);    // z vale 2.500
printf("z vale %.3e\n", z);    // z vale 2.500e+00

Le slide dicono «troncata al terzo decimale». In realtà printf arrotonda all'ultima cifra stampata: printf("%.2f", 1.0 / 3) stampa 0.33, e printf("%.2f", 2.0 / 3) stampa 0.67.

Un'altra cosa da sapere: printf usa %f sia per i float sia per i double. Quando passi un float a printf, il C lo trasforma da solo in double. Per questo i messaggi di errore di gcc su %f parlano sempre di double.

Leggere un double

Con scanf le cose cambiano. scanf non riceve un valore ma un indirizzo (lezione 02C), e deve sapere quanti byte scrivere: 4 per un float, 8 per un double. Per questo:

• un float si legge con %f;
• un double si legge con %lf (o %le, %lg).

double x;
float y;
int letti = scanf("%lf %f", &x, &y);

Con l'input 3.25 1.5 il programma legge tutti e due i valori: letti vale 2.

Il primo programma delle slide divide due float:

#include <stdio.h>

int main(void) {
    float x = 5, y = 2, z;
    z = x / y;
    printf("La var x vale %f\n", x);
    printf("La var y vale %f\n", y);
    printf("La var z vale %f\n", z);
}

La var x vale 5.000000
La var y vale 2.000000
La var z vale 2.500000

float x = 5 mette nel float il numero 5, che diventa 5.0. La divisione tra due float è con la virgola: 2.5.

Le slide 7 e 8 rifanno lo stesso programma con i double, e poi con x e y di tipo float e z di tipo double. Il risultato stampato è sempre 2.500000; cambia solo lo spazio in memoria: 4 byte per ogni float, 8 per ogni double.

La libreria math.h

Gli operatori del C fanno solo le operazioni di base. Per radici, potenze, logaritmi e trigonometria c'è la libreria math.h, da includere con #include <math.h>. Le funzioni più usate:

#include <stdio.h>
#include <math.h>

int main(void) {
    float num = 9.0, radice, quadrato;
    quadrato = pow(num, 2);
    radice = sqrt(num);
    printf("Il quadrato di %.0f e' %.2f\n", num, quadrato);
    printf("La radice di %.0f e' %.2f\n", num, radice);
}

Il quadrato di 9 e' 81.00
La radice di 9 e' 3.00

In un'espressione puoi mettere insieme un int, un float e un char. Ma i tre tipi sono scritti in memoria in modi diversi: per fare il conto, il C deve prima portarli tutti allo stesso formato. Questo passaggio si chiama conversione di tipo, e ce ne sono di due modi:

• conversione implicita: la fa il compilatore da solo, senza che tu scriva niente;
• conversione esplicita, o cast: la chiedi tu, scrivendo il tipo tra parentesi.

Tutte e due possono perdere informazione: cifre, o l'intera parte dopo la virgola.

Le conversioni dell'assegnamento

L'assegnamento è il caso più comune: il valore a destra viene convertito nel tipo della variabile a sinistra. La tabella delle slide, con i valori che ho ottenuto sul mio PC:

Tre osservazioni.

1. La parte dopo la virgola viene tagliata, non arrotondata. 9.9 diventa 9, non 10. Con i negativi il taglio va verso lo zero: −2.7 diventa −2.
2. Gli interi molto grandi non stanno in un float, che ha solo 24 bit di mantissa. 16 777 217 messo in un float diventa 16 777 216.
3. Un double fuori dall'intervallo degli int, come 3 miliardi, non si può convertire: il comportamento è indefinito. Sul mio PC (int)3e9 dà −2 147 483 648, ma non è garantito.

L'ultima riga della tabella è un errore vero: con gcc 16.1, anche senza opzioni, int *p = x; dà error: initialization of 'int *' from 'int' makes pointer from integer without a cast. Un numero e un indirizzo non sono la stessa cosa (lezione 02C).

Quando un operatore come + o / riceve due valori di tipo diverso, il compilatore li porta allo stesso tipo prima di fare il conto. Per non perdere informazione sceglie sempre il tipo più ampio. Questo si chiama promozione di tipo.

• I tipi interi piccoli salgono: char → short → int → long.
• I reali salgono: float → double.
• Un intero con un reale diventa un reale.

Esempi delle slide:

• char + int: il char diventa int, il risultato è int. Così 'A' + 2 vale 67, e 'a' - 'A' vale 32.
• int + double: l'int diventa double, il risultato è double. Così 3 + 0.5 vale 3.5.

Il passo 2 è il punto chiave: la promozione guarda un operatore alla volta, non tutta l'espressione. Lo mostra la prossima sezione.

Ecco il caso più traditore della lezione. Il risultato va in un float, eppure la divisione perde la virgola.

int main(void) {
    int x = 5, y = 2;
    float z = x / y;
    printf("La var x vale %d\n", x);
    printf("La var y vale %d\n", y);
    printf("La var z vale %f\n", z);
}

La var x vale 5
La var y vale 2
La var z vale 2.000000

Perché 2.000000 e non 2.500000? Segui il metodo: l'operatore / riceve due int, quindi fa la divisione intera, che dà 2. Solo dopo, nell'assegnamento, il 2 viene convertito in float e diventa 2.000000. Il fatto che z sia un float arriva troppo tardi: la parte frazionaria è già persa.

Il caso opposto

Le slide 20–22 fanno il contrario: due float e il risultato in un int.

float x = 5, y = 2;
int z = x / y;

Qui la divisione è tra due reali e dà 2.5, giusto. Ma poi l'assegnamento mette 2.5 in un int: la parte dopo la virgola sparisce e z vale 2. Il risultato è lo stesso del caso di prima, ma la perdita avviene in un momento diverso: nell'assegnamento, non nella divisione.

Per avere 2.5 da due int bisogna fare in modo che la divisione veda almeno un reale. Si fa con il cast esplicito: il nome del tipo tra parentesi, davanti al valore da convertire.

int x = 5, y = 2;
float z = x / (float)y;   // y convertito in float: risultato 2.5

(float)y vale 2.0, un float. Ora la divisione è tra un int e un float: per la promozione l'int sale a float, e il risultato è 2.5.

Come si legge. (float)y si legge «y convertito in float». Dopo il calcolo y è ancora un int che vale 2: il cast ha creato un valore nuovo, non ha cambiato y.

Dove si mette il cast

La posizione delle parentesi decide tutto. Con int x = 5, y = 2;, ho provato tre versioni:

Nel terzo caso il cast arriva troppo tardi: la parte dopo la virgola è persa dentro la parentesi. È lo stesso errore della sezione prima, scritto con il cast.

L'esame di Programmazione I è al PC, unico per i tre canali: appelli lunedì 25/01/2027 e giovedì 11/02/2027. CodeRunner confronta le stampe del tuo programma con quelle attese, carattere per carattere: un 2.000000 al posto di 2.500000 è un test fallito.

Gli errori che costano

1. La media tra interi. Sommare interi e dividere per il numero di elementi dà una divisione intera. Serve un cast su un operando, o una costante reale come 3.0.
2. %lf dimenticato in scanf con un double: con -Wall -Werror non compila.
3. Lo specificatore sbagliato in printf: %d con un double, o %f con un int, non compila con -Wall -Werror.
4. Il numero di cifre: se il testo chiede due cifre dopo la virgola, serve %.2f; con %f ne escono sei e il test fallisce.
5. I reali confrontati con ==: con le condizioni, nelle prossime lezioni.

float

Tipo reale, di solito 4 byte, con circa 7 cifre decimali giuste.

double

Tipo reale in doppia precisione, di solito 8 byte, con circa 15–16 cifre decimali giuste.

IEEE 754

Lo standard che descrive come sono scritti in memoria i numeri reali: segno, esponente e mantissa.

%f, %e, %g

Specificatori di printf per i reali: virgola fissa, notazione scientifica, scrittura più corta.

%lf

Specificatore di scanf per leggere un double.

math.h

Libreria del C con le funzioni matematiche: sqrt, pow, floor, ceil, round, sin, cos.

Conversione implicita

Cambio di tipo fatto dal compilatore da solo, per esempio in un assegnamento o in un'espressione mista.

Promozione di tipo

Conversione automatica degli operandi al tipo più ampio prima di un'operazione.

Cast

Conversione esplicita scritta con il tipo tra parentesi, come (float)y; vale solo per l'espressione subito a destra.

Comportamento indefinito

Situazione in cui il linguaggio non dice che cosa succede, come un double troppo grande messo in un int.

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

• So la differenza tra float e double, in byte e in cifre giuste.
• So stampare un reale con %f, %e, %g e con un numero fissato di cifre.
• So leggere un double con %lf.
• So usare sqrt e pow di math.h e so quando serve -lm.
• So che cosa si perde nelle conversioni dell'assegnamento.
• So decidere il tipo di un'espressione, operatore per operatore.
• So perché float z = 5 / 2; vale 2.0, e come correggerlo con un cast.
• So dove mettere il cast per fare una media con la virgola.