How does C handle mixing signed and unsigned types in expressions?

In any expression that mixes signed and unsigned operands — including comparisons — the signed operand is implicitly converted to unsigned, which flips many "obvious" comparisons.

Explicit casting:

int tx, ty;
unsigned ux, uy;

// Explicit: unsigned → signed
tx = (int) ux;
// Explicit: signed → unsigned
uy = (unsigned) ty;

Implicit casting (the dangerous kind):

// Implicit conversion - same bit pattern, different interpretation
tx = ux;
// If ty is negative, becomes huge positive!
uy = ty;

The danger with comparisons:

The rule: If one operand is unsigned, the other is converted to unsigned.

Real-world bug (from earlier card):

int copy_from_kernel(void *dest, int maxlen) {
    int len = maxlen > KSIZE ? KSIZE : maxlen;
    // len=-1 becomes 4GB!
    memcpy(dest, kbuf, len);
}

Best practice: Don't mix signed and unsigned. Use -Wall -Wextra to catch warnings.

Go deeper:

• Integer overflow — Wikipedia — implicit conversions, wraparound, and overflow bugs.