Yet another std::unique_ptr implementation

Question

I know I haven't implemented many methods, and haven't specialized it for T[], but I just want to see if what I coded is good or bad.

template< class T >
class unique_ptr
{
private:
   T* ptr;
   
public:
   unique_ptr() noexcept : ptr(nullptr) {}
   ~unique_ptr() noexcept { release(); }
   explicit unique_ptr(T* data) noexcept;
   unique_ptr(const unique_ptr& rhs) = delete;
   unique_ptr& operator=(const unique_ptr& rhs) = delete;
   unique_ptr(unique_ptr&& rhs) noexcept;
   unique_ptr& operator=(unique_ptr&& rhs) noexcept
   {
       ptr = std::move(rhs.ptr);
   }
   T& operator*() { return *get(); }
   T* get() const noexcept;
   T* release() noexcept;
};

template< class T >
unique_ptr<T>::unique_ptr(T* data) noexcept : ptr(data) {}
template< class T >
unique_ptr<T>::unique_ptr(unique_ptr&& rhs) noexcept
{
   ptr = std::move(rhs.ptr);
}
template< class T >
T* unique_ptr<T>::get() const noexcept
{
   return ptr;
}

template < class T >
T* unique_ptr<T>::release() noexcept
{
   auto old_ptr = ptr;
   ptr = nullptr;
   return old_ptr;
}

template< typename T, typename ...Args >
unique_ptr<T> make_unique(Args&&... args)
{
   return unique_ptr<T>(new T(std::forward<Args>(args)...));
}

Answer 1

What's implemented so far looks mostly fine, except for the destructor. I would add operator->() as soon as possible, since we have operator*() - they come as a pair, and I don't think it's yet defaultable in the way that != can be synthesized when we provide ==.

Technically, we don't need = delete declarations of copy-construct/assign, since providing move-construct/assign inhibits those. But I like showing that explicitly - it can help the reader.

We could make the T* constructor also be the default constructor, by using a default argument:

   explicit unique_ptr(T* data = nullptr) noexcept;

operator* needs to be const (it can be noexcept, too).

release() can be simplified to just return std::exchange(ptr, nullptr);. It probably should make marked [[nodiscard]] since it transfers ownership of the pointer.

There's a bug in the destructor: we just call release(), abandoning the ownership of the pointer. But we actually need to free the owned object instead:

   ~unique_ptr() noexcept { delete ptr; }

(Remember that delete on a null pointer is safe, and does nothing).