Why can't i assign the name of a 2d array to a 2d pointer?

Question

Practicing some simple arrays and pointers basics, I met something I can't understand:

in all written sources I could find, they say that a name of a 2D array is actually a 2D pointer, meaning that if I write:

int a[3][4];

and also declare a pointer:

int **d2;

both of them are of the same type and I can safely assign:

d2 = a;

making the pointer point to the beginning of the first line.

But most surprisingly, that doesn't work, and my question is-why?

I would copy for you the code and the warnings I am getting:

#include <stdio.h>

int main() {
    int **d2;
    int a[5][2] = { {1, 2}, {3, 4}, {5, 7}, {7, 8}, {9, 11} };

    d2 = a;
    while (d2 < a + 2) {
        printf("%d", **d2);
        d2++;
    }
    return 0;
} 

I get this diagnostic:

warning: assignment from incompatible pointer type [-Wincompatible-pointer-types]
  d=a;
   ^

ptr.c:11:9: warning: comparison of distinct pointer types lacks a cast
  while(d<a+2)

Answer 1

They have totally different inner structure, so they are not interchangeable.

2D array

2D array is like this:

p[3][3]
|
v 
+---------+---------+---------+---------+---------+---------+---------+
| p[0][0] | p[0][1] | p[0][2] | p[1][0] | p[1][1] | p[1][2] |   ...   |
+---------+---------+---------+---------+---------+---------+---------+

A single continuous space.

Pointer

pointer is like this:

**p
|
v 
+------+   +---------+---------+---------+---------+---------+
| p[0] |-->| p[0][0] | p[0][1] | p[0][2] | p[0][3] |   ...   |
+------+   +---------+---------+---------+---------+---------+
| p[1] |-->| p[1][0] | p[1][1] | p[1][2] | p[1][3] |   ...   |
+------+   +---------+---------+---------+---------+---------+
| p[2] |-->| p[2][0] | p[2][1] | p[2][2] | p[2][3] |   ...   |
+------+   +---------+---------+---------+---------+---------+
| .... |
+------+

Where every p[i] may pointing to difference space with different size.

Answer 2

int **d2 defines a pointer to a pointer to an int. You can also think of it as a pointer to an array, and each array element contains a pointer to an int. Zang MinJie's answer shows this nicely.

An array int a[3][4]; is a contiguous block of memory, so equivalent to int a[3*4];. As you see, it is not an array of pointers to the rows.

Note that the compiler knows when you work with a contiguous array and with an array of pointers, and uses the correct indexing method. For example:

void f(int **d2)
{
    printf("%d", d2[3][4]);
}
void g(void)
{
    int a[5][2] = { {1, 2}, {3, 4}, {5, 7}, {7, 8}, {9, 11} };

    printf("%d", a[3][1]);
}

As you see, the way to write the index expressions is the same, even though the underlying representations are completely different. I can understand that is confusing. Just remember that "the compiler knows".

Answer 3

int **d2; is not a 2D pointer, it is a pointer to a pointer to int, sometimes called a double pointer.

int a[3][4]; defines an array of 3 arrays of 4 int, also called a 2D array.

These 2 objects have incompatible types: there is no int pointer variable here, the address of which could be stored into d2.

Let's take an analogy:

• an int is like a house with 32 rooms;
• a street is an array of houses;
• a block is a group of contiguous streets;
• a pointer is an entry in an address book with the address of a house;
• a double pointer is a piece of paper where you wrote the location where you stored your address book.

The rows in a 2D array are consecutive in memory, so you can enumerate the entries in the array this way:

#include <stdio.h>

int main() {
    int *p;
    int a[5][2] = { {1, 2}, {3, 4}, {5, 7}, {7, 8}, {9, 11} };

    printf("iterating as a 2D array:\n");
    p = &a[0][0];
    for (int row = 0; row < 5; row++) {
        for (int col = 0; col < 2; col++) {
            printf("%d ", *p);
            p++;
        }
        printf("\n");
    }
    printf("\n");

    printf("iterating as a single array:\n");
    p = &a[0][0];
    while (p < &a[5][0]) {
        printf("%d ", *p);
        p++;
    }
    printf("\n");
    return 0;
}

Output:

iterating as a 2D array:
1 2
3 4
5 7
7 8
9 11

iterating as a single array:
1 2 3 4 5 7 7 8 9 11

Answer 4

This is because int **d2 is a pointer to pointer. There is no such thing as 2d pointer.

For example, lets consider 1d array:

int a[2] = {1, 2};

Now, an integer pointer will point to the first element of the array if assigned as follows:

int *d = a;

Talking about pointer to pointers, a pointer to pointer points to a memory location which holds address of other pointer!

For example,

// This will declare an integer pointer
int *a;

The above pointer will store address of some other variables.

For example, you can assign values to it as follows:

int x = 5;
int *a = &x;

Now, here is what a pointer to pointer does:

A pointer to pointer holds memory address of other pointers.

This means that, in the above example we can declare a pointer to pointer that holds address of pointer a:

int x = 5;
int *a = &x;

// A pointer to pointer
int **b = &a;

// To print value of x using b
printf("%d", **b);

The above code can be understood as follows:

1. a = &x; so *a = *(&x) = 5
2. b = &a; so *b = *(address in b) = *(address of a) = address of x
3. But **b = *(*b) = *(address of x) = 5

Hope this clears your confusion about pointer to pointers.

Now, coming towards your use case, if you want a pointer to point to your 2d integer array, you can just use a pointer and assign it the address of first element of the array. This can be done as follows:

int a[2][2] = {{1, 2}, {3, 4}};

// Declare a pointer that points to first element of array
int *b = &a[0][0];

Now if you want to access the element a[i][j] of this array using pointer, you can access it as b + 2*i + j.

In general, if the dimensions of array is p*q, the element a[i][j] can be accessed using b + q * i + j.

For example, to print the array using 2 for loops,

int rows = 2;
int cols = 3;
int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
int *b = &a[0][0];

for(int i=0; i<rows; i++) {
    for(int j=0; j<cols; j++) {
        // Print a[i][j] using pointer b
        printf("%d ", *(b + cols * i + j));
    }
}

// 1 2 3 4 5 6

You can also use single loop,

int rows = 2;
int cols = 3;
int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
int *b = &a[0][0];

for(int i=0; i<rows*cols; i++) {
    printf("%d ", *(b + i));
}

// 1 2 3 4 5 6