.NET

Value Type Vs Reference Type

There is always a confusion between value types vs reference types or a struct vs a class. Specially during interview times .. :), when Interviewer starts question by asking whats the difference between Value Types vs Reference Types and ends by delocating of memory.
There is a simple difference of these two is about how these are allocated in memory.
e.g.
Value Types like struct, int, double etc. all premitive data types are stored in Stack and Reference types like classes are stored in Heap.
In classes, there are two things : one is instance and second is object.
Class Employee
{
    int ID;
    int Salary;
}
Employee Emp; // this is instance 
Emp = new Employee;//this is object
So, Instance is stored in Stack, whereas actual object is stored in Heap.

Memory Allocation / Deallocation:

In case of Value types variables, as the value is stored in Stack, after function execution, all values from Stacks are popped and memory deallocated.
In case of Reference types, as references are stored in Stack, these are also popped up from Stack but the main object which is created in Heap, that still remains in memory until Garbage Collector cycle doesn’t run because it’s GC(Garbage Collector) responsibility to clear all unallocated objects.

Passing as Parameter:

Suppose there is a struct say Point P and Class Employee as defined above:
Struct Point
{
    int X;
    int Y;
}
Class Employee
{
    int ID;
    int Salary;

}

By default, every paramter is passed by value. Suppose there is a function ChangeValues.

public void ChangeValues(Point P, Employee emp)
{
P.X = 200;      //There will be no change on original P.X passed
emp.ID = 5;    //This will change original ID
emp = null;     //No change on original Emp object
}

Reason : Point is a value type which is passed as copy of original value, so any change done inside the function will not reflect original value. Employee emp has been passed as a reference(instance), So emp represent here as a pointer to main object, so emp = null will not change the oringinal object, but this emp reference points to original object, so emp.ID will change original object properties. Let’s clear the picture by passing these two as passing by reference.

public void ChangeValuebyRefernce(ref Point P, ref Employee emp)
{
P.X = 200;      //There will be change because refernce to original value is passed

emp.ID = 5;    //This will change original ID

emp = null;     //This will change original reference
}

This was the brief summary of how value types and refernce types ate stored in memory, how these are deallocated from memory, how these behave in passing as parameter. In further blogs, I’ll try to clear more doubts.

Categories: .NET, c#

Tagged as: , , , ,

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.