> ## 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 integer data type in C that represents non-negative whole numbers. It modifies the standard integer type by removing the sign bit (allocating all bits to magnitude) and guaranteeing a minimum storage size of at least 32 bits, as defined by the ISO/IEC 9899 C standard. ## Syntax and Declaration The `int` keyword is optional when declaring an `unsigned long`. Both declarations below are semantically identical and recognized by the compiler: ```c theme={"dark"} unsigned long var1; unsigned long int var2; ``` ## Memory Size and Architecture Dependence The C standard dictates minimum sizes rather than exact sizes. While `unsigned long` is guaranteed to be $\ge$ 32 bits, its actual byte size is heavily dependent on the compiler's data model and the target architecture: * **ILP32 (32-bit systems):** 32 bits (4 bytes). * **LLP64 (64-bit Windows):** 32 bits (4 bytes). * **LP64 (64-bit Unix/Linux/macOS):** 64 bits (8 bytes). To determine the exact size on a specific system at runtime, use the `sizeof` operator: ```c theme={"dark"} size_t size = sizeof(unsigned long); ``` ## Value Range Because the type is `unsigned`, the Most Significant Bit (MSB) is not used as a sign flag. The range is always $0$ to $2^N - 1$, where $N$ is the number of bits. * **32-bit implementation:** $0$ to $4,294,967,295$ * **64-bit implementation:** $0$ to $18,446,744,073,709,551,615$ The absolute maximum value for the compilation environment is exposed via the `ULONG_MAX` macro, which requires including the `` header. ## Literals When assigning hardcoded numeric constants to an `unsigned long`, append the `UL` or `ul` suffix. This explicitly instructs the compiler to treat the literal as an `unsigned long`, preventing accidental truncation or signed integer overflow during compilation. ```c theme={"dark"} unsigned long dec_val = 4294967295UL; unsigned long hex_val = 0xFFFFFFFFUL; unsigned long oct_val = 037777777777UL; ``` ## Format Specifiers When reading or writing `unsigned long` values using standard I/O functions (like `printf` or `scanf`), the `%lu` format specifier is mandatory. Using `%d` or `%u` results in undefined behavior due to type mismatch and potential stack misalignment. ```c theme={"dark"} #include int main(void) { // Value fits within the guaranteed 32-bit minimum unsigned long val = 3141592653UL; // Outputting the value printf("Value: %lu\n", val); // Reading the value scanf("%lu", &val); return 0; } ``` ## Type Conversion and Promotion Under C's usual arithmetic conversions, if an operation involves an `unsigned long` and a smaller integer type (like `int` or `unsigned int`), the smaller type is implicitly promoted to `unsigned long` before the operation is evaluated. If mixed with a signed type of the same size (e.g., `long` and `unsigned long`), the signed type is implicitly converted to `unsigned long`, which can alter the mathematical value if the signed integer is negative.

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