Why are `&array` and `array` pointing to the same address?
Until now, I thought an array is the same as a pointer. But I found a weird case:
code
int array[5] = { 10,11,12,13,14};
std::cout << array << std::endl;
std::cout << &array << std::endl;
std::cout << &array[0] << std::endl;
int *pArray = new int[5];
std::cout << pArray << std::endl;
std::cout << &pArray << std::endl;
std::cout << &pArray[0] << std::endl;
output
0x7ffeed730ad0
0x7ffeed730ad0
0x7ffeed730ad0
0x7f906d400340
0x7ffeed730a30
0x7f906d400340
As you can see array
and &array
have the same value. But pArray
and &pArray
have different value. If array is same as pointer, address of array should be different from array.
How can array
and &array
be the same? If array
and &array
are same, what is the address of the memory which holds the array values?
Solution 1:
Plain array
decays to a pointer to its first element, it's equal to &array[0]
. The first element also happens to start at the same address as the array itself. Hence &array == &array[0]
.
But it's important to note that the types are different:
- The type of
&array[0]
is (in your example)int*
. - The type of
&array
isint(*)[5]
.
The relationship between &array[0]
and &array
might be easier if I show it a little more "graphically" (with pointers added):
+----------+----------+----------+----------+----------+ | array[0] | array[1] | array[2] | array[3] | array[4] | +----------+----------+----------+----------+----------+ ^ | &array[0] | &array
As an extra addendum, array
decays to a pointer to its first element, that is array
decays to &array[0]
and will thus have the same type.
Things are different with pointers though. The pointer pArray
is pointing to some memory, the value of pArray
is the location of that memory. This is what you get when you use pArray
. It is also the same as &pArray[0]
.
When you use &pArray
you get a pointer to the pointer. That is, you get the location (address) of the variable pArray
itself. Its type is int**
.
Somewhat graphical with the pointer pArray
it would be something like this
+--------+ +-----------+-----------+-----------+-----------+-----------+-----+ | pArray | ----> | pArray[0] | pArray[1] | pArray[2] | pArray[3] | pArray[4] | ... | +--------+ +-----------+-----------+-----------+-----------+-----------+-----+ ^ ^ | | &pArray &pArray[0]
[Note the ...
at the end of the "array", that's because pointers retains no information about the memory it points to. A pointer is only pointing to a specific location, the "first" element of the "array". Treating the memory as an "array" is up to the programmer.]
Solution 2:
An array of X's has to behave like a pointer to a contiguous list of X's in memory much like a pointer. However, nowhere is it written where the memory that stores that data is must be it's own address and writablej. In the case of an explicit pointer there is a new allocation for this address (in this case the stack) however for an array, on the stack, the compiler already know where the contents are so no new allocation is needed.
As a consequence, its not safe to treat it as a pointer, without indexing. e.g.:
pArray = nullptr; // This is a memory leak, unless a copy is taken, but otherwise fine.
array = nullptr; // This is will make the compiler upset