Dynamic Memory - The Free Store and the Heap

In the previous lesson, we introduced memory management, and how memory is allocated on the stack.

The automatic memory management done for us in the stack kept our lives simple through the beginner courses. But, we saw two big constraints of stack-allocated memory:

• The amount of memory available on the stack is limited
• When a frame is removed from the stack, the memory it was using is released.

But, inevitably, there are going to be scenarios where we need to intervene and take control of the memory allocation and deallocation process.

When we need to do this, we will be placing our objects in dynamic memory.

Allocating Dynamic Memory with new

To create an object in dynamic memory, we use the new keyword:

1#include <iostream>
2using std::cout, std::endl;
3
4class Character {
5public:
6string Name { "Frodo" };
7
8~Character() {
9  cout << "Destroying Character" << endl;
10}
11};
12
13int main() {
14  cout << new Character << endl;
15}
16

10x624e70
2

On my system, this logged out 0x624e70

This looks like a memory address, which would suggest that new returns a pointer. This is indeed the case:

1int main() {
2  cout << (new Character)->Name << endl;
3}
4

1Frodo
2

Like with any other pointer, we can store this in a variable:

1int main() {
2  Character* MyCharacter { new Character };
3  cout << MyCharacter->Name << endl;
4}
5

During this program, we have memory on the stack that is being used to store a pointer. That pointer is pointing at a location in dynamic memory, that has a Character object.

When using new we can still construct our objects any way we normally would. For example, we can pass arguments to the constructor:

1int main() {
2  int* MyInt { new int { 42 } };
3  cout << *MyInt << endl;
4
5  Character* MyCharacter { new Character { "Gandalf" } };
6  cout << MyCharacter->Name << endl;
7}
8

142
2Gandalf
3

We can also use any expression that would create a value of the appropriate type:

1Character GetGandalf() {
2  return Character { "Gandalf" };
3}
4
5int main() {
6  int* MyInt { new int { 40 + 2 } };
7  cout << *MyInt << endl;
8
9  Character* MyCharacter { new Character { GetGandalf() } };
10  cout << MyCharacter->Name << endl;
11}
12

142
2Gandalf
3

Returning Dynamic Memory from Functions

This allows us to address the problem from the previous chapter. We can now create an object within a function and return a pointer to that object.

Because the object is not being stored in the stack, it will remain available even when the stack frame is removed after the function ends:

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6~Character() {
7  cout << "Destroying Character" << endl;
8}
9string Name { "Frodo" };
10};
11
12Character* SelectCharacter() {
13  return new Character { "Gandalf" };
14}
15
16int main() {
17  Character* MyCharacter { SelectCharacter() };
18  cout << MyCharacter->Name << endl;
19}
20

1Gandalf
2

Our program now logs out Gandalf as expected. However, we never see the Destroyed Character message from our destructor being logged.

Because we’re now allocating memory in the free store rather than the stack, we are now responsible for deleting our objects.

This no longer happens automatically and, if we do not free the memory when it is no longer needed, we have a type of defect called a memory leak.

Memory Leaks

The systems that our software runs on only have a limited amount of memory. Because of this, we need to make sure we’re freeing the memory we no longer need.

Any failure to do that creates a defect in our software called a memory leak. When we have a memory leak, our software uses more and more memory the longer it is running. When the system runs out of memory to allocate, our program is likely to run into problems.

This is a particularly nasty type of defect to have because, by its very nature, it can be difficult to detect during testing. A memory leak may take hours or days to deplete the system resources, and it can take much longer if it’s being tested on a system with a lot of memory available.

Because of this, a program that seems stable when we run it on our machine can fail in the real world.

Freeing Memory using Delete

To delete an object we previously created by calling new, we call delete with the pointer to the object.

1int main() {
2  Character* MyCharacter { SelectCharacter() };
3  cout << MyCharacter->Name << endl;
4  delete MyCharacter;
5}
6

Our program now works as expected, and cleans up after itself:

1Gandalf
2Destroying Character
3

Problems with new and delete

In complex programs, managing memory manually using new and delete can become very difficult. This is particularly true when many different components of our system are relying on the same objects stored in the free store.

1. If we do not call delete, we have a memory leak
2. If we call delete on a resource that was already deleted, we cause memory corruption and defects (this is called a “double-free error”)
3. If we call delete too early, a component that was still using that resource will stop functioning

Additionally, even code that looks safe can have a memory leak:

1void MyFunction() {
2  int* ptr { new int { 42 } };
3  AnotherFunction();
4  delete ptr;
5}
6

In this seemingly safe example, it is possible for AnotherFunction to fail, but for our program to recover. We talk about how to recover from failures in a future chapter on Exception Handling but, even applying those techniques, we would still be left with a memory leak. This is because MyFunction would fail before line 4 is executed.

In complex software, the responsibility to delete every object, exactly once, at the correct time, and in every scenario, is too much of a burden.

Because of this, we adopt a more structured design around how memory is managed, and we use smart pointers to help us implement it. We’ll cover this in the next lesson.