printf Long Format Specifier in C

By the end of this page, you will understand how printf formats long values in C, why the correct conversion specifier matters, how length modifiers work, and how to avoid common type-mismatch bugs when printing integers.

printf in C does not guess argument types at runtime. It relies entirely on the format string you provide.

For integer output, the base conversion specifier for a signed decimal integer is %d or %i. To print other integer types, C uses length modifiers that are placed before the conversion letter.

For a long, the correct signed decimal format is:

%ld

You can also use:

%li

Both are valid for printf when printing a signed long, though %ld is more commonly used.

For an unsigned long, use:

%lu

This matters because printf is a variadic function. Variadic functions do not know the actual types of extra arguments unless the format string describes them correctly. If you pass a long but use %d, printf will interpret the bytes as if they were an int, which can produce incorrect output and causes undefined behavior.

In real programs, this becomes especially important when:

Think of printf like a labeling machine in a warehouse.

• The value is the package.
• The format specifier is the label telling the machine what kind of package it is.

If you put a long package on the belt but label it as %d (an int), the machine reads it using the wrong instructions. Sometimes the output looks almost right, sometimes it is completely wrong, and sometimes it causes subtle bugs.

%ld means: “This is a signed decimal number, and its type is long.”

The general syntax is:

printf("format string", value);

For long, use %ld:

#include <stdio.h>

int main(void) {
    long distance = 1234567890L;
    printf("Distance: %ld\n", distance);
    return 0;
}

Output:

Distance: 1234567890

For unsigned long, use %lu:

#include <stdio.h>

int main(void) {
    unsigned long population = 4000000000UL;
    printf("Population: %lu\n", population);
     ;
}

Consider this example:

#include <stdio.h>

int main(void) {
    long score = 500000L;
    printf("Score = %ld\n", score);
    return 0;
}

Step by step:

1. long score = 500000L;

   • A variable named score is created.
   • Its type is long.
   • The L suffix makes the literal a long constant.

2. printf("Score = %ld\n", score);

   • printf reads the format string.
   • It finds %ld.
   • %l means the argument is a long.
   • d means print it as a signed decimal integer.

Printing long values appears in many practical situations:

• Counters and IDs

  • Large loop counters
  • Record IDs stored in long

• Timestamps

  • Unix-style time values are often stored in larger integer types

• File sizes and offsets

  • Programs may use long or related integer types for file positions

• System logs

  • Logging process data, durations, counts, or totals

• Scientific and numeric programs

  • Intermediate results may exceed the range of int

Example:

long total_requests = 1250000L;
printf("Processed requests: %ld\n", total_requests);

In each case, the format string must match the actual variable type.

In real codebases, developers usually combine correct format specifiers with a few common patterns:

Validation and logging

if (count < 0) {
    printf("Invalid count: %ld\n", count);
    return 1;
}

This is a simple example of a guard clause: detect a bad value early, log it, and stop.

Debug output

long retries = 3L;
printf("Retry attempt: %ld\n", retries);

Developers often print numeric state while debugging.

Configuration values

long timeout_ms = 5000L;
printf("Timeout set to %ld ms\n", timeout_ms);

Configuration values are often read, validated, and then logged.

Matching type and format consistently

Teams usually try to keep these aligned:

• variable type: long
• literal suffix: L when useful
• format string: %ld

1. Using %d for a long

Broken code:

long n = 100000L;
printf("%d\n", n);

Problem:

• %d expects an int
• n is a long
• This is undefined behavior

Fix:

printf("%ld\n", n);

2. Forgetting unsigned types need different specifiers

Broken code:

unsigned long n = 42UL;
printf("%ld\n", n);

Problem:

• %ld is for signed long
• n is

Here is a quick comparison of common integer format specifiers in C:

• Print signed long: %ld
• Print unsigned long: %lu
• Print signed int: %d or %i
• Print signed long long: %lld

Examples:

long a = 123L;
unsigned long b = 123UL;
long long c = 123LL;

printf("%ld\n", a);
printf("%lu\n", b);
printf("%lld\n", c);

Rules:

• l is the length modifier for long
• d and i are signed decimal output specifiers
• The format string must match the argument type exactly

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

Use %ld for a signed long.

Can I use %i for a long?

Not by itself. For a long, use %li or %ld. In printf, both are valid for signed decimal output.

What is the specifier for unsigned long?

Use %lu.

Why is %d wrong for a long?

Because %d expects an int. If you pass a long, the format and argument types do not match, which causes undefined behavior.

Is %ld the same as %li?

• printf format specifiers — The broader system that includes %d, %f, %s, %ld, and more.
• Length modifiers in C — Explains prefixes like l, ll, and h used with format specifiers.
• Variadic functions — Important because printf depends on the format string to interpret extra arguments.
• Integer types in C — Helps distinguish int, long, short, and long long.
• scanf format specifiers — Related, but input specifiers have different behavior and must be matched carefully.
• Undefined behavior — Relevant because incorrect printf type matching can trigger it.