In questo tutorial impareremo a conoscere la precedenza e l'associatività degli operatori in C #. Questo ci darà un'idea di come un'espressione viene valutata dal compilatore C #.
Precedenza degli operatori C #
La precedenza degli operatori è un insieme di regole che definisce come viene valutata un'espressione. In C # ogni operatore C # ha una priorità assegnata e in base a queste priorità viene valutata l'espressione.
Ad esempio , la precedenza (*)dell'operatore di moltiplicazione è maggiore della precedenza (+)dell'operatore di addizione . Pertanto, l'operazione che coinvolge la moltiplicazione viene eseguita prima dell'aggiunta.
Dai un'occhiata alla dichiarazione qui sotto.
int x = 4 + 3 * 5;
Quale sarà il valore di x dopo aver eseguito questa istruzione?
L'operando 3è associato a +e *. Come affermato in precedenza, la moltiplicazione ha una precedenza maggiore dell'addizione. Quindi, l'operazione 3 * 5viene eseguita invece di 4 + 3. Il valore della variabile x sarà 19.
Se l'addizione avesse una precedenza maggiore, 4 + 3verrebbe valutata per prima e il valore di x sarebbe 35.
Tabella di precedenza degli operatori
Maggiore è la precedenza dell'operatore, maggiore sarà la sua visualizzazione nella tabella
Precedenza degli operatori C #| Categoria | Operatori |
|---|---|
| Incremento e decremento di Postfix | ++, - |
| Incremento, decremento e unario prefisso | ++, -, +, -,!, ~ |
| Moltiplicativo | *, /,% |
| Additivo | +, - |
| Cambio | <> |
| Relazionale | <,,> = |
| Uguaglianza | ==,! = |
| Bitwise AND | & |
| Bitwise XOR | ^ |
| OR bit per bit | | |
| AND logico | && |
| OR logico | || |
| Ternario | ? : |
| Incarico | =, + =, - =, * =, / =,% =, & =, | =, =, <> = |
Gli operatori di assegnazione hanno la precedenza più bassa mentre gli operatori di incremento e decremento suffisso hanno la precedenza più alta.
Esempio 1: precedenza degli operatori
using System; namespace Operator ( class OperatorPrecedence ( public static void Main(string() args) ( int result1; int a = 5, b = 6, c = 4; result1 = --a * b - ++c; Console.WriteLine(result1); bool result2; result2 = b>= c + a; Console.WriteLine(result2); ) ) )
Quando eseguiamo il programma, l'output sarà:
19 Falso
Comprendiamo come viene valutata l'espressione nel programma.
La precedenza di --e ++è maggiore di *e la precedenza di *è maggiore di -. Da qui la dichiarazione,
risultato1 = --a * b - ++ c;
è equivalente a
risultato1 = ((--a) * b) - (++ c);
L'espressione tra parentesi viene sempre valutata per prima, indipendentemente dalla precedenza degli operatori al di fuori di essa.
- All'inizio, (--a) viene valutato risultando in
4.
- Quindi (++ c) viene valutato risultando in
5.
- Ora, (a * b) viene valutato risultando in
24.
- Infine, viene eseguita la sottrazione risultante in
19.
- Quindi il valore finale di result1 sarà
19.
Nell'espressione successiva, la precedenza di +è maggiore di >=. Quindi, c e a vengono aggiunti per primi e la somma viene confrontata con b per produrre false.
Associatività degli operatori in C #
Nella sezione precedente abbiamo discusso della precedenza degli operatori. Se vengono utilizzati due operatori con precedenza diversa, viene valutato per primo l'operatore con precedenza maggiore.
Ma cosa succede se entrambi gli operatori hanno la stessa precedenza?
In tal caso, l'espressione viene valutata in base all'associatività dell'operatore (da sinistra a destra o da destra a sinistra).
Per esempio:
int a = 5, b = 6, c = 3; int risultato = a * b / c;
Qui, entrambi *e /hanno la stessa precedenza. Ma poiché l'associatività di questi operatori va da sinistra a destra , a * bviene valutata prima e poi viene eseguita la divisione. Il risultato finale di questa espressione sarà 10.
In questo particolare esempio, l'associatività non ha molta importanza. Perché anche se la divisione fosse eseguita prima della moltiplicazione, il risultato non sarebbe influenzato.
Diamo un'occhiata a un altro esempio.
int a = 5, b = 6, c = 3; a = b = c;
L'associatività =dell'operatore va da destra a sinistra . Quindi il valore di c (cioè 3) viene assegnato a b, e quindi il valore di b viene assegnato a a. Quindi, dopo aver eseguito questa istruzione, i valori di a, bec saranno 3.
La tabella seguente mostra l'associatività degli operatori C #:
Associatività degli operatori in C #| Categoria | Operatori | Associatività |
|---|---|---|
| Incremento e decremento di Postfix | ++, - | Da sinistra a destra |
| Incremento, decremento e unario prefisso | ++, -, +, -,!, ~ | Da destra a sinistra |
| Moltiplicativo | *, /,% | Da sinistra a destra |
| Additivo | +, - | Da sinistra a destra |
| Cambio | <> | Da sinistra a destra |
| Relazionale | <,,> = | Da sinistra a destra |
| Uguaglianza | ==,! = | Da sinistra a destra |
| Bitwise AND | & | Da sinistra a destra |
| Bitwise XOR | ^ | Da sinistra a destra |
| OR bit per bit | | | Da sinistra a destra |
| AND logico | && | Da sinistra a destra |
| OR logico | || | Da sinistra a destra |
| Ternario | ? : | Da destra a sinistra |
| Incarico | =, + =, - =, * =, / =,% =, & =, | =, =, <> = | Da destra a sinistra |
Quasi tutti gli operatori hanno l'associatività da sinistra a destra. Gli operatori con associatività da destra a sinistra sono:
- Operatori unari
- Operatori di incremento e decremento prefisso
- Operatore ternario
- Operatori di assegnazione
Esempio 2: associatività degli operatori
using System; namespace Operator ( class OperatorPrecedence ( public static void Main(string() args) ( int a = 5, b = 6, c = 3; int result = a * b / c; Console.WriteLine(result); a = b = c; Console.WriteLine("a = (0), b = (1), c = (2)", a, b, c); ) ) )
Quando eseguiamo il programma, l'output sarà:
10 a = 3, b = 3, c = 3
