Operatori e Casting in C#
Manipolare i dati con operatori matematici, logici e conversioni di tipo
🎯 Cosa Imparerai in Questa Lezione
Gli operatori sono i simboli che permettono di eseguire operazioni sui dati:
calcoli matematici, confronti, decisioni logiche. Il casting è invece il
processo di conversione tra diversi tipi di dato. Padroneggiare questi concetti è fondamentale
per scrivere programmi efficaci.
➕ Operatori Matematici
Gli operatori matematici in C# sono simili a quelli dell’algebra. Permettono di eseguire
operazioni aritmetiche di base sui numeri.
| Operatore | Descrizione | Esempio | Risultato |
|---|---|---|---|
+ |
Addizione | int somma = 8 + 5; |
13 |
- |
Sottrazione | int diff = 10 - 4; |
6 |
* |
Moltiplicazione | int prod = 3 * 6; |
18 |
/ |
Divisione | double quot = 12.0 / 5.0; |
2.4 |
% |
Modulo (resto) | int resto = 17 % 3; |
2 |
int a = 10;
int b = 3;
int somma = a + b; // 13
int differenza = a - b; // 7
int prodotto = a * b; // 30
int quoziente = a / b; // 3 (divisione intera!)
int resto = a % b; // 1
Console.WriteLine($"Somma: {somma}");
Console.WriteLine($"Resto: {resto}");
In C#, quando si divide due numeri interi, il risultato è sempre un intero
(la parte decimale viene troncata, non arrotondata). Per ottenere un risultato decimale,
almeno uno degli operandi deve essere un numero decimale.
int a = 5; int b = 2; // ❌ PROBLEMA: divisione tra interi int risultatoIntero = a / b; // 2 (parte decimale PERSA!) // ✅ SOLUZIONE 1: casting a double double risultato1 = (double)a / b; // 2.5 // ✅ SOLUZIONE 2: casting del secondo operando double risultato2 = a / (double)b; // 2.5 // ✅ SOLUZIONE 3: usa numeri decimali direttamente double risultato3 = 5.0 / 2; // 2.5 double risultato4 = 5 / 2.0; // 2.5
L’operatore modulo è molto utile per:
- Verificare numeri pari/dispari:
numero % 2 == 0(pari) - Ciclare in un range:
indice % 10(valori 0-9) - Convertire secondi:
secondi % 60(resto dopo i minuti)
📝 Operatori di Assegnazione
Gli operatori di assegnazione combinano un’operazione matematica con l’assegnazione del risultato.
Rendono il codice più conciso e leggibile.
| Operatore | Descrizione | Esempio | Equivalente a |
|---|---|---|---|
= |
Assegnazione semplice | x = 5; |
– |
+= |
Addizione e assegnazione | x += 3; |
x = x + 3; |
-= |
Sottrazione e assegnazione | x -= 2; |
x = x - 2; |
*= |
Moltiplicazione e assegnazione | x *= 4; |
x = x * 4; |
/= |
Divisione e assegnazione | x /= 2; |
x = x / 2; |
%= |
Modulo e assegnazione | x %= 3; |
x = x % 3; |
int punteggio = 100;
// Operazioni con assegnazione composta
punteggio += 50; // punteggio diventa 150
punteggio -= 20; // punteggio diventa 130
punteggio *= 2; // punteggio diventa 260
punteggio /= 4; // punteggio diventa 65
Console.WriteLine($"Punteggio finale: {punteggio}"); // 65
⬆️ Operatori di Incremento e Decremento
Gli operatori ++ e -- sono scorciatoie per aumentare o diminuire
una variabile di 1. Sono molto comuni nei cicli.
| Operatore | Descrizione | Esempio | Risultato |
|---|---|---|---|
++ |
Incremento di 1 | x++; o ++x; |
x = x + 1 |
-- |
Decremento di 1 | x--; o --x; |
x = x – 1 |
La posizione dell’operatore (prima o dopo la variabile) cambia il comportamento:
Usa il valore prima, poi incrementa
int x = 5; int y = x++; // y = 5, poi x = 6 // Risultato: y=5, x=6
Incrementa prima, poi usa il valore
int a = 5; int b = ++a; // a = 6, poi b = 6 // Risultato: a=6, b=6
Nella maggior parte dei casi, usa x++ o ++x da soli su una riga.
Evita di usarli in espressioni complesse per mantenere il codice chiaro e leggibile.
🔍 Operatori di Confronto
Gli operatori di confronto confrontano due valori e restituiscono un valore booleano
(true o false). Sono fondamentali per le istruzioni condizionali.
| Operatore | Descrizione | Esempio | Risultato |
|---|---|---|---|
== |
Uguale a | 5 == 5 |
true |
!= |
Diverso da | 5 != 3 |
true |
> |
Maggiore di | 5 > 3 |
true |
< |
Minore di | 5 < 3 |
false |
>= |
Maggiore o uguale a | 5 >= 5 |
true |
<= |
Minore o uguale a | 5 <= 3 |
false |
int eta = 18;
int etaMinima = 18;
bool maggiorenne = eta >= etaMinima; // true
bool minorenne = eta < etaMinima; // false
Console.WriteLine($"È maggiorenne? {maggiorenne}"); // True
// Confronto stringhe
string password = "secret123";
bool passwordCorretta = password == "secret123"; // true
=è l'assegnazione:x = 5;(assegna 5 a x)==è il confronto:x == 5(verifica se x vale 5)
Confondere i due è un errore comune! Il compilatore spesso ti avviserà.
🧮 Operatori Logici
Gli operatori logici permettono di combinare più espressioni booleane per creare condizioni complesse.
| Operatore | Descrizione | Esempio | Risultato |
|---|---|---|---|
&& |
AND logico (entrambi veri) | true && false |
false |
|| |
OR logico (almeno uno vero) | true || false |
true |
! |
NOT logico (inversione) | !true |
false |
int eta = 25;
bool haPatente = true;
bool haAssicurazione = false;
// AND (&&) - entrambe le condizioni devono essere vere
bool puoGuidare = eta >= 18 && haPatente; // true
// OR (||) - almeno una condizione deve essere vera
bool necessitaDocumenti = !haPatente || !haAssicurazione; // true
// NOT (!) - inverte il valore booleano
bool minorenne = !(eta >= 18); // false
Console.WriteLine($"Può guidare? {puoGuidare}");
Console.WriteLine($"Minorenne? {minorenne}");
- true && true = true
- true && false = false
- false && true = false
- false && false = false
- true || true = true
- true || false = true
- false || true = true
- false || false = false
C# utilizza la valutazione a corto circuito:
- Con
&&, se la prima condizione èfalse, la seconda non viene valutata - Con
||, se la prima condizione ètrue, la seconda non viene valutata
Questo può migliorare le prestazioni ed evitare errori!
🔄 Casting e Conversioni di Tipo
Il casting è il processo di conversione di un valore da un tipo di dato a un altro.
In C# esistono diversi modi per convertire i tipi.
Casting Implicito (Automatico)
Avviene automaticamente quando non c'è rischio di perdita di dati.
Si passa da un tipo "più piccolo" a uno "più grande".
// ✅ SICURO: int → long (sempre ok) int numeroIntero = 100; long numeroLong = numeroIntero; // casting implicito // ✅ SICURO: int → double (sempre ok) int x = 10; double y = x; // casting implicito, y = 10.0 // ✅ SICURO: float → double float f = 3.14f; double d = f; // casting implicito
Casting Esplicito (Manuale)
Richiede una sintassi specifica quando c'è rischio di perdita di dati.
Si passa da un tipo "più grande" a uno "più piccolo".
// ⚠️ ATTENZIONE: double → int (perde decimali) double numeroDecimale = 10.75; int numeroIntero = (int)numeroDecimale; // 10 (troncamento!) // ⚠️ ATTENZIONE: long → int (rischio overflow) long grandeNumero = 5000000000; int piccolo = (int)grandeNumero; // ATTENZIONE: possibile overflow! // Casting con arrotondamento double prezzo = 19.99; int prezzoArrotondato = (int)Math.Round(prezzo); // 20
- Perdita di precisione:
10.99 → 10(decimali troncati) - Overflow: Numero troppo grande per il tipo destinazione
- Valori imprevisti: Il risultato potrebbe non essere quello atteso
Metodi di Conversione
C# fornisce metodi specifici per convertire tra tipi, specialmente da e verso stringhe.
// ✅ Da stringa a numero con Parse
string testoPrezzoNumero = "123";
int numero = int.Parse(testoNumero); // 123
string testoDecimale = "19.99";
double prezzo = double.Parse(testoDecimale); // 19.99
// ✅ Da numero a stringa con ToString
int x = 42;
string s = x.ToString(); // "42"
double pi = 3.14159;
string piStringa = pi.ToString("F2"); // "3.14" (2 decimali)
Usa TryParse quando l'input potrebbe non essere valido.
Evita eccezioni e rende il codice più robusto.
string input = "abc123"; // Input non valido!
// ❌ Parse lancerebbe un'eccezione
// int numero = int.Parse(input); // ERRORE!
// ✅ TryParse gestisce l'errore
if (int.TryParse(input, out int risultato))
{
Console.WriteLine($"Numero valido: {risultato}");
}
else
{
Console.WriteLine("Input non valido!"); // Questo viene eseguito
}
// Esempio con input valido
string inputValido = "42";
if (int.TryParse(inputValido, out int numero))
{
Console.WriteLine($"Numero: {numero}"); // Output: Numero: 42
}
| Metodo | Descrizione | Esempio |
|---|---|---|
int.Parse() |
Stringa → int (lancia eccezione se fallisce) | int.Parse("123") |
int.TryParse() |
Stringa → int (ritorna bool) | int.TryParse("123", out int n) |
.ToString() |
Qualsiasi tipo → stringa | numero.ToString() |
Convert.ToInt32() |
Conversione generica a int | Convert.ToInt32("123") |
🚀 Esempio Completo: Calcolatrice
Vediamo un programma completo che utilizza tutti gli operatori e le conversioni apprese.
using System;
class Program
{
static void Main()
{
Console.WriteLine("=== CALCOLATRICE C# ===\n");
// OPERATORI MATEMATICI
int a = 10, b = 3;
Console.WriteLine("--- Operatori Matematici ---");
Console.WriteLine($"{a} + {b} = {a + b}"); // 13
Console.WriteLine($"{a} - {b} = {a - b}"); // 7
Console.WriteLine($"{a} * {b} = {a * b}"); // 30
Console.WriteLine($"{a} / {b} = {a / b}"); // 3 (intero)
Console.WriteLine($"{a} / {b} = {(double)a / b:F2}"); // 3.33
Console.WriteLine($"{a} % {b} = {a % b}"); // 1
// OPERATORI DI CONFRONTO
Console.WriteLine("\n--- Operatori di Confronto ---");
Console.WriteLine($"{a} > {b}: {a > b}"); // True
Console.WriteLine($"{a} == {b}: {a == b}"); // False
Console.WriteLine($"{a} != {b}: {a != b}"); // True
// OPERATORI LOGICI
Console.WriteLine("\n--- Operatori Logici ---");
bool vero = true, falso = false;
Console.WriteLine($"true && false: {vero && falso}"); // False
Console.WriteLine($"true || false: {vero || falso}"); // True
Console.WriteLine($"!true: {!vero}"); // False
// CASTING E CONVERSIONI
Console.WriteLine("\n--- Casting ---");
double d = 123.456;
int i = (int)d; // casting esplicito
Console.WriteLine($"Double: {d}, Int: {i}");
// CONVERSIONE DA STRINGA
Console.WriteLine("\n--- Conversione Stringhe ---");
string input = "42";
// Metodo 1: Parse
int numero1 = int.Parse(input);
Console.WriteLine($"Parse: '{input}' → {numero1}");
// Metodo 2: TryParse (sicuro)
string inputNonValido = "abc";
if (int.TryParse(inputNonValido, out int numero2))
{
Console.WriteLine($"Valido: {numero2}");
}
else
{
Console.WriteLine($"'{inputNonValido}' non è un numero valido");
}
// ESEMPIO PRATICO: Calcolo sconto
Console.WriteLine("\n--- Esempio Pratico ---");
decimal prezzoOriginale = 100.00m;
double percentualeSconto = 0.20; // 20%
decimal sconto = prezzoOriginale * (decimal)percentualeSconto;
decimal prezzoFinale = prezzoOriginale - sconto;
Console.WriteLine($"Prezzo: {prezzoOriginale:C}");
Console.WriteLine($"Sconto: {percentualeSconto:P0}");
Console.WriteLine($"Prezzo finale: {prezzoFinale:C}");
}
}
=== CALCOLATRICE C# === --- Operatori Matematici --- 10 + 3 = 13 10 - 3 = 7 10 * 3 = 30 10 / 3 = 3 10 / 3 = 3.33 10 % 3 = 1 --- Operatori di Confronto --- 10 > 3: True 10 == 3: False 10 != 3: True --- Operatori Logici --- true && false: False true || false: True !true: False --- Casting --- Double: 123.456, Int: 123 --- Conversione Stringhe --- Parse: '42' → 42 'abc' non è un numero valido --- Esempio Pratico --- Prezzo: €100.00 Sconto: 20% Prezzo finale: €80.00
💪 Esercizi Pratici
📝 Esercizio 1: Calcolatore IMC Avanzato
Crea un programma che calcola l'IMC (Indice Massa Corporea) con validazione:
- Chiedi peso (kg) e altezza (cm) come stringhe
- Usa
TryParseper validare l'input - Converti l'altezza da cm a metri
- Calcola IMC:
peso / (altezza * altezza) - Determina la categoria usando operatori logici
📝 Esercizio 2: Convertitore Temperatura
Crea un programma che converte temperature tra Celsius e Fahrenheit:
- Formula C → F:
(C × 9/5) + 32 - Formula F → C:
(F - 32) × 5/9 - Usa il casting corretto per evitare divisione intera
- Formatta l'output a 2 decimali
- Matematici: +, -, *, /, %
- Assegnazione: =, +=, -=, *=, /=
- Incremento: ++, --
- Confronto: ==, !=, >, <, >=, <=
- Logici: &&, ||, !
- Casting implicito (automatico)
- Casting esplicito (manuale)
- Parse() per stringhe
- TryParse() per sicurezza
- ToString() per conversioni
Lezione 9 del Corso C# Completo