🧮 21. Operator Precedence & Associativity in C

When a C expression contains several operators, its meaning depends on how the operators and operands are grouped and how equal-precedence operators group together. These rules are described using operator precedence and operator associativity.

21.1 Why Do We Need Precedence?

Consider:

int result = 2 + 3 * 4;

There are two operators: + and *. If addition happened first, the result would be:

(2 + 3) * 4 = 20

But multiplication has higher precedence than addition, so C groups the expression as:

2 + (3 * 4)

Therefore:

2 + 12 = 14

 Expression: 2 + 3 * 4 │ ▼ * has higher precedence │ ▼ 2 + (3 * 4) │ ▼ 14 

21.2 What Is Operator Precedence?

Operator precedence defines the relative priority of operators when an expression contains different operators.

For example:

* / % 

have higher precedence than:

+ - 

Therefore:

a + b * c

is grouped as:

a + (b * c)

not:

(a + b) * c

21.3 What Is Associativity?

Associativity determines how operators having the same precedence are grouped.

For example:

a - b + c

The + and - operators have the same precedence and their associativity is left-to-right.

Therefore:

(a - b) + c

is the grouping.

 a - b + c ┌───────────────┐ │ Same precedence│ └───────┬───────┘ │ ▼ Left → Right (a - b) + c 

21.4 Precedence vs Associativity

21.5 C Operator Precedence Reference Table

The following table is a practical ordering from higher precedence to lower precedence.

21.6 Parentheses Make Grouping Explicit

Parentheses explicitly group an expression.

int a = 2 + 3 * 4; int b = (2 + 3) * 4;

Results:

a = 14 b = 20

21.7 Arithmetic Precedence

int result = 10 + 4 * 2;

Multiplication comes first:

10 + (4 * 2) 10 + 8 18

Now consider:

int result = (10 + 4) * 2;

Parentheses change the grouping:

14 * 2 28

21.8 Multiplication, Division and Remainder

The operators *, /, and % have the same precedence and associate from left to right.

int result = 20 / 5 * 2;

Grouping:

(20 / 5) * 2

Result:

8

Not:

20 / (5 * 2)

21.9 Addition and Subtraction

int result = 20 - 5 + 2;

Both operators have the same precedence and are left-associative.

(20 - 5) + 2 15 + 2 17

21.10 Relational Operators vs Equality Operators

Relational operators have higher precedence than equality operators.

a < b == c < d

The relational comparisons are grouped first:

(a < b) == (c < d)

A comparison produces int value 1 when true and 0 when false. In the next comparison, that 0 or 1 becomes an operand.

21.11 Logical AND vs Logical OR

Logical AND has higher precedence than logical OR.

a || b && c

is grouped as:

a || (b && c)

not:

(a || b) && c

21.12 Bitwise AND vs Logical AND

For example:

a & b == 0

Because equality has higher precedence than bitwise AND, the expression is grouped as:

a & (b == 0)

This may be surprising. If the intended meaning is to test the bitwise result, write:

(a & b) == 0

21.13 Assignment Operators Are Right-Associative

a = b = c = 10;

The grouping is:

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

Therefore c receives 10, then b, then a.

21.14 Chained Assignment

int a, b, c; a = b = c = 25;

Conceptually:

c = 25 b = c a = b

All three objects end up containing 25.

21.15 Conditional Operator Associativity

The conditional operator ?: is right-associative.

a ? b : c ? d : e

is grouped as:

a ? b : (c ? d : e)

Nested conditional expressions can become difficult to read, so parentheses are often useful.

21.16 Unary Operators and Right-to-Left Associativity

For a chain of prefix unary operators, start with the operator nearest the operand and work outward.

!~x

can be understood as:

!(~x)

Read the inner operation first to understand what value the outer operator uses.

21.17 Function Calls and Array Access

Function call and array subscript operators have very high precedence.

arr[i + 1]

The expression between the brackets supplies the array index. The brackets form an array-access expression using arr.

Similarly:

printf("%d", a + b);

The parentheses after the function name form a function call. Commas separate the arguments; they do not specify which argument is evaluated first.

21.18 Structure Member Access

The operators . and -> are among the highest precedence operators.

student.age studentPtr->age

Parentheses can still be necessary when combining member access with other operators or pointer expressions.

21.19 Prefix vs Postfix Increment

++i i++

Both increment the object, but their values in an expression differ.

Postfix increment has higher precedence than prefix increment. This controls grouping, while the prefix/postfix rule determines whether the expression gives the new or old value.

21.20 Precedence Is Not Evaluation Order

For example, do not reason incorrectly from precedence alone about:

f() + g()

The precedence of + does not tell you whether f() or g() is called first.

When the call order matters, call each function in a separate statement. Store the results and then calculate their sum.

21.21 Associativity Is Not Evaluation Order Either

Associativity answers a grouping question. It does not guarantee the execution order of separate function calls or other operands.

For example:

a - b - c

is grouped as:

(a - b) - c

because subtraction is left-associative.

For values already stored in variables, follow this grouping to calculate the answer. If the operands are function calls, do not assume that the leftmost call runs first.

21.22 A Complete Expression Trace

int result = 10 + 2 * 5 - 8 / 2;

 10 + 2 * 5 - 8 / 2 │ │ ▼ ▼ 2 * 5 8 / 2 │ │ ▼ ▼ 10 4 Expression becomes: 10 + 10 - 4 + and - have equal precedence. Associativity = Left → Right. (10 + 10) - 4 20 - 4 = 16 

21.23 Another Expression Trace

int result = 8 + 4 * 3 - 6 / 2;

Step 1:

4 * 3 = 12 6 / 2 = 3

Now:

8 + 12 - 3

Left-to-right for equal-precedence + and -:

(8 + 12) - 3 20 - 3 17

21.24 Parentheses Can Improve Readability

Compare:

if (a & mask == 0)

with:

if ((a & mask) == 0)

The second version communicates the intended grouping much more clearly.

21.25 Common Precedence Trap — Arithmetic

int x = 2 + 3 * 4;

Correct:

14

Incorrect assumption:

20

21.26 Common Precedence Trap — Division and Multiplication

int x = 24 / 6 * 2;

Both operators have the same precedence and are left-associative:

(24 / 6) * 2 4 * 2 8

21.27 Common Precedence Trap — Logical Operators

if (age >= 18 && score >= 50 || bonus)

Grouping:

((age >= 18) && (score >= 50)) || bonus

Logical AND has higher precedence than logical OR.

21.28 Common Precedence Trap — Assignment

if (x = 10)

This condition assigns a value instead of comparing values. The assigned value becomes the condition: zero is false and a nonzero value is true. Use equality comparison when you only want to test the value.

For comparison, use:

if (x == 10)

21.29 Comma Operator

The comma operator has very low precedence compared with most other operators.

int x = (a = 5, b = 10, a + b);

The comma operator evaluates the expressions from left to right and the value of the whole comma expression is the value of its rightmost operand.

Here:

a = 5 b = 10 a + b = 15

So:

x = 15

21.30 The Cast Operator

double result = (double)5 / 2;

A cast groups tightly with its operand. Here, it converts 5 to double before division, so the division uses floating-point arithmetic.

Therefore:

(double)5 

becomes a floating-point value before division.

Without the cast:

5 / 2

is integer division when both operands are integers.

21.31 Pointer Expressions and Precedence

Consider:

*p++

The postfix increment operator has higher precedence than unary dereference, so it is grouped as:

*(p++)

It is not:

(*p)++

These expressions have different effects.

21.32 Another Pointer Example

(*p)++;

Here parentheses force the dereferenced object to be incremented.

Compare:

*p++; 

which groups as:

*(p++);

21.33 Array and Pointer Precedence

*p[i]

The array subscript operator has higher precedence than unary dereference. Therefore it is grouped as:

*(p[i])

not:

(*p)[i]

Parentheses are required for the second interpretation.

21.34 Macro Expressions and Precedence

Precedence becomes especially important when writing C preprocessor macros.

Unsafe macro:

#define SQUARE(x) x * x

Consider:

int result = SQUARE(5 + 1);

Expansion:

5 + 1 * 5 + 1

Due to multiplication precedence:

5 + 5 + 1 = 11 

Safe form:

#define SQUARE(x) ((x) * (x))

Expansion:

((5 + 1) * (5 + 1)) = 36 

21.35 Side Effects in Expressions

Parentheses do not prevent a macro from using an argument twice. If the argument changes a variable, the expanded expression may have undefined behavior.

#define SQUARE(x) ((x) * (x)) int i = 5; int result = SQUARE(i++);

Expansion:

((i++) * (i++))

The expression modifies i more than once without the sequencing required to make the behavior defined. The behavior is therefore undefined.

A function is often safer when an argument may have side effects:

static inline int square_int(int x) { return x * x; }

21.36 Precedence and the Conditional Operator

int max = a > b ? a : b;

Relational comparison binds more strongly than the conditional operator, so the expression is effectively:

int max = (a > b) ? a : b;

Adding parentheses can still improve readability.

21.37 Precedence and Assignment

x = a + b * c;

Grouping:

x = (a + (b * c));

The multiplication is grouped before addition, and the resulting expression is then assigned to x.

21.38 How to Solve Precedence Questions

 Expression | v Check parentheses | v Find higher-precedence operators | v Group equal-precedence operators using associativity | v Check casts / unary operators | v Check logical and relational grouping | v Check assignment | v Evaluate the grouped expression | v Final result 

21.39 A Reliable Exam Method

1. Write the expression clearly.
2. Resolve explicit parentheses first.
3. Identify the highest-precedence operators.
4. Apply associativity where operators share precedence.
5. Rewrite the expression with parentheses.
6. Evaluate only after the grouping is clear.
7. Check for side effects or undefined behavior.

21.40 Example — Placement Style Question

int x = 5; int y = 2; int result = x + y * 3;

Multiplication first:

5 + (2 * 3) 5 + 6 11

Therefore:

result = 11

21.41 Example — Same Precedence

int result = 100 / 10 * 2;

Because / and * have the same precedence:

(100 / 10) * 2 10 * 2 20

21.42 Example — Logical Expression

int result = 1 || 0 && 0;

AND first:

1 || (0 && 0)

Then:

1 || 0 = 1 

21.43 Example — Comparison and Logical Operators

int result = 5 > 2 && 8 > 4;

Comparisons are grouped before logical AND:

(5 > 2) && (8 > 4)

Both comparisons are true, so:

1 && 1 = 1 

21.44 Example — Assignment Chain

int a, b, c; a = b = c = 50;

Because assignment is right-associative:

a = (b = (c = 50));

Final values:

a = 50 b = 50 c = 50 

21.45 Example — Parentheses Change Everything

int a = 2; int b = 3; int c = 4; int x = a + b * c; int y = (a + b) * c;

First:

x = 2 + (3 * 4) x = 14

Second:

y = (2 + 3) * 4 y = 20

21.46 Precedence vs Evaluation vs Sequencing

#include <stdio.h>

int main(void)
{
    int valid = 1;
    int points = valid ? 10 : -1;
    printf("Points = %d\n", points);
    return 0;
}

Points = 10

21.48 Quick Revision

INTERACTIVE LEARNING

🎬 Operator Precedence — Expression Grouping

Follow how C groups 10 + 5 * 2 > 15 && 1 according to operator precedence.

▶ Open Visualization

—

21.49 Quick MCQs

Select an answer first, then click Check Answer. A correct choice becomes green. If the answer is wrong, your choice becomes red and the correct option becomes green. The explanation appears below.

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("%d", 10 + 5 * 2);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("%d", 20 / 5 * 2);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("%d", 10 + 5 > 12);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("%d", 5 | 3 & 1);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("%d", 1 << 2 + 1);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("%d", 1 || 0 && 0);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int a, b;
    a = b = 20;
    printf("a=%d b=%d", a, b);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int x = 5;
    int y = ++x;
    printf("x=%d y=%d", x, y);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int x = 5;
    int y = x++;
    printf("x=%d y=%d", x, y);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int a[] = {10, 20};
    int *p1 = a;
    int *p2 = a;

    int first = *p1++;
    int second = (*p2)++;

    printf("first=%d next=%d second=%d a0=%d",
           first, *p1, second, a[0]);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int marks;
    scanf("%d", &marks);

    char grade = marks >= 90 ? 'A' : marks >= 75 ? 'B' : 'C';
    printf("%c", grade);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int x, y;
    y = (x = 5, x + 3);
    printf("x=%d y=%d", x, y);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int a, b, c, d;
    scanf("%d %d %d %d", &a, &b, &c, &d);
    printf("%d", a + b * c - d);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    printf("%d", a && b || c);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("%d", 10 > 5 == 1);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int direct = 5 & 3 == 1;
    int clear = (5 & 3) == 1;

    printf("direct=%d clear=%d", direct, clear);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int a, b, c, d, e;
    scanf("%d %d %d %d %d", &a, &b, &c, &d, &e);

    int result = (((a + (b * c)) > d) && e);
    printf("%d", result);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("Precedence determines grouping.\n");
    printf("Evaluation order determines when operands are evaluated.");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("i = i++ + 1: Undefined\n");
    printf("i++; i += 1;: Well-defined");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("E1=%d\n", 10 + 5 * 2);
    printf("E2=%d\n", 20 / 5 * 2);
    printf("E3=%d\n", 10 + 5 > 12);
    printf("E4=%d\n", 5 | 3 & 1);
    printf("E5=%d\n", 1 << 2 + 1);
    printf("E6=%d\n", 1 || 0 && 0);
    printf("E7=%d\n", 10 > 5 == 1);
    printf("E8=%d\n", (5 & 3) == 1);
    printf("E9=%d\n", 2 + 3 << 1);
    printf("E10=%d", 0 ? 10 : 20);
    return 0;
}

21.51 Key Takeaway