Do the pre and post operators matter outside of assignments?

The increment operators ++i and i++ or likewise the decrement operators, have identical effects except in assignments
and that is the only place they actually distinguish themselves (or find their use).
Is my understanding correct?

They do both have the effect of incrementing the value of the variable "i". The difference is when you look at the result of the incrementation. For one of the operators the result is the value of "i" before incrementing, and for the other the result is the value of "i" after incrementing. No doubt you know which.

So yes, the only concern is when you use the result of the operator. You mentioned assignments, which is true, but be careful, it's not only = which causes an assignment. Using a value as a method parameter also assigns that value to something, for example. Example: Math.max(++i, 42). There may be other situations.

Paul Clapham wrote:You mentioned assignments, which is true, but be careful, it's not only = which causes an assignment. Using a value as a method parameter also assigns that value to something,

Perhaps they should be referred to as assignment operators!

i++ and ++i are expressions.

The difference between them will become evident whenever you use them as part of a larger expression. Not just explicit assignments or assignment to method arguments, but anywhere an expression is allowed.

if (i++ == 10) Does something different than
if (++i == 10)

array[i++] Retrieves a different element than
array[++i]

There are many similar examples.

Anil Philip wrote:The increment operators . . . have identical effects . . . Is my understanding correct?

Afraid not. Since you are sitting a cert. exam, you will need to know the differences because cert. exams use i++ and ++i, etc., in larger expressions where the differences are there to confuse you. There are only a few instances where use of those operators as part of a larger expression doesn't count as bad programming. Or good programming for cert. exams!/* Adding to an array, as in an array stack */ values[size++] = newValue;/* Removing last element from an array, as in an array stack */ var oldValue = values[--size]; values[size] = null; return oldValue;You will find those examples in Effective Java by Joshua Bloch, but I haven't got the time now to find the page number (sorry).

Stephan van Hulst wrote:[tt] whenever you use them as part of a larger expression.

Isn't it (a special case of) an assignment to a temporary variable in the expression?
@moderators I don't know how this thread ended up in the JDBC forum - can you please move it? thanks.

Anil Philip wrote:. . . Isn't it a special case of an assignment to a temporary variable in the expression?

No. That is part of the definition of the ++ and -- operators. It's all in the JLS.

. . . don't know how this thread ended up in the JDBC forum . . .

Shall move you. It will stay in the JDBC forum as a link for one week.

Campbell Ritchie wrote:No. That is part of the definition of the ++ and -- operators. It's all in the JLS.

from Stefan's example
if (i++ == 10)

is really

int temp = i++; if (temp == 10)

an assignment to a temporary

Anil Philip wrote:. . . is equivalent to . . .

Not 100% sure, but I think you will find that is incorrect. The JLS sometimes tells us that a temporary variable is used, e.g. in the for‑each loop and try‑with‑resources, but as far as I can remember, there are no temporary variables for increment and decrement. Try javap −c and see what happens.

Anil Philip wrote:from Stefan's example [...] is really [...] an assignment to a temporary

No, not really.

Every expression evaluates to some value. For i++, that value is the current value of i before incrementing it, and for ++i it is the value of i after incrementing it. There are no temporary variables involved.

Your logic comes down to saying that
if (5+a == 10) is really
int temp = 5+a; if (temp == 10)
That just isn't the case.

Here's some sample code to study, with no assignment statements.  Can you explain the results?
   int i = 1;    System.out.println(i++ * i++);    int j = 1;    System.out.println(j++ * ++j);    int k = 1;    System.out.println(++k * ++k);

Anil Philip wrote:Perhaps they should be referred to as assignment operators!

Well, they are a lot like assignment operators.  "++i" is effectively the same as "(i += 1)" - except I added parenthesis because ++ is much higher in precedence, so if you use it within an expression it may make a difference.  It would be confusing to start calling ++ an assignment operator, and then discuss order of precedence, because those rules use the existing definition of "assignment operator".  Better to just use the terms as they have already been defined.

Anil Philip wrote:. . . Perhaps they should be referred to as assignment operators!

As Mike has said, no they shouldn't.

Mike Simmons wrote:Here's some sample code to study, with no assignment statements.  Can you explain the results?

nice question! thanks...

package enthuware.operators; public class Increments {    public static void main(String[] args) {        int i = 1;        System.out.println("i " + i);        System.out.println("i++ * i++  " + i++ * i++);        System.out.println("i " + i);        int j = 1;        System.out.println("\nj " + j);        System.out.println("j++ * ++j  " + j++ * ++j);        System.out.println("j " + j);        int k = 1;        System.out.println("\nk " + k);        System.out.println("++k * ++k  " + ++k * ++k);        System.out.println("k " + k);    } }

i 1
i++ * i++  2
i 3

j 1
j++ * ++j  3
j 3

k 1
++k * ++k  6
k 3

This morning, I wrote:. . . I haven't got the time now to find the page number (sorry).

In the 2nd edition, pages 25‑26. In the 3rd edition, pages 27‑28.

Mike Simmons wrote:. . .  Can you explain the results?

Well, can you?

Stephan van Hulst wrote:i++ and ++i are expressions. . . . .

Aren't they also called expression statements? Nearly, but not quite←JLS link.

If they're used as statements, where the entire statement is "i++;" for example, they are expression statements.  If they're used as subexpressions in a larger expression, then they are not.

For Anil: so do you agree there is a difference between pre and post operators, outside of any assignment?

Mike Simmons wrote:For Anil: so do you agree there is a difference between pre and post operators, outside of any assignment?

For the same kind of operator, there is no difference between pre and post operations - outside of an assignment.

Anil Philip wrote:For the same kind of operator, there is no difference between pre and post operations - outside of an assignment.

You seem to be asserting that "6 + (++a)" is not different than "6 + (a++)". There's no assignment here.

Paul Clapham wrote:

Anil Philip wrote:For the same kind of operator, there is no difference between pre and post operations - outside of an assignment.

You seem to be asserting that "6 + (++a)" is not different than "6 + (a++)". There's no assignment here.

I meant that

++i;
and
i++;

result in the same value.

Anil Philip wrote:I meant that

++i;
and
i++;

result in the same value.

That's an unambiguous statement, then. Which is a false statement.

It's true that the value of the variable i is the same after either of those operations, but you made a statement about the values of those expressions. Not the same.

So Anil, between
System.out.println(i++ * i++);
and
System.out.println(++i * ++i);
Is there any difference in the result?  Are there any assignments in those statements?

Paul Clapham wrote:but you made a statement about the values of those expressions. Not the same.

I did not say expressions, I said operators.

Your understanding is mostly correct, but there's a bit more to it when considering the broader implications of pre and post increment/decrement operators (i.e., ++i/i++ and --i/i--) in programming.

The primary difference between these operators is not just in assignments, but in how they behave in expressions and how the value is used:

Pre-Increment/Decrement (++i or --i):
The variable i is incremented or decremented before it is used in the rest of the expression. This means the updated value of i is available immediately for any further computation within the same expression.
Post-Increment/Decrement (i++ or i--):
The variable i is used in its current state first, and only then is it incremented or decremented. This means the expression evaluates using the original value, and the change takes effect after the expression's value is computed.

Here are some scenarios beyond simple assignments where the distinction matters:

In a Function Call:
When passing a variable as an argument to a function, f(++i) will pass the incremented value, whereas f(i++) will pass the original value and increment i afterward.
In Loops:
Although often interchangeable in loops like for, the choice between pre and post can affect readability or performance minutely in some languages due to the timing of the increment/decrement.
In Complex Expressions: I
n expressions that mix several operations, choosing pre or post increment can affect the order of operations and thus the final result.
In Concurrent or Multi-threaded Code:
The choice between pre and post can have implications in terms of when a variable is updated, potentially affecting synchronization or the visibility of the variable's state across different threads.

Anil Philip wrote:

Paul Clapham wrote:but you made a statement about the values of those expressions. Not the same.

I did not say expressions, I said operators.

correction: operations

Raphaelle Senger wrote:The primary difference between these operators is not just in assignments, but in how they behave in expressions and how the value is used:

thank you.

Anil Philip wrote:I did not say expressions, I said operators.

Let's review where you said "operators" and what you said, then. You'll have to copy and paste what you said, though, because you've said a lot of things including those two words.

Anil Philip wrote:

Raphaelle Senger wrote:The primary difference between these operators is not just in assignments, but in how they behave in expressions and how the value is used:

thank you.

Why thank you?  He's right, of course.  But you're telling us that there is no difference, and he's telling you there's a difference.  Did you suddenly understand?  Are you changing your answer?

Mike Simmons wrote:So Anil, between
System.out.println(i++ * i++);
and
System.out.println(++i * ++i);
Is there any difference in the result?  Are there any assignments in those statements?

There could be a temporary variable(s) involved and assignments to those variables happening, but I do not know enough.
But I do understand those expressions.

Anil Philip wrote:

Mike Simmons wrote:For Anil: so do you agree there is a difference between pre and post operators, outside of any assignment?

For the same kind of operator, there is no difference between pre and post operations - outside of an assignment.

@Paul here it is.

Mike Simmons wrote:
Why thank you?  He's right, of course.  But you're telling us that there is no difference, and he's telling you there's a difference.  Did you suddenly understand?  Are you changing your answer?

No, I was just thanking him because this is his first post.

I don't usually quote the whole post, but it seems appropriate here for maximum clarity:

Anil Philip wrote:

Mike Simmons wrote:So Anil, between
System.out.println(i++ * i++);
and
System.out.println(++i * ++i);
Is there any difference in the result?  Are there any assignments in those statements?

There could be a temporary variable(s) involved and assignments to those variables happening, but I do not know enough.
But I do understand those expressions.

Okaaayy.  

But again, is there any difference in the result of those two statements?

And, would you agree that these statements are "outside of any assignment", to use the phrase you used earlier?

[This second post is a mispost, please delete - I was trying to update the preceding post, and added a second post instead.]

I don't wish to be not nice, but this thread is, let's say, not useful. It's true that the expressions ++x and x++ have different values, given some variable x. And many students have had difficulty with that. But really that's all you need to know. Those two expressions have different values, and the rule for what differs is fairly simple. So when you use those values in subsequent code, you have to understand the difference.

However there is no point in expanding upon the idea of "use". You might use those values by assigning them to a variable, or by using them as a method parameter, or by doing arithmetic with them, or in some other way I haven't thought of. But it makes no difference at all, the values of those expressions are the same no matter what. So going on about assignments, for example, is not useful.

I find it's easier to look for simple explanations for bits of computer languages. Writers of computer languages generally use simple concepts, unlike writers of fiction. So going on about nonexistent complications is not useful.

The point I was making is: Anil, you've been shown an example that (a) does not involve any assignments, but (b) clearly there is a difference in output, between the pre-increment and post-increment versions of the code.  So how can you believe that these are equivalent, outside of an assignment operator?

I suspect that one of these statements we're making means something different to me than it does to you.  So I was trying to unearth where the disconnect is, between my understanding and yours.

If we're going to start imagining invisible assignments in random locations, well, I guess that would make "outside of any assignment" kind of meaningless.  It's probably best if we limit the discussion to things that are actually in the code that we discuss.

Anil Philip wrote:. . . There could be a temporary variable(s) . . .

We have already established that there most probably isn't such a temporary variable.

Campbell Ritchie wrote:

Anil Philip wrote:. . . There could be a temporary variable(s) . . .

We have already established that there most probably isn't such a temporary variable.

I meant that when the compiler translates it into assembler (or interprets it), then it likely might use them.
So there is an assignment happening at the lower levels.
But at the higher levels, it looks like one step - copy the present value and increment afterwards.

I think that your technique of trying to imagine how the Java runtime is actually implementing "x++" is getting in your way. What it does is to increment x and then return the original value of x as the result of the expression. There's no need to imagine the machinations under the covers as it does that, you only need to remember that "x++" returns the original value of x. That's all. When you start imagining hidden variables and assignments you just add extra conceptual load to your understanding which is unnecessary.

For another example consider the expression "(3 + 6) * (2 + 3)". To compute this, the runtime computes 3 + 6, then it computes 2 + 3, then it multiplies the results of those two calculations. No doubt it has to store those two calculated values somewhere before it multiplies them. But there's no need to imagine hidden variables and assignments to describe where they are stored -- because it's totally unnecessary to care how that works. I'm sure you never gave that example a second thought, though. Likewise there's no need to obsess over how "x++" works.

(As I understand it, those temporary results are stored in a stack in real life, and I expect "x++" results in something being stored in that stack too, but you don't need to care.)

Anil Philip wrote:. . . when the compiler translates it into assembler . . .

It doesn't use assembler, but Java bytecode. That is similar to assembler. Have you looked at the bytecode?