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
Esempi Pratici
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}");

⚠️ ATTENZIONE: Divisione tra Interi

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.

Problema Divisione Interi
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

💡 Quando Usare il Modulo (%)

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;
Esempio Pratico con Contatore
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
⚡ Differenza tra Prefisso e Postfisso

La posizione dell’operatore (prima o dopo la variabile) cambia il comportamento:

Post-incremento (x++)

Usa il valore prima, poi incrementa

int x = 5;
int y = x++;  // y = 5, poi x = 6
// Risultato: y=5, x=6

Pre-incremento (++x)

Incrementa prima, poi usa il valore

int a = 5;
int b = ++a;  // a = 6, poi b = 6
// Risultato: a=6, b=6

💡 Consiglio Pratico

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
Esempi Pratici
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

⚠️ Attenzione: = vs ==

  • = è 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
Esempi Pratici con Operatori Logici
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}");

📊 Tabelle di Verità

AND (&&)

  • true && true = true
  • true && false = false
  • false && true = false
  • false && false = false
OR (||)

  • true || true = true
  • true || false = true
  • false || true = true
  • false || false = false

⚡ Short-Circuit Evaluation

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".

Esempi Casting Implicito
// ✅ 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".

Esempi Casting Esplicito
// ⚠️ 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

⚠️ Rischi del Casting Esplicito

  • 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.

Parse e ToString
// ✅ 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)

🛡️ TryParse - Conversione Sicura

Usa TryParse quando l'input potrebbe non essere valido.
Evita eccezioni e rende il codice più robusto.

Esempio TryParse
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.

Program.cs - Calcolatrice Completa
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}");
    }
}

💡 Output del Programma
=== 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 TryParse per 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

🎯 Riepilogo Lezione

Operatori Appresi:

  • Matematici: +, -, *, /, %
  • Assegnazione: =, +=, -=, *=, /=
  • Incremento: ++, --
  • Confronto: ==, !=, >, <, >=, <=
  • Logici: &&, ||, !
Casting e Conversioni:

  • Casting implicito (automatico)
  • Casting esplicito (manuale)
  • Parse() per stringhe
  • TryParse() per sicurezza
  • ToString() per conversioni

Lezione 9 del Corso C# Completo

Torna in alto