> ## 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 a fundamental, built-in numeric data type used to represent signed, exact-value integers. By default, `int` is a signed type. As of C++20, the standard mandates that signed integers use Two's Complement representation, where the most significant bit acts as a sign bit with a negative weight, and the remaining bits contribute to the overall value. ## Memory Allocation and Data Models The C++ standard does not prescribe a fixed size in bytes for `int`. Instead, it dictates minimum width requirements based on the underlying architecture's data model. * **Standard Guarantee:** The standard guarantees that an `int` will be at least 16 bits wide. Note that this does not strictly equate to 2 bytes; the standard defines size in terms of `char` (bytes), and the number of bits in a byte (`CHAR_BIT`) is only guaranteed to be *at least* 8. * **Modern Architectures:** In nearly all modern 32-bit and 64-bit data models (such as ILP32, LP64, and LLP64), `int` is implemented as a 32-bit integer. ## Syntax and Initialization C++ supports multiple initialization paradigms for `int`. Uniform (brace) initialization is the modern standard as it strictly prohibits narrowing conversions. ```cpp theme={"dark"} // Declaration without initialization. // Contains an indeterminate garbage value if it has automatic storage duration (local block-scope). // Zero-initialized if it has static or thread storage duration (namespace/global scope). int uninitialized_val; // Copy initialization int copy_val = 42; // Direct initialization int direct_val(42); // Uniform / Brace initialization (C++11 onwards) int brace_val{42}; // Zero-initialization via empty braces int zero_val{}; ``` ## Value Range and Representation Because C++20 requires **Two's Complement** representation, the range of an `int` is strictly determined by its bit width ($n$), calculated as $-2^{n-1}$ to $2^{n-1} - 1$. Assuming the standard modern 32-bit implementation: * **Minimum Value:** `-2,147,483,648` * **Maximum Value:** `2,147,483,647` These limits can be queried programmatically at compile-time using the `` header: ```cpp theme={"dark"} #include constexpr int min_val = std::numeric_limits::min(); constexpr int max_val = std::numeric_limits::max(); ``` ## Type Modifiers The `int` type serves as the base for several modified integer types, which alter either the sign representation or the memory allocation: * **Sign Modifiers:** * `signed int` (Identical to `int`) * `unsigned int` (Uses all bits for magnitude, shifting the 32-bit range to `0` through `4,294,967,295`) * **Size Modifiers:** * `short int` (Guaranteed minimum 16 bits) * `long int` (Guaranteed minimum 32 bits) * `long long int` (Guaranteed minimum 64 bits) *Note: When using modifiers, the `int` keyword itself can be omitted (e.g., `unsigned` is synonymous with `unsigned int`).* ## Overflow Behavior According to the C++ standard, **signed integer overflow invokes undefined behavior (UB)**. If an operation causes an `int` to exceed its maximum or minimum representable value, the compiler is permitted to optimize out the check or execute unpredictable instructions. This contrasts with `unsigned int`, which is guaranteed to wrap around modulo $2^n$.

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