Incrementing and Decrementing - Just Trying to Understand
-
Close enough. The decrementing itself really happens while that expression is being evaluated, but that rarely matters. It does matter if you do this:
int x = 0;
int z = x++ + ++x;After that, clearly
xis 2, because it was incremented twice. Andzis also 2, proving that the increment really happens while the expression is evaluated. Firstx++is evaluated, the result is 0 and the effect is thatxis now 1. Then++xis evaluated,xwas 1 and for pre-increment the result is the value after the increment, so the result is two (the effect is again thatxis incremented, of course). So that works out to0 + 2. The left-to-right rules goes even further, if you have an assignment where there's an increment on the left hand side (yes, you can do that), it happens before the right hand side is evaluated, which can be demonstrated with something like this:int[] array = new int[2];
int x = 0;
array[x++] = x++;After that,
xis 2, obviously, andarraylooks like this:{ 1, 0 }What happened, was the firstx++was evaluated first, making the index into the array 0, then the right hand side is evaluated, which is 1 due to the first increment, and thenxis incremented again, and finally the value of the right hand side (which was 1) is stored in the array at index 0.:confused: after all that dumbing it down, I'm thrown for a loop (pun intended). After reading a little bit more in the book they decide to give me a little exercise. int x = 10; int y = 100; int z = y; y = y++ + x; z = ++z + x; I thought I would do this in my head before writing it to the console window. The first expression, the answer I got my head was: 110 (which turned out to be right, woo hoo) The second expression I got wrong, in my head I came up with: 121 the console window printed out: 111 Console.WriteLine(y); Console.WriteLine(z); just before this exercise, the book showed me a table trying to explain: primary, urnary, binary My Coding Journey
-
:confused: after all that dumbing it down, I'm thrown for a loop (pun intended). After reading a little bit more in the book they decide to give me a little exercise. int x = 10; int y = 100; int z = y; y = y++ + x; z = ++z + x; I thought I would do this in my head before writing it to the console window. The first expression, the answer I got my head was: 110 (which turned out to be right, woo hoo) The second expression I got wrong, in my head I came up with: 121 the console window printed out: 111 Console.WriteLine(y); Console.WriteLine(z); just before this exercise, the book showed me a table trying to explain: primary, urnary, binary My Coding Journey
WidmarkRob wrote:
int z = y;
Ok, what happens here is not "make x an other word for y", which is what I think you might have thought. It really means "let x have the value that y now has". y later changed, z did not. Ok z did change, but the assignment to y did not affect it.
WidmarkRob wrote:
y = y++ + x;
does not affect z, only y.
-
:confused: after all that dumbing it down, I'm thrown for a loop (pun intended). After reading a little bit more in the book they decide to give me a little exercise. int x = 10; int y = 100; int z = y; y = y++ + x; z = ++z + x; I thought I would do this in my head before writing it to the console window. The first expression, the answer I got my head was: 110 (which turned out to be right, woo hoo) The second expression I got wrong, in my head I came up with: 121 the console window printed out: 111 Console.WriteLine(y); Console.WriteLine(z); just before this exercise, the book showed me a table trying to explain: primary, urnary, binary My Coding Journey
Try an experiment. When you see a statement involving prefix or postfix increments, mentally (or even physically) re-write it to be several statements, moving the increment outside all other statements.
y = y++ + x;
Becomes:
int y2 = y;
y = y + 1;
y = y2 + x;In other words, the postfix increment of y is irrelevant, because the value is immediately discarded, and y is set to the value of the sum of the original value of y and x
z = ++z + x;
Becomes:
z = z + 1;
z = z + x;That is all the compiler is doing - a prefix or suffix increment just gets done when it is met, that's all - it's syntactic sugar for the broken down statements above. Having said that, try not to use them in "complex" statements: What happens may not be what you expect - different compilers interpret "when to do this" slightly differently, and that gave have a dramatic effect. Normally, pre-and post- increments are kept to simple things like array accesses and
forloops.The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
Try an experiment. When you see a statement involving prefix or postfix increments, mentally (or even physically) re-write it to be several statements, moving the increment outside all other statements.
y = y++ + x;
Becomes:
int y2 = y;
y = y + 1;
y = y2 + x;In other words, the postfix increment of y is irrelevant, because the value is immediately discarded, and y is set to the value of the sum of the original value of y and x
z = ++z + x;
Becomes:
z = z + 1;
z = z + x;That is all the compiler is doing - a prefix or suffix increment just gets done when it is met, that's all - it's syntactic sugar for the broken down statements above. Having said that, try not to use them in "complex" statements: What happens may not be what you expect - different compilers interpret "when to do this" slightly differently, and that gave have a dramatic effect. Normally, pre-and post- increments are kept to simple things like array accesses and
forloops.The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
OriginalGriff wrote:
different compilers interpret "when to do this" slightly differently
Not in C#. Or if they do, it's a compiler bug. There is only one right order of side-effects in C#, which is left-to-right.
I originally did add something to that effect, but deleted it because I didn't want to confuse the OP too much. Anyone who starts writing code like
int y = 10;
y = y++ + ++y*y--;deserves the headache they are going to get1. 1 When I find out and hit them. 154, by the way.
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
I originally did add something to that effect, but deleted it because I didn't want to confuse the OP too much. Anyone who starts writing code like
int y = 10;
y = y++ + ++y*y--;deserves the headache they are going to get1. 1 When I find out and hit them. 154, by the way.
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
Ok, but IMHO you could now be confusing the OP with the possibility that there's some sort of quantum-magic involved that makes the result depend on the phase of the moon or something..
Do you want to sit there and work out why
y++ + ++y * y--equals 154? Quantum magic works for me! :laugh:The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
Do you want to sit there and work out why
y++ + ++y * y--equals 154? Quantum magic works for me! :laugh:The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
Easy, 10 + 12 * 12. The complex cases don't really matter of course, I'm sure we're in agreement there - I just brought them into this to prove to OP that it really works that way.
:laugh: I know - but it's not that obvious when you look at it, particularly if you come from a C / C++ background where a different result is a strong possibility. DevC++ will give you 132 for example.
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
WidmarkRob wrote:
It is declared at 100.
Yes the initial value is 100, did you see the y--? As you were told, the -- is the decrement operator that makes y 99. The -- is short hand for y = y - 1.
ThePhantomUpvoter wrote:
The -- is short hand for y = y - 1
That's not entirely correct. The point behind the '--' being in front of the expression or behind it just tells the compile WHEN to increment or decrement the expression. The operation is either going to happen before the expression is evaluated, in his case
y, or after.A guide to posting questions on CodeProject[^]
Dave Kreskowiak -
:laugh: I know - but it's not that obvious when you look at it, particularly if you come from a C / C++ background where a different result is a strong possibility. DevC++ will give you 132 for example.
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
Now you see why I hit people who do it! :laugh:
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
Now you see why I hit people who do it! :laugh:
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
.. And if they turn the other cheek, hit them again :laugh: This has got to be close to using GoTo statments or possibly worse....
-
.. And if they turn the other cheek, hit them again :laugh: This has got to be close to using GoTo statments or possibly worse....
I think of it as "Codefuscating" ;)
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
.. And if they turn the other cheek, hit them again :laugh: This has got to be close to using GoTo statments or possibly worse....
-
I think of it as "Codefuscating" ;)
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
Worse. With goto at least only one thing can happen, even if it's not always immediately clear what that thing is.
I have seen some pretty nasty goto's in my life, but I have to agree that this seems to take the cake. Why would anybody want to use such a feature anyway, it seems daft.
-
To you or the compiler or perhaps both? :laugh:
Oh just me, the compiler knows what it's doing. I just guess. :laugh:
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
Oh just me, the compiler knows what it's doing. I just guess. :laugh:
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
Quote:
I just guess. debug.
FTFY
-
I get the basic parts of incrementing and decrementing a variable by one. Maybe because I'm not quite thinking like a programmer yet, is why I don't understand this code below. "Console.WriteLine(y); // result = 99 — The value of y after" - this is what's confusing me. How do you get 99 when there is no loop? And doesn't 100 become 99 before you add it to 10? Of course after compiling this, it worked. It came from a book from BrainMeasures dot com. They said the book was even for novices (PSSH) Dummy it down for me quite a bit please. :-) LOL
using System;
class ArithmeticOperators
{
public static void Main()
}
int x = 10;
int y = 100;
int z = y-- + x;
Console.WriteLine(z); // result = 110
Console.WriteLine(y); // result = 99 — The value of y after
// decrementing
z = --z + x;
Console.WriteLine(z); // result = 119
}
}Hi, Sometimes a simple description can be very hard to grasp - especially if the simple description tries to abstract the details away. In such cases I find it rewarding simply to dig a bit deeper... Here goes the details:
.entrypoint
// Code size 51 (0x33)
.maxstack 3
.locals init ([0] int32 x,
[1] int32 y,
[2] int32 z)
IL_0000: nop // evaluation stack is empty []
// int x = 10;
IL_0001: ldc.i4.s 10 // push 10 onto stack [10]
IL_0003: stloc.0 // pop 10 into x []
// int y = 100;
IL_0004: ldc.i4.s 100 // push 100 onto stack [100]
IL_0006: stloc.1 // pop 100 into y []
// int z = y-- + x;
IL_0007: ldloc.1 // push y onto stack [100]
IL_0008: dup // copy top stack value onto stack [100,100]
IL_0009: ldc.i4.1 // push 1 onto stack [1,100,100]
IL_000a: sub // y-- [99,100]
IL_000b: stloc.1 // pop 99 into y [100]
IL_000c: ldloc.0 // push x onto stack [10,100]
IL_000d: add // + x [110]
IL_000e: stloc.2 // pop 110 into z []If instruction, stack and arithmic unit are alien terms to you, then above might be a bit tough. It is a window into a lower layer of code. The C# compiler outputs this in binary form as your assembly/executable. IL means Intermediate Language and it can be executed by a Virtual Machine aka a program. The idea is to simulate the arithmic unit of a cpu, so above code is also a window into history. -- and ++ are special language features that comes nearly for free because of the (virtual) machine architecture. I produced above from your code example by running IL Disassembly from Microsft .Net. Kind Regards, Keld Ølykke
