> ## 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 long `unsigned long` (formally `unsigned long int`) is a fundamental integral data type in C++ designed to store non-negative integer values. By applying the `unsigned` specifier, the memory bit typically reserved for the sign in a signed integer is repurposed to represent magnitude. This shifts the representable range, effectively doubling the maximum positive value compared to a standard `signed long` while establishing a strict minimum value of zero. ## Memory Size and Architecture Dependency The C++ standard does not prescribe a fixed byte size for `unsigned long`. Instead, it enforces a relative size constraint: it must be at least 32 bits (4 bytes) and must be greater than or equal to the size of an `unsigned int`. The exact memory footprint is dictated by the compiler and the target architecture's data model: * **32-bit systems (ILP32) & Windows 64-bit (LLP64):** `unsigned long` is typically **32 bits**. * **Linux/macOS 64-bit (LP64):** `unsigned long` is typically **64 bits**. ## Value Range Because the size varies by data model, the maximum representable value ($2^n - 1$, where $n$ is the number of bits) also varies: * **32-bit implementation:** $0$ to $4,294,967,295$ * **64-bit implementation:** $0$ to $18,446,744,073,709,551,615$ ## Syntax and Literals When declaring an `unsigned long`, the `int` keyword is optional and conventionally omitted. To explicitly define an integer literal as an `unsigned long`, append the `ul` or `UL` suffix to the numeric value. ```cpp theme={"dark"} // Standard declaration unsigned long a = 4294967295UL; // Equivalent verbose declaration unsigned long int b = 4294967295UL; // Hexadecimal and binary literals unsigned long hex_val = 0xFFFFFFFFUL; unsigned long bin_val = 0b11111111111111111111111111111111UL; ``` ## Overflow and Underflow Mechanics Unlike signed integers, where overflow results in Undefined Behavior (UB), unsigned integers in C++ have strictly defined wraparound semantics. Operations that exceed the maximum or minimum representable values follow modulo arithmetic, specifically modulo $2^n$. To guarantee correct wraparound behavior across different architectures (32-bit vs. 64-bit), limits should be referenced dynamically rather than hardcoded. ```cpp theme={"dark"} #include unsigned long max_val = ULONG_MAX; unsigned long overflow_val = max_val + 1; // Wraps around to 0 unsigned long min_val = 0UL; unsigned long underflow_val = min_val - 1; // Wraps around to ULONG_MAX ``` ## Querying Type Limits To programmatically determine the exact limits of `unsigned long` on a specific compilation target, C++ provides standard library interfaces via `` and ``. ```cpp theme={"dark"} #include #include #include int main() { // Using the C++ library (Preferred) std::cout << "Max: " << std::numeric_limits::max() << "\n"; std::cout << "Min: " << std::numeric_limits::min() << "\n"; std::cout << "Bits: " << std::numeric_limits::digits << "\n"; // Using C-style macros from std::cout << "Max (Macro): " << ULONG_MAX << "\n"; return 0; } ```

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