Type Conversions & Casts

C performs type conversions constantly, often without you asking. Some conversions are safe. Others silently produce wrong results. Understanding when C converts types implicitly and when you must convert explicitly is the difference between code that works and code that appears to work until it does not.

Implicit Conversions

The compiler inserts type conversions automatically in several contexts: assignments, function arguments, arithmetic expressions, and comparisons.

Integer Promotion

Whenever a char or short appears in an expression, C promotes it to int (or unsigned int if int cannot represent all values of the original type) before performing any operation.

#include <stdio.h>

int main(void) {
    char a = 100;
    char b = 100;
    char c = a + b;    // a and b are promoted to int, added as ints,
                        // result (200) is truncated back to char

    printf("a + b as int: %d\n", a + b);     // 200
    printf("stored in char: %d\n", c);        // -56 (if char is signed, 200 overflows)

    return 0;
}

a + b as int: 200
stored in char: -56

The addition happens in int arithmetic and produces 200. But 200 does not fit in a signed char (range -128 to 127), so the assignment truncates it. This is not a compiler bug — it is the promotion rules working as designed.

Usual Arithmetic Conversions

When an operator has two operands of different types, C converts the "narrower" type to the "wider" type:

If either operand is long double, the other converts to long double
If either is double, the other converts to double
If either is float, the other converts to float
Otherwise, integer promotions apply, then:
- If both have the same signedness, the narrower converts to the wider
- If the unsigned type is at least as wide as the signed type, the signed converts to unsigned
- If the signed type can represent all values of the unsigned type, the unsigned converts to signed
- Otherwise, both convert to the unsigned version of the signed type

#include <stdio.h>

int main(void) {
    int i = 42;
    double d = 3.14;

    // int is promoted to double
    double result = i + d;     // 45.14
    printf("%f\n", result);

    // integer division: both operands are int
    printf("%d\n", 7 / 2);    // 3

    // one operand is double: int promoted to double
    printf("%f\n", 7 / 2.0);  // 3.500000

    return 0;
}

45.140000
3
3.500000

The Signed/Unsigned Comparison Trap

This is the most dangerous implicit conversion in C:

#include <stdio.h>

int main(void) {
    int a = -1;
    unsigned int b = 1;

    if (a < b) {
        printf("-1 is less than 1\n");
    } else {
        printf("-1 is NOT less than 1\n");  // this prints
    }

    printf("a as unsigned: %u\n", (unsigned int)a);

    return 0;
}

-1 is NOT less than 1
a as unsigned: 4294967295

When comparing int and unsigned int, the int is converted to unsigned int. The value -1 becomes 4294967295 (the maximum value of unsigned int), which is clearly greater than 1. The comparison produces the mathematically wrong result.

The compiler warns about this with -Wall. Read the warnings.

Truncation on Assignment

Assigning a wider type to a narrower type truncates the value:

#include <stdio.h>

int main(void) {
    int big = 100000;
    short small = big;      // truncated: 100000 does not fit in 16 bits
    printf("big: %d, small: %d\n", big, small);

    double pi = 3.14159;
    int truncated = pi;     // fractional part discarded
    printf("pi: %f, truncated: %d\n", pi, truncated);

    return 0;
}

big: 100000, small: -31072
pi: 3.141590, truncated: 3

The compiler warns about these conversions if you use -Wconversion. In production code, these warnings catch real bugs.

Explicit Casts

A cast tells the compiler "I know what I am doing, convert this type." The syntax is (target_type)expression.

Numeric Casts

#include <stdio.h>

int main(void) {
    int a = 7, b = 2;

    // Without cast: integer division
    printf("7 / 2 = %d\n", a / b);              // 3

    // With cast: floating-point division
    printf("7 / 2 = %f\n", (double)a / b);       // 3.500000

    // Explicit truncation (suppresses compiler warning)
    double pi = 3.14159;
    int whole = (int)pi;
    printf("whole part: %d\n", whole);            // 3

    return 0;
}

7 / 2 = 3
7 / 2 = 3.500000
whole part: 3

Casts are necessary when you intentionally want a conversion that the compiler would otherwise warn about. But a cast also silences the warning — so if the conversion is wrong, the cast hides the bug.

Pointer Casts & void*

void* is C's generic pointer type. Any pointer can be implicitly converted to void* and back without a cast:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int x = 42;

    // Any pointer converts to void* implicitly
    void *generic = &x;

    // void* converts back to the original type implicitly in C
    int *p = generic;   // no cast needed in C (required in C++)

    printf("*p = %d\n", *p);

    // malloc returns void*
    int *arr = malloc(10 * sizeof(int));
    if (arr == NULL) {
        return 1;
    }
    arr[0] = 100;
    printf("arr[0] = %d\n", arr[0]);
    free(arr);

    return 0;
}

*p = 42
arr[0] = 100

Do not cast the return value of malloc in C. Writing int *p = (int *)malloc(...) is unnecessary and can hide the bug of forgetting to include <stdlib.h> (which would make malloc implicitly return int in older standards).

Casting Between Pointer Types

Casting between pointer types is sometimes necessary for low-level programming, but it is dangerous:

#include <stdio.h>
#include <string.h>

int main(void) {
    int x = 0x41424344;

    // Examine individual bytes of an int
    unsigned char *bytes = (unsigned char *)&x;
    for (size_t i = 0; i < sizeof(int); i++) {
        printf("byte %zu: 0x%02x (%c)\n", i, bytes[i], bytes[i]);
    }

    // Safe type punning with memcpy
    float f;
    int bits = 0x40490FDB;   // IEEE 754 representation of pi
    memcpy(&f, &bits, sizeof(f));
    printf("pi (approx): %f\n", f);

    return 0;
}

byte 0: 0x44 (D)
byte 1: 0x43 (C)
byte 2: 0x42 (B)
byte 3: 0x41 (A)
pi (approx): 3.141593

Accessing memory through unsigned char * is always valid — this is the one exception to strict aliasing rules. For reinterpreting bytes as a different type, use memcpy instead of pointer casts to avoid undefined behavior.

When Casts Are Necessary vs When They Hide Bugs

Legitimate casts: printing pointers ((void *)p for %p), forcing floating-point division ((double)a / b), intentional truncation ((uint8_t)(value & 0xFF)), and working with generic interfaces (*(const int *)a inside a qsort comparator).

Dangerous casts:

// BAD: cast hides the real problem
void *ptr = malloc(100);
int result = (int)ptr;       // pointer truncated to int on 64-bit systems!

// BAD: cast suppresses useful warning
size_t len = strlen(s);
int length = (int)len;       // silently truncates if len > INT_MAX

// BAD: cast hides type mismatch
float values[10];
int *ip = (int *)values;     // strict aliasing violation
ip[0] = 42;                  // undefined behavior

The rule: if you need a cast, ask yourself why. If the answer is "to make the compiler stop complaining," the cast is probably hiding a bug. If the answer is "because I need to interface with a generic API" or "because I intentionally want this conversion," the cast is legitimate.

The compiler's implicit conversion warnings (-Wconversion, -Wsign-compare) are one of your best defenses. Each warning describes a real problem. The correct response is not to add a cast — it is to understand whether the conversion is correct and restructure the code so the conversion is explicit and obviously intentional.

Common Pitfalls

Signed/unsigned comparison — this is the most common source of conversion bugs. Comparing int to unsigned int converts the signed value to unsigned, producing incorrect results for negative values.
Casting malloc's return — in C, void* converts to any pointer type implicitly. Casting malloc is unnecessary and hides the error of forgetting <stdlib.h>.
Using casts to silence warnings — a cast tells the compiler "I know better." If you do not actually know better, the cast hides a bug.
Pointer type punning without memcpy — casting float* to int* and dereferencing violates strict aliasing. Use memcpy for type punning.
Assuming integer promotion preserves signedness — char and short promote to int, which is signed. If the original type was unsigned char, the promoted value is still non-negative, but the type is int.

Key Takeaways

C performs implicit conversions in expressions, assignments, and function calls. Integer promotion converts char/short to int before any arithmetic.
The signed/unsigned comparison trap is the most dangerous implicit conversion. -1 < 1U is false because -1 converts to a large unsigned value.
Truncation occurs silently when assigning wider types to narrower types. Enable -Wconversion to catch these.
void* is C's generic pointer. Do not cast malloc's return in C.
Explicit casts are necessary for generic interfaces, intentional truncation, and forcing floating-point division. They are harmful when used to silence warnings without understanding the underlying issue.
Compiler warnings about conversions are bug reports. Read them, understand them, and fix the root cause rather than casting the problem away.