Stack vs Heap: How C Programs Use Memory

When people talk about stack vs heap in C, they mean the two main places where a running program keeps its data. Every variable you create lives somewhere in memory, and where it lives decides how long it lasts and how big it can be. In this lesson, you'll see the full memory layout of a C program, learn what happens on the stack when functions call each other, and find out when you need the heap instead.

What is the memory layout of a C program?

When your program starts, the operating system gives it a block of memory split into a few regions (also called segments). Each region has its own job:

• Text (code): the compiled machine instructions of your functions. It's usually read-only.
• Data: global and static variables that start with a non-zero value, like int store_id = 7;.
• BSS: global and static variables that start at zero or have no initial value. C sets them all to 0 before main runs.
• Heap: memory you request while the program runs, using malloc(). It stays until you release it with free().
• Stack: local variables and the bookkeeping for function calls. It's cleaned up automatically.

The exact order and addresses depend on the operating system, but this picture is a good mental model for Linux, macOS and Windows alike.

Globals and statics: the data and BSS regions

Variables declared outside every function (globals) and variables marked static live in the data or BSS region. They are created once, before main starts, and live until the program ends. You met them in scope and storage classes; here's where they actually sit.

#include <stdio.h>

int visitors = 0;              /* global: BSS (starts at 0) */

void greet(void) {
    static int calls = 0;      /* static: BSS, keeps its value */
    int local = 0;             /* local: stack, fresh every call */

    calls++;
    local++;
    visitors++;
    printf("calls=%d local=%d visitors=%d\n", calls, local, visitors);
}

int main(void) {
    greet();
    greet();
    greet();
    return 0;
}

calls=1 local=1 visitors=1
calls=2 local=1 visitors=2
calls=3 local=1 visitors=3

calls and visitors remember their values between calls because they live outside the stack. local is created fresh on the stack each time greet() runs, so it's always 1.

What is the stack in C?

The stack is a region of memory that stores local variables, function parameters and the return address for every function call that is currently running. Each call gets its own slice of the stack called a stack frame. When the function returns, its frame is removed and all its local variables disappear. That automatic cleanup is why local variables are also called automatic variables.

Watch the frames come and go in this small checkout program:

#include <stdio.h>

void checkout(double total) {
    double tax = total * 0.10;
    printf("  checkout: total=%.2f tax=%.2f\n", total, tax);
}

void add_items(int count, double price) {
    double total = count * price;
    printf(" add_items: total=%.2f\n", total);
    checkout(total);
    printf(" add_items: back from checkout\n");
}

int main(void) {
    printf("main: start\n");
    add_items(3, 4.50);
    printf("main: done\n");
    return 0;
}

main: start
 add_items: total=13.50
  checkout: total=13.50 tax=1.35
 add_items: back from checkout
main: done

When main calls add_items, a frame holding count, price and total is pushed. When add_items calls checkout, another frame holding checkout's own total and tax is pushed. As each function returns, its frame is popped in reverse order: last in, first out. It's the same call stack you saw in recursion.

Why is the stack size limited?

The stack is fast because it's simple: making room for a frame just means moving a marker. The price is that it's small, often around 1 MB on Windows and 8 MB on Linux by default. If you create a huge local array or recurse too deeply, you run out of stack, and the program crashes with a stack overflow, usually reported as a "segmentation fault" on Linux or macOS.

What is the heap in C?

The heap is a large pool of memory that your program requests at run time, as much as it needs, whenever it needs it. You ask for a block with malloc(), get back a pointer to it, and the block stays valid until you call free(). Nothing is cleaned up automatically. Here's a first peek; you'll learn the details in the next lesson:

int *scores = malloc(1000 * sizeof *scores);   /* room for 1000 ints */
/* ... use scores[0] to scores[999] ... */
free(scores);                                  /* hand the memory back */

The heap is a little slower than the stack, because the system has to find a free block that fits. In exchange, you get two superpowers: size chosen at run time and a lifetime you control.

Seeing where variables live

You can print addresses with %p to see the regions for yourself:

#include <stdio.h>

int total_sales;          /* BSS  */
int store_id = 7;         /* data */

int main(void) {
    static int open_days = 30;   /* data  */
    int today = 12;              /* stack */

    printf("store_id    %p\n", (void *)&store_id);
    printf("total_sales %p\n", (void *)&total_sales);
    printf("open_days   %p\n", (void *)&open_days);
    printf("today       %p\n", (void *)&today);
    return 0;
}

Your addresses will differ on every run. On a typical 64-bit Linux system, the first three come out close together (something like 0x55d1c3a7e010), while today shows a much larger number such as 0x7ffe2b9c4a1c. That big gap is the distance between the data regions near the bottom and the stack near the top.

Stack vs heap in C: comparison table

When should you use the stack or the heap?

Common mistakes

1. Putting a huge array on the stack

int main(void) {
    int pixels[10000000];   /* about 40 MB of local variables */
    pixels[0] = 255;
    return 0;
}

This compiles fine, but on most systems it crashes immediately with a stack overflow. Make big arrays static or allocate them on the heap with malloc().

2. Returning the address of a local variable

A local variable's frame disappears when the function returns, so a pointer to it points at memory that's no longer yours. Reading it gives garbage or crashes. You saw this in common pointer mistakes; the heap is the proper fix.

3. Expecting a local variable to keep its value

Without static, a local variable starts over on every call, as local did in the greet() example. If you need the value to stick around, use static.

Practice exercise

#include <stdio.h>

int next_ticket(void) {
    static int last = 100;   /* data region: lives for the whole program */
    last++;
    return last;
}

int main(void) {
    for (int i = 0; i < 3; i++) {
        int ticket = next_ticket();   /* stack: a new local each time */
        printf("Ticket %d\n", ticket);
    }
    return 0;
}

Ticket 101
Ticket 102
Ticket 103

What's next?

You now know where every kind of variable lives. Next, learn to request and release heap memory yourself with malloc() and free() in C.