Custom deleter

main.cpp

@@ -34,14 +34,18 @@ int TestObject::instanceCount = 0;
 template<class T>
 class UniquePtr {
 public:
-    explicit UniquePtr(T *object) : object(object) {}
+    /// Constructor without deleter
+    explicit UniquePtr(T *object) : object(object), deleter(nullptr) {}
+
+    /// Constructor with deleter
+    UniquePtr(T *object, void (*deleter)(T*)) : object(object), deleter(deleter) {}
 
     /// Copy constructor
     /// Shouldn't be used, since the pointer wouldn't be unique otherwise
     UniquePtr(const UniquePtr &other) = delete;
 
     /// Move constructor
-    UniquePtr(UniquePtr &&other) : object(other.object) {
+    UniquePtr(UniquePtr &&other) : object(other.object), deleter(other.deleter) {
         other.object = nullptr;
     }
 
@@ -54,7 +58,7 @@ public:
 
     /// Destructor
     virtual ~UniquePtr() {
-        delete object;
+        deleteObject();
     }
 
     T operator*() const {
@@ -79,35 +83,61 @@ public:
 
     /// Reset the internal pointer to null
     void Reset() {
-        delete object;
+        deleteObject();
 
         object = nullptr;
     }
 
     /// Swaps the currently owned object with another
     void Swap(T *other) {
-        delete object;
+        deleteObject();
 
         object = other;
     }
 
 private:
     T *object;
+    void (*deleter)(T*);
+
+    void deleteObject() {
+        if (deleter != nullptr && object != nullptr) {
+            deleter(object);
+        } else {
+            delete object;
+        }
+    }
 };
 
+void customTestObjectDeleter(TestObject *object) {
+    std::cout << "Custom deleter" << std::endl;
+    delete object;
+}
+
 int main() {
     {
         std::cout << "Constructing first pointer" << std::endl;
         UniquePtr pointer = UniquePtr<TestObject>(new TestObject());
 
-        std::cout << "Calling test print via pointer" << std::endl;
-        pointer->testPrint();
+        std::cout << "Calling test print via pointer if it bools to true" << std::endl;
+        if (pointer) {
+            pointer->testPrint();
+        }
 
         std::cout << "Swapping for new object" << std::endl;
         pointer.Swap(new TestObject());
 
         std::cout << "Move constructing new pointer" << std::endl;
         UniquePtr pointer2 = UniquePtr<TestObject>(std::move(pointer));
+
+        std::cout << "Constructing pointer with custom deleter" << std::endl;
+        UniquePtr pointer3 = UniquePtr<TestObject>(new TestObject(), customTestObjectDeleter);
+
+        std::cout << "Resetting that pointer" << std::endl;
+        pointer3.Reset();
+
+        if (pointer3) {
+            std::cout << "This shouldn't happen!" << std::endl;
+        }
     }
 
     std::cout << std::endl << "All pointers should now be out of scope!" << std::endl;