Operators

Programming Language & Its Applications — Introduction to C Programming, NEC licence examination syllabus (Nepal Engineering Council).

Operators: precedence is where bugs hide

a + b * c is not (a + b) * c, and ++i is not i++. These distinctions cost marks and cause real bugs.

C has an unusually rich operator set — including some, like the comma operator and compound assignment, that other languages lack. The syntax is easy; the difficulty is precedence and associativity, which determine how an expression without parentheses is actually grouped. Most C exam numericals are precedence puzzles in disguise.

🌍 Where this lives: the bitwise operators in this topic look academic until you meet real code. Every permission system uses them — the 755 in chmod 755 is three groups of three bits, tested with &. Every image format packs RGBA into one 32-bit integer and extracts channels with >> and & 0xFF. Network code masks IP addresses with & to find the subnet. Search for "bit manipulation tricks" — checking whether a number is a power of two is one line, n & (n-1), and understanding why is genuinely delightful.

The categories

ARITHMETIC + - * / % RELATIONAL < > <= >= == != LOGICAL && || ! BITWISE & | ^ ~ << >> ASSIGNMENT = += -= *= /= %= &= |= ^= <<= >>= INCREMENT ++ -- (prefix and postfix forms) CONDITIONAL ? : (the only ternary operator) SPECIAL sizeof & * . -> , (type)

Precedence table (highest to lowest)

Level Operators Associativity ────────────────────────────────────────────────────── 1 () [] . -> ++(post) left to right 2 ++(pre) -- ! ~ + - RIGHT to left (type) * & sizeof 3 * / % left to right 4 + - left to right 5 << >> left to right 6 < <= > >= left to right 7 == != left to right 8 & left to right 9 ^ left to right 10 | left to right 11 && left to right 12 || left to right 13 ? : RIGHT to left 14 = += -= etc. RIGHT to left 15 , left to right

Two rows to memorise above all: * / % bind tighter than + −, and && binds tighter than ||. Also note that the bitwise operators sit lower than the relational ones — so a & 1 == 0 parses as a & (1 == 0), which is almost never what you meant. That single misplacement is a classic real-world bug.

Worked example 1 — precedence evaluation

Evaluate step by step: int r = 10 + 20 * 3 % 7 - 4 / 2;

Precedence: * / % first (left to right), then + − Step 1: 20 * 3 = 60 → 10 + 60 % 7 − 4/2 Step 2: 60 % 7 = 4 (60 = 8×7 + 4) → 10 + 4 − 4/2 Step 3: 4 / 2 = 2 → 10 + 4 − 2 Step 4: 10 + 4 = 14 (left to right) Step 5: 14 − 2 = 12 Answer: r = 12 Common wrong answer: treating % as lower than + gives (10+60) % 7 = 0, then wrong from there.

Worked example 2 — prefix versus postfix

increment.c

#include <stdio.h>

int main(void) {
    int i = 5, j = 5;

    printf("%d\n", i++);   /* prints 5, THEN i becomes 6 */
    printf("i is now %d\n", i);

    printf("%d\n", ++j);   /* j becomes 6 FIRST, prints 6 */
    printf("j is now %d\n", j);

    int a = 5;
    int b = a++ + ++a;    /* UNDEFINED BEHAVIOUR - avoid! */
    printf("b = %d (compiler dependent)\n", b);
    return 0;
}
Output:
5
i is now 6
6
j is now 6
b = 12 (compiler dependent)

The rule: POSTFIX i++ → use the OLD value, then increment PREFIX ++i → increment first, then use the NEW value The line b = a++ + ++a modifies 'a' twice between sequence points. The C standard calls this UNDEFINED BEHAVIOUR — the compiler may produce any answer. Never write such code, and if an exam asks for its value, say it is undefined and explain why. That is the correct answer.

Worked example 3 — bitwise operations

bitwise.c

#include <stdio.h>

int main(void) {
    unsigned char a = 12;   /* 0000 1100 */
    unsigned char b = 10;   /* 0000 1010 */

    printf("a & b  = %d\n", a & b);   /* AND  */
    printf("a | b  = %d\n", a | b);   /* OR   */
    printf("a ^ b  = %d\n", a ^ b);   /* XOR  */
    printf("~a     = %d\n", (unsigned char)~a);
    printf("a << 2 = %d\n", a << 2);  /* multiply by 4 */
    printf("a >> 2 = %d\n", a >> 2);  /* divide by 4   */
    return 0;
}
Output:
a & b  = 8      0000 1000
a | b  = 14     0000 1110
a ^ b  = 6      0000 0110
~a     = 243    1111 0011
a << 2 = 48     0011 0000  (12 x 4)
a >> 2 = 3      0000 0011  (12 / 4)

Shifting is the cheapest multiply and divide a processor has — which is why compilers turn x * 8 into x << 3 automatically.

Worked example 4 — short-circuit evaluation

shortcircuit.c

#include <stdio.h>

int side_effect(void) {
    printf("  side_effect called!\n");
    return 1;
}

int main(void) {
    int x = 0;

    /* && stops at the first FALSE */
    if (x != 0 && side_effect()) { }   /* never calls it */
    printf("after && test\n");

    /* || stops at the first TRUE */
    if (x == 0 || side_effect()) { }   /* never calls it */
    printf("after || test\n");

    /* The idiom this enables — safe division: */
    int d = 0;
    if (d != 0 && 100/d > 5)
        printf("big\n");
    else
        printf("guarded against divide-by-zero\n");
    return 0;
}
Output:
after && test
after || test
guarded against divide-by-zero

SHORT-CIRCUIT rules: A && B → if A is false, B is NEVER evaluated A || B → if A is true, B is NEVER evaluated This is guaranteed by the standard, not an optimisation. It is what makes the guard idiom safe: if (ptr != NULL && ptr->value > 0) if (d != 0 && 100/d > 5) Without short-circuiting, both would crash.

💡 Exam angle: step-by-step expression evaluation is guaranteed — show every intermediate step with the operator you applied. Memorise that * / % beat + −, and that bitwise operators are lower precedence than relational ones. For i++ vs ++i, state the old-value/new-value rule. If an expression modifies a variable twice, the answer is "undefined behaviour" — say so explicitly.

Syllabus points

Arithmetic, relational, logical, bitwise
Precedence & associativity (output prediction)

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.