the heap
The stack is great for memory whose lifetime matches a function call, but sometimes you need memory that outlives the function that created it, or whose size you only learn at run time. The heap is the region of a program's address space set aside for exactly this: memory you request explicitly, that stays around until you explicitly give it back.
Unlike the stack, the heap is not tied to call-and-return. You ask for a block with an allocation call, you get back a pointer to it, and that block persists — across function returns, for as long as you like — until you release it. The heap grows as needed (classically upward, toward higher addresses, opposite the stack), and the run-time allocator carves your requested blocks out of it and tracks which parts are in use. Because nothing reclaims heap memory automatically, ownership becomes a question you must answer: somebody has to remember to free each block exactly once. This is the region that the next field, dynamic memory, is all about; here it is enough to know what it is and how it differs from the stack.
Two honest cautions. First, like the call stack, 'the heap' here is a memory region for dynamic allocation — it is not the heap data structure (the priority-queue tree); they share a name only by accident. Second, heap memory is flexible but not free of cost: allocating and freeing take real work, blocks can leak if you forget to release them, and a freed block leaves your pointer dangling. The stack is automatic and fast; the heap is manual and flexible — choosing between them is a recurring design decision.
char *p = malloc(256); fills a request for 256 bytes on the heap and returns a pointer to it; that block survives past the current function and is reclaimed only by free(p). Forgetting the free(p) leaks those 256 bytes.
Heap blocks persist until explicitly freed — ownership is your job.
'The heap' (a memory region for dynamic allocation) is not the heap data structure (a priority-queue tree) — the names coincide. Heap memory is never reclaimed automatically in C, so every block needs an owner who frees it exactly once; the details (malloc, free, leaks, use-after-free) are Field e.