Operators in C: Arithmetic, Logical, and Precedence

Operators are the verbs of C: they take values and produce new ones. There are around 40 of them, but a dozen cover most code, and two of those have traps sharp enough to be worth their own sections.

Arithmetic Operators

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3  - integer division! */
    printf("a %% b  = %d\n", a % b);  /* 2  - the remainder */
    printf("-a     = %d\n", -a);      /* unary minus */
    return 0;
}

(%% in the format string prints a literal percent sign - % alone would start a format specifier.)

The five binary arithmetic operators are + - * / %, plus unary - for negation and + which does essentially nothing.

The Integer Division Trap

a / b with two integers performs integer division and throws away the remainder. There is no rounding - the result is truncated toward zero.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* division happens FIRST, as ints */
    printf("wrong average = %f\n", wrong);   /* 3.000000 */
    return 0;
}

That last case is the bug that survives into production. Assigning to a double does not help: the division total / count is already complete, and already an int, before the assignment happens. The fix is to make one operand floating-point inside the expression, usually with a cast.

Two related rules: dividing by zero with integers is undefined behavior and typically crashes the program, and INT_MIN / -1 overflows.

The Modulus Operator

% gives the remainder and works only on integers:

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d is even\n", i);
        } else {
            printf("%d is odd\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d seconds = %dh %dm %ds\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

Testing x % 2 == 0 for evenness and using % n to wrap an index around an array are the two everyday uses.

With negative numbers, C's % follows the sign of the dividend:

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, not 2 */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

So x % 2 == 1 is a broken test for oddness when x can be negative - -7 % 2 is -1. Use x % 2 != 0 instead.

For floating-point remainders, % is a compile error; use fmod() from math.h.

Assignment and Compound Assignment

= stores a value. The compound forms combine an operation with the store:

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

x += 5 means x = x + 5, but it evaluates x only once - which matters when the target is something like arr[compute_index()].

Assignment is itself an expression that yields the assigned value, which is why a = b = c = 0 works (it assigns right to left) and why the = versus == mistake compiles silently.

Increment and Decrement

++ adds one, -- subtracts one. Each comes in a prefix and a postfix form:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a gets 5 (the old value), then i becomes 6 */
    printf("postfix: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* j becomes 6 first, then b gets 6 */
    printf("prefix:  b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* as a statement on its own, identical to ++k */
    printf("statement: k = %d\n", k);
    return 0;
}

As a standalone statement the two are interchangeable, and i++ is the conventional choice in a for header for no deeper reason than tradition.

What you must not do is use a variable more than once in an expression where it is also modified:

int i = 5;
int x = i++ + i++;      /* undefined behavior */
arr[i] = i++;           /* undefined behavior */
printf("%d %d", i++, i);/* undefined behavior */

C does not define the order in which those subexpressions are evaluated, so the result is not merely unspecified - the whole program's behavior is undefined. Split the statement in two and the ambiguity disappears.

Comparison Operators

Six of them, and all of them produce an int: 1 for true and 0 for false.

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

The result being a plain int rather than a dedicated boolean type is a defining feature of C - see booleans in C for what follows from it, including the = versus == bug.

Two comparison mistakes are specific to C. Chaining does not work the way mathematics suggests: if (1 < x < 10) is always true, because 1 < x evaluates to 0 or 1 and then that is compared with 10. Write if (x > 1 && x < 10). And comparing strings with == compares pointers, not text - use strcmp from string.h.

Logical Operators

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("May drive\n");
    }

    if (age < 13 || age > 65) {
        printf("Discounted ticket\n");
    } else {
        printf("Full price\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&& is AND, || is OR, ! is NOT. All three treat any non-zero value as true.

They short-circuit: && stops as soon as one operand is false, and || stops as soon as one is true. The rest is never evaluated, which is not just an optimization - it is a guarantee you can rely on for safety:

#include <stdio.h>

int is_safe(int *p) {
    /* If p is NULL, *p is never evaluated - the && stops first. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("with a real pointer: %d\n", is_safe(&value));
    printf("with NULL:           %d\n", is_safe(NULL));
    return 0;
}

Swap the order of those two tests and the NULL call dereferences a null pointer and crashes. Guard first, then use - the order in a && chain is part of the logic.

The Conditional Operator

C's only three-operand operator picks between two values:

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

    int max = (a > b) ? a : b;
    printf("max = %d\n", max);

    printf("%d item%s\n", a, (a == 1) ? "" : "s");
    return 0;
}

condition ? value_if_true : value_if_false. It is an expression, so it fits where an if statement cannot - inside a printf argument, in an initializer. Keep it short; nested conditionals become unreadable quickly.

Bitwise Operators, Briefly

These work on the individual bits of an integer:

#include <stdio.h>

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

    printf("a & b  = %u\n", a & b);    /* 8  - 1000, AND */
    printf("a | b  = %u\n", a | b);    /* 14 - 1110, OR  */
    printf("a ^ b  = %u\n", a ^ b);    /* 6  - 0110, XOR */
    printf("~a     = %u\n", ~a);       /* NOT - flips every bit */
    printf("a << 2 = %u\n", a << 2);   /* 48 - shift up, multiplies by 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3  - shift down, divides by 4 */
    return 0;
}

They are used for flags, masks, and hardware registers. Two cautions: & and | are not && and || (they do not short-circuit and they operate bit by bit), and shifting a signed value or shifting by more than the type's width is undefined. Use unsigned types for bit work.

Precedence

When an expression has no parentheses, this table decides what binds to what. Highest precedence first:

The practical consequences:

a + b * c       /* means a + (b * c) */
a < b == c < d  /* means (a < b) == (c < d) - rarely what you meant */
x & 1 == 0      /* means x & (1 == 0), i.e. x & 0 - a classic bug */
*p++            /* means *(p++) - dereference p, then advance it */

That third line is worth memorizing: == binds tighter than &, so bitmask tests need parentheses - (x & 1) == 0.

Nobody remembers all fifteen levels, and nobody needs to. Learn that * beats +, that comparisons beat && beats ||, and that everything else gets parentheses:

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

That line has redundant parentheses and is better for them.