指向数组元素地址的指针

Question

int s[4][2]= {
             {1234,56},
             {1212,33},
             {1434,80},
             {1312,78}
             };
int i,j;
for(i=0;i<=3;i++)
{
    printf("\n");
    for(j=0;j<=1;j++)
    {
        printf("%d  ",*(s[i]+j));
    }
}

Output Showing is

 1234,56 1212,33 1434,80 1312,78 

As we know *(&Variable) will print the Value of the Variable But when We implement the same concept in above program...

int s[4][2]= {
             {1234,56},
             {1212,33},
             {1434,80},
             {1312,78}
             };
int i,j;
for(i=0;i<=3;i++)
{
    printf("\n");
    for(j=0;j<=1;j++)
    {
        printf("%d  ",*(&s[i]+j));
    }
}

output is showing the Address of each element of array.

Why this is happening? Why Output is not equal to value of elements of Array??

Answer 1

Notice here , s is a two dimensional array, and array names decay to pointer to the first element, in certain cases.

Here, s[i] is of type array, array of two int s.

Then, quoting C11 , chapter §6.3.2.1,

Except when it is the operand of the sizeof operator, the _Alignof operator, or 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. [...]

Thus,

• In the first case,

   *(s[i]+j) 

  s[i] is of type int [2] , which decays to an int * , which is used in the pointer arithmetic, producing another int * . After the dereference, you get an int .

• In the second case,

   *(&s[i]+j) 

  due to the same aforesaid reason, in case of &s[i] , s[i] does not decay , and the type is "pointer to int [2] " and the pointer arithmetic works on that. So, in this case, the result of the addition is also "pointer to int [2] " and after the final dereference, it becomes int * , which is the mismatch for %d and that is what reported by your compiler.

Answer 2

Your array is bi-dimensional. So, s[i] is the address of line i (ie s[i] is of type int * ), and &s[i] is an address of an address (ie of type int ** ). When you apply * on it, you get an address (ie int * ).

It is true that the operator & means "address-of" and *(&x) refers to the value of x .

Answer 3

First case

Your print statement is this.

printf("%d  ",*(s[i]+j));

Here s[i]+j is the address.

lets consider i=0,j=1 , first i loop, second j loop.

here s[i] will be the address in which value 1234 is residing. lets say it is 489000. so s[i]+j , here s[0]+1 will be the address at which value 56 is residing. lets say it is 489004

So, *(s[i]+j) ,ie; here *(s[0]+1) will be giving the value at address 489004. ie 56. So here it will print the values 1234, 56, 1212 etc.

Second Case Your print statement is this.

printf("%d  ",*(&s[i]+j));

Here &s[i]+j is the address.

lets consider i=0,j=0 , first i loop, first j loop.

here s[i] will be the address in which value 1234 is residing. Lets say it is 489000. So &s[i] will be the address in which address 489000 is residing. Lets say it is 380000. Recall the concepts of pointer's.

So &s[i]+j will be "address in which address 489000 is residing + j" . ie; 380000+j

we are applying a value at operator * on this particular 'address' we got. *(&s[i]+j). So it becomes, Value at['address in which address 489000 is residing' + j]. Value at[380000 + j].

when i=0,j=0, it will print, Value At[380000] , ie; 489000.

So it will print the address in which the values 1234, 56 , 1212 etc are stored.