Stack and Heap Memory Allocation

The short version:

• The stack stores short-lived, fixed-size data tied to function calls.
• The heap stores data whose size or lifetime is not known locally.
• Stack allocation is usually cheaper; heap allocation is more flexible.
• Python hides this choice. Rust makes it visible through types such as Box.

These are useful models, not guarantees: compilers and runtimes may optimise where data actually lives.

Stack

Each function call gets a stack frame containing things such as arguments, local values, and a return address. Frames are removed in reverse order when calls return, so allocation is little more than moving a pointer.

The stack is fast and automatically managed, but limited in size. Very deep recursion can overflow it.

Typical stack examples include:

• A counter, flag, or other fixed-size value whose size is known before the function runs.
• A small fixed-size array, such as a 32-byte checksum buffer.
• Function arguments and local values that only need to exist until the current function returns.
• Temporary state used while processing one operation, when its lifetime is tied to that operation.

Heap

Heap memory can outlive the function that requested it and can hold dynamically sized values. Allocating and releasing it requires more bookkeeping; ownership, garbage collection, or reference counting decides when it can be reused.

Typical heap examples include:

• Data read from a file or network connection when its size is not known until runtime.
• A buffer that must grow as more input arrives, when a fixed-size stack allocation would not be enough.
• Data returned from a function because it must remain alive after the function's stack frame has been removed.
• Shared data whose lifetime is determined by the last consumer rather than by one function call.

Rust: the distinction is visible

fn main() {
    let count: i32 = 3;                 // fixed-size value; normally stack
    let name = String::from("pelican"); // String metadata on stack, text on heap
    let boxed = Box::new(42);            // Box pointer on stack, 42 on heap

    println!("{count} {name} {boxed}");
}

Rust releases boxed when its owner leaves scope. No garbage collector is needed. Moving ownership can change which variable controls heap data without copying that data.

Python: the distinction is hidden

def total() -> int:
    numbers = [1, 2, 3]
    return sum(numbers)

In CPython, the function call has an interpreter frame, while the list and integers are Python objects managed on the heap. numbers is a reference to the list, not the list stored directly in a conventional stack slot.

Python normally reclaims objects through reference counting, with a cyclic garbage collector as backup. That convenience adds overhead but removes most manual memory decisions.

Practical rule

In Python, focus on object lifetimes, copies, and container sizes. In Rust, also notice whether a type owns heap data and when that ownership moves. Reach for heap allocation when values must grow, escape their scope, or have an unknown size—not because “heap” or “stack” is inherently better.

Quiz

Test your understanding, from basics to more advanced ownership questions. Open each answer only after you have had a go.

let array = [1, 2, 3];              // Fixed length: always three elements.
let mut vector = vec![1, 2, 3];     // Growable: can hold more elements.
vector.push(4);                     // The vector now has four elements.

let count = 3;                    // Usually a simple stack allocation.
let numbers = Box::new([1, 2, 3]); // Requires heap-allocation bookkeeping.

fn make_count() -> i32 {
    let count = 3; // This local value is tied to the function call.
    count
} // The function's stack frame is removed here.

let fixed = [0u8; 1024];       // Fixed size, reserved up front.
let mut growing = Vec::new(); // Heap-backed storage can grow at runtime.

let name = String::from("pelican"); // A String tracks a pointer, length, and capacity.

let boxed = Box::new(42); // Consider the owner and the value it owns separately.

fn make_value() -> Box<i32> {
    let value = Box::new(42); // Ownership can move to the caller.
    value
} // The Box moves out; its heap allocation remains alive.

numbers = [1, 2, 3]
alias = numbers  # This assigns another reference; it does not copy the list.

def count_down(n):
    if n > 0:
        count_down(n - 1)  # Each call needs another stack frame.

fn square(value: i32) -> i32 {
    value * value // An optimiser may keep this in a register or remove it.
}