Why won't *num show the zeroth element value?

Question

In this code:

#include<stdio.h>
  int main()
  {
    int num[2] = {20, 30};
    printf("%d", num);
    printf("%d", &num[0]);
    return 0;
  }

As far as I know, both the printf statement will print the address of the first element in num because in the first statement, num is a pointer to an int.

But if num is a pointer, then it should also have any address but on printing its address (with printf("%d", &num)), it's showing the address of the first element.

In a 2-D array the whole thing becomes confusing too:

#include<stdio.h>
int main(void)
{
    int num[ ] [2]={20,30,40,50};
    printf("%d",*num);
    return 0;
}

This program is printing the address of zeroth element that is the address of num[0][0]. But why does it do this? Why isn't it printing the value stored in it, since they all have same address(num,num[0] and num[0][0])?

Answer 1

First things first; array variables are not pointers; they do not store an address to anything.

For a declaration such as

T a[N];

memory will be laid out as

         +---+
   a[0]: |   |
         +---+
   a[1]: |   |
         +---+
          ...
         +---+
 a[N-1]: |   |
         +---+

For a 2D MxN array, it will look like

              +---+
     a[0][0]: |   |
              +---+
     a[0][1]: |   |
              +---+
               ...
              +---+
   a[0][N-1]: |   |
              +---+
     a[1][0]: |   |
              +---+
     a[1][1]: |   |
              +---+
               ...
              +---+
 a[M-1][N-1]: |   |
              +---+

The pattern should be obvious for 3D and higher arrays.

As you can see, no storage is set aside for a separate variable a that contains the address of the first element; instead, there is a rule in the C language that an expression of type "N-element array of T" will be converted ("decay") to an expression of type "pointer to T" and the value of the expression will be the address of the first element of the array, except when the array expression is one of the following:

• an operand of the sizeof operator
• an operand of the unary & operator
• an operand of the _Alignof operator (C99 and later)
• a string literal used to initialize an array in a declaration

So given the declaration

T a[N];

all of the following are true:

Expression         Type        Decays to         Value
----------         ----        ---------         -----
         a         T [N]       T *               address of first element, &a[0]
        *a         T           n/a               value stored in first element
        &a         T (*)[N]    n/a               address of the array, which is 
                                                   the same as the address of the
                                                   first element of the array
      a[i]         T           n/a               value stored in the i'th element
     &a[i]         T *         n/a               address of the i'th element
  sizeof a         size_t      n/a               total number of bytes used by the
                                                   array
 sizeof *a         size_t      n/a               total number of bytes used by the
                                                   first element of the array
 sizeof &a         size_t      n/a               total number of bytes used by a 
                                                   pointer to the array 

The expression a has type "N-element array of T"; it is not the operand of the unary & or sizeof operators, so it is converted to a pointer to the first element of the array, amd its value is the address of that element.

The expression &a has type "pointer to N-element array of T"; since a is an operand of the unary & operator, the conversion rule above isn't applied (which is why the expression has type T (*)[N] instead of T **). However, since the address of the array is the same as the address of the first element of the array, it yields the same value as the expression a.

The expression &a[0] has type "pointer to T", and explicitly points to the first element of the array. Again, this value will be the same as the previous two expressions.

For a 2D array

T a[M][N];

all of the following are true:

Expression         Type        Decays to         Value
----------         ----        ---------         -----
         a         T [M][N]    T (*)[N]          address of first subarray, a[0]
        *a         T [N]       T *               address pf first subarray, a[0]
        &a         T (*)[M][N] n/a               address of the array, which is 
                                                   the same as the address of the
                                                   first subarray, which is the same
                                                   as the address of the first element
                                                   of the first subarray.
      a[i]         T [N]       T *               address of first element of i'th
                                                   subarray
     *a[i]         T           n/a               value of first element of i'th subarray
     &a[i]         T (*)[N]    n/a               address of the i'th subarray
  sizeof a         size_t      n/a               total number of bytes used by the
                                                   array
 sizeof *a         size_t      n/a               total number of bytes used by the
                                                   first subarray
 sizeof &a         size_t      n/a               total number of bytes used by a 
                                                   pointer to the array 

Final note: to print out pointer values, use the %p conversion specifier and cast the argument to (void *) (this is the pretty much the only time it's considered proper to explicitly cast a pointer to void *):

printf( "   &a yields %p\n", (void *) &a );
printf( "    a yields %p\n", (void *) a );
printf( "&a[0] yields %p\n", (void *) &a[0] );

Edit

To answer a question in the comments:

num,num[] and num[][] are all different thing. There types are different.Here num decays and became pointer to a pointer and num[] decays and became pointer to int and num[][] is a int. Right?

Not quite.

Assuming a declaration like

int arr[10][10];

then the expression arr will decay to type int (*)[10] (pointer to 10-element array of int), not int **; refer to the table above again. Otherwise you're right; arr[i] will decay to type int *, and arr[i][j] will have type int.

An expression of type "N-element array of T" decays to type "pointer to T"; if T is an array type, then the result is "pointer to array", not "pointer to pointer".

Answer 2

In the second example, num is a 2 dimensional array, or say an array of array. It's true that *num is its first element, but this first element is an array itself.

To get num[0][0], you need **num.

printf("%d\n", **num);

Answer 3

Look how an array looks like:

int num[ ] [2]={20,30,40,50};

is better written as

int num[][2]={{20,30},{40,50}};

It is an array with 2 elements. Those 2 elements are, again, arrays with 2 ints.

In memory, they look like

20    30    40    50

but the difference is that num refers to the whole array, num[0] to the first "part- array" and num[0][0] to the first element of the first array.

They have the same address (because they start at the same place), but they have a different type.

That is, the address is not the only important thing with a pointer, the type is important as well.

Answer 4

Arrays are not pointers actually, though they tend to act in a bit similar way, but not always.

Say you have this array and a pointer:

int a[] = {1, 2, 3};
int i = 19;
int *ptr = &i;

Now here a is equal to &a, but the same is not true, for pointers (ptr is not equal to &ptr).

Now coming to the question:

Consider a single dimensional array:

int arr[] = {11, 19, 5, 9};

Here, this array elements are stored in contiguous memory locations. Say, with starting address 0:

 ---------------------
| 11 |  19 |  5 |  9 |
 ---------------------
0   4     8    12   16

Now when you write name of the array, arr (for this example), you will get the starting address of the 1^st element. Though if you write &arr, then you get the starting address of the whole block(this includes all the elements of the array). Now when you write *arr, you actually get the value inside the 1^st element of this array.

Now consider this 2-dimensional array arr[][4] = {{11, 19, 5, 9}, {5, 9, 11, 19}}:

0   4     8    12   16   -> These are memory addresses
 ---------------------
| 11 |  19 |  5 |  9 | ----> These values represent the values inside each index
 ---------------------
| 5  |   9 | 11 | 19 |
 ---------------------
16   20   24    28   32

Here, when you write the name of the array, as arr, what you get is the address of the 1^st element of this array, which in this case will be address of this 0^th index:

0                           16                32
 ----------------------------------------------
| 0<sup>th</sup> index | 1<sup>st</sup> index |
 ----------------------------------------------

Now when you do &arr, here what you get is the base address for whole of the block, i.e. base address of this:

0   4     8    12   16 
 ---------------------
| 11 |  19 |  5 |  9 | 
 ---------------------
| 5  |   9 | 11 | 19 |
 ---------------------
16   20   24    28   32

Now, if you do *arr, in 1-dimensional array it gives you the value inside the 1^st element, though in 2-dimensional array, the value inside each index is actually one 1-dimensional array, hence you will get the address of this array:

0   4     8    12   16 
 ---------------------
| 11 |  19 |  5 |  9 | 
 ---------------------

Now if you do **arr, that is when you will actually get the value inside the 1^st element, which is 11.

I hope it clears some doubts :-)

EDIT 1:

As brought to my attendtion, by fellow user, it seems there is a bit of a confusion somewhere, though I have explained in detail what is meant by what thingy. But just to justify, for this statement:

Now here __a is equal to &a__, but the same is not true, for pointers (__ptr is not equal to &ptr__).

The types of both a and &a will be different, as already stated, in the answer. If one performs pointer arithmetics, one will able to know that. Try performing a + 1 and &a + 1, how they both react to pointer arithmetics will surely give a good idea.

Considering a 1-dimensional array:

int arr[] = {11, 19, 5, 9};


 ---------------------
| 11 |  19 |  5 |  9 |
 ---------------------
0   4     8    12   16

We cannot do a++, though for a pointer:

int i = 4;
int *ptr = &i;

we can perform ptr++, this will make ptr point to the next memory location.

Answer 5

I think it result means that the array not really a pointer, but it is converted to a pointer in some contexts that is expected a pointer, like pass to a function that expect a pointer argument.

see this code:

void test(int* num) {
     printf("test\n");
     printf("%p\n",num);
     printf("%p\n",&num);
     printf("%p\n",&num[0]);
  }

int main(){
         int num[2]={20,30};
         test(num);
         printf("main\n");
         printf("%p\n",num);
         printf("%p\n",&num);
         printf("%p\n",&num[0]);
         //other();
         return 0;
}

The output is:

test
0x7fff7a422300
0x7fff7a4222e8   //LOOK THIS! Is diferent from main!
0x7fff7a422300
main
0x7fff7a422300
0x7fff7a422300
0x7fff7a422300