Order of evaluation for C++ vs Java

Question

This is regarding another question: Java Recursion Bug? I am going crazy.

I understand the solution there. But, why does C++ behaves differently than Java in this case?

Can anybody please give exact pointers (no pun) to C++/Java specifications? I know that java assigns 0 to sum before each call, while C++ does it differently. But what's the specification which allows this?

Edit: Adding code from link

public class Test {

public static int sum=0;

public static int fun(int n) {

    if (n == 1)
        return 1;
    else
        sum += fun(n - 1);  // this statement leads to weird output
    // { // the following block has right output
    //     int tmp = fun(n - 1);
    //     sum += tmp;
    // }

    return sum;
}

public static void main(String[] arg) {
    System.out.print(fun(5));
}
}

The output is 1 which should be 8. Relative C/C++ code is as follows:

#include<stdio.h>
int sum=0;
int fun(int n) {

    if (n == 1)
        return 1;
    else
        sum += fun(n - 1);

    return sum;
}

int main()
{
printf("%d",fun(5));

return 0;
}

Output in C++ is 8.

Answer 1

OK, combining everyone's comments:

This line:

sum += fun(n - 1);  // this statement leads to weird output

expands to

sum = sum + fun(n - 1);

in both C++ and Java. See JLS 15.26.2, C++11 draft section 5.17(7).

In Java, the language specifies that sum must be evaluated first, before the function is called. See JLS 15.7.1. In order to get this right (in case fun modifies sum, as it does), the code must read sum and save it somewhere, before it calls fun. After fun returns, the code then adds the saved version of sum to the result of fun. Since sum is never modified until after all the fun calls have been started, the result is that all the saved versions of sum are 0, and the result is 1.

In C++, the order in which the operands to + are evaluated is unspecified. (See 1.9.15 of the C++11 draft.) Because of this, the function result could be 1 or 8 depending on how the compiler decides to implement it. 8 is probably more likely, since the compiler will probably generate code that doesn't require sum to be saved in a temporary, and on some processors could generate an instruction that adds directly into sum without reading it first. But 1 would not be an incorrect result, since the evaluation order is unspecified and the result can change depending on the evaluation order. Moral: Don't write code like this.

Answer 2

from jls http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.7.1

15.7.1. Evaluate Left-Hand Operand First

The left-hand operand of a binary operator appears to be fully evaluated before any part of the right-hand operand is evaluated.

If the operator is a compound-assignment operator (§15.26.2), then evaluation of the left-hand operand includes both remembering the variable that the left-hand operand denotes and fetching and saving that variable's value for use in the implied binary operation.

If evaluation of the left-hand operand of a binary operator completes abruptly, no part of the right-hand operand appears to have been evaluated.

for

sum += fun(n - 1);

sum is evaluated first and the value 0 is saved any change to the value of sum after this is ignored.

fun is then evaluated and is equal to 1

giving the result

sum = 0 + 1 

recursively this is the same as

sum = sum + sum + sum + sum + 1

or

sum = 0 + 0 + 0 + 0 + 1

Answer 3

update - declaring sum to be volatile would prevent using a cached copy of sum in an expression, but this may not solve the order of evaluation issue.

If Java is always left to right then changing the statement to sum = fun(n-1) + sum should work, but the alternate code mentioned in the original example may be the only solution. volatile isn't needed in this example, but I left it there to show how it's implemented.

#include <iostream>

class Test{
public:
static volatile int sum;
static int fun(int n) {
    if (n == 1)
        return 1;
    int tmp = fun(n - 1);
    sum += tmp;
    return sum;
}
};

volatile int Test::sum = 0; // declare and initialize sum

int main(){
    std::cout << Test::fun(5) << std::endl;
    return(0);
}