Structs

Smart Lucky

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...?

3 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes15y ago
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);
}

}
0
Zoran Horvat15y ago
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.
0
Jaganathan Bantheswaran15y ago
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.
0