2

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.

Improve this question
6
  • 2
    First of all - what is the point of decimal value of an address? Commented Jan 17, 2018 at 20:02
  • 1
    "%d" works with int. It may not work with &a. Suggest printf("%p\n",(void*) &a); Commented Jan 17, 2018 at 20:02
  • To print address of pointers, you should use %p. Forget the decimal interpretation of pointers, the hexadecimal representation is far superior. Commented Jan 17, 2018 at 20:03
  • later i will try to manipulte the tab variable , and i will test if every cell in the tab is 4 byte , so may be i wiill 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 . Commented Jan 17, 2018 at 20:04
  • 1
    @zakzak The output format of %p is implementation defined, but it is defined. You code gave decimal output, but not necessarily correct output. Your goal seems to wants any simple decimal output and not necessarily correct decimal output. Commented Jan 17, 2018 at 20:26

4 Answers 4

Reset to default
10

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.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

5

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).

Improve this answer

Comments

4

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); }
Improve this answer

3 Comments

I would use unsigned long long above instead of uint64_t, even if they are usually the same.
Why not #include <stdint.h> and use size_t? Seems preferable to either uint64_t or unsigned long long. size_t may well be the same as either of those but uint64_t is very likely to be the same as unsigned long long while size_t is merely likely to be the same.
@SoronelHaetir size_t may be as small a uint16_t. Converting to a wide type like unsigned long long or uintmax_t, which are both at least 64-bit, reduces the chance of information loss.
3

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);
Improve this answer

3 Comments

your solution worked for me , i would prefere this because it's simple. i have to thank every One .
@zakzak It is simple - and with pointers wider than long, may provide confusing results.
chux's answer is the right one, don't prefer simple answers to right answers...

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.