Operator Precedence

Operator precedence is one of the most important concepts in programming. It defines the order in which different operators in an expression are evaluated. When multiple operators appear together in a statement, operator precedence determines which operation will be performed first, second, and so on. Understanding operator precedence ensures that expressions are evaluated correctly and that the program produces the intended results.

Every programming language follows a specific set of precedence rules. These rules dictate the priority of operators such as arithmetic, relational, logical, bitwise, and assignment operators. Without understanding these rules, programmers can easily misinterpret the outcome of an expression, leading to logical errors that are often hard to detect.

This article explains operator precedence in depth — what it is, how it works, examples of precedence rules, the difference between precedence and associativity, common pitfalls, and the best practices for writing clear and predictable code.

What Is Operator Precedence?

Operator precedence refers to the hierarchy or ranking of operators that determines the sequence in which operations are executed in a statement containing multiple operators.

For example, consider the expression:

int result = 10 + 5 * 2;

In this expression, both addition and multiplication appear. However, multiplication has higher precedence than addition. Therefore, the multiplication operation is performed first, and the result is added to 10. The expression is evaluated as 10 + (5 * 2) which gives 20, not (10 + 5) * 2.

If the programmer wants addition to happen first, parentheses must be used explicitly:

int result = (10 + 5) * 2;

Now, the result will be 30 because the parentheses have overridden the default precedence.

In short, operator precedence defines the natural order of evaluation in complex expressions.

Why Operator Precedence Is Important

Operator precedence helps eliminate ambiguity in mathematical and logical expressions. If every operation had the same priority, programmers would be forced to use parentheses around every operation, making code longer and harder to read. Precedence rules simplify expression evaluation by defining a clear hierarchy.

For example, in arithmetic, everyone knows that multiplication is done before addition. The same rule applies in programming. These consistent precedence rules make it easier for programmers to predict results.

Without precedence, an expression like:

a + b * c - d

would be ambiguous. But with precedence rules, it becomes clear that b * c is computed first, then the addition and subtraction.

The Concept of Associativity

Operator precedence determines which operator is evaluated first, while associativity determines the direction in which operators of the same precedence are evaluated.

For example:

Left-to-right associativity means the expression is evaluated from left to right.
Right-to-left associativity means the expression is evaluated from right to left.

Example of Left-to-Right Associativity

int result = 100 / 10 / 2;

Both division operators have the same precedence and are evaluated left to right:

(100 / 10) / 2 = 10 / 2 = 5

Example of Right-to-Left Associativity

Assignment operators have right-to-left associativity:

a = b = c = 10;

This means c is assigned 10 first, then b, and finally a.

Understanding both precedence and associativity is essential to correctly predict how an expression will be evaluated.

Categories of Operators and Their Precedence Levels

Programming languages define several categories of operators. Each category has its own precedence level. The general hierarchy (from highest to lowest precedence) is as follows:

Parentheses ( )
Unary operators like ++, --, !, ~, +, -
Multiplicative operators *, /, %
Additive operators +, -
Shift operators <<, >>
Relational operators <, <=, >, >=
Equality operators ==, !=
Bitwise AND &
Bitwise XOR ^
Bitwise OR |
Logical AND &&
Logical OR ||
Conditional (ternary) operator ?:
Assignment operators =, +=, -=, *=, /=, etc.
Comma operator ,

This order defines how expressions are evaluated in languages like C, C++, and Java. Python follows a similar but slightly adjusted hierarchy.

How Operator Precedence Works

When an expression contains multiple operators, the language first looks for the operator with the highest precedence and evaluates it. Then it moves to the next level. If two operators share the same precedence, associativity rules decide the evaluation order.

Let’s look at several examples to see how precedence affects results.

Example 1: Arithmetic Operators

int result = 10 + 5 * 2;

According to precedence rules, multiplication has a higher priority than addition. Therefore:

result = 10 + (5 * 2);
result = 10 + 10;
result = 20;

If we change the order using parentheses:

result = (10 + 5) * 2;
result = 15 * 2;
result = 30;

This shows how parentheses can alter evaluation order.

Example 2: Combining Arithmetic and Relational Operators

int a = 10, b = 5, c = 2;
int result = a > b + c;

Here, addition has higher precedence than the relational operator >. Therefore:

result = a > (b + c);
result = 10 > 7;
result = 1 (true);

If parentheses are changed:

result = (a > b) + c;
result = (10 > 5) + 2;
result = 1 + 2 = 3;

This example highlights how even a simple change in parentheses can completely alter the meaning of an expression.

Example 3: Logical and Relational Operators

int x = 5, y = 10, z = 15;
int result = x < y && y < z;

Here, < has higher precedence than &&. Therefore, both relational operations are evaluated first, then the logical AND:

(x < y) && (y < z);
(true) && (true);
true;

If we change it using parentheses:

int result = x < (y && y < z);

This would be evaluated differently and could even result in unexpected behavior.

Example 4: Bitwise and Logical Operators

int a = 6;    // binary 0110
int b = 3;    // binary 0011
int result = a & b == 2;

Here, the equality operator (==) has higher precedence than bitwise AND (&). Therefore, the expression is interpreted as:

a & (b == 2);

If we intended to perform the bitwise AND first, we would need to use parentheses:

(a & b) == 2;

Without parentheses, the output may not match the programmer’s intention.

Example 5: Assignment and Arithmetic Operators

int result = 10 + 5 * 2 - 3;

Here, the order is:

Multiplication first
Then addition
Then subtraction

So:

result = 10 + (5 * 2) - 3;
result = 10 + 10 - 3;
result = 17;

Parentheses can always be used to change this order.

Example 6: Assignment and Increment Operators

int a = 5;
int result = ++a * 2;

The prefix increment (++a) has higher precedence than multiplication. Therefore:

a = 6;
result = 6 * 2 = 12;

If the increment were postfix:

int result = a++ * 2;

Then:

result = 5 * 2 = 10;
a = 6;

Understanding operator precedence helps avoid subtle logic errors like this.

Example 7: Assignment Operator Associativity

int a, b, c;
a = b = c = 10;

Since assignment is right-to-left associative, the expression is evaluated as:

a = (b = (c = 10));

So all three variables get the value 10.

Example 8: Ternary Operator Precedence

The conditional or ternary operator (?:) has lower precedence than most arithmetic and relational operators but higher than assignment operators.

int x = 5;
int y = 10;
int result = x > y ? x : y;

Here, the relational expression x > y is evaluated first. Since 5 is not greater than 10, the result will be y, which is 10.

If we use parentheses differently:

int result = (x + 5 > y) ? x : y;

Then the addition occurs before the comparison.

Operator Precedence Table Example (C-Like Languages)

Here’s a simplified precedence table showing operators from highest to lowest precedence:

Parentheses ( )
Unary Operators ++ -- ! ~ + -
Multiplication, Division, Modulus * / %
Addition, Subtraction + -
Shift Operators << >>
Relational Operators < <= > >=
Equality Operators == !=
Bitwise AND &
Bitwise XOR ^
Bitwise OR |
Logical AND &&
Logical OR ||
Ternary Operator ?:
Assignment Operators = += -= *= /= %= <<= >>= &= ^= |=
Comma Operator ,

This table provides a clear summary of operator hierarchy. Although exact details may vary slightly across programming languages, the general order remains similar.

Parentheses and Their Role

Parentheses are the most powerful tool for controlling the order of evaluation. Regardless of operator precedence, parentheses always take the highest priority. By enclosing an expression in parentheses, you can force the program to evaluate it before applying other operators.

Example

int result = 10 + 5 * 2;

Evaluates to 20.

int result = (10 + 5) * 2;

Evaluates to 30.

Parentheses make expressions more readable and less error-prone. Even if you know precedence rules, it is often good practice to use parentheses for clarity.

Precedence vs Associativity: Key Differences

Feature	Operator Precedence	Associativity
Definition	Determines which operator is evaluated first	Determines the direction of evaluation when operators have the same precedence
Example	`10 + 5 * 2` → Multiplication first	`100 / 10 / 2` → Left to right
Impact	Controls operation priority	Controls order of execution for equal-precedence operators
Parentheses Effect	Can override precedence	Does not change associativity

Both are essential for correct expression evaluation.

Common Mistakes in Operator Precedence

Even experienced programmers make mistakes when they assume precedence incorrectly. Here are some common pitfalls:

1. Confusing Bitwise and Logical Operators

Expressions like:

if (a & b == 0)

may not behave as expected because == has higher precedence than &. Always use parentheses:

if ((a & b) == 0)

2. Forgetting Associativity

int x = 10, y = 20, z = 30;
int result = x = y = z;

If you mistakenly assume left-to-right evaluation, you may think x becomes 20, but actually, due to right-to-left associativity, all three become 30.

3. Ignoring Parentheses

int value = 10 + 5 << 1;

This is not (10 + 5) << 1 by default. Shift operators have lower precedence than addition in C, but in other languages, the rules may differ. Always use parentheses for clarity.

4. Misunderstanding Postfix vs Prefix

int a = 5;
int result = a++ + ++a;

The order of evaluation and result depend on how the language handles side effects. Avoid such complex expressions.

Operator Precedence in Different Programming Languages

Although the general precedence hierarchy is similar across languages, there are small variations worth noting.

C and C++

C and C++ follow strict precedence and associativity rules similar to the table above. Parentheses are heavily used for clarity in complex expressions.

Java

Java’s precedence rules are almost identical to C and C++, with the addition of some specific rules for bitwise and logical shifts.

Python

Python follows a clear precedence hierarchy but also allows chaining comparisons like:

a < b < c

which is equivalent to (a < b) and (b < c).

JavaScript

JavaScript uses similar precedence rules but includes additional operators such as ===, !==, and the ternary ? :.

Best Practices for Using Operator Precedence

Use parentheses for clarity. Even if you know the rules, parentheses make your intentions explicit.
Avoid complex expressions. Break them into smaller parts.
Check associativity rules. Especially for assignment and conditional operators.
Review language documentation. Each language has minor differences.
Test and verify expressions. Especially when mixing bitwise and logical operators.

Real-World Examples of Operator Precedence

Example 1: Mathematical Calculations

int result = 10 + 20 * 30;

Multiplication happens first, so:

result = 10 + (600);
result = 610;

Example 2: Complex Conditional

if (a > b && b > c || a == c)

> is evaluated first, followed by &&, and finally ||.

Example 3: Assignments

x = y = 5 + 3 * 2;

First multiplication, then addition, then right-to-left assignment.

Example 4: Mixing Types

int result = (a + b) * (c - d) / e;

Parentheses ensure the correct sequence and readability.

The Role of Parentheses in Preventing Bugs

Parentheses not only clarify precedence but also prevent subtle logical bugs. Even when the compiler knows the correct order, other developers reading your code might misinterpret it. Parentheses act as visual guides to your intention.