> ## 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++ unsigned int An `unsigned int` (frequently abbreviated as `unsigned`) is a fundamental integral data type in C++ that represents non-negative whole numbers. By omitting the sign bit required in signed integers, it allocates all available bits to represent the magnitude of the value. This architectural shift effectively doubles the maximum representable positive limit compared to its signed counterpart of the same byte size. ## Syntax and Literals The type can be declared using either `unsigned int` or simply `unsigned`, as the `int` specifier is implicit. When assigning literal values, the `u` or `U` suffix explicitly types the literal as unsigned, preventing the compiler from defaulting to a signed `int`. ```cpp theme={"dark"} unsigned int val1 = 42; unsigned val2 = 100; // Equivalent to 'unsigned int' auto val3 = 4294967295U; // 'U' suffix forces unsigned type deduction ``` ## Memory Layout and Range The C++ standard dictates that an `unsigned int` must be at least 16 bits, though on virtually all modern 32-bit and 64-bit architectures, it occupies 32 bits (4 bytes). Because it uses pure binary representation without a two's complement sign bit, an $N$-bit `unsigned int` has a strict range of $0$ to $2^N - 1$. You can query these limits at compile-time using the `` header: ```cpp theme={"dark"} #include // Guaranteed to be 0 constexpr unsigned int min_val = std::numeric_limits::min(); // UINT_MAX: Typically 4294967295 (0xFFFFFFFF) on 32-bit systems, // but 65535 (0xFFFF) on 16-bit systems. constexpr unsigned int max_val = std::numeric_limits::max(); ``` ## Wraparound Behavior (Modular Arithmetic) Unlike signed integers, where overflow results in Undefined Behavior (UB), `unsigned int` arithmetic is strictly defined by the C++ standard to operate using modulo $2^N$ arithmetic. If an operation exceeds the maximum representable value, it wraps around to zero. Conversely, if an operation falls below zero, it wraps around to the maximum representable value (`UINT_MAX`). ```cpp theme={"dark"} #include unsigned int max_val = UINT_MAX; unsigned int overflow_val = max_val + 1; // Strictly defined: evaluates to 0 unsigned int min_val = 0U; unsigned int underflow_val = min_val - 1; // Strictly defined: evaluates to UINT_MAX ``` ## Implicit Conversions When an operation involves both a signed `int` and an `unsigned int`, C++ applies the **Usual Arithmetic Conversions**. The signed `int` undergoes an **integral conversion** to an `unsigned int` before the operation evaluates. This is strictly an integral conversion, not an integral promotion (promotions specifically refer to converting smaller integer types like `char` or `short` up to `int` or `unsigned int`). Because negative signed values are converted to unsigned values via modulo arithmetic, this can lead to counterintuitive logical evaluations if not explicitly managed. ```cpp theme={"dark"} #include int signed_val = -1; unsigned int unsigned_val = 1U; // The following evaluates to true. // signed_val (-1) undergoes integral conversion to unsigned int, becoming UINT_MAX. // UINT_MAX > 1U is true. if (signed_val > unsigned_val) { // Execution enters this block } ``` ## Bitwise Operations Because there is no sign bit, right-shift operations (`>>`) on unsigned integers are guaranteed to perform a **logical shift** (shifting in zeroes from the most significant bit). In contrast, as of C++20 (which mandates two's complement representation), right-shifting a negative signed integer is strictly defined by the standard to perform an **arithmetic shift** (sign extension). To guarantee exact bitwise behavior and output across platforms regardless of the native `unsigned int` width, fixed-width unsigned integers like `uint32_t` from `` are utilized. ```cpp theme={"dark"} #include uint32_t bits = 0xF0000000U; // 11110000... in binary bits = bits >> 4; // Guaranteed logical shift: 0x0F000000U ```

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