Stack vs heap mental model in C Sharp (C#) - Visual Side-by-Side Comparison

Concept Flow - Stack vs heap mental model

Start: Program runs

↓

Function call: push stack frame

↓

Allocate local variables on stack

↓

If new object created

↓

Allocate object on heap

↓

Store reference on stack

No↓

Function returns: pop stack frame

↓

Heap objects remain until GC cleans

↓

End

This flow shows how function calls create stack frames with local variables, while objects are allocated on the heap with references stored on the stack.

Execution Sample

C Sharp (C#)

void Foo() {
  int x = 10;
  Person p = new Person();
  p.Name = "Alice";
}

Foo();

This code calls Foo, which stores an int on the stack and creates a Person object on the heap with a reference on the stack.

Execution Table

Step	Action	Stack State	Heap State	Notes
1	Call Foo()	Push Foo stack frame	Empty	Stack frame for Foo created
2	int x = 10;	x=10	Empty	Local int stored on stack
3	Person p = new Person();	x=10, p=ref1	Object Person#1 allocated	Person object created on heap, reference stored in p
4	p.Name = "Alice";	x=10, p=ref1	Person#1.Name = "Alice"	Object field set on heap
5	Return from Foo()	Pop Foo stack frame	Person#1 remains	Stack frame removed, heap object still exists
6	End	Empty	Person#1 remains until GC	Heap object persists until garbage collected

💡 Function returns, stack frame is popped, heap objects remain until garbage collection

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
x	undefined	10	10	10	undefined	undefined
p	undefined	undefined	ref1	ref1	undefined	undefined
Heap Person#1	none	none	allocated	Name="Alice"	allocated	allocated

Key Moments - 3 Insights

Why does the local variable 'p' store a reference and not the actual object?

Because objects are stored on the heap due to their dynamic size and lifetime, the stack only holds a reference (pointer) to that heap object, as shown in execution_table step 3.

What happens to the heap object after the function returns?

The stack frame is popped and local variables are removed, but the heap object remains until garbage collection, as seen in execution_table steps 5 and 6.

Why are value types like 'int x' stored on the stack?

Value types have fixed size and short lifetime tied to the function call, so they are stored directly on the stack for fast access, as shown in execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution table at step 3. What does variable 'p' hold?

A Null

B A reference to the Person object on the heap

C The actual Person object data

D An integer value

💡 Hint

Check the 'Stack State' and 'Heap State' columns at step 3 in the execution_table.

At which step does the stack frame for Foo get removed?

A Step 5

B Step 2

C Step 4

D Step 6

💡 Hint

Look for 'Pop Foo stack frame' in the 'Action' column of the execution_table.

If 'p' was a value type instead of a reference type, how would the stack state change at step 3?

A 'p' would be null

B 'p' would hold a reference to heap object

C 'p' would hold the actual object data on the stack

D Heap would have no objects

💡 Hint

Refer to variable_tracker and key_moments about value types stored on stack.

Concept Snapshot

Stack vs Heap Mental Model in C#:
- Stack stores local variables and function call info.
- Heap stores objects created with 'new'.
- Stack variables hold values or references.
- Heap objects live beyond function calls until GC.
- Stack is fast and short-lived; heap is slower and long-lived.

Full Transcript

When a C# program runs and calls a function like Foo, a stack frame is created to hold local variables such as integers and references. Value types like int are stored directly on the stack. When the code creates a new object with 'new', the object is allocated on the heap, and the stack stores a reference to it. The heap object can have fields, like Name, which are stored inside the heap. When the function returns, the stack frame is removed, so local variables disappear, but the heap object remains until garbage collection. This model helps understand memory management and variable lifetimes in C#.

Practice

1. In C#, where are value types like int and bool typically stored during program execution?

easy

A. On the heap, because they are objects that need dynamic memory

B. In static memory, shared across all instances

C. In the CPU cache only, not in stack or heap

D. On the stack, because they are stored directly and accessed quickly

Solution

1. Step 1: Understand value type storage

   Value types like int and bool are stored on the stack because they hold data directly and have a short lifetime.

2. Step 2: Contrast with heap storage

   Heap stores objects (reference types), not simple value types, which makes stack the correct place for these.

3. Final Answer:

   On the stack, because they are stored directly and accessed quickly -> Option D

4. Quick Check:

   Value types = stack [OK]

Hint: Value types go on stack; objects go on heap [OK]

Common Mistakes:

• Thinking all data goes on heap
• Confusing value types with reference types
• Assuming stack is for objects only

2. Which of the following C# declarations correctly creates a reference type stored on the heap?

easy

A. string text = "hello";

B. double pi = 3.14;

C. bool flag = true;

D. int number = 5;

Solution

1. Step 1: Identify reference types

   In C#, string is a reference type stored on the heap, while int, bool, and double are value types stored on the stack.

2. Step 2: Match declaration to heap storage

   Only string text = "hello"; creates a reference type object on the heap.

3. Final Answer:

   string text = "hello"; -> Option A

4. Quick Check:

   Reference type = string [OK]

Hint: Strings are reference types stored on heap [OK]

Common Mistakes:

• Assuming all primitives are reference types
• Confusing string as value type
• Ignoring heap for object storage

3. Consider the following C# code:

class Person { public string Name; }
Person p1 = new Person();
p1.Name = "Alice";
Person p2 = p1;
p2.Name = "Bob";
Console.WriteLine(p1.Name);

What will be the output and why?

medium

A. "Bob" because p1 and p2 reference the same object on the heap

B. Compilation error due to missing constructor

C. "Alice" because p1 and p2 are separate objects on the heap

D. "Alice" because strings are immutable

Solution

1. Step 1: Understand reference assignment

   Both p1 and p2 point to the same Person object on the heap because p2 = p1; copies the reference.

2. Step 2: Trace the name change effect

   Changing p2.Name to "Bob" changes the same object that p1 references, so p1.Name is also "Bob".

3. Final Answer:

   "Bob" because p1 and p2 reference the same object on the heap -> Option A

4. Quick Check:

   Reference copy = shared object [OK]

Hint: Reference copy means both variables point to same heap object [OK]

Common Mistakes:

• Thinking p1 and p2 are independent copies
• Confusing value and reference assignment
• Ignoring that strings are immutable but object fields can change

4. Identify the error in this C# code snippet related to stack and heap usage:

int[] numbers;
numbers[0] = 10;
Console.WriteLine(numbers[0]);

medium

A. Array elements are stored on stack but accessed incorrectly

B. Array is not initialized before use, causing a runtime error

C. Syntax error: missing semicolon after array declaration

D. No error; code runs and prints 10

Solution

1. Step 1: Check array initialization

   The array numbers is declared but not initialized, so it points to null by default.

2. Step 2: Understand runtime behavior

   Accessing numbers[0] without initialization causes a NullReferenceException at runtime.

3. Final Answer:

   Array is not initialized before use, causing a runtime error -> Option B

4. Quick Check:

   Uninitialized reference = runtime error [OK]

Hint: Always initialize arrays before accessing elements [OK]

Common Mistakes:

• Assuming declaration allocates memory
• Confusing stack and heap for array storage
• Ignoring runtime null reference errors

5. You want to optimize a C# program that creates many small objects rapidly. Which approach best uses the stack and heap to improve performance?

hard

A. Avoid using the stack by allocating everything on the heap

B. Use only reference types to ensure all data is on the heap for consistency

C. Use value types (structs) for small data to store on stack and reduce heap allocations

D. Use global static variables to store all objects

Solution

1. Step 1: Understand stack vs heap performance

   The stack is faster for allocation and deallocation, so using value types (structs) reduces heap pressure.

2. Step 2: Apply optimization strategy

   Using structs for small data stores them on the stack, avoiding costly heap allocations and garbage collection.

3. Final Answer:

   Use value types (structs) for small data to store on stack and reduce heap allocations -> Option C

4. Quick Check:

   Value types on stack = better performance [OK]

Hint: Use structs for small data to leverage fast stack allocation [OK]

Common Mistakes:

• Thinking heap is always better for performance
• Ignoring garbage collection overhead
• Using static variables without reason