Operator Precedence and Associativity in C

Operator precedence determines the order in which different operators are evaluated in an expression. Associativity decides the evaluation order when two or more operators have the same precedence.

• Operators with higher precedence are evaluated before operators with lower precedence.
• When operators have the same precedence, associativity (left-to-right or right-to-left) determines the order of evaluation.

#include <stdio.h>

int main()
{
    int a = 6, b = 3, c = 4;
    int res;

    // Precedence and associativity applied here
    res = a + b * c / 2;

    printf("%d", res);

    return 0;
}

12

Explanation

In the above example, the expression is evaluated according to the precedence and associativity of the operators.

• Multiplication (*) and division (/) have higher precedence than addition (+), so they are evaluated first.
• Since * and / have the same precedence, they are evaluated from left to right due to their associativity.
• Therefore, the expression evaluates to 12, not 18.

Operator Precedence

Operator precedence determines which operator is evaluated first when an expression contains multiple operators.

• Operators with higher precedence are evaluated before operators with lower precedence.
• In 10 + 20 * 30, * has higher precedence than +, so multiplication is performed first.

#include <stdio.h>

int main() {
  
    // Printing the value of same expression
    printf("%d", 10 + 20 * 30);

    return 0;
}

610

As we can see, the expression is evaluated as,10 + (20 * 30) but not as (10 + 20) * 30 due to * operator having higher precedence.

Operator Associativity

Operator associativity determines the order in which operators of the same precedence are evaluated.

• Associativity can be left-to-right or right-to-left, depending on the operator.
• In 100 / 5 % 2, / and % have the same precedence, so they are evaluated from left to right.

#include <stdio.h>
int main()
{

    // Verifying the result of the same expression
    printf("%d", 100 / 5 % 2);

    return 0;
}

0

Operators Precedence and Associativity are two characteristics of operators that determine the evaluation order of sub-expressions.

Example of Operator Precedence and Associativity

The following example shows how operator precedence and associativity determine the order in which an expression is evaluated.

• In 100 + 200 / 10 - 3 * 10, / and * are evaluated before + and -.
• Operators with the same precedence are evaluated from left to right, producing the final result

#include <stdio.h>
int main()
{

    // getting the result of the same expression as the example
    int exp = 100 + 200 / 10 - 3 * 10;
    printf("%d", exp);

    return 0;
}

90

Operator Precedence and Associativity Table

The following tables list the C operator precedence from highest to lowest and the associativity for each of the operators:

Easy Trick to Remember the Operators Associtivity and Precedence: PUMA'S REBL TAC

where, P = Postfix, U = Unary, M = Multiplicative, A = Additive, S = Shift, R = Relational, E = Equality, B = Bitwise, L = Logical, T = Ternary, A = Assignment and C = Comma

Important Points

There are a few important points and cases that we need to remember for operator associativity and precedence which are as follows:

Associativity is only used when there are two or more operators of the same precedence.

Associativity does not decide the order of operand or function evaluation. For example, in f1() + f2(), f1() is not guaranteed to execute before f2(), so the output may be compiler-dependent.

#include <stdio.h>

int x = 0;
int f1()
{
    x = 5;
    return x;
}
int f2()
{
    x = 10;
    return x;
}
int main()
{
    int p = f1() + f2();
    printf("%d ", x);
    return 0;
}

10 

You can check this article for more details.

We can use parenthesis to change the order of evaluation

Parentheses () have the highest precedence in C. They are used to change the default order of evaluation in an expression.

Consider the given expression

100 + 200 / 10 - 3 * 10 = 90

But if we enclose 100 + 200 in parenthesis, then the result will be different.

(100 + 200) / 10 - 3 * 10 = 0

As the + operator will be evaluated before / operator.

All operators with the same precedence have the same associativity.

This is necessary, otherwise, there won't be any way for the compiler to decide the evaluation order of expressions that have two operators of the same precedence and different associativity. For example + and - have the same associativity.

Precedence and associativity of postfix ++ and prefix ++ are different.

The precedence of postfix ++ is more than prefix ++, their associativity is also different. The associativity of postfix ++ is left to right and the associativity of prefix ++ is right to left. Check this article for more details.

Comma has the least precedence among all operators and should be used carefully.

#include <stdio.h>
int main()
{
    int a;
  
    // Evaluated as (a = 1), 2, 3
    a = 1, 2, 3; 
    printf("%d", a);
    return 0;
}

1

There is no chaining of comparison operators in C

In Python, an expression like "c > b > a" is treated as "c > b and b > a", but this type of chaining doesn't happen in C. For example, consider the following program. The output of the following program is "FALSE".

#include <stdio.h>
int main()
{
    int a = 10, b = 20, c = 30;

    // (c > b > a) is treated as ((c  > b) > a), associativity of '>' is left to right.
    // Therefore the value becomes ((30 > 20) > 10) which becomes (1 > 10)
    if (c > b > a)
        printf("TRUE");
    else
        printf("FALSE");
    return 0;
}