C Pointers Past Paper - c

Question

I'm looking at a past paper for a course I'm doing at university, and there is always a question about C pointers.
I reckon I have a reasonable grasp of how they work, however this is the question that is confusing me:
Consider running the C program fragment:
int x[4] = {0,2,4,6};
int *y;
y = &x[2];
*(x + 2) = y[1] + 1;
What is the value of the expression *y afterwards?
(a) 2
(b) 4
(c) 5
(d) 7
(e) 8
Now, in the answers to said question, it says the answer is d.
I'm super confused, seeing as:
The value of x is not declared, so I'd have thought it would be impossible to evaluate x+2
y isn't an array, so how can y[1] be evaluated?
Why is 7 the correct answer here?

Answer 1

x is the 4-element array. *x references the first element in that array, and *(x + 2) references the 3rd element.
*y points at index 2 (3rd element) in the x array (y = &x[2])
the final assignment sets the 3rd element of the original x array ( *(x + 2) ) to the value of y[1] + 1. since y is initialized to point at the 3rd element, y[1] will point at the final element of the original x array.
6 + 1 is assigned to the 3rd element of the x array, which *y refers to.

Answer 2

Things to note:
*(x + 2) is exactly the same as x[2].
&x[2] is exactly the same as &(*(x + 2)) which is the same as x + 2.
So knowing that, let's rewrite the problem:
int x[4] = {0,2,4,6};
int *y = &x[2];
*(x + 2) = y[1] + 1;
And some more rewriting:
int x[4] = {0,2,4,6};
int *y = x + 2;
x[2] = *(y + 1) + 1;
Now, let's substitute y directly into the last equation:
int x[4] = {0,2,4,6};
int *y = x + 2;
x[2] = *((x + 2) + 1) + 1;
And clean it up:
int x[4] = {0,2,4,6};
int *y = x + 2;
x[2] = x[3] + 1;
So now, let's look at the problem:
x[2] is updated with the value of x[3] + 1
So x[2] is now 7.
So x == {0, 2, 7, 6}
y still points at the value at x + 2.
So *y == 7

Answer 3

Lets break it down:
int x[4] = {0,2,4,6};
x [0] = 0
x [1] = 2
x [2] = 4
x [3] = 6
int *y; Pointer to an integer so y could point to any location in x
x [0] = 0 // <-- y ?
x [1] = 2 // <-- y ?
x [2] = 4 // <-- y ?
x [3] = 6 // <-- y ?
y = &x[2]; Now we have specified that y points to x[2]
x [0] = 0
x [1] = 2
x [2] = 4 // <-- y (or y[0])
x [3] = 6
*(x + 2) This is the same as x[2] so:
x[2] = y[1] + 1;
x [0] = 0
x [1] = 2
x [2] = 4 // <-- x[2]
x [3] = 6 // <-- y[1]
y[1] is 6, so y[1] + 1 = 7
Note that y[1] is the same as *(y + 1). We take the address y points too, add to it the size of one integer and obtain the contents of what it now points to.

Answer 4

Let consider the code step by step.
Pointer y is initialized by the address of the third element of the array (indices start from 0)
y = &x[2];
So y points to 4. So x[2] and y[0] are equivalent expressions
y[1] is the next element after y[0] that is it is 6.
y[1] + 1 will be equal to 7
*( x + 2 ) is the same as x[2] So x[2] will be set to 7. At the same time y also points to
x[2]. So *y will be equal to 7.

Answer 5

The key components here are that the index operator returns y1 an actual int not an address. The same for the dereference operator *(x + 2).
int a = y[1]; // a = the value of the int after y[0]
int b = *(x + 2); // b = the value of x[2] note that the index operator is just shorthand, y[1] just means *(y + 1)
// int* c = y[1]; NOT LEGAL assignment of an int to an int*
// int* d = *(x + 2); NOT LEGAL assignment of an int to an int*
I've added a table here to hopefully help clarify: