Today, we will discuss a very important topic—Type Conversion

Many tutorials may delve into this topic when discussing floating-point numbers or object-oriented programming, but I insist on addressing it earlier. Because in C language, if you do not understand the range and calculation principles of various integer types discussed in the previous lessons, you cannot truly grasp the essence of type conversion, nor can you understand why a seemingly simple assignment statement can sometimes become the hardest bug to find in your program.

In simple terms, type conversion is the process of assigning a value of one data type to a variable of another data type. Sounds simple? Let’s look at a real-life example.

01

Implicit Conversion: Small Shopping Cart Easily Transferred to a Large Cart

Imagine you are shopping at a supermarket, pushing shopping carts of different sizes.

• int16_t is like a small shopping cart, with a maximum capacity of 32767.

• int32_t is a large shopping cart, with a capacity of over 2.1 billion.

Now, there is a product on the shelf (for example, an integer value of 100), and the small shopping cart (int16_t) can easily hold it.

#include <stdint.h>
#include <stdio.h>
int main(void) {
    int16_t small_number = 100; // Small cart holds one item
    int32_t big_number = 0;     // Big cart is still empty
    // ...the big cart arrives...
    big_number = small_number;  // Copy the contents from the small cart to the big cart
    printf("Small number: %d\n", small_number);
    printf("Big number: %d\n", big_number);
    return 0;
}

In the line big_number = small_number; we assign a value of a smaller type (int16_t) to a variable of a larger type (int32_t). This is like putting the contents of a small shopping cart into a large shopping cart, which is more than enough!

The C language compiler sees this situation and intelligently handles it for us automatically; it knows this is safe, so it “silently” completes the conversion. This automatic conversion performed by the compiler is called Implicit Type Conversion (Implicit Type Conversion).

02

The “Disaster” of Forced Conversion: When an Elephant Tries to Squeeze into a Refrigerator

Now, the situation is reversed. If a large shopping cart contains a “big guy” and you try to force it into a small shopping cart, what will happen?

Let’s look at an example that exceeds the int16_t range:

#include <stdint.h>
#include <stdio.h>
int main(void) {
    int32_t big_number = 50000; // A "big guy", int16_t cannot hold it
    int16_t small_number = 0;    // "You must take it down!"
    small_number = big_number; // Forced!
    printf("Big number: %d\n", big_number);
    printf("Small number: %d\n", small_number); // Check the result
    return 0;
}

Run it, and you will see an astonishing result:

Big number: 50000
Small number: -15536

The value of small_number has “crashed”! It has turned into a completely unrelated negative number. This is a typical case of Overflow (Overflow). It’s like a person’s appetite can only hold one bowl of rice, and if you force them to eat three bowls, the result is predictable.

This type of conversion from a large range type to a small range type is fraught with risk. The compiler may give you a warning, but it still defaults to executing it. And this behavior, when the code is complex, is the source of disaster.

Professional Corrections and Additions: Three High-Risk Conversion Scenarios

To help everyone better understand the risks involved, I have summarized three scenarios where problems are most likely to occur:

1. Unsigned ➔ Signed

Unsigned types (like uint32_t) can only represent positive numbers, with a maximum value of about 4.2 billion. The maximum value of signed int32_t is about 2.1 billion. What happens if you give a huge unsigned number to a signed variable?

#include <stdint.h>
#include <stdio.h>
int main(void) {
    // UINT32_MAX is the maximum value of uint32_t, a "tricky operation"
    uint32_t u_number = UINT32_MAX; // About 4.2 billion
    int32_t s_number = u_number;    // Implicit conversion
    printf("Unsigned number: %u\n", u_number);
    printf("Signed number: %d\n", s_number);
    return 0;
}

The result is:

Unsigned number: 4294967295
Signed number: -1

4.2 billion turns into -1! This is because, in the computer’s internal representation, the binary data is reinterpreted, leading to a completely erroneous result.

2. Large Range ➔ Small Range

This is exactly the example we just discussed about the “elephant squeezing into the refrigerator.” A value of int32_t or int64_t, if it exceeds the representable range of int16_t (-32768 to 32767), will have its high-order binary bits directly “chopped off” during conversion, leaving only the low-order bits, ultimately leading to a completely distorted value.

3. Negative ➔ Unsigned

Conversely, assigning a negative number to an unsigned type will also produce unexpected results.

#include <stdint.h>
#include <stdio.h>
int main(void) {
    int16_t s_number = -1;
    uint32_t u_number = s_number;
    printf("Signed number: %d\n", s_number);
    printf("Unsigned number: %u\n", u_number);
    return 0;
}

The result is:

Signed number: -1
Unsigned number: 4294967295

-1 has transformed into the maximum value of an unsigned 32-bit integer! This is also a result of binary-level bit interpretation, which can seem like magic to developers who do not understand the underlying principles.

03

The Core Principle: Why Should We “Go the Extra Mile” to Write Explicit Conversions?

At this point, some students may ask:“You have mentioned so many risks of implicit conversion, what should we do?”

The answer is:Develop the habit of using explicit type conversion (Explicit Type Conversion)! This is what we commonly refer to as “forced type conversion.”

The syntax is simple; just add (target type) before the variable you want to convert:

// Still large to small, but this time we "explicitly" tell the compiler
small_number = (int16_t)big_number;

You may find it strange that even with forced conversion, if the value truly overflows, the result is still incorrect. Why go through the extra step?

This is precisely the difference between professional developers and novices! There are two reasons:

First: Improve code clarity and clarify intent.

When you write (int16_t), you are effectively planting a flag in the code, loudly announcing to everyone reading the code (including your future self): “Attention! I am performing a type conversion here, I know this may be risky, and I am doing it intentionally!” This makes the intent of the code clear, and others will not mistakenly think this is just a normal assignment.

Second: Warn of potential risks and simplify debugging.

When your program encounters an error due to data overflow, this explicit (int16_t) acts like a signpost, helping you quickly locate where the problem may have occurred. Without it, when facing a complex project, you may spend hours tracking down where a mysterious negative number came from. Many novice programmers fail to find bugs often because they overlook these details hidden under “automatic” conversions.

Let’s look at a successful example:

#include <stdint.h>
#include <stdio.h>
int main(void) {
    int16_t small_number = 32767; // Maximum value of int16_t
    int32_t big_number = 0;
    // Implicit conversion can succeed, but the intent is not clear
    // big_number = small_number;
    // ✅ Recommended practice: explicit conversion, clear code, professional habit
    big_number = (int32_t)small_number;
    printf("Final big number: %d\n", big_number);
    return 0;
}

Although in this example, implicit conversion could also succeed, writing (int32_t) is a very good programming habit.

04

Summary

Today, we spent a long time emphasizing a core point:

In C programming, whenever type conversion is involved, especially conversions that may carry risks (large to small, signed to unsigned, etc.), always use explicit type conversion!

If you remember this point after today’s lesson, even if you forget other details, and start practicing it from now on, your programming skills and code quality will surpass many others.

This is not about syntax correctness, but about programming habits and engineering quality. Developing good habits will make your future programming journey much smoother. Otherwise, seeking short-term convenience now may lead to endless bugs waiting for you in the future.