Memory Management in C
Master the two memory worlds: Stack vs Heap, and learn to manage memory like a pro.
🤔 Why Do We Need to Understand Memory?
💡 The "Your Room" Analogy
Imagine your program is like your bedroom:
- You have a small desk (stack) where you keep things you need right now — your notebook, pen, calculator. It's organized, easy to reach, but limited space.
- You have a big closet (heap) where you store everything else — clothes, old books, boxes. It's larger but you have to manually organize it.
In C, you get to choose where your data lives. Making the right choice keeps your program fast and efficient!
🍽️ Stack vs Heap: The Real-World Analogy
📚 The "Stack of Plates" (Stack Memory)
🍽️ STACK OF PLATES
Think of a cafeteria plate dispenser:
┌─────┐ ← TOP (most recent)
│ 🍽️ │ Plate 3 (last function call)
├─────┤
│ 🍽️ │ Plate 2 (middle function)
├─────┤
│ 🍽️ │ Plate 1 (main function)
├─────┤
│ │
└─────┘ ← BOTTOM
🔑 KEY CHARACTERISTICS:
• Last In, First Out (LIFO)
• Automatic: Plates are pushed on and popped off
• Limited: Only so many plates fit
• Fast: Just grab from the top!
In C: Local variables and function calls live here
🧸 The "Heap of Toys" (Heap Memory)
🧸 HEAP OF TOYS
Think of a toy box where toys are scattered:
┌─────────────────────────────────────┐
│ │
│ 🚗 🤖 │
│ │
│ 🧩 🎮 │
│ │
│ 🎯 │
│ 🎲 │
│ │
└─────────────────────────────────────┘
🔑 KEY CHARACTERISTICS:
• No order: Toys are placed anywhere
• Manual: YOU must pick up and put away
• Large: Much more space than the plate stack
• Slower: Have to search for space
In C: Dynamic allocation with malloc/calloc lives here
📊 Stack vs Heap Comparison
| Feature | Stack 🍽️ | Heap 🧸 |
|---|---|---|
| Organization | Neat stack (LIFO) | Scattered blocks |
| Allocation | Automatic | Manual (you control it) |
| Deallocation | Automatic when function ends | Manual (free()) |
| Size | Limited (usually 1-8 MB) | Larger (GB available) |
| Speed | Very fast | Slower |
| Scope | Local to function | Global access |
| Fragmentation | Never | Can happen |
💾 C Program Memory Layout
🏗️ How Your Program Uses Memory
┌──────────────────────────────────────────┐
│ │
│ HIGH MEMORY ADDRESS │
│ (0xFFFFFFFF on 32-bit) │
│ │
├──────────────────────────────────────────┤ ← Stack starts here
│ │ ↓ GROWS DOWN
│ STACK 🍽️ │ ↓ ↓ ↓
│ Local variables, function calls │
│ Grows DOWNWARD (toward lower addresses)│
│ │
├──────────────────────────────────────────┤
│ │
│ ↕️ GAP ↕️ │
│ Free space for heap to grow │
│ │
├──────────────────────────────────────────┤
│ │ ↑ GROWS UP
│ HEAP 🧸 │ ↑ ↑ ↑
│ malloc(), calloc(), realloc() │
│ Grows UPWARD (toward higher addresses)│
│ │
├──────────────────────────────────────────┤ ← Heap starts here
│ │
│ BSS 📋 │
│ Uninitialized global/static variables│
│ (set to 0 by default) │
│ │
├──────────────────────────────────────────┤
│ │
│ DATA SEGMENT 📊 │
│ Initialized global/static variables │
│ │
├──────────────────────────────────────────┤
│ │
│ TEXT/CODE SEGMENT 📖 │
│ Your program's instructions │
│ (read-only, executable) │
│ │
├──────────────────────────────────────────┤
│ │
│ LOW MEMORY ADDRESS │
│ (0x00000000) │
│ │
└──────────────────────────────────────────┘
💡 MEMORY MAP ANATOMY:
• Text/Code: Where your compiled code lives
• Data: Global variables with values you set
• BSS: Global variables you declared but didn't initialize
• Heap: Dynamic memory you request (malloc)
• Stack: Function calls and local variables
📍 Memory Regions Quick Reference
| Region | What Lives Here | Who Manages It |
|---|---|---|
| Text/Code | Program instructions, compiled code | OS (read-only) |
| Data | Initialized global/static variables | Compiler |
| BSS | Uninitialized global/static variables | OS (zeroed) |
| Heap | Dynamically allocated memory | You! (malloc/free) |
| Stack | Local variables, function parameters | Automatic |
💻 Stack vs Heap in Code
📊 Visual: What Goes Where
Code Example:
┌─────────────────────────────────────────────────────────────┐
│ int global = 10; // DATA segment │
│ int uninit; // BSS segment (starts as 0) │
│ │
│ void myFunction() { │
│ int local = 5; // STACK 🍽️ │
│ int arr[10]; // STACK 🍽️ │
│ │
│ int *ptr = malloc(100); // HEAP 🧸 │
│ // ptr (the variable) is on STACK │
│ // but points to memory on HEAP │
│ │
│ free(ptr); // Give HEAP memory back │
│ } │
│ │
│ int main() { │
│ myFunction(); │
│ return 0; │
│ } │
└─────────────────────────────────────────────────────────────┘
MEMORY DURING EXECUTION:
┌──────────────────────────────────────────┐
│ STACK (top) │
│ ┌────────────────────────────────────┐ │
│ │ main()'s stack frame │ │
│ │ (return address, etc.) │ │
│ └────────────────────────────────────┘ │
│ ┌────────────────────────────────────┐ │
│ │ myFunction()'s stack frame │ │
│ │ local = 5 │ │
│ │ arr[10] = {?,?,?,?,?,?,?,?,?,?} │ │
│ │ ptr = 0x2000 (address on heap) │ │
│ └────────────────────────────────────┘ │
├──────────────────────────────────────────┤
│ │
│ HEAP: │
│ ┌────────────────────────────────────┐ │
│ │ Address 0x2000: 100 bytes allocated │ │
│ │ for ptr │ │
│ └────────────────────────────────────┘ │
├──────────────────────────────────────────┤
│ DATA: global = 10 │
├──────────────────────────────────────────┤
│ BSS: uninit = 0 │
└──────────────────────────────────────────┘
stack_vs_heap.c
#include <stdio.h>
#include <stdlib.h>
void demonstrateStack() {
// These live on the STACK
int localVar = 10; // Stack variable
int localArray[100]; // Stack array
printf("Stack variable: %d\n", localVar);
printf("Stack array size: %zu bytes\n", sizeof(localArray));
// All stack variables are automatically freed
// when this function returns!
}
void demonstrateHeap() {
// This lives on the HEAP
int *heapArray = (int*)malloc(100 * sizeof(int));
if (heapArray == NULL) {
printf("Memory allocation failed!\n");
return;
}
printf("Heap memory allocated!\n");
// Use the memory
for (int i = 0; i < 100; i++) {
heapArray[i] = i * 10;
}
printf("First value: %d\n", heapArray[0]);
printf("Last value: %d\n", heapArray[99]);
// MUST manually free heap memory!
free(heapArray);
printf("Heap memory freed!\n");
}
int main() {
printf("=== Stack Demo ===\n");
demonstrateStack();
printf("\n=== Heap Demo ===\n");
demonstrateHeap();
return 0;
}🎁 Dynamic Memory Functions Explained Simply
💡 The "Library Book" Analogy
Think of heap memory like borrowing books from a library:
📚 malloc() - "Asking for Memory"
Like asking the librarian for books
📖 MALLOC - Memory ALLOCation
You: "Can I have 100 bytes of memory?"
OS (Operating System): "Sure, here you go!"
┌─────────────────────────────────────────┐
│ int *ptr = malloc(100); │
│ │
│ Before: │
│ ptr → ??? (uninitialized) │
│ │
│ After: │
│ ptr → [???][???][???]... (100 bytes) │
│ ↑ │
│ Memory contains GARBAGE values │
└─────────────────────────────────────────┘
⚠️ malloc gives you RAW memory - it could contain
any random values! Always initialize before use.
✨ calloc() - "Asking for Clean Memory"
Like asking for new, clean books
✨ CALLOC - Contiguous ALLOCation with Zero
You: "Can I have 10 integers, all set to 0?"
OS: "Sure, here are 10 clean, zeroed integers!"
┌─────────────────────────────────────────┐
│ int *ptr = calloc(10, sizeof(int)); │
│ │
│ Before: │
│ ptr → ??? │
│ │
│ After: │
│ ptr → [0][0][0][0][0][0][0][0][0][0] │
│ ↑ │
│ Memory is ZEROED/CLEAN! │
└─────────────────────────────────────────┘
✅ Use calloc when you need memory initialized to 0
(e.g., for arrays, counters)
📏 realloc() - "Resizing Your Memory"
Like asking for a bigger table at a restaurant
📏 REALLOC - REsize ALLOCated memory
Scenario: You asked for 5 integers, but now need 10!
┌─────────────────────────────────────────────────────┐
│ int *ptr = malloc(5 * sizeof(int)); │
│ // ptr → [1][2][3][4][5] │
│ │
│ // Oops, need more space! │
│ ptr = realloc(ptr, 10 * sizeof(int)); │
│ │
│ After realloc: │
│ ptr → [1][2][3][4][5][0][0][0][0][0] │
│ ↑ Old data preserved ↑ New space │
│ │
│ ✅ Old values are kept! │
│ ✅ New space is available │
│ ⚠️ May move to a new location if no room to grow │
└─────────────────────────────────────────────────────┘
💡 realloc can also SHRINK memory if you need less space!
malloc_calloc_realloc.c
#include <stdio.h>
#include <stdlib.h>
int main() {
// ============ MALLOC ============
printf("=== Using malloc ===\n");
int *arr1 = (int*)malloc(5 * sizeof(int));
if (arr1 == NULL) {
printf("malloc failed!\n");
return 1;
}
// malloc doesn't initialize - values are random!
printf("After malloc:\n");
for (int i = 0; i < 5; i++) {
printf("arr1[%d] = %d\n", i, arr1[i]); // Garbage values!
}
// Initialize manually
for (int i = 0; i < 5; i++) {
arr1[i] = (i + 1) * 10; // 10, 20, 30, 40, 50
}
// ============ CALLOC ============
printf("\n=== Using calloc ===\n");
int *arr2 = (int*)calloc(5, sizeof(int));
if (arr2 == NULL) {
printf("calloc failed!\n");
free(arr1);
return 1;
}
// calloc initializes to 0!
printf("After calloc:\n");
for (int i = 0; i < 5; i++) {
printf("arr2[%d] = %d\n", i, arr2[i]); // All zeros!
}
// ============ REALLOC ============
printf("\n=== Using realloc ===\n");
printf("Before: arr1 has 5 elements\n");
// Grow from 5 to 10 elements
int *temp = realloc(arr1, 10 * sizeof(int));
if (temp == NULL) {
printf("realloc failed!\n");
free(arr1);
free(arr2);
return 1;
}
arr1 = temp;
printf("After realloc (10 elements):\n");
printf("Old values preserved:\n");
for (int i = 0; i < 5; i++) {
printf("arr1[%d] = %d\n", i, arr1[i]); // 10, 20, 30, 40, 50
}
// Clean up
free(arr1);
free(arr2);
return 0;
}🗑️ Why free() Matters
📚 The "Library Book" Analogy for Memory Leaks
MEMORY LEAK = BORROWING BOOKS BUT NEVER RETURNING
Scenario: You keep borrowing books but never return them...
Week 1:
┌─────────────────────────────────────────┐
│ LIBRARY SHELVES │
│ ┌─────┐┌─────┐┌─────┐┌─────┐┌─────┐ │
│ │ 📕 ││ 📗 ││ 📘 ││ 📙 ││ 📕 │ │
│ └─────┘└─────┘└─────┘└─────┘└─────┘ │
│ │
│ Your Books: [📕][📗] (borrowed) │
└─────────────────────────────────────────┘
Week 5:
┌─────────────────────────────────────────┐
│ LIBRARY SHELVES │
│ ┌─────┐┌─────┐┌─────┐┌─────┐┌─────┐ │
│ │ ❌ ││ ❌ ││ ❌ ││ ❌ ││ 📙 │ │
│ └─────┘└─────┘└─────┘└─────┘└─────┘ │
│ │
│ Your Books: [📕][📗][📘][📙][📕][📗] │
│ ↑ 10 books borrowed! │
│ ↑ Never returned! │
└─────────────────────────────────────────┘
Week 10:
┌─────────────────────────────────────────┐
│ LIBRARY SHELVES │
│ ┌─────┐┌─────┐┌─────┐┌─────┐┌─────┐ │
│ │ ❌ ││ ❌ ││ ❌ ││ ❌ ││ ❌ │ │
│ └─────┘└─────┘└─────┘└─────┘└─────┘ │
│ │
│ NO MORE BOOKS AVAILABLE! │
│ Library is "OUT OF MEMORY" │
│ │
│ New borrowers can't get books! │
│ Program crashes or becomes slow! │
└─────────────────────────────────────────┘
IN C CODE:
┌─────────────────────────────────────────┐
│ void leakyFunction() { │
│ int *arr = malloc(1000); │
│ // Process data... │
│ // FORGOT TO CALL FREE! │
│ } // Memory is lost forever! │
│ │
│ Every call leaks 1000 bytes! │
│ Call it 1000 times → 1MB lost! │
└─────────────────────────────────────────┘
🎨 Visual: Memory Getting Filled Up
MEMORY LEAK VISUALIZATION
HEAP at start: HEAP after leak:
┌─────────────────────┐ ┌─────────────────────┐
│ │ │ ████████████████ │
│ │ │ ████████████████ │
│ │ │ ████████████████ │
│ │ │ ████████████████ │
│ │ │ ████████████████ │
│ │ │ ████████████████ │
│ │ │ ███ Leaked Memory │
│ │ │ ███ (can't use) │
│ │ │ ████████████████ │
│ │ │ │
│ │ │ Available space ↓ │
└─────────────────────┘ └─────────────────────┘
Legend:
░ = Free memory
█ = Used/leaked memory
The more you leak, the less memory is available!
⚠️ Common Memory Mistakes
Mistake #1: Using Memory After Free
❌ WRONG - Use After Free
┌─────────────────────────────────────────┐
│ int *ptr = malloc(sizeof(int)); │
│ *ptr = 10; │
│ free(ptr); │
│ │
│ printf("%d\n", *ptr); // DANGER! │
│ ↑ │
│ Using freed memory! │
│ Could be anything now │
└─────────────────────────────────────────┘
✅ RIGHT - Set to NULL after free
┌─────────────────────────────────────────┐
│ int *ptr = malloc(sizeof(int)); │
│ *ptr = 10; │
│ free(ptr); │
│ ptr = NULL; // Now it's safe! │
│ │
│ if (ptr != NULL) { │
│ printf("%d\n", *ptr); │
│ } │
└─────────────────────────────────────────┘
Mistake #2: Double Free
❌ WRONG - Freeing Twice
┌─────────────────────────────────────────┐
│ int *ptr = malloc(sizeof(int)); │
│ *ptr = 10; │
│ free(ptr); │
│ free(ptr); // CRASH! │
│ ↑ │
│ Already freed, can't free again! │
│ → Undefined behavior / crash │
└─────────────────────────────────────────┘
✅ RIGHT - Free once, set to NULL
┌─────────────────────────────────────────┐
│ int *ptr = malloc(sizeof(int)); │
│ *ptr = 10; │
│ free(ptr); │
│ ptr = NULL; // Prevents double free │
│ │
│ // Safe to call free(NULL) - does nothing│
│ free(ptr); // No problem! │
└─────────────────────────────────────────┘
Mistake #3: Memory Leak Example
❌ WRONG - Memory Leak in a Loop
┌─────────────────────────────────────────┐
│ void processData() { │
│ for (int i = 0; i < 1000; i++) { │
│ int *temp = malloc(1000); │
│ // Use temp... │
│ // FORGOT TO FREE! │
│ } // Leaks 1000 bytes each time │
│ } // Total leak: 1,000,000 bytes! │
└─────────────────────────────────────────┘
✅ RIGHT - Always Free What You Malloc
┌─────────────────────────────────────────┐
│ void processData() { │
│ for (int i = 0; i < 1000; i++) { │
│ int *temp = malloc(1000); │
│ // Use temp... │
│ free(temp); // Clean up! │
│ } // No leak! │
│ } │
└─────────────────────────────────────────┘
Mistake #4: Not Checking malloc Return
❌ WRONG - No NULL Check
┌─────────────────────────────────────────┐
│ int *arr = malloc(1000000000); │
│ ↑ │
│ What if this fails? │
│ arr[0] = 10; // CRASH! NULL pointer │
└─────────────────────────────────────────┘
✅ RIGHT - Always Check Return Value
┌─────────────────────────────────────────┐
│ int *arr = malloc(1000000000); │
│ if (arr == NULL) { │
│ printf("Out of memory!\n"); │
│ return 1; // Handle error gracefully │
│ } │
│ arr[0] = 10; // Safe! │
└─────────────────────────────────────────┘
common_mistakes.c
#include <stdio.h>
#include <stdlib.h>
void safeMemoryUsage() {
// GOOD: Check malloc return
int *ptr = (int*)malloc(sizeof(int) * 100);
if (ptr == NULL) {
fprintf(stderr, "Memory allocation failed\n");
return;
}
// Use the memory
for (int i = 0; i < 100; i++) {
ptr[i] = i * i;
}
// GOOD: Free once
free(ptr);
// GOOD: Set to NULL after free
ptr = NULL;
// Now safe - free(NULL) does nothing
free(ptr); // No crash!
}
void leakyFunction() {
// BAD: Memory leak
int *arr = (int*)malloc(1000);
// Process data...
// Oops! Forgot to free!
// Memory is lost forever
}
void useAfterFreeExample() {
int *ptr = (int*)malloc(sizeof(int));
*ptr = 42;
free(ptr);
// ptr still points to old address, but it's invalid!
// DANGER: Using freed memory!
// printf("%d\n", *ptr); // DON'T DO THIS!
// GOOD: Set to NULL
ptr = NULL;
}
int main() {
safeMemoryUsage();
// This would leak memory:
// leakyFunction();
return 0;
}✅ Memory Management Best Practices
📋 The Golden Rules of Memory
| Rule | Why It Matters | Example |
|---|---|---|
| 1. Always check if malloc succeeded | Prevents crashes when out of memory | if (ptr == NULL) { handle_error(); } |
| 2. Always free what you malloc | Prevents memory leaks | free(ptr); |
| 3. Set pointer to NULL after free | Prevents use-after-free bugs | ptr = NULL; |
| 4. Don't free twice | Prevents crashes from double-free | Setting NULL after free helps |
| 5. Free in the same scope when possible | Makes cleanup easier to track | Allocate and free in same function |
| 6. Use calloc when you need zeros | Saves initialization code | calloc(n, sizeof(int)) |
🎯 The Complete Pattern
✅ THE COMPLETE SAFE PATTERN
┌─────────────────────────────────────────────────────┐
│ 1. ALLOCATE with NULL initialization │
│ int *ptr = NULL; │
│ │
│ 2. REQUEST memory from OS │
│ ptr = malloc(size); │
│ │
│ 3. CHECK if allocation succeeded │
│ if (ptr == NULL) { │
│ // Handle error │
│ return ERROR; │
│ } │
│ │
│ 4. USE the memory │
│ ptr[0] = 10; │
│ │
│ 5. FREE when done │
│ free(ptr); │
│ │
│ 6. SET to NULL to prevent use-after-free │
│ ptr = NULL; │
└─────────────────────────────────────────────────────┘
MEMORY SAFETY CHECKLIST:
□ Did I check malloc/calloc/realloc return value?
□ Do I have a free() for every malloc()?
□ Did I set the pointer to NULL after free?
□ Is there any path where I return without freeing?
□ Am I accessing memory after it was freed?
best_practices_complete.c
#include <stdio.h>
#include <stdlib.h>
// Example of complete safe memory management
int* createArray(int size) {
// Step 1: Declare with NULL
int *arr = NULL;
// Step 2: Allocate
arr = (int*)malloc(size * sizeof(int));
// Step 3: Check
if (arr == NULL) {
fprintf(stderr, "Failed to allocate %d integers\n", size);
return NULL;
}
// Step 4: Use
for (int i = 0; i < size; i++) {
arr[i] = i + 1;
}
return arr; // Caller must free!
}
// Safe function that allocates and frees
void processArray() {
int *arr = createArray(10);
if (arr == NULL) {
return; // Allocation failed
}
// Use the array
printf("Array: ");
for (int i = 0; i < 10; i++) {
printf("%d ", arr[i]);
}
printf("\n");
// Step 5: Free
free(arr);
// Step 6: Set to NULL
arr = NULL;
}
int main() {
printf("=== Safe Memory Example ===\n");
processArray();
printf("\nMemory handled safely!\n");
return 0;
}📝 Quick Reference Summary
🔑 Key Takeaways
MEMORY TYPES CHEAT SHEET
┌──────────────────────────────────────────────────────────┐
│ STACK MEMORY (Automatic) │
│ • Local variables: int x = 5; │
│ • Function parameters │
│ • Arrays: int arr[100]; │
│ • Allocated automatically when function starts │
│ • Freed automatically when function ends │
│ • Limited size (1-8 MB typically) │
└──────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────┐
│ HEAP MEMORY (Dynamic) │
│ • malloc(size) - raw memory, uninitialized │
│ • calloc(n, size) - zero-initialized memory │
│ • realloc(ptr, new_size) - resize existing memory │
│ • free(ptr) - return memory to OS │
│ • YOU must manage it! │
│ • Large size available (GB) │
└──────────────────────────────────────────────────────────┘
THE GOLDEN RULE:
"For every malloc/calloc/realloc, there must be a free()"
COMMON PATTERN:
int *ptr = malloc(size);
if (ptr == NULL) { /* handle error */ }
// ... use memory ...
free(ptr);
ptr = NULL;