Can a pointer ever point to itself?

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 c

Answer 1

Yes, a pointer can point to itself as mentioned in the answers.

A possible use case is we can use this trick in lieu of NULL pointers. You can initialize int * p = (int *)&p, and check this later to see if the pointer is valid or not. This could have been used if say in a system where we wanted 0x0 and the entire address range to be valid addresses.

You can also use this trick in special C programs which would not crash on NULL pointer usage because you would avoid them altogether and on dereference system will not crash. It will lead to erroneous behavior but it may help debugging in certain situations.

Answer 2

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.

Answer 3

void* p = &p;

It's not terribly useful, but structs that point to themselves are useful in circular lists of length 1:

typedef struct A {
  struct A* next;
} A;

A a = { &a };

Per your exact example, I believe you meant:

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

// which can be simplified to:
int* a = (int*)&a;

Answer 4

Dereferencing a pointer results in a value of its value type (e.g. dereference an int* gives you an int, an int*s value type). For a variable to point to a pointer its value type would have to be int*, which is not the case for an int* as previously stated. So for a pointer to point to itself one would have to do some kind of cast in order to get it by the compiler:

int* a;
a = reinterpret_cast<int*>(&a);

To dereference a, then, you would have an int whose value happens to be the address at which a is located (mod truncation of the address to fit the type), but it is still an int and not an int*, which would require another cast.

A pointer to a pointer is often known as a handle, which is a different type (int**) than a pointer (int*). (Note that an int** handle has value type int*.)

Answer 5

Well, first I'd change the code around:

int **a;
a = (int **)&a;  // otherwise you get a warning, since &a is int ***

I'm not sure why you would do this, but it is allowed.

printf("The address of a is %p\n", &a);
printf("a holds the address %p\n", a);
printf("The value at %p is %p\n", a, *a); // the *a is why we made a an int **

They should print out the same thing.

The address of a is 0x7fffe211d078
a holds the address 0x7fffe211d078
The value at 0x7fffe211d078 is 0x7fffe211d078

Note that this is not a good idea, as that very first cast a = (int **)&a is a hack to force a to hold a value that it shouldn't hold. You declare it an int ** but try to force an int *** into it. Technically the sizes are the same, but in general don't do that because people expect that an int * holds the address of something that can be used as an int, an so on.

Answer 6

Yes, it is possible to point to itself.

int* a;
a = &a;

But not have any use, at least explicitly like this.