C++ Memory

Most objects need no new

A local variable lives until the block ends. The compiler allocates it and frees it. That is automatic storage, often called the stack. Beginners should stay here: int n, string s,vector<int> v.

#include <iostream>
#include <string>
using namespace std;

int main() {
  int n = 7;
  string label = "count";
  cout << label << " " << n << endl;
  return 0;
}

When main returns, n and label are gone. You did not calldelete. Prefer this until you have a reason not to.

new allocates, delete frees

new int(7) asks the heap for an int, stores 7 in it, and returns a pointer. That memory stays allocated until you delete the pointer. Forget delete and the program leaks. Delete twice and the program is undefined.

#include <iostream>
using namespace std;

int main() {
  int* p = new int(7);
  cout << *p << endl;
  delete p;
  return 0;
}

Pair every new with one delete on the same path. For arrays allocated withnew int[n] the match is delete[]. This tutorial shows a single object so the pairing is obvious. Do not return from the function before delete unless something else owns the pointer.

Use vector instead of new[]

A resizable list is the usual reason people reach for new int[n]. vector already does that allocation and frees it in the destructor. You write push_back. You do not writedelete[].

#include <iostream>
#include <vector>
using namespace std;

int main() {
  vector<int> nums;
  nums.push_back(7);
  nums.push_back(11);
  cout << nums[0] + nums[1] << endl;
  return 0;
}

When nums goes out of scope, its buffer is released. No leak, even if you add morepush_back calls later. For a tutorial list, this is the default tool.

unique_ptr when you need a single heap object

Sometimes you really want one object on the heap (a large graph node, an object whose type is chosen at runtime). In C++17 use std::make_unique from <memory>. The unique_ptr deletes the object when the pointer variable dies.

#include <iostream>
#include <memory>
using namespace std;

int main() {
  unique_ptr<int> p = make_unique<int>(42);
  cout << *p << endl;
  return 0;
}

There is no delete in this file. make_unique<int>(42) allocates. powns the result. At the closing brace of main, the destructor of unique_ptr frees it. Do not mix this with a manual delete p.get().

Who owns the memory

Ownership is the question: when this name dies, does the object die with it? Automatic variables, vectors, and unique_ptr all answer yes. A raw pointer from new answers no until you delete.

A default rule

1. Use a local variable or a member. No heap.
2. If you need a list, use vector.
3. If you need one heap object, use make_unique and #include <memory>.
4. Write new and delete only when you are learning how the heap works, or when a library forces a raw pointer and you wrap it immediately.

What you should remember

new is not how you create every object in C++. It is how you ask the heap for storage that outlives the current statement. Containers and smart pointers are the usual owners of that storage. If you do usenew yourself, delete once, on every path, and then look for a way to stop doing that.