C++ vs C# operators precedence

Question

I have the same code on visual studio C++ and C# and each compiler has a different output although both have the same precedence and associativity table

On C++

    int i = 10;  
    int a = i++ + ++i + i--;  
    printf("a=%u\n",a);

    i = 10;
    a = i++ + i;
    printf("a=%u\n",a);

    int x=2,y=3;
    int z=((x++)*(x++))+((++y)*(++y));
    printf("x=%u , y=%u , z=%u \n",x,y,z);

the output is

a=33
a=20
x=4 , y=5 , z=29

On C#

            int i = 10;
            int a = i++ + ++i + i--;

            Console.WriteLine("a={0}",a);

            i = 10;
            a = i++ + i;

            Console.WriteLine("a={0}", a);

            int x = 2, y = 3;
            int z=((x++)*(x++))+((++y)*(++y));
            Console.WriteLine("x={0} , y={1} , z={2}",x,y,z);

the output is

a=34
a=21
x=4 , y=5 , z=26

In C# I found that the operation obey the precedence table that post-increment has a higher precedence that pre-increment and so it places the value then increment I can't find any logical explanation for this . Could anyone explain this ?

You have undefined behaviour in your C++ code because you are modifying `i` multiple times that are unsequenced. Anything could happen. I don't know how C# deals with this. — Joseph Mansfield, Jan 14 '14 at 12:15

score 3 · Answer 1 · answered Jan 14 '14 at 12:18

3

It's not a case of precedence, but of operand evaluation order and sequencing of side-effects. In C++, evaluation order is unspecified, and you also get undefined behaviour from unsequenced modifications of a variable.

I've no idea whether or not C# specifies the behaviour of such insane code, but you shouldn't write such nonsense in any language.

answered Jan 14 '14 at 12:18

Mike Seymour

249,747
28
448
644

See http://stackoverflow.com/questions/7698293/why-does-the-postincrement-has-a-higher-precedence-than-preincrement for more details – Matthew Watson Jan 14 '14 at 12:21

score 1 · Accepted Answer · edited Feb 01 '22 at 11:00

In C++ the code has undefined behaviour because side effect of the post-increment operator is not exactly sequenced relative to other operations.

In C# there is such notion as DAS (define assignment state); DAs before Expression i must be equal to DAS after Expression i - 1.

The order of calculation of expression x++ or x-- the following.

Value of x is calculated and saved.
The value is used to calculate x++ or x-- and also saved.
This saved result becomes the result of the operation.

So consider statement

int a = i++ + ++i + i--;

The first expression is i++. i is evaluated. Its value is 10. It is saved as the value of the expression. Then operation ++ is applied. The result of operation is 11. So the output DAS of i is equal to 11. It is the input DAS for the next expression ++i. Here ++i is evaluated because there is pre-increment operator. The value is 12 and the output DAS of i is 12. The order of evaluation of i-- the same as i++. So we have

10 + 12 + 12 = 34

and the output DAS of i of the expression is 11.

Maybe it is not very clear but the difference between C++ and C# is that C# made the process of evaluation of expressions more deterministic and clear, to avoid undefined behaviour.

C++ vs C# operators precedence

2 Answers2