KembaraXtra - Computer Science - Stack and Heap Memory

I. Introduction

• High-level languages abstract memory management, with varying degrees of transparency (e.g., Python vs. C).
• Programs utilize two main types of memory: stack and heap.

II. The Stack

• Definition: An area of memory that operates on a Last-In, First-Out (LIFO) model.
• Analogy: Stack of plates.
• LIFO Operation:
• Last item added is the first item removed.
• Items can be read or modified at any time while on the stack.
• Stack Pointer:
• A processor register stores the memory address of the top of the stack.
• The stack pointer adjusts to make room for a value on the stack.
• The stack pointer adjusts to decrease the size of the stack when a value is removed.
• Usage:
• The compiler uses the stack to track the state of program execution and store local variables.
• Implementation details are usually hidden from the programmer.
• Memory Allocation (C Example):
• Variables are pushed onto the stack as they are declared.
• The order of declaration determines their position on the stack.
• Memory addresses on the stack decrease as the stack grows (in many architectures).
• Characteristics:
• Fast and efficient for small, temporary data.
• Each thread of execution has its own stack.
• Limited resource; prone to stack overflow if too much data is pushed onto it.

III. The Heap

• Definition: A pool of memory available to a program.
• Allocation Model:
• Unlike the stack, the heap doesn't have a LIFO model.
• No standard allocation model.
• Accessibility:
• Heap allocations can be accessed by any of the program's threads.
• Memory Management:
• Memory is allocated from the heap and persists until explicitly freed or the program terminates.
• Freeing Memory: Releasing memory back to the available pool.
• Garbage Collection: Automatic memory freeing when an allocation is no longer referenced (common in some languages).
• Memory Leaks: Occur when unused memory is not freed.
• Pointers (C Language):
• Pointers are variables that hold memory addresses.
• Used to track heap memory allocations.
• The pointer itself can be a local variable stored on the stack, pointing to an address in the heap.
• Heap Allocation in C (Example):
• malloc() function allocates memory from the heap and returns the address of the allocated block.
• The pointer to this memory (returned by malloc()) is typically stored in a local variable on the stack.

IV. Stack vs. Heap: Key Differences

V. Key Terminology

• Stack: LIFO memory area for local variables and program state.
• Heap: Memory pool for dynamic allocation of larger, persistent data.
• LIFO: Last-In, First-Out.
• Stack Pointer: Register tracking the top of the stack.
• Stack Overflow: Error when the stack runs out of memory.
• Garbage Collection: Automatic memory management.
• Memory Leak: Unused memory that is not freed.
• Pointer: A variable holding a memory address.

VI. Important Considerations

• Choose stack for small, short-lived data within a limited scope.
• Choose heap for larger data or data that needs to persist longer and be accessible across different parts of the program.
• Be aware of memory management responsibilities in languages like C to avoid memory leaks.