Smart Pointers
This article is quite advanced and assumes you have an understanding of C++. If not, please refer to the C++ section of this book!
Smart pointers (in C++) are objects that act as pointers, but provide additional features - primarily automatic memory management. They help address issues such as memory leaks and improve safety when compared to raw pointers. The two main types of smart pointers in C++ are:
std::unique_ptr
std::shared_ptr
In general, smart pointers help prevent memory leaks and dangling pointers by automatically managing memory and ensuring proper deallocation. In return, smart pointers may have a slight performance overhead compared to traditional raw pointers, due to additional bookkeeping for ownership and reference counting.
It’s worth noting that smart pointers convey ownership semantics and nullability more clearly, where readability may be a concern in your codebase.
Unique Pointers
Unique pointers (std::unique_ptr
) represent exclusive ownership of a dynamically allocated object. When this type of pointer goes out of scope, it automatically deallocates the associated memory.
Unique pointers enforces exclusive ownership, preventing multiple pointers from managing the same resource simultaneously.
#include <iostream>
#include <memory>
class SomeClass
{
public:
SomeClass(int val)
: data(val)
{
}
int data;
void PrintMe()
{
std::cout << "Data: " << data << std::endl;
}
};
int main()
{
// Creating a std::unique_ptr with a dynamically allocated object
std::unique_ptr<SomeClass> someUniquePtr = std::make_unique<SomeClass>(69);
// Accessing members of the managed object
someUniquePtr->PrintMe();
// std::unique_ptr automatically deallocates memory when it goes out of scope
// No need for manual cleanup or delete
return 0;
}
Shared Pointers
Shared pointers (std::shared_ptr
) enable shared ownership of a dynamically allocated object. It uses a reference counting mechanism, and the memory is deallocated only when the last shared pointer releases its ownership. It’s useful for scenarios where multiple pointers need to share access to the same dynamically allocated object.
#include <iostream>
#include <memory>
class SomeClass
{
public:
SomeClass(int val)
: data(val)
{
}
int data;
void PrintMe()
{
std::cout << "Data: " << data << std::endl;
}
};
int main()
{
// Creating a std::shared_ptr with a dynamically allocated object
std::shared_ptr<SomeClass> someSharedPtr = std::make_shared<SomeClass>(69);
// Creating another std::shared_ptr that shares ownership with the first one
std::shared_ptr<SomeClass> anotherSharedPtr = someSharedPtr;
// Accessing members of the managed object through both shared pointers
someSharedPtr->PrintMe();
anotherSharedPtr->PrintMe();
// The reference count is now 2 (two shared pointers pointing to the same object)
// std::shared_ptr automatically deallocates memory when the last shared_ptr is reset or goes out of scope
return 0;
}