pointer movement what is difference between cs[1], and *cs++

Question

I am trying to understand how the pointers are moving. Following is the program and I am aware that if

int cs={1,2,3};  

then cs points to cs[0] what I am not clear is what is *cs pointing to.

#include<stdio.h>
int main()
{
        int array[] = { 1, 2, 3, 4, 5 };
        int *arrptr1 = array;
        int *arrptr = array;
        int i;
        for (i = 0; i < sizeof(array) / sizeof(int); i++) {
                printf("%d, %d, %d\n", array[i], *arrptr1++, *arrptr + i);
        }
}

the output of above program is

1, 1, 1
2, 2, 2
3, 3, 3
4, 4, 4
5, 5, 5

then my understanding *arrptr should increase the value stored at

*arrptr

should get incremented by 1. Where as what I observe is the pointer is moving to next location.So just want to know what is wrong in my understanding?

UPDATE
As per the replies below I understand that

print("%d", *arrptr1++);

in such a statement evaluation of operators is from right to left. Hence in *arrptr1++ the ++ will get evaluated first and then arrptr and then * So to confirm the same I wrote another program

#include<stdio.h>
int main()
{
        int array[] = { 10, 20, 30, 40, 50 };
        int *q1 = array;
        printf("q1 = %p\n",q1);
      printf("*q1++ = %d\n",*q1++);
        printf("q1 = %p\n",q1);
      printf("*q1++ = %d\n",*q1);
}

The output of above program is different than the expected operator precedence by above logic. The output I got is

q1 = 0x7ffffcff02e0
*q1++ = 10
q1 = 0x7ffffcff02e4
*q1++ = 20

So I was expecting in the 2nd line of output instead of *q1++ = 10 following *q1++ = 20 so did the operator precedence not happened right to left?

Answer 1

*arrptr1++ is parsed as *(arrptr1++), not (*arrptr1)++.

Answer 2

Whenever you use dereference operator * and pre-increment(pre-decrement) or post-increment(post-decrement) operator on a variable simultaneously ,the order of operation is from right to left (if parenthesis are not used).

What you want to do is (*arrptr)++

because of higher precedence of (), it will force the compiler to first access the element pointed to by arrptr and then increment its value. When you do this *arrptr++ , as I've said it first operates rightmost operator (i.e. ++) and then the dereference operator. If you will write

EDITED (only the comment): *++arrptr // increment the pointer then access

it will first advance the pointer and then access the value stored in the address now pointed to by arrptr. One more thing,The comma used for separation of function argument is not the comma operator so the order of evaluation of the arguments is undefined. (already been told)