🧠 Understanding Memory Layout in C++ Programs

When a C++ program runs, the operating system divides the program’s memory into well-defined regions.
Understanding this memory layout is crucial for debugging, writing efficient code, and avoiding undefined behavior.

---

📐 Typical Memory Layout

Here’s a visual representation of a process’s memory layout in C++:

A typical process is divided into the following regions:

1. Text (Code) Segment
2. Initialized Data Segment
3. Uninitialized Data Segment (BSS)
4. Heap
5. Stack

Let’s break them down.

---

1️⃣ Text Segment (Code)

• Contains compiled machine instructions of your program.
• Marked as read-only to prevent accidental modification.
• Shared among processes running the same program (saves memory).

cpp
Copy
#include <iostream>
void hello() {
    std::cout << "Hello, Memory Layout!\n";
}
int main() {
    hello();
}

Here, the compiled instructions for main() and hello() live in the text segment.

---

2️⃣ Data Segment (Initialized Data)

• Stores global and static variables that are initialized.
• Persistent throughout program execution.

cpp
Copy
#include <iostream>

int globalVar = 42; // lives in the Data segment

int main() {
    std::cout << globalVar << "\n";
}

---

3️⃣ BSS (Uninitialized Data Segment)

• Holds global and static variables initialized to 0 (or not initialized at all).
• Memory is allocated at runtime but not explicitly stored in the binary.

cpp
Copy
#include <iostream>

int uninitialized; // stored in BSS

int main() {
    std::cout << uninitialized << "\n"; // default is 0
}

---

4️⃣ Heap

• Dynamic memory allocated at runtime using new, malloc(), etc.
• Grows upwards in memory.
• Managed manually by the programmer (or smart pointers).

cpp
Copy
#include <iostream>

int main() {
    int* arr = new int[5]; // allocated on heap
    arr[0] = 10;
    std::cout << arr[0] << "\n";
    delete[] arr; // free heap memory
}

---

5️⃣ Stack

• Used for function calls, local variables, and control flow.
• Grows downwards in memory.
• Managed automatically — freed when a function returns.

cpp
Copy
#include <iostream>

void foo() {
    int local = 5; // allocated on stack
    std::cout << local << "\n";
}

int main() {
    foo(); // stack frame created + destroyed
}

---

🔄 Stack vs Heap

Feature	Stack	Heap
Allocation	Automatic (fast)	Manual (slower)
Lifetime	Function scope	Until delete/free
Size	Limited (MBs)	Large (depends on system)
Errors	Stack overflow (deep recursion)	Memory leaks, fragmentation

---

⚠️ Common Pitfalls

1. Stack Overflow

   cpp
   Copy
   void recurse() {
       int arr[10000]; // consumes stack quickly
       recurse();
   }

   Recursive calls may overflow the stack.

2. Memory Leaks in Heap

   cpp
   Copy
   int* p = new int(10);
   // forgot delete → memory leak

3. Dangling Pointers

   cpp
   Copy
   int* p = new int(5);
   delete p;
   std::cout << *p; // ❌ undefined behavior

---

✅ Key Takeaways

• Text segment → program instructions.
• Data segment → initialized globals/statics.
• BSS → uninitialized globals/statics.
• Heap → dynamic memory (you manage it).
• Stack → local variables & function calls.

---

📝 Quick Checklist

• Know where variables live (stack vs heap).
• Initialize all global/static variables.
• Free heap memory (delete / smart pointers).
• Avoid deep recursion to prevent stack overflow.
• Use sanitizers (-fsanitize=address,undefined) for debugging.

---

🚀 Final Words

Mastering memory layout makes you a better C++ developer, helps in writing bug-free code, and prepares you for low-level interviews at top companies (like NVIDIA, Qualcomm, HFTs).

Next time you debug a segmentation fault, remember:

It’s usually stack overflow, heap misuse, or accessing invalid memory regions 😉