Incrementing and Decrementing - Just Trying to Understand
-
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
-
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
WidmarkRob wrote:
int z = y-- + x;
WidmarkRob wrote:
Anyway, you guys have explained to me that the variable y takes on the new value after evaluating the expression.
ytakes on the new value ofy, which is sort of tautological.. One is subtracted fromy, that is all. -
WidmarkRob wrote:
int z = y-- + x;
WidmarkRob wrote:
Anyway, you guys have explained to me that the variable y takes on the new value after evaluating the expression.
ytakes on the new value ofy, which is sort of tautological.. One is subtracted fromy, that is all.Yes, I get that now… Post-fix decrementing… It takes on the new value after evaluating the expression. On to my new problem. I used this same type of thinking with my so-called simple exercise I was given. y = y++ + x; z = ++z + x; In using that same thought process of y taking on the new value after evaluating the expression, in this new problem (the first expression). I did this in my head before printing it to the console window and came up with 121. The console window printed 111. In trying to keep things in semi-sort of uniform fashion. In my head, I also thought this variable y would take on the new value as well. Where did I go wrong in my head? My Coding Journey
-
Yes, I get that now… Post-fix decrementing… It takes on the new value after evaluating the expression. On to my new problem. I used this same type of thinking with my so-called simple exercise I was given. y = y++ + x; z = ++z + x; In using that same thought process of y taking on the new value after evaluating the expression, in this new problem (the first expression). I did this in my head before printing it to the console window and came up with 121. The console window printed 111. In trying to keep things in semi-sort of uniform fashion. In my head, I also thought this variable y would take on the new value as well. Where did I go wrong in my head? My Coding Journey
-
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; This exercise is virtually the same as the example they gave to me in the beginning. (My original question I was asking about) When I print the variable y to the console window, the result is 110. (Which is what I came up but in my head) Using the same thought process as in the example, where this variable y also takes on the new value (110)… I used this new value in my head. This so-called simple exercise is using "Boxing"? (Just throwing in another term that I learned, hopefully using it correctly) the variable z now equals the variable y. (Which in my mind, I thought would equal 110) The second expression. Prefixes incrementing. So I thought, 110+1+10. That's how I came up with 121 in my head. When I went to go print the variable z to the console window, the result was 111. My Coding Journey
-
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; This exercise is virtually the same as the example they gave to me in the beginning. (My original question I was asking about) When I print the variable y to the console window, the result is 110. (Which is what I came up but in my head) Using the same thought process as in the example, where this variable y also takes on the new value (110)… I used this new value in my head. This so-called simple exercise is using "Boxing"? (Just throwing in another term that I learned, hopefully using it correctly) the variable z now equals the variable y. (Which in my mind, I thought would equal 110) The second expression. Prefixes incrementing. So I thought, 110+1+10. That's how I came up with 121 in my head. When I went to go print the variable z to the console window, the result was 111. My Coding Journey
It's pretty simple:
int x = 10;
int y = 100;
int z = y;At the end of this, you have three variables, each with separate values:
x y z
10 100 100Although "y" and "z" contain the same number, they aren't linked together, so changing one does not change the other. Think of them as three pockets: two in your trousers, and one in your shirt. If you put ten coins in each pocket, they all have the same number. If you then take 5 coins out of your shirt pocket, you still have ten coins in each of your trouser pockets.
y = y++ + x;
Equates to:
int y2 = y;
y = y + 1;
y = y2 + x;Which means that "y" ends up holding 110 - as you have seen.
z = ++z + x;
Is the equivalent of:
int z2 = z + 1;
z = z2 + x;Which is the same as saying:
z = 11 + 100;
Which gives you the answer: 111
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
It's pretty simple:
int x = 10;
int y = 100;
int z = y;At the end of this, you have three variables, each with separate values:
x y z
10 100 100Although "y" and "z" contain the same number, they aren't linked together, so changing one does not change the other. Think of them as three pockets: two in your trousers, and one in your shirt. If you put ten coins in each pocket, they all have the same number. If you then take 5 coins out of your shirt pocket, you still have ten coins in each of your trouser pockets.
y = y++ + x;
Equates to:
int y2 = y;
y = y + 1;
y = y2 + x;Which means that "y" ends up holding 110 - as you have seen.
z = ++z + x;
Is the equivalent of:
int z2 = z + 1;
z = z2 + x;Which is the same as saying:
z = 11 + 100;
Which gives you the answer: 111
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
where it confuses me, if you look at the example I posted… The variable y takes on a new value after evaluating the expression. In my head, I was applying that same logic/thinking too my exercise. I also thought, in my exercise… That the variable y would also take on the new value (in this case, 110) after evaluating the first expression. My Coding Journey
-
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
}
}This line is the important one: int z = y-- + x; it says to the computer, assign y + x into a variable called z. When you've done that knock one off the stored value of y. so, in the line int z = y-- + x; z gets assigned with 100 + 10 (110) then y gets reduced to 99. In the line z = --z + x; The operation goes; knock one off z then assign the sum of z + x to z. ie. take 1 off 110(z) to get 109; THEN assign 109+10 to z. Basically if the ++ or -- is BEFORE the variable name (--y) then the operation is done BEFORE the rest of the line. But, if the ++ or -- is AFTER the variable name, the operation is done AFTER the rest of the line. Simples! :-)
-
where it confuses me, if you look at the example I posted… The variable y takes on a new value after evaluating the expression. In my head, I was applying that same logic/thinking too my exercise. I also thought, in my exercise… That the variable y would also take on the new value (in this case, 110) after evaluating the first expression. My Coding Journey
It does. But since you don't use "y" in the second expression that doesn't have any effect. Changing the value in "y" doesn't affect the value in "x" or "z" - it's like they are separate pockets. Adding coins to your shirt pocket doesn't affect the number of coins in either of your trouser pockets! :laugh: So:
int x = 10;
int y = 100;
int z = y;
y = y++ + x;
// At this point, X = 10, y = 110 and z = 100;
z = ++z + x;
// At this point, X = 10, y = 110 and z = 111The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
This line is the important one: int z = y-- + x; it says to the computer, assign y + x into a variable called z. When you've done that knock one off the stored value of y. so, in the line int z = y-- + x; z gets assigned with 100 + 10 (110) then y gets reduced to 99. In the line z = --z + x; The operation goes; knock one off z then assign the sum of z + x to z. ie. take 1 off 110(z) to get 109; THEN assign 109+10 to z. Basically if the ++ or -- is BEFORE the variable name (--y) then the operation is done BEFORE the rest of the line. But, if the ++ or -- is AFTER the variable name, the operation is done AFTER the rest of the line. Simples! :-)
-
I know - BUT, why the hell would anyone write such a monstrosity. ;P Also, as it was clearly a beginner question, I was trying to simplify. So you get 10/10 for correctness but 2/10 for being clear for the sake of the OP.. :omg:
-
I know - BUT, why the hell would anyone write such a monstrosity. ;P Also, as it was clearly a beginner question, I was trying to simplify. So you get 10/10 for correctness but 2/10 for being clear for the sake of the OP.. :omg:
-
It does. But since you don't use "y" in the second expression that doesn't have any effect. Changing the value in "y" doesn't affect the value in "x" or "z" - it's like they are separate pockets. Adding coins to your shirt pocket doesn't affect the number of coins in either of your trouser pockets! :laugh: So:
int x = 10;
int y = 100;
int z = y;
y = y++ + x;
// At this point, X = 10, y = 110 and z = 100;
z = ++z + x;
// At this point, X = 10, y = 110 and z = 111The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
Okay, I get what you're saying about the different pockets. This variable y in this exercise is clearly not the same as the variable y in the example. In the example: y takes on the new value after evaluating the expression. Okay, I understand (sort of) In the exercise: y does not take on a new value after evaluating the first expression. Different pockets and something like that. Okay, I guess my question is: When it is postfix, the variable takes on the new value? When it is prefix, the variable does not take on the new value? My Coding Journey
-
Okay, I get what you're saying about the different pockets. This variable y in this exercise is clearly not the same as the variable y in the example. In the example: y takes on the new value after evaluating the expression. Okay, I understand (sort of) In the exercise: y does not take on a new value after evaluating the first expression. Different pockets and something like that. Okay, I guess my question is: When it is postfix, the variable takes on the new value? When it is prefix, the variable does not take on the new value? My Coding Journey
No, no - sorry, I'm probably confusing you. Let's go right back to the beginning. Assume we have a function with just a two lines of code:
int x = 10;
Console.WriteLine(x);If we run it, we obviously get "10" printed. So let's start with that and add bits between the two lines.
int x = 10;
x++;
Console.WriteLine(x);Will print 11, because the post increment adds one to the value of
xint x = 10;
++x;
Console.WriteLine(x);Will also print 11, because the pre increment adds one to the value as well. Prefix and postfix operations always affect the value of the variable; the only difference is when the variable is altered. With prefix, the variable is altered before it's value is used: So
int x= 10;
int y = ++x;
Console.WriteLine("x={0}, y = {1}", x, y);will give us "x = 11, y = 11" because x was altered before it's value was used in the expression. This is the equivalent of writing:
int x = 10;
x = x + 1;
int y = ++x;
Console.WriteLine("x={0}, y = {1}", x, y);With post fix, the variable is altered after its's value is used in the expression:
int x = 10;
int y = x++;
Console.WriteLine("x={0}, y = {1}", x, y);Will give us "x=11, y = 10" and is the equivalent of writing:
int x= 10;
int y = x;
x = x + 1;
Console.WriteLine("x={0}, y = {1}", x, y);Does that make sense so far?
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
