Operator precedence in c with pointers

Question

How to analyse the precedence in following situation .

for (i=0; i<20; i++)
{
    *array_p++ = i*i;
    printf("%d\n",*arr++);
}

how is following code different from above.

for (int i=0; i<20; i++)
{
    *arr = i*i;
    printf("%d\n",*arr);
    arr++; 
    printf("%d\n",(int )arr);
}

I am expecting same output but outputs are different for *arr value

I would suggest referring to a table like this: http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#Operator_precedence. — Oliver Charlesworth, Nov 23 '11 at 23:53
Did you mean to increment arr twice in the first example but not in the second? — Martin Beckett, Nov 23 '11 at 23:53
Also, why would you expect the same output? The first loop has one printf, the second loop has two. — Oliver Charlesworth, Nov 23 '11 at 23:54
possible duplicate of [How to increment a pointer address and pointer's value?](http://stackoverflow.com/questions/8208021/how-to-increment-a-pointer-address-and-pointers-value) — detly, Nov 23 '11 at 23:54
Removed the gcc tag because this has nothing to do with gcc. — Oscar Korz, Nov 23 '11 at 23:59

Oscar Korz · Answer 1 · 2011-11-24T03:07:13.533

4

Citing Wikipedia, postfix ++ binds before unary *. This means that you have *(arr++). For example, in the expression *arr++ = 5, *arr is assigned to 5, then arr is incremented.

In the K&R, this trick is used to write a concise version of memcpy. It's something like:

while (--size)
    *dest++ = *src++;

I'll post the correct example after I get home tonight.

Edit: Apparently, only postfix ++ has higher precedence. Wikipedia says prefix ++ has equal precedence.

edited Nov 24 '11 at 03:07

answered Nov 23 '11 at 23:57

Oscar Korz

2,437
1
17
18

1

did you mean `strcpy`: `while (*dst++ = *src++);`? – pmg Nov 24 '11 at 00:05
Yeah, something like that. I don't have the book with me so I'm going from memory. – Oscar Korz Nov 24 '11 at 00:05
@Oscar:if it is *++arr then it leads to segfault . why? – Imposter Nov 24 '11 at 00:12
@Imposter: Work through the last iteration of the look by hand. Be very careful with when things happen and how the array cells are numbered. – dmckee --- ex-moderator kitten Nov 24 '11 at 01:57

score 4 · Accepted Answer · answered Nov 24 '11 at 02:28

4

Postfix operators have higher precedence than unary operators, so *x++ is parsed as *(x++); the result of the expression x++ (which is x) is dereferenced.

In the case of *++x, both * and ++ are unary operators and thus have the same precedence, so the operators are applied left-to-right, or *(++x); the result of the expression ++x (which is x + sizeof *x) is dereferenced.

answered Nov 24 '11 at 02:28

John Bode

113,266
18
112
190

2

In case of *++x, the operators dereference and suffix are applied right-to-left, not left-to-right. http://en.cppreference.com/w/c/language/operator_precedence – Aymen Oct 25 '15 at 06:48

score 2 · Answer 3 · answered Jul 01 '13 at 06:03

2

It is easy to remember which has precedence when you consider prefix increment.

what has precedence here?

*++array = x; // pretty obvious

the same precedence rules go for the postfix expression so its rather easy.

The same goes for the cast operator.

(somestruct *)x + 1;

first the cast is done since if it wasn't the following wouldnt make sense

x + (int)1;

answered Jul 01 '13 at 06:03

Serve Laurijssen

8,981
5
35
82

1

Thanks for you answer: almost 2 year old post :-) – Imposter Jul 02 '13 at 02:36

score 1 · Answer 4 · edited Jul 01 '13 at 05:24

1

Operators ++ and * have the same precedence (postfix or prefix).However the associativity in such cases is from right to left. so in cases like

*ptr++ ==>  *(ptr++) 
*++ptr ==> *(++ptr)
++*ptr ==> ++(*ptr)

this link should give you more information on operators precedence and their associativity.. http://www.isthe.com/chongo/tech/comp/c/c-precedence.html

edited Jul 01 '13 at 05:24

Firoze Lafeer

17,113
4
51
48

answered Jul 01 '13 at 05:00

Sandeep R Venkatesh

197
1
13

score 1 · Answer 5 · answered Jul 31 '13 at 06:23

In the first sample code snippet,

    for (i=0; i<20; i++)
        {
          *array_p++ = i*i;
           printf("%d\n",*arr++);
    }

array_ptr is incremented first i.e address, and then the value computed from i*i is assigned to *array_ptr since evaluation takes in the order of right to left i.e *(array_ptr ++).

In the second sample of code snippet,

for (int i=0; i<20; i++)
{
  *arr = i*i;
printf("%d\n",*arr);
 arr++; 
printf("%d\n",(int )arr);
}

value computed from i*i is first computed and assigned to *arr, then pointer pointing to arr is incremented.

Hence there is difference in values among the 2 code snippets.

Thanks for you answer: almost 2 year old post – Imposter Aug 01 '13 at 09:31 — Imposter, Aug 01 '13 at 09:31

Operator precedence in c with pointers

5 Answers5

Linked