Increment and Decrement Operators

[Lost User]

Marco Bertschi wrote:

my comment was intended to be an addition to yours.

Yes, that was how I understood it. :thumbsup:

Veni, vidi, abiit domum

[Lost User]

See http://msdn.microsoft.com/en-us/library/126fe14k.aspx[^].

Veni, vidi, abiit domum

[OriginalGriff]

Pre- and post- fix increment and decrement operations are pretty easy in theory, it's only when people get creative that you get problems in practice. Basically, a prefix (++i or --i) says to increase or decrease the value before you use the variable, so the variable has the new value immediately:

i = 10;
x = ++i + 5;

Can be read as:

i = 10;
i = i + 1;
x = i + 5;

and similarly for the -- version:

i = 10;
x = --i + 5;

Can be read as:

i = 10;
i = i - 1;
x = i + 5;

The postfix version (i++ or i--) does the same thing, but after the variable has been used:

i = 10;
x = i++ + 5;

Can be read as:

i = 10;
x = i + 5;
i = i + 1;

And similarly

i = 10;
x = i-- + 5;

Can be read as:

i = 10;
x = i + 5;
i = i - 1;

The trouble comes when you start mixing operations on the same line (as Richard said):

i = 10;
x = ++i + i++;

The problem is that the language specification does not define exactly when pre- and post- fix operations should occur! Which means that it's implementation specific exactly what you get as a result: The value of i should always be the same: 12 but the value of x can be different depending on the compiler (and to an extent on the target processor - ARM for example has built in pre- and post- fix increment and decrement to it's "machine code" LOAD operations, so it would be quite likely that an efficient compiler would use them directly) Should it be executed as:

i = 10;
i = i + 1;
x = i + i;
i = i + 1;

Which gives the result 22 or as

i = 10;
i1 = i;
i = i + 1;
x = i1 + i;
i = i + 1;

Which gives 21 Or as

i = 10;
i1 = i;
i = i + 1;
x = i + i1;
i = i + 1;

which also gives 21 by a different route And bear in mind that the compiler does not have to evaluate the two operands of "+" in left to right order, so it could even give some very strange and unexpected results! Like 23... So avoid combining them: use them for "simple expressions" such as incrementing an array index each time round a loop, but don't get fancy, or your code may well fail in interesting ways... :laugh:

Never underestimate the power of stupid things in large numbers --- Serious Sam

[OriginalGriff]

You are making unwarranted assumptions! :laugh: It's more complex that that - Richard is right, you shouldn't mix 'em - see my post below for some compiler nasties...

Never underestimate the power of stupid things in large numbers --- Serious Sam

[tgsb]

Thanks sir for highlighting its deep concepts related to the compiler. I hope now I am able to solve these question without getting shocked by their answers. Appreciate all your responses.

[OriginalGriff]

You're welcome!

Never underestimate the power of stupid things in large numbers --- Serious Sam

[Suk nta]

I know increment and decrement operator depend on compiler. actually i had tried it in dev c++.

[OriginalGriff]

If you know that something is compiler dependant, then you can't say "it is like this" - because there is a very good chance that the other person is not using the same compiler! :laugh:

Never underestimate the power of stupid things in large numbers --- Serious Sam

[Stefan_Lang]

Am I the only one to spot that at least one of the problems in your last line is not related to increment and decrement at all? The operator+ which is invoked here needs to evaluate both of its operands, but it's undefined whether the first or second operand is evaluated first - the compiler may choose to do either! So, if the compiler evaluates the first operand first, the following happens:

i = 10;
i = i + 1; // pre-increment of the first argument
first_arg = i;
second_arg = i;
i = i + 1; // post-increment of the second argument
result = first_arg + second_arg; // 11 + 11

Now consider the same on the assumption the compiler evaluates the second operand first:

i = 10;
second_arg = i;
i = i + 1; // post-increment of second argument
i = i + 1; // pre-increment of first argument
first_arg = 1;
result = first_arg + second_arg; // 12 + 10

In this case, the results are the same, but that is just by coincidence - if you had used subtraction in stead of addition you'd be in for a surprise! You may want to check http://en.cppreference.com/w/cpp/language/eval_order[^] for further information regarding both function argument evaluation and increment/decrement.

GOTOs are a bit like wire coat hangers: they tend to breed in the darkness, such that where there once were few, eventually there are many, and the program's architecture collapses beneath them. (Fran Poretto)

[Lost User]

That was exactly my point.

Veni, vidi, abiit domum

[Suk nta]

Thanks