C Academy · Lesson

Conversion Pitfalls

Overflow and truncation.

Lesson 4 of 413 steps

Conversion Pitfalls is a free C Academy lesson on CoddyKit. This is 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, and your progress syncs across the web and the CoddyKit app. The C Academy course includes 4 lessons in total.

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.

Answer it in the interactive lesson

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

Free to start

Learn C with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 39
Lessons: 144

Start learning free View the full course

Frequently Asked Questions

Is the “Conversion Pitfalls” lesson free?

Yes — the full text of “Conversion Pitfalls” is free to read here on the web. 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. The C Academy course includes 4 lessons in total.

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, so you can start here or from the beginning and move at your own pace. This is lesson 4 of 4.

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