Complemento a 2 e virgola mobile in terza al tecnico

Fine settembre 2026, terza al tecnico, articolazione Informatica e Telecomunicazioni: TPSIT ha aperto l’anno con il primo modulo del programma, la codifica dell’informazione, ed è entrato — o sta per entrare, fra fine settembre e ottobre — nel punto più denso: conversioni di base, complemento a 2, algebra booleana. La prima verifica scritta cade di solito fra cinque e sei settimane, quindi fra fine ottobre e inizio novembre, ed è quasi sempre calcolo puro: conversioni ed esercizi numerici da fare a mano, senza spazio per “spiegare a parole” se il conto non torna.

Le conversioni di base (decimale, binario, esadecimale) di solito le hai già viste in prima; se ti servono da ripassare in fretta, il metodo passo passo è in binario ed esadecimale in prima al tecnico — qui parto da dove quel post si ferma e do le conversioni per acquisite. Il pezzo nuovo di quest’anno è rappresentare numeri con il segno, e più avanti anche numeri non interi: è lì che nasce il complemento a 2, ed è lì che arriva la virgola mobile.

Il problema: come si rappresenta un numero negativo in binario?

Un byte non ha un simbolo per il “meno”. Ha solo 8 celle che possono contenere 0 o 1. Per rappresentare interi con segno servono convenzioni che decidano, tra le $2^8=256$ configurazioni possibili di un byte, quali contano come positive e quali come negative. Le convenzioni storiche sono tre; le prime due sono utili per capire perché si usa la terza.

Modulo e segno: l’idea più intuitiva, ma con un difetto

L’idea più naturale è dedicare un bit al segno (di solito il più significativo, a sinistra: 0 per positivo, 1 per negativo) e i bit restanti al valore assoluto. Su 4 bit, $+5$ si scrive $0101$ e $-5$ si scrive $1101$. Il difetto emerge subito con lo zero: $+0=0000$ e $-0=1000$ sono due configurazioni diverse per lo stesso numero, quindi su $n$ bit restano solo $2^n-1$ valori distinti utili, non $2^n$. Inoltre sommare due numeri così non funziona con la somma binaria diretta: bisogna prima controllare i segni e poi decidere se sommare o sottrarre i moduli — per un circuito semplice ed economico, è un problema.

Complemento a 1: un passo avanti, non ancora la soluzione

Il complemento a 1 di un numero si ottiene invertendo ogni bit. Su 4 bit, $+5=0101$ e il suo complemento a 1 è $1010$. La somma torna a funzionare con la logica binaria consueta, ma il problema dello zero doppio resta: $+0=0000$ e il suo complemento a 1 è $1111$, letto ancora come "$-0$". Due zeri distinti, di nuovo un valore rappresentabile in meno del possibile.

Complemento a 2: la convenzione che si usa davvero

Il complemento a 2 risolve il problema in un colpo solo: si prende il complemento a 1 e gli si somma 1. Su 4 bit, il complemento a 2 di $+0=0000$ è: inverti → $1111$, aggiungi 1 → $10000$, che scartando il riporto in eccesso (resti sempre dentro $n$ bit) torna a $0000$. Un solo zero, e lo zero negativo semplicemente non esiste più come configurazione a sé.

Ci sono due modi equivalenti per ottenere o leggere un numero in complemento a 2, ed entrambi servono: il primo per costruire una rappresentazione da un numero decimale, il secondo per leggerne una velocemente in verifica senza rifare tutti i passaggi.

Metodo 1 — inverti e aggiungi 1. Per rappresentare $-A$ su $n$ bit: scrivi $A$ in binario su $n$ bit, inverti ogni bit, somma 1 al risultato.

Metodo 2 — peso negativo del bit più significativo. Per leggere il valore di un numero già scritto in complemento a 2, il bit più a sinistra (il più significativo) non vale $+2^{n-1}$ come negli interi senza segno: vale $-2^{n-1}$. Tutti gli altri bit mantengono il peso positivo consueto:

I due metodi devono dare sempre lo stesso risultato: uno costruisce la rappresentazione, l’altro la verifica. Il primo esercizio svolto più sotto usa entrambi sullo stesso numero.

Il range rappresentabile su n bit

Con $n$ bit in complemento a 2 si rappresentano $2^n$ valori, distribuiti in modo asimmetrico fra negativi e positivi:

Su 8 bit: da $-128$ a $127$. L’asimmetria (un negativo in più) è conseguenza diretta dell’avere un solo zero: lo zero conta come non-negativo, quindi il lato positivo ha un valore in meno di quello che avrebbe altrimenti.

Somma e sottrazione: la stessa addizione binaria, sempre

Il vantaggio pratico del complemento a 2 è che la sottrazione non serve come operazione a sé: $A-B$ si calcola come $A+(-B)$, dove $-B$ è il complemento a 2 di $B$, e si somma con la normale addizione binaria in colonna — nessun controllo di segno, nessuna logica speciale.

Un esempio: $50-70$ su 8 bit diventa $50+(-70)$. Scrivo $70=01000110$, lo complemento: inverto → $10111001$, aggiungo 1 → $10111010$ (questo è $-70$). Sommo:

  0 0 1 1 0 0 1 0    (50)
+ 1 0 1 1 1 0 1 0    (-70)
-------------------
  1 1 1 0 1 1 0 0

Qui nessun riporto esce dal bit più a sinistra; se ci fosse, si scarterebbe (si resta sempre su 8 bit). Leggo il risultato con il metodo del peso negativo: $-128+64+32+8+4=-20$. Corretto: $50-70=-20$.

Overflow: non è lo stesso del riporto

Il riporto (carry) è quello che esce dal bit più significativo durante una somma. L’overflow, in complemento a 2, è un concetto diverso: significa che il risultato di un’operazione tra due numeri con segno non rientra nel range $[-2^{n-1},2^{n-1}-1]$, anche se formalmente la somma binaria “torna” perfettamente.

La regola pratica per riconoscerlo: l’overflow può avvenire solo sommando due numeri dello stesso segno, e si manifesta come un risultato che ha il segno sbagliato. Sommando un positivo e un negativo il risultato è sempre rappresentabile e l’overflow non può capitare — è il caso di $50-70$ appena visto: c’è stato un riporto scartato, ma nessun overflow. Il secondo esercizio più sotto mostra il caso in cui l’overflow scatta davvero.

Estensione del segno

Quando un numero in complemento a 2 va spostato su un registro più largo (da 8 a 16 bit, per esempio), non basta aggiungere zeri a sinistra come si farebbe con un numero senza segno: bisogna ripetere il bit di segno in tutte le posizioni nuove. Un numero negativo su 4 bit, $-5=1011$, esteso a 8 bit diventa $11111011$, non $00001011$ (che varrebbe $+11$, un numero completamente diverso). Ripetere l’1 di segno mantiene invariato il valore; ripetere zeri lo distruggerebbe.

Virgola mobile IEEE 754, singola precisione

Il complemento a 2 rappresenta interi. Per numeri non interi — con una parte decimale — lo standard quasi universale è IEEE 754, e nella versione a singola precisione usa 32 bit divisi in tre campi:

Il bias evita di rappresentare l’esponente con un segno a parte: si somma sempre 127 prima di scriverlo, e lo si sottrae per leggerlo. La mantissa sfrutta un fatto della normalizzazione binaria: un numero non nullo, in notazione scientifica in base 2, ha sempre la forma $1,xxxx\times 2^e$ — il bit prima della virgola è sempre 1, quindi non serve memorizzarlo. È il bit implicito: un bit di precisione gratis, perché non lo scrivi mai ma lo consideri sempre presente in lettura.

Come si converte un numero decimale

Il procedimento per convertire un numero decimale in IEEE 754 singola precisione ha sempre gli stessi passi:

1. Converti la parte intera e la parte decimale separatamente in binario.
2. Scrivi il numero come $1,xxxx\times 2^e$ (normalizzazione: sposti la virgola finché resta un solo 1 prima di essa).
3. L’esponente da memorizzare è $e+127$, scritto in binario su 8 bit (senza segno: il bias ha già assorbito il negativo).
4. La mantissa da memorizzare sono le cifre dopo la virgola della forma normalizzata, completate con zeri fino a 23 bit.
5. Il bit di segno è 0 o 1 a seconda del segno del numero originale.

Il primo esercizio svolto sotto applica questi cinque passi per intero su $-6,75$.

Perché 0,1 non è mai esatto in virgola mobile

Non tutti i numeri decimali hanno una rappresentazione binaria finita, e $0,1$ è l’esempio più citato. Convertendolo con le moltiplicazioni successive per 2 si ottiene una sequenza che non finisce mai:

con il blocco $0011$ che si ripete all’infinito, come $\frac{1}{3}=0,333\dots$ in base 10. La mantissa ha solo 23 bit: quella sequenza va tagliata e arrotondata, quindi il valore memorizzato è il più vicino possibile a 0,1, non 0,1 esatto. È per questo, non per un bug del linguaggio, che 0.1 + 0.2 stampa quasi ovunque 0.30000000000000004 invece di 0.3: entrambi gli addendi sono già approssimati prima di essere sommati.

Tre esercizi svolti

1. Rappresentare $-45$ su 8 bit in complemento a 2

Scrivo $45$ in binario su 8 bit: $45=32+8+4+1=00101101$.

Inverto ogni bit (complemento a 1): $11010010$.

Aggiungo 1: $11010011$.

Quindi $-45$ su 8 bit in complemento a 2 è $11010011$. Verifico con il metodo del peso negativo, senza rifare i passaggi da capo: il bit più a sinistra vale $-128$, gli altri hanno peso positivo normale.

Torna: $-1\cdot 128+1\cdot 64+0\cdot 32+1\cdot 16+0\cdot 8+0\cdot 4+1\cdot 2+1\cdot 1=-45$.

2. Somma con overflow su 8 bit

Sommo $100$ e $50$, entrambi positivi, su 8 bit: $100=01100100$, $50=00110010$.

  0 1 1 0 0 1 0 0    (100)
+ 0 0 1 1 0 0 1 0    (50)
-------------------
  1 0 0 1 0 1 1 0

Il risultato binario è $10010110$. Letto come numero con segno (bit più a sinistra $=1$, quindi negativo): $-128+16+4+2=-106$. Ma $100+50=150$ in aritmetica normale, e $150$ supera il massimo rappresentabile su 8 bit con segno ($127$): è overflow. Il segnale che lo tradisce, oltre al fatto che $150>127$: ho sommato due numeri positivi e ho ottenuto un risultato che si legge come negativo — per la regola vista sopra, questo può succedere solo in presenza di overflow, mai in una somma corretta.

3. $-6,75$ in IEEE 754 singola precisione, in esadecimale

Parte intera $6=110_2$; parte decimale $0,75=0,11_2$ (perché $0,75=\frac{1}{2}+\frac{1}{4}$). Quindi $6,75=110,11_2$.

Normalizzo: $110,11_2=1,1011\times 2^2$.

• Segno: $1$ (il numero è negativo).
• Esponente: $2+127=129=10000001_2$.
• Mantissa: le cifre dopo la virgola normalizzata, $1011$, completate a 23 bit con zeri: $10110000000000000000000$.

I 32 bit completi, segno-esponente-mantissa:

Raggruppo in nibble da 4 bit per leggerli in esadecimale: $11000000110110000000000000000000$, cioè $\text{C},0,\text{D},8,0,0,0,0$.

Una nota onesta: le nostre simulazioni per la scuola coprono matematica e fisica, non ancora informatica. Se in terza ti preoccupa anche la matematica, lì trovi una verifica simulata per argomento: la risposta corretta di ogni domanda è gratis, la soluzione guidata si sblocca con la prima lezione.

Errori tipici

• Dimenticare di scartare il riporto in eccesso dopo aver aggiunto 1 nel complemento a 2 di $0$, o in generale dopo una somma che produce un riporto oltre gli $n$ bit disponibili: si resta sempre dentro il numero di bit dato.
• Confondere riporto e overflow. Un riporto in uscita dal bit più significativo non è di per sé overflow (vedi l’esempio $50-70$ sopra, dove c’è riporto ma non overflow): l’overflow si controlla sul segno del risultato rispetto ai segni degli operandi, non sul riporto.
• Estendere il segno con zeri invece che ripetendo il bit più significativo, che su un numero negativo cambia completamente il valore.
• Dimenticare il bit implicito nella mantissa IEEE 754, sia scrivendolo esplicitamente per errore sia dimenticandolo in lettura quando si riconverte un numero da esadecimale a decimale.
• Arrotondare male l’esponente con bias: l’esponente memorizzato è sempre $e+127$, mai $e$ da solo — un errore di segno qui sposta il numero di potenze di due enormi.

Dove torna più avanti

Il complemento a 2 non resta confinato a questo modulo: è così che una CPU reale — quella di cui hai visto lo schema in architettura di Von Neumann e CPU — rappresenta gli interi in memoria e nell’ALU.

Il resto del programma di informatica, cicli e array compresi, è raccontato in cicli annidati e array in terza informatica; il quadro completo della materia è sulla pagina di informatica. Se vuoi una mano a preparare la verifica di fine ottobre, parti da una chiamata conoscitiva gratuita: mezz’ora per capire dove concentrare gli ultimi ripassi.