C#•2y ago

Reference type variables themselves are stored on the stack, is that correct?

While we often say value types live on the stack, ref types live on the heap.

That's not completely true right?

eg. Building house = new Building();

In this case, house is simply a pointer to the building object. And it's stored on the stack. While actual building object is stored on the heap.

When we assign int to a List<int>, those int values actually live on the heap. ( Of course if we create int variables directly, they are stored on the stack)

Is this the correct interpretation?

salty_pepperOP•3/20/24, 10:25 AM

Also is this why we don't have boxing/unboxing with List<int>, because those ints are stored directly on the heap ( albeit inside the List array )

TheBoxyBear•3/20/24, 1:21 PM

Generics are not boxed by default indeed

TheBoxyBear•3/20/24, 1:22 PM

What do you mean by " if we create int variables directly, they are stored on the heap" in 2.? Local variables are on the stack. If the variable is of a reference type, the object is on the heap while the local reference on the stack

XE SparkyCracked•3/20/24, 1:24 PM

I am actually so happy this question came up, busy with this now:

When you declare a reference type variable such as , the variable house itself is indeed stored on the stack. However, if you initialize it using new, as in , the object it refers to is stored on the heap.
Value types, like

int

int

float

float

, , etc., are typically stored on the stack when they are local variables within a method or function. However, if they are part of an object (whether a reference type object or a value type object), they are stored along with that object. Reference types, such as classes and interfaces, are usually stored on the heap.

So yes, you are right, the above is to just clarify the diff. between value types and reference types

XE SparkyCracked•3/20/24, 1:27 PM

It's also worth noting that reference objects may be stored on the stack but the data it is storing, if there is any, could be stored on the heap

TheBoxyBear•3/20/24, 1:30 PM

Cases of boxing are for when a reference may be a value or reference type. The reference can be passed around but if the reference were to be to a value on the stack, the reference could become invalid, rendering the language not memory-safe. This is resolved by copying the value to the heap.

TheBoxyBear•3/20/24, 1:31 PM

To be distinguished with passing by

ref

ref

, where the reference remains valid for the lifetime of the call so it can safely pass references to the stack

TTheBoxyBear Cases of boxing are for when a reference may be a value or reference type. The r...

TheBoxyBear•3/20/24, 1:35 PM

Although there's also the odd case of which seems to also involve boxing as the actual type (and importantly size) can vary at runtime even if it can only store value types. Similar deal with as enums can have different underlying types.

TTheBoxyBear What do you mean by " if we create int variables directly, they are stored on th...

salty_pepperOP•3/21/24, 2:53 AM

Sorry it was a typo, I meant