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
No, you should be using something like java.util.concurrent.atomic.AtomicInteger. Look at its getAndIncrement() method.
++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
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
Note: The two defect reports DR#637 and DR#222 are important to understand the below’s behavior rationale. For explanation, in C++0x there are value computations and side effects. A side effect for example is an assigment, and a value computation is determining what an lvalue refers to or reading the value out of an lvalue. Note … Read more
You hit the nail on the head. Your understanding is correct. The difference between pre and post increment expressions is just like it sounds. Pre-incrementation means the variable is incremented before the expression is set or evaluated. Post-incrementation means the expression is set or evaluated, and then the variable is altered. It’s easy to think … Read more
Quoting Java Language Specification, 15.7 Evaluation Order: The Java programming language guarantees that the operands of operators appear to be evaluated in a specific evaluation order, namely, from left to right. 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 … Read more