Increment and Decrement Operators
-
hey i want to rectify Message send by Richard MacCutchan
int i = 10;
int result;
result = i++; // result equals 10, i equals 11
result = ++i; // result equals 12, i equals 12
result = i--; // result equals 12, i equals 11
result = --i; // result equals 10, i equals 10// note do not use expressions such as
result = ++i + i++; // results undefinedAs written the last line gives output undefine i think its wrong .it will give correct output as 23. If u had checked then u already got the result. here i will explan u how it's work.. 1:from left to right ++i changes i values 10 to 11. 2:then it will add 11 + 11 (as i++ is post increment operator it will execute after expression execution) and gives result as 22 3: then i values becomes 22 and i++ will going to execute and i value changes to 22+1=23
I'll explain why the behavior is undefined... This has a lot to do with operator precedence[^], see the ++ as a prefix operator has an equal precedence to the + operator. Its up to the compiler to determine which one to evaluate first, since they are at an equal precedence there is no universal "++(pre) before +". However, ++ as a postfix operator has a higher precedence than the prefix operator, so for example: i = 10 result = ++i + i++; Turns into result = ++i + 11; Now, the compiler really doesn't care which one is evaluated first, the + or the ++. Each one is free to implement it as they see fit, so it might be 22 or it might be 23, it depends on which one the programmer handled first.
-
I'll explain why the behavior is undefined... This has a lot to do with operator precedence[^], see the ++ as a prefix operator has an equal precedence to the + operator. Its up to the compiler to determine which one to evaluate first, since they are at an equal precedence there is no universal "++(pre) before +". However, ++ as a postfix operator has a higher precedence than the prefix operator, so for example: i = 10 result = ++i + i++; Turns into result = ++i + 11; Now, the compiler really doesn't care which one is evaluated first, the + or the ++. Each one is free to implement it as they see fit, so it might be 22 or it might be 23, it depends on which one the programmer handled first.
-
Hi everyone....this Increment(++) and Decrement(--) operators in C topic is really one of the surprise topic for me as I always get some surprise with their answer. The time I thought I got the concept of this topic I find my self wrong with its next question. I want to know what is its actual concept and whats the best approach to solve inc and dec operator questions. Make me understand with an example. Appreciate your suggestion and help. Thanks
O God....wow I am not the only one who is confused? This is the problem I specified when I started this thread, I got surprising answers when i solve these inc and dec problems.So who is correct please tell me and whom explaination I go with to pursue my learning on this topic?
-
Richard MacCutchan wrote:
but it is still worth avoiding expressions of that sort.
Every respectable Dev must avoid it. By the way, my comment was intended to be an addition to yours.
Veni, vidi, caecus | Everything summarizes to Assembly code
-
no no..in any compiler prefix operator execute first than postfix. postfix will execute after value returned or assigned to some variable..
-
O God....wow I am not the only one who is confused? This is the problem I specified when I started this thread, I got surprising answers when i solve these inc and dec problems.So who is correct please tell me and whom explaination I go with to pursue my learning on this topic?
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
ishould always be the same: 12 but the value ofxcan 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
-
hey i want to rectify Message send by Richard MacCutchan
int i = 10;
int result;
result = i++; // result equals 10, i equals 11
result = ++i; // result equals 12, i equals 12
result = i--; // result equals 12, i equals 11
result = --i; // result equals 10, i equals 10// note do not use expressions such as
result = ++i + i++; // results undefinedAs written the last line gives output undefine i think its wrong .it will give correct output as 23.
If u had checked then u already got the result.
here i will explan u how it's work..1:from left to right ++i changes i values 10 to 11.
2:then it will add 11 + 11 (as i++ is post increment operator it will execute after expression execution) and gives result as 22
3: then i values becomes 22 and i++ will going to execute and i value changes to 22+1=23You 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
-
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
ishould always be the same: 12 but the value ofxcan 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
-
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.
You're welcome!
Never underestimate the power of stupid things in large numbers --- Serious Sam
-
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
-
I know increment and decrement operator depend on compiler. actually i had tried it in dev c++.
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
-
These operators merely add (
inc) or subtract (dec) 1 from the item in question. If the operator is used in the postfix position (i++) then the original value is returned. If the operator is used in the prefix position (--i) then the new value is returned. Thus:int i = 10;
int result;
result = i++; // result equals 10, i equals 11
result = ++i; // result equals 12, i equals 12
result = i--; // result equals 12, i equals 11
result = --i; // result equals 10, i equals 10// note do not use expressions such as
result = ++i + i++; // results undefinedVeni, vidi, abiit domum
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 + 11Now 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 + 10In 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)
-
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 + 11Now 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 + 10In 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)
-
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
