Свой unique_ptr

#ifndef PTR_H
 
#define PTR_H
 
#include <stdexcept>
#include <utility>
 
// функциональный объект удаления
template <typename T> 
class Deleter
{
public:
    void operator () (T* t) const
    { delete t; }
};
 
// объявления
template <typename T, typename F = Deleter<T>> class MyUniquePtr;
 
template <typename T, typename F>
void swap (MyUniquePtr<T, F>&, MyUniquePtr<T, F>&);
 
// class MyUniquePtr
template <typename T, typename F>
class MyUniquePtr
{
private:
// данные
    T* ptr = nullptr;
 
// функции реализации
    void free ()
    { F(ptr); }
 
public:
// конструкторы и управление копированием
    MyUniquePtr () = default;
 
    MyUniquePtr (const MyUniquePtr&) = delete;
 
    MyUniquePtr& operator = (const MyUniquePtr&) = delete;
 
    MyUniquePtr (T* t): ptr(t)
    {  }
 
    MyUniquePtr& operator = (T* t)
    {
        free();
        ptr = t;
        return *this;
    }
 
    MyUniquePtr (MyUniquePtr&& mp) noexcept: ptr(mp.ptr)
    { mp.ptr = nullptr; }
 
    MyUniquePtr& operator = (MyUniquePtr&&) noexcept;
 
    ~MyUniquePtr ()
    { free(); }
 
// функции интерфейса
    explicit operator bool () const
    { return ptr ? true : false; }
 
    T& operator * () const
    {
        if (!ptr)
            throw std::invalid_argument("dereference on nullptr");
        return *ptr;
    }
 
    T* operator -> () const
    { return &(this -> operator *()); }
 
    T* get ()
    { return ptr; }
 
    void swap (MyUniquePtr& mp)
    { swap(*this, mp); }
 
    T* release ()
    {
        T* copy = ptr;
        ptr = nullptr;
        return copy;
    }
 
    void reset ()
    {
        free();
        ptr = nullptr;
    }
 
    void reset (T* t)
    {
        free();
        ptr = t;
    }
 
    friend void swap (MyUniquePtr<T, F>&, MyUniquePtr<T, F>&);
};
 
// определение конструкторов / функций управления копированием
template <typename T, typename F>
MyUniquePtr<T, F>& MyUniquePtr<T, F>::operator = (MyUniquePtr&& mp) noexcept
{
    if (this != &mp)
    {
        free();
        ptr = mp;
        mp.ptr = nullptr;
    }
    return *this;
}
 
// определение глобальных функций
template <typename T, typename F>
void swap (MyUniquePtr<T, F>& mp1, MyUniquePtr<T, F>& mp2)
{
    using std::swap;
    swap(mp1.ptr, mp2.ptr);
}
 
 
#endif