Pointer of pointer: &foo == foo?

Question

#include <cstdio>

typedef struct {
  int a;
  int b;
  int c;
} Foo;

int main() {
  Foo foo[42];
  printf("foo = %p\n", foo);
  printf("&foo = %p\n", &foo);
  return 0;
}

When I compile this program with g++ and run it, it produces the following output.

foo = 0xbf8caea8
&foo = 0xbf8caea8

This is not what I expected. When I derefence foo, I would expect to get the value of foo[0].a and when I dereference &foo, I would expect to get a pointer on foo[0].a.

How can these two pointers be equal?

Google for *arrays versus pointers in C++*. An array *decays* to a pointer. — Basile Starynkevitch, Aug 14 '14 at 09:42
*What* dereference? To dereference a pointer you would use the dereference operator `*`. — Some programmer dude, Aug 14 '14 at 09:45
I know that arrays are stored as pointers, so `foo` is basically of type `Foo*`. In my understanding, `&foo` should be of type `Foo**` and therefore foo != &foo. — MBober, Aug 14 '14 at 09:47
@MBober Arrays are *most definitely **not*** stored as pointers. A pointer is an address (typically 4 or 8 bytes). An array is a sequence of objects. In C and C++, arrays *decay* to pointers - an array can be implicitly converted to a pointer to its first element. — Angew is no longer proud of SO, Aug 14 '14 at 09:49
Thanks everyone. http://stackoverflow.com/a/2528999/990968 answered my question. I just wasn't able to find it using the SO search. Sorry. — MBober, Aug 14 '14 at 10:03

score 1 · Accepted Answer · answered Aug 14 '14 at 09:50

Think of them as addresses rather than pointers, because &foo there for example is not a pointer, rather just the address of the foo variable.

What does the foo variable stand for?

It stands for the array of Foos you've declared. This array starts from a point in memory, exactly where the first element of the array starts, logically.

Think of a chain in real life. The whole chain starts from the exact same location as the flrst bit of chain starts. Their sizes are different, but both originate from the same location in space.

The case is just like that for arrays. &foo is where the whole chain starts, &foo[0] - which is what foo is - starts from that same location.

My problem was that I thought that `foo` always decays to a pointer to `foo[0]`. I wasn't aware of the fact that this is true **unless `foo` is an operand of unary operator `&`** (or `sizeof`). — MBober, Aug 14 '14 at 10:06

Pointer of pointer: &foo == foo?

1 Answers1