1. Introduzione
Hai mai provato a infilare un'anguria in una bottiglia? Ecco, C# si trova davanti a una roba simile ogni volta che gli chiedi di assegnare una variabile di un tipo a un altro. A volte è facile (trasformare un numero piccolo in uno grande — come mettere una mela in una valigia), altre volte serve attenzione (anguria nella bottiglia — qui senza problemi non si va avanti).
Conversione di tipo — è l'operazione di trasformare un valore da un tipo di dato a un altro. Serve spesso quando vuoi sommare o confrontare valori di tipi diversi, o passarli a metodi che accettano solo un certo tipo.
Nella vita reale i programmatori ci sbattono la testa sempre: fai un pagamento, calcoli sconti, fai calcoli fisici o, per esempio, fai il parsing di numeri inseriti dall'utente da tastiera (lì arriva tutto come stringa).
2. Conversione implicita dei tipi (Implicit Conversion)
Che roba è?
La conversione implicita è quando C# decide da solo che si può "spostare" i dati da un tipo all'altro senza problemi. Succede tutto in automatico — tu non scrivi nulla, usi solo i valori.
- Il compilatore non si lamenta.
- Non servono comandi speciali o cast.
- Nessuna perdita di dati (beh, quasi mai).
Esempio di conversione implicita
int a = 42;
double b = a; // Conversione implicita int -> double
Console.WriteLine(b); // 42 (ma ora è 42.0)
Qui a di tipo int diventa automaticamente double quando lo assegni alla variabile b. Nessuna perdita di dati, perché tutti i valori int ci stanno tranquillamente in un double.
Qui a di tipo int diventa automaticamente double quando lo assegni alla variabile b. Nessuna perdita di dati, perché tutti i valori int ci stanno tranquillamente in un double.
Quando funziona?
- Quando il tipo di destinazione è più largo del tipo di origine — supporta un range di dati più ampio.
- Nessuna perdita di dati.
- Esempi:
- int → long
- int → float / double
- float → double
- char → int
Altro esempio:
byte x = 100;
int y = x; // byte -> int (tutti i valori byte stanno nel range di int)
Tabella delle conversioni implicite per i tipi numerici
| From | To |
|---|---|
|
|
|
|
|
|
|
|
3. Conversione esplicita dei tipi (Explicit Conversion, Type Cast)
Quando la magia non basta?
A volte il compilatore non può garantire che la conversione sia sicura e ti chiede di prenderti la responsabilità — devi dire esplicitamente che sei consapevole dei rischi.
- Potresti perdere dei dati.
- Il formato del valore può cambiare.
- A volte la conversione è proprio impossibile — ottieni un errore.
Come si scrive la conversione esplicita?
Si usa la sintassi tra parentesi (cast):
double pi = 3.1415;
int wholePi = (int)pi; // Conversione esplicita double -> int
Console.WriteLine(wholePi); // 3 (la parte decimale viene buttata via!)
Quando si usa?
- Quando il tipo di destinazione è più stretto del tipo di origine — il range di valori del destinatario è più piccolo di quello della sorgente.
- Possibile perdita della parte decimale, dati, overflow.
- Esempi:
- double → int
- long → int
- int → byte
- Quasi tutti i passaggi tra tipi non compatibili.
4. Vediamo qualche esempio
1) Perdiamo dati? Vediamo!
Conversione implicita — tutto ok!
int small = 25;
long big = small; // Conversione implicita (int -> long)
Console.WriteLine(big); // 25
Conversione esplicita — zona pericolosa!
int big = 1000;
byte small = (byte)big; // Conversione esplicita (int -> byte)
Console.WriteLine(small); // 232 (!), perché 1000 non ci sta in byte (0..255)
Qui il risultato è il "magico" 232, perché 1000 % 256 == 232.
2) Con i numeri floating point (double, float)
double number = 9.99;
int approximate = (int)number; // la parte decimale viene semplicemente buttata via
Console.WriteLine(approximate); // 9
3) Conversione tra interi e floating (double ↔ int)
int apples = 5;
double exactApples = apples; // int -> double (implicita)
Console.WriteLine(exactApples); // 5.0
double bananaWeight = 2.77;
int weightForReport = (int)bananaWeight; // double -> int (esplicita)
Console.WriteLine(weightForReport); // 2
5. Che fare con la conversione delle stringhe: Parse e Convert
La conversione di tipo non funziona tra numeri e stringhe! Qui servono metodi speciali, tipo:
string strNumber = "123";
int num = int.Parse(strNumber); // oppure Convert.ToInt32(strNumber);
Ma il contrario (int → string) succede automaticamente quando concateni le stringhe:
int number = 42;
string message = "Risposta: " + number; // Conversione implicita int → string
6. Errori nella conversione dei tipi
Lezione di storia: una volta qualcuno si è dimenticato di fare la conversione esplicita, e il pagamento finale è stato 250 volte più basso del dovuto... Ragazzi, fate attenzione!
Errore tipico: provare a convertire implicitamente un tipo dove si può perdere dati.
int big = 500;
byte small = big; // Compilatore: "Non si può! Possibile perdita di dati!"
Qui serve la conversione esplicita:
byte small = (byte)big; // Ma rischi di perdere dati!
Altro bug popolare — ti dimentichi della parte decimale:
double x = 2.9;
int y = (int)x; // y == 2, la parte decimale sparisce
Per arrotondare secondo le regole matematiche, usa Math.Round:
int y = (int)Math.Round(x); // y == 3
7. Trappole della conversione
- Perdita di dati. Controlla sempre che il valore non esca dal range consentito dal tipo. Per esempio, int va da -2 147 483 648 a 2 147 483 647, mentre byte — solo 0–255.
- Arrotondamento. La conversione normale ((int)x) butta via la parte decimale. Per arrotondare bene usa Math.Round, Math.Floor, Math.Ceiling.
- Letterali numerici. Occhio che scrivere 3 / 2 dà 1 (divisione intera), mentre 3.0 / 2 — già 1.5 (double)!
- Operazioni tra tipi misti. Se in un'espressione mischi, per esempio, int e double, il risultato sarà di tipo double.
GO TO FULL VERSION