'static' value appears to reset after function call

Question

I found a lot of articles about statics (MSDN, MSDN 2, Stack Overflow, and lot lot more), but I still can't understand why this code returns -1:

class Program
{
    static int value = 0;

    static int foo()
    {
        value = value - 7;
        return 1;
    }

    static void Main(string[] args)
    {
        value -= foo();
        Console.WriteLine(value);
        Console.ReadKey();
    }
}

Here's what the debugger shows after foo() has run, but before the result is subtracted from value:

But one step later, value is -1:

I would expect -8 because of the static field which is stored in memory once.

When I changed it to

var x = foo();
value -= x;

it shows -8

How does this work exactly?

Your `value` is initialized to 0. In `foo()` you subtract 7 from it, so it becomes -7. Then you subtract 1 more from it at ` value -= foo();` because `foo()` returns 1. So you end up with `value == -8`. — pappbence96, Jul 23 '19 at 07:27
@pappbence96 which is exactly what he expects, but isn't getting. — TvanB, Jul 23 '19 at 07:28
@TvanB Sorry, misinterpreted the question! Still early it seems — pappbence96, Jul 23 '19 at 07:29
The best way to understand is to debug the program line by line. — Guy, Jul 23 '19 at 07:30
Debuged this already , when method ends, value = -7, but step next it magically changed on "-1". Thas the problem which can't understand — EmerG, Jul 23 '19 at 07:36
`value -= foo()` is the same as `value = current value of value (0) - foo() which returns 1`, which is the same as `value = 0 - 1`. `foo()` does decrement `value` but only *after* you've referenced it in the calculation that calls `foo()`. Bad explanations have made it difficult to understand, but that's it in a nutshell. — Reinstate Monica Cellio, Jul 23 '19 at 07:43
Statements like `i += i++;` are inherently ambiguous in meaning. Some languages have legalese in place that makes such statements well-defined, other languages (infamously the C family) just say: "The order of operand evaluation is undefined." **It doesn't matter what category your language falls in, code that's ambiguous in this way should not be written as it's hard to understand.** — cmaster - reinstate monica, Jul 24 '19 at 19:43
@DavidConrad there was a misspeliing at archer's comment, it's already fixed. — koviroli, Jul 25 '19 at 06:32
And why exactly is this question up voted so much, it's a debugging problem and has no value to future readers — TheGeneral, Jul 25 '19 at 22:58

score 133 · Accepted Answer · edited Jul 25 '19 at 10:30

133

This problem is not about static; it's about how the subtraction works.

value -= foo(); can be expanded to value = value - foo()

The compiler will explain it into four steps:

Load the value of value onto the stack.
Call the method foo and put the result onto the stack.
Do subtraction with these two values on the stack.
Set the result back to value field.

So the original value of value field is already loaded. Whatever you change value in the method foo, the result of the subtraction won't be affected.

If you change the order to value = - foo() + value, then the value of value field will be loaded after foo is called. The result is -8; that's what you are expected to get.

Thanks for Eliahu's comment.

edited Jul 25 '19 at 10:30

Peter Mortensen

30,738
21
105
131

answered Jul 23 '19 at 08:02

shingo

18,436
5
23
42

14

If you change `value = foo() - value` to `value = -foo() + value;` in your last sentence you will get the 'expected' result `-8` – Eliahu Aaron Jul 23 '19 at 08:17
7

@EliahuAaron ...probably. The order of evaluation of operands [is unspecified/unsequenced](https://stackoverflow.com/questions/7112282/), so the compiler would be allowed to evaluate the two arguments in either order, or indeed in parallel. But your comment usefully emphasises that `-=` is a more complicated thing than may at first appear. – Norman Gray Jul 24 '19 at 08:43
12

@NormanGray you remind me to search definition from specification, the link is c++ standard, and I find [one for c#](https://github.com/dotnet/csharplang/blob/master/spec/expressions.md#operators), it's from left to right. – shingo Jul 24 '19 at 09:13
1

Wait, does this mean that addition is **not** commutative? – Alberto Santini Jul 25 '19 at 05:37
3

@AlbertoSantini The addition part is. You don't get an analogue in Maths, since in an immutable world, the problem doesn't exist. It comes from mutability - depending on the order you do `value` and `foo()`, you get different results. The final addition, `a + b`, is commutative, but how you *get* `a` and `b` isn't. – Luaan Jul 25 '19 at 07:57
6

@AlbertoSantini Because of [side effects](https://en.wikipedia.org/wiki/Side_effect_(computer_science)), it is not. `A + B` means _first_ evaluate `A` (might cause side effects), keep the result, _then_ evaluate `B` (side effects), finally add the results. – Jeppe Stig Nielsen Jul 25 '19 at 11:33
2

@AlbertoSantini (Another thing: Some overloads of `+` may be non-commutative for another reason, for example without side effects `"Hello" + "world"` is different from `"world" + "Hello"`, but I guess you would not call string concatenation "addition" even if it uses the operator `+`. User-defined overloads of the `+` operator can do anything, for example `DateTime.Now + TimeSpan.FromHours(0.5)` is OK, but `TimeSpan.FromHours(0.5) + DateTime.Now` does not match any overload.) – Jeppe Stig Nielsen Jul 25 '19 at 11:33

DotNet Developer · Answer 2 · 2019-07-23T07:53:34.867

62

The statement

value -= foo(); // short for value = value - foo();

is equivalent to

var temp = value; // 0
var fooResult = foo(); // 1
value = temp - fooResult; // -1

That's why you are getting -1

edited Jul 23 '19 at 07:53

answered Jul 23 '19 at 07:33

DotNet Developer

2,973
1
15
24

11

@Bahrom: It seems to work like you claim, but why? – Eliahu Aaron Jul 23 '19 at 07:37
16

@EliahuAaron: Because the C# spec says so. And why does the C# spec say so? Because (a) having a deterministic order of evaluation and (b) a -= b behaving like a = a - b (while evaluating `a` only once) are both widely considered to be good ideas. Would you have specified it differently? If yes, how, and why? – Heinzi Jul 24 '19 at 20:22

score 33 · Answer 3 · edited Jul 25 '19 at 10:39

Just look at the generated CIL:

.method private hidebysig static int32  foo() cil managed
{
  // Code size       19 (0x13)
  .maxstack  2
  .locals init ([0] int32 V_0)
  IL_0000:  nop
  IL_0001:  ldsfld     int32 Program::'value'
  IL_0006:  ldc.i4.7
  IL_0007:  sub
  IL_0008:  stsfld     int32 Program::'value'
  IL_000d:  ldc.i4.1
  IL_000e:  stloc.0
  IL_000f:  br.s       IL_0011
  IL_0011:  ldloc.0
  IL_0012:  ret
} // end of method Program::foo

IL_0001: - Push the value of the static field on the stack. s:[value(0)]
IL_0006: - Push 7 onto the stack. s:[7, value(0)]
IL_0007: - Subtracts value2 (7) from value1 (0), returning a new value (-7).
IL_0008: - Replaces the value of the static field with val (value = -7).
IL_000d: - Push 1 onto the stack. s:[1, 7, value(-7)]
IL_000e: - Pop a value from stack into local variable 0. (lv = 1)
IL_0011: - Load local variable 0 onto stack. s:[lv(1), 7, value(-7)]
IL_0012: - Return (lv(1))

And the Main method:

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       29 (0x1d)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldsfld     int32 Program::'value'
  IL_0006:  call       int32 Program::foo()
  IL_000b:  sub
  IL_000c:  stsfld     int32 Program::'value'
  IL_0011:  ldsfld     int32 Program::'value'
  IL_0016:  call       void [mscorlib]System.Console::WriteLine(int32)
  IL_001b:  nop
  IL_001c:  ret
} // end of method Program::Main

IL_0001: - pushes value onto stack (which is 0)
IL_0006: - calls foo (which will return 1)
IL_000b: - subtract values: value2(1) from value1(0) (value(0) - value(1) = -1).

So the result is -1.

score 17 · Answer 4 · edited Jul 25 '19 at 10:45

You can use menu Debug → Windows → Disassembly and check what goes on in the background:

I commented the most interesting parts.

    //static int value = 0;
    05750449  mov         ebp,esp
    0575044B  push        edi
    0575044C  push        esi
    0575044D  push        ebx
    0575044E  sub         esp,2Ch
    05750451  xor         edx,edx
    05750453  mov         dword ptr [ebp-10h],edx
    05750456  mov         dword ptr [ebp-1Ch],edx
    05750459  cmp         dword ptr ds:[15E42D8h],0
    05750460  je          05750467
    05750462  call        55884370
    05750467  xor         edx,edx
    05750469  mov         dword ptr ds:[15E440Ch],edx  // STEP_A place 0 in ds register
 somewhere
    0575046F  nop
    05750470  lea         esp,[ebp-0Ch]
    05750473  pop         ebx
    05750474  pop         esi
    05750475  pop         edi
    05750476  pop         ebp
    05750477  ret

    //value -= foo();
    057504AB  mov         eax,dword ptr ds:[015E440Ch]   // STEP_B places (temp) to eax. eax now contains 0
    057504B0  mov         dword ptr [ebp-40h],eax
    057504B3  call        05750038



    057504B8  mov         dword ptr [ebp-44h],eax
    057504BB  mov         eax,dword ptr [ebp-40h]
    057504BE  sub         eax,dword ptr [ebp-44h]   //STEP_C substract the return(-1) of call from the temp eax
    057504C1  mov         dword ptr ds:[015E440Ch],eax  // STEP_D moves eax (-1) value to our ds register to some memory location

    //Console.WriteLine(value);
    015E04C6  mov         ecx,dword ptr ds:[015E440Ch]  // Self explanatory; move our ds(-1) to ecx, and then print it out to the screen.
    015E04CC  call        54CE8CBC

So it is true that when writing value -= foo(), it generates code something like this:

value = 0; // In the beginning STEP_A

//... main
var temp = value; //STEP_B
temp -= foo(); // STEP_C
value = temp; // STEP_D

score 7 · Answer 5 · edited Jul 25 '19 at 10:46

7

I think it has something to do with how it subtracts value on the assembly level, and that causes some inconsistency in the program. I don't know if it has something to do with static or not. But from my intuition this is what happens:

Let's focus on value -= foo()

The old value get saved (pushed to the stack)
The foo() function returns 1
Now, the value is -7 due to foo() operation
HERE is the problem: The OLD value (which is the one that saved earlier, which is 0) subtracted with 1 and the result assigned to the current value.

edited Jul 25 '19 at 10:46

Peter Mortensen

30,738
21
105
131

answered Jul 23 '19 at 09:02

mol

103
4

5

It's not just an accident - the C# specification specifically defines the order of execution in such a case - the compiler is not allowed to produce code that would output anything else than `-1`, unlike in C. – Luaan Jul 25 '19 at 08:04

score 5 · Answer 6 · edited Jul 25 '19 at 10:31

5

value -= foo(); // value = value - foo();

foo() will return 1.

value is initially 0, so: 0 = 0 - 1.

Now the value has -1.

So the issue is with return 1.

edited Jul 25 '19 at 10:31

Peter Mortensen

30,738
21
105
131

answered Jul 23 '19 at 08:03

Arun Pandian k

125
8

3

This answer ignores the fact that calling `foo` changes `value`. – Theraot Jul 24 '19 at 10:25
2

@Theraot: This answer is correct; the fact that `foo` changes `value` is irrelevant. Regardless of what values `foo` changes, the fact is that subtraction in C# proceeds from left-to-right. – Eric Lippert Jul 25 '19 at 19:14
1

@EricLippert that is true, however, it is still not good explaining it. – Theraot Jul 25 '19 at 19:15
1

@Theraot i have explained only the core-concept, remaining upto you. – Arun Pandian k Aug 01 '19 at 11:45

'static' value appears to reset after function call

6 Answers6