C Operators — How Integer Division Cost a Bank

Every useful program on the planet — from a banking app calculating your balance to a game engine deciding if a bullet hit a target — makes decisions and performs calculations. None of that is possible without operators. They are the verbs of your code. If variables are the nouns, operators are the actions performed on those things. Understanding them deeply is not optional — it is the foundation everything else is built on.

Before operators existed in programming languages, writing even simple math required multiple low-level machine instructions. C gave programmers a concise, expressive set of symbols that map closely to what the hardware actually does — which is why C is still used in embedded systems, operating systems, and performance-critical software today. Operators solve the problem of expressing computation, comparison, and logic in a way that is both human-readable and highly efficient.

By the end of this article you will know every major category of C operator, understand exactly what each one does and why it exists, be able to read real C code without getting tripped up by symbols like >>= or !=, know the silent rules around integer division, negative modulus, and undefined behaviour with increment operators, and you will know the most common operator mistakes beginners make — so you can avoid them from day one.

Arithmetic Operators — Your Program's Built-In Calculator

Arithmetic operators do exactly what the name suggests: math. C gives you six of them — addition (+), subtraction (-), multiplication (*), division (/), modulus (%), and unary negation (-). You already know the first four from school. The ones that surprise beginners are modulus and integer division.

Modulus (%) gives you the remainder after integer division. So 10 % 3 gives you 1, because 10 divided by 3 is 3 with 1 left over. This is useful in real code for checking if a number is even or odd, wrapping a value around a range (keeping a game character on screen, cycling through a circular buffer), or extracting digits from a number. However, there is a rule that catches people: in C99 and later, the sign of the modulus result follows the sign of the dividend, not the divisor. So -7 % 3 gives -1, not 2. If you need a guaranteed non-negative remainder, use the safe idiom: ((n % m) + m) % m.

The bigger trap is integer division. When you divide two integers in C, you get integer division — the decimal part is thrown away, not rounded, just discarded silently. 7 / 2 gives 3. There is no warning, no error, no indication that anything was lost. If you need the decimal result, at least one of the operands must be a float or double before the division happens — casting after the fact is too late, the truncation has already occurred.

#include <stdio.h>

// io.thecodeforge — arithmetic operators demonstration

int main() {
    int apples = 17;
    int children = 5;

    // Basic arithmetic
    int total_after_buying_more = apples + 8;   // addition
    int eaten                   = apples - 3;   // subtraction
    int doubled                 = apples * 2;   // multiplication

    // Integer division: the decimal part is SILENTLY dropped, never rounded
    int each_child_gets = apples / children;    // 17 / 5 = 3 (not 3.4)

    // Modulus: gives the leftover after integer division
    int leftover_apples = apples % children;    // 17 % 5 = 2

    printf("Apples after buying more : %d\n", total_after_buying_more);
    printf("Apples after eating 3    : %d\n", eaten);
    printf("Apples if doubled        : %d\n", doubled);
    printf("Each child gets          : %d apples (decimal lost!)\n", each_child_gets);
    printf("Leftover apples          : %d\n", leftover_apples);

    // To preserve the decimal, cast BEFORE division — not after
    double precise_share = (double)apples / children;
    printf("Precise share per child  : %.2f apples\n", precise_share);

    // Even/odd check with modulus
    int mystery_number = 42;
    printf("%d is %s\n", mystery_number,
           (mystery_number % 2 == 0) ? "even" : "odd");

    // Negative modulus — sign follows the DIVIDEND in C99/C11
    int neg_result = -7 % 3;   // gives -1, not 2
    printf("-7 %% 3 = %d  (sign follows dividend in C99)\n", neg_result);

    // Safe non-negative remainder for wrapping (e.g. circular buffer index)
    int m = 3;
    int safe = ((-7 % m) + m) % m;
    printf("Safe non-negative remainder of -7 mod 3 = %d\n", safe);

    return 0;
}

Relational and Logical Operators — Teaching Your Program to Make Decisions

Arithmetic operators crunch numbers. Relational operators compare them and return either 1 (true) or 0 (false). They are the basis of every if-statement, every loop condition, every decision your program makes. C has six: == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than or equal to), and <= (less than or equal to).

Logical operators let you combine those comparisons. Think of them as the words 'and', 'or', and 'not' in English. In C: && means AND (both conditions must be true), || means OR (at least one must be true), and ! means NOT (flips true to false or false to true).

Here is a real-world framing: you are building access control for a theme park ride. The rule is: the rider must be at least 120 cm tall AND no taller than 200 cm AND either be 18 or over OR have a parent present. That is three conditions, two operators, and the kind of compound logic that appears in virtually every non-trivial program ever written.

Short-circuit evaluation is the behaviour you must understand: with &&, if the left side is false, C skips the right side entirely — it cannot change the result. With ||, if the left side is true, the right side is skipped. This matters enormously when the right side has side effects (function calls, pointer dereferences, increments). The idiom if (ptr != NULL && *ptr == 'A') is safe precisely because of short-circuit evaluation — the dereference only happens when the pointer is non-null. Flip the order and you have a crash waiting to happen.

#include <stdio.h>

// io.thecodeforge — relational and logical operators demonstration

int main() {
    int height_cm          = 145;
    int age                = 12;
    int has_parent_with_them = 1;  // 1 = true, 0 = false in C

    // --- Relational Operators: each returns 1 or 0 ---
    printf("height_cm > 120 : %d\n", height_cm > 120);  // 1
    printf("height_cm > 200 : %d\n", height_cm > 200);  // 0
    printf("height_cm != 200: %d\n", height_cm != 200); // 1
    printf("height_cm == 145: %d\n", height_cm == 145); // 1

    // --- Logical AND (&&): both sides must be true ---
    // Short-circuits: if left is false, right is never evaluated
    int allowed_on_ride = (height_cm >= 120) && (height_cm <= 200);
    printf("\nAllowed on ride (height in range): %d\n", allowed_on_ride);

    // --- Logical OR (||): at least one side must be true ---
    // Short-circuits: if left is true, right is never evaluated
    int can_enter_park = (age >= 18) || (has_parent_with_them == 1);
    printf("Can enter park (adult OR has parent): %d\n", can_enter_park);

    // --- Logical NOT (!): flips true to false and vice versa ---
    int is_minor = !(age >= 18);
    printf("Is a minor: %d\n", is_minor);

    // --- Short-circuit safety: pointer check before dereference ---
    // The dereference only happens when ptr is non-NULL.
    // This is safe and idiomatic C — rely on short-circuit here.
    const char *ptr = "Hello";
    if (ptr != NULL && *ptr == 'H') {
        printf("First character is H\n");
    }

    // --- Combined condition ---
    if (allowed_on_ride && can_enter_park) {
        printf("\nWelcome! Enjoy the ride!\n");
    } else {
        printf("\nSorry, you cannot go on this ride.\n");
    }

    return 0;
}

Assignment and Compound Assignment Operators — Writing Less, Doing More

The single equals sign (=) in C is the assignment operator. It takes the value on the right and stores it in the variable on the left. It does not check equality — that is ==. A useful mental habit: read = as 'gets the value of', not 'equals'. It prevents the = versus == confusion at the thinking stage, before your fingers reach the keyboard.

C also gives you compound assignment operators, which combine an arithmetic operation with assignment into one step. Instead of writing score = score + 10, you write score += 10. They are shorthand — nothing more. But they appear everywhere in real C code and reading them fluently matters.

The full set is: += (add and assign), -= (subtract and assign), *= (multiply and assign), /= (divide and assign), and %= (modulo and assign). There are also bitwise compound assignments: &=, |=, ^=, <<=, >>= — you will see these in embedded and systems code for manipulating hardware registers.

Then there is the increment (++) and decrement (--) operator pair. These add or subtract exactly 1. They exist in two forms: prefix (++counter) and postfix (counter++). The difference only matters when the result is used inside a larger expression. Prefix increments first and returns the new value. Postfix returns the current value and then increments. In a simple for loop where the result is discarded, the two are identical. When used inside a larger expression, the difference is concrete — and modifying the same variable twice in the same expression crosses into undefined behaviour territory, which means the compiler can do whatever it likes and still be technically correct.

#include <stdio.h>

// io.thecodeforge — assignment and increment operators demonstration

int main() {
    int player_score = 100;

    // Compound assignment: read as 'score gets score plus 50'
    player_score += 50;    // equivalent to: player_score = player_score + 50
    player_score *= 2;     // equivalent to: player_score = player_score * 2
    printf("Score after += 50 then *= 2: %d\n", player_score); // 300

    // --- Prefix vs Postfix: ONLY matters when the result is used ---
    int counter = 5;

    // Postfix: 'a gets the current value, THEN counter increments'
    int a = counter++;   // a = 5, counter becomes 6
    printf("After postfix (counter++): a=%d, counter=%d\n", a, counter);

    // Prefix: 'counter increments FIRST, THEN b gets the new value'
    int b = ++counter;   // counter becomes 7, b = 7
    printf("After prefix  (++counter): b=%d, counter=%d\n", b, counter);

    // In a for loop, prefix and postfix are IDENTICAL — result is discarded
    printf("For loop (postfix and prefix behave the same here):\n");
    for (int i = 0; i < 3; i++) {
        printf("  i = %d\n", i);
    }

    // --- DANGER: modifying a variable twice in one expression ---
    // arr[i++] + arr[i++] is UNDEFINED BEHAVIOUR in C.
    // The compiler is free to evaluate operands in any order.
    // Do NOT do this. Separate onto individual lines:
    int arr[] = {10, 20, 30, 40};
    int idx = 0;
    int val = arr[idx];  // use current index
    idx++;               // then increment — unambiguous, always correct
    printf("Safe indexed access: arr[0] = %d, next index = %d\n", val, idx);

    return 0;
}

Bitwise Operators — Working Directly With the Zeros and Ones

Every value in your computer is stored as binary — a sequence of 0s and 1s called bits. Bitwise operators let you manipulate those individual bits directly. This sounds advanced, but it is used everywhere: setting hardware flags in embedded systems, optimising memory in tight loops, building permission systems (the read/write/execute flags in Linux file permissions are a textbook example), and implementing fast operations in graphics and networking code.

C has six bitwise operators: & (AND), | (OR), ^ (XOR), ~ (NOT/complement), << (left shift), and >> (right shift).

AND (&) returns 1 for each bit position where both operands have a 1. It is the masking operator — use it to check whether a specific bit is set. OR (|) returns 1 where either operand has a 1 — use it to set a bit. XOR (^) returns 1 where the bits differ and 0 where they match — which is why XORing a value with 1 always flips that bit. This makes XOR the toggle operator: apply it twice to the same value with the same mask and you get back exactly where you started.

NOT (~) inverts every bit. Left shift (<<) shifts all bits toward higher significance — shifting left by 1 is equivalent to multiplying by 2, shifting left by n is multiplying by 2^n. Right shift (>>) moves bits toward lower significance — for unsigned integers this divides by 2^n. For signed negative integers, right shift behaviour is implementation-defined: some platforms fill the vacated bits with the sign bit (arithmetic shift), others fill with zeros (logical shift). This is why the rule exists: always use unsigned int or a fixed-width type from stdint.h for bitwise operations.

#include <stdio.h>
#include <stdint.h>

// io.thecodeforge — bitwise operators: flags, masking, toggling, shifting

int main() {
    // Permission flags — each is a single bit in a bitmask
    // Using 1u (unsigned literal) to avoid signed-type warnings
    uint8_t READ    = 1u << 2;  // 0000 0100  (decimal 4)
    uint8_t WRITE   = 1u << 1;  // 0000 0010  (decimal 2)
    uint8_t EXECUTE = 1u << 0;  // 0000 0001  (decimal 1)

    // Set READ and WRITE using OR (|)
    uint8_t user_perms = READ | WRITE;  // 0000 0110  (decimal 6)
    printf("Initial permissions : %u (binary: READ|WRITE)\n", user_perms);

    // Check if a bit is set using AND (&)
    // If the bit is present, (perms & FLAG) is non-zero (truthy)
    if (user_perms & READ) {
        printf("Access granted      : Read enabled\n");
    }
    if (!(user_perms & EXECUTE)) {
        printf("Access denied       : Execute not set\n");
    }

    // Toggle a bit using XOR (^)
    // XOR with 1 flips the bit; apply twice to restore original value
    user_perms ^= WRITE;   // clears WRITE bit
    printf("After toggle WRITE  : %u (WRITE cleared)\n", user_perms);
    user_perms ^= WRITE;   // sets WRITE bit again
    printf("After toggle again  : %u (WRITE restored)\n", user_perms);

    // Clear a bit using AND with NOT (~)
    user_perms &= ~WRITE;  // forces the WRITE bit to 0
    printf("After clear WRITE   : %u\n", user_perms);

    // Left shift: multiply by powers of 2 (fast, single CPU instruction)
    unsigned int x = 3;
    printf("\n3 << 1 = %u  (3 * 2 = 6)\n",  x << 1);
    printf("3 << 2 = %u  (3 * 4 = 12)\n", x << 2);

    // Right shift: divide by powers of 2 (safe only on unsigned)
    unsigned int y = 16;
    printf("16 >> 1 = %u  (16 / 2 = 8)\n",  y >> 1);
    printf("16 >> 2 = %u  (16 / 4 = 4)\n",  y >> 2);

    // XOR swap — classic interview trick
    // Works because a ^ a = 0 and a ^ 0 = a
    // The if guard is required: XORing a value with itself gives 0
    unsigned int p = 7, q = 13;
    printf("\nBefore XOR swap: p=%u, q=%u\n", p, q);
    if (&p != &q) { p ^= q; q ^= p; p ^= q; }
    printf("After  XOR swap: p=%u, q=%u\n", p, q);

    return 0;
}

Ternary Operator and Comma Operator — Compact but Dangerous

C offers two lesser-known operators that can make code either elegantly compact or genuinely hard to read. Knowing both is important — you will encounter them in production codebases and interviews, and misreading either one leads to real bugs.

The ternary operator (?:) is a shorthand if-else that returns a value. Syntax: condition ? value_if_true : value_if_false. It returns a value, so you can use it inside assignments, function arguments, or anywhere an expression is expected. It is best used for simple, clear conditional assignments. Chaining ternaries — condition_a ? a : condition_b ? b : c — is technically legal but a code smell that harms readability without saving meaningful lines. If you find yourself nesting them, use an if-else chain instead.

The comma operator (,) evaluates its left operand, discards the result, then evaluates its right operand and returns that. It has the lowest precedence of any C operator, which means assignment binds tighter: y = 1, 2, 3 is parsed as (y = 1), 2, 3 — y gets 1, and 2 and 3 are evaluated and discarded. The comma is most legitimately used in for-loop headers to initialise or update multiple variables in lockstep. Its use elsewhere is mostly a maintenance hazard — it appears in macros and obfuscated code, and the precedence surprise catches people who are not expecting it.

#include <stdio.h>

// io.thecodeforge — ternary and comma operator demonstration

int main() {
    int temperature = 30;

    // Ternary: condition ? value_if_true : value_if_false
    // Returns a value — usable anywhere an expression is valid
    const char *weather = (temperature > 25) ? "Hot" : "Cold";
    printf("Weather: %s\n", weather);

    // Ternary inside printf — concise and readable when simple
    int score = 72;
    printf("Grade: %s\n", (score >= 90) ? "A" :
                           (score >= 75) ? "B" :
                           (score >= 60) ? "C" : "F");
    // Note: the above chaining is borderline — if it grows one more level,
    // switch to if-else. Readability wins over compactness.

    // Comma operator: evaluates left, discards it, returns right
    // Parentheses are required to force comma-operator semantics here
    int x = (1, 2, 3);  // x = 3 (rightmost value)
    printf("x = %d  (comma operator returns rightmost)\n", x);

    // Precedence trap: assignment binds TIGHTER than comma
    // This is: (y = 1), then 2 is evaluated and discarded, then 3 is discarded
    // y ends up as 1, NOT 3
    int y;
    y = 1, 2, 3;  // valid C: (y = 1), 2, 3
    printf("y = %d  (assignment beat comma; y got 1, not 3)\n", y);

    // Comma in for-loop: the legitimate and idiomatic use
    printf("Converging loop (i goes up, j goes down):\n");
    for (int i = 0, j = 4; i <= j; i++, j--) {
        printf("  i=%d, j=%d\n", i, j);
    }

    return 0;
}