struct value types

Question

I know that struct is a value type , that means it defined on stack .

But I can do A a = new A(); (A my struct of course). and it defined on heap , and only the reference variable is on stack.

Can you explain me this one please .

Answer 1

Value types are stored on the stack sometimes. It's a complex topic and usually the exact storage of a variable (stack or heap) is irrelevant for programming issues. The real difference between value and reference types lies in their behaviour (for example, value types are always copied by value).

Eric Lippert covers this issue in detail:

• http://blogs.msdn.com/b/ericlippert/archive/2009/04/27/the-stack-is-an-implementation-detail.aspx
• http://blogs.msdn.com/b/ericlippert/archive/2009/05/04/the-stack-is-an-implementation-detail-part-two.aspx
• http://blogs.msdn.com/b/ericlippert/archive/2010/09/30/the-truth-about-value-types.aspx

Answer 2

Where a local variable is stored is an implementation detail.
Simple local variables are usually stored in the CPU-registers and/or the stack.

If they are captured in a closure they'll be rewritten into members in a heap allocated object. That's because the lamda might outlive it's creating functions, and thus the variables it uses must be able to live long enough too.

Unlike in C++ in C# the new does not imply a heap allocation. It's just the syntax for calling a constructor.

And calling new on a value-type doesn't have the semantics of a placement new either. It has the semantics of constructing an instance somewhere and then copying it into the target variable.

In my mental model there are two types of storage:

1. Local storage that can't outlive the return of the function. This includes stack and registers.
2. Global storage that lives until it isn't referenced anymore. This is usually the heap. But in run-times that do escape analysis it might be put on the stack if the runtime proves that no references will survive the function.

Your example falls into the first kind of storage since you use a value type.

Answer 3

Your code (A a = new A();) creates and initializes the struct. If it is a local variable, it is initialized on the stack. If it is a member variable, it is initialized on the heap as part of the object. Using "new" doesn't necessarily mean a heap allocation in C#/.NET. It depends on the context.

Answer 4

The original assumption that value types live "on the stack" is not correct. However, The Truth About Value Types has been revealed by Eric Lippert:

1. It is usually stated incorrectly: the statement should be "value types can be stored on the stack", instead of the more common "value types are always stored on the stack".
2. It is almost always irrelevant. We've worked hard to make a managed environment where the distinctions between different kinds of storage are hidden from the user. Unlike some languages, in which you must know whether a particular storage is on the stack or the heap for correctness reasons.
3. It is incomplete. What about references? References are neither value types nor instances of reference types, but they are values. They've got to be stored somewhere. Do they go on the stack or the heap? Why does no one ever talk about them? Just because they don't have a type in the C# type system is no reason to ignore them.

Answer 5

But I can do A a = new A(); (A my struct of course). and it defined on heap , and only the reference variable is on stack.

If A is a value type as you say, and a is a method local, it will be allocated on the stack. Unless a is used in a closure -- then it will be allocated as part of a heap-allocated object of a compiler-generated class.

If you want further analysis, you will have to post the definition of the A type as well as the entire method where you define this variable.