Stack, Heap and Object Lifetime

Where objects live and when they die

Every C++ object has a storage duration and a lifetime. Automatic objects (local variables) live on the stack: created when execution reaches their definition and destroyed automatically, in reverse order, when the enclosing scope ends. Allocation is extremely fast and cleanup is guaranteed. Dynamic objects live on the heap (the free store), created with new and destroyed only when someone calls delete. That flexibility brings classic bugs: memory leaks (forgetting delete), double deletes (calling delete twice), dangling pointers (using memory after it was deleted) and mismatched new[] with delete. Static objects (globals, static locals) live for the whole program. In modern C++ you almost never write new and delete directly: containers such as std::vector and std::string manage their own heap memory, and smart pointers own dynamically allocated objects, so cleanup is automatic even when exceptions are thrown.

Stack frames and the heap

Local variables live in stack frames that disappear on return; heap objects stay until released.

Manual memory versus automatic management

The raw version leaks if anything throws between new and delete.

#include <memory>
#include <string>
#include <vector>

void risky() {
    auto* names = new std::vector<std::string>{"Asha", "Ravi"};   // heap allocation
    process(*names);           // if this throws, delete below never runs -> leak
    delete names;
}

void safe() {
    std::vector<std::string> names{"Asha", "Ravi"};   // the vector manages its own heap memory
    process(names);            // freed automatically when names goes out of scope
}

void when_you_need_heap_object() {
    auto report = std::make_unique<std::string>("quarterly report");
    process_text(*report);     // freed automatically, even if an exception is thrown
}

No naked new

The C++ Core Guidelines recommend avoiding explicit new and delete in application code. If you see new, ask which container or smart pointer should own that object instead.

त्वरित जाँच: What happens to a local std::vector when the function it was declared in returns?

• Its destructor runs automatically and frees its memory
• It leaks unless you call delete
• It moves to the heap
• It stays alive until the program ends