Incrementing and Decrementing - Just Trying to Understand
-
: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
-
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)
I see you guys have been busy bees about this… I had to take a break, steam was coming from my ears because of this. Anyway, I looked over the example in the exercise they gave me. Give me about 30 min., I'll explain to you guys but I ended up getting the second expression in my exercise wrong. By the way, thank you for trying to help clear this up for me. Rob My Coding Journey
-
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
Okay, just to recap… I'm going to show the example they gave me first… Then tell you how I understand what you guys have been trying to help me with. Then I will post my exercise towards the end and try to explain how I came up with my answer doing it in my head before running the program and printing it to the console window.
// Example 3-2.cs
// Increment and Decrement
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
}
}So, we print out the variable z… Like it says, the result is 110. Okay, easy enough. Just in my mind, the variable y automagically becomes 99. Anyway, you guys have explained to me that the variable y takes on the new value after evaluating the expression. Semi-sort of easy enough. Using this as somewhat of a template for my exercise is probably what threw me off. In the exercise, I got the first expression done in my head correctly. Meaning it matched what the console window printed out. The second expression, using the example above. I also thought the variable y would become the new value after evaluating the first expression. That's why in my head, I came up with 121… The console window printed out 111. Drill 3-1 Start with the following assignments: int x = 10; int y = 100; int z = y; Then write a C# program to compute and display the values of the variables y and z after executing these expressions: y = y++ + x; z = ++z + x; My Online Journey
