Precedence and Associativity: When to Reach for Brackets

Zara is checking whether a flag byte has its lowest bit clear. She writes x & 1 == 0, which reads exactly like the sentence.

The Playground compiles it without a word. For x of 4, where the answer should be 1, it gives 0. For every other value it also gives 0.

The operators are right and the order is wrong. == grabs the operands before & gets near them.

Precedence decides who gets the operands

In 2 + 3 * 4 the number 3 sits between two operators. Only one of them can have it.

Precedence is the ranking that settles the argument. * outranks +, so 3 goes to the multiplication.

#include <stdio.h>

int main(void)
{
    printf("2 + 3 * 4   = %d\n", 2 + 3 * 4);
    printf("(2 + 3) * 4 = %d\n", (2 + 3) * 4);
    return 0;
}

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

Brackets outrank everything. They are not a hint to the compiler; they change which operator gets the operand.

So precedence is not about what runs first in time. It is about how the line is grouped before anything runs at all.

The table, fifteen rows, highest first

Here is the part of C's table that this track has taught or will teach. Look things up in it; do not learn it.

Two things in that table are worth a second look, and both are the traps of this lesson.

Rows 6 and 7 sit above rows 8 to 10. Every comparison binds tighter than every bitwise operator.

Row 5 sits below rows 3 and 4. Every shift binds looser than every ordinary sum.

Associativity: which way a row leans

Precedence settles arguments between different rows. Associativity settles them inside one row.

Rows 3 to 12 group left to right. 20 - 8 - 3 is (20 - 8) - 3, which is 9, and not 15.

Rows 2, 13 and 14 group right to left. That is why p = q = r = 7 works: the rightmost assignment happens first and its value flows left.

#include <stdio.h>

int main(void)
{
    int a = 20;
    int b = 8;
    int c = 3;

    printf("a - b - c   = %d\n", a - b - c);
    printf("a - (b - c) = %d\n", a - (b - c));

    int p = 0;
    int q = 0;
    int r = 0;
    p = q = r = 7;
    printf("p %d q %d r %d\n", p, q, r);
    return 0;
}

a - b - c   = 9
a - (b - c) = 15
p 7 q 7 r 7

Subtraction leaning the other way would break school arithmetic, so left to right is the one you already expect.

So associativity only matters when you have written two operators of the same rank in a row, which is most lines of arithmetic.

The two traps that really bite

Almost every precedence bug in real C is one of two shapes, and the table already told you both.

Trap one: a comparison beside a bitwise operator. Rows 6 and 7 are above row 8, so the comparison wins.

#include <stdio.h>

int main(void)
{
    unsigned int x = 4u;

    printf("x & 1u == 0u   %u\n", x & 1u == 0u);
    printf("(x & 1u) == 0u %u\n", (x & 1u) == 0u);
    return 0;
}

x & 1u == 0u   0
(x & 1u) == 0u 1

The first line is x & (1u == 0u), which is x & 0, which is 0 for every x there has ever been.

The Playground says nothing. A local gcc -Wall reports warning: suggest parentheses around comparison in operand of '&', which is the compiler telling you the table's answer.

Trap two: a shift beside a sum. Row 5 is below row 4, so the addition happens first.

#include <stdio.h>

int main(void)
{
    printf("1u << 2 + 1   = %u\n", 1u << 2 + 1);
    printf("(1u << 2) + 1 = %u\n", (1u << 2) + 1);
    return 0;
}

1u << 2 + 1   = 8
(1u << 2) + 1 = 5

The first is 1u << 3. The two answers are 8 and 5, and only one of them is a power of two, which is how this one is usually noticed.

So the two traps share a cause: C ranked its operators in an order that does not match how the sentences are read aloud.

Five rules, and one bracket rule

You do not need the table for everyday code. Five statements cover almost all of it.

1  unary before binary            -a * b   is   (-a) * b
2  * / % before + -               a + b * c   is   a + (b * c)
3  comparison, then &&, then ||   a < b && c < d   needs no brackets
4  assignment is last, and leans right     p = q = 7
5  brackets win, always

The track's style rule follows from that gap: bracket every bitwise operator and every shift when anything else shares the line.

Brackets cost nothing at run time. The compiler produces identical machine code, so the only reader they serve is human.

#include <stdio.h>

int main(void)
{
    int n = 0;
    scanf("%d", &n);

    printf("%d\n", 10 - 4 > n);
    printf("%d\n", 10 - (4 > n));
    return 0;
}

1
9

#include <stdio.h>

int main(void)
{
    unsigned int x = 0;
    scanf("%u", &x);

    printf("no brackets %u\n", x & 1u == 0u);
    printf("bracketed   %u\n", (x & 1u) == 0u);
    return 0;
}

no brackets 0
bracketed   1

#include <stdio.h>

int main(void)
{
    double u = 0.0;
    double t = 0.0;
    double a = 0.0;
    scanf("%lf %lf %lf", &u, &t, &a);

    double distance = u * t + 0.5 * a * t * t;

    printf("%.2f\n", distance);
    return 0;
}

80.10

unsigned int x = 4u;
printf("%u\n", x & 1u == 0u);

printf("%u\n", 1u << 2 + 1);

printf("%d\n", 1 | 2 ^ 3 & 4);

int r = f() + g() * h();

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;

    a = 1, b = 2;

    printf("a %d b %d\n", a, b);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    scanf("%d %d %d", &a, &b, &c);

    /* Type the five expressions exactly as written. Add no brackets. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    unsigned int x = 0;
    unsigned int n = 0;
    scanf("%u %u", &x, &n);

    /* Each line needs exactly one pair of brackets, around the bitwise part. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    double mass = 0.0;
    double speed = 0.0;
    double time = 0.0;
    scanf("%lf %lf %lf", &mass, &speed, &time);

    /* Rule 2 does the first line. The second needs one pair of brackets. */

    return 0;
}

Next you find out what happens when the two operands of an operator are not the same type at all.