Heap overflow and Stack overflow in C

In C programming, memory management involves two primary areas: the heap and the stack. Both can experience overflow conditions that lead to program crashes or undefined behavior. Understanding these overflows is crucial for writing robust C programs.

Heap Overflow

The heap is a region of memory used for dynamic allocation. Functions like malloc(), calloc(), and realloc() allocate memory from the heap at runtime.

Heap overflow occurs when the program exhausts available heap memory. This typically happens in two scenarios −

Allocating Excessive Memory

Attempting to allocate extremely large amounts of memory can cause heap overflow −

#include <stdio.h>
#include <stdlib.h>

int main() {
    /* Attempting to allocate 4GB of memory */
    float *ptr = (float *)malloc(sizeof(float) * 1000000000);
    
    if (ptr == NULL) {
        printf("Memory allocation failed - heap overflow<br>");
        return 1;
    }
    
    printf("Memory allocated successfully<br>");
    free(ptr);
    return 0;
}

Memory allocation failed - heap overflow

Memory Leaks

Continuously allocating memory without freeing it eventually exhausts the heap −

#include <stdio.h>
#include <stdlib.h>

int main() {
    int count = 0;
    
    /* Allocate memory in a loop without freeing */
    for (int i = 0; i < 1000000; i++) {
        int *p = (int *)malloc(sizeof(int));
        if (p == NULL) {
            printf("Heap overflow after %d allocations<br>", count);
            break;
        }
        count++;
        /* Memory not freed - causes leak */
    }
    
    return 0;
}

Heap overflow after 524288 allocations

Stack Overflow

The stack is a LIFO (Last In First Out) data structure that stores local variables, function parameters, and return addresses. Stack memory is limited and allocated at compile time.

Stack overflow occurs when the program exceeds the available stack space. This happens in two main scenarios −

Infinite Recursion

When a function calls itself infinitely without proper termination, it exhausts stack space −

#include <stdio.h>

int count = 0;

void infiniteRecursion(int a) {
    count++;
    printf("Recursion depth: %d<br>", count);
    
    /* This creates infinite recursion */
    infiniteRecursion(a + 1);
}

int main() {
    printf("Starting infinite recursion...<br>");
    infiniteRecursion(1);
    return 0;
}

Starting infinite recursion...
Recursion depth: 1
Recursion depth: 2
Recursion depth: 3
...
Segmentation fault (core dumped)

Large Local Variables

Declaring very large arrays or variables as local can exceed stack limits −

#include <stdio.h>

int main() {
    /* Large local array may cause stack overflow */
    printf("Attempting to declare large array...<br>");
    
    /* This may cause stack overflow on systems with limited stack */
    int largeArray[1000000];
    
    printf("Array declared successfully<br>");
    printf("First element: %d<br>", largeArray[0]);
    
    return 0;
}

Attempting to declare large array...
Segmentation fault (core dumped)

Prevention Strategies

Conclusion

Heap and stack overflows are serious runtime errors in C programs. Proper memory management, checking allocation return values, and avoiding infinite recursion are essential practices to prevent these issues and ensure program stability.