How to print the address value of a pointer in a C program?

Question

I'm trying to learn how to use the pointer in a C program; my example is as follows:

   #include <stdio.h>
   #include <stdlib.h>
   
   int main(int argc, char *argv[]) {
        int * tab = (int*)malloc(sizeof(int)*5);
        int a = 10;
        int *p;
        p  = &a;
        printf("the address of a is %d \n",&a);    
        printf("the address of a using the pointer is %p \n",p);    
        printf("the address of tab is %d \n",tab);    
    }

I'm trying to print the address of a, the address value inside of p and where the first byte of the tab begins.

I can get hexadecimal values when using "%p", but I'm willing the decimal value of the addresses.

Edit : On this Video image, someone has used "%d" to print a decimal value for a pointer address, and it has confused me.

Answer 1

To print a decimal version of an object pointer, 1st convert the pointer to an integer. Best to use the optional type uintptr_t.

The following type (uintptr_t) designates an unsigned integer type with the property that any valid pointer to void can be converted to this type (uintptr_t) ... C11dr §7.20.1.4 1

#include <inttypes.h>
uintptr_t d = (uintptr_t)(void *) &a;

Then print it.
Some info on PRIuPTR

printf("%" PRIuPTR "\n", d);

---

For pre-C99 code, consider a direct cast to unsigned long. @Barmar

---

OP later commented

"... i will try to manipulate the tab variable , and i will test if every cell in the tab is 4 byte , so may be i will do tab+8 bytes to get the value of a specific cell , here it's a simple example , with decimal it will be easy for me ."

This is a questionable approach as the decimalization of a pointer may not provide the continuous numeric model expected. This post this may be good for learning, but with OP providing more details in another post, even better ideas could be given for the higher level problem.

Answer 2

First, be aware that addresses are often "number-like" but might not be (e.g. remember the segment+offset notion of far addresses on 1980-era 16 bits x86 PCs).

Then, the integral type the most similar to pointers is intptr_t (signed) or uintptr_t (unsigned) - both from <stdint.h>.

You might cast that to a long long (hoping that they are not smaller than pointers), e.g.

 printf("address of a in decimal is %lld\n", (long long) (intptr_t) (&a));

But really, why do you want to show an address in such a fashion? I see no need for it (e.g. debuggers or linkers are generally showing addresses in hexa, which is probably what %p does).

Notice that the C11 standard (see n1570, §7.21.6.2, p315) does not say much about %p for printing pointer:

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.

I'm understanding the above in a way where printing Hello ⭔ for any pointer would be an acceptable and standard conforming behavior. In practice, implementations print pointers in a way similar to what linkers and debuggers do, and don't behave in a silly way (but I understand they could).

At last, the actual concrete "numerical" value of a pointer is not really important and can vary greatly from one execution to the next (e.g. because of ASLR).

Answer 3

For printing an "address" (actually a pointer) "%p" is the most common method (note the necessary cast to void*). If you need the address in decimal instead of hexadecimal, you can convert the pointer into an integral value; this is well defined in C (cf. this online C standard draft):

6.3.2.3 Pointers

(6) Any pointer type may be converted to an integer type. Except as previously specified, the result is implementation-defined. If the result cannot be represented in the integer type, the behavior is undefined. The result need not be in the range of values of any integer type.

So the code could look as follows:

int main(int argc, char *argv[]) {
    int a =10;
    int *p = &a;
    p  = &a;

    unsigned long long addrAsInt = (unsigned long long)p;

    printf("the adress of a is %llu \n",addrAsInt);
    printf("the adress of a using the pointer is %p \n",(void*)p);
}

Answer 4

If you want to see the pointer as a decimal integer, cast it to unsigned long and print it with %lu format. While this isn't guaranteed by the standard, it should work in most implementations.

printf("the address of a is %lu\n", (unsigned long)&a);