C Programming - Arrays - Discussion

*Great Angel_Eyez...Thanks..

@anand, @vedavati, @karthiga

If you urself can't understand then don't try to explain the answer here, it will confuse others, thank you.

Where give ptr is point to a pointer ?

@Angel eyez thanks.

4th step is explained wrongly.

++*ptr mean value pointed by ptr is being incremented. So it increments arr+3 or arr[2].

i am trying to make this simpler.

Here p[] is a pointer array to arr[]
and ptr is pointer variable to p[].

1.ptr++;

Initially ptr is at 0 position referring to *p[0], now ptr is incremented and is at 1st position *p[1].

Initially p is at 0

so ptr -p= 1-0 =0
*ptr is the value present in *p[1] i.e, arr+1 hence *ptr-arr=1
**ptr is the value present in arr at position 1 i.e 1
2. *ptr++
the same thing happens here. ptr is again incremented by 1. now it points to *p[2].
ptr-p=2-0=0
*ptr is value present in *p[2] i.e, arr+2 and *ptr-arr=2
**ptr is value present in arr at position 2 i.e 2.
3. *++Ptr
this is same as 2. ptr is incremented and it points to *p[3]
so the remaining is same
4. ++*ptr
in case 2 and 3 pointer is incremented but here the value that the ptr pointing is incremented

ptr is pointing to arr+3 in *p[] and arr+3 is incremented
so *p[3]= arr+4;

ptr-p= 3-0=3
*ptr-arr = arr+4-arr=4
**ptr refers to the value in arr+4 i.e arr[4]=4

arr[] sotres the elements 0,1,2,3,4
arr , arr+1 ,arr+2... represents the base address 32--0 ,33--1 ,34--2 ...

*p[]={ base address are sotred.}

Here p(48) also represents a base address . p base address 48 (something not in array) stored in ptr.

*ptr(32) gives base address = = arr.

ptr++ increments (49)
--> ptr(49) - p(48) = 1.
-->*ptr(33) - arr(32) =1.
-->*(*ptr) gives the value 1.(bcz *(33) = 1.)

ptr=49
*ptr++ increments (34)
--> ptr(50) - p(48) = 2.
-->*ptr(34) - arr(32) =2 , arr(address) same.
-->**ptr gives the value 2.(bcz *(34)=2)

ptr=50
*++ptr increments (35) Although *ptr++ = *++ptr
-->ptr(51) - p(48) = 3.
-->*ptr(35) - arr(32) = 3.
-->**ptr gives the value 3.(bcz *(35)=3)

ptr=51 (it will not change down bcz it is not incremented.)
++*ptr (36)
But ptr = 51
--> ptr(51) - p(48) = 3.
-->*ptr(36) - arr(32) = 4.
-->**ptr gives the value = 4.(bcz *(36)=4.)

So the result
1 1 1
2 2 2
3 3 3
3 4 4

Yes @Angel_Eyez is right. The above problem can be solved if we know that precedence of increment(++)operator is greater than (*) dereferencing operator.