Where Is Memory Allocated When Structs Are Stored in Arrays?

Where Is Memory Allocated When Structs Are Stored in Arrays?

You've probably heard the saying, "Structs in C# are stored on the stack." And on the other hand, arrays are said to be stored on the heap. So that naturally raises a question:
"What happens when a struct is stored in an array? Where does it go?"

This article clears up that exact question.

Structs Are Stored on the Stack by Default

When you declare a struct as a local variable, it is stored on the stack:

void MyMethod()
{
    MyStruct s = new MyStruct(); // stored on the stack
}

Value types (like struct, int, float, bool) are usually stored on the stack, unlike reference types such as class.

Arrays Are Stored on the Heap (Even Without new)

In C#, arrays are reference types, so they are always stored on the heap. Even if you omit the new keyword during initialization, the compiler still allocates memory on the heap internally.

(In C++, arrays can be stored on the stack if declared without new. This is one of the key differences from C#.)

// stored on the heap
int[] numbers = new int[5];        

// also stored on the heap
MyStruct[] segments = new MyStruct[5]; 

// stored on the heap, even without 'new'
int[] nums = { 1, 2, 3 };

Value Copy to the Heap When Structs Are Added to Containers

Structs are value types, so whether they are initialized with new or not, they are stored on the stack when declared as local variables.

However, when such a struct is added to a reference type container like an array or a list, it is copied by value and the copy is stored on the heap.

In other words, the original struct does not move to the heap — rather, a separate copy of it is created and stored in the heap.

Once the function ends, the stack-based variable is discarded, but the heap-based copy continues to live as long as the container holds it.

This heap copy remains alive as long as the reference-type container exists, and will only be collected by the garbage collector (GC) when no longer in use.

The key idea: "Even value types are copied into the heap when stored in reference-type containers."

Structs Inside a Class Are Also Stored in the Heap

Classes are reference types, so they are stored on the heap. If a class contains a struct field, that struct becomes part of the class instance.

Unlike arrays or lists, the struct here is not copied from the stack to the heap — instead, it is allocated directly as part of the class's memory on the heap. 

class MyClass
{
    // This struct is stored as part of the MyClass instance on the heap
    public MyStruct segment;
}

Summary

Structs are typically stored on the stack when declared locally. However, when added to an array or list, a value copy is made and stored on the heap.

Also, when a struct is part of a class, it is not moved or copied but is simply included within the heap memory of the class instance.

Value types can also live in the heap — that's a key takeaway when understanding C#’s memory model.

Popular posts from this blog

Understanding Arrays as Reference Types in C#

Image
Arrays as Reference Types In programming, it's important to understand the behavior of arrays. In most programming languages including C#, arrays are treated as reference types. This article will explore what that means and how to use that knowledge effectively. Value Types vs Reference Types In C#, data types are categorized into two main types: Value types : Store actual values directly. Examples : int , float , bool , struct Reference types : Store memory addresses instead of the actual values. Examples: class , string , array , delegate Arrays, like classes, are reference types. When you assign one array variable to another, you're copying the reference, not the actual data. Example: Arrays as Reference Types using System; class Program { static void Main() { int[] array1 = { 1, 2, 3 }; int[] array2 = array1; // Copy reference array2[0] = 100; Console.WriteLine(array1[0]); // Out...
Read more

Setting Up a Basic Follow Camera with Cinemachine 3.x

Image
Setting Up a Basic Follow Camera with Cinemachine 3.x Cinemachine has been significantly upgraded in version 3.x, introducing new concepts, improved terminology, and a refined workflow. In this post, we’ll go through how to set up a simple follow camera using the latest version. For more advanced examples, be sure to check out the sample scenes provided in the Cinemachine package—they’re very helpful for understanding the system. Install the Cinemachine Package Start by downloading and importing the Cinemachine package from the Unity Package Manager. Check the Main Camera After installation, you'll notice that the Main Camera now has a Cinemachine Brain component attached. Make sure the Live Camera field shows the name of your Cinemachine Camera. Create a Cinemachine Camera In the Hierarchy window, right-click and go to Cinemachine > Cinemachine Camera to create a new virtual camera. Set the Tracking Targe...
Read more

Understanding and Using ? (nullable) in C#

Image
Understanding and Using ? (nullable) in C# In C#, ? is the symbol used to declare a variable as nullable, meaning it can hold a null value. ? (nullable) declaration string text1 = null; string? text2 = null; Both variables are null , but when you call text1.ToString() , a runtime null reference exception will occur. This happens because text1 is null , meaning it points to nothing. Trying to access .ToString() on a null variable results in an exception. To put it into words, asking someone who has no thoughts, "What should we have for lunch?" is similar. The person doesn't have any thoughts, so asking them anything at all would be an error. On the other hand, text2 has been declared with ? , which tells the compiler, "This variable might be null ." However, just informing the compiler doesn't automatically prevent exceptions. You still need to handle it explicitly. ?. (null-conditional operator) Thus, ? ...
Read more