# Operator precedence in C

The sequence in which operations are carried out in an expression in C is determined by operator precedence. It specifies which operators are evaluated first and which are evaluated last when multiple operators are present in an expression. The following is a list of operators in C sorted by precedence, from highest to lowest:

• Parentheses () - Expressions enclosed in parentheses are evaluated first.
• Postfix increment/decrement (++/--): These operators increase or decrease the value of a variable by 1 after the expression is evaluated.
• Prefix increment/decrement (++/--): These operators increase or decrease the value of a variable by 1 before the expression is evaluated.
• Unary plus/minus (+/-): These operators are used to specify the sign of a value.
• Logical negation (!): The logical negation (!) operator is used to make a boolean expression's logical meaning the opposite.
• Bitwise complement (~): This operator is used to flip the bits of a value.
• Casts: These operators are employed to change an expression's type into another type.
• Multiplication/division/modulo (* / %): These operators perform multiplication, division, and modulo operations.
• Bitwise shift (<< >>): These operators are employed to left- or right-shift the bits of a number.
• Relational operators (< <= > >=): These operators perform a comparison between two numbers and provide a boolean result as a result.
• The equality operators (==!=): These operators compare two values to see if they are equal and then deliver a boolean result based on the comparison
• Bitwise AND (&): This operator combines two numbers in a bitwise manner.
• Bitwise XOR (): Using this operator, two numbers are bitwise XORed.
• Bitwise OR (|): This operator combines two numbers in a bitwise manner.
• Logical AND (&&): The logical AND operator (&&) applies the logical AND function to two boolean values.
• Logical OR (||): Using this operator, two boolean numbers are logically combined. Ternary conditional operator (?:): This operator allows for a conditional statement that is used to evaluate one of two expressions based on the result of a boolean expression.
• Assignment (= += -= *= /= %= <<= >>= &= ^= |=): These operators are used to assign a value to a variable, or to modify the value of a variable.

It's important to note that the order of evaluation is not always intuitive or straightforward, and it's often necessary to use parentheses to clarify the intended order of operations. For example, consider the expression "2 + 3 * 4". Without parentheses, it's not clear whether the multiplication or the addition should be performed first. However, if we write "(2 + 3) * 4", it's clear that the addition should be performed first, and then the multiplication.

In addition to operator precedence, C also has rules for operator associativity, which determine the order in which operators of the same precedence are evaluated. For example, the addition and subtraction operators have the same precedence, but they are left-associative, which means that they are evaluated from left to right. So the expression "2 + 3 - 4" is evaluated as "(2 + 3) - 4", which is equal to 1.

It's important to understand operator precedence and associativity in C, as they can affect the outcome of an expression and lead to unexpected results if not used correctly. By understanding these rules, you can write more efficient and correct code.

Operators in C have associativity, which defines the order in which operators with the same precedence are evaluated. There are two kinds of associativity: left-to-right and right-to-left.

### Here is a table of operator associativity in C: Note that operators with left-to-right associativity are evaluated from left to right, while operators with right-to-left associativity are evaluated from right to left. This can affect the order of operations when multiple operators of the same precedence are used in an expression.

To comprehend operator precedence in C, consider the following instance:

### C Program:

Output

```Result: 14
Result2: 77
Result3: 17
Result4: 10
Result5: 1
```
1. In the first example, the expression x + y * z is evaluated as x + (y * z), due to the higher precedence of * over +. This results in result being assigned the value of 14.
2. In the second example, the expression (a + b) * c is evaluated as (a + b) * c, due to the parentheses overriding the precedence of + and *. This results in result2 being assigned the value of 77.
3. In the third example, the expression e % f is evaluated first, due to the higher precedence of % over +, and then the result is added to d. This results in result3 being assigned the value of 17.
4. In the fourth example, the expression g * h is evaluated first, due to the same precedence of * and / and left-to-right associativity. Then the result is divided by i. This results in result4 being assigned the value of 10.
5. In the fifth example, the expression j == k is evaluated first, due to the same precedence of == and || and left-to-right associativity. Then the result is OR-ed with the result of l > k. This results in result5 being assigned the value of 1 (true).

## Conclusion

In conclusion, understanding operator precedence and associativity in C is crucial for writing correct and efficient code. It figures out the sequence in which operators are evaluated and can influence the outcome of an expression. It is essential to recall that brackets can override operators' default precedence and associativity. You can construct complex expressions that compute the desired outcome using the operator precedence and associativity tables in conjunction with brackets.

### Feedback   