C sharp/Operatori

Gli operatori in C# (e il loro ordine di precedenza) sono molto riassimilabili a quelli di altri linguaggi della famigli del C.

Similmente al C++, le classi (che saranno trattate in seguito) possono effettuare quello che viene chiamato l'overlead, cioè ridefinire il comportamento degli operatori con gli oggetti in questione.

In questa pagina sono indicati gli operatori built-in nel linguaggio.

Gli operatori possono essere combinati per formare le espressioni usando le parentesi tonde.

Operatori aritmetici

I seguenti operatori aritmetici operano su operandi numerici (nell'esempio a e b).

Esempio Significato Spiegazione

a + b a più b L'operatore binario + restituisce la somma dei due argomenti.

a - b a meno b L'operatore binario - restituisce la differenza tra i due argomenti.

a * b a per b L'operatore binario * restituisce il prodotto dei due argomenti.

a / b a diviso b L'operatore binario / restituisce il rapporto tra i due argomenti. Se entrambi gli operandi sono interi, il risultato sarà anch'esso un numero intero (verrà troncata la parte decimale)

a % b

a modulo b

L'operatore binario % opera solo su numeri interi. Restituisce il resto della divisione intera degli argomenti.

Per approfondire su Wikipedia, vedi la voce Aritmetica modulare.

a++

L'operatore unario ++ opera su un solo argomento. Quando è inserito dopo l'argomento, restituisce prima il valore dell'argomento e poi ne incrementa di uno il valore. Ad esempio:

int a = 4;
System.Console.WriteLine(a++); //stampa 4
// ora a contiene il valore 5

++a

L'operatore unario ++ opera su un solo argomento. Quando è inserito prima dell'argomento, prima incrementa di uno l'argomento e poi ne restituisce il valore . Ad esempio:

int a = 4;
System.Console.WriteLine(++a); //stampa 5
// ora a contiene il valore 5

a-- e --a Analogamente

Operatori logici

A differenza del C e C++, gli operatori logici del C# possono lavorare solo su operandi di tipo booleano.

Esempio	Spiegazione
`a && b`	L'operatore binario `&&` valuta prima il valore del primo argomento. Se il suo valore è false, restituisce false (questo perché falso è l'elemento assorbente della congiunzione, quindi qualunque sia il valore del secondo operando, il risultato sarà false); altrimenti, valuta anche il secondo parametro e restituisce la congiunzione tra i due. Questa tecnica è chiamata valutazione short-circuit
`a \|\|` b	L'operatore binario `\|\|` valuta prima il valore del primo argomento. Se il suo valore è true, restituisce true (questo perché vero è l'elemento assorbente della disgiunzione, quindi qualunque sia il valore del secondo operando, il risultato sarà true); altrimenti, valuta anche il secondo parametro e restituisce la disgiunzione tra i due.
`!a`	L'operatore unario `!` lavora su un solo valore booleano e ne restituisce la negazione (non).

Operatori bit a bit

I seguenti operatori bit a bit lavorano su operandi booleani o interi.

Esempio	Spiegazione
`a & b` (bitwise and)	L'operatore binario `&` valuta entrambi gli operandi e ne restituisce la congiunzione logica (et) dei loro valori. Se gli operandi sono interi, la congiunzione è fatta a livello di bit: bool a = true; bool b = false; bool c = a & b; //false int n1 = 5; //in binario 101 int n2 = 2; //in binario 10 int n3 = n1 & n2; //vale 100, cioè 4
`a \| b`	L'operatore binario \| valuta entrambi gli operandi e ne restituisce la disgiunzione logica (vel) dei loro valori. Se gli operandi sono interi, la disgiunzione è fatta a livello di bit: bool a = true; bool b = false; bool c = a \| b; //true int n1 = 5; //in binario 101 int n2 = 2; //in binario 10 int n3 = n1 \| n2; //vale 111, cioè 7
`a ^ b`	L'operatore binario `^` valuta entrambi gli operandi e ne restituisce la disgiunzione non inclusiva logica (aut) dei loro valori. Se gli operandi sono interi, la disgiunzione è fatta a livello di bit: bool a = false; bool b = false; bool c = a ^ b; //true int n1 = 5; //in binario 101 int n2 = 2; //in binario 10 int n3 = n1 ^ n2; //vale 00, cioè 0
`~a`	L'operatore unario `~` lavora su un solo parametro che può essere booleano o intero. Se l'operando è intero, la negazione è fatta a livello di bit: bool a = false; bool b = ~a; //true int n1 = 5; //in binario 101 int n2 = ~n1; //in binario 010 cioè 2

Scorrimento di bit

Esempio	Spiegazione
`a << b`	L'operatore binario `<<` scorre a sinistra i bit del primo argomento di tante posizioni quante indicate nel secondo. Scarta i bit più a sinistra che ha spostato e imposta i nuovi bit di destra su zero: int a = 7; //in binario 111 int b = a << 1; //in binario 1110 cioè 14;
`a >> b`	L'operatore binario `>>` scorre a destra i bit del primo argomento di tante posizioni quante indicate nel secondo. Scarta i bit più a destra che ha spostato e imposta i nuovi bit di destra su zero se il valore non ha segno, altrimenti li imposta sul segno in bit del primo argomento.

Operatori relazionali

Gli operatori relazionali ==, !=, <, >, <= e >= sono usati per relazioni tra valori o comparazione di tipi.

Esempio	Significato	Spiegazione
`a == b`	`a` è uguale a `b`	Per argomenti numerici, `==` restituisce true se i suoi operandi hanno lo stesso valore, altrimenti false. Per i tipi stringa, restituisce true se la sequenza di caratteri combacia. Per gli oggetti, invece, `a == b` restituisce true solo se `a` e `b` si riferiscono alla stessa istanza dell'oggetto.
`a != b`	`a` non è uguale a `b`	L'operatore `!=` è la negazione logica dell'operatore `==`.
`a < b`	`a` è minore di `b`	L'operatore `<` lavora su valori interi. Restituisce true se `a` è minore di `b`, false negli altri casi.
`a > b`	`a` è maggiore di `b`	L'operatore `>` lavora su valori interi. Restituisce true se `a` è maggiore di `b`, false negli altri casi.
`a <= b`	`a` è minore o uguale a `b`	L'operatore `<=` lavora su valori interi. Restituisce true se `a` è minore o uguale a `b`, false negli altri casi.
`a >= b`	`a` è maggiore o uguale a `b`	L'operatore `>=` lavora su valori interi. Restituisce true se `a` è maggiore o uguale a `b`, false negli altri casi.

Assegnazione

Gli operatori di assegnazione sono binari; il più semplice è l'operatore =, che assegna il valore del secondo argomento nel primo argomento:

int a = 3;
int b = a; //b è uguale a 3
a = 4; //b è ancora uguale a 3 mentre a è uguale a 4
//si possono anche comporre le operazioni...
int c = ((a + b) + 3) * a;

Il primo argomento dell'operatore di assegnazione (=) è normalmente una variabile.

Esempio	Spiegazione
`a = b`	L'operatore `=` assegna il valore dell'operando di destra al primo argomento.
`a = b = c`	Uguale a `a = (b = c)`. Si possono comporre le assegnazioni. È come scrivere `b=c` e poi `a=b`. Si possono fare anche calcoli più complessi: int a = 3; int b; int c = 3 * (b = a) + 2; //c è uguale a 11 // è come scrivere... int a = 3; int b; b = a; int c = 3 * b + 2; //c è uguale a 11

Operatori abbreviati

Quasi tutti gli operatori dispongono di una sintassi abbreviata nel caso di operazioni comuni di a = a operatore b che diventa a operatore= b.

Esempio	Spiegazione
`a += b`	Equivale a `a = a + b`.
`a -= b`	Equivale a `a = a - b`.
`a *= b`	Equivale a `a = a * b`.
`a /= b`	Equivale a `a = a / b`.
`a %= b`	Equivale a `a = a % b`.
`a &= b`	Equivale a `a = a & b`.
`a \|= b`	Equivale a `a = a \| b`.
`a ^= b`	Equivale a `a = a ^ b`.
`a <<= b`	Equivale a `a = a << b`.
`a >>= b`	Equivale a `a = a >> b`.

Altri operatori

Esempio	Spiegazione
`a ? b : c`	L'operatore ternario `? :` dapprima valuta il valore logico dell'operando a. Se esso è vero, ritorna il valore dell'espressione b, altrimenti quella dell'espressione c. Esempio: bool a = true; int b = 5; int c = 2; int x = a ? b : c; // restituisce 5 perché a è true