Incorrect Conversion between Numeric Types

At its core, this flaw is about mismatched containers. Think of pouring a gallon of water into a quart-sized bottle; you're going to lose most of the water. In programming, this 'spillage' happens during type casting or implicit conversion when a larger data type (like a `long` or `size_t`) is squeezed into a smaller one (like an `int`). The high-order bits are simply chopped off—a process called truncation—which silently turns a large number into a much smaller, and often positive, number. This is especially dangerous because the code might not crash; it just starts working with wildly incorrect data. Developers most often encounter this when dealing with memory sizes, array indices, or loop counters in code that must work across different architectures (32-bit vs. 64-bit). The primary defense is to proactively validate that a value fits within the target type's range *before* performing the conversion. Use compiler warnings, static analysis tools, and explicit checks with limits defined in headers like `<limits.h>`. Always assume that inputs, especially those derived from user or file data, can exceed your variable's capacity.