How to create an operator-> for a class unique_ptr

Question

I have to implement a simple "unique_ptr" class supporting only a constructor, destructor, –>, *, and release(). And I did below.

However, it feels weird to write "up.operator->()" to get the pointer p. I would be more logical to write "up->p". But how do I do that? Thanks!

#include <iostream>
#include <stdexcept>

template <class T>
class unique_ptr
{
    T *p;

public:        
    unique_ptr(T *ptr)
        : p{ptr}
    {
    }
    ~unique_ptr() { delete p; }


    T *operator->() const { return p; } // returns a pointer
    T operator*() const { return *p; }
    T *release()
    {
        T *ptr = p;
        p = nullptr;
        return ptr;
    }
};

template <class T>
void print(const unique_ptr<T> &up, const std::string &s)
{
    std::cout << s << " up.operator->(): " << up.operator->() << '\n';
    std::cout << s << " up.operator*(): " << up.operator*() << '\n'; 
}

int main()
try
{
    int *ptr = new int(10);

    unique_ptr<int> up(ptr);
    print(up, "up: ");

}

catch (std::exception &e)
{
    std::cerr << "exception: " << e.what() << '\n';
    return 1;
}
catch (...)
{
    std::cerr << "exception\n";
    return 2;
}

Answer 1

However, it feels weird to write "up.operator->()" to get the pointer p.

It feels weird because the member access operator is not generally used to get a pointer to the object (although you can do it using the operator->() syntax, as you demonstrated). Member access operator is used to access members of the object. In your example, you have a unique pointer of int. int doesn't have a member, so it doesn't make sense to use the member access operator.

Here is an example of how to use it:

struct S {
    int member;
};

unique_ptr<S> up(new S{10});
int value_of_member = up->member;

would be more logical to write "up->p"

That wouldn't be logical unless p is a member of the pointed object.

How to create an operator-> for a class unique_ptr

Like you did in the example. As far as I can tell, there was no problem with how you create the operator, but rather how to use it.

---

P.S. Your unique pointer is copyable, movable and assignable, but those operations are horribly broken leading to undefined behaviour. See rule of 5.