In ogni linguaggio di programmazione un elemento fondamentale è costituito dagli operatori. Al termine della precedente lezione, in cui abbiamo introdotto il concetto di variabile ed espressione, abbiamo già visto quali sono alcuni degli operatori matematici più comuni.
In questa lezione affronteremo in modo molto più approfondito la tematica passando in rassegna tutti gli operatori supportati da C#. Nelle nostre tabelle proporremo dei piccoli esempi esplicativi di ciascun operatore sulla base di due variabili x e y, dove x ha valore 8 e y valore 4.
Operatori matematici
| 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 |
Vediamo un esempio:
using System;
class Esempio
{
public static void Main()
{
int a, b, risultato;
float floatrisultato;
a = 3;
b = 6;
// Somma
risultato = a+b;
Console.WriteLine("a+b: {0}", risultato);
// Sottrazione
risultato = a-b;
Console.WriteLine("a-b: {0}", risultato);
// Moltiplicazione
risultato = a*b;
Console.WriteLine("a*b: {0}", risultato);
// Divisione
risultato = a/b;
Console.WriteLine("a/b: {0}", risultato);
// Divisione con virgola
floatrisultato = (float)a/(float)b;
Console.WriteLine("a/b: {0}", floatrisultato);
// Modulo
risultato = a%b;
Console.WriteLine("a%b: {0}", risultato);
Console.ReadLine();
}
}Operatore di concatenazione
L’operatore + può essere utilizzato, oltre che per effettuare delle addizioni, anche per concatenare due variabili stringa (come già visto nella lezione precedente). Ad esempio:
string var a = "Ciao ";
string var b = "a tutti";
string var c = a + b;Operatori di incremento e decremento
Gli operatori di incremento (++) e decremento (–), rispettivamente, incrementano e decrementano di 1 il valore di una variabile numerica. Una particolarità di questi operatori è che possono essere posti prima o dopo una variabile (ad esempio "x") con delle importanti differenze:
- quando vengono utilizzati da soli l’effetto è il medesimo sia mettendo l’operatore come prefisso che come suffisso;
- quando vengono utilizzati all’interno di espressioni, i valori delle variabili interessate vengono modificati prima o dopo che l’espressione venga valutata a seconda che gli operatori, appunto, vengano utilizzati rispettivamente come prefisso o come suffisso.
Ecco un esempio di quest’ultima circostanza:
int x = 9;
if (++x == 10) // vero x viene incrementata a 10 prima del confronto
{
Console.WriteLine("OK");
}
if (x++ == 11) // vero x viene incrementata a 11 dopo il confronto
{
Console.WriteLine("KO");
}Nel primo if la variabile x viene incrementata prima che sia confrontata con il valore 10, nel secondo caso viene incrementata dopo essere stata confrontata con il valore 11. Stessa cosa vale per l’operatore di decremento.
L’uso degli altri operatori è comune agli altri linguaggi e molto intuitivo, ci soffermeremo solo su alcuni operatori più particolari.
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 costrollare, così, il flusso del programma).
| Operatore | Descrizione | Esempio |
|---|---|---|
| == | Verifica una uguaglianza | (x == y) // false |
| != | Verifica una diversità | (x != y) // true |
| > | Maggiore | (x > y) // true |
| < | Monire | (x < y) // false |
| >= | Maggiore o uguale | (x >= y) // true |
| <= | Minore o uguale | (x <= y) // false |
Operatori logici
Gli operatori logici sono tre: AND, OR e NOT. Sono utilizzati per creare condizioni complesse ed articolate basate sul verificarsi (o non verificarsi) di una serie di situazioni.
| Operatore | Descrizione | Esempio |
|---|---|---|
| && | AND | (x > 9 && y < 3) // false. |
| || | OR | (x > 9 || y < 3) // true. |
| ! | NOT | !(x > 9 && y < 3) // true |
Operatori di assegnazione
Questi operatori sono utilizzati per assegnare un valore ad una variabile.
| Operatore | Descrizione | Esempio |
|---|---|---|
| = | Assegnazione | x = 10 (assegna ad 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 (==). Utilizzando, ad esempio, l’operatore di assegnazione (=) all’interno di un’istruzione if viene generato un errore in fase di compilazione.
Altri operatori di C#
Oltre a quelli elencati, che sono i più utilizzati ed importanti, C# dispone di numerosi altri operatori. Vediamo di seguito alcuni dei più interessanti.
L’operatore is
Altro utile operatore è is che consente di verificare se un oggetto è compatibile con uno specifico tipo dati ovvero se l’oggetto è dello stesso tipo o deriva da quel tipo dati. Vediamo un esempio:
string i = "Ciao";
if (i is object)
{
Console.WriteLine("i è un oggetto");
}Una stringa, come tutti i tipi dati in C#, deriva dalla classe object e quindi in questo caso la condizione dell’if è verificata.
L’operatore as
Abbiamo poi l’operatore as che viene utilizzato per effettuare esplicite conversioni di tipi riferimento, ovviamente se il tipo da convertire è compatibile con il tipo di destinazione. Se i due tipi sono incompatibili l’operatore restituisce il valore null. Vediamo un esempio:
object o1 = "Ciao";
object o2 = 10;
string s1 = o1 as string; // s1 = "Ciao"
string s2 = o2 as string; // s2 = nullIn quest’esempio la variabile "s2" assume il valore null perchè l’oggetto con valore 10 è un int e non è compatibile con il tipo string.
L’operatore sizeof
Se si vuole conoscere la dimensione in byte di un tipo valore è possibile utilizzare l’operatore sizeof. Ecco un esempio:
Console.WriteLine(sizeof(double));L’operatore typeof
Se si vuole conoscere il tipo di una classe è possibile utilizzate l’operatore typeof. Ecco un esempio:
Console.WriteLine(typeof(Stream));Operatore ternario
L’operatore condizionale o operatore ternario (?:) può essere definito come un costrutto if else semplificato. Esso deve il suo nome al fatto che coinvolge tre operandi e permette di valutare una condizione, restituendo un valore diverso a seconda che la stessa risulti vera o falsa
condizione ? valore_condizone verificata : valore_condizione_non_verificata
Ne vedremo un esempio concreto nella lezione dedicata ai costrutti condizionali.
