Difference Between *ptr and *(&ptr + 1)

Question

I am new to pointers and learning basics of pointers. I want to know the difference between *ptr and *(&ptr + 1) from the below code.

#include<stdio.h>
int main()
{
     int a[3] = {1, 2, 3};
     int *ptr = a;

     printf("*ptr = %d\n",*ptr);
     printf("&ptr = %p\n",&ptr);

     printf("(&ptr + 1) = %p\n",(&ptr + 1));
     printf("*(&ptr + 1) = %d\n",*(&ptr + 1));

     return 0;
}       

From my analysis gcc produced the following output,

*ptr = 1    // as ptr = a, Ultimately *ptr will print the first value of array i.e. 1
&ptr = 0x7fffa7e97788   // Starting Address of array or address of first element
(&ptr + 1) = 0x7fffa7e97790   //address of next element in the array
*(&ptr + 1) = 1  // I want to know how this is getting dereffered 

Thanks in Advance.

Answer 1

&ptr is the address of the pointer variable ptr. This address in unrelated to the address of the array.

*(&ptr + 1) is undefined behavior because &ptr + 1 is one step past the address of ptr. Dereferencing such a pointer produces undefined behavior.

What you probably meant was *(ptr + 1).

Answer 2

It seems that the compiler placed defined objects on the stack the following way

--------------------------------
|   ptr   | a[0] | a[1] | a[2] | 
--------------------------------

Thus &ptr is the address where ptr is allocated. &ptr + 1 is the next address after ptr and at the same time it is the address of a[0].

Take into account that it is unspecified in which order the compiler has to place local variables on stack.

Also it seems that in the environment where the program was compiled sizeof( int * ) that corresponds to sizeof( *( &ptr + 1 ) ) is equal to sizeof( int ) and in turn equal to 4. Or sizeof( int * ) is equal to 8 but sizeof( int ) is equal to 4. As you are using format specifier %d in printf for expression *( &ptr + 1 ) then exactly a[0] is outputed.

By the way you can check whether this scheme corresponds to the actual placement of the variables by printing

printf("(&ptr + 1) = %p\n", &ptr + 1 );
printf("(&a[0]) = %p\n",  &a[0] );

If the addresses will not be equal then it means that there is some arbitrary value at the address &ptr + 1 that does not correspond to a[0].

As for the question in the title of your post

Difference Between *ptr and *(&ptr + 1)

then *ptr corresponds to a[0] while using expression *(&ptr + 1) results in undefined behaviour because you are trying to dereference address after ptr.

Answer 3

ptr is a pointer and it points to some valid memory location in your case.

&ptr is the address of your pointer and it can be assigned to a double pointer

int **ptr1 = &ptr; 

Else the address of your first element is given just by ptr.

If you want to parse through your array then have

for(i=0;i<4;i++)
{
printf("Value %d is stored in %p\n",ptr[i],(void *)(ptr+i));
}

(&ptr+1) being dereferenced leads to undefined behavior as this is not the memory which is allocated by you. &ptr is under your control not the location after it i.e. &ptr+1