C Academy · Lesson

Conversion Pitfalls

Overflow and truncation.

Conversion Pitfalls is a free C Academy lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the C Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Conversions Can Bite

Silent conversions are convenient but can cause overflow, truncation, and sign surprises. This lesson covers the traps.

#include <stdio.h>
int main(void) {
    printf("Beware silent conversions\n");
    return 0;
}

Integer Overflow

Assigning a value too large for the target integer type wraps around or loses data.

#include <stdio.h>
#include <limits.h>
int main(void) {
    int max = INT_MAX;
    printf("INT_MAX = %d\n", max);
    return 0;
}

Narrowing Truncation

Putting a large value into a smaller type keeps only the low bits, silently corrupting the number.

#include <stdio.h>
int main(void) {
    int big = 300;
    unsigned char small = (unsigned char)big;
    printf("small = %d\n", small);
    return 0;
}

Signed and Unsigned Mix

Mixing signed and unsigned converts the signed value to unsigned, turning negatives into huge positives.

#include <stdio.h>
int main(void) {
    int a = -1;
    unsigned int b = 1;
    if (a > b)
        printf("surprise: -1 > 1 as unsigned\n");
    return 0;
}

Loop Counter Trap

An unsigned loop counter that goes below zero wraps to a huge value, causing an infinite loop. Use signed counters when counting down.

#include <stdio.h>
int main(void) {
    for (int i = 3; i >= 0; i--)
        printf("%d ", i);
    printf("\n");
    return 0;
}

Float to Int Loss

Converting a float to int loses the fraction. If the value exceeds int range, the result is undefined.

#include <stdio.h>
int main(void) {
    double d = 3.99;
    int n = (int)d;
    printf("n = %d\n", n);
    return 0;
}

Precision Loss double to float

Storing a high-precision double in a float drops digits, which can accumulate in long computations.

#include <stdio.h>
int main(void) {
    double d = 1.123456789012345;
    float f = (float)d;
    printf("%.7f\n", f);
    return 0;
}

Char Sign Surprises

Whether char is signed is implementation-defined. Use unsigned char for byte values to avoid negative results.

#include <stdio.h>
int main(void) {
    unsigned char b = 200;
    printf("b = %d\n", b);
    return 0;
}

Division Then Convert

Doing integer division and then casting cannot recover the lost fraction. Cast before dividing.

#include <stdio.h>
int main(void) {
    int a = 7, b = 2;
    double wrong = (double)(a / b);
    double right = (double)a / b;
    printf("%.1f vs %.1f\n", wrong, right);
    return 0;
}

Comparing Sizes

Use limits.h constants to understand the range a type can hold before assuming a value fits.

#include <stdio.h>
#include <limits.h>
int main(void) {
    printf("char range: %d to %d\n", CHAR_MIN, CHAR_MAX);
    return 0;
}

Defensive Conversions

Check ranges before narrowing, prefer wider types when in doubt, and make casts explicit so intent is clear.

#include <stdio.h>
int main(void) {
    long value = 200;
    if (value >= 0 && value <= 255)
        printf("fits in a byte: %ld\n", value);
    return 0;
}

Quick Check

Test your understanding of conversion pitfalls.

Recap: Conversion Pitfalls

You learned the dangers of silent conversions.

Narrowing can overflow or truncate
Signed/unsigned mixing flips comparisons
Unsigned counters wrap below zero
Cast before dividing to keep fractions
Check ranges and make casts explicit

Frequently asked questions

Is the “Conversion Pitfalls” lesson free?

Yes — the full text of “Conversion Pitfalls” is free to read here on the web, and the C Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the C Academy course, upgrade to CoddyKit PRO.

What will I learn in “Conversion Pitfalls”?

Overflow and truncation. You practise C Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start C Academy?

No prior experience is required. C Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Conversion Pitfalls” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this C Academy lesson?

Yes. Every C Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to C Academy