Manual memory management requires developers to remember to deallocate memory explicitly when it’s no longer needed. However, as we saw in the last chapter, manual deallocation can lead to memory leaks and dangling pointers.

You can think of manual memory management as having to manually clean up after a party. If you forget to clean up, it can lead to an untidy and disorganized space over time, which will be unsuitable for hosting future parties.

Now, imagine if you had a team of diligent cleaners who automatically took care of tidying up after the party. They ensured that nothing was left behind after the party was over, and everything was clean and ready for the next event. This is what smart pointers do for memory management in C++.

Smart pointers introduction

Smart pointers are objects that automate memory management, even for dynamic memory. There are three kinds of smart pointers:

• Unique pointers: these smart pointers ensure exclusive ownership of the dynamically allocated object. It means that only one unique pointer can own the object at any given time.
• Shared pointers: these smart pointers allow multiple pointers to safely share ownership of the same dynamically allocated object.
• Weak pointers: these smart pointers can access a resource without taking ownership of it.

The role of references

Smart pointers are a valuable tool, but they're not the only ones in our arsenal. References also play a crucial role in memory management and data manipulation.

In this example, we create a reference to the integer variable x. In subsequent code, if we modify the value of refX, the value of x will automatically be changed. Similarly, if we modify the value of x, refX will also get updated.

Remember

References provide an alias for an existing objects. Any changes to the alias are also made to the existing object, and vice versa.

We briefly touched upon the importance of smart pointers and references while dealing with dynamic memory. We’ll explore these concepts in detail in the next sections.