Every C++ developer eventually encounters a memory leak. You allocate something on the heap, write some logic, hit an early return at runtime and suddenly that heap memory is gone forever:
std::vector<int>* numbers = new std::vector<int>({1, 2, 3});
// ... what if we return early?
// ... what if an exception fires?
delete numbers; // only runs if we get here
The good news is that it is entirely possible to write professional C++ without malloc or new. The above example can be written as follows, without new and delete:
std::vector<int> numbers = {1, 2, 3}; // Clean and safeThe vector internally does roughly this:
Stack Heap ┌───────────────┐ ┌───────────────┐ │ numbers │ │ │ │ _data ────────┼──┼─► [1] [2] [3] │ │ _size = 3 │ │ │ │ _capacity= 3 │ │ │ └───────────────┘ └───────────────┘
The vector object itself lives on the stack, but the actual integers are allocated on the heap via new[] / allocator, inserted by the compiler. The vector acts as a "wrapper" or "manager" for a raw block of memory on the heap. The std::vector object itself is just a small, fixed-size handle (8-byte pointers = 24 bytes). It doesn't grow or shrink, helping you preserve the precious stack. It knows exactly where the heap memory starts, how much is used, and how much is left. The actual data (your integers, strings, or custom objects) lives in the heap and its size can be gigabytes.
In C++, the destructor of a stack-allocated object is automatically inserted into the generated code by the compiler at all the places where the object goes out of scope:
int complexFunction(int x) {
std::vector<int> numbers = {1, 2, 3};
if (x < 0) {
// COMPILER INSERTS: numbers.~vector();
return -1;
}
// COMPILER INSERTS: numbers.~vector();
return x * 2;
}
In the assembly listing, you will see lines like this:
call std::vector<int, std::allocator<int>>::~vector() [base object destructor]
When the std::vector destructor runs, it automatically performs two critical tasks:
- Element Destruction: it calls the destructor for every individual object currently stored in the vector. If you have a vector of strings, it ensures each string cleans up its own character buffer first.
- Deallocation: Once the elements are destroyed, the vector calls the underlying deallocation function (typically a wrapper around operator delete[] or a custom allocator) to return the entire block of heap memory to the system.
If you were using malloc or new manually, you would have to remember to call free or delete in every possible exit path of your function (including if an error occurs):
std::vector removes this "human element" by making the cleanup a language-level guarantee.
If you have a custom MyClass with a constructor that takes runtime parameters:
// ❌ with new — obj on heap, you manage lifetime manually
MyClass* obj = new MyClass(size, name);
delete obj; // must remember this at every exit point
// ✅ without new — obj on stack, lifetime managed automatically
MyClass obj(size, name);
// no delete needed
In C++11 and beyond, smart pointers cover every legitimate use case for new and delete. Example of object that outlives its scope:
// ❌ old way
MyClass* obj = new MyClass(size, name);
return obj; // caller must remember to delete
// ✅ modern way
return std::make_unique<MyClass>(size, name); // ownership transfers automatically
When you have a class OneClass with a member myMember variable that is also a class of type MyClass and myMember constructor parameters are specified at runtime:
class OneClass {
public:
OneClass(int size, std::string name)
: myMember(size, name) // ← myMember constructed here, with runtime args
{
// constructor body, myMember is already fully constructed here
}
private:
MyClass myMember; // ← no "new", lives inside OneClass
};
OneClass obj(size, name) created
│
├── myMember(size, name) constructed ← initializer list
│
└── OneClass constructor body runsIf myMember is not constructed in OneClass constructor but in some other method call:
#include <memory>
class OneClass {
public:
OneClass() {} // myMember is nullptr
void initialize(int size, std::string name) {
myMember = std::make_unique<MyClass>(size, name); // constructed here
}
private:
std::unique_ptr<MyClass> myMember; // nullptr until initialize() is called
};unique_ptr starts as nullptr and takes ownership when assigned. ~MyClass() is called automatically when OneClass is destroyed, no manual cleanup needed.
The general term for this mechanism is called RAII (Resource Acquisition Is Initialization). In this paradigm, you use objects that manage their own memory. When the object goes out of scope, it automatically cleans up.
Music: Passenger - Let Her Go
