> ## 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 int The `int` keyword in C designates the fundamental signed integer data type. It represents whole numbers without a fractional component and is architecturally mapped to the natural word size of the target machine's execution environment, making it the primary type for standard arithmetic operations. ```c theme={"dark"} int uninitialized_var; int initialized_var = 42; signed int explicit_signed = -10; // 'signed' is implicit in 'int' ``` ## Memory Size and Architecture Dependence Unlike fixed-width types (e.g., `int32_t`), the exact byte size of an `int` is compiler- and architecture-dependent. The ISO C Standard mandates only that an `int` must be capable of holding a minimum range of values, requiring at least 16 bits (2 bytes) of storage. * **16-bit architectures:** `int` is typically 2 bytes. * **32-bit (ILP32) and 64-bit (LP64/LLP64) architectures:** `int` is universally implemented as 4 bytes (32 bits). You can determine the exact size on a specific platform using the `sizeof` operator, which evaluates to a `size_t` constant expression: ```c theme={"dark"} #include size_t int_size = sizeof(int); ``` ## Value Range and Limits Because `int` is signed by default, one bit is reserved for the sign. The values are represented in memory using **Two's Complement** binary encoding. The absolute limits of the `int` type for a given compiler are defined as macros in the `` standard library header. * **16-bit implementation:** * Minimum (`INT_MIN`): -32,768 ($-2^{15}$) * Maximum (`INT_MAX`): 32,767 ($2^{15} - 1$) * **32-bit implementation:** * Minimum (`INT_MIN`): -2,147,483,648 ($-2^{31}$) * Maximum (`INT_MAX`): 2,147,483,647 ($2^{31} - 1$) ## Integer Promotion A fundamental semantic of C is that `int` serves as the baseline type for arithmetic evaluation. Under the rules of **Integer Promotion**, any integer type smaller than `int` (such as `char` and `short`) is automatically converted to `int` before arithmetic operations, bitwise operations, or logical evaluations are performed. If an `int` cannot represent all possible values of the original type, it is promoted to `unsigned int` instead. ```c theme={"dark"} void demonstrate_promotion(void) { char a = 100; char b = 50; // 'a' and 'b' are implicitly promoted to 'int' before addition. // The result of (a + b) is of type 'int'. int result = a + b; } ``` ## Signed Integer Overflow In C, overflowing a signed integer—such as exceeding `INT_MAX` or falling below `INT_MIN`—results in **Undefined Behavior (UB)**. The compiler is permitted to optimize out overflow checks or assume overflow never occurs, which can lead to unpredictable program execution. This strictly contrasts with `unsigned int`, which safely wraps around using modulo arithmetic. ```c theme={"dark"} #include void trigger_overflow(void) { int max_val = INT_MAX; int overflowed = max_val + 1; // UNDEFINED BEHAVIOR } ``` ## Type Modifiers The `int` base type can be altered using sign and size modifiers to adjust its memory footprint and value range. When a modifier is used, the `int` keyword itself becomes optional. ```c theme={"dark"} unsigned int u_val = 4000000000U; // Drops the sign bit to double the positive range short int s_val = 32000; // Guarantees at least 16 bits long int l_val = 2147483647L; // Guarantees at least 32 bits long long int ll_val = 9000000LL; // Guarantees at least 64 bits ``` ## Format Specifiers When interfacing with standard I/O functions like `printf` and `scanf`, specific format specifiers are required to correctly parse the binary data of an `int`. * **Decimal:** `%d` and `%i` are functionally identical in `printf`. However, in `scanf`, `%d` strictly expects base-10 input, whereas `%i` will auto-detect the base if the input is prefixed with `0x` (hexadecimal) or `0` (octal). * **Hexadecimal and Octal:** The `%x` (hexadecimal) and `%o` (octal) format specifiers strictly expect an `unsigned int`. Passing a negative `int` to these specifiers invokes Undefined Behavior. To safely inspect the binary, hexadecimal, or octal representation of a signed `int`, it must be explicitly cast to an `unsigned int`. ```c theme={"dark"} #include void print_integers(void) { int val = 255; int negative_val = -255; // Standard decimal output printf("Decimal: %d\n", val); printf("Decimal: %i\n", val); // Explicit cast to unsigned int is required to avoid Undefined Behavior printf("Hexadecimal: %x\n", (unsigned int)negative_val); printf("Octal: %o\n", (unsigned int)negative_val); } ```
Tired of Poor C Skills? Fix That With Deep Grasping! Learn More