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:

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:

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 <limits.h> 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.

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.

#include <stdio.h>

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.

Master C with Deep Grasping Methodology!

Learn More