Memory Management¶
C++ lets programs control resource lifetimes explicitly. RAII, containers, and smart pointers help manage those lifetimes without placing cleanup code on every return path.
Runnable examples on GitHub
This lesson's examples and original blocks · CMake build and test instructions. The README distinguishes executable examples, explanation-only fragments and optional compiler/library features.
1. The Stack and the Heap¶
A running C++ program splits its allocated RAM into several areas, most notably the Stack and the Heap.
The Stack (Automatic Storage)¶
The stack is a "LIFO" (Last In, First Out) memory structure managed automatically by the CPU.
- Speed: Extremely fast. Allocation is just incrementing the stack pointer register.
- Lifetime: Managed by scope. When a variable goes out of scope (e.g. at a closing brace }), its memory is popped and automatically freed.
- Limitations: Relatively small size (typically 1–8 MB depending on the OS). Allocating massive arrays on the stack causes a Stack Overflow crash.
The Heap (Dynamic Storage / Free Store)¶
The heap is a large pool of system memory managed manually or via runtime libraries. - Speed: Slower. The OS must search for a free block of suitable size. - Lifetime: Controlled entirely by the programmer. Variables persist until explicitly deleted. - Limitations: Large capacity (limited by system RAM). Requires careful management to prevent leaks.
2. Legacy Manual Management: new and delete¶
Historically, C++ allocated heap memory using new and freed it using delete.
The Dangers of Manual Management¶
- Memory Leaks: Forgetting to call
deletekeeps memory allocated, slowly consuming RAM until the OS terminates the process. - Dangling Pointers: Accessing a pointer after its memory has been deleted.
- Double Free: Calling
deletetwice on the same memory address, causing heap corruption. - Exception Unsafety: If an exception is thrown between
newanddelete, the delete statement is bypassed, causing a leak.
3. The RAII Paradigm¶
RAII (Resource Acquisition Is Initialization) is the single most important design pattern in C++. It binds the lifetime of a resource (heap memory, file handles, network sockets, database connections, or mutex locks) to the lifetime of a stack-allocated object.
- Acquire the resource inside the object's constructor.
- Release the resource inside the object's destructor.
Since stack-allocated objects are guaranteed to call their destructors when going out of scope—even during exceptions—resources are never leaked.
4. Modern C++ Smart Pointers¶
Prefer containers and smart pointers for ordinary ownership. The <memory> header provides smart pointers that use RAII to release owned objects; raw pointers can still represent non-owning access.
1. std::unique_ptr<T>¶
Represents exclusive ownership of a heap resource. Only one unique_ptr can point to the resource at a time. It cannot be copied, only moved.
2. std::shared_ptr<T>¶
Represents shared ownership of a resource. Multiple shared_ptr objects can point to the same resource. It maintains an internal Reference Count block.
- Creating/copying a shared_ptr increments the count.
- Destroying a shared_ptr decrements the count.
- When the reference count reaches 0, the heap resource is deleted.
Why Use std::make_shared?¶
Using std::shared_ptr<T>(new T) performs two separate heap allocations: one for the object T, and one for the reference control block. std::make_shared allocates both in a single contiguous block, improving cache locality and performance.
3. std::weak_ptr<T>¶
A non-owning observer pointing to an object managed by std::shared_ptr. It does not increment the reference count. To access the resource, it must be promoted to a shared_ptr using .lock().
5. Circular Reference Leaks¶
A major vulnerability of std::shared_ptr is the Circular Reference (or reference cycle). If two objects contain shared_ptrs pointing to each other, their reference counts can never drop to 0, resulting in a permanent memory leak.
The Fix: Use std::weak_ptr¶
Break the cycle by declaring one of the pointers as a weak_ptr:
6. Move Semantics: Performance Optimized¶
C++11 introduced Move Semantics to eliminate expensive deep copy operations on temporary objects (Rvalues). Instead of copying the underlying memory block, a move constructor "steals" the pointer from the source object, resetting the source's pointer to null.
- Lvalues: Objects that have an identifiable location in memory (an address) and a name (e.g.,
int x). - Rvalues: Temporary values that do not persist beyond the expression (e.g., the result of
x + y, or a temporary string returned by a function).
std::move is a cast that permits move-aware overload selection; it does not itself transfer a resource or establish that an operation is safe. The selected constructor or assignment defines the actual operation. Unless a stronger contract applies, standard-library moved-from objects have a valid but unspecified state. In the illustrative vector example below, an observed source size of zero is not a general postcondition; the repository test deliberately does not require it.
Related Guides¶
- Pointers and References — Address basics and pointer types.
- Classes and Objects — Destructors, copy constructors, and move assignment.