Pre and Post increment on pointers pointing array

Question

Consider the program:-

void main()

{

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

 int *p[] = { a, a+1, a+2, a+3, a+4 };

 int **ptr = p;

 ptr++;

 print( ptr - p, *ptr - p, **ptr );

 *ptr++;

 print( ptr - p, *ptr - a, **ptr );

 *++ptr;

 print( ptr - p, *ptr - a, **ptr );

 print(++*ptr);

}

Now my doubt is how these bold letter lines are working i.e. how pre increment and post increment are working on pointers?

Answer 1

The operator precedence is as follows-

Operator	Description	Associativity
++ --	Postfix increment/decrement (see Note 2)	left-to-right
++ -- *	Prefix increment/decrement Dereference	right-to-left

According to precedence table - 

We can see that ++(postfix) has higher precedence than * hence ,evaluate ++ (postfix) first then * hence *ptr++ = *(ptr++)

We can see that ++(prefix) has same precedence as *  but the expression will be evaluated from right to left , hence evaluate ++ (prefix) first then * hence *++ptr  = *(++ptr)

We can see that ++(prefix) has same precedence as *  but the expression will be evaluated from right to left , hence evaluate * first then ++(prefix) hence  ++*ptr = ++(*ptr)

---

Now, even if post-increment happens first, remember that post-increment operator returns the old value of ptr in ptr++; and "then only" ptr gets incremented. When the "then-only" happens is not fixed-- it is just guaranteed to happen before the next sequence point. 

Comments

I m saying the same thing but in lame language, to simplify the procedure n headache of learning rules☺

---

@Arjun Sir  thank you for clearing the doubt :)

I could infer these things from your answer-

In an expression , operands in the expression can be evaluated in any order in the register.  Operators are evaluated according to operator precedence and associativity rules. If there is side effect of expression then it will be after the next sequence point.

---

@Arjun sir,

@Deeptimittal97  

if ptr = 2000 

and *ptr = 1000

then expresion *ptr++ 

1. if put explicitly braces on expression like 

(*ptr)++ then it will be error something like "Incrementing constant is not allowed"

2. if not puting braces explicitly then expression will be solved as 

*(ptr++) because post increment has higher precedance over *.

then output will be  

*(2000 + 1 * size of ptr data type lets say 2)

*(2000 + 1 * 2)

*(2002)

crct me if I am wrong??