Operatori (Guida per programmatori C#)
Nel linguaggio C#, un operatore è un elemento del programma che si applica a uno o più operandi in un'espressione o in un'istruzione. Gli operatori che accettano un unico operando, ad esempio l'operatore di incremento (++) o new, sono denominati operatori unari. Quelli che accettano due operandi, ad esempio gli operatori aritmetici (+,-,*,/), sono denominati operatori binari. L'operatore condizionale (?:) accetta tre operandi ed è l'unico operatore ternario disponibile in C#.
L'istruzione C# riportata di seguito contiene un unico operatore unario e un unico operando. L'operatore di incremento ++ modifica il valore dell'operando y.
y++;
L'istruzione C# riportata di seguito contiene due operatori binari, ciascuno con due operandi. L'operatore di assegnazione = ha come operandi la variabile integer y e l'espressione 2 + 3. L'espressione 2 + 3 è costituita dall'operatore di addizione e due operandi, 2 e 3.
y = 2 + 3;
Operatori, valutazione e precedenza operatori
Un operando può essere un'espressione valida composta da codice di qualsiasi lunghezza e può includere un numero qualsiasi di sottoespressioni. In un'espressione che contiene più operatori, l'ordine in cui vengono applicati gli operatori è determinata dalla precedenza tra operatori, l'associatività e le parentesi.
Ogni operatore ha una precedenza definita. In un'espressione che contiene più operatori che dispongono di diversi livelli di precedenza, la precedenza degli operatori determina l'ordine in cui gli operatori verranno valutati. L'istruzione che segue, ad esempio, assegna il valore 3 a n1.
n1 = 11 - 2 * 4;
La moltiplicazione viene eseguita per prima perché ha la precedenza sulla sottrazione.
Nella tabella riportata di seguito gli operatori sono suddivisi in categorie in base al tipo di operazione che eseguono. Le categorie sono elencate in ordine di precedenza.
Operatori primari
Espressione |
Descrizione |
|---|---|
x.y |
Accesso ai membri |
f(x) |
Chiamata a metodi e delegati |
a[x] |
Accesso a matrici e indicizzatori |
x++ |
Post-incremento |
x-- |
Post-decremento |
new T(...) |
Creazione di oggetti e delegati |
new T(...){...} |
Creazione di oggetti con inizializzatore. Vedere Inizializzatori di oggetto e di raccolte (Guida per programmatori C#). |
new {...} |
Inizializzatore di oggetti anonimi. Vedere Tipi anonimi (Guida per programmatori C#). |
new T[...] |
Creazione di matrici. Vedere Matrici (Guida per programmatori C#). |
typeof(T) |
Ottenere l'oggetto System.Type per T |
checked(x) |
Valutare l'espressione in un contesto controllato (checked) |
unchecked(x) |
Valutare l'espressione in un contesto non controllato (unchecked) |
default (T) |
Ottenere il valore predefinito del tipo T |
delegate {} |
Funzione anonima (metodo anonimo) |
Operatori unari
Espressione |
Descrizione |
|---|---|
+x |
Identità |
-x |
Negazione |
!x |
Negazione logica |
~x |
Negazione bit per bit |
++x |
Pre-incremento |
--x |
Pre-decremento |
(T)x |
Convertire in modo esplicito x nel tipo T |
Operatori moltiplicativi
Espressione |
Descrizione |
|---|---|
Moltiplicazione |
|
Divisione |
|
Resto |
Operatori additivi
Espressione |
Descrizione |
|---|---|
x + y |
Addizione, concatenazione di stringhe, combinazione di delegati |
x - y |
Sottrazione, rimozione di delegati |
Operatori shift
Espressione |
Descrizione |
|---|---|
x << y |
Spostamento a sinistra |
x >> y |
Spostamento a destra |
Operatori relazionali e operatori di tipo
Espressione |
Descrizione |
|---|---|
x < y |
Minore di |
x > y |
Maggiore di |
x <= y |
Minore o uguale a |
x >= y |
Maggiore o uguale a |
x is T |
Restituisce true se x è un oggetto T; in caso contrario, false |
x as T |
Restituisce x tipizzato come T oppure Null se x non è un oggetto T |
Operatori di uguaglianza
Espressione |
Descrizione |
|---|---|
x == y |
Uguale |
x != y |
Non uguaglianza |
Operatori logici, condizionali e Null
Categoria |
Espressione |
Descrizione |
|---|---|---|
AND logico |
x & y |
AND Integer bit per bit, AND logico booleano |
XOR logico |
x ^ y |
XOR Integer bit per bit, XOR logico booleano |
OR logico |
x | y |
OR Integer bit per bit, OR logico booleano |
AND condizionale |
x && y |
Restituisce y solo se x è true |
OR condizionale |
x || y |
Restituisce y solo se x è false |
Null-coalescing |
x ?? y |
Restituisce y se x è Null; in caso contrario x |
Condizionale |
x ?: y : z |
Restituisce y se x è true, z se x è false |
Operatori di assegnazione e operatori anonimi
Espressione |
Descrizione |
|---|---|
Assegnazione |
|
x op= y |
Assegnazione composta. Supporta gli operatori seguenti: +=, -=, *=, /=, %=, &=, |=, !=, <<=, >>= |
(T x) => y |
Funzione anonima (espressione lambda) |
Associazione
Quando in un'espressione sono presenti due o più operatori con la stessa precedenza, verranno valutati in base all'associazione. Gli operatori che prevedono l'associazione all'operando sinistro vengono valutati nell'ordine da sinistra a destra. L'espressione x * y / z viene ad esempio valutata come (x * y) / z. Gli operatori che prevedono l'associazione all'operando destro vengono valutati nell'ordine da destra a sinistra. Ad esempio, l'operatore di assegnazione prevede l'associazione all'operando destro. Se non fosse così, il codice seguente restituirà un errore.
int a, b, c;
c = 1;
// The following two lines are equivalent.
a = b = c;
a = (b = c);
// The following line, which forces left associativity, causes an error.
//(a = b) = c;
Facendo un altro esempio, l'operatore ternario (?:) prevede l'associazione all'operando destro. La maggior parte degli operatori binari prevede l'associazione all'operando sinistro.
Se gli operatori in un'espressione sono impostati su associativo o associativo da destra, gli operandi di ogni espressione vengono valutati per primi, da sinistra a destra. Negli esempi seguenti viene illustrato l'ordine di valutazione degli operatori e degli operandi.
Istruzione |
Ordine di valutazione |
|---|---|
a = b |
a, b, = |
a = b + c |
a, b, c, +, = |
a = b + c * d |
a, b, c, d, *, +, = |
a = b * c + d |
a, b, c, *, d, +, = |
a = b - c + d |
a, b, c, -, d, +, = |
a += b -= c |
a, b, c, -=, += |
Aggiunta di parentesi
È possibile modificare l'ordine imposto dalla precedenza degli operatori e dall'associatività usando le parentesi. Ad esempio, il risultato dell'espressione 2 + 3 * 2 restituisce normalmente 8, in quanto gli operatori di moltiplicazione hanno la precedenza su quelli di addizione. Tuttavia, se si scrive l'espressione in questo modo (2 + 3) * 2, l'addizione è presa in considerazione prima della moltiplicazione e il risultato sarà 10. Negli esempi seguenti viene illustrato l'ordine di valutazione delle espressioni tra parentesi. Come negli esempi precedenti, gli operandi vengono valutati prima di applicare l'operatore.
Istruzione |
Ordine di valutazione |
|---|---|
a = (b + c) * d |
a, b, c, +, d, *, = |
a = b - (c + d) |
a, b, c, d, +, -, = |
a = (b + c) * (d - e) |
a, b, c, +, d, e, -, *, = |
Overload dell'operatore
È possibile modificare il comportamento degli operatori per classi e struct personalizzati. Questo processo è denominato overload degli operatori. Per altre informazioni, vedere Operatori che supportano l'overload (Guida per programmatori C#).
Sezioni correlate
Per altre informazioni, vedere Parole chiave per operatori (Riferimenti per C#) e Operatori [C#].
Vedere anche
Riferimenti
Istruzioni, espressioni e operatori (Guida per programmatori C#)