Thread: question about incrementing variables

Hello all,
I have perhaps one silly question...
when i compile code :

int k = 5; 
k = ++k + k++;
System.out.println(k);

I get output 12 instead of 13 (as i would if I use c++ compiler). I know this type of coding is "wrong" but i just wonder why do I get that kind of output I understand how does gcc do this... first increment k to 6, then add those two k's (6+6) and put it on memory location of the k, and after that line is executed, just before it fetch new instruction k will be incremented by one so it will be 13 and if I would do something like "cout << k" in the next line I would get 13 in the output...

but here I'm a bit confused and any explanation is very useful

I know
that's why I said it's wrong to do it like this
I just wonder how does java compiler handles this situation with ++k and k++ (because stack memory is not in the physical memory but in the stack memory of the virtual machine)

int k = 5; 
k = ++k + k++;
System.out.println(k);

I'd expect 12 not 13 to be printed.

Those ++ things are operators and they form expressions. It's best to keep these two roles distinct and recognise that operators have effects on the value of variables while expressions have values that might go on to play a role in larger expressions.

++k: the effect is to increment k, the value is the incremented value of k
k++: the effect is to increment k, the value is the original value of k

So, working left to right (as Java does) we get

++k
This increments k which is now 6. It has the value 6.

k++
This increments k which is now 7. It has the value 6.

++k + k++
This has the value 12 ie the values of the two terms added together

k = ++k + k++
This assigns 12 to k. Ie it assigns the value of the right hand side to k

Thanks
I know it's stupidity to write somethig like that code I wrote but i just wondered since if i do

someArray[i++]

I get ith element and "i" will be i+1 after that line. But when i do :

someArray[++i]

I get i+1 element from that array...

That's why thought it will be 6 + 6 = 12 and after that increment by 1

Thanks very much

I'm glad it helped.

Personally I find it easier to think in terms of an operator's effect and the resulting expression's value rather than trying to figure out the particular ordering of events.

Java is more straightforward (I think) in this regard than C. For example the following Java code admits the same sort of analysis (although it probably falls into Norm's category of Code That Should Not Be Written):

import java.util.Arrays;
 
public class ArrayEg {
    public static void main(String[] args) {
        int[] arr = new int[5];
        int i = 2;
        arr[i] = i++;
        // arr[i] = ++i;
        System.out.println(Arrays.toString(arr));
        System.out.println("i=" + i);        
    }
}

(Predictions of what either form will do is left as an exercise.)

K&R thought that the ambiguous (in C) "arr[i] = i++;" was unspecified. Later standardisers got tough and made it undefined. Java just does what Java always does: works through the two terms left to right, and considers the second term (i++) to do something but also to have a value.