the pointer of the entire array - arrays

Question

int main(){
int a[][3]={1,2,3,4,5,6};
int (*ptr)[3]=a;
printf(" %d",(*ptr)[1]) ;
}
I know that the variable ptr is a pointer of the first 1d array of type int, in other words the variable ptr will store the the address of the first 3 integers, first let's suppose that the base address of a is 1000 so as I think this 2d array will be stored in the memory in this form:
elements: | 1 | 2 | 3 || 4 | 5 | 6 |
addressed of each element: | 1000 | 1004 | 1008 || 1012 | 1016 | 1020 |
---------------------------------||---------------------------------
addressed of each array: 1000 1012
So ptr will store the value 1000 which is the address of the first array. And that means *ptr or (*ptr)[0] will give me the address of the first element, and *ptr+1 or ((*ptr)[1]) will give me the address of the second element and so on.
So as I understand *ptr[1] will give the address of the second element, and not it's value.
But from the output it seem that I am wrong. So I want to know what is the problem in my process.

Answer 1

You are correct until this part:
And that means *ptr or (*ptr)[0] will give me the address of the first element
*ptr will do that. (*ptr)[0] will de-reference the array pointer and then dereference the resulting array, giving you the value of the first item, 1.
Similarly, (*ptr)[1]) will first give you an array and then the second item in that array, 2.
So as I understand *ptr[1] will give the address of the second element, and not it's value.
No, since [] has higher precedence than *, ptr[1] will first give you (the address of) the second array. Then you dereference that and you'll get the the value of the first item in the second array, 4.
The key here is that once you de-reference a pointer to an array, you end up with an array - behaving just like any array would in terms of "array decay" etc.
Best practices:
Do not de-reference array pointers with * if you can avoid it. ptr[0][0] is much less ambiguous. That syntax is the whole point of using array pointers in this case to begin with.
Avoid sloppy initializer lists like int a[][3]={1,2,3,4,5,6};. C allows it but it is bad style and mutes some possibilities of diagnostics. Instead this should have been int a[][3]={ {1,2,3}, {4,5,6} }; which as a bonus is also readable, self-documenting code.

Answer 2

First, it's a good idea to enable compiler warnings. Then you will be informed about missing braces in the initializer. Here is a slightly cleaned up version of your program:
#include <stdio.h>
int main(void)
{
int a[][3] = {{1, 2, 3}, {4, 5, 6}};
int (*ptr)[3] = a;
printf("%d\n", (*ptr)[1]);
return 0;
}
If you run it you will get the output "2". This is because *ptr is the first element of the array a, which itself is an array, and (*ptr)[1] is therefor the second element in this contained array which is 2.

Answer 3

Let's consider the expression used in the call of printf
printf(" %d",(*ptr)[1]) ;
For starters the pointer ptr points to the first element of the type int[3] of the two-dimensional array .
int (*ptr)[3]=a;
That is due to the initializer list
int a[][3]={1,2,3,4,5,6};
the two-dimensional array has two elements of the type int[3].
So dereferencing the pointer *ptr you get an lvalue of the type int[3] that is a one-dimensional array. Then to this array there is applied the subscript operator ( *ptr )[1] that yields the second element of the one-dimensional array.
So the value 2 will be outputted.
And that means *ptr or (*ptr)[0] will give me the address of the first
element
The expression *ptr and ( *ptr )[0] are two entities of different types.The expression*ptryields lvalue of the typeint[3]` , Use din expressions it is in turn can be implicitly converted to a pointer to teh first element of the obtained array.
The expression ( *ptr )[0] yields the first scalar element of the obtained array of the type int.
So as I understand *ptr[1] will give the address of the second
element, and not it's value.
The expression ptr[1] yields the second element of the type int[3] of the two-dimensional array In this expression *ptr[1] the obtained object of the type int[3] is implicitly converted to pointer of the type int * and dereferencing the pointer yields the first element of the type int of the second element of the two-dimensional array.
To make in more clear consider how the subscript operator is evaluated.
For example the expression ptr[0] is equivalent to *( ptr + 0 ) that in turn is equivalent to *ptr.
The expression (*ptr)[1] is equivalent to ptr[0][1].
The expression *ptr[1] is equivalent to *(ptr[1] ) that in turn is equivalent to ptr[1][0].
In general the expression ptr[i][j] can be rewritten in several ways. For example
( *( ptr + i ) )[j]
*( *( ptr + i ) + j )
*( ptr[i] + j )