Why doesn't %p show the full width of pointer?

Question

If I am not mistaken, on a 64bit machine, a pointer is equivalent to a number between 0 and 2^64-1. Hence the following results:

printf("%p",    (void*)     -1); → 0xffffffffffffffff
printf("0x%lx", (uintptr_t) -1); → 0xffffffffffffffff

yet when I print a pointer from an object I just allocated, the results do not show the same width:

printf("%p", (void*) &myobject); → 0x70d940

Is there any reason why all my objects are (always) given an adress at the begining of the memory space ? Thanks to virtual memory the could be placed (from the program's point of view) basicaly anywhere in the 64bit space.

Also why doesn't %p print the full width by default ? (I would expect if to act like 0x%016lx)

Edit: Also, is there any reason why 0x018p is not valid ?

error : fanion « 0 » used with « %p » gnu_printf format

Answer 1

As noted in a comment,

%p can format the address in any way it chooses. It doesn't have to be hex (though it usually is); the output doesn't have to start 0x or 0X; it might print hex in upper-case or lower-case.

Try printf("%p\n", (void *)0); — on a Mac, that prints just 0 even though other values are printed 0x1234 style. Try printf("%p\n", (void *)1024); — it probably prints a short address 0x400.

There are no requirements in the standards (POSIX or C or C++) specifying what the output from %p should look like.

If you want control over the format of pointers, use uintptr_t and the PRIzPTR macros from <inttypes.h>:

void *vp = 0;
printf("0x%.16" PRIXPTR " contains 0x%" PRIXPTR "\n",
       (uintptr_t)&vp, (uintptr_t)vp);

Or use PRIxPTR if you prefer lower-case hex digits. I don't, and I do like the 0x prefix, so that's what I use when I'm not constrained by someone else's questionable æsthetics.

Answer 2

The exact representation of pointers via the %p format specifier is implementation defined.

From section 7.21.6.1 of the C standard:

p The argument shall be a pointer to void. The value of the pointer is converted to a sequence of printing characters, in an implementation-defined manner.

On Linux in particular, the man page states the following:

The void * pointer argument is printed in hexadecimal (as if by %#x or %#lx)

So if you are on Linux, you might be able to get away with using %#016lx

However, that's just one implementation, so you can't assume anything about the format in a conforming C application.

For example, on Turbo C running on DOS, a pointer actually contains two values, a segment and an offset.

Answer 3

Speaking mainly from a C perspective, since you've tagged [C] and you're using C-style code.

If I am not mistaken, on a 64bit machine, a pointer is equivalent to a number between 0 and 2^64-1.

Well that's a bit tricky. Pointers can be converted to integers and back, but the size required for an integer type to be capable of supporting all possible round-trip pointer-integer-pointer conversions without data loss is unspecified. Implementations are not required to provide such a type.

Moreover, pointers are not required to be represented as integer indexes into a flat address space, and indeed, historically, some implementations have used different representations. It is therefore not correct or safe to assert that a pointer is equivalent to a number, regardless of range.

Note also that this ...

printf("0x%lx", (uintptr_t) -1);

... is unsafe, inasmuch as it assumes that uintptr_t is unsigned long int, which is by no means guaranteed to be the case. The safe way to write a format string for a value of type uintptr_t is:

printf("0x%" PRIxPTR, (uintptr_t) -1);

(Uses inttypes.h)

Is there any reason why all my objects are (always) given an adress at the begining of the memory space ? Thanks to virtual memory the could be placed (from the program's point of view) basicaly anywhere in the 64bit space.

This is well beyond anything specified by C or C++, but yes, on a virtual-memory machine, your objects could be placed anywhere in the system's virtual address space. Why should they be, however? If your objects are dynamically allocated or have automatic duration then they are likely to be allocated in relatively consistent regions, because the system has regions that it uses for those purposes. If the objects have static duration then they might, in principle, be subject to ASLR, but that depends on the system, the C implementation, compilation options, and other details.

Also why doesn't %p print the full width by default ? (I would expect if to act like 0x%016lx)

Why should it do so? Your expectation is unjustified. printf() generally does not print leading zeroes unless you explicitly ask it to do so. C does not even require that the output be formatted as a hexadecimal number -- the format is completely implementation-defined.

Edit: Also, is there any reason why 0x018p is not valid ?

Because the standard explicitly says that the 0 flag character causes undefined behavior when used with the p conversion specifier. More generally, it produces UB when used with any conversion specifier other than d, i, o, u, x, X, a, A, e, E, f, F, g, or G. That's a long list of specifiers, but p is not on it. If you look carefully, you'll see that it's all the ones that specify conversion to numeric format, which, again, C does not specify p to do (though some implementations may so specify).

Answer 4

It is because in most C++ implementations the pointer printing (%p) suppresses leading zeroes to make things more readable. You can use formatting tricks while printing to get the full address width.

EDIT: The 'formatting trick' I mentioned:

std::cout
<< "0x"
<< std::hex
<< std::noshowbase
<< std::setw(2)
<< std::setfill('0')
<< n
<< std::endl ;

Taken from https://stackoverflow.com/a/30326177/7407065

Answer 5

Also why doesn't %p print the full width by default?

Printing the full width of pointers by default breaks the style of printf(). A "full width" option is available through modifiers.

The various unmodified specifiers print minimal text.

printf("%d", INT_MIN);
// "-2147483648"   example
printf("%d", 123);
// "123", not "+0000000123"

double value_nearest_one_seventh = 1/7.0;
printf("%f", value_nearest_one_seventh);
// "0.142857" 
// instead of its exact value of
// 0.142857142857142849212692681248881854116916656494140625

Should code need to print a pointer to a fixed width, use the length modifier.

void *ptr = ptr;
int pointer_print_width = sizeof("0xffffffffffffffff") - 1;
printf("<%*p>", pointer_print_width, ptr);
// <          0x28cc6c>