Wonder said:
Keith said:
Note that we considered this conversion rule in two different
contexts. For p, the prefix to the indexing operator, the rule
doesn't apply, because p is already a pointer (to an array of 3 ints).
For p[0], an array of 3 ints, the rule does apply, and it's converted
to a pointer-to-int.
In fact, after reading your program and explain, I doubt the compiler
just output the address of a pointer points to, no matter you are using
p or &p. The following program can prove it:
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p = NULL;
p = malloc(sizeof *p);
if (p == NULL)
{
exit(EXIT_FAILURE);
}
*p = 10;
printf("p=%p\n", (void*)p);
printf("&p=%p\n", (void*)p);
ITYM:
printf("&p=%p\n", (void*)&p);
printf("*p=%d\n", *p);
free(p);
return 0;
}
It can be compiled by gcc on Linux, and the output is:
p=0x8049678
&p=0x8049678
Which will be different with the code correction above applied.
*p=10
In the second printf, we apply the "&" (address-of) operator to p[0].
This is one of the contexts in which the conversion to pointer
*doesn't* take place. (Another is the operand of the sizeof
operator.) So &p[0] is the address of an array-of-3-ints. p[0] and
&p[0] have different types, but they yield the same raw pointer value
when converted to void* and printed with "%p".
Could you explain in which contexts such conversion doesn't take place?
An array "decays" into a pointer, except when it is the operand of the
address operator & or the sizeof operator. (Another exception are
string literals used to initialize arrays.) Consider:
int arr[42];
arr /* arr is converted to a pointer to its first element, the
type of the expression is pointer-to-int. */
arr[1] /* arr is again converted, the value of the expression is
*(arr+1), its type is int. */
&arr /* No conversion of arr, value of the expression is the same
as above (the address of the array equals the address of
its first element). The type however is pointer-to-array.
*/
sizeof arr /* No conversion, value is the size of the array. */
Now back to our original example:
int (*p)[3] /* p is a pointer-to-array-of-three-ints */
p[0] /* Per definition, this is equivalent to: *(p + 0),
which yields an array, which in turn decays into a
pointer to it's first element, a pointer-to-int. */
&p[0] /* Per definition, this is equivalent to (p + 0), a
pointer-to-array-of-three-ints. */
Note that the two latter expressions yield the same value (memory
address), but are of different type!
And in your original program, p[1] actually refers to *another* array
of 3 ints, the second element of the array of arrays-of-3-ints to
which p points. In my version of your program, I only allocated
enough memory for a single array-of-3-ints; if I wanted to play with
p[1], I'd have to allocate more memory.
So, does that mean we have 3 pointers p[0], p[1], p[2], and each one
points
to an array of 3 integers? But we are not defining an array of
pointers, right?
Right, but remember that the array subscription operator [] is nothing
but syntactic sugar for *(p + index). Thus we can use array
subscription on any old object pointer if we like. However, in the
mentioned case, we indeed refer to memory we don't own.
[...] I never use pointers to an array. [...]
A wise decision, since they are hardly useful anyway. ;-)
Best regards
