Why pointer to pointer is a matrix? [closed]

Answer 1

Why pointer to pointer is a matrix?

This is not true for every case.

A pointer can also be a pointer to a single element and and therefore a "pointer to pointer" can also be a pointer to a single pointer which points to a single element.

A pointer to pointer only is a valid (dense) "matrix", if

1. it's an array of pointers,
2. each of which points to an array of elements,
3. with each element array having the same size.

(If this is about C++: Don't use pointer-to-pointer syntax at all but stick to a 1d representation something like this instead.)

Answer 2

Because of opeator [] inline implementation. a[b] actually is *(a + b)

So the first [] chooses the row and the second chooses the column. So it is arr[m][n] the same as stepOne = *(arr + M) where M = m * n and stepTwo = stepOne[n],

which is the same as *(stepOne + n). So after this chain we see what arr[m][n] is the same as *(arr m*n + n)

To confirm what is true you can check this short program

int main()
{
    char arr[10][15];
    std::cout << sizeof(arr) << std::endl;           //150
    std::cout << sizeof(*arr) << std::endl;          //15
    std::cout << sizeof(arr[0]) << std::endl;        //15
    std::cout << sizeof(*arr[0]) << std::endl;       //1
    std::cout << sizeof(**arr) << std::endl;         //1
    std::cout << sizeof(arr[0][0]) << std::endl;     //1

    std::cout << arr << std::endl;                    //some number
    std::cout << arr+1 << std::endl;                  //some number + 15
    std::cout << &arr << std::endl;                   //some number
    std::cout << &arr+1 << std::endl;                 //some number + 150

    return 0;
}



                +---+---+---+---+---+---+---+
This is matrix: | E |   |   |   |   |   |   |
                +---+---+---+---+---+---+---+
                |   |   |   |   |   |   |   |
                +---+---+---+---+---+---+---+
                |   |   |   |   |   |   |   |
                +---+---+---+---+---+---+---+
                |   |   |   |   |   |   |   |
                +---+---+---+---+---+---+---+
                |   |   |   |   |   |   |   |
                +---+---+---+---+---+---+---+
                |   |   |   |   |   |   |   |
                +---+---+---+---+---+---+---+

I marked entry letter E. Lets say this is int M[6][7]. So lets go reverse way.

1. &M - pointer to matrix. If you increase or decrease it by one you will get on some other data, this is bad... because sizeof(M) is the same as sizeof(int) * 7 * 6
2. &M[0] pointer to the first row of matrix. If you increase it you will go to the next row, because sizeof(M[0]) is equals to sizeof(int) * 7.
3. So to get pointer to entry you need to do &(M[0][0]) and sizeof(M[0][0]) is equals to sizeof(int).

So to make a graph out of all this:

           +---+---+---+---+---+---+---+
M[0] ----> | E |   |   |   |   |   |   |
           +---+---+---+---+---+---+---+

                +---+
M[0][0]  ---->  | E |
                +---+

I hope graph help because I'm not so good in explaining this stuff...

BTW One more thing, pointer to pointer not always a matrix.