Language: EN
LuisLlamas Logo
Search
⏲️ ~ 4 minutes Beginner
csharp-precedencia-operadores

Operator Precedence in C#

Operator precedence defines the order in which different operators are evaluated in an expression without parentheses.

Operators with higher precedence are evaluated before operators with lower precedence. If two operators have the same precedence, their evaluation is determined by the associativity of the operator (left to right or right to left).

If you want to learn more about Operator Precedence
check out the Introduction to Programming Course read more

Operator Precedence Table

In C#, operators are grouped into levels of precedence. Below is a table that shows some of the most common operators organized by their precedence, from highest to lowest.

PrecedenceOperatorDescriptionAssociativity
1()ParenthesesN/A
2++, --Increment and decrementPostfix
3+, -Unary positive and negativeRight to left
4*, /, %Multiplication, division, modulusLeft to right
5+, -Addition, subtractionLeft to right
6<<, >>Bitwise shiftLeft to right
7<, >, <=, >=ComparisonLeft to right
8==, !=Equality, inequalityLeft to right
9&Bitwise ANDLeft to right
10^Bitwise XORLeft to right
11``Bitwise OR
12&&Logical ANDLeft to right
13``
14?:Conditional (ternary) operatorRight to left
15=, +=, -=Assignment and compound operatorsRight to left

How Operator Precedence Works

Expression Evaluation

Operator precedence determines the order of evaluation in complex expressions. For example, suppose we have the following expression:

int result = 3 + 4 * 2; // equals to 3 + (4 * 2) = 11

In this expression, multiplication (*) has higher precedence than addition (+). Therefore, 4 * 2 is evaluated first, yielding 8, and then 3 is added, resulting in 11.

Use of Parentheses

To change the order of evaluation, we can employ our faithful friends, parentheses. Parentheses have the highest precedence and force the evaluation of the expression they contain first.

int result = (3 + 4) * 2;

Here, 3 + 4 is evaluated first due to the parentheses, yielding 7, and then it is multiplied by 2, resulting in 14.

Associativity

When operators have the same precedence, associativity determines the order of evaluation. Most operators in C# have left-to-right associativity, which means they are evaluated from left to right.

int a = 1;
int b = 2;
int c = 3;
int result = a + b - c;

In this example, both + and - have the same precedence and left-to-right associativity. Therefore, a + b is evaluated first, yielding 3, and then 3 - c is evaluated, resulting in 0.

However, some operators, such as assignment operators, have right-to-left associativity.

Understanding Compound Operators

Compound operators, such as += and -=, combine assignment with another operation. These operators have lower precedence, which can affect the outcome of expressions if not understood correctly.

int a = 5;
a += 3 * 2; // a = a + (3 * 2)
Console.WriteLine(a); // Output: 11

In this example, 3 * 2 is evaluated first due to its higher precedence, and then the result 6 is added to a.

Complex Example

Let’s consider a more complex expression to illustrate how precedence and associativity combine:

int result = 5 + 2 * 3 - 4 / 2 + (1 + 3);

We evaluate step by step according to precedence and associativity:

  1. Evaluate the expression in parentheses: (1 + 3), which results in 4.
  2. Evaluate the multiplication: 2 * 3, which results in 6.
  3. Evaluate the division: 4 / 2, which results in 2.
  4. Evaluate the remaining operations from left to right:
    • 5 + 6 results in 11.
    • 11 - 2 results in 9.
    • 9 + 4 results in 13.

Therefore, the final result of the expression is 13.

Best Practices Tips

Although operator precedence allows omitting parentheses in many situations, it is good practice to use parentheses to improve code clarity. This not only makes the code easier to understand but also reduces the likelihood of errors.

int result = (5 + 2) * (3 - 1);

On this page