Neste tutorial, você aprenderá sobre precedência de operador e associatividade em C #. Isso nos dará uma ideia de como uma expressão é avaliada pelo compilador C #.
Precedência do operador C #
A precedência do operador é um conjunto de regras que define como uma expressão é avaliada. Em C #, cada operador C # tem uma prioridade atribuída e, com base nessas prioridades, a expressão é avaliada.
Por exemplo , a precedência do (*)operador de multiplicação é maior do que a precedência do (+)operador de adição . Portanto, a operação que envolve a multiplicação é realizada antes da adição.
Dê uma olhada na declaração abaixo.
int x = 4 + 3 * 5;
Qual será o valor de x depois de executar esta instrução?
O operando 3está associado a +e *. Conforme afirmado anteriormente, a multiplicação tem uma precedência maior do que a adição. Portanto, a operação 3 * 5é realizada em vez de 4 + 3. O valor da variável x será 19.
Se a adição tivesse uma precedência mais alta, 4 + 3seria avaliada primeiro e o valor de x seria 35.
Tabela de precedência do operador
Quanto maior for a precedência do operador, mais alto ele aparecerá na tabela
Precedência do operador C #| Categoria | Operadores |
|---|---|
| Incremento e diminuição do Postfix | ++, - |
| Incremento, decremento e unário do prefixo | ++, -, +, -,!, ~ |
| Multiplicativo | *, /,% |
| Aditivo | +, - |
| Mudança | <> |
| Relacional | <,,> = |
| Igualdade | ==,! = |
| E bit a bit | E |
| XOR bit a bit | ^ |
| OR bit a bit | | |
| E lógico | && |
| OR lógico | || |
| Ternário | ? : |
| Tarefa | =, + =, - =, * =, / =,% =, & =, | =, =, <> = |
Os operadores de atribuição têm a precedência mais baixa, enquanto os operadores de incremento e decremento pós-fixados têm a precedência mais alta.
Exemplo 1: Precedência do operador
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 executamos o programa, a saída será:
19 falso
Vamos entender como a expressão é avaliada no programa.
A precedência de --e ++é superior a *, e a precedência de *é superior a -. Daí a declaração,
resultado1 = --a * b - ++ c;
é equivalente a
resultado1 = ((--a) * b) - (++ c);
A expressão entre parênteses é sempre avaliada primeiro, não importa qual seja a precedência dos operadores fora dela.
- Em primeiro lugar, (--a) é avaliado resultando em
4.
- Então (++ c) é avaliado resultando em
5.
- Agora, (a * b) é avaliado resultando em
24.
- Finalmente, a subtração é realizada resultando em
19.
- Portanto, o valor final de result1 será
19.
Na próxima expressão, a precedência de +é maior que >=. Assim, c e a são adicionados primeiro e a soma é comparada com b para produzir false.
Associatividade de operadores em C #
Na seção anterior, discutimos sobre a precedência do operador. Se dois operadores com precedência diferente forem usados, o operador com precedência mais alta será avaliado primeiro.
Mas e se os dois operadores tiverem a mesma precedência?
Nesse caso, a expressão é avaliada com base na associatividade do operador (da esquerda para a direita ou da direita para a esquerda).
Por exemplo:
int a = 5, b = 6, c = 3; resultado interno = a * b / c;
Aqui, ambos *e /têm a mesma precedência. Mas como a associatividade desses operadores é da esquerda para a direita , ela a * bé avaliada primeiro e, em seguida, a divisão é realizada. O resultado final desta expressão será 10.
Neste exemplo específico, a associatividade não importa realmente. Porque mesmo que a divisão fosse realizada antes da multiplicação, o resultado não seria afetado.
Vamos dar uma olhada em outro exemplo.
int a = 5, b = 6, c = 3; a = b = c;
A associatividade do =operador é da direita para a esquerda . Portanto, o valor de c (ie 3) é atribuído a b, e o valor de b é atribuído a a. Então, depois de executar esta instrução, os valores de a, bec serão 3.
A tabela abaixo mostra a associatividade dos operadores C #:
C # Associatividade de operadores| Categoria | Operadores | Associatividade |
|---|---|---|
| Incremento e diminuição do Postfix | ++, - | Da esquerda para direita |
| Incremento, decremento e unário do prefixo | ++, -, +, -,!, ~ | Direita para esquerda |
| Multiplicativo | *, /,% | Da esquerda para direita |
| Aditivo | +, - | Da esquerda para direita |
| Mudança | <> | Da esquerda para direita |
| Relacional | <,,> = | Da esquerda para direita |
| Igualdade | ==,! = | Da esquerda para direita |
| E bit a bit | E | Da esquerda para direita |
| XOR bit a bit | ^ | Da esquerda para direita |
| OR bit a bit | | | Da esquerda para direita |
| E lógico | && | Da esquerda para direita |
| OR lógico | || | Da esquerda para direita |
| Ternário | ? : | Direita para esquerda |
| Tarefa | =, + =, - =, * =, / =,% =, & =, | =, =, <> = | Direita para esquerda |
Quase todos os operadores têm associatividade da esquerda para a direita. Os operadores com associatividade da direita para a esquerda são:
- Operadores unários
- Operadores de incremento e decremento de prefixo
- Operador Ternário
- Operadores de atribuição
Exemplo 2: Associatividade de Operadores
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 executamos o programa, a saída será:
10 a = 3, b = 3, c = 3
