How to Print size_t Portably with printf in C

By the end of this page, you will understand why size_t should not be printed with %u or %lu directly, and how to print it portably using the correct printf format specifier: %zu. You will also learn what size_t represents, why platform differences matter, and how to avoid common formatting mistakes in C.

size_t is an unsigned integer type used to represent sizes and counts of objects in memory. You commonly see it as the return type of sizeof(), and in standard library functions that work with array lengths, memory sizes, and buffer counts.

The important detail is that size_t is not guaranteed to be the same type on every platform:

• On one system, it might be unsigned int
• On another, it might be unsigned long
• On another, it could be a different unsigned integer type

Because printf() is a variadic function, it does not know the actual type of each argument unless the format string tells it correctly. That means the format specifier must match the argument type exactly.

Using %u assumes the argument is an unsigned int. Using %lu assumes the argument is an unsigned long. Neither is guaranteed to match size_t everywhere.

The portable solution in standard C is:

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

Here:

• %z is the length modifier for

Think of size_t as a container label that changes depending on the machine.

You want to print the number inside the container. But printf() needs the correct label to know how to read it.

• %u says: "This container is an unsigned int."
• %lu says: "This container is an unsigned long."
• %zu says: "This container is a size_t."

If you use the wrong label, printf() may read the bytes incorrectly or the compiler may warn you.

So the rule is simple:

• If the variable is size_t, use %zu

Match the format to the real type, not to what you guess the type probably is on your machine.

The correct portable syntax is:

#include <stdio.h>
#include <stddef.h>

size_t n = 42;
printf("%zu\n", n);

Example 1: Printing the result of sizeof

#include <stdio.h>

int main(void) {
    printf("int uses %zu bytes\n", sizeof(int));
    return 0;
}

sizeof(int) returns a size_t, so %zu is the correct format specifier.

Example 2: Printing an array length

#include <stdio.h>

int main() {
     values[] = {, , , };
     count = (values) / (values[]);

    (, count);
     ;
}

Consider this example:

#include <stdio.h>

int main(void) {
    size_t count = sizeof(double) * 4;
    printf("count = %zu\n", count);
    return 0;
}

Step by step

1. sizeof(double) is evaluated.

   • Suppose double is 8 bytes on your system.

2. sizeof(double) * 4 becomes 8 * 4.

   • The result is 32.

3. That result is stored in count.

   • count has type size_t.

4. printf("count = %zu\n", count); is called.

size_t appears often in real C programs, especially where code deals with memory, lengths, or buffer sizes.

Common situations

• Printing the result of sizeof()
• Displaying array lengths
• Showing buffer capacities
• Logging memory allocation sizes
• Reporting bytes read or written
• Working with string or data processing loops

Example: buffer logging

#include <stdio.h>

void log_buffer_size(size_t size) {
    printf("Allocated buffer: %zu bytes\n", size);
}

Example: loop count reporting

#include <stdio.h>

int main(void) {
    char text[] = "hello";
    size_t len = sizeof(text) - 1;

    printf("Text length: %zu\n", len);
    return ;
}

In real projects, developers usually follow a few simple patterns when working with size_t.

1. Use size_t for sizes and counts

If a variable stores:

• number of elements
• buffer length
• byte count
• result of sizeof

then size_t is usually the right type.

size_t capacity = 256;
size_t item_count = 10;

2. Print it with %zu

printf("capacity=%zu, item_count=%zu\n", capacity, item_count);

3. Validate sizes before allocation

if (count == 0) {
    printf("No items to allocate\n");
    return;
}

4. Use size_t consistently across APIs

  {
     ( i = ; i < count; i++) {
        (, i, items[i]);
    }
}

Here are some frequent mistakes beginners make when printing size_t.

Mistake 1: Using %u

size_t n = 10;
printf("%u\n", n);  // Wrong on some systems

Why it is a problem

%u expects unsigned int, but size_t may be a different type.

Fix

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

Mistake 2: Using %lu because it works on one machine

size_t n = 10;
printf("%lu\n", n);  // Still not fully portable

Why it is a problem

This assumes size_t is unsigned long, which is not guaranteed everywhere.

Here is a quick comparison of common integer format choices when printing unsigned values in C.

// Correct way to print size_t
size_t n = 42;
printf("%zu\n", n);

Rules

• size_t is used for sizes, lengths, and counts
• sizeof(...) returns size_t
• Use %zu with printf() for size_t
• Do not assume size_t is unsigned int or unsigned long

Common examples

printf("%zu\n", sizeof(int));
printf("length = %zu\n", len);
printf("capacity = %zu bytes\n", capacity);

Avoid

printf("%u\n", n);   // not portable
(, n);  

What is the correct printf specifier for size_t in C?

Use %zu.

Why does %u sometimes work for size_t?

It works only on systems where size_t happens to be the same type as unsigned int. That is not guaranteed by the language.

Can I use %lu for size_t?

Only if size_t is actually unsigned long on that platform. For portable code, use %zu instead.

Does sizeof return int?

No. sizeof returns a value of type size_t.

Why does the compiler warn about %u with size_t?

Because expects an for , but your argument has type , which may be a different type.

• printf format specifiers - Related because size_t printing depends on matching the correct format string.
• size_t - The core type being printed; understanding what it represents is essential.
• sizeof operator - It returns size_t, so these concepts are closely connected.
• Variadic functions - printf is variadic, which is why format-string type matching matters.
• Integer types in C - Helps explain why unsigned int, unsigned long, and size_t are not interchangeable.
• Compiler warnings - Important because format mismatches are often caught at compile time.
• Portable C programming - This question is fundamentally about writing code that works across platforms.