why does derefrencing a pointer to an array of integers(in 2d array) return(or decay to) pointer to first element?

Question

I have read many posts of pointers and 2d array relation, but I cant seem to understand concept. Lets say there is a 2d array int a[3][2] and an array int b[2].
now a is returning a pointer to array of integers of size 3. It would be of type int (*)[2].

As my understanding of the concept goes derefrencing it(*a) would give me the array itself and this decays to a pointer pointing to first element of the 1d array and is of type (int*) . now the bold part is the doubt.

why and how does this decay happen where the array itself(which is the complete 1d array a[0]) decays to first element of the 1d array?
(cant seem to get the why and how part) and cant seem to find it on other links also.

As a[0], *a,&a[0][0] represent the same pointer. here as a[0] is the first 1d array. then is this true that b(declared above) and a[0] represent the same thing (both being 1d array and then decay to the pointer to first element in array of type (int*)?

Answer 1

why and how does this decay happen where the array itself decays to first element of the 1d array?

C11: 6.3.2.1 p(3):

Except when it is the operand of the sizeof operator, the _Alignof operator ¹,the unary & operator, or is a string literal used to initialize an array, an expression that has type ‘‘array of type’’ is converted to an expression with type ‘‘pointer to type’’ that points to the initial element of the array object and is not an lvalue.

In simple; the array names can be converted to pointer to its first element.

Since a is an array name, it decays to the pointer to its first element which is a 1D array. Its type is int(*)[2]. Since a (after decay) is a pointer to an array of 2 int, *a is an array of 2 ints. Since that's an array type, i.e *a is an array name for the first 1D array, it decays to a pointer to the first element (a[0][0]) of the array object. So, its type is int *.

is this true that b(declared above) and a[0] represent the same thing (both being 1d array and then decay to the pointer to first element in array of type (int*)?

Yes b and a[0] are both of type int * (after decay).

---

_{1. Read the commat by Keith Thompson. Also read this answer which states that: A draft of the C11 standard says that there's another exception for arrays, namely when the array is the operand of the new _Alignof operator. This is an error in the draft, corrected in the final published C11 standard; _Alignof can only be applied to a parenthesized type name, not to an expression.}

Answer 2

The answer to your "why " question is: because the language specification says so. Arrays always decay to pointers to their first elements (aside from a number of specific contexts). So, as you correctly noted *a has type int [2]. This is an array. And since it is an array, it is required by the language to decay to pointer of type int * that points to (*a)[0] (again, with the exception of a few specific contexts). Your original a is an array of type int [3][2] that decays to int (*)[2] pointer. Meanwhile *a is an array of type int [2] that decays to int * pointer. That's why.

As for "how", it is not clear what exactly you are asking about. "Decay" in this case means that in expressions values of array type are implicitly replaced by values of pointer type. That's all there is to it.

And yes, both a[0] and b in your example are arrays of type int [2], which decay identically to pointers of type int *. I.e. they are "the same thing" with regard to decaying behavior.

Answer 3

The rule specifying this conversion is hidden in the C11 chapter 6.3.2:

...an expression that has type "array of type" is converted to an expression with type "pointer to type" that points to the initial element of the array object and is not an lvalue.

Meaning if you have an expression where the array name b of int b[3] is used, it will get converted to a pointer to int, an int*.

This rule is generic. If you have an array int a[3][2], then formally you have a "size 3 array of size 2 arrays of type int". This will get converted to a a pointer to type, which is a "pointer to array of size 2 of type int", int(*)[2].

Note that the "decay" only goes "down" one level, so by using the two-dimensional array name a, you will always get an array pointer and not a pointer to the first element. The difference between an array pointer and a plain int pointer is mainly stylistic, to keep the language consistent. If you print the actual address of the pointer as an integer, it will be the same no matter pointer type.

so as my understanding of the concept goes derefrencing it (*a) would give me the array itself and this decays to a pointer pointing to first element of the 1d array and is of type (int*)

It will give you the array itself, which will decay into an array pointer. It will not decay any further from there, just one level. So *a will not give you a pointer to the first element.

why and how does this decay happen where the array itself decays to first element of the 1d array?

Whenever you use the array name inside an expression it will decay, from "array to type" to "pointer to type". If "type" happens to be an array, you get a pointer to an array.

and one more doubt i had. As a[0], *a, &a[0][0] represent the same pointer. here as a[0] is the first 1d array.

a[0] and *a are equivalent, both gives an array pointer. &a[0][0] is a pointer to int. They have different types but in practice points at the same memory.

Answer 4

Try the following code:

int x[3][10];
printf("%d\n", x[0]);
printf("%d\n", x[1]);
printf("%d\n", x[2]);

Look at the following expression

if(&x[0][9] + 1 == &x[1][0])
    printf("I've entered here");

This evaluates to true... When you add 1 to the pointer it is increasing its address by 4 (or whatever int size your machine has), showing that in memory, element x[1][0] comes right after element x[0][9]

an integer has size 4, you will see that the difference between the prints is 40 (4 * 10) elements...

This array was allocated at compilation time so it already knows how much space it needs and it allocates space for 3*10 integers contiguous, the same way as it would be if it was declared as

 int x[30];

when you use the name x alone what you get is the address of the first element it points to...

The second dimension is just for us programmers... But it comes at a small cost for the compiler... when you access like

 x[1][8];

it has to calculate how much it has to add to the start address to access that element,

which would be (1 * 10 + 8) * SIZE_OF_ARRAY_TYPE (which is int here) ...

In the above expression 1 = the number on the first dimension, multiplied by 10 (number of elements in the second dimension that would be on first row) added to the number of elements in the second []

and if you had a 1 dimension array:

 x[23]

the only account is 23 * SIZE_OF_ARRAY_TYPE (which is int here)

you can also try this IF statement here:

 if(&x[0][10] == &x[1][0])
    printf("I've entered here");

or even assignments such as

x[1][4] = 20;

printf("%d\n", x[0][14]);

Pointers give you a lot of power, but with a great power comes a great responsibility ;)

Answer 5

The array int a[3][2] is stored in memory as 1d array in row major order, so this array:

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

will be stored as:

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

for instance:

#include <stdio.h>
#include <stdlib.h>

int
main(int argc, char **argv)
{
  size_t i;

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

  for(i = 0 ; i < sizeof(a) / sizeof(int) ; i++)
  {
    printf("%d\n", ((int *) a)[i]);
  }

  return 0;
}