Type Casting in C: Implicit Conversions and Explicit Casts

C converts values between types constantly. Some of those conversions you write yourself with a cast; most of them the compiler performs silently under rules you did not choose. Knowing which is which is the difference between "why is my average always 3?" and code that does what it says.

Implicit Conversion

Whenever a value of one type meets a context expecting another, C converts it:

#include <stdio.h>

int main(void) {
    int    i = 5;
    double d = i;        /* int -> double: 5.0, exact */
    char   c = 'A';
    int    code = c;     /* char -> int: 65 */
    double pi = 3.9;
    int    truncated = pi;   /* double -> int: 3, the .9 is gone */

    printf("d         = %f\n", d);
    printf("code      = %d\n", code);
    printf("truncated = %d\n", truncated);
    return 0;
}

Conversions that cannot lose information (int to double, char to int, short to long) are widening and are always safe. Conversions in the other direction are narrowing and can lose data - the 3.9 above became 3 with no warning unless you ask for one with -Wconversion.

The Usual Arithmetic Conversions

When a binary operator has operands of different types, C converts them to a common type before doing the work. The ladder, from the bottom up:

1. Anything smaller than int (char, short, _Bool) is promoted to int. This is integer promotion and it happens first, always.
2. If either side is long double, the other becomes long double.
3. Otherwise if either is double, the other becomes double.
4. Otherwise if either is float, the other becomes float.
5. Otherwise, among integer types, the one with the higher rank wins, and if ranks tie, unsigned wins.

That last rule is the one that causes real bugs. The rest are intuitive.

#include <stdio.h>

int main(void) {
    char a = 100, b = 100;

    /* a and b are promoted to int first, so 10000 fits fine. */
    printf("a * b as int = %d\n", a * b);

    /* But storing it back in a char narrows it again. */
    char product = a * b;
    printf("stored in char = %d\n", product);
    return 0;
}

Integer promotion is why char arithmetic does not overflow the way you might expect - and why storing the result back into a char does.

Explicit Casts

A cast is the target type in parentheses:

(double)x
(int)3.9
(char)65
(unsigned int)n

It applies to the expression immediately after it, and it binds very tightly - tighter than *, /, or +.

#include <stdio.h>

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

    printf("no cast:        %f\n", (double)(total / count));  /* 3.0 */
    printf("cast first:     %f\n", (double)total / count);    /* 3.5 */
    printf("cast both:      %f\n", (double)total / (double)count);
    return 0;
}

The first line divides as integers (giving 3) and then converts 3 to 3.0 - too late. The second converts total to 3.5's worth of precision before the division, so the / operator sees a double and an int, promotes the int, and performs floating-point division.

Casting one operand is enough. The usual arithmetic conversions take care of the other.

Fixing Integer Division

This is the single most common reason to write a cast in C:

#include <stdio.h>

int main(void) {
    int scores[] = {88, 92, 75, 61, 90};
    int n = 5;
    int sum = 0;

    for (int i = 0; i < n; i++) {
        sum += scores[i];
    }

    printf("sum = %d\n", sum);
    printf("wrong average: %f\n", (double)(sum / n));    /* 81.000000 - divided as ints, THEN converted */
    printf("right average: %f\n", (double)sum / n);      /* 81.200000 */

    /* Percentages have the same trap. */
    int passed = 3;
    printf("wrong pct: %d%%\n", passed / n * 100);            /* 0 percent */
    printf("right pct: %.1f%%\n", 100.0 * passed / n);        /* 60.0 percent */
    return 0;
}

The percentage line is instructive: passed / n is 3 / 5, which is 0 as integers, and 0 * 100 is 0. Multiplying before dividing (100 * passed / n) fixes it even without a cast, because 300 / 5 is exact - but that only works when the numbers cooperate. The cast is the reliable fix.

Truncation, Not Rounding

Casting a floating-point value to an integer discards the fraction. It truncates toward zero - it does not round:

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("(int) 3.2  = %d\n", (int) 3.2);
    printf("(int) 3.9  = %d\n", (int) 3.9);    /* 3, not 4 */
    printf("(int)-3.9  = %d\n", (int)-3.9);    /* -3, not -4 */

    /* Real rounding from math.h: */
    printf("round(3.9)  = %d\n", (int)round(3.9));    /* 4  */
    printf("round(-3.9) = %d\n", (int)round(-3.9));   /* -4 */
    printf("floor(3.9)  = %d\n", (int)floor(3.9));    /* 3  */
    printf("ceil(3.2)   = %d\n", (int)ceil(3.2));     /* 4  */
    return 0;
}

If you build this on your own machine, remember math.h needs -lm at link time on Linux.

One more hazard: converting a floating-point value that is too large for the integer type is undefined behavior, not a wrap-around. (int)1e20 can produce anything. Check the range before casting when the value is not under your control.

char and int

A char in C is a small integer holding a character code. Converting between the two is everyday work:

#include <stdio.h>

int main(void) {
    char letter = 'A';
    int code = letter;

    printf("'%c' has code %d\n", letter, code);
    printf("code + 1 is '%c'\n", (char)(code + 1));   /* 'B' */

    /* Digit character to its numeric value: */
    char digit = '7';
    int value = digit - '0';
    printf("the character '%c' as a number is %d\n", digit, value);

    /* Upper to lower, using the fixed 32-position gap in ASCII: */
    for (char ch = 'A'; ch <= 'E'; ch++) {
        printf("%c -> %c\n", ch, (char)(ch + 32));
    }
    return 0;
}

digit - '0' is the standard idiom for turning a digit character into its value, and it works because the ten digit characters are guaranteed to be consecutive. For letters, prefer toupper() and tolower() from ctype.h over the + 32 arithmetic - the offset is an ASCII fact, not a C guarantee.

A related trap: functions in ctype.h such as isdigit and toupper take an int that must be either EOF or representable as an unsigned char. Passing a plain char that is negative (possible, since plain char may be signed) is undefined. Cast it: isdigit((unsigned char)c).

The Signed/Unsigned Trap

Step 5 of the conversion ladder - unsigned wins a tie - produces C's most surprising comparison:

#include <stdio.h>

int main(void) {
    int          signed_val = -1;
    unsigned int unsigned_val = 1;

    if (signed_val < unsigned_val) {
        printf("-1 is less than 1  (what you expect)\n");
    } else {
        printf("-1 is NOT less than 1  (what C actually says)\n");
    }

    printf("(unsigned)-1 = %u\n", (unsigned int)signed_val);
    return 0;
}

-1 is converted to unsigned int, which reinterprets its bit pattern as 4,294,967,295. That is larger than 1, so the comparison is false.

The same conversion makes loops run forever:

/* BUG: i is unsigned, so i >= 0 is always true. When i is 0, i-- wraps. */
for (size_t i = n - 1; i >= 0; i--) { ... }

And it makes length checks fail:

/* BUG: strlen returns size_t (unsigned). If the string is shorter
   than 5, len - 5 wraps to a huge number and the test passes. */
if (strlen(s) - 5 > 0) { ... }

Rewrite as if (strlen(s) > 5) and the subtraction never happens.

The defenses: keep counts and indices in one signedness throughout, compile with -Wsign-compare (included in -Wextra), and when you must mix, cast explicitly after establishing the value cannot be negative.

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

int main(void) {
    const char *s = "hi";
    size_t len = strlen(s);

    /* Safe: compare without subtracting. */
    if (len > 5) {
        printf("long\n");
    } else {
        printf("short: %zu characters\n", len);
    }

    /* Safe: cast to a signed type once the value is known to be small. */
    int signed_len = (int)len;
    printf("len - 5 = %d\n", signed_len - 5);
    return 0;
}

Casting Pointers

Casts also convert between pointer types, and here they carry real risk because they change how memory is interpreted, not the bytes themselves.

#include <stdio.h>

int main(void) {
    int value = 1;
    /* View the bytes of an int through a char pointer. */
    unsigned char *bytes = (unsigned char *)&value;

    printf("int 1 is stored as bytes:");
    for (size_t i = 0; i < sizeof(int); i++) {
        printf(" %02x", bytes[i]);
    }
    printf("\n");
    return 0;
}

On a little-endian machine this prints 01 00 00 00. Inspecting object representation through an unsigned char * is one of the few pointer casts the standard explicitly blesses.

Most other pointer casts are not blessed. Reading an int through a float * violates the strict aliasing rule and is undefined behavior even though it compiles; use memcpy to reinterpret bytes instead.

Two conventions worth knowing. void * converts to and from any object pointer type without a cast in C, which is why you should not cast the result of malloc:

int *arr = malloc(n * sizeof *arr);        /* correct C */
int *arr = (int *)malloc(n * sizeof *arr); /* needless; hides a missing header */

The cast is required in C++, which is why so much code has it. In C it can hide the error of forgetting <stdlib.h>.

And printf("%p", ...) expects a void *, so pointer arguments there genuinely do need a cast: printf("%p", (void *)p).

When a Cast Is the Wrong Answer

A cast silences the compiler. Sometimes the compiler was right.

long big = 5000000000L;
int  small = (int)big;    /* the cast hides real data loss */

If the value truly fits, the cast documents that you checked. If it might not, the cast has converted a warning into a silent wrong answer. Before writing one, ask whether the fix is to change a variable's type instead - double instead of int, size_t instead of int, long long instead of long. A cast is the right tool mainly when two correct types must meet for one operation, as in (double)sum / count.