Why does a pointer behave like this in c++

Question

I found this program in a contest question paper:

#include <iostream>
void main() 
{    
    int a[5] = { 1, 2, 3, 4, 5 };
    int *ptr = (int*)(&a + 1);
    printf("%d %d ",*(a + 1), *(ptr - 1));
}

The output is 2 5

now when I change the 5th line to int *ptr=(int*)(&a); and printf("%d %d ",*(a + 1), *(ptr));

The output becomes 2 1

In the first case the ptr got the last address of the array+1 and in the second case the ptr got the same address of the array(address of a).

My doubt is why does this assignment show different kind of behavior when the a is incremented and assigned to ptr and when a is assigned to ptr without incrementing?

Answer 1

When you take the address of the array, you get a pointer to an array of 5 ints (that is, int(*)[5]). When you increment that pointer, it moves by the size of an array of 5 ints. So it points to the next array in a sequence of arrays (if you actually had a sequence of arrays). Then when you convert that pointer to int*, it becomes a pointer to the first int of the second (non-existent) array, which is one element after the last element of the first array. So that's what is happening with your first example.

With your second example, you are not incrementing the pointer to the array, so when you convert it to int*, it becomes a pointer to the first int in the array.

Answer 2

&a is a pointer to an integer array of size 5, while ptr is an int*. Thus, &a + 1 increment by the size of an int[5], while pointer arithmetic on an int* changes the value of the pointer by multiples of sizeof(int). Thus, &a + 1 is pointing to the address which is 5*sizeof(int) from the address of a. Casting this to an int* ptr and doing ptr-1 gives you the address of a[4].

Answer 3

&a + 1;

Here, simple a refers to the base address of array i.e address of first element. When you say a+1 compiler will see +1 applied to pointer to an int. So, it would increment by offset which would make it jump to next integer.

However, when you say &a, it means address of that array element ( which is of type int [5]). So, adding one to it means that next offset would be to next array of that type i.e indirectly to one-past end of array. Taking address of one-past-array element is no problem until you don't dereference it.