What Are Operators and How Do I Use Them in Expressions?

After this lesson, you will be able to:

• Identify the bug in if (x = 5) versus if (x == 5)
• Use arithmetic, comparison, and logical operators in C expressions
• Explain C’s truthiness rule: zero is false, any non-zero value is true
• Trace bitwise operations (&, |, ^, ~, <<, >>) on binary representations
• Distinguish between bitwise (&, |) and logical (&&, ||) operators
• Use sizeof to determine the byte size of a data type or variable

The = vs == Trap

Pop quiz. What does this C code do?

int x = 5;
if (x = 3)
{
    printf("True!\n");
}

If you said “checks if x equals 3” — you just fell into C’s most famous trap. That’s assignment (=), not comparison (==). It sets x to 3, evaluates to 3 (non-zero = true), and always prints “True!”

In Java, this would be a compile error. In C, it compiles silently. Welcome to operators in C.

Every Operator You Need

Arithmetic (Familiar from Java)

int a = 17, b = 5;
printf("%d\n", a + b);     // 22
printf("%d\n", a - b);     // 12
printf("%d\n", a * b);     // 85
printf("%d\n", a / b);     // 3  (integer division!)
printf("%d\n", a % b);     // 2  (remainder/modulo)

Increment and decrement:

int count = 5;
count++;         // count is now 6
count--;         // count is now 5 again

Assignment shortcuts:

x += 5;          // x = x + 5
x -= 3;          // x = x - 3
x *= 2;          // x = x * 2
x /= 4;          // x = x / 4
x %= 3;          // x = x % 3

These all work the same as Java.

Comparison Operators

x == y           // Equal to
x != y           // Not equal to
x < y            // Less than
x > y            // Greater than
x <= y           // Less than or equal
x >= y           // Greater than or equal

Common Pitfall: = is assignment, == is comparison. if (x = 5) assigns 5 to x and is always true. if (x == 5) checks if x equals 5. Always compile with -Wall — gcc warns about assignment inside conditions.

Logical Operators

x && y           // AND — true if both true
x || y           // OR — true if either true
!x               // NOT — true if x is false

Key Insight: In C, truth is numeric: zero is false, any non-zero value is true. There’s no separate boolean type in C89 — conditions are just integer expressions. if (x) means “if x is not zero.” if (!x) means “if x is zero.”

This means unusual expressions are valid:

int count = 42;
if (count)              // True! (42 is non-zero)
{
    printf("count has a value\n");
}

Bitwise Operators

These operate on individual bits — new territory for most Java programmers:

Let’s trace 5 & 3:

  5 = 0101
& 3 = 0011
  --------
  1 = 0001

Key Insight: This is exactly how Unix file permissions work internally. The 9 permission bits (rwxrwxrwx) are stored as a bitmask. chmod 755 sets bits 111 101 101. When the OS checks “can group execute?”, it ANDs the permission mask with the group-execute bit.

Common Pitfall: Don’t confuse bitwise operators with logical operators! & (bitwise AND) is very different from && (logical AND). 5 & 3 is 1. 5 && 3 is 1 (true). They happen to give the same result here, but 2 & 4 is 0 while 2 && 4 is 1.

Octal 7 = binary 111 = rwx    (read + write + execute)
Octal 5 = binary 101 = r-x    (read + execute, no write)
Octal 5 = binary 101 = r-x

So 755 = 111 101 101 in binary

mode_t permissions = 0755;     // File permissions (octal literal)
mode_t group_write  = 0020;    // Group write bit mask

if (permissions & group_write)  // 0755 & 0020 = 0?
{
    // Group can write
}
else
{
    // Group cannot write (this branch runs for 755)
}

  0755 = 111 101 101
& 0020 = 000 010 000
  ─────────────────
  0000 = 000 000 000  → zero → false → no group write

permissions |= 0020;    // Grant group write (set the bit)
permissions &= ~0020;   // Revoke group write (clear the bit)

The sizeof Operator

sizeof tells you how many bytes a type or variable uses:

printf("int: %zu bytes\n", sizeof(int));          // 4
printf("double: %zu bytes\n", sizeof(double));     // 8
printf("char: %zu bytes\n", sizeof(char));         // 1

The Trick: You’ll use sizeof constantly with calloc for dynamic memory allocation: int *arr = calloc(n, sizeof(int));. It ensures you allocate the right number of bytes regardless of the platform.

Type Casting

Explicit conversion between types:

int total = 7;
int count = 2;
double average = (double)total / count;   // 3.5, not 3

Implicit conversions happen automatically when mixing types:

int x = 5;
double y = x;       // Implicit: int → double (safe, no data loss)
int z = 3.14;       // Implicit: double → int (truncates! z = 3)

The Trick: When computing an average, cast the numerator: (double)sum / count. Casting either operand promotes the entire expression to floating-point division.

Operator Precedence

When in doubt, use parentheses. But here’s the short version:

Watch out: Bitwise operators have lower precedence than comparison operators. a & b == c parses as a & (b == c), which is almost never what you want. Always use parentheses: (a & b) == c. This is one of C’s most notorious precedence traps.

Operators Are Your Vocabulary

Every C expression is built from operators. The ones that trip up Java programmers most: = vs ==, bitwise vs logical, and integer division. Now that you know the traps, you can avoid them.

Next: decisions. You’ll use these operators inside if, else if, and switch statements to make your programs branch. And you’ll meet C’s version of the dangling else problem.

Big Picture: Bitwise operators aren’t just academic. They show up in systems programming (file permissions, network protocols, hardware registers), embedded systems (controlling device pins), and performance optimization (fast multiplication by powers of 2 using shifts). You’ll use them in Week 10 when working with system calls.