Using Custom Deleters with Weak Pointers

No, you cannot directly specify custom deleters for weak pointers like you can with unique_ptr and shared_ptr. Weak pointers do not participate in the ownership or destruction of the pointed-to objects. Instead, they rely on the corresponding shared pointers to manage the object's lifetime and deletion.

When you create a shared pointer with a custom deleter, the deleter is stored in the control block associated with the shared pointer. The control block is shared among all the shared pointers and weak pointers that refer to the same object. When the last shared pointer to the object is destroyed, the custom deleter is invoked to properly cleanup the resource.

Here's an example that demonstrates using a custom deleter with shared_ptr:

1#include <memory>
2#include <iostream>
3
4class MyClass {
5public:
6  ~MyClass() {
7    std::cout << "Destructor called\n";
8  }
9};
10
11struct CustomDeleter {
12  void operator()(MyClass* ptr) {
13    std::cout << "Custom deleter called\n";
14    delete ptr;
15  }
16};
17
18int main() {
19  std::shared_ptr<MyClass> SharedPtr{
20    new MyClass{}, CustomDeleter{}
21  };
22
23  std::weak_ptr<MyClass> WeakPtr{SharedPtr};
24}

1Custom deleter called
2Destructor called

In this example, we create a shared pointer SharedPtr to a dynamically allocated MyClass object, and we specify a CustomDeleter as the second argument to the shared_ptr constructor. The CustomDeleter is a functor that overloads the function call operator to define how the object should be deleted.

We then create a weak pointer WeakPtr from the SharedPtr. The weak pointer itself does not store or manage the custom deleter. It simply refers to the object managed by the shared pointer.

When the SharedPtr goes out of scope and is destroyed, it checks if it is the last shared pointer referencing the object. Since it is, it invokes the CustomDeleter to cleanup the resource, and then the destructor of MyClass is called.

Although weak pointers do not directly support custom deleters, they can still be used in conjunction with shared pointers that have custom deleters. The custom deleter will be invoked when the last shared pointer is destroyed, regardless of any weak pointers that may still reference the object.

If you need to perform custom cleanup logic when the object is destroyed, you should define the custom deleter in the shared pointer that owns the object, and weak pointers can be used to observe the object without affecting its lifetime.