Smart Pointers and std::unique_ptr

Using Smart Pointers with Custom Deleters

Can I use smart pointers with my own custom deleters?

Illustration representing computer hardware

Yes, std::unique_ptr allows you to specify a custom deleter. This can be useful if you need to do something more than just call delete when the pointer is destroyed.

Here's an example where we use a custom deleter to print a message when the object is destroyed:

1#include <memory>
2#include <iostream>
3
4class Character {
5public:
6  std::string Name;
7  Character(std::string Name) : Name{Name} {
8    std::cout << "Creating " << Name << '\n';
9  }
10  ~Character() {
11    std::cout << "Destroying " << Name << '\n';
12  }
13};
14
15struct CharacterDeleter {
16  void operator()(Character* c) const {
17    std::cout << "Custom deleting "
18      << c->Name << '\n';
19    delete c;
20  }
21};
22
23int main() {
24  std::unique_ptr<Character, CharacterDeleter>
25    Gandalf{new Character{"Gandalf"}};
26}

1Creating Gandalf
2Custom deleting Gandalf
3Destroying Gandalf

Here, we define a CharacterDeleter struct that overloads the () operator. This operator will be called when the unique_ptr needs to delete the Character.

We then specify CharacterDeleter as the second template argument to std::unique_ptr. This tells the unique_ptr to use CharacterDeleter instead of the default deleter.

You can also use a lambda as a custom deleter:

1#include <memory>
2#include <iostream>
3
4class Character {
5public:
6  std::string Name;
7  Character(std::string Name) : Name{Name} {
8    std::cout << "Creating " << Name << '\n';
9  }
10  ~Character() {
11    std::cout << "Destroying " << Name << '\n';
12  }
13};
14
15int main() {
16  std::unique_ptr<Character,
17    void(*)(Character*)> Gandalf{
18    new Character{"Gandalf"},
19    [](Character* c) {
20      std::cout << "Custom deleting "
21        << c->Name << '\n';
22      delete c;
23    }
24  };
25}

1Creating Gandalf
2Custom deleting Gandalf
3Destroying Gandalf

Here, we specify the type of the deleter as void(*)(Character*), which is a function pointer that takes a Character* and returns void. We then pass a lambda with this signature as the second argument to the unique_ptr constructor.

Custom deleters can be useful for managing resources that aren't directly heap-allocated with new, such as file handles, network sockets, or graphics resources.

This Question is from the Lesson: