Operatori e casting

Manipolare i dati con operatori matematici, logici e conversioni di tipo.

🖥️ In pratica con Windows Forms: Variabili, tipi di dato e operatori.

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.

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.

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.

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

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.

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
}

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

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("=== CALCOLATORE IMC ===\n");

        // Input peso
        Console.Write("Inserisci il peso (kg): ");
        string inputPeso = Console.ReadLine();

        // Input altezza
        Console.Write("Inserisci l'altezza (cm): ");
        string inputAltezza = Console.ReadLine();

        // Validazione con TryParse
        if (!double.TryParse(inputPeso, out double peso))
        {
            Console.WriteLine("Peso non valido!");
            return;
        }

        if (!double.TryParse(inputAltezza, out double altezzaCm))
        {
            Console.WriteLine("Altezza non valida!");
            return;
        }

        // Conversione cm → metri
        double altezzaM = altezzaCm / 100.0;

        // Calcolo IMC
        double imc = peso / (altezzaM * altezzaM);

        // Output
        Console.WriteLine($"\nPeso: {peso} kg");
        Console.WriteLine($"Altezza: {altezzaM:F2} m");
        Console.WriteLine($"IMC: {imc:F2}");

        // Determinazione categoria
        if (imc < 18.5)
            Console.WriteLine("Categoria: Sottopeso");
        else if (imc >= 18.5 && imc < 25)
            Console.WriteLine("Categoria: Normopeso");
        else if (imc >= 25 && imc < 30)
            Console.WriteLine("Categoria: Sovrappeso");
        else
            Console.WriteLine("Categoria: Obesità");
    }
}

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

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("=== CONVERTITORE TEMPERATURA ===\n");

        // Celsius → Fahrenheit
        Console.Write("Temperatura in Celsius: ");
        string inputCelsius = Console.ReadLine();

        if (double.TryParse(inputCelsius, out double celsius))
        {
            // Formula: (C × 9/5) + 32
            // ⚠️ IMPORTANTE: usa 9.0/5.0 per evitare divisione intera!
            double fahrenheit = (celsius * 9.0 / 5.0) + 32;

            Console.WriteLine($"{celsius:F2}°C = {fahrenheit:F2}°F");
        }
        else
        {
            Console.WriteLine("Valore non valido!");
            return;
        }

        // Fahrenheit → Celsius
        Console.Write("\nTemperatura in Fahrenheit: ");
        string inputFahrenheit = Console.ReadLine();

        if (double.TryParse(inputFahrenheit, out double fahr))
        {
            // Formula: (F - 32) × 5/9
            double celsiusRisultato = (fahr - 32) * 5.0 / 9.0;

            Console.WriteLine($"{fahr:F2}°F = {celsiusRisultato:F2}°C");
        }
        else
        {
            Console.WriteLine("Valore non valido!");
        }
    }
}

🎯 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