GLI OPERATORI

  • CAST E OPERATORI IN C SHARP GLI OPERATORI MATEMATICI

Supponiamo di avere due variabili x e y con i seguenti valori:

int x = 8;

int y = 4;

Operatore

Descrizione

Esempio

+

Somma o Concatenazione

x + y = 12

–

Sottrazione

x – y = 4

*

Moltiplicazione

x * y = 32

/

Divisione

x / y = 2

%

Modulo (restituisce il resto di una divisione intera)

x % y = 0

++

Incremento

x++ = 9

—

Decremento

x– = 7

                                                   

OPERANDO     OPERATORE        OPERANDO

        8                           +                          4

C sharpIn C #, un operatore è un elemento di programma che viene applicato a uno o più operandi in un’espressione o istruzione. Gli operatori che accettano un operando, come l’operatore di incremento (++), sono indicati come operatori unari. Gli operatori che accettano due operandi, come gli operatori aritmetici (+, -, *, /), sono indicati come operatori binari. Un operatore, l’operatore condizionale (? :), prende tre operandi ed è l’unico operatore ternario in C #.

Una espressione è un’operazione valutata a runtime ad esempio:

Per quanto riguarda la precedenza tra gli operatori si seguono le stesse regole dell’aritmetica, quindi nel caso precedente x vale 19. Volendo si può modificare la precedenza tra gli operatori usando le parentesi tonde.

int x = (9 + 5) * 2 = 28

  • CAST E OPERATORI IN C SHARP GLI OPERATORI DI RELAZIONE O DI CONFRONTO

Sono utilizzati in C#, così come in molti altri linguaggi di programmazione, per effettuare dei confronti tra variabili, al fine di prendere delle decisioni (e controllare così il flusso di esecuzione del programma).

Operatore

Descrizione

Esempio

==

Verifica una uguaglianza

(x == y) // false

!=

Verifica una diversità

(x! = y) // true

>

Maggiore

(x > y) // true

<

Minore

(x < y) // false

>=

Maggiore o uguale

(x >= y) // true

<=

Minore o uguale

(x <= y) // false

  • CAST E OPERATORI IN C SHARP GLI OPERATORI LOGICI

Gli operatori logici sono tre: AND, OR e NOT. Sono utilizzati per creare condizioni complesse e articolate basate sul verificarsi o meno di una serie di situazioni. Conosciamo già questi operatori e le loro tabelle di verità da quando abbiamo parlato di elettronica digitale.

Operatore

Descrizione

Esempio

&&

AND

(x > 9 && y < 5) // false.

||

OR

(x > 9 || y < 5) // true.

!

NOT

! (x > 9 && y < 5) // true

  • CAST E OPERATORI IN CSHARP GLI OPERATORI DI ASSEGNAZIONE

Questi operatori sono utilizzati per assegnare un valore ad una variabile.

Operatore

Descrizione

Esempio

=

Assegnazione

x = 10 (assegna a x il valore 10)

+=

Assegnazione con addizione

x += y è equivalente a x = x + y

-=

Assegnazione con sottrazione

x -= y è equivalente a x = x – y

*=

Assegnazione con moltiplicazione

x *= y è equivalente a x = x * y

/=

Assegnazione con divisione

x /= y è equivalente a x = x / y

Si noti che, come in altri linguaggi, il C# utilizza operatori differenti per l’assegnazione (=) e la comparazione (==).

ESEMPIO DI ASSEGNAZIONE CON ADDIZIONE

int a = 5;

a = a +3;

È equivalente a:

a+=3; 

C# ci mette a disposizione una sintassi abbreviata per questo tipo di operazioni.

Per quanto riguarda gli operatori di incremento ++ e decremento — esiste una notazione postfissa e una notazione prefissa, entrambe aumentano o diminuiscono la variabile o il literal di uno.

NOTAZIONE PREFISSA

–a                              ++a

NOTAZIONE POSTFISSA

a–                              a++

int a = 10;

int b = 5 + ++a;      (notazione prefissa)

Console.Writeline(a);    a=11

Console.Writeline(b);    b=16

In questo caso ++a ha la precedenza rispetto agli altri operatori, quindi prima viene incrementata a poi si somma 5.

int a = 10

int b = 5 + a++ (notazione postfissa)

Console.Writeline(a);    a=11

Console.Writeline(b);    b=15

In questo caso a++ non ha la precedenza rispetto agli altri operatori, quindi prima si fa la somma tra 10 e 5 poi viene incrementata a.

 

CASTING

double d = 1200.5;

int a = 20 + d

Se chiediamo al compilatore di sommare un int e un double otteniamo un errore di compilazione in quanto il tipo int di destinazione che memorizza il valore è più stretto, meno ampio di un double. Esistono due tipi di casting, il casting implicito che viene eseguito dal compilatore senza il nostro intervento e il cast esplicito in cui siamo noi ad indicare al compilatore quello che stiamo facendo. Se si tenta di convertire un tipo più stretto (quindi che occupa meno Byte) in uno più ampio (occupa più Byte) il casting è implicito in quanto non c’è il rischio di perdita di informazione. Ad esempio:

byte b = 10;

int a = 20 + b;

Nel caso invece in cui il tipo di destinazione è un int che è più stretto di un double, c’è il rischio di perdita di informazione. Ed è per questo motivo che siamo noi a dover fornire al compilatore un cast esplicito in quanto si presuppone che sappiamo quello che stiamo facendo.

double d = 1200.5;

int a = 20 + (int)d

A questo punto il compilatore compila lo Statement, ma vediamo quali sono i rischi legati ad un casting sbagliato.

int a = 255;

byte b = (byte)a;

Cosa succede se a assume il valore 256? Succede che un Byte non è più sufficiente a contenerne il valore e si ha un traboccamento o errore di overflow succede qualcosa a livello interno nella rappresentazione dei bit e in b finiscono valori inattesi e assolutamente non corretti.

LA CLASSE CONVERT

int a = 300;

string s = Convert.ToString(a);

Console.WriteLine(s) stamperà la stringa “300”

CODICE VISUAL STUDIO CODE PER GLI OPERATORI

using System;
namespace Operatori
{
    class Program
    {
        static void Main(string[] args)
        {
            //ESEMPI OPERATORI BINARI (2 OPERANDI)
            int x = 45;
            int y = 10;
            int somma = x+y;
            int prodotto = x*y;
            int divisione = x/y;
            byte modulo = (byte)(x % y);//CONVERSIONE ESPLICITA
            double division = (double)x/y;
            Console.WriteLine($"Divisione:{divisione},modulo{modulo},Divisione floating point {division}");
            //ESEMPI OPERATORI UNARI (1 OPERANDO)
            int x1 = 10;
            int y1 = -x1;
            y1 = y1 -3;
            //E' EQUIVALENTE A 
            y1-=3;
            x1=x1+1;
            //E' EQUIVALENTE A 
            x1+=1;
            int a = 10;
            int b = 5 + ++a;/*Notazione prefissa ++a che incrementa di 1
            ha la precedenza su tutti gli altri operatori. Quindi prima
            viene incrementata a poi si somma 5*/
            int a1 = 10;
            int b1 = 5 + a1++;/*Notazione postfissa a++ che incrementa di 1
            non ha la precedenza su tutti gli altri operatori. Quindi prima
            viene eseguita la somma e al termine viene incrementata a*/
            Console.WriteLine($"x1:{x1},y1:{y1},a:{a},b:{b},a1:{a1},b1:{b1}");
            //ESEMPI OPERATORI LOGICI
            int z = 10;
            int k = 8;
            bool v = (z>9&&k<10);
            bool s = (z>10||k>=8);
            bool negazione = !(z > 9 && k < 10);
            Console.WriteLine($"v:{v},s:{s},negazione:{negazione}");
            //ESEMPI OPERATORI SUI BIT (Bitwise)
            int binary_shift = 0b10101011;   //shiftato di 1 posizione a sinistra diventa 10101 0110  (342)
                                             //shiftato di una posizione a destra diventa 0101 0101 (85)   
                                                                                        
            int binary1 = 0b1010;
            int binary2 = 0b1010;
            int binary3 = binary1&binary2;
            int binary4 = 0b1111;
            int binary5 = 0b1010;
            int binary6 = binary4|binary5;
            int binary7 = 0b1111;
            int binary8 = 0b1010;
            int binary9 = binary7^binary8;
            int binary10 = binary_shift<<1;
            int binary11 = binary_shift>>1;
            Console.WriteLine($"AND Binario: {binary3}, Or Binario: {binary6}, XOR {binary9}");
            Console.WriteLine($"Shift a sinistra di 1 posizione: {binary10}, shift a destra di 1 posizione {binary11}");

        }
    }
}

CODICE VISUAL STUDIO CODE PER IL CASTING

using System;
namespace Conversioni
{
    class Program
    {
        static void Main(string[] args)     
        {
            //ESEMPI DI CAST IMPLICITO
            int a = 1200;
            double d = (1234.89 + a);
            byte b = 255;
            int c = b;
            //ESEMPI DI CAST ESPLICITO
            float f = 2345.89765f;
            int g = 100 + (int)f;
            long h = 123567789;
            int z = 5 + (int)h;
            //ESEMPIO DI OVERFLOW
            int x = 1235678654; //dovrebbe restituire 1.235.678.655
            short k = (short)(1 + x);
            Console.WriteLine("overflow {0}",k);
            //LA CLASSE CONVERT
            int m = 1200;
            string s = Convert.ToString(m);
            Console.WriteLine("Conversione di un intero in stringa {0}",s);
            
        }
    }
}

APPROFONDIMENTO SUGLI OPERATORI

In C#, gli operatori sono simboli speciali che dicono al compilatore di eseguire operazioni matematiche o logiche specifiche. Gli operatori in C# possono essere classificati in diverse categorie, tra cui aritmetici, logici, di confronto, bit a bit e altri. Ecco un riepilogo dei principali operatori in C#:

Operatori Aritmetici

Utilizzati per eseguire operazioni matematiche.

•+ : Addizione

•– : Sottrazione

•* : Moltiplicazione

•/ : Divisione

•% : Modulo (resto della divisione)

•++ : Incremento (aumenta di 1)

•— : Decremento (diminuisce di 1)

Operatori di Assegnazione

Utilizzati per assegnare valori alle variabili.

•= : Assegnazione semplice

•+= : Addizione e assegnazione

•-= : Sottrazione e assegnazione

•*= : Moltiplicazione e assegnazione

•/= : Divisione e assegnazione

•%= : Modulo e assegnazione

Operatori di Confronto

Utilizzati per confrontare due valori.

•== : Uguaglianza

•!= : Diversità

•> : Maggiore di

•< : Minore di

•>= : Maggiore o uguale a

•<= : Minore o uguale a

Operatori Logici

Utilizzati per operazioni logiche (di solito con valori booleani).

•&& : AND logico

•|| : OR logico

•! : NOT logico

Operatori Bit a Bit

Utilizzati per operazioni a livello di bit.

•& : AND bit a bit

•| : OR bit a bit

•^ : XOR bit a bit (OR esclusivo)

•~ : NOT bit a bit

•<< : Shift a sinistra

•>> : Shift a destra

Operatori Condizionali

•?: : Operatore ternario (condizionale)

Operatori di Tipo

Utilizzati per verificare o convertire tipi.

•is : Verifica se un oggetto è di un certo tipo

•as : Conversione di tipi (ritorna null se la conversione fallisce)

•typeof : Ottiene il tipo di un oggetto

•sizeof : Ottiene la dimensione di un tipo (solo per tipi non gestiti)

•checked : Controlla overflow aritmetico

•unchecked : Disabilita il controllo dell’overflow aritmetico

Operatori Altri

•new : Crea istanze di oggetti

•sizeof : Ottiene la dimensione in byte di un tipo

•typeof : Ottiene il tipo di dati

Esempi di Codice

int a = 5;
int b = 10;
int sum = a + b;  // Addizione
bool isEqual = (a == b);  // Confronto
bool logicalAnd = (a < b && b > 0);  // AND logico
int bitwiseAnd = a & b;  // AND bit a bit
int? result = a > b ? a : b;  // Operatore ternario

APPROFONDIMENTO SUL CASTING IN C#

Operatore di Cast in C#

L’operatore di cast in C# viene utilizzato per convertire un oggetto di un tipo in un altro tipo. Questa conversione può essere implicita o esplicita.

Conversione Implicita

La conversione implicita avviene automaticamente quando non vi è alcuna perdita di dati. Esempi comuni includono la conversione da un tipo più piccolo a un tipo più grande, come da int a long.

Esempio:

int numeroIntero = 123;
long numeroLungo = numeroIntero; // Conversione implicita

Conversione Esplicita

La conversione esplicita, invece, deve essere specificata utilizzando l’operatore di cast () poiché potrebbe comportare la perdita di dati o l’eccezione di runtime. È spesso usata quando si passa da un tipo più grande a un tipo più piccolo.

Esempio:

double numeroDecimale = 123.45;
int numeroIntero = (int)numeroDecimale; // Conversione esplicita

In questo caso, numeroIntero conterrà il valore 123, poiché la parte decimale viene troncata.

Cast di oggetti e tipi di riferimento

Oltre ai tipi di valore, il cast è anche utilizzato per convertire tra tipi di riferimento. Quando si lavora con l’ereditarietà, il cast può convertire un tipo di base a un tipo derivato e viceversa.

Esempio:

class Animale { }
class Cane : Animale { }

Animale mioAnimale = new Cane();
Cane mioCane = (Cane)mioAnimale; // Cast esplicito

Se il cast non è valido, verrà sollevata un’eccezione InvalidCastException. Per evitare questo, è possibile utilizzare l’operatore as o l’operatore is.

Esempio con as:

Cane mioCane = mioAnimale as Cane;
if (mioCane != null)
{
// Operazioni con mioCane
}

In sintesi, l’operatore di cast in C# è uno strumento potente per la conversione di tipi, ma deve essere usato con attenzione per evitare errori di runtime o perdita di dati.

LINK AI PRECEDENTI POST

IL LINGUAGGIO C#

APPROFONDIMENTO