Question 1

What is the difference between the stack and the heap?

Accepted Answer

Both are regions of memory a program uses, with fundamentally different allocation strategies and lifetimes.

**The stack** holds function call frames. Each call pushes a frame containing parameters, local variables and the return address; each return pops it. Allocation is **automatic** and extremely fast — it is essentially moving a pointer — and deallocation is guaranteed by the structure itself.

**Properties:** strictly last-in-first-out, contiguous, excellent cache locality, and a **fixed, fairly small size** (often a few megabytes per thread).

**Its limits:** everything must have a size known at compile time, and lifetimes are bound to the call. Returning a pointer to a local variable is a classic bug in C, because the frame is gone. Exceed the stack — usually through unbounded recursion — and you get a **stack overflow**.

**The heap** holds dynamically allocated memory. You request a block at runtime, of a size determined at runtime, and it lives until explicitly freed or garbage collected.

**Properties:** large, flexible, and lifetimes independent of function calls — which is what lets you return data structures from functions and share them.

**Its costs:** allocation is significantly slower, requiring the allocator to find a suitable block; memory becomes **fragmented** over time; access has worse cache locality because objects are scattered; and it is where memory leaks and use-after-free bugs live.

**How languages expose this.** In C and C++ it is explicit — locals on the stack, `malloc`/`new` on the heap. In Java, primitives and references sit on the stack while objects live on the heap. Go's compiler performs **escape analysis**, placing values on the stack when it can prove they do not outlive the function. Rust's ownership system tracks heap lifetimes at compile time.

**Practical implication:** prefer stack allocation where possible — it is faster and cannot leak.

Question 2

How does garbage collection actually work?

Accepted Answer

By determining which objects are still reachable from your running program and reclaiming everything else. The key insight is that it does not detect garbage — it detects live data, and treats the

Question 3

What is a queue and a stack, and when do you use each?

Accepted Answer

Two of the simplest data structures, distinguished entirely by which element you get back: a stack returns the most recently added, a queue returns the oldest. That single difference determines an

Question 4

What is memory safety, and why does it matter so much?

Accepted Answer

A property of a language or system guaranteeing that a program cannot access memory it should not — no reading past the end of a buffer, no using freed memory, no dereferencing invalid pointers. Its

Question 5

What is the difference between a process and a thread?

Accepted Answer

A process is an independent running program with its own memory space. A thread is a unit of execution inside a process, sharing that process's memory with its sibling threads. What a process owns:

Question 6

What is recursion, and when should you use it?

Accepted Answer

A function that calls itself, solving a problem by reducing it to a smaller version of the same problem until it reaches a case simple enough to answer directly. The two required parts. A base case,

Question 7

What are the best C++ memory management techniques?

Accepted Answer

C++ memory management techniques include stack allocation, dynamic memory allocation, smart pointers, memory pooling, and garbage collection. Each has its advantages and trade-offs.

Related Questions