C Operators Guide: Complete Operator Categories With Examples

Category 2: Relational Operators — The Comparers

These compare two values and answer with C's boolean logic:1 (true) or 0 (false):

int marks = 72;
printf("%d\n", marks >= 40);
// 1 — true, printed as a number

⚠️The eternal trap:=assigns,==compares.if (x = 5)setsx to 5 and is always true.if (x == 5)actually checks. One character, endless debugging sessions.

Category 3: Logical Operators — The Combiners

When one condition isn't enough, logical operators combine them:

int age = 20;
int hasID = 1;
if (age >= 18 && hasID) {
    printf("Entry allowed\n");
    // both true — runs
}
if (age < 13 || age > 60) {
    printf("Discount ticket\n");
    // either true — would run
}
if (!(age >= 18)) {
    printf("Minor\n");
    // NOT flips the result
}

The pro detail — short-circuit evaluation:C stops early when the answer is decided. InA && B, ifAis false,Bnever runs (the result is already false). InA || B, ifAis true,Bnever runs. This isn't just speed — programmers deliberately place safety checks first:if (ptr != NULL && ptr->value > 0)worksbecausethe second half never executes when the pointer is null.

Category 4: Bitwise Operators — The Bit Surgeons

C's specialty — operators that manipulateindividual bitsof data. This is where C touches the metal:

int a = 5;
// binary: 0101
int b = 3;
// binary: 0011
printf("%d\n", a & b);
// 1  (0001 — only last bit matches)
printf("%d\n", a | b);
// 7  (0111)
printf("%d\n", a ^ b);
// 6  (0110 — different bits)
printf("%d\n", a << 1);
// 10 (1010 — doubled!)

That last one is a gem:left-shifting by 1 doubles a number, and right-shifting halves it. Bitwise operators are the backbone of embedded systems, device drivers, and anywhere hardware registers need poking.

⚠️ Don't confuse&(bitwise AND) with&&(logical AND) —5 & 3is1, but5 && 3is also1... while4 & 2is0but4 && 2is1. Different operators, different worlds.

Category 5: Assignment Operators — The Updaters

Beyond plain=, C offerscompound assignmentsthat combine operation and assignment:

int score = 100;
score += 50;
// 150
score *= 2;
// 300
score %= 7;
// 6

Shorter to write, and once fluent, faster to read. Real C code uses these constantly.

Category 6: Unary Operators — The Solo Acts

Operators that work on asingle operand— including the two most famous symbols in C:

Increment and Decrement (++ and --)

int i = 5;
i++;
// 6 — add one
i--;
// 5 — subtract one

But there's a twist —pre vs postposition:

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

This tiny difference powers a thousand interview questions.

The Other Unary Stars

int x = -10;
int positive = -x;
// unary minus: 10
int size = sizeof(int);
// sizeof: 4 (bytes)
int flag = !0;
// logical NOT: 1
int *ptr = &x;
// address-of: where x lives
int value = *ptr;
// dereference: the value there

That last pair —&(address-of) and*(dereference) — are the gateway to pointers, C's most powerful feature.

The Special One: The Ternary Operator (?:)

C's only three-operand operator compresses an entire if-else into one expression:

// the long way
if (marks >= 40) {
    result = 'P';
} else {
    result = 'F';
}
// the ternary way — one line
char result =(marks >= 40) ? 'P' : 'F';
//           condition      ? if-true : if-false

Perfect for small decisions:max = (a > b) ? a : b;. Resist nesting them, though — stacked ternaries become unreadable riddles.

When Operators Collide: A Word on Precedence

What does2 + 3 * 4give? Not 20 — multiplication strikes first, giving14. Every operator has aprecedencerank, and when operators compete, higher rank wins:

int r1 = 2 + 3 * 4;
// 14 — * beats +
int r2 =(2 + 3) * 4;
// 20 — parentheses override everything
int r3 = 10 > 5 && 3 < 8;
// 1  — comparisons beat &&, && beats nothing here

The professional habit:when in doubt, parenthesize.(a + b) * cis never wrong, never ambiguous, and never needs a precedence table to read.

The Complete Quick-Reference Table