When you compile and run a C program, it doesn't just execute randomly in your computer's memory. The operating system organizes it into a clean, predictable structure called a process address space. This space is divided into distinct segments, each with a specific purpose. Understanding this layout is the key to mastering pointers, memory management, and debugging tricky errors.

Every C program is organized into four primary memory segments. Let's walk through them from the lowest memory address to the highest.

2. Data & BSS Segments: These segments store global and static variables, which exist for the entire lifetime of the program. They are split into two sub-sections:

• Initialized Data Segment: Stores global and static variables that have an explicit starting value. For example, int global_max = 99; would live here.
• BSS Segment: Stores global and static variables that are not initialized in the code. For example, static int counter;. The operating system ensures that all memory in this segment is initialized to zero before your program starts running.

3. Heap: This is the region for dynamically allocated memory. When you use functions like malloc() to request memory while the program is running, that memory is carved out of the heap. The heap starts at the end of the BSS segment and grows upward toward higher memory addresses. Crucially, you are responsible for managing this memory yourself by calling free() when you're done with it.

4. Stack: This segment is used for local variables, function parameters, and return addresses. It operates on a Last-In, First-Out (LIFO) basis. When a function is called, its data is "pushed" onto the stack. When the function finishes, its data is "popped" off. The stack starts at the highest memory address and grows downward.

The stack is the workhorse for managing the flow of your program. Every time you call a function, a new stack frame is created and pushed onto the stack. This frame is a self-contained block of memory that holds everything the function needs to do its job:

• Its local variables.
• The parameters passed to it.
• The return address—the spot in the code it needs to jump back to when it's finished.

When the function completes, its entire frame is popped off the stack, and all its local variables are destroyed. This automatic allocation and deallocation is what makes the stack fast and efficient.

This frame-based system explains why recursive functions can be dangerous. Each recursive call pushes a new stack frame. If the recursion goes too deep without a base case to stop it, the stack runs out of space. This collision with the heap or other memory segments results in a classic crash: a stack overflow.