为何使用short/char存在弊端？int相对短整型的优势解析

Great question—this is one of those subtle C/C++ quirks that trips up a lot of new devs who’re trying to squeeze every last byte out of their code. Let’s break this down step by step.

Even if your value fits in a byte or two, these narrow types come with hidden gotchas:

• Integer promotion surprises: In C/C++, any narrow integer type (char, short, even unsigned char) gets automatically promoted to int when used in expressions (like arithmetic, comparisons, or function arguments). This means you don’t actually save any processing time, and you can run into weird behavior—for example, a signed char holding 0xFF (255 as unsigned) will promote to -1 as an int, which can break comparisons or calculations.
• Alignment and wasted memory: Most CPUs use memory alignment matching the size of int (e.g., 4 bytes on 32-bit systems). If you declare a char variable, the compiler will often pad it with extra bytes to meet alignment requirements—so you don’t actually save any memory for single variables. Worse, some architectures will throw errors or run slower when accessing unaligned short values.
• Standard library mismatch: Almost all standard library functions expect or return int (think getchar(), printf("%d"), or even basic math functions). Using narrow types means you’ll have to add explicit casts, which adds boilerplate and increases the chance of bugs.

The C/C++ standards define int as the natural integer type for the target system. That means it’s sized to match the CPU’s word length—the size of the general-purpose registers that the CPU uses most efficiently. The standard only requires int to be at least 16 bits, but in practice:

• On 32-bit systems, int is 4 bytes
• On 64-bit systems, int is still 4 bytes (with long being 8 bytes for larger values)

This makes int the type that compilers optimize most heavily, and the one that CPU instructions are designed to handle natively—no extra conversion steps needed.

The advantages over narrow types are hard to ignore:

• Maximum performance: CPUs process int values faster than narrower types because they fit perfectly into registers. Using short or char forces the compiler to add extra instructions to truncate or extend values, which slows things down.
• Fewer bugs: By avoiding integer promotion and sign extension surprises, your code behaves more predictably. You won’t have to debug why a short variable suddenly becomes a negative number when you pass it to a function.
• Better readability and consistency: Every developer expects plain integer variables to be int. When you see a char or short, you have to stop and ask: "Is this meant to hold a byte of data, or is this a mistake?" Using int keeps your code straightforward and reduces cognitive load for anyone reading it.
• Negligible memory cost: Unless you’re declaring a massive array (like millions of elements), the tiny memory difference between int and a narrow type is irrelevant on modern systems. Worrying about 2-3 bytes of memory for a single variable is premature optimization 99% of the time.

Of course, there are exceptions: if you’re working with tightly packed data (like image pixels, network packets, or large lookup tables), char or short makes sense. But for everyday variables—counters, loop indices, function parameters—int is the clear winner.

内容的提问来源于stack exchange，提问作者Edenia