Why do I have to use %ld when referring to the size of an int variable?

Question

I define an int like this:

int a;

When I want to lookup the size of this int, I have to use the format specifier %ld like this:

printf("int size is %ld\n", sizeof(a));

When I use %d as the format specifier, I get the following error:

foo.c:7:10: warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘long unsigned int’ [-Wformat=]
    printf("int size is %d\n", sizeof(a));

The question is, why is the result of sizeof() defined as long unsigned int when the parameter of the function is an int?

Answer 1

The type of sizeof(anything) is size_t, which is some unsigned integral constant. To print it, you should be using %zu.

Answer 2

According to the C Standard (6.5.3.4 The sizeof and alignof operators)

5 The value of the result of both operators is implementation-defined, and its type (an unsigned integer type) is size_t, defined in <stddef.h> (and other headers).

and (7.19 Common definitions <stddef.h>)

size_t which is the unsigned integer type of the result of the sizeof operator;

and (7.21.6.1 The fprintf function)

z Specifies that a following d, i, o, u, x, or X conversion specifier applies to a size_t....

Thus it would be more correctly to write

printf( "int size is %zu\n", sizeof( a ) );
                     ^^^

It is not important what type of an object the operator sizeof is applied to. It returns the number of bytes occupied by an object of the given type and the returned number has type size_t.

Your compiler issues a warning because in your system type size_t is defined like unsigned long int but you are using signed int. It seems does not issue a warning when you use format specifier %ld because the rank of the signed long int type is equal to the rank of the unsigned long int type that corresponds to size_t.

Answer 3

"when the parameter of the function is an int?"

First off, sizeof is an operator, not a function.

Second, why do you think its result type should be the same as its argument type? What if you want to get the size of a struct? or an array? or a pointer? How would it be supposed to yield the size of a struct as a struct? It just doesn't make sense.

It yields a size, so the type of its result is size_t, that you should print using %zu.

Answer 4

sizeof gives the number of storage units taken up by the operand. The result type is size_t, which is an unsigned type wide enough to represent the size of the largest object the system is capable of storing. The type of the operand doesn't affect the type of the result.

With C89 compilers, you can print a size_t value with %ld and cast the argument to unsigned long:

 printf( "sizeof x = %ld\n", (unsigned long) sizeof x );

With C99 and later compilers, use %zu:

 printf( "sizeof x = %zu\n", sizeof x );

Answer 5

%zu is not portable; it requires a C99 library. For instance, MinGW:

$ cat zu.c
#include <stdio.h>

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

$ gcc zu.c -o zu

$ ./zu.exe
zu

Oops! The characters zu printed literally, and the size argument was ignored.

For printing types which you know are reasonably small, cast the size to int or unsigned, and use the %d or %u conversion specifier:

printf("sizeof int == %d\n", (int) sizeof (int));

If there is any possibility that the size of an object might not fit into type int, try unsigned long int:

printf("sizeof int == %lu\n", (unsigned long) sizeof object);

This is probably only necessary on systems with a small int, like 16 bits, such that int only goes up to 32767 and unsigned int to 65535, and yet there can be objects whose sizes exceed these values.

If you're sure that the program needs only to be portable to targets that support C99, then %zu it is.