Isn't A in A[m][n] a pointer(drawing analogy from when we define 2 dimensional matrix using pointers)

Question

A[0] and A[1] are clearly pointers without any doubt which point to respective arrays. But shouldn't A be a pointer as well pointing to A[0] because compileing printf("%d", A) in GCC results in the following error:

format %d expects argument of type int, but argument 2 has type int *

If A is not a pointer then why is it considered a pointer when defining 2D matrix using pointers.

Moreover, printf("%d", *(A+1)[0]); works pretty fine implying that A is rendered as a pointer. And if that is the case printf("%d", A) should print the address of A[0] but it shows compilation error.

Answer 1

This question boils down to whether or not arrays are pointers, which is not the case. See this question: Arrays are Pointers?.

When you use

int arr = {1, 2, 3, 4};
int *p = arr;

arr is converted from an array of ints to a pointer to an int. It is the same as doing.

int *p = &arr[0]

The same is happening with

printf("%d", A)

Which is why the compilers gives you the message, but this can be confusing and might lead one to think that pointers and arrays are indeed the same.

Answer 2

There are many different ways to create so-called 2D matrices of int, each defining a very different type of object:

1. as an array of arrays of int:

   int A[ROWS][COLS] = { 0 };
   

2. as an array of pointers to arrays of int:

   int *A[ROWS];
   for (int i = 0; i < ROWS; i++)
       A[i] = calloc(sizeof(int), COLS);
   

3. as pointer to an array of arrays of int:

   int (*A)[COLS] = calloc(sizeof(*A), ROWS);
   

4. as a pointer to an array of pointers to arrays of int:

   int **A = calloc(sizeof(*A), ROWS);
   for (int i = 0; i < ROWS; i++)
       A[i] = calloc(sizeof(int), COLS);
   

In all cases, the syntax to access the matrix elements is the same: A[row][col], or any of the equivalent pointer notation variants:

    *(*(A + row) + col)
    *(A[row] + col)
    (*(A + row))[col]

In all cases, A, and A[row] can be used where a pointer is expected, either because they are indeed pointers (cases 3 and 4) or because arrays (cases 1 and 2) decay to a pointer to their first element when used in an expression context (except as an argument to sizeof), such as when passed as an argument to printf.

Printing pointer values with printf requires the %p conversion format.

%d expects an int, which is not the same as a pointer, may have a different size and may be passed to printf differently, all causing undefined behavior. The compiler emits a very useful warning about this. It is a good idea to configure the compiler with as many warnings as possible to detect silly mistakes.These warnings are sometimes difficult to understand, but are almost always an indication of something that needs fixing.

You can use printf("%p", (void*)A) which is equivalent to printf("%p", (void*)&A[0]) and printf("%p", (void*)A[0]), equivalent to printf("%p", (void*)&A[0][0]). All 4 should print the same address.