Structs

Question

Hi any one tell me that when i using Structs and structs is value type (means it will store in Stack right...?) and when i make its object of struct where it will store heep side either stack side...?

Vulpes · Answer

In summary struct instances which are: 1. assigned to local variables of the struct type; 2. assigned to parameters passed by value of the struct type; or 3. fields of other struct instances assigned as in 1. or 2. above; are stored on the stack. All other struct instances - static fields elements of arrays instance fields of classes or 'boxed' structs - are stored on the heap. Here's an example to help make all this clear: using System; struct Point { public int X Y; public Point (int x int y) { X = x; Y = y; } public override string ToString() { return String.Format([{0} {1}] X Y); } } class Test { static Point p1 = new Point(100 100); // static field stored on heap Point p2 = new Point(100 200); // instance field of class stored on heap static void Main() { Point p3 = new Point(100 300); // local variable stored on stack Point[] points = new Point[]{new Point(100 400)}; // element of array stored on heap int x = p3.X; // field of other stack-allocated struct stored on stack object o = p3; // boxed Point instance stored on heap Display(p1); Test t = new Test(); Display(t.p2); Display(p3); Display(points[0]); Console.WriteLine(x); Console.WriteLine(o); Console.ReadKey(); } static void Display (Point p) { // p is passed by value i.e a copy of p is made which is stored on the stack Console.WriteLine(p); } }

Zoran Horvat · Answer

Every instance whether it is value or reference type is a block of successive bytes allocated somewhere. Value and reference types differ in way in which it is determined where these bytes are actually allocated. Value type instance is allocated in place where declared. Reference type instance will always be allocated on heap and on place of declaration only a 4- or 8-byte scalar will be allocated (depending on CPU) which merely keeps the address on the heap where the block begins. Hence value type can be allocated as part of a stack frame if declared as a local variable in the method. Or it can be allocated on the heap if declared as part of a larger instance which goes to the heap e.g. the simplest case is if declared as a field in a class. For example if you declare a struct Point{ int x; int y } and do this: Point p = new Point(5 3) that would surely go onto stack. But if you do this: Point[] p = new Point[40]; then that would go to heap because array is a reference type. In more details one instance of Point takes four bytes for x and four bytes for y. So first instantiation of only one Point instance will take 8 bytes on stack as part of the current stack frame. In second case when array of 40 points is allocated that would allocate 40x8=320 successive bytes on heap. The example with array of 40 points also raises the question of default constructors in structures. C# does not allow parameterless constructors on structures (though CLR does) but rather leaves CLR to allocate array of structures and to zero them out in a single assembler instruction which is extremely efficient.

Jaganathan Bantheswaran · Answer

Hi When you call the New operator on a class it will be allocated on the heap. However when you instantiate a struct it gets created on the stack. This will yield performance gains. Also you will not be dealing with references to an instance of a struct as you would with classes. You will be working directly with the struct instance. Because of this when passing a struct to a method it's passed by value instead of as a reference.