Pre vs Post Increment

Question

I get the basis for the pre and post increment, but having trouble wrapping my mind when it actually takes place on a post increment.

For example in the following post increment code:

int counter = 10;
int result = 0;

result = counter++ + 10;

cout << "Counter: " << counter << endl;
cout << "Result: " << result << endl;

I understand that Counter will come out as 11 and result at 20. Is Result coming out at 20 because the entire function is being run, and THEN it is adding +1 when the program goes to return 0; ?

When exactly is that +1 getting added?

Thanks

Answer 1

When exactly is that +1 getting added?

According to the standard:

The value computation of the ++ expression is sequenced before the modification of the operand object.

From a layman's point of view:

1. Computation of counter is sequenced, which could be part of the entire RHS of the statement or just the term counter++.
2. Computation of counter += 1 is sequenced before the next statement in the program is sequenced.

There are two things to keep in mind.

1. The value of a term -- what it evaluates to in an expression.
2. The side effects of the evaluation of the term.

In the case of counter++:

The value of the term is the value of counter before it is incremented.
The side effect of evaluation of the term is incrementing of the value of counter.

Answer 2

Also for a better understanding you can consider these loosely described examples:

• think of the pre-increment for the_object of the_type as a function like this:

the_object = the_object + 1;
return the_object;

• now think of the Post-increment for the_object of the_type as a function like this:

the_type backup_of_the_object;
backup_of_the_object = the_object;
the_object = the_object + 1;
return backup_of_the_object;

Now consider:

result = counter++ + 10;

When the program is being compiled:

1. compiler sees result = at the beginning of the line, so it should first determine what is placed at the right side of = and then produce the machine code to assign it to the left side of = which is result.
2. compiler sees counter but the statement has not ended because; has not been reached yet. So now it knows that it also has to do something with counter.

3. compiler sees ++ but the statement has not ended. So now it knows that it has to consider producing the machine code to perform counter++ first.

4. compiler sees +. So now it knows that it has to consider producing the machine code to add the right side of + and the left side of + which was counter++.

5. compiler sees 10; and finally the statement has ended. So now it knows all that it needed to know! It knows that after producing the machine code to perform counter++, it should produce the machine code to add 10 to the outcome_of it. Then it should produce the machine code to assign the outcome_of that to the result.

when the program is running:

1. CPU should perform counter++

now counter is incremented by 1 hence it is 11 but the outcome_of(counter++) is the previous value of the counter which is 10

2. CPU should perform outcome_of(counter++) + 10

now outcome_of(outcome_of(counter++) + 10) is outcome_of(10 + 10) which is 20

3. CPU should perform result = outcome_of(outcome_of(counter++) + 10)

now result is 20

Also please note that every stages that was described was only about
result = counter++ + 10;
regardless of what is going to happen afterwards. Meaning before

cout << "Counter: " << counter << endl;
cout << "Result: " << result << endl;

so obviously before main() returns 0.

In my opinion you should take it easy and learn it through experience by writing and running some programs!

Good luck!

Answer 3

Post-increment operator: A post-increment operator is used to increment the value of variable after executing expression completely in which post increment is used. In the Post-Increment, value is first used in an expression and then incremented.

So in your case

result = counter++ + 10;

post increment takes place after it has been used in this statement, and obviously it is reflected in next statement.