It’s perfectly safe to use across platforms. The behavior is specified in §15.4.2 of the Java Language Specification (emphasis added): The result of the postfix expression must be a variable of a type that is convertible (§5.1.8) to a numeric type, or a compile-time error occurs. The type of the postfix increment expression is the … Read more
It’s not more efficient in Java. It can be more efficient in languages where the increment/decrement operators can be overloaded, but otherwise the performance is exactly the same. The difference between x++ and ++x is that x++ returns the value of x before it was incremented, and ++x returns the value of x after it was … Read more
++i is slightly more efficient due to its semantics: ++i; // Fetch i, increment it, and return it i++; // Fetch i, copy it, increment i, return copy For int-like indices, the efficiency gain is minimal (if any). For iterators and other heavier-weight objects, avoiding that copy can be a real win (particularly if the … Read more
Well, there are two things to consider with your example code: The order of evaluation of function arguments is unspecified, so whether ++a or a++ is evaluated first is implementation-dependent. Modifying the value of a more than once without a sequence point in between the modifications results in undefined behavior. So, the results of your … Read more
The loop is equivalent to: int x = 2; { int y = 2; while (y > 0) { System.out.println(x + ” “+ y + ” “); x++; y–; // or –y; } } As you can see from reading that code, it doesn’t matter whether you use the post or pre decrement operator in … Read more
for (int i = 0; i < 10; i = i++) { The above loop is essentially the same as: – for (int i = 0; i < 10; i = i) { the 3rd part of your for statement – i = i++, is evaluated as: – int oldValue = i; i = i … Read more
Let’s take a look at the intermediary language code for that: IL_0000: nop IL_0001: ldc.i4.s 2A IL_0003: stloc.0 // c IL_0004: ldloc.0 // c This loads the constant integer 42 onto the stack, then stores it into the variable c, and loads it immediately again onto the stack. IL_0005: stloc.1 IL_0006: ldloc.1 This copies the … Read more
The results are undefined. You’re modifying a variable more than once in an expression (or sequence point to be more accurate). Modifying a variable more than once between sequence points is undefined, so don’t do it. It might be your compiler, for this particular case decides to evalate ++i + ++i as increment the last … Read more
No, the printout of 10 is correct. The key to understanding the reason behind the result is the difference between pre-increment ++x and post-increment x++ compound assignments. When you use pre-increment, the value of the expression is taken after performing the increment. When you use post-increment, though, the value of the expression is taken before … Read more
Part-1: Array names are constant (not modifiable lvalue), your can add value to array name but can’t modify it. Expression a + 2 doesn’t modify a itself but when you do a++ that is equivalent to a = a + 1 try to modify array name –lvalue error. The expression a++ in second printf is … Read more