Question

My question is: If a pointer variable has the same address as its value, is it really pointing to itself?

For example – in the following piece of code, is a a pointer to itself?

#include<stdio.h>

int main(){
   int* a;
   int b = (int)&a;
   a = b;
   printf("address of a = %d\n", &a);
   printf("  value of a = %d\n", a);
}

If a is not a pointer to itself, then the same question poses again: Can a pointer point to itself?
Also, how is a self pointing pointer useful?

Answer 1

What you’re actually doing there is not having the pointer point to itself. You are using the memory space allocated for the pointer to store the location of the pointer. A pointer to an int points to ints – never to other pointers to ints, including itself.

For example, let’s say you create a pointer a:

int * a;

It gets its own spot in memory:

   4     a (5)    6
[....][00000000][....]

In this simple example, let’s say a is at memory location ‘5’.

If you were to do this:

a = (int*)&a;

…the following would happen:

   4     a (5)    6
[....][00000005][....]

What’s happening here is that a is pointing to what it thinks is an integer at location 5. This also happens to be the same memory location that &a is pointing to, but in the context of what a is pointing to, it’s now pointing to the integer at location 5 – and that integer is 5.

For example both of these would work:

cout<<(int)a;//outputs 5
cout<<*a;//Outputs the integer at memory location 5 - which is 5.

If you wanted to create a pointer to a, you most definitely could – either of these ways:

int **b = (int**)a;

or

int ** b = &a;

But it’s very important to realize that a isn’t a pointer to itself. It’s a pointer to the integer at the location it stores – which just happens to be the same as its own location.

---

To further show (through an even simpler example) what’s going on, something similar could happen with an int. That is, you can store the memory location of an int within itself:

int a=999;

a now has a location in memory, and has a value of 999 (we’ll pretend it’s been placed in the memory location ’46’):

  45     a (46)   47
[....][00000999][....]

It’s in the location ’46’ – if we wanted, we could store this number as an integer within a:

a=(int)&a;

  45     a (46)   47
[....][00000046][....]

and now a is equal to &a in value, but not in type – a is just an integer, it doesn’t point to itself magically now just because we used it to store its own memory location.