I’ve recently found the need for a custom deleter function attached to smart pointers in C++ and I found there are a number of different ways to implement this.
I’ll touch on the advantages/disadvantages of the different ways to use custom deleters and the difference between unique and shared ptr.
std::unique_ptr:
The type of the deleter is defined as part of the unique_ptr and you define it as the second template parameter, then when constructing the type, you must pass through the type specified as a parameter.
Instead of std::unique_ptr calling ‘delete’ and invoking the destructor on the internally stored pointer, it will instead pass the pointer to the function provided.
The deleter must by a type which implements a operator() which takes a T* as a parameter.
So in the example below, we specify that the deleter is std::function<void(MyClass*)>. Then on construction, we pass through the function we want to call.
class MyClass
{
public:
~MyClass() { }
};
using DefaultPtr = std::unique_ptr<MyClass>;
DefaultPtr pDefault; //Will call MyClass::~MyClass()
using CustomDeletePtr = std::unique_ptr<MyClass, std::function<void(MyClass*)>>;
CustomDeletePtr pCustom; //Will call function passed through on construction
static void CustomDeleter(MyClass* pMyClass)
{
//This will be called instead of delete and invoking the constructor.
}
void InitPointers()
{
pDefault = DefaultPtr(new MyClass());
pCustom = CustomDeletePtr(new MyClass(), &CustomDeleter);
}std::unique_ptr – cheapest implementations:
The custom deleter type you specify will affect the size of your std::unique_ptr. The sizes below are from C++ VS2019 64bit.
- Default: std::unique_ptr<MyClass> (no custom deleter) – 8 bytes.
- 1: std::unique_ptr<MyClass, CustomDeleteClass> – 8 bytes.
- 2 std::unique_ptr<MyClass, decltype(lambda)> – 8 bytes.
- 2: std::unique_ptr<MyClass, void(*)(MyClass*)> – 16 bytes.
- 3: std::unique_ptr<MyClass, std::function<void(MyClass*)> – 72 bytes.
Lets talk about the sizes above. std::unique_ptr by default is a really simple wrapper for a pointer and it only has to store the 8 byte pointer.
Adding custom deleters can increase the size of std::unique_ptr because it has to store the type specified. std::function really bloats out the size of the std::unique_ptr because of the flexibility and features it provides.
Providing a C Style function as the deleter void(*)(MyClass*) increases the size to 16 bytes. This is because it needs to store a pointer to the function specified. Its increase the size of the function but offers good flexibility because you can provide any function you want when constructing.
Using a custom deleter class with an operator() or a lambda incurs no additional storage overhead because the custom deleter function is always the same for all objects created and the DeleterClass contains no member variables.
class DeleterClass
{
public:
void operator()(MyClass* pMyClass)
{
}
};
using CustomDeleteOperatorPtr = std::unique_ptr<MyClass, DeleterClass>;
CustomDeleteOperatorPtr MyCustomPtr(new MyClass());
auto lambda = [](MyClass* p) { delete p; };
std::unique_ptr<MyClass, decltype(lambda)> PointerWithLambda(new MyClass(), lambda);One bonus when using the operator() over a lambda is that you don’t even have to specify it when constructing new instances of the object as you can see above, assuming the class can be default constructed.
std::shared_ptr
std::shared_ptr requires some different syntax compared to std::unique_ptr. Behind the scenes, std::shared_ptr allocates a ‘control block’ containing the atomic reference counter and other data such as the custom deleter. The image below from Oreilly.com shows it nicely:
When using a custom deleter with shared_ptr we don’t pass any additional template arguments, our custom deleter is passed when creating the object and it exists within the control block.
class MyClass
{
public:
~MyClass() { }
};
static void CustomDeleter(MyClass* pMyClass)
{
delete pMyClass;
}
int main()
{
//1 - Function
std::shared_ptr<MyClass> s1(new MyClass(), CustomDeleter);
//2 - Lambda
std::shared_ptr<MyClass> s2(new MyClass(), [](MyClass* pMyClass) { delete pMyClass; });
//3 - Custom Class
class DeleterClass
{
public:
DeleterClass()
{
}
void operator()(MyClass* pMyClass)
{
delete pMyClass;
}
};
DeleterClass d; //Must be CopyConstructible.
std::shared_ptr<MyClass> s3(new MyClass(), d);
}The size of the shared_ptr remains 16 bytes on a 64 bit compiler. One pointer to the object and another pointer to the control block. Depending on the implementation, the size of the control block could change if a custom deleter is or isn’t allocated.
On MSVC 2019, using std::shared_ptr by default, the control block size is 24 bytes. The size of the control block can increase depending on the type of deleter used. Using a lambda or class with an operator() incurs no additonal storage overhead. Using a function pointer will increment the size by the cost of a pointer and using more complex types such as std::function will increase storage further, as it does with std::unique_ptr.
Note: Unfortunately you cannot use a custom deleter with std::make_shared (nor with std::make_unique). Something else interesting to know about std::shared_ptr is that it’s more optimal to use std::make_shared() rather than std::shared_ptr<T>(new T()) because internally the implementation needs to allocate a control block so if you provide your own pointer, it has to call ‘new’ to allocate its own control block. If you called make_shared(), it will allocate the memory for your data and the control block in the same allocation!
Closing thoughts
When wanting to use a custom deleter with a std::unique_ptr and you want it to be the same function for all objects, use a custom class with operator() as this incurs the least overhead, can be inlined at runtime and doesn’t increase the size of unique_ptr.
If you’re wanting to call a different function for each of your unique_ptrs, opt for a straight up function pointer/ lambda. The only additional overhead is the cost of storing the function pointer.
For std::shared_ptr, the storage overhead of the deleter is stored in the control block only once instead of for every object like with std::unique_ptr, so it’s cheaper to use a complex delete type with larger storage requirements.
Leave a Reply