0

I have been reading MSDN "C# classes and struct" this morning to try to better understand these two concepts.

A class is a reference type. When an object of the class is created, the variable to which the object is assigned holds only a reference to that memory. When the object reference is assigned to a new variable, the new variable refers to the original object. Changes made through one variable are reflected in the other variable because they both refer to the same data.

A struct is a value type. When a struct is created, the variable to which the struct is assigned holds the struct's actual data. When the struct is assigned to a new variable, it is copied. The new variable and the original variable therefore contain two separate copies of the same data. Changes made to one copy do not affect the other copy."--MSDN

Can someone please write few lines of example codes to illustrate this concept as I am a young high school girl trying to grasp OOP concept and explain to me ??

Reference and value( scenario): In a book, there is a page with a difficult terminology, which not everyone may understand, so the author decides to include the definition of the terminology in bracket(for those who are not familiar with the term). Is this like passing by value?

If the author had instead put page number reference in brackets right after the term, where readers not familiar with the term can browse to to find the meaning of the term, then would this be passing by reference?

Improve this question
2
  • 2
    What is it you don't understand? Commented Aug 5, 2012 at 17:25
  • 3
    The concepts of value type and reference type are .NET concepts, not general OOP concepts. Commented Aug 5, 2012 at 17:26

2 Answers 2

Reset to default
3

Trying to put this into simple words, the difference is mainly how the instances are stored and used.

Reference types are - as their name suggests - always addressed through a reference. This means that the variable holds not the object itself, but rather just information about where the information is effectively stored in memory. Now if you assign this variable to another value, not the instance but just the reference will be copied, meaning that now both variables reference the same instance.

Value types on the other hand are directly stored in the location (for instance a variable) where they reside. Therefore, when you make an assignment to another variable, it will copy the instance, and both will remain separate.

Let's assume we have instances a and b, which have a field x on them:

a = new MyReferenceType(); a.x = 5; b = a; a.x = 10; // b.x is now also 10, because both a and b reference the same instance a = new MyValueType(); a.x = 5; b = a; a.x = 10; // b.x is still 5, because both a and b are distinct instances

Now being a reference allows for greater flexibility; the size of the reference is constant but the size of the object instance it references may vary, which enables implementing the typical OO principles, especially also polymorphism. Also, in contrast to value types references can reference "nothing", in which case they are null.

Note: this is mostly an implementation detail of the .NET Framework. Value types (structs) have their uses and they fit nicely with the concept of primitive types, which share the same semantics as value types. However, they are severely restricted in what OOP concepts they support.

Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

It's also worth noting that one should almost never use mutable value types – they cause way too much confusion.
Joey, that's correct, and there is much that could be written on that topic (such as using properties instead of fields on mutable structs - which makes matters even worse). However, I tried to concentrate on the question asked. Concepts such as immutability etc. are probably not something that Sarika should think too much about.
Important to note: In C#, value types do not need to be initialized with new MyValueType(). The moment you declare the variable, the memory is already allocated, but uninitialized (i.e. it contains random bytes). Therefore, structs are often used in performance-critical scenarios (XNA framework), since the overhead of the new keyword can be omitted (Vector2 myvec; myvec.X = ...; myvec.Y = ...; is notably faster than Vector2 myvec = new Vector2(..., ...)). Furthermore, the way structs store information is predictable, so structs play a major role in marshalling unmanaged data to C#.
@dialer, I think you have some misconceptions here. First C# requires you to initialize variables when you want to use them. Also, structs always have a default constructor which cannot be overridden, which is why calling new MyStruct() (not one with parameters) does not have any performance implication (have a look at the generated IL). Also, all managed memory allocated in the .NET Framework is zeroed out AFAIK, it never contains random bytes.
@Lucero The generated IL of Vector2 myvec; myvec.X = 5.0f; myvec.Y = 4.0f; is not the same as Vector2 myvec = new Vector2(); myvec.X = 5.0f; myvec.Y = 4.0f;. new Vector2() explicitly adds the initobj opcode, however the difference between both those variants nothing compared to: Vector2 myvec(5.0f, 4.0f); (this comparison was my comment's point). However, when I looked at the produced ASM, I was surprised to see that the fields are indeed initialized to 0 (xor edx,edx; mov ...), which I find unnecessary since C# doesn't let you use structs with uninitialized fields anyway.
|
2

Let's say we have a class Foo and a struct Bar

class Foo { public string Name; } struct Bar { public string Name; } Foo f = new Foo(); Foo g = f; f.Name = "Larry"; //Since g and f point to the same object both have a name of "Larry" //changes to one, change all instances that point (refer) to the same object (memory location) Bar b = new Bar(); Bar c = b; b.Name = "Paul"; //Since Bar is a value type, when we set the name of b, c is not altered because //b and c do not refer to the same object, they are independent variables //each allocated their own memory //and can vary separately after the initial assignment.
Improve this answer

5 Comments

So they are both essentially data structures, only being different in how their instance objects refer to each of their member variables and methods? For struct, instantiated object's state values will be direct memory allocation where as for class instantiated object, its state values are not directly stored in memory, a reference in the memory instead..
@SarikaThapaliya - No. It is about how the types are stored in memory. The memory location where a reference type points to holds a reference (a memory location) to the actual object. For a value type, the reference points directly to the object.
@Oded, I find your comment "For a value type, the reference points directly to the object." a bit misleading due to the ambiguous use of the work "reference".
@Lucero - fair enough, though I struggle with a better way to put it.
@Oded, yeah, it's the reason why I chose the word "variable" in my answer, which is technically not fully accurate but probably intuitively understood the right way.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.