Dereferencing a pointer to an array?

Question

Referring to the line with the comment:

• Why does adding parenthesis in the example work to print all the contents of the array?

The example prints "one", then prints garbage.

#include <iostream>

int main() {
    const char* a[3] = { "one", "two", "three" };
    const char*(*p)[3] = &a;
    for(int i = 0; i < 3; i++) {
        std::cout << *p[i] << std::endl; // this line
    }
    return 0;
}

It works after changing to this:

std::cout << (*p)[i] << std::endl;

Answer 1

p is a pointer to an array of 3 elements like this:

┌─────┬─────┬─────┐
│     │     │     │
└─────┴─────┴─────┘
   ^
   └─ p

Note that it points at the whole array, not a single element of it.

The expression *p[i] is treated as *(p[i]) due to operator precedence (which is equivalent to *(*(p + i))). This means that you are indexing the pointer to the array. If you do p[1], for example, you move the pointer along to the "next" array and attempt to dereference it:

┌─────┬─────┬─────┐
│     │     │     │
└─────┴─────┴─────┘
                     ^
                     └─ p + 1

As we can see, there is nothing there, and you'll get undefined behaviour. However, when you do (*p)[i] (equivalent to *((*p) + i)), you are making sure the dereference happens first. The dereference gives us the array itself, which can then be implicitly converted by array-to-pointer conversion to a pointer to the arrays first element. So what you get is:

┌─────┬─────┬─────┐
│     │     │     │
└─────┴─────┴─────┘
   ^
   └─ *p

In this case, the pointer is pointing at the array element and not the whole array. If you then index, for example, (*p)[1], you'll get:

┌─────┬─────┬─────┐
│     │     │     │
└─────┴─────┴─────┘
         ^
         └─ (*p) + 1

This gives you a valid const char* which can then be outputted by cout.

Answer 2

Operator precedence.Without () operator [] will be called first and result of it will be dereferenced. With () - firstly will be dereference and then call to operator [].