I was asked this question as a class exercise:
int A[] = {1,3,5,7,9,0,2,4,6};
printf("%d\n", *(A+A[1]-*A));
I couldn't figure it out on paper, so went ahead to compiling a simple program and tested it and found that printf("%d",*A) always gives me 1 for the output.
But I still do not understand why this is the case, hence it would be great if someone can explain this.
A is treated like a pointer to the first element of array of integers. A[1] is the value of the first element of that array, which is 3 (indexes are 0-based) *A is the value to which A points, which if the zeroth element of array, so 1. So
A[1] - *A == 3 - 1 == 2
Now we have
*(A + 2)
That's where pointer arithmetic kicks in. Since A is a pointer to integer, A+2 points to the second (0-based) item in that array and *(A+2) gets its value. So answer is 5.
Also please note for future reference that pointer to an integer and array of integers are somewhat different things in C, but for the purposes of this discussion they are the same thing.
A is an array, not a pointer.
+ and - are left-right associative; it is (A + A[1]) - *A, not A + (A[1] - *A). In this case it happens those are equivalent but in general that may not be so.Break it down into its constituent parts:
A by itself is the memory address of the array, which is also equivalent to &A[0], the memory address of the first element of the array.
A[1] is the value stored in the second element of the array, which is 3.
*A dereferences the memory address of the array, which is equivilent to A[0], the value stored in the first element of the array, which is 1.
So, do some substitutions:
*(A+A[1]-*A)
= *(A+(A[1])-(A[0]))
= *(A+3-1)
= *(A+2)
The notation *(Array+index) is the same as the notation Array[index]. Under the hood, they both take the starting address of the array, increment it by the number of bytes of the array element type (in this case, int) multiplied by the index, and then dereference the resulting address. So *(A+2) is the same as A[2], which is 5.
sizeof or unary & operators.E1[E2] is defined to be equivalent to *((E1) + (E2))+ and - operator used to pointers will move the pointer forward and backward.In this case, *A is equivalent to *(A + 0), which is equivalent to A[0] and it will give you the first element of the array.
The expression *(A+A[1]-*A) will
1, via AA[1] (3) elements ahead via +A[1], so the pointer now points at 7*A (1) element before what is pointed via -*A, so the pointer now points at 5* operator, so the expression is evaluated to 5
(...) are evaluated where A[1] (+3) and -*A (-1) are added to pointer A before being dereferenced. So the pointer doesn't move, you effectively add 2 to it before dereference. Or, is there another pointer being moved?An array variable in C is only the pointer to the initial memory location for the array. So if you derreference the array, you will always get the value for the first position.
If you sum up 1 to the original array value, like *(A+1) you will get the second position.
You can get any position from the array using the same method:
*(A) is the first position
*(A+1) is the second position
*(A+2) is the third position
and so on...
If you declare the int array as int* A and allocate the memory and attribute the values, it is usually easier to visualize how this works.
1is fromprintf("%d\n", *A), which is what you'd expect, I believe. The original code would produce5, though. The question is misleading.