> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C short The `short` (or `short int`) data type in C is a primitive integer type that allocates less or equal memory compared to a standard `int`. By default, it represents signed whole numbers and is guaranteed by the C Standard to be at least 16 bits (2 bytes) in width, strictly adhering to the architectural constraint `sizeof(short) <= sizeof(int)`. ## Type Variants and Syntax The `short` keyword can be combined with signedness modifiers. If no modifier is provided, the type defaults to `signed`. The `int` keyword is optional and usually omitted in idiomatic C. ```c theme={"dark"} short a = 10; // Implicitly signed, equivalent to 'signed short int' signed short b = -500; // Explicitly signed unsigned short c = 65000; // Unsigned, strictly non-negative ``` ## Size and Value Ranges While the exact byte size is architecture-dependent, a `short` is almost universally implemented as a 16-bit two's complement integer. The exact limits for the target compiler are defined via macros in the `` header. | Type | Minimum Size | Standard Range (16-bit) | `` Macros | | :--------------- | :----------- | :---------------------- | :---------------------- | | `signed short` | 16 bits | -32,768 to 32,767 | `SHRT_MIN` / `SHRT_MAX` | | `unsigned short` | 16 bits | 0 to 65,535 | `0` / `USHRT_MAX` | ## Format Specifiers When performing I/O operations with standard library functions like `printf` or `scanf`, the `h` (half) length sub-specifier must be prepended to the base integer format specifiers. ```c theme={"dark"} #include int main(void) { short s_val = -1234; unsigned short u_val = 56789; // %hd for signed decimal printf("Signed: %hd\n", s_val); // %hu for unsigned decimal printf("Unsigned: %hu\n", u_val); // %hx or %ho for unsigned hexadecimal or octal printf("Hexadecimal: %hx\n", u_val); return 0; } ``` ## Integer Promotion A critical mechanical behavior of `short` in C is **integer promotion**. When a `short` is evaluated in an arithmetic or bitwise expression, the compiler implicitly promotes its value to an `int` (or `unsigned int` if an `int` cannot represent the entire range of the original type) before executing the operation. ```c theme={"dark"} #include void promotion_example(void) { short x = 32000; short y = 1000; // x and y are promoted to 'int' before the addition occurs. // The expression (x + y) yields an 'int', not a 'short'. size_t expr_size = sizeof(x + y); // Evaluates to sizeof(int), typically 4 bytes // Assigning an out-of-range 'int' back to a signed 'short' results in Implementation-Defined Behavior. // Unlike unsigned types (which guarantee modulo arithmetic/truncation), signed conversion is compiler-dependent. short z = x + y; } ```

Tired of Poor C Skills? Fix That With Deep Grasping! Learn More