different way to represent to a pointer to an array

Question

I have read the pointer to array c++ and have some experiment on it.

#include <iostream>
using namespace std;
int main()
{
    int g[] = {9,8};
    int (*j)[2] = &g;
    int *i = g;

    int n = (*j)[0];
    int m = *(i + 0);
    cout << "n:" << n << endl;
    cout <<"m:" << m << endl;
    cout << "=============" << endl;
    cout << "*(j):" << *(j) << endl;//9's address ???
    cout << "j:" << j << endl;//9's address ???
    cout << "&j:" << &j << endl;//what it is???
    cout << "&(*j)" << &(*j) << endl;//9's address ???
    cout << "=============" << endl;
    cout << "*(i):" << *(i) << endl;//get the value pointered by i
    cout << "i:" << i << endl;//i's value store g's address
    cout << "&i:" << &i << endl; //i's address
    cout << "&(*i):" << &(*i) << endl;//9's address
    cout << "=============" << endl;
    cout << "*(g):" << *(g) << endl;//get the value pointered by g
    cout << "g:" << g << endl;//g's value store 9's address
    cout << "&g:" << &g << endl;//9's address???
    cout << "&(*g):" << &(*g) << endl;//9's address
    return 0;
}

The result is :

n:9
m:9
=============
*(j):0x7fff56076bbc
j:0x7fff56076bbc
&j:0x7fff56076bb0
&(*j)0x7fff56076bbc
=============
*(i):9
i:0x7fff56076bbc
&i:0x7fff56076ba8
&(*i):0x7fff56076bbc
=============
*(g):9
g:0x7fff56076bbc
&g:0x7fff56076bbc
&(*g):0x7fff56076bbc
[Finished in 0.3s]

What I want to ask is:

1.Why

    int (*j)[2] = &g;
    int *i = g;

if I change either one &g to g, or g to &g, it will give a compile error, what is the difference?

(I think that the array name is a pointer, so why cannot I use int (*j)[2] = g and what is the meaning of &g, it is a pointer already, why get address again?)

2. Since the &g and g, their address are the same, why cannot be exchanged?

3. Why the &g's value is 9's address? Is it store its own address?

4. Can you explain the j variable part? I cannot understand why j stores the 9's address and *(j) gets the 9's address, &(*j) gets the 9's address too?

I am very confused about it now. What I totally understand is about the i variable part, g variable part is confused about the &g, and the j varialbe part is all confused. The int (*j)[2] = &g; part is confused too.

Answer 1

1. g is the variable (in this case array), &g is the address of the variable (in this case the address of the beginning of the array. You might understand that, but the compiler does not, and thus it's giving you an error.

2. They probably could be exchanged, if you were willing to do type-casting, but that's not a really good idea in this case.

3. Because g is the array of integers, and the address of the first (0-th) element of that array just happens to be the address of the whole array. Doesn't it make sense?

4. j in your case is a pointer to the array, of course it is also a pointer to the address with the 0-th element of that array (by definition)

Answer 2

(*j)[2] is pointer to array of 2 integers. In other words it is (almost) equivalent with pointer to pointer to ints. The line int (*j)[2] = g; tries to assign int* to (int**) which is a type mismatch. The line int *i = &g; tries to assign int** to int* which is again a type mismatch.

(I think that the array name is a pointer, so why cannot I use int (*j)[2] = g and what is the meaning of &g, it is a pointer already, why get address again?)

The address of what? In its type checking C++ distinguishes address of variables of different types, so even though int* and int** are both addresses (pointers) they point to different types.

Answer 3

You can have a look at this post to understand why g and &g hold the same address:

How array name has its address as well as its first element in it?

The compiler complains when you change either of g to &g because there is a type mismatch. This means that semantically, g and &g have different meanings, even though they may refer to the same thing: g, when used in an expression, decays into pointer to int (int *), but &g is of type pointer to array of 2 ints. These are not compatible types; you can't assign a pointer to an array of ints to something that is a pointer to int (and the same happens the other way around).

Your claim that g is already a pointer is wrong: g is an array. When used in an expression, it decays into a pointer to the array's first element. A pointer is just something that holds an address; an array is an address (the address of its first element). With &g, you get a pointer to an array, you don't get pointer to pointer because arrays do not decay into pointers when the referencing operator is used. Think of it like this: if an array is an address, then applying the "address of" operator - & - yields this same address, which is, by convention, the address of the first element. When you don't apply the & operator, in an expression, the array decays into a pointer to the first element, and then again - it points to the first element, the same address as &g.