Operators in C

Operators in C are not just convenience syntax — they map almost directly to single CPU instructions. That's why C feels "fast": when you write a + b, the compiler often emits exactly one add instruction.

Operator Precedence — Who Goes First?

Just like math, C has rules about which operator runs first.

int x = 2 + 3 * 4;   // 14, NOT 20 — * binds tighter than +

Selected precedence (high → low):

> Don't memorise this table. When in doubt, use parentheses. Clear code beats clever code.

Integer vs Floating-Point Division

printf("%d\n", 7 / 2);          // 3
printf("%f\n", 7.0 / 2);        // 3.500000
printf("%f\n", (double)7 / 2);  // 3.500000

If either operand is floating-point, C promotes the whole expression to floating-point. If both are int, you get integer division.

Modulo (%)

The remainder operator. Used constantly in real code:

n % 2 == 0          // is n even?
n % 10              // last digit of n
i = (i + 1) % size; // circular increment (wrap around)

> % only works on integer types. 5.5 % 2 is a compile error. Use fmod() from for floats.

Pre vs Post Increment — The Real Difference

int i = 5;
int a = i++;   // a = 5, then i becomes 6   (post: use, then change)
int b = ++i;   // i becomes 7, then b = 7   (pre:  change, then use)

In a simple statement like i++; alone, there's no difference. The difference only matters when the value is being read in the same expression.

> Modern advice: prefer ++i in loops; it's marginally faster on objects (matters in C++) and never wrong in C.

The = vs == Trap

int x = 5;
if (x = 10) {     // ❌ assigns 10 to x, condition is "10" (true)
    // always runs!
}
if (x == 10) {    // ✅ comparison
    // runs only if x equals 10
}

Defensive trick — put the constant on the left:

if (10 == x)   // typo "10 = x" is a compile error → safer

Modern compilers warn about if (x = 10) if you enable -Wall.

Short-Circuit Evaluation

&& and || are lazy — they stop as soon as the answer is known.

if (p != NULL && *p == 5) { ... }   // *p only evaluated if p is not NULL — safe!
if (denominator != 0 && (numerator / denominator) > 0) { ... }

This is one of the most useful patterns in all of C — it lets you guard dangerous operations.

The Ternary Operator ?:

int max = (a > b) ? a : b;
//        condition  ↑    ↑
//                  if-true if-false

Equivalent to:

int max;
if (a > b) max = a;
else       max = b;

Use ternary for simple value-choice. Don't nest more than one level — it gets unreadable fast.

Operator Pitfalls Summary

Master operators and precedence and you've absorbed about 30 % of the entire C language.