How to Print unsigned long with printf in C

By the end of this page, you will know the correct printf format specifier for unsigned long in C, understand why mismatched format specifiers can print incorrect values, and learn how to choose the right specifier for related integer types.

In C, printf does not automatically know the type of each value you pass. It relies entirely on the format string to interpret the bytes correctly.

For an unsigned long, the correct format specifier is:

%lu

• % starts a format specifier
• l means long
• u means unsigned decimal integer

So this is correct:

unsigned long unsigned_foo = 123456UL;
printf("%lu\n", unsigned_foo);

If you use the wrong specifier, printf interprets the argument as the wrong type. That causes undefined behavior, which often shows up as strange output such as negative numbers or garbage values.

For example:

• %ld means long int (signed long)
• %u means unsigned int

Think of printf like a machine reading labeled boxes on a conveyor belt.

Each value you pass is a box containing bytes. The format string tells printf which label to use when opening each box.

If the box contains an unsigned long, the label must match:

• unsigned → use u
• long → use l

So the correct label is %lu.

If you attach the wrong label, printf opens the box incorrectly. It may treat an unsigned value as signed, or expect a different size. That is why wrong format specifiers can print nonsense or negative values.

Core syntax

printf("%lu\n", value);

Use %lu when value has type unsigned long.

Basic example

#include <stdio.h>

int main(void) {
    unsigned long count = 4000000000UL;
    printf("count = %lu\n", count);
    return 0;
}

Output might be:

count = 4000000000

Why %ld is different

#include <stdio.h>

int main(void) {
    unsigned long value = ;

    (, value);
    (, value);

     ;
}

Consider this program:

#include <stdio.h>

int main(void) {
    unsigned long value = 42UL;
    printf("Value: %lu\n", value);
    return 0;
}

Step by step

1. unsigned long value = 42UL;

   • A variable named value is created.
   • Its type is unsigned long.
   • The suffix UL makes the literal an unsigned long.

2. printf("Value: %lu\n", value);

   • printf reads the format string.
   • It sees ordinary text: Value:
   • Then it sees %lu
   • %lu means: read the next argument as an and print it in decimal form.

Logging counters and totals

unsigned long request_count = 150000UL;
printf("Requests handled: %lu\n", request_count);

Printing file sizes or byte counts

unsigned long bytes = 2048UL;
printf("Downloaded: %lu bytes\n", bytes);

Reporting loop progress

unsigned long i;
for (i = 0; i < 3; i++) {
    printf("Step %lu\n", i);
}

Debugging values from system or library code

Some APIs return values stored in larger integer types. When printing them for debugging, the format must match the actual type exactly.

Embedded and systems programming

In low-level C programs, exact integer sizes and signedness matter. Printing with the right specifier helps verify values correctly during testing and troubleshooting.

In real projects, developers usually do more than just write printf("%lu", x).

1. Print values with clear labels

printf("timeout_ms=%lu\n", timeout_ms);

This makes logs easier to read.

2. Use the exact matching specifier

Developers check the actual variable type before printing:

unsigned long total;
printf("%lu\n", total);

Not:

printf("%u\n", total);   // wrong if total is unsigned long

3. Use warnings to catch mistakes

Compilers can detect many printf mismatches.

gcc -Wall -Wextra -Wformat program.c

These warnings are extremely helpful in real codebases.

4. Use <inttypes.h> for fixed-width integer types

If a codebase uses types like uint32_t or uint64_t, developers often prefer macros such as instead of guessing the right format string.

1. Using the right letters in the wrong order

This is wrong:

printf("%ul\n", value);

The correct order is length modifier first, then conversion specifier:

printf("%lu\n", value);

2. Using %d or %u for an unsigned long

Broken example:

unsigned long value = 5000000000UL;
printf("%u\n", value);   // wrong

%u is for unsigned int, not unsigned long.

Use:

printf("%lu\n", value);

3. Using %ld because long looks close enough

// unsigned long
printf("%lu\n", value);

Quick rules

• unsigned long → %lu
• long → %ld
• unsigned int → %u
• int → %d
• unsigned long long → %llu
• long long → %lld

Pattern

% + length modifier + type

Examples:

• l = long
• ll = long long
• d = signed decimal
• u = unsigned decimal

What is the correct printf specifier for unsigned long in C?

Use:

%lu

Why does %ld sometimes print a negative number?

Because %ld tells printf to treat the value as a signed long. If the actual value is unsigned long, the types do not match.

Is %ul correct for unsigned long?

No. The correct order is %lu, not %ul.

Can I use %u for unsigned long if the value is small?

No. The format specifier must match the type, not just the value.

Why do some wrong format specifiers seem to work?

Sometimes the memory layout makes the output look correct by accident. But it is still undefined behavior and cannot be trusted.

How can I catch printf format mistakes?

• printf format specifiers — directly related because printing in C depends on matching the format string to the argument type.
• signed vs unsigned integers — important for understanding why %ld and %lu are different.
• integer types in C — useful for learning the differences between int, long, and long long.
• variadic functions — printf is variadic, which is why it depends on the format string instead of automatic type checking at runtime.
• compiler warnings — helpful for catching format string mismatches early.
• <inttypes.h> macros — important when printing fixed-width integer types portably.