CareerCup

The result is undefined. Side effects in an expression do not have a set order of evaluation in C. The outcome is up to the compiler's implementation.

A compiler may decide to evaluate the side effects of an expression at a different time. The side effect of j++ is permanently incrementing the value of j after using the current value.

This is not a simple expression. This is an arithmetic expression containing two side effects. One of the side effects can potentially impact the rest of the processing.

Since the subtraction has a set operator order of precedence (left-to-right), the code will first compute (j++). The value of which is the current value of j, 10. This is the left-hand side of the subtraction, the minuend. The side effect making j permanently represent a value one higher (j+=1) may not occur until later (the end of the line's execution), even though this evaluates.
Next, the right-hand side of the subtraction, the subtrahend, will evaluate. Now comes the reason we have an undefined outcome. Did the side effect of evaluating the minuend take effect immediately, or will it not take effect until the line is completed? The compiler decides this question, then evaluates (j++) again, yielding a value of 10 or 11.

With ++j - ++j, you may find the same issue. Do we get 11-12 (side effect happens immediately) or 11-11 (side effect happens at the end of the line's execution)?

Do not depend on side effects happening at a particular time in code.

void main() {
int i,j;
j = 10;
i = j++ - j++;
printf("++j - j++%d %d \n\n", i,j);

j = 10;
i = ++j - ++j;
printf("++j - j++%d %d \n\n", i,j);

j = 10;
i = j++ - ++j;
printf("++j - j++%d %d \n\n", i,j);

j = 10;
i = ++j - j++;
printf("++j - j++%d %d \n\n", i,j);
getch();
}

You get the same answer for all the above code because the expression is first evaluated and the (pre/post)-incremental takes place...

In Chrome this outputs " -1 1":
javascript: var x = 1, y = x++ - x++; var w = 1; var z = w++ - 0; alert(' ' + y + ' ' + z)

So seems like it is different answer than yours.

#include<stdio.h>
int main() {
int i,j;
j = 10;
i = 3;
//i = j++ - j++;
//i =   i++ + ++i;
//i = j++ - j++ + i++ + ++i;
printf("%d\n", i);
}
~

If I un-comment the first comment then output = 0
if second then output = 9
if third then output = 8

Please explain why this is so

Just experiment with code :-)
Here is my example how to see what is going on.

template <typename T>
class op_test
{
private:
    T val_;
    op_test();
public:
    explicit op_test(const T& v)
        : val_(v)
    {
    }
    virtual ~op_test(){}

    op_test& operator-(const op_test& rhs){
        std::cout << "called operator-" << std::endl;
        val_ = val_ - rhs.val_;
        return *this;
    }

    op_test& operator++(int i)
    {
        std::cout << "called operator++" << std::endl;
        val_ += 1;
        return *this;
    }
};


int main()
{
    op_test<int> a(12), res(0);
    res = a++ - a++;
}

It produce following result for G++

called operator++
called operator++
called operator-

Perl gives
-1 and 12
which i agree with .
ur interviewer is a doormat

i agree with the last comment- howdoes it matter
perl gives -1 and 12 .

$j = 10;
$i = $j++ - $j++;
print "i=",$i," j=",$j;


-1 and 12

surely, his interviewer was a class A i_diot.

Let not talk about perl and stick to this C code given.

its i = 10 - 10

its i = 10 - 10
becoz '++' is lower precedence than '-'.
you can try this program by
main() {
int i,j,a,b;
j = 10;
i = (a=j++) - (b=j++);
printf("%d %d %d %d", i,j,a,b);
}
you wil get 0 12 10 10.

this type of problems r compiler dependent...

main() {
int i,j;
j = 10;
i = j++ - j++; //{i=10-10=0}
printf("%d %d", i,j);//{j=j++=11,j++=12}
}

j++ j value is incremented after the execution of statement
++j j value is incremented while the statement is executed
i=j++ - j++;
so above indicates i=10-10
however if
i=++j - ++j;
i value can be compiler dependent
so i value is 0 and j value is 12 as it is incremented twice after the execution of statement
i=j++ - j++;

ya its 0 ,12 because j++,j++ will remain on the same value it's 10 ,so i becomes 0,then first j++ (before -)will be inc then second j++ (second j++)will be inc.......

That's trivial ....
we have i = 10 -10 = 0 //post increment of j, means we use 10 rather than 11 ,then we increment that
then we see that j increment 2times which gives it the value of 12