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 di qualsiasi dimensione, costituita da un numero qualsiasi di altre espressioni. 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é la moltiplicazione ha la precedenza sulla sottrazione.
Nella tabella riportata di seguito gli operatori sono suddivisi in categorie in base all'operazione che eseguono. Le categorie sono elencate in ordine di precedenza.
Operatori primari
Espressione |
Oggetto di descrizione |
|---|---|
x.y |
Accesso a 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 insieme (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 |
Oggetto di 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 di moltiplicazione (*)
Espressione |
Oggetto di descrizione |
|---|---|
Moltiplicazione |
|
Divisione |
|
Resto |
Operatori di addizione
Espressione |
Oggetto di descrizione |
|---|---|
x + y |
Addizione, concatenazione di stringhe, combinazione di delegati |
x - y |
Sottrazione, rimozione di delegati |
Operatori shift
Espressione |
Oggetto di descrizione |
|---|---|
x << y |
Spostamento a sinistra |
x >> y |
Spostamento a destra |
Operatori relazionali e operatori di tipo
Espressione |
Oggetto di 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, falso |
x as T |
Restituisce x tipizzato come T oppure null se x non è un oggetto T |
Operatori di uguaglianza
Espressione |
Oggetto di descrizione |
|---|---|
x == y |
Uguale |
x != y |
Non uguale |
Operatori logici, condizionali e null
Category |
Espressione |
Oggetto di descrizione |
|---|---|---|
AND logico |
x & y |
AND intero bit per bit, AND logico booleano |
XOR logico |
x ^ y |
XOR bit per bit integer, XOR logico booleano |
OR logico |
x | y |
OR bit per bit integer, 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 |
Oggetto di descrizione |
|---|---|
Assegnazione |
|
x op= y |
Assegnazione composta. Supporta i seguenti operatori: +=, -=, *=, /=, %=, &=, |=, !=, <<=, >>= |
(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 di sinistra 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 di destra vengono valutati nell'ordine da destra a sinistra. Ad esempio, l'operatore di assegnazione prevede l'associazione all'operando di destra. 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;
Gli operatori di assegnazione e l'operatore terziario (?:) prevedono l'associazione all'operando di destra. Tutti gli altri operatori binari prevedono l'associazione all'operando di sinistra.
Se gli operatori in un'espressione sono impostati su associativo o associativo da destra, gli operandi di ogni espressione vengono valutati in primo luogo, 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à utilizzando le parentesi. 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 strutture personalizzate. Questo processo è denominato overload degli operatori. Per ulteriori informazioni, vedere Operatori che supportano l'overload (Guida per programmatori C#).
Sezioni correlate
Per ulteriori informazioni, vedere Parole chiave per operatori (Riferimenti per C#) e Operatori [C#].
Vedere anche
Riferimenti
Istruzioni, espressioni e operatori (Guida per programmatori C#)